feat: refresh creation config and visual assets

2026-05-20 14:02:36 +08:00
parent 83e92fc3c4
commit ef09a23c35
509 changed files with 19470 additions and 43 deletions
--- a/scripts/generate-taonier-anti-candy-logo-concepts.mjs
+++ b/scripts/generate-taonier-anti-candy-logo-concepts.mjs
@@ -0,0 +1,420 @@
+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 repoRoot = path.resolve(__dirname, '..');
+const outputDir = path.join(
+  repoRoot,
+  'public',
+  'branding',
+  'taonier-logo-anti-candy-concepts',
+);
+const timeoutMsDefault = 180000;
+
+const args = new Map();
+for (let index = 2; index < process.argv.length; index += 1) {
+  const raw = process.argv[index];
+  if (!raw.startsWith('--')) {
+    continue;
+  }
+  const next = process.argv[index + 1];
+  if (next && !next.startsWith('--')) {
+    args.set(raw, next);
+    index += 1;
+  } else {
+    args.set(raw, true);
+  }
+}
+
+const basePrompt = [
+  '请生成一枚全新的「陶泥儿」产品商标图形标概念稿，但画面中绝对不要出现任何中文字、英文字母、数字、符号字样或品牌字标。',
+  '产品定位：精品 AI UGC 轻休闲小游戏创作与传播平台，用户可以像捏陶泥一样把脑洞、梗和灵感塑造成小游戏或趣味内容。',
+  '这次必须反糖果化：第一眼必须像哑光陶泥、泥章、窑印、创作印记，绝对不能像糖果、软糖、奶油、饼干、夹心甜点、月饼、巧克力或食品包装。',
+  '核心隐喻：脑洞泥印。一块被轻轻捏平的不规则软方圆陶泥印章，中间有一个抽象星核凹印或镂空星形泥印，表达灵感被压印成作品。',
+  '风格：扁平矢量商标为主，低高光、低饱和、哑光粉陶质感；轮廓清楚，可后续矢量化，适合商标、App 图标、社区头像。',
+  '主色：灰米白、未经上釉的陶土白、陶土褐、深泥灰、少量暗金土黄；颜色必须干燥、克制、低甜度。不使用亮金、糖果黄、奶油黄、粉色、青色、蓝色、紫色、荧光色或彩虹色。',
+  '形态：保留不规则软方圆，但不要鼓胀、不要胶状、不要可食用的圆润光泽。边缘可以有少量粗糙泥料纹理、压痕、手捏不均匀。',
+  '数字感：只允许 2 到 3 个很小的深泥灰或暗土黄刻点，像生成节点或 UGC 扩散点；不要闪亮星星，不要糖珠。',
+  '构图：正方形画布，居中图形标，干净浅灰米白背景，留足安全边距；缩小到 64px 时仍能看清软方圆轮廓和中间星核凹印。',
+  '禁止：脸、眼睛、嘴巴、表情、角色身体、吉祥物立绘、儿童黏土玩具感、陶艺工具、手、笔刷、复杂场景、按钮、UI、边框、水印、文字、商标字标、旋涡环形旧稿、三色花瓣旧稿。',
+  '强禁止食品感：不要 glossy 高光、不要果冻质感、不要奶油夹心、不要糖霜、不要撒糖粒、不要饼干边、不要巧克力流心、不要金色膨胀星糖。',
+];
+
+const variants = [
+  {
+    id: '01-matte-clay-stamp',
+    title: '哑光陶泥印章',
+    prompt: [
+      ...basePrompt,
+      '本张重点：最克制的陶泥印章。灰米白软方圆主体，中间是压进去的暗陶土星核凹印，只有 2 个微小刻点。几乎无高光。',
+    ],
+  },
+  {
+    id: '02-kiln-mark-core',
+    title: '窑印星核',
+    prompt: [
+      ...basePrompt,
+      '本张重点：窑印感。中间星核像烧陶后的浅浮雕窑印，用深泥灰边缘和陶土褐阴影表现，不要任何金属或糖果光泽。',
+    ],
+  },
+  {
+    id: '03-cutout-negative-star',
+    title: '负形星核',
+    prompt: [
+      ...basePrompt,
+      '本张重点：负形。星核用干净的镂空负形或深泥灰内孔表达，主体是单块哑光陶泥，整体更像可注册商标图形。',
+    ],
+  },
+  {
+    id: '04-dry-clay-grain',
+    title: '干陶颗粒',
+    prompt: [
+      ...basePrompt,
+      '本张重点：干陶质感。加入非常细微的陶土颗粒和粉陶纹理，但保持扁平图标，不要照片写实，不要脏乱。',
+    ],
+  },
+  {
+    id: '05-hand-pressed-token',
+    title: '手压泥币',
+    prompt: [
+      ...basePrompt,
+      '本张重点：手压泥币。像一枚被手工压平的陶泥代币，边缘不完全对称，中间星核为凹刻符号，但不要出现手或工具。',
+    ],
+  },
+  {
+    id: '06-digital-clay-glyph',
+    title: '数字泥符',
+    prompt: [
+      ...basePrompt,
+      '本张重点：AI 与 UGC 暗示更强。用 3 个极小方形刻点围绕星核，像生成节点，但必须像刻在陶泥上的小孔。',
+    ],
+  },
+  {
+    id: '07-premium-flat-mark',
+    title: '精品扁平标',
+    prompt: [
+      ...basePrompt,
+      '本张重点：更互联网精品。减少纹理，强化几何平衡和负形，灰米白主体、深泥灰星核、陶土褐小刻痕，适合 App 图标。',
+    ],
+  },
+  {
+    id: '08-monochrome-proof',
+    title: '单色验证版',
+    prompt: [
+      ...basePrompt,
+      '本张重点：黑白商标验证。尽量用单色深浅关系表达软方圆和星核凹印，减少装饰，确保黑白化后轮廓仍成立。',
+    ],
+  },
+];
+
+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 || timeoutMsDefault),
+      10,
+    ),
+  };
+}
+
+function buildVectorEngineImagesGenerationUrl(baseUrl) {
+  return baseUrl.endsWith('/v1')
+    ? `${baseUrl}/images/generations`
+    : `${baseUrl}/v1/images/generations`;
+}
+
+function buildRequestBody(variant) {
+  return {
+    model: 'gpt-image-2-all',
+    prompt: variant.prompt.join('\n'),
+    n: 1,
+    size: '1024x1024',
+  };
+}
+
+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 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';
+  }
+  return 'png';
+}
+
+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) {
+      throw new Error(`VectorEngine ${response.status}: ${text.slice(0, 600)}`);
+    }
+    return JSON.parse(text);
+  } catch (error) {
+    if (error?.name === 'AbortError') {
+      throw new Error(`VectorEngine request timed out after ${timeoutMs}ms`);
+    }
+    throw error;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+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, variant) {
+  const requestBody = buildRequestBody(variant);
+  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 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 = Buffer.from(b64Images[0], 'base64');
+    image = {
+      bytes,
+      extension: inferExtensionFromBytes(bytes),
+    };
+  } else {
+    throw new Error(`VectorEngine returned no image for ${variant.id}`);
+  }
+
+  mkdirSync(outputDir, { recursive: true });
+  const outputPath = path.join(outputDir, `taonier-anti-candy-${variant.id}.${image.extension}`);
+  writeFileSync(outputPath, image.bytes);
+  return outputPath;
+}
+
+function writeManifest(files) {
+  const manifestPath = path.join(outputDir, 'taonier-logo-anti-candy-manifest.json');
+  writeFileSync(
+    manifestPath,
+    `${JSON.stringify(
+      {
+        model: 'gpt-image-2-all',
+        size: '1024x1024',
+        generatedAt: new Date().toISOString(),
+        creativeDirection: {
+          name: '陶泥儿反糖果化脑洞泥印图形标',
+          textPolicy: 'no Chinese, no English, no wordmark',
+          palette: '灰米白、陶土白、陶土褐、深泥灰、少量暗金土黄',
+          motif: '哑光软方圆陶泥印章 + 星核凹印/负形 + 极少量刻点',
+          antiCandyRules:
+            'no glossy highlight, no cream filling, no jelly, no cookie, no chocolate, no candy star',
+        },
+        variants: variants.map((variant) => {
+          const file = files.find((item) => path.basename(item).includes(variant.id));
+          return {
+            id: variant.id,
+            title: variant.title,
+            file: file ? path.basename(file) : null,
+            prompt: variant.prompt.join('\n'),
+          };
+        }),
+      },
+      null,
+      2,
+    )}\n`,
+    'utf8',
+  );
+  return manifestPath;
+}
+
+const dryRun = args.has('--dry-run') || !args.has('--live');
+const limit = Number.parseInt(String(args.get('--limit') || variants.length), 10);
+const selectedVariants = variants.slice(0, limit);
+
+if (dryRun) {
+  console.log(
+    JSON.stringify(
+      {
+        mode: 'dry-run',
+        outputDir,
+        count: selectedVariants.length,
+        requests: selectedVariants.map((variant) => ({
+          id: variant.id,
+          title: variant.title,
+          body: buildRequestBody(variant),
+        })),
+      },
+      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 variant of selectedVariants) {
+  console.log(`Generating ${variant.id} ${variant.title}...`);
+  generated.push(await generateOne(env, variant));
+}
+
+const manifestPath = writeManifest(generated);
+console.log(
+  JSON.stringify(
+    {
+      ok: true,
+      count: generated.length,
+      files: generated,
+      manifest: manifestPath,
+    },
+    null,
+    2,
+  ),
+);