ima2-gen 1.1.20 → 1.1.22

package/lib/historyList.ts

@@ -1,177 +0,0 @@
-import { mkdir, readFile, readdir, stat } from "fs/promises";
-import { dirname, join } from "path";
-import { config } from "../config.js";
-import { readEmbeddedImageMetadataFromFile } from "./imageMetadataStore.js";
-
-import { errInfo } from "./errInfo.js";
-async function listImageFiles(baseDir: string) {
-  const out: Array<{ full: string; rel: string; name: string }> = [];
-
-  async function walk(dir: string, depth: number) {
-    const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
-    for (const entry of entries) {
-      if (entry.name === config.storage.trashDirName) continue;
-      const full = join(dir, entry.name);
-      if (entry.isDirectory() && depth > 0) {
-        await walk(full, depth - 1);
-      } else if (entry.isFile() && /\.(png|jpe?g|webp|mp4)$/i.test(entry.name)) {
-        out.push({ full, rel: full.slice(baseDir.length + 1), name: entry.name });
-      }
-    }
-  }
-
-  await walk(baseDir, 2);
-  return out;
-}
-
-export async function listHistoryRows(baseDir = config.storage.generatedDir) {
-  await mkdir(baseDir, { recursive: true });
-  const imgs = await listImageFiles(baseDir);
-  const setRows = await listCardNewsSetRows(baseDir);
-  const rows = await Promise.all(imgs.map(async ({ full, rel, name }) => {
-    const st = await stat(full).catch(() => null);
-    const meta = await readImageMetadata(full, rel);
-    return {
-      filename: rel,
-      url: `/generated/${rel.split("/").map(encodeURIComponent).join("/")}`,
-      mediaType: meta?.mediaType || (/\.mp4$/i.test(name) ? "video" : "image"),
-      video: meta?.video || null,
-      videoSeries: meta?.videoSeries || null,
-      createdAt: meta?.createdAt || st?.mtimeMs || 0,
-      prompt: meta?.prompt || null,
-      userPrompt: meta?.userPrompt || meta?.prompt || null,
-      revisedPrompt: meta?.revisedPrompt || null,
-      promptMode: meta?.promptMode || null,
-      composerPrompt: meta?.composerPrompt ?? null,
-      composerInsertedPrompts: meta?.composerInsertedPrompts ?? null,
-      quality: meta?.quality || null,
-      size: meta?.size || null,
-      format: meta?.format || name.split(".").pop(),
-      model: meta?.model || null,
-      reasoningEffort: meta?.reasoningEffort ?? null,
-      elapsed: meta?.elapsed ?? null,
-      provider: meta?.provider || "oauth",
-      usage: meta?.usage || null,
-      webSearchCalls: meta?.webSearchCalls || 0,
-      sessionId: meta?.sessionId || null,
-      nodeId: meta?.nodeId || null,
-      parentNodeId: meta?.parentNodeId || null,
-      clientNodeId: meta?.clientNodeId || null,
-      requestId: meta?.requestId || null,
-      kind: meta?.kind || null,
-      canvasVersion: Boolean(meta?.canvasVersion),
-      canvasSourceFilename: meta?.canvasSourceFilename || null,
-      canvasEditableFilename: meta?.canvasEditableFilename || null,
-      canvasMergedAt: Number.isFinite(meta?.canvasMergedAt) ? meta.canvasMergedAt : null,
-      setId: meta?.setId || null,
-      cardId: meta?.cardId || null,
-      cardOrder: Number.isFinite(meta?.cardOrder) ? meta.cardOrder : null,
-      headline: meta?.headline || null,
-      body: meta?.body || null,
-      cards: meta?.cards || null,
-      refsCount: Number.isFinite(meta?.refsCount) ? meta.refsCount : 0,
-      sequenceId: meta?.sequenceId || null,
-      sequenceIndex: Number.isFinite(meta?.sequenceIndex) ? meta.sequenceIndex : null,
-      sequenceTotalRequested: Number.isFinite(meta?.sequenceTotalRequested) ? meta.sequenceTotalRequested : null,
-      sequenceTotalReturned: Number.isFinite(meta?.sequenceTotalReturned) ? meta.sequenceTotalReturned : null,
-      sequenceStatus: meta?.sequenceStatus || null,
-    };
-  }));
-
-  rows.push(...setRows);
-  rows.sort((a, b) => {
-    if (b.createdAt !== a.createdAt) return b.createdAt - a.createdAt;
-    return b.filename < a.filename ? -1 : b.filename > a.filename ? 1 : 0;
-  });
-
-  return rows;
-}
-
-async function readImageSidecar(full: string, rel: string) {
-  const sibling = full.replace(/\.(png|jpe?g|webp)$/i, ".json");
-  for (const candidate of [`${full}.json`, sibling]) {
-    try {
-      return JSON.parse(await readFile(candidate, "utf-8"));
-    } catch (e) {
-      const err = errInfo(e);
-      if (err.code !== "ENOENT") console.warn("[history] sidecar parse fail:", rel, err.message);
-    }
-  }
-  return null;
-}
-
-async function readImageMetadata(full: string, rel: string) {
-  const sidecar = await readImageSidecar(full, rel);
-  if (sidecar) return sidecar;
-  try {
-    const embedded = await readEmbeddedImageMetadataFromFile(full);
-    return embedded.metadata;
-  } catch (e) {
-    const err = errInfo(e);
-    if (err.code !== "ENOENT") console.warn("[history] embedded metadata read fail:", rel, err.message);
-    return null;
-  }
-}
-
-async function listCardNewsSetRows(baseDir: string) {
-  const root = join(baseDir, "cardnews");
-  const entries = await readdir(root, { withFileTypes: true }).catch(() => []);
-  const rows: any[] = [];
-  for (const entry of entries) {
-    if (!entry.isDirectory()) continue;
-    try {
-      const manifestPath = join(root, entry.name, "manifest.json");
-      const manifest = JSON.parse(await readFile(manifestPath, "utf-8")) as any;
-      const first = (manifest.cards || []).find((card: any) => card.imageFilename);
-      const filename = `cardnews/${entry.name}/manifest.json`;
-      rows.push({
-        filename,
-        url: first?.imageFilename
-          ? `/generated/cardnews/${encodeURIComponent(entry.name)}/${encodeURIComponent(first.imageFilename)}`
-          : "",
-        createdAt: manifest.createdAt || 0,
-        prompt: null,
-        userPrompt: null,
-        revisedPrompt: null,
-        promptMode: null,
-        composerPrompt: null,
-        composerInsertedPrompts: null,
-        quality: null,
-        size: manifest.size || null,
-        format: "card-news-set",
-        model: null,
-        provider: "oauth",
-        usage: null,
-        webSearchCalls: 0,
-        sessionId: manifest.sessionId || null,
-        nodeId: null,
-        parentNodeId: null,
-        clientNodeId: null,
-        requestId: manifest.requestId || null,
-        kind: "card-news-set",
-        setId: manifest.setId || entry.name,
-        cardId: null,
-        cardOrder: null,
-        title: manifest.title || "Untitled card news",
-        headline: manifest.title || "Untitled card news",
-        body: null,
-        cards: (manifest.cards || []).map((card: any) => ({
-          url: card.imageFilename
-            ? `/generated/cardnews/${encodeURIComponent(entry.name)}/${encodeURIComponent(card.imageFilename)}`
-            : "",
-          headline: card.headline,
-          body: card.body,
-          cardOrder: card.cardOrder,
-          imageFilename: card.imageFilename,
-          status: card.status || "generated",
-        })),
-        refsCount: 0,
-        dir: dirname(manifestPath),
-      });
-    } catch (e) {
-      const err = errInfo(e);
-      if (err.code !== "ENOENT") console.warn("[history] card-news manifest parse fail:", entry.name, err.message);
-    }
-  }
-  return rows;
-}

package/lib/imageMetadata.ts

@@ -1,113 +0,0 @@
-export const IMA2_METADATA_SCHEMA = "ima2.generation.v1";
-export const IMA2_XMP_NAMESPACE = "https://github.com/lidge-jun/ima2-gen/ns/1.0/";
-export const IMA2_XMP_PROPERTY = "GenerationMetadata";
-export const MAX_EMBEDDED_METADATA_CHARS = 64 * 1024;
-
-function isPlainObject(value: unknown) {
-  return value != null && typeof value === "object" && !Array.isArray(value);
-}
-
-function stringOrNull(value: unknown, max = 4000) {
-  if (typeof value !== "string") return null;
-  return value.slice(0, max);
-}
-
-function numberOrNull(value: unknown) {
-  return typeof value === "number" && Number.isFinite(value) ? value : null;
-}
-
-function xmlEscape(value: unknown) {
-  return String(value)
-    .replace(/&/g, "&")
-    .replace(/"/g, """)
-    .replace(/</g, "&lt;")
-    .replace(/>/g, "&gt;");
-}
-
-function xmlUnescape(value: unknown) {
-  return String(value)
-    .replace(/&quot;/g, "\"")
-    .replace(/&lt;/g, "<")
-    .replace(/&gt;/g, ">")
-    .replace(/&amp;/g, "&");
-}
-
-export function buildIma2MetadataPayload(meta: any = {}, context: any = {}) {
-  const payload = {
-    schema: IMA2_METADATA_SCHEMA,
-    app: "ima2-gen",
-    version: stringOrNull(context.version, 80) || null,
-    createdAt: numberOrNull(meta.createdAt) || Date.now(),
-    kind: stringOrNull(meta.kind, 80),
-    canvasVersion: Boolean(meta.canvasVersion),
-    canvasSourceFilename: stringOrNull(meta.canvasSourceFilename, 240),
-    canvasEditableFilename: stringOrNull(meta.canvasEditableFilename, 240),
-    canvasMergedAt: numberOrNull(meta.canvasMergedAt),
-    prompt: stringOrNull(meta.prompt),
-    userPrompt: stringOrNull(meta.userPrompt) || stringOrNull(meta.prompt),
-    revisedPrompt: stringOrNull(meta.revisedPrompt),
-    promptMode: meta.promptMode === "direct" ? "direct" : "auto",
-    quality: stringOrNull(meta.quality, 40),
-    size: stringOrNull(meta.size, 40),
-    format: stringOrNull(meta.format, 20),
-    moderation: stringOrNull(meta.moderation, 40),
-    model: stringOrNull(meta.model, 80),
-    reasoningEffort: stringOrNull(meta.reasoningEffort, 40),
-    elapsed: numberOrNull(meta.elapsed),
-    provider: stringOrNull(meta.provider, 40),
-    sessionId: stringOrNull(meta.sessionId, 120),
-    nodeId: stringOrNull(meta.nodeId, 120),
-    parentNodeId: stringOrNull(meta.parentNodeId, 120),
-    clientNodeId: stringOrNull(meta.clientNodeId, 120),
-    requestId: stringOrNull(meta.requestId, 160),
-    refsCount: Number.isFinite(meta.refsCount) ? meta.refsCount : 0,
-    webSearchCalls: Number.isFinite(meta.webSearchCalls) ? meta.webSearchCalls : 0,
-    styleSheetApplied: Boolean(meta.styleSheetApplied),
-  };
-  return Object.fromEntries(Object.entries(payload).filter(([, value]) => value !== undefined));
-}
-
-export function normalizeEmbeddedMetadata(value: any) {
-  if (!isPlainObject(value)) return null;
-  if (value.schema !== IMA2_METADATA_SCHEMA || value.app !== "ima2-gen") return null;
-  return buildIma2MetadataPayload(value, { version: value.version });
-}
-
-export function buildIma2Xmp(metadataPayload: unknown) {
-  const normalized = normalizeEmbeddedMetadata(metadataPayload);
-  if (!normalized) {
-    const err: any = new Error("Invalid ima2 metadata payload");
-    err.code = "IMAGE_METADATA_INVALID";
-    throw err;
-  }
-  const json = JSON.stringify(normalized);
-  if (json.length > MAX_EMBEDDED_METADATA_CHARS) {
-    const err: any = new Error("ima2 metadata payload is too large");
-    err.code = "IMAGE_METADATA_TOO_LARGE";
-    throw err;
-  }
-  const escaped = xmlEscape(json);
-  return [
-    "<?xpacket begin=\"\" id=\"W5M0MpCehiHzreSzNTczkc9d\"?>",
-    "<x:xmpmeta xmlns:x=\"adobe:ns:meta/\">",
-    "<rdf:RDF xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\">",
-    `<rdf:Description xmlns:ima2="${IMA2_XMP_NAMESPACE}" ima2:${IMA2_XMP_PROPERTY}="${escaped}"/>`,
-    "</rdf:RDF>",
-    "</x:xmpmeta>",
-    "<?xpacket end=\"w\"?>",
-  ].join("");
-}
-
-export function parseIma2Xmp(xmpString: unknown) {
-  if (typeof xmpString !== "string" || xmpString.length === 0) return null;
-  const attrPattern = new RegExp(`ima2:${IMA2_XMP_PROPERTY}="([^"]*)"`);
-  const attrMatch = attrPattern.exec(xmpString);
-  const raw = attrMatch?.[1];
-  if (!raw) return null;
-  try {
-    const parsed = JSON.parse(xmlUnescape(raw));
-    return normalizeEmbeddedMetadata(parsed);
-  } catch {
-    return null;
-  }
-}

package/lib/imageMetadataStore.ts

@@ -1,67 +0,0 @@
-import { readFile } from "node:fs/promises";
-import sharp from "sharp";
-import { buildIma2MetadataPayload, buildIma2Xmp, parseIma2Xmp } from "./imageMetadata.js";
-
-const SUPPORTED_FORMATS = new Set(["png", "jpeg", "jpg", "webp"]);
-
-export function normalizeImageMetadataFormat(format: unknown) {
-  const normalized = String(format || "").toLowerCase();
-  if (normalized === "jpg") return "jpeg";
-  return normalized;
-}
-
-export function isSupportedMetadataFormat(format: unknown) {
-  return SUPPORTED_FORMATS.has(String(format || "").toLowerCase());
-}
-
-export async function embedImageMetadata(buffer: Buffer, format: unknown, metadata: unknown, context: any = {}) {
-  const normalizedFormat = normalizeImageMetadataFormat(format);
-  if (!isSupportedMetadataFormat(normalizedFormat)) {
-    const err: any = new Error(`Unsupported image metadata format: ${format}`);
-    err.code = "IMAGE_METADATA_UNSUPPORTED_FORMAT";
-    throw err;
-  }
-  const payload = buildIma2MetadataPayload(metadata, context);
-  const xmp = buildIma2Xmp(payload);
-  const next = await sharp(buffer)
-    .toFormat(normalizedFormat as any)
-    .withXmp(xmp)
-    .toBuffer();
-  return { buffer: next, embedded: true, metadata: payload };
-}
-
-export async function embedImageMetadataBestEffort(buffer: Buffer, format: unknown, metadata: unknown, context: any = {}) {
-  try {
-    return await embedImageMetadata(buffer, format, metadata, context);
-  } catch (error: any) {
-    return {
-      buffer,
-      embedded: false,
-      warning: error?.message || "metadata embedding failed",
-      code: error?.code || "IMAGE_METADATA_EMBED_FAILED",
-    };
-  }
-}
-
-export async function readEmbeddedImageMetadata(buffer: Buffer) {
-  const meta = await sharp(buffer, { failOn: "none" }).metadata();
-  const xmpString = meta.xmpAsString || (meta.xmp ? meta.xmp.toString("utf8") : "");
-  const xmp = parseIma2Xmp(xmpString);
-  if (xmp) return { metadata: xmp, source: "xmp", warnings: [] };
-
-  for (const comment of meta.comments || []) {
-    const text = comment?.text || "";
-    const parsed = parseIma2Xmp(text);
-    if (parsed) return { metadata: parsed, source: "png-comment", warnings: [] };
-  }
-
-  return {
-    metadata: null,
-    source: null,
-    warnings: ["No ima2 metadata found in this image."],
-  };
-}
-
-export async function readEmbeddedImageMetadataFromFile(path: string) {
-  return readEmbeddedImageMetadata(await readFile(path));
-}

package/lib/imageModels.ts

@@ -1,165 +0,0 @@
-import type { RouteRuntimeContext } from "./runtimeContext.js";
-
-const FALLBACK_IMAGE_MODEL = "gpt-5.4-mini";
-const VALID_IMAGE_MODELS = new Set(["gpt-5.5", "gpt-5.4", "gpt-5.4-mini"]);
-const UNSUPPORTED_IMAGE_MODELS = new Set(["gpt-5.3-codex-spark"]);
-const FALLBACK_REASONING_EFFORT = "none";
-const VALID_REASONING_EFFORTS = new Set(["none", "low", "medium", "high", "xhigh"]);
-
-const GROK_FALLBACK_IMAGE_MODEL = "grok-imagine-image";
-const VALID_GROK_IMAGE_MODELS = new Set(["grok-imagine-image", "grok-imagine-image-quality"]);
-
-export function normalizeReasoningEffort(ctx: RouteRuntimeContext | null | undefined, rawEffort: unknown) {
-  const configured = (ctx?.config as { imageModels?: { reasoningEffort?: string; validReasoningEfforts?: Set<string> } } | undefined)?.imageModels;
-  const fallback = configured?.reasoningEffort ?? FALLBACK_REASONING_EFFORT;
-  const valid = configured?.validReasoningEfforts ?? VALID_REASONING_EFFORTS;
-
-  if (typeof rawEffort !== "string" || rawEffort.length === 0) {
-    return { effort: valid.has(fallback) ? fallback : FALLBACK_REASONING_EFFORT };
-  }
-  if (!valid.has(rawEffort)) {
-    return {
-      error: "reasoningEffort must be one of: none, low, medium, high, xhigh",
-      code: "INVALID_REASONING_EFFORT",
-      status: 400,
-    };
-  }
-  return { effort: rawEffort };
-}
-
-export function normalizeImageModel(ctx: RouteRuntimeContext | null | undefined, rawModel: unknown) {
-  const configured = (ctx?.config as { imageModels?: { default?: string; valid?: Set<string>; unsupported?: Set<string> } } | undefined)?.imageModels;
-  const fallback = configured?.default ?? FALLBACK_IMAGE_MODEL;
-  const valid = configured?.valid ?? VALID_IMAGE_MODELS;
-  const unsupported = configured?.unsupported ?? UNSUPPORTED_IMAGE_MODELS;
-
-  if (typeof rawModel !== "string" || rawModel.length === 0) {
-    return { model: valid.has(fallback) ? fallback : FALLBACK_IMAGE_MODEL };
-  }
-
-  if (unsupported.has(rawModel)) {
-    return {
-      error: "model is listed by OAuth but does not support image_generation: gpt-5.3-codex-spark",
-      code: "IMAGE_MODEL_UNSUPPORTED",
-      status: 400,
-    };
-  }
-
-  if (!valid.has(rawModel)) {
-    return {
-      error: "model must be one of: gpt-5.5, gpt-5.4, gpt-5.4-mini",
-      code: "INVALID_IMAGE_MODEL",
-      status: 400,
-    };
-  }
-
-  return { model: rawModel };
-}
-
-export function normalizeGrokImageModel(rawModel: unknown) {
-  if (typeof rawModel !== "string" || rawModel.length === 0) {
-    return { model: GROK_FALLBACK_IMAGE_MODEL };
-  }
-  if (!VALID_GROK_IMAGE_MODELS.has(rawModel)) {
-    return {
-      error: `Grok image model must be one of: ${[...VALID_GROK_IMAGE_MODELS].join(", ")}`,
-      code: "INVALID_GROK_IMAGE_MODEL" as const,
-      status: 400 as const,
-    };
-  }
-  return { model: rawModel };
-}
-
-// ── Grok video (T2V/I2V) ─────────────────────────────────────────────────
-// Video is a separate generation kind, not an image model. Keep it out of the
-// image model unions/helpers above so `grok-` image classification is unaffected.
-const GROK_FALLBACK_VIDEO_MODEL = "grok-imagine-video";
-export const VALID_GROK_VIDEO_MODELS = new Set(["grok-imagine-video", "grok-imagine-video-1.5-preview"]);
-export const VALID_VIDEO_RESOLUTIONS = new Set(["480p", "720p"]);
-export const VALID_VIDEO_ASPECT_RATIOS = new Set([
-  "1:1",
-  "16:9",
-  "9:16",
-  "4:3",
-  "3:4",
-  "3:2",
-  "2:3",
-  "auto",
-]);
-export const MIN_VIDEO_DURATION = 1;
-export const MAX_VIDEO_DURATION = 15;
-// reference-to-video (xAI): up to 7 reference images, max 10s duration.
-export const MAX_REF2V_REFERENCES = 7;
-export const MAX_REF2V_DURATION = 10;
-
-export type GrokVideoModel = "grok-imagine-video" | "grok-imagine-video-1.5-preview";
-export type VideoResolution = "480p" | "720p";
-export type VideoAspectRatio = "1:1" | "16:9" | "9:16" | "4:3" | "3:4" | "3:2" | "2:3" | "auto";
-export type VideoMode = "text-to-video" | "image-to-video" | "reference-to-video";
-
-// Mode is derived purely from the number of attached reference images.
-export function deriveVideoMode(refCount: number): VideoMode {
-  if (refCount >= 2) return "reference-to-video";
-  if (refCount === 1) return "image-to-video";
-  return "text-to-video";
-}
-
-// Clamp duration to the reference-to-video ceiling; other modes keep their value.
-export function clampVideoDuration(duration: number, mode: VideoMode): number {
-  return mode === "reference-to-video" ? Math.min(duration, MAX_REF2V_DURATION) : duration;
-}
-
-export function isGrokVideoModel(value: unknown): value is GrokVideoModel {
-  return typeof value === "string" && VALID_GROK_VIDEO_MODELS.has(value);
-}
-
-export function normalizeGrokVideoModel(rawModel: unknown) {
-  if (typeof rawModel !== "string" || rawModel.length === 0) {
-    return { model: GROK_FALLBACK_VIDEO_MODEL };
-  }
-  if (!VALID_GROK_VIDEO_MODELS.has(rawModel)) {
-    return {
-      error: `Grok video model must be one of: ${[...VALID_GROK_VIDEO_MODELS].join(", ")}`,
-      code: "INVALID_GROK_VIDEO_MODEL" as const,
-      status: 400 as const,
-    };
-  }
-  return { model: rawModel };
-}
-
-export function normalizeVideoResolution(raw: unknown) {
-  if (raw === undefined || raw === null || raw === "") return { resolution: "480p" as const };
-  if (typeof raw !== "string" || !VALID_VIDEO_RESOLUTIONS.has(raw)) {
-    return {
-      error: `resolution must be one of: ${[...VALID_VIDEO_RESOLUTIONS].join(", ")}`,
-      code: "INVALID_VIDEO_RESOLUTION" as const,
-      status: 400 as const,
-    };
-  }
-  return { resolution: raw as VideoResolution };
-}
-
-export function normalizeVideoAspectRatio(raw: unknown) {
-  if (raw === undefined || raw === null || raw === "") return { aspectRatio: "auto" as const };
-  if (typeof raw !== "string" || !VALID_VIDEO_ASPECT_RATIOS.has(raw)) {
-    return {
-      error: `aspectRatio must be one of: ${[...VALID_VIDEO_ASPECT_RATIOS].join(", ")}`,
-      code: "INVALID_VIDEO_ASPECT_RATIO" as const,
-      status: 400 as const,
-    };
-  }
-  return { aspectRatio: raw as VideoAspectRatio };
-}
-
-export function normalizeVideoDuration(raw: unknown) {
-  if (raw === undefined || raw === null || raw === "") return { duration: 5 };
-  const n = typeof raw === "number" ? raw : Number(raw);
-  if (!Number.isInteger(n) || n < MIN_VIDEO_DURATION || n > MAX_VIDEO_DURATION) {
-    return {
-      error: `duration must be an integer between ${MIN_VIDEO_DURATION} and ${MAX_VIDEO_DURATION} seconds`,
-      code: "INVALID_VIDEO_DURATION" as const,
-      status: 400 as const,
-    };
-  }
-  return { duration: n };
-}