kdletters
071faa482c
纳入 AGC Cargo workspace 的统一 rustfmt 检查与格式化入口 完成项目 TypeScript/Prettier 与 Rust 全量格式化 修复 Pingora expected executable 门禁的空白敏感误报 同步开发运维文档与 AGC skill pack 格式化忽略规则
433 lines
12 KiB
JavaScript
433 lines
12 KiB
JavaScript
import { Buffer } from 'node:buffer';
|
|
import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
|
|
import path from 'node:path';
|
|
import { fileURLToPath } from 'node:url';
|
|
|
|
const __filename = fileURLToPath(import.meta.url);
|
|
const __dirname = path.dirname(__filename);
|
|
const skillRoot = path.resolve(__dirname, '..');
|
|
const repoRoot = path.resolve(skillRoot, '..', '..', '..');
|
|
const promptsPath = path.join(
|
|
skillRoot,
|
|
'assets',
|
|
'puzzle-template-prompts.json',
|
|
);
|
|
const defaultOutDir = path.join(
|
|
repoRoot,
|
|
'public',
|
|
'puzzle-creation-templates',
|
|
);
|
|
const defaultTimeoutMs = 1000000;
|
|
const preferredImageModel = 'gpt-image-2';
|
|
const fallbackImageModel = 'gpt-image-2-c';
|
|
|
|
const args = new Map();
|
|
for (let index = 2; index < process.argv.length; index += 1) {
|
|
const raw = process.argv[index];
|
|
if (raw.startsWith('--')) {
|
|
const next = process.argv[index + 1];
|
|
if (next && !next.startsWith('--')) {
|
|
args.set(raw, next);
|
|
index += 1;
|
|
} else {
|
|
args.set(raw, true);
|
|
}
|
|
}
|
|
}
|
|
|
|
function readDotenv(fileName) {
|
|
const filePath = path.join(repoRoot, fileName);
|
|
if (!existsSync(filePath)) {
|
|
return {};
|
|
}
|
|
|
|
const values = {};
|
|
for (const line of readFileSync(filePath, 'utf8').split(/\r?\n/u)) {
|
|
const trimmed = line.trim();
|
|
if (!trimmed || trimmed.startsWith('#')) {
|
|
continue;
|
|
}
|
|
const match = /^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/u.exec(trimmed);
|
|
if (!match) {
|
|
continue;
|
|
}
|
|
let value = match[2].trim();
|
|
if (
|
|
(value.startsWith('"') && value.endsWith('"')) ||
|
|
(value.startsWith("'") && value.endsWith("'"))
|
|
) {
|
|
value = value.slice(1, -1);
|
|
}
|
|
values[match[1]] = value;
|
|
}
|
|
return values;
|
|
}
|
|
|
|
function resolveEnv() {
|
|
const loaded = {
|
|
...readDotenv('.env.example'),
|
|
...readDotenv('.env.local'),
|
|
...readDotenv('.env.secrets.local'),
|
|
...process.env,
|
|
};
|
|
return {
|
|
baseUrl: String(loaded.VECTOR_ENGINE_BASE_URL || '')
|
|
.trim()
|
|
.replace(/\/+$/u, ''),
|
|
apiKey: String(loaded.VECTOR_ENGINE_API_KEY || '').trim(),
|
|
timeoutMs: Number.parseInt(
|
|
String(loaded.VECTOR_ENGINE_IMAGE_REQUEST_TIMEOUT_MS || defaultTimeoutMs),
|
|
10,
|
|
),
|
|
};
|
|
}
|
|
|
|
function buildVectorEngineImagesGenerationUrl(baseUrl) {
|
|
return baseUrl.endsWith('/v1')
|
|
? `${baseUrl}/images/generations`
|
|
: `${baseUrl}/v1/images/generations`;
|
|
}
|
|
|
|
function buildPrompt(template) {
|
|
return [
|
|
'请生成一张高清 1:1 方形插画，用作拼图创作模板样例图。',
|
|
`画面主体：${template.prompt}`,
|
|
'要求：主体清晰集中，前中后景层次明确，边角有可辨识细节，适合切成 3x3 到 7x7 拼图。',
|
|
'避免：文字、水印、边框、按钮、UI 元素、教程标注、低清晰度、过度模糊、杂乱构图。',
|
|
].join('');
|
|
}
|
|
|
|
function collectStringsByKey(value, targetKey, output) {
|
|
if (Array.isArray(value)) {
|
|
value.forEach((entry) => collectStringsByKey(entry, targetKey, output));
|
|
return;
|
|
}
|
|
if (!value || typeof value !== 'object') {
|
|
return;
|
|
}
|
|
|
|
for (const [key, nested] of Object.entries(value)) {
|
|
if (key === targetKey) {
|
|
if (typeof nested === 'string' && nested.trim()) {
|
|
output.push(nested.trim());
|
|
}
|
|
if (Array.isArray(nested)) {
|
|
nested.forEach((entry) => {
|
|
if (typeof entry === 'string' && entry.trim()) {
|
|
output.push(entry.trim());
|
|
}
|
|
});
|
|
}
|
|
}
|
|
collectStringsByKey(nested, targetKey, output);
|
|
}
|
|
}
|
|
|
|
function extractImageUrls(payload) {
|
|
const urls = [];
|
|
collectStringsByKey(payload, 'url', urls);
|
|
collectStringsByKey(payload, 'image', urls);
|
|
collectStringsByKey(payload, 'image_url', urls);
|
|
return [...new Set(urls)].filter((url) => /^https?:\/\//u.test(url));
|
|
}
|
|
|
|
function extractBase64Images(payload) {
|
|
const values = [];
|
|
collectStringsByKey(payload, 'b64_json', values);
|
|
return values;
|
|
}
|
|
|
|
function decodeStrictBase64Image(raw) {
|
|
const normalized = String(raw || '').trim();
|
|
if (
|
|
!normalized ||
|
|
normalized.length % 4 !== 0 ||
|
|
!/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/u.test(
|
|
normalized,
|
|
)
|
|
) {
|
|
return null;
|
|
}
|
|
const bytes = Buffer.from(normalized, 'base64');
|
|
return bytes.length > 0 &&
|
|
bytes.toString('base64') === normalized &&
|
|
inferExtensionFromBytes(bytes)
|
|
? bytes
|
|
: null;
|
|
}
|
|
|
|
function inferExtensionFromContentType(contentType) {
|
|
const normalized = contentType.split(';')[0]?.trim().toLowerCase();
|
|
if (normalized === 'image/png') {
|
|
return 'png';
|
|
}
|
|
if (normalized === 'image/webp') {
|
|
return 'webp';
|
|
}
|
|
if (normalized === 'image/gif') {
|
|
return 'gif';
|
|
}
|
|
return 'jpg';
|
|
}
|
|
|
|
function inferExtensionFromBytes(bytes) {
|
|
if (bytes.subarray(0, 8).equals(Buffer.from('\x89PNG\r\n\x1A\n', 'binary'))) {
|
|
return 'png';
|
|
}
|
|
if (bytes.subarray(0, 3).equals(Buffer.from([0xff, 0xd8, 0xff]))) {
|
|
return 'jpg';
|
|
}
|
|
if (
|
|
bytes.subarray(0, 4).toString('ascii') === 'RIFF' &&
|
|
bytes.subarray(8, 12).toString('ascii') === 'WEBP'
|
|
) {
|
|
return 'webp';
|
|
}
|
|
if (
|
|
bytes.subarray(0, 6).toString('ascii') === 'GIF87a' ||
|
|
bytes.subarray(0, 6).toString('ascii') === 'GIF89a'
|
|
) {
|
|
return 'gif';
|
|
}
|
|
return null;
|
|
}
|
|
|
|
async function fetchJson(url, options, timeoutMs) {
|
|
const abortController = new AbortController();
|
|
const timer = setTimeout(() => abortController.abort(), timeoutMs);
|
|
try {
|
|
const response = await fetch(url, {
|
|
...options,
|
|
signal: abortController.signal,
|
|
});
|
|
const text = await response.text();
|
|
if (!response.ok) {
|
|
const error = new Error(
|
|
`VectorEngine ${response.status}: ${text.slice(0, 600)}`,
|
|
);
|
|
error.vectorEngineStatus = response.status;
|
|
error.vectorEngineBody = text;
|
|
throw error;
|
|
}
|
|
try {
|
|
return JSON.parse(text);
|
|
} catch (error) {
|
|
error.vectorEngineResponseParse = true;
|
|
error.vectorEngineBody = text;
|
|
throw error;
|
|
}
|
|
} catch (error) {
|
|
if (error?.name === 'AbortError') {
|
|
throw new Error(`VectorEngine request timed out after ${timeoutMs}ms`);
|
|
}
|
|
throw error;
|
|
} finally {
|
|
clearTimeout(timer);
|
|
}
|
|
}
|
|
|
|
function shouldFallbackImageModel(error) {
|
|
const raw =
|
|
`${error?.message || ''}\n${error?.vectorEngineBody || ''}`.toLowerCase();
|
|
if (error?.vectorEngineResponseParse) {
|
|
return !containsContentRejection(raw);
|
|
}
|
|
const status = Number(error?.vectorEngineStatus || 0);
|
|
if (status === 408 || status >= 500) {
|
|
return true;
|
|
}
|
|
if (status === 429) {
|
|
return !containsContentRejection(raw);
|
|
}
|
|
const mentionsImageModel =
|
|
raw.includes('model') ||
|
|
raw.includes('模型') ||
|
|
raw.includes(preferredImageModel) ||
|
|
raw.includes(fallbackImageModel);
|
|
return (
|
|
[400, 404, 422].includes(status) &&
|
|
mentionsImageModel &&
|
|
/(not found|not supported|unsupported|unavailable|does not exist|invalid model|unknown model|不存在|不支持|不可用|未开通)/u.test(
|
|
raw,
|
|
)
|
|
);
|
|
}
|
|
|
|
function containsContentRejection(raw) {
|
|
return /(invalid_prompt|safety|content[_ ]policy|moderation|prompt rejected|content rejected|prompt refusal|content refusal|rejected by safety|rejected by moderation|敏感|违规|安全策略|内容审核|提示词拒绝|内容拒绝)/u.test(
|
|
raw,
|
|
);
|
|
}
|
|
|
|
async function requestImagePayload(env, template) {
|
|
for (const model of [preferredImageModel, fallbackImageModel]) {
|
|
const requestBody = {
|
|
model,
|
|
prompt: buildPrompt(template),
|
|
n: 1,
|
|
size: '1024x1024',
|
|
};
|
|
try {
|
|
const payload = await fetchJson(
|
|
buildVectorEngineImagesGenerationUrl(env.baseUrl),
|
|
{
|
|
method: 'POST',
|
|
headers: {
|
|
Authorization: `Bearer ${env.apiKey}`,
|
|
Accept: 'application/json',
|
|
'Content-Type': 'application/json',
|
|
},
|
|
body: JSON.stringify(requestBody),
|
|
},
|
|
env.timeoutMs,
|
|
);
|
|
const base64Image = decodeStrictBase64Image(
|
|
extractBase64Images(payload)[0],
|
|
);
|
|
if (extractImageUrls(payload)[0] || base64Image) {
|
|
return payload;
|
|
}
|
|
const error = new Error(
|
|
`VectorEngine returned no image for ${template.id}`,
|
|
);
|
|
error.vectorEngineResponseParse = true;
|
|
error.vectorEngineBody = JSON.stringify(payload).slice(0, 600);
|
|
throw error;
|
|
} catch (error) {
|
|
if (model !== preferredImageModel || !shouldFallbackImageModel(error)) {
|
|
throw error;
|
|
}
|
|
console.warn(
|
|
`VectorEngine ${preferredImageModel} failed, retrying with ${fallbackImageModel}: ${error.message}`,
|
|
);
|
|
}
|
|
}
|
|
throw new Error(`VectorEngine returned no image for ${template.id}`);
|
|
}
|
|
|
|
async function downloadUrl(url, timeoutMs) {
|
|
const abortController = new AbortController();
|
|
const timer = setTimeout(() => abortController.abort(), timeoutMs);
|
|
try {
|
|
const response = await fetch(url, { signal: abortController.signal });
|
|
if (!response.ok) {
|
|
throw new Error(`download ${response.status}`);
|
|
}
|
|
const bytes = Buffer.from(await response.arrayBuffer());
|
|
return {
|
|
bytes,
|
|
extension: inferExtensionFromContentType(
|
|
response.headers.get('content-type') || 'image/jpeg',
|
|
),
|
|
};
|
|
} catch (error) {
|
|
if (error?.name === 'AbortError') {
|
|
throw new Error(
|
|
`Generated image download timed out after ${timeoutMs}ms`,
|
|
);
|
|
}
|
|
throw error;
|
|
} finally {
|
|
clearTimeout(timer);
|
|
}
|
|
}
|
|
|
|
async function generateOne(env, template, outDir) {
|
|
const payload = await requestImagePayload(env, template);
|
|
|
|
const urls = extractImageUrls(payload);
|
|
const b64Images = extractBase64Images(payload);
|
|
|
|
let image;
|
|
if (urls[0]) {
|
|
image = await downloadUrl(urls[0], env.timeoutMs);
|
|
} else if (b64Images[0]) {
|
|
const bytes = decodeStrictBase64Image(b64Images[0]);
|
|
if (!bytes) {
|
|
throw new Error(
|
|
`VectorEngine returned invalid base64 image for ${template.id}`,
|
|
);
|
|
}
|
|
image = {
|
|
bytes,
|
|
extension: inferExtensionFromBytes(bytes),
|
|
};
|
|
} else {
|
|
throw new Error(`VectorEngine returned no image for ${template.id}`);
|
|
}
|
|
|
|
mkdirSync(outDir, { recursive: true });
|
|
const outputPath = path.join(outDir, `${template.id}.${image.extension}`);
|
|
writeFileSync(outputPath, image.bytes);
|
|
return outputPath;
|
|
}
|
|
|
|
const dryRun = args.has('--dry-run') || !args.has('--live');
|
|
const outDir = path.resolve(String(args.get('--out-dir') || defaultOutDir));
|
|
const limit = Number.parseInt(String(args.get('--limit') || '0'), 10);
|
|
const onlyIds = String(args.get('--only') || '')
|
|
.split(',')
|
|
.map((value) => value.trim())
|
|
.filter(Boolean);
|
|
const templates = JSON.parse(readFileSync(promptsPath, 'utf8')).filter(
|
|
(template) => !onlyIds.length || onlyIds.includes(template.id),
|
|
);
|
|
const selectedTemplates = limit > 0 ? templates.slice(0, limit) : templates;
|
|
|
|
if (dryRun) {
|
|
console.log(
|
|
JSON.stringify(
|
|
{
|
|
mode: 'dry-run',
|
|
outDir,
|
|
count: selectedTemplates.length,
|
|
requests: selectedTemplates.map((template) => ({
|
|
id: template.id,
|
|
title: template.title,
|
|
fallbackModel: fallbackImageModel,
|
|
body: {
|
|
model: preferredImageModel,
|
|
prompt: buildPrompt(template),
|
|
n: 1,
|
|
size: '1024x1024',
|
|
},
|
|
})),
|
|
},
|
|
null,
|
|
2,
|
|
),
|
|
);
|
|
process.exit(0);
|
|
}
|
|
|
|
const env = resolveEnv();
|
|
if (!env.baseUrl || !env.apiKey) {
|
|
console.error(
|
|
JSON.stringify({
|
|
ok: false,
|
|
error: 'Missing VECTOR_ENGINE_BASE_URL or VECTOR_ENGINE_API_KEY',
|
|
hasBaseUrl: Boolean(env.baseUrl),
|
|
hasApiKey: Boolean(env.apiKey),
|
|
}),
|
|
);
|
|
process.exit(1);
|
|
}
|
|
|
|
const generated = [];
|
|
for (const template of selectedTemplates) {
|
|
console.log(`Generating ${template.id}...`);
|
|
generated.push(await generateOne(env, template, outDir));
|
|
}
|
|
|
|
console.log(
|
|
JSON.stringify(
|
|
{
|
|
ok: true,
|
|
count: generated.length,
|
|
files: generated,
|
|
},
|
|
null,
|
|
2,
|
|
),
|
|
);
|