ima2-gen 1.1.21 → 1.1.23

package/lib/cardNewsPlannerSchema.ts

@@ -1,321 +0,0 @@
-export const CARD_NEWS_TEXT_KINDS = ["headline", "body", "caption", "cta", "badge", "number"];
-export const CARD_NEWS_RENDER_MODES = ["in-image", "ui-only"];
-export const CARD_NEWS_PLACEMENTS = [
-  "top-left",
-  "top-center",
-  "top-right",
-  "center-left",
-  "center",
-  "center-right",
-  "bottom-left",
-  "bottom-center",
-  "bottom-right",
-  "free",
-];
-export const CARD_NEWS_HIERARCHIES = ["primary", "secondary", "supporting"];
-export const CARD_NEWS_TEXT_SOURCES = ["planner", "user"];
-
-const TEXT_FIELD_SCHEMA = {
-  type: "object",
-  additionalProperties: false,
-  required: [
-    "id",
-    "kind",
-    "text",
-    "renderMode",
-    "placement",
-    "slotId",
-    "hierarchy",
-    "maxChars",
-    "language",
-    "source",
-  ],
-  properties: {
-    id: { type: "string" },
-    kind: { type: "string", enum: CARD_NEWS_TEXT_KINDS },
-    text: { type: "string" },
-    renderMode: { type: "string", enum: CARD_NEWS_RENDER_MODES },
-    placement: { type: "string", enum: CARD_NEWS_PLACEMENTS },
-    slotId: { type: ["string", "null"] },
-    hierarchy: { type: "string", enum: CARD_NEWS_HIERARCHIES },
-    maxChars: { type: ["integer", "null"] },
-    language: { type: ["string", "null"] },
-    source: { type: "string", enum: CARD_NEWS_TEXT_SOURCES },
-  },
-};
-
-export const CARD_NEWS_PLANNER_SCHEMA = {
-  type: "object",
-  additionalProperties: false,
-  required: ["title", "topic", "cards"],
-  properties: {
-    title: { type: "string" },
-    topic: { type: "string" },
-    audience: { type: "string" },
-    goal: { type: "string" },
-    cards: {
-      type: "array",
-      items: {
-        type: "object",
-        additionalProperties: false,
-        required: ["order", "role", "headline", "body", "visualPrompt", "textFields", "references", "locked"],
-        properties: {
-          order: { type: "integer" },
-          role: { type: "string" },
-          headline: { type: "string" },
-          body: { type: "string" },
-          visualPrompt: { type: "string" },
-          textFields: { type: "array", items: TEXT_FIELD_SCHEMA },
-          references: { type: "array", items: { type: "string" } },
-          locked: { type: "boolean" },
-        },
-      },
-    },
-  },
-};
-
-interface TextFieldRecord {
-  id?: unknown;
-  kind?: unknown;
-  text?: unknown;
-  renderMode?: unknown;
-  placement?: unknown;
-  slotId?: unknown;
-  hierarchy?: unknown;
-  maxChars?: unknown;
-  language?: unknown;
-  source?: unknown;
-}
-
-interface NormalizedTextField {
-  id: string;
-  kind: string;
-  text: string;
-  renderMode: string;
-  placement: string;
-  slotId: string | null;
-  hierarchy: string;
-  maxChars: number | null;
-  language: string | null;
-  source: string;
-}
-
-interface CardRecord {
-  order?: unknown;
-  role?: unknown;
-  headline?: unknown;
-  body?: unknown;
-  visualPrompt?: unknown;
-  textFields?: unknown;
-  references?: unknown;
-  locked?: unknown;
-}
-
-interface RoleEntry {
-  role: string;
-  promptHint?: string;
-}
-
-interface RoleTemplate {
-  roles: RoleEntry[];
-}
-
-interface BriefInput {
-  topic?: string;
-  title?: string;
-  audience?: string;
-  goal?: string;
-  contentBrief?: string;
-  roleTemplate?: RoleTemplate;
-}
-
-function asText(value: unknown, fallback = ""): string {
-  return typeof value === "string" && value.trim() ? value.trim() : fallback;
-}
-
-function detectBriefLanguage(input: BriefInput = {}): "ko" | "en" | "und" {
-  const text = [input.topic, input.audience, input.goal, input.contentBrief].filter(Boolean).join(" ");
-  if (/[가-힣]/.test(text)) return "ko";
-  if (/[A-Za-z]/.test(text)) return "en";
-  return "und";
-}
-
-function fallbackCopy(input: BriefInput = {}, kind = "body"): string {
-  const lang = detectBriefLanguage(input);
-  const topic = asText(input.topic, asText(input.title, "Card news"));
-  const goal = asText(input.goal, topic);
-  const brief = asText(input.contentBrief, goal);
-  if (kind === "headline") return topic;
-  if (lang === "ko") return brief || `${topic} 핵심 내용을 정리합니다.`;
-  if (lang === "en") return brief || `Summarize the key point for ${topic}.`;
-  return brief || topic;
-}
-
-function normalizeTextField(field: unknown, index: number): NormalizedTextField | null {
-  if (!field || typeof field !== "object") return null;
-  const f = field as TextFieldRecord;
-  const text = asText(f.text);
-  if (!text) return null;
-  return {
-    id: asText(f.id, `tf_${index + 1}`),
-    kind: typeof f.kind === "string" && CARD_NEWS_TEXT_KINDS.includes(f.kind) ? f.kind : "body",
-    text,
-    renderMode: typeof f.renderMode === "string" && CARD_NEWS_RENDER_MODES.includes(f.renderMode) ? f.renderMode : "in-image",
-    placement: typeof f.placement === "string" && CARD_NEWS_PLACEMENTS.includes(f.placement) ? f.placement : "free",
-    slotId: typeof f.slotId === "string" && f.slotId.trim() ? f.slotId.trim() : null,
-    hierarchy: typeof f.hierarchy === "string" && CARD_NEWS_HIERARCHIES.includes(f.hierarchy) ? f.hierarchy : "supporting",
-    maxChars: Number.isInteger(f.maxChars) ? (f.maxChars as number) : null,
-    language: typeof f.language === "string" && f.language.trim() ? f.language.trim() : null,
-    source: typeof f.source === "string" && CARD_NEWS_TEXT_SOURCES.includes(f.source) ? f.source : "planner",
-  };
-}
-
-function normalizeTextFields(value: unknown): NormalizedTextField[] {
-  if (!Array.isArray(value)) return [];
-  return value.map((item, idx) => normalizeTextField(item, idx)).filter((field): field is NormalizedTextField => field !== null);
-}
-
-function stripExactVisibleText(visualPrompt: unknown, textFields: NormalizedTextField[]): string {
-  let next = asText(visualPrompt);
-  for (const field of textFields) {
-    const text = asText(field.text);
-    if (text.length >= 4 && next.includes(text)) {
-      next = next.split(text).join("visible text box");
-    }
-  }
-  return next.trim();
-}
-
-function normalizeCard(card: CardRecord | null | undefined, role: RoleEntry, index: number, input: BriefInput) {
-  const topic = asText(input.topic, "Card news");
-  const textFields = normalizeTextFields(card?.textFields);
-  return {
-    order: index + 1,
-    role: role.role,
-    headline: asText(card?.headline, index === 0 ? topic : fallbackCopy(input, "headline")),
-    body: asText(card?.body, fallbackCopy(input, "body")),
-    visualPrompt: stripExactVisibleText(
-      asText(card?.visualPrompt, `${asText(role.promptHint, role.role)}, ${topic}`),
-      textFields,
-    ),
-    textFields,
-    references: Array.isArray(card?.references)
-      ? (card.references as unknown[]).filter((ref): ref is string => typeof ref === "string")
-      : [],
-    locked: false,
-  };
-}
-
-export function repairPlannerOutput(output: unknown, input: BriefInput = {}) {
-  const roles = input.roleTemplate?.roles || [];
-  const outputCards = (output && typeof output === "object" && Array.isArray((output as { cards?: unknown }).cards))
-    ? (output as { cards: CardRecord[] }).cards
-    : null;
-  const cards = roles.map((role, index) => {
-    const original = outputCards ? outputCards[index] : null;
-    return normalizeCard(original, role, index, input);
-  });
-  const out = (output ?? {}) as Record<string, unknown>;
-  return {
-    ok: true,
-    repaired: true,
-    errors: [] as string[],
-    plan: {
-      title: asText(out.title, asText(input.topic, "Untitled card news")),
-      topic: asText(out.topic, asText(input.topic, "Untitled card news")),
-      audience: asText(out.audience, asText(input.audience)),
-      goal: asText(out.goal, asText(input.goal)),
-      cards,
-    },
-  };
-}
-
-function validateTextField(field: unknown, path: string, errors: string[]): void {
-  if (!field || typeof field !== "object") {
-    errors.push(`${path} must be object`);
-    return;
-  }
-  const f = field as TextFieldRecord;
-  if (typeof f.id !== "string") errors.push(`${path}.id must be string`);
-  if (typeof f.kind !== "string" || !CARD_NEWS_TEXT_KINDS.includes(f.kind)) errors.push(`${path}.kind invalid`);
-  if (typeof f.text !== "string") errors.push(`${path}.text must be string`);
-  if (typeof f.text === "string" && !f.text.trim()) errors.push(`${path}.text must not be empty`);
-  if (typeof f.renderMode !== "string" || !CARD_NEWS_RENDER_MODES.includes(f.renderMode)) errors.push(`${path}.renderMode invalid`);
-  if (typeof f.placement !== "string" || !CARD_NEWS_PLACEMENTS.includes(f.placement)) errors.push(`${path}.placement invalid`);
-  if (!(typeof f.slotId === "string" || f.slotId === null)) errors.push(`${path}.slotId invalid`);
-  if (typeof f.hierarchy !== "string" || !CARD_NEWS_HIERARCHIES.includes(f.hierarchy)) errors.push(`${path}.hierarchy invalid`);
-  if (!(Number.isInteger(f.maxChars) || f.maxChars === null)) errors.push(`${path}.maxChars invalid`);
-  if (!(typeof f.language === "string" || f.language === null)) errors.push(`${path}.language invalid`);
-  if (typeof f.source !== "string" || !CARD_NEWS_TEXT_SOURCES.includes(f.source)) errors.push(`${path}.source invalid`);
-}
-
-export function validatePlannerOutput(output: unknown, roleTemplate: RoleTemplate | null | undefined) {
-  const errors: string[] = [];
-  if (!output || typeof output !== "object" || Array.isArray(output)) {
-    return { ok: false, repaired: false, errors: ["output must be an object"] };
-  }
-  const out = output as { title?: unknown; topic?: unknown; cards?: unknown; audience?: unknown; goal?: unknown };
-  if (typeof out.title !== "string") errors.push("title must be a string");
-  if (typeof out.topic !== "string") errors.push("topic must be a string");
-  if (!Array.isArray(out.cards)) errors.push("cards must be an array");
-
-  const roles = roleTemplate?.roles || [];
-  if (Array.isArray(out.cards) && out.cards.length !== roles.length) {
-    errors.push("cards length must match role template");
-  }
-
-  const cards: CardRecord[] = Array.isArray(out.cards) ? (out.cards as CardRecord[]) : [];
-  cards.forEach((card, index) => {
-    const expected = roles[index];
-    if (!card || typeof card !== "object") {
-      errors.push(`card ${index + 1} must be an object`);
-      return;
-    }
-    if (card.order !== index + 1) errors.push(`card ${index + 1} order mismatch`);
-    if (expected && card.role !== expected.role) errors.push(`card ${index + 1} role mismatch`);
-    for (const key of ["headline", "body", "visualPrompt"] as const) {
-      if (typeof card[key] !== "string") errors.push(`card ${index + 1} ${key} must be string`);
-    }
-    if (!Array.isArray(card.textFields)) errors.push(`card ${index + 1} textFields must be array`);
-    if (Array.isArray(card.textFields)) {
-      card.textFields.forEach((field, fieldIndex) =>
-        validateTextField(field, `card ${index + 1} textFields ${fieldIndex + 1}`, errors));
-      for (const field of card.textFields as TextFieldRecord[]) {
-        if (
-          field?.renderMode === "in-image" &&
-          typeof field.text === "string" &&
-          field.text.trim().length >= 4 &&
-          typeof card.visualPrompt === "string" &&
-          card.visualPrompt.includes(field.text.trim())
-        ) {
-          errors.push(`card ${index + 1} visualPrompt must not duplicate exact visible text`);
-        }
-      }
-    }
-    if (!Array.isArray(card.references)) errors.push(`card ${index + 1} references must be array`);
-    if (card.locked !== false) errors.push(`card ${index + 1} locked must be false`);
-  });
-
-  if (errors.length) return { ok: false, repaired: false, errors };
-  return {
-    ok: true,
-    repaired: false,
-    errors: [] as string[],
-    plan: {
-      title: (out.title as string).trim(),
-      topic: (out.topic as string).trim(),
-      audience: asText(out.audience),
-      goal: asText(out.goal),
-      cards: cards.map((card) => ({
-        order: card.order as number,
-        role: card.role as string,
-        headline: (card.headline as string).trim(),
-        body: (card.body as string).trim(),
-        visualPrompt: (card.visualPrompt as string).trim(),
-        textFields: normalizeTextFields(card.textFields),
-        references: (card.references as unknown[]).filter((ref): ref is string => typeof ref === "string"),
-        locked: false,
-      })),
-    },
-  };
-}

package/lib/cardNewsRoleTemplateStore.ts

@@ -1,47 +0,0 @@
-const ROLE_TEMPLATES = [
-  {
-    id: "short-3",
-    name: "Short 3",
-    defaultCount: 3,
-    roles: [
-      { role: "hook", required: true, promptHint: "strong opening card", preferredSlots: ["title", "visual"] },
-      { role: "core", required: true, promptHint: "main explanation card", preferredSlots: ["visual", "body"] },
-      { role: "cta", required: true, promptHint: "clear call to action card", preferredSlots: ["cta"] },
-    ],
-  },
-  {
-    id: "mid-5",
-    name: "Mid 5",
-    defaultCount: 5,
-    roles: [
-      { role: "cover", required: true, promptHint: "cover card with strong headline", preferredSlots: ["title", "visual"] },
-      { role: "problem", required: true, promptHint: "problem framing card", preferredSlots: ["title", "body"] },
-      { role: "insight", required: true, promptHint: "insight or solution card", preferredSlots: ["visual", "body"] },
-      { role: "example", required: true, promptHint: "example or proof card", preferredSlots: ["visual", "body"] },
-      { role: "cta", required: true, promptHint: "closing call to action card", preferredSlots: ["cta"] },
-    ],
-  },
-  {
-    id: "long-8",
-    name: "Long 8",
-    defaultCount: 8,
-    roles: [
-      { role: "cover", required: true, promptHint: "cover card", preferredSlots: ["title"] },
-      { role: "problem", required: true, promptHint: "problem card", preferredSlots: ["body"] },
-      { role: "data", required: true, promptHint: "data card", preferredSlots: ["visual"] },
-      { role: "tip1", required: true, promptHint: "first tip card", preferredSlots: ["body"] },
-      { role: "tip2", required: true, promptHint: "second tip card", preferredSlots: ["body"] },
-      { role: "example", required: true, promptHint: "example card", preferredSlots: ["visual"] },
-      { role: "summary", required: true, promptHint: "summary card", preferredSlots: ["body"] },
-      { role: "cta", required: true, promptHint: "call to action card", preferredSlots: ["cta"] },
-    ],
-  },
-];
-
-export function listRoleTemplates() {
-  return ROLE_TEMPLATES;
-}
-
-export function getRoleTemplate(roleTemplateId = "mid-5") {
-  return ROLE_TEMPLATES.find((t) => t.id === roleTemplateId) || ROLE_TEMPLATES[1];
-}

package/lib/cardNewsTemplateStore.ts

@@ -1,252 +0,0 @@
-import { readFile } from "node:fs/promises";
-import { existsSync } from "node:fs";
-import { basename, join, normalize, sep } from "node:path";
-
-interface TemplateCtx {
-  rootDir?: string;
-}
-
-interface SlotInput {
-  id?: unknown;
-  kind?: unknown;
-  textKind?: unknown;
-  label?: unknown;
-  placement?: unknown;
-  x?: unknown;
-  y?: unknown;
-  w?: unknown;
-  h?: unknown;
-  required?: unknown;
-  maxChars?: unknown;
-  safeArea?: unknown;
-  [k: string]: unknown;
-}
-
-interface NormalizedSlot {
-  id: string;
-  kind: string;
-  textKind: string | null;
-  label: string;
-  placement: string;
-  x: number;
-  y: number;
-  w: number;
-  h: number;
-  required: boolean;
-  maxChars: number | null;
-  safeArea: boolean;
-  [k: string]: unknown;
-}
-
-interface TemplateRecord {
-  id?: string;
-  name?: string;
-  description?: string;
-  size?: string;
-  stylePrompt?: string;
-  negativePrompt?: string;
-  slots?: SlotInput[];
-  palette?: unknown[];
-  typography?: unknown;
-  recommendedOutputSizes?: string[];
-  authoringLabel?: string;
-  recommendedRoleNodeIds?: string[];
-  createdBy?: string;
-  previewFilename?: string;
-  baseFilename?: string;
-  [k: string]: unknown;
-}
-
-type TypedError = Error & { status?: number; code?: string };
-function makeError(msg: string, status: number, code: string): TypedError {
-  const err = new Error(msg) as TypedError;
-  err.status = status;
-  err.code = code;
-  return err;
-}
-
-const TEMPLATE_ROOT = ["assets", "card-news", "templates"];
-const IMAGE_TEMPLATE_REGISTRY = [
-  {
-    id: "clean-report-square",
-    label: "Clean editorial report",
-    recommendedOutputSizes: ["1024x1024", "2048x2048"],
-  },
-  {
-    id: "academy-lesson-square",
-    label: "Academy lesson carousel",
-    recommendedOutputSizes: ["1024x1024", "2048x2048"],
-  },
-];
-const OUTPUT_SIZE_RE = /^(1024|2048|[1-3][0-9]{3})x(1024|2048|[1-3][0-9]{3})$/;
-const PLACEMENTS = new Set([
-  "top-left",
-  "top-center",
-  "top-right",
-  "center-left",
-  "center",
-  "center-right",
-  "bottom-left",
-  "bottom-center",
-  "bottom-right",
-  "free",
-]);
-
-function assertSafeId(id: unknown): asserts id is string {
-  if (typeof id !== "string" || !/^[a-z0-9][a-z0-9-]{1,80}$/.test(id)) {
-    throw makeError("Invalid template id", 400, "CARD_NEWS_BAD_TEMPLATE_ID");
-  }
-}
-
-function templateDir(ctx: TemplateCtx, templateId: string): string {
-  assertSafeId(templateId);
-  const root = join(ctx.rootDir ?? process.cwd(), ...TEMPLATE_ROOT);
-  const dir = join(root, templateId);
-  const normalizedRoot = normalize(root + sep);
-  const normalizedDir = normalize(dir + sep);
-  if (!normalizedDir.startsWith(normalizedRoot)) {
-    throw makeError("Template path escapes root", 400, "CARD_NEWS_BAD_TEMPLATE_PATH");
-  }
-  return dir;
-}
-
-function publicTemplate(t: TemplateRecord) {
-  return {
-    id: t.id,
-    name: t.name,
-    description: t.description || "",
-    size: t.size,
-    previewUrl: `/api/cardnews/image-templates/${encodeURIComponent(t.id ?? "")}/preview`,
-    stylePrompt: t.stylePrompt,
-    negativePrompt: t.negativePrompt || "",
-    slots: normalizeSlots(t.slots),
-    palette: t.palette || [],
-    typography: t.typography || null,
-    recommendedOutputSizes: Array.isArray(t.recommendedOutputSizes) ? t.recommendedOutputSizes : [],
-    authoringLabel: t.authoringLabel || t.name,
-    recommendedRoleNodeIds: t.recommendedRoleNodeIds || [],
-    createdBy: t.createdBy || "system",
-  };
-}
-
-function normalizeLegacySlotKind(kind: unknown): { kind: string; textKind: string | null } {
-  if (kind === "title") return { kind: "text", textKind: "headline" };
-  if (kind === "body") return { kind: "text", textKind: "body" };
-  if (kind === "cta") return { kind: "text", textKind: "cta" };
-  if (kind === "image") return { kind: "image", textKind: null };
-  if (kind === "text" || kind === "mixed" || kind === "safe-area") return { kind: kind as string, textKind: null };
-  return { kind: "mixed", textKind: null };
-}
-
-function normalizeSlot(slot: SlotInput = {}): NormalizedSlot {
-  const legacy = normalizeLegacySlotKind(slot.kind);
-  return {
-    ...slot,
-    id: typeof slot.id === "string" && slot.id ? slot.id : "slot",
-    kind: legacy.kind,
-    textKind: typeof slot.textKind === "string" && slot.textKind ? slot.textKind : (legacy.textKind || null),
-    label: typeof slot.label === "string" && slot.label ? slot.label : (typeof slot.id === "string" && slot.id ? slot.id : "slot"),
-    placement: typeof slot.placement === "string" && PLACEMENTS.has(slot.placement) ? slot.placement : "free",
-    x: Number.isFinite(slot.x) ? (slot.x as number) : 0,
-    y: Number.isFinite(slot.y) ? (slot.y as number) : 0,
-    w: Number.isFinite(slot.w) ? (slot.w as number) : 100,
-    h: Number.isFinite(slot.h) ? (slot.h as number) : 100,
-    required: Boolean(slot.required),
-    maxChars: Number.isFinite(slot.maxChars) ? (slot.maxChars as number) : null,
-    safeArea: Boolean(slot.safeArea),
-  };
-}
-
-function normalizeSlots(slots: unknown): NormalizedSlot[] {
-  return Array.isArray(slots) ? slots.map((s) => normalizeSlot(s as SlotInput)) : [];
-}
-
-function registryEntry(templateId: string) {
-  return IMAGE_TEMPLATE_REGISTRY.find((entry) => entry.id === templateId);
-}
-
-function validateTemplateAuthoring(template: TemplateRecord): void {
-  const problems: string[] = [];
-  if (typeof template.name !== "string" || !template.name.trim()) problems.push("name");
-  if (typeof template.size !== "string" || !OUTPUT_SIZE_RE.test(template.size)) problems.push("size");
-  if (typeof template.stylePrompt !== "string" || !template.stylePrompt.trim()) problems.push("stylePrompt");
-  if (!Array.isArray(template.slots) || template.slots.length === 0) problems.push("slots");
-  const ids = new Set<string>();
-  for (const slot of normalizeSlots(template.slots)) {
-    if (ids.has(slot.id)) problems.push(`duplicate slot ${slot.id}`);
-    ids.add(slot.id);
-    if (!PLACEMENTS.has(slot.placement)) problems.push(`slot ${slot.id} placement`);
-    if ((slot.kind === "text" || slot.textKind) && !slot.maxChars) problems.push(`slot ${slot.id} maxChars`);
-  }
-  if (
-    template.recommendedOutputSizes &&
-    (!Array.isArray(template.recommendedOutputSizes) ||
-      template.recommendedOutputSizes.some((size) => typeof size !== "string" || !OUTPUT_SIZE_RE.test(size)))
-  ) {
-    problems.push("recommendedOutputSizes");
-  }
-  if (problems.length) {
-    throw makeError(`Template authoring metadata invalid: ${problems.join(", ")}`, 500, "CARD_NEWS_TEMPLATE_AUTHORING_INVALID");
-  }
-}
-
-async function readTemplate(ctx: TemplateCtx, templateId: string): Promise<TemplateRecord> {
-  const dir = templateDir(ctx, templateId);
-  const raw = await readFile(join(dir, "template.json"), "utf8");
-  const parsed = JSON.parse(raw) as TemplateRecord;
-  const id = parsed.id || templateId;
-  if (id !== templateId) {
-    throw makeError("Template id mismatch", 500, "CARD_NEWS_TEMPLATE_ID_MISMATCH");
-  }
-  const entry = registryEntry(templateId);
-  if (!entry) {
-    throw makeError("Template is not registered", 500, "CARD_NEWS_TEMPLATE_NOT_REGISTERED");
-  }
-  validateTemplateAuthoring(parsed);
-  return {
-    ...parsed,
-    authoringLabel: parsed.authoringLabel || entry.label,
-    recommendedOutputSizes: parsed.recommendedOutputSizes || entry.recommendedOutputSizes,
-    slots: normalizeSlots(parsed.slots) as unknown as SlotInput[],
-    previewFilename: parsed.previewFilename || "preview.png",
-    baseFilename: parsed.baseFilename || "base.png",
-    createdBy: "system",
-  };
-}
-
-export async function listImageTemplates(ctx: TemplateCtx) {
-  const templates: ReturnType<typeof publicTemplate>[] = [];
-  for (const entry of IMAGE_TEMPLATE_REGISTRY) {
-    templates.push(publicTemplate(await readTemplate(ctx, entry.id)));
-  }
-  return templates;
-}
-
-export async function getImageTemplate(ctx: TemplateCtx, templateId: string) {
-  return readTemplate(ctx, templateId);
-}
-
-export async function readTemplatePreview(ctx: TemplateCtx, templateId: string) {
-  const template = await readTemplate(ctx, templateId);
-  const filename = basename(template.previewFilename || "preview.png");
-  const path = join(templateDir(ctx, templateId), filename);
-  if (!existsSync(path)) {
-    throw makeError("Template preview not found", 404, "CARD_NEWS_TEMPLATE_PREVIEW_NOT_FOUND");
-  }
-  return readFile(path);
-}
-
-export async function readTemplateBaseB64(ctx: TemplateCtx, templateId: string) {
-  const template = await readTemplate(ctx, templateId);
-  const filename = basename(template.baseFilename || "base.png");
-  const path = join(templateDir(ctx, templateId), filename);
-  if (!existsSync(path)) {
-    throw makeError("Template base image not found", 404, "CARD_NEWS_TEMPLATE_BASE_NOT_FOUND");
-  }
-  const buf = await readFile(path);
-  return {
-    template,
-    templateBase: join(...TEMPLATE_ROOT, templateId, filename),
-    b64: buf.toString("base64"),
-  };
-}

package/lib/codexDetect.ts

@@ -1,71 +0,0 @@
-// Codex CLI / OAuth auth detection across platforms.
-// References:
-// - OpenAI Codex stores auth under CODEX_HOME (default ~/.codex/auth.json).
-// - Legacy chatgpt-local stores auth under ~/.chatgpt-local/auth.json.
-// - Auth may live in OS keyring instead of a file (file absence ≠ unauth).
-// - Windows has no documented native install path; WSL is the supported path.
-import { existsSync } from "node:fs";
-import { execFileSync } from "node:child_process";
-import { homedir } from "node:os";
-import { join } from "node:path";
-
-import { errInfo } from "./errInfo.js";
-const HOME = homedir();
-
-export function codexAuthPaths() {
-  const codexHome = process.env.CODEX_HOME || join(HOME, ".codex");
-  return {
-    codex: join(codexHome, "auth.json"),
-    chatgpt: join(HOME, ".chatgpt-local", "auth.json"),
-    xdgCodex: join(HOME, ".config", "codex", "auth.json"),
-  };
-}
-
-export function hasAuthFile() {
-  const p = codexAuthPaths();
-  return existsSync(p.codex) || existsSync(p.chatgpt) || existsSync(p.xdgCodex);
-}
-
-// Non-invasive probe: `codex login status` returns 0 when authed (file OR keyring).
-// Returns: "authed" | "unauthed" | "missing" (codex binary not found)
-export function codexLoginStatus(timeoutMs = 2000) {
-  const candidates =
-    process.platform === "win32"
-      ? ["codex.cmd", "codex.exe", "codex"]
-      : ["codex"];
-  for (const bin of candidates) {
-    try {
-      execFileSync(bin, ["login", "status"], {
-        stdio: "ignore",
-        timeout: timeoutMs,
-        windowsHide: true,
-      });
-      return "authed";
-    } catch (e) {
-      const err = errInfo(e);
-      if (err.raw && err.code === "ENOENT") continue;
-      // non-zero exit = binary exists but not authed
-      if (err.raw && typeof err.status === "number") return "unauthed";
-    }
-  }
-  return "missing";
-}
-
-export function detectCodexAuth() {
-  const files = codexAuthPaths();
-  const fileHits = {
-    codex: existsSync(files.codex),
-    chatgpt: existsSync(files.chatgpt),
-    xdgCodex: existsSync(files.xdgCodex),
-  };
-  const probe = codexLoginStatus();
-  const authed = probe === "authed" || fileHits.codex || fileHits.chatgpt || fileHits.xdgCodex;
-  return {
-    authed,
-    probe,
-    files,
-    fileHits,
-    platform: process.platform,
-    wslHint: process.platform === "win32",
-  };
-}