440 lines
16 KiB
TypeScript
440 lines
16 KiB
TypeScript
import { Buffer } from 'node:buffer';
|
|
import type { IncomingMessage, ServerResponse } from 'node:http';
|
|
import type { HostApiContext } from '../context';
|
|
import { parseJsonBody, sendJson } from '../route-utils';
|
|
import { deleteApiKey, getApiKey, storeApiKey } from '../../utils/secure-storage';
|
|
import { proxyAwareFetch } from '../../utils/proxy-fetch';
|
|
import {
|
|
readBundledMeowaApiKey,
|
|
readEmbeddedMeowaApiKey,
|
|
} from '../../services/meowa-game-assets-release-credential';
|
|
|
|
export const MEOWA_GAME_ASSETS_ACCOUNT_ID = 'meowa-game-assets';
|
|
export const MEOWA_GAME_ASSETS_API_BASE_URL = 'https://api.meowa.ai';
|
|
export const MEOWA_GAME_ASSETS_SKILL_VERSION = '2026.06.19.1';
|
|
|
|
const MAX_REFERENCE_FILE_BYTES = 8 * 1024 * 1024;
|
|
const MAX_REFERENCE_BYTES = 16 * 1024 * 1024;
|
|
const MAX_DOWNLOAD_BYTES = 32 * 1024 * 1024;
|
|
const SUPPORTED_KINDS = ['pixel', 'hd'] as const;
|
|
|
|
type MeowaGameAssetKind = typeof SUPPORTED_KINDS[number];
|
|
type JsonRecord = Record<string, unknown>;
|
|
|
|
function asRecord(value: unknown): JsonRecord | null {
|
|
return value && typeof value === 'object' && !Array.isArray(value)
|
|
? value as JsonRecord
|
|
: null;
|
|
}
|
|
|
|
function readRequiredString(value: unknown, field: string, maxLength = 2_000): string {
|
|
if (typeof value !== 'string' || !value.trim()) {
|
|
throw new Error(`Missing ${field}`);
|
|
}
|
|
const normalized = value.trim();
|
|
if (normalized.length > maxLength) {
|
|
throw new Error(`${field} is too long`);
|
|
}
|
|
return normalized;
|
|
}
|
|
|
|
function readOptionalString(value: unknown, maxLength = 2_000): string | undefined {
|
|
if (typeof value !== 'string' || !value.trim()) return undefined;
|
|
const normalized = value.trim();
|
|
if (normalized.length > maxLength) throw new Error('Optional field is too long');
|
|
return normalized;
|
|
}
|
|
|
|
function readKind(value: unknown): MeowaGameAssetKind {
|
|
if (value === 'pixel' || value === 'hd') return value;
|
|
throw new Error('kind must be pixel or hd');
|
|
}
|
|
|
|
function endpoint(kind: MeowaGameAssetKind, suffix: string): string {
|
|
return `${MEOWA_GAME_ASSETS_API_BASE_URL}/api/${kind}-gen${suffix}`;
|
|
}
|
|
|
|
function upstreamHeaders(apiKey?: string): Record<string, string> {
|
|
return {
|
|
Accept: 'application/json',
|
|
...(apiKey ? { Authorization: `Bearer ${apiKey}` } : {}),
|
|
};
|
|
}
|
|
|
|
async function readResponsePayload(response: Response): Promise<unknown> {
|
|
const text = await response.text();
|
|
if (!text.trim()) return null;
|
|
try {
|
|
return JSON.parse(text) as unknown;
|
|
} catch {
|
|
return text.slice(0, 500);
|
|
}
|
|
}
|
|
|
|
function messageFromPayload(payload: unknown, fallback: string): string {
|
|
const record = asRecord(payload);
|
|
if (record) {
|
|
for (const field of ['message', 'error', 'detail', 'msg']) {
|
|
const value = record[field];
|
|
if (typeof value === 'string' && value.trim()) return value.trim().slice(0, 500);
|
|
}
|
|
}
|
|
if (typeof payload === 'string' && payload.trim()) return payload.trim().slice(0, 500);
|
|
return fallback;
|
|
}
|
|
|
|
async function sendUpstreamError(
|
|
res: ServerResponse,
|
|
response: Response,
|
|
operation: string,
|
|
): Promise<void> {
|
|
const payload = await readResponsePayload(response);
|
|
const status = response.status >= 400 && response.status < 500 ? response.status : 502;
|
|
sendJson(res, status, {
|
|
success: false,
|
|
error: `${operation}: ${messageFromPayload(payload, `upstream status ${response.status}`)}`,
|
|
});
|
|
}
|
|
|
|
type MeowaCredentialSource = 'secure-store' | 'environment' | 'release-bundle' | 'embedded' | 'none';
|
|
|
|
async function resolveCredential(): Promise<{ apiKey: string | null; source: MeowaCredentialSource }> {
|
|
const stored = await getApiKey(MEOWA_GAME_ASSETS_ACCOUNT_ID);
|
|
if (stored?.trim()) return { apiKey: stored.trim(), source: 'secure-store' };
|
|
|
|
const environment = process.env.MEOWART_API_KEY?.trim();
|
|
if (environment) {
|
|
await storeApiKey(MEOWA_GAME_ASSETS_ACCOUNT_ID, environment);
|
|
return { apiKey: environment, source: 'environment' };
|
|
}
|
|
|
|
const bundled = await readBundledMeowaApiKey();
|
|
if (bundled) {
|
|
await storeApiKey(MEOWA_GAME_ASSETS_ACCOUNT_ID, bundled);
|
|
return { apiKey: bundled, source: 'release-bundle' };
|
|
}
|
|
|
|
const embedded = readEmbeddedMeowaApiKey();
|
|
if (embedded) {
|
|
await storeApiKey(MEOWA_GAME_ASSETS_ACCOUNT_ID, embedded);
|
|
return { apiKey: embedded, source: 'embedded' };
|
|
}
|
|
|
|
return { apiKey: null, source: 'none' };
|
|
}
|
|
|
|
export async function initializeMeowaGameAssetsCredential(): Promise<Awaited<ReturnType<typeof resolveCredential>>> {
|
|
return resolveCredential();
|
|
}
|
|
|
|
async function requireCredential(res: ServerResponse): Promise<string | null> {
|
|
const credential = await resolveCredential();
|
|
if (credential.apiKey) return credential.apiKey;
|
|
sendJson(res, 409, {
|
|
success: false,
|
|
error: 'Meowa 素材服务尚未配置，请联系管理员。',
|
|
code: 'MEOWA_API_KEY_MISSING',
|
|
});
|
|
return null;
|
|
}
|
|
|
|
function readTemplateConfig(value: unknown): string {
|
|
if (value === undefined || value === null || value === '') return '{}';
|
|
if (typeof value === 'string') {
|
|
try {
|
|
const parsed = JSON.parse(value) as unknown;
|
|
if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) throw new Error('templateConfig must be an object');
|
|
return JSON.stringify(parsed);
|
|
} catch (error) {
|
|
throw new Error(`Invalid templateConfig: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
|
|
}
|
|
}
|
|
if (!asRecord(value)) throw new Error('templateConfig must be an object');
|
|
return JSON.stringify(value);
|
|
}
|
|
|
|
function readBoolean(value: unknown, fallback: boolean): boolean {
|
|
return typeof value === 'boolean' ? value : fallback;
|
|
}
|
|
|
|
function readNumber(value: unknown, fallback: number): number {
|
|
return typeof value === 'number' && Number.isFinite(value) ? value : fallback;
|
|
}
|
|
|
|
function readReferenceFiles(value: unknown): Array<{ name: string; mimeType: string; bytes: Buffer }> {
|
|
if (value === undefined) return [];
|
|
if (!Array.isArray(value)) throw new Error('referenceFiles must be an array');
|
|
|
|
let totalBytes = 0;
|
|
return value.map((item, index) => {
|
|
const record = asRecord(item);
|
|
if (!record) throw new Error(`referenceFiles[${index}] must be an object`);
|
|
const encoded = readRequiredString(record.dataBase64, `referenceFiles[${index}].dataBase64`, MAX_REFERENCE_FILE_BYTES * 2);
|
|
if (!/^[A-Za-z0-9+/]+={0,2}$/.test(encoded)) throw new Error(`referenceFiles[${index}] has invalid base64`);
|
|
const bytes = Buffer.from(encoded, 'base64');
|
|
if (bytes.length > MAX_REFERENCE_FILE_BYTES) throw new Error(`referenceFiles[${index}] is too large`);
|
|
totalBytes += bytes.length;
|
|
if (totalBytes > MAX_REFERENCE_BYTES) throw new Error('referenceFiles are too large');
|
|
return {
|
|
name: readOptionalString(record.name, 160) ?? `reference-${index + 1}.png`,
|
|
mimeType: readOptionalString(record.mimeType, 120) ?? 'image/png',
|
|
bytes,
|
|
};
|
|
});
|
|
}
|
|
|
|
async function buildGenerationForm(kind: MeowaGameAssetKind, body: JsonRecord): Promise<FormData> {
|
|
const form = new FormData();
|
|
form.set('template_name', readRequiredString(body.templateName, 'templateName', 200));
|
|
form.set('template_config', readTemplateConfig(body.templateConfig));
|
|
form.set('requirement', readRequiredString(body.requirement, 'requirement', 12_000));
|
|
form.set('aspect_ratio', readOptionalString(body.aspectRatio, 40) ?? '1:1');
|
|
form.set('temperature', String(readNumber(body.temperature, 0)));
|
|
form.set('include_base64', readBoolean(body.includeBase64, false) ? 'true' : 'false');
|
|
|
|
const optionalFields: Array<[string, unknown, number]> = [
|
|
['job_name', body.jobName, 200],
|
|
['model_name', body.modelName, 200],
|
|
['resolution', body.resolution, 40],
|
|
['hd_remove_bg_mode', body.hdRemoveBgMode, 80],
|
|
['project_id', body.projectId, 200],
|
|
['thread_id', body.threadId, 200],
|
|
];
|
|
for (const [field, value, maxLength] of optionalFields) {
|
|
const normalized = readOptionalString(value, maxLength);
|
|
if (normalized) form.set(field, normalized);
|
|
}
|
|
|
|
const references = readReferenceFiles(body.referenceFiles);
|
|
references.forEach((reference, index) => {
|
|
const blob = new Blob([reference.bytes], { type: reference.mimeType });
|
|
form.append(index === 0 ? 'reference_file' : 'reference_files', blob, reference.name);
|
|
});
|
|
|
|
// Keep this explicit so adding a third generation kind cannot silently send
|
|
// HD-only fields to a different Meowa endpoint.
|
|
if (kind === 'pixel') {
|
|
form.delete('hd_remove_bg_mode');
|
|
}
|
|
return form;
|
|
}
|
|
|
|
async function forwardJson(
|
|
res: ServerResponse,
|
|
url: string,
|
|
init: RequestInit,
|
|
operation: string,
|
|
): Promise<void> {
|
|
const response = await proxyAwareFetch(url, init);
|
|
if (!response.ok) {
|
|
await sendUpstreamError(res, response, operation);
|
|
return;
|
|
}
|
|
const payload = await readResponsePayload(response);
|
|
sendJson(res, response.status, payload);
|
|
}
|
|
|
|
function parseOutputIndex(value: string | null): number | null {
|
|
if (value === null || value.trim() === '') return null;
|
|
const parsed = Number(value);
|
|
if (!Number.isInteger(parsed) || parsed < 0 || parsed > 99) throw new Error('outputIndex must be an integer from 0 to 99');
|
|
return parsed;
|
|
}
|
|
|
|
function responseFileName(response: Response, jobId: string): string {
|
|
const disposition = response.headers.get('content-disposition') ?? '';
|
|
const utf8Match = disposition.match(/filename\*=UTF-8''([^;]+)/i);
|
|
if (utf8Match?.[1]) return decodeURIComponent(utf8Match[1]).replace(/[\\/\0]/g, '_');
|
|
const match = disposition.match(/filename="?([^";]+)"?/i);
|
|
if (match?.[1]) return match[1].replace(/[\\/\0]/g, '_');
|
|
const mime = response.headers.get('content-type')?.toLowerCase() ?? '';
|
|
const suffix = mime.includes('zip') ? '.zip' : mime.includes('jpeg') ? '.jpg' : mime.includes('webp') ? '.webp' : '.png';
|
|
return `${jobId}${suffix}`;
|
|
}
|
|
|
|
async function handleDownload(
|
|
res: ServerResponse,
|
|
url: URL,
|
|
kind: MeowaGameAssetKind,
|
|
apiKey: string,
|
|
): Promise<void> {
|
|
const jobId = readRequiredString(url.searchParams.get('id'), 'id', 200);
|
|
const outputIndex = parseOutputIndex(url.searchParams.get('outputIndex'));
|
|
const suffix = outputIndex === null
|
|
? `/jobs/${encodeURIComponent(jobId)}/download`
|
|
: `/jobs/${encodeURIComponent(jobId)}/outputs/${outputIndex}/download`;
|
|
const response = await proxyAwareFetch(endpoint(kind, suffix), {
|
|
method: 'GET',
|
|
headers: upstreamHeaders(apiKey),
|
|
});
|
|
if (!response.ok) {
|
|
await sendUpstreamError(res, response, 'Meowa 素材下载失败');
|
|
return;
|
|
}
|
|
|
|
const bytes = Buffer.from(await response.arrayBuffer());
|
|
if (bytes.length > MAX_DOWNLOAD_BYTES) {
|
|
sendJson(res, 413, { success: false, error: 'Meowa 输出文件超过本地代理大小限制' });
|
|
return;
|
|
}
|
|
sendJson(res, 200, {
|
|
success: true,
|
|
fileName: responseFileName(response, jobId),
|
|
mimeType: response.headers.get('content-type') || 'application/octet-stream',
|
|
bytes: bytes.length,
|
|
dataBase64: bytes.toString('base64'),
|
|
});
|
|
}
|
|
|
|
export async function handleMeowaGameAssetsRoutes(
|
|
req: IncomingMessage,
|
|
res: ServerResponse,
|
|
url: URL,
|
|
_ctx: HostApiContext,
|
|
): Promise<boolean> {
|
|
if (url.pathname === '/api/meowa/game-assets/config' && req.method === 'GET') {
|
|
const credential = await resolveCredential();
|
|
sendJson(res, 200, {
|
|
success: true,
|
|
configured: Boolean(credential.apiKey),
|
|
credentialSource: credential.source,
|
|
provider: 'meowa',
|
|
apiBaseUrl: MEOWA_GAME_ASSETS_API_BASE_URL,
|
|
skillVersion: MEOWA_GAME_ASSETS_SKILL_VERSION,
|
|
supportedKinds: [...SUPPORTED_KINDS],
|
|
});
|
|
return true;
|
|
}
|
|
|
|
if (url.pathname === '/api/meowa/game-assets/config' && req.method === 'PUT') {
|
|
try {
|
|
const body = await parseJsonBody<JsonRecord>(req);
|
|
const apiKey = readRequiredString(body.apiKey, 'apiKey', 512);
|
|
const stored = await storeApiKey(MEOWA_GAME_ASSETS_ACCOUNT_ID, apiKey);
|
|
if (!stored) throw new Error('安全存储写入失败');
|
|
sendJson(res, 200, {
|
|
success: true,
|
|
configured: true,
|
|
credentialSource: 'secure-store',
|
|
});
|
|
} catch (error) {
|
|
sendJson(res, 400, { success: false, error: error instanceof Error ? error.message : String(error) });
|
|
}
|
|
return true;
|
|
}
|
|
|
|
if (url.pathname === '/api/meowa/game-assets/config' && req.method === 'DELETE') {
|
|
const deleted = await deleteApiKey(MEOWA_GAME_ASSETS_ACCOUNT_ID);
|
|
const credential = deleted ? await resolveCredential() : null;
|
|
sendJson(res, deleted ? 200 : 500, {
|
|
success: deleted,
|
|
configured: Boolean(credential?.apiKey),
|
|
credentialSource: credential?.source ?? 'none',
|
|
});
|
|
return true;
|
|
}
|
|
|
|
if (url.pathname === '/api/meowa/game-assets/skill-doc' && req.method === 'GET') {
|
|
try {
|
|
const remoteUrl = new URL(`${MEOWA_GAME_ASSETS_API_BASE_URL}/api/agent-skills/game-assets/doc`);
|
|
const task = url.searchParams.get('task');
|
|
const topic = url.searchParams.get('topic');
|
|
if (task) remoteUrl.searchParams.set('task', task.slice(0, 2_000));
|
|
if (topic) remoteUrl.searchParams.set('topic', topic.slice(0, 200));
|
|
await forwardJson(res, remoteUrl.toString(), { method: 'GET', headers: upstreamHeaders() }, 'Meowa Skill 文档获取失败');
|
|
} catch (error) {
|
|
sendJson(res, 502, { success: false, error: error instanceof Error ? error.message : String(error) });
|
|
}
|
|
return true;
|
|
}
|
|
|
|
if (url.pathname === '/api/meowa/game-assets/template-info' && req.method === 'GET') {
|
|
try {
|
|
const kind = readKind(url.searchParams.get('kind'));
|
|
const apiKey = await requireCredential(res);
|
|
if (!apiKey) return true;
|
|
await forwardJson(
|
|
res,
|
|
endpoint(kind, '/template-info'),
|
|
{ method: 'GET', headers: upstreamHeaders(apiKey) },
|
|
`Meowa ${kind} 模版信息获取失败`,
|
|
);
|
|
} catch (error) {
|
|
sendJson(res, 400, { success: false, error: error instanceof Error ? error.message : String(error) });
|
|
}
|
|
return true;
|
|
}
|
|
|
|
if (url.pathname === '/api/meowa/game-assets/generate' && req.method === 'POST') {
|
|
try {
|
|
const apiKey = await requireCredential(res);
|
|
if (!apiKey) return true;
|
|
const body = await parseJsonBody<JsonRecord>(req);
|
|
const kind = readKind(body.kind);
|
|
const form = await buildGenerationForm(kind, body);
|
|
|
|
const response = await proxyAwareFetch(endpoint(kind, ''), {
|
|
method: 'POST',
|
|
headers: upstreamHeaders(apiKey),
|
|
body: form,
|
|
});
|
|
if (!response.ok) {
|
|
await sendUpstreamError(res, response, `Meowa ${kind} 素材生成提交失败`);
|
|
return true;
|
|
}
|
|
sendJson(res, response.status, await readResponsePayload(response));
|
|
} catch (error) {
|
|
sendJson(res, 400, { success: false, error: error instanceof Error ? error.message : String(error) });
|
|
}
|
|
return true;
|
|
}
|
|
|
|
if (url.pathname === '/api/meowa/game-assets/jobs' && req.method === 'GET') {
|
|
try {
|
|
const kind = readKind(url.searchParams.get('kind'));
|
|
const apiKey = await requireCredential(res);
|
|
if (!apiKey) return true;
|
|
const jobId = readRequiredString(url.searchParams.get('id'), 'id', 200);
|
|
await forwardJson(
|
|
res,
|
|
endpoint(kind, `/jobs?id=${encodeURIComponent(jobId)}`),
|
|
{ method: 'GET', headers: upstreamHeaders(apiKey) },
|
|
`Meowa ${kind} 任务查询失败`,
|
|
);
|
|
} catch (error) {
|
|
sendJson(res, 400, { success: false, error: error instanceof Error ? error.message : String(error) });
|
|
}
|
|
return true;
|
|
}
|
|
|
|
if (url.pathname === '/api/meowa/game-assets/download' && req.method === 'GET') {
|
|
try {
|
|
const kind = readKind(url.searchParams.get('kind'));
|
|
const apiKey = await requireCredential(res);
|
|
if (!apiKey) return true;
|
|
await handleDownload(res, url, kind, apiKey);
|
|
} catch (error) {
|
|
sendJson(res, 400, { success: false, error: error instanceof Error ? error.message : String(error) });
|
|
}
|
|
return true;
|
|
}
|
|
|
|
if (url.pathname === '/api/meowa/game-assets/credits' && req.method === 'GET') {
|
|
try {
|
|
const apiKey = await requireCredential(res);
|
|
if (!apiKey) return true;
|
|
await forwardJson(
|
|
res,
|
|
`${MEOWA_GAME_ASSETS_API_BASE_URL}/api/credits/balance`,
|
|
{ method: 'GET', headers: upstreamHeaders(apiKey) },
|
|
'Meowa 额度查询失败',
|
|
);
|
|
} catch (error) {
|
|
sendJson(res, 400, { success: false, error: error instanceof Error ? error.message : String(error) });
|
|
}
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|