ima2-gen 1.1.21 → 1.1.23

package/lib/videoFrameExtract.ts

@@ -1,78 +0,0 @@
-import { execFile } from "node:child_process";
-import { randomBytes } from "node:crypto";
-import { open, readFile, realpath, stat, unlink } from "node:fs/promises";
-import { extname, join, resolve, sep } from "node:path";
-import { promisify } from "node:util";
-
-const execFileAsync = promisify(execFile);
-const MAX_LOCAL_VIDEO_BYTES = 100 * 1024 * 1024;
-const MAX_FRAME_POSITION_SECONDS = 60 * 60;
-const FFMPEG_TIMEOUT_MS = 30_000;
-
-function routeError(message: string, status = 400): Error & { status: number } {
-  return Object.assign(new Error(message), { status });
-}
-
-export async function safeGeneratedFilePath(generatedDir: string, file: string, options: { requireMp4?: boolean } = {}): Promise<string> {
-  const base = resolve(generatedDir);
-  const target = file.startsWith("/") ? resolve(file) : resolve(base, file);
-  if (target !== base && !target.startsWith(`${base}${sep}`)) {
-    throw routeError("invalid file path", 400);
-  }
-  let baseReal: string;
-  let targetReal: string;
-  try {
-    baseReal = await realpath(base);
-    targetReal = await realpath(target);
-  } catch {
-    throw routeError("video file not found", 404);
-  }
-  if (targetReal !== baseReal && !targetReal.startsWith(`${baseReal}${sep}`)) {
-    throw routeError("invalid file path", 400);
-  }
-  if (options.requireMp4 && extname(targetReal).toLowerCase() !== ".mp4") {
-    throw routeError("generated video input must be an .mp4 file", 400);
-  }
-  return targetReal;
-}
-
-export async function assertLocalMp4(path: string): Promise<void> {
-  const info = await stat(path);
-  if (!info.isFile()) throw routeError("generated video input must be a file", 400);
-  if (info.size <= 0) throw routeError("generated video input is empty", 400);
-  if (info.size > MAX_LOCAL_VIDEO_BYTES) throw routeError("generated video input exceeds the 100MB limit", 400);
-  const fh = await open(path, "r");
-  try {
-    const header = Buffer.alloc(12);
-    const { bytesRead } = await fh.read(header, 0, header.length, 0);
-    if (bytesRead < 12 || header.subarray(4, 8).toString("ascii") !== "ftyp") {
-      throw routeError("generated video input must be an MP4 container", 400);
-    }
-  } finally {
-    await fh.close();
-  }
-}
-
-export async function extractVideoFrame(input: string, output: string, position: string): Promise<void> {
-  const options = { timeout: FFMPEG_TIMEOUT_MS, killSignal: "SIGKILL" as const, maxBuffer: 1024 * 1024 };
-  if (position === "last") {
-    await execFileAsync("ffmpeg", ["-y", "-sseof", "-3", "-i", input, "-update", "1", "-q:v", "1", output], options);
-    return;
-  }
-  const sec = Number(position);
-  if (!Number.isFinite(sec) || sec < 0) throw new Error("position must be a non-negative number or 'last'");
-  if (sec > MAX_FRAME_POSITION_SECONDS) throw new Error("position exceeds the maximum supported seek time");
-  await execFileAsync("ffmpeg", ["-y", "-ss", String(sec), "-i", input, "-vframes", "1", output], options);
-}
-
-export async function extractGeneratedVideoFrameB64(generatedDir: string, filename: string, position = "last"): Promise<string> {
-  const inputPath = await safeGeneratedFilePath(generatedDir, filename, { requireMp4: true });
-  await assertLocalMp4(inputPath);
-  const tmpOut = join(generatedDir, `frame_tmp_${randomBytes(4).toString("hex")}.png`);
-  try {
-    await extractVideoFrame(inputPath, tmpOut, position);
-    return (await readFile(tmpOut)).toString("base64");
-  } finally {
-    await unlink(tmpOut).catch(() => {});
-  }
-}

package/lib/videoSeriesChain.ts

@@ -1,29 +0,0 @@
-import { readdir, readFile } from "fs/promises";
-import { join } from "path";
-
-interface VideoSeriesMeta {
-  revisedPrompt?: string;
-  createdAt?: number;
-  videoSeries?: { topic: string; chainIndex?: number };
-}
-
-/**
- * Scan generatedDir for videos with matching topic, return the most recent N revisedPrompts.
- */
-export async function getVideoSeriesChain(generatedDir: string, topic: string, limit = 4): Promise<string[]> {
-  if (!topic.trim()) return [];
-  const entries = await readdir(generatedDir).catch(() => [] as string[]);
-  const sidecars = entries.filter((e) => e.endsWith(".mp4.json"));
-  const matches: Array<{ revisedPrompt: string; createdAt: number }> = [];
-  for (const sidecar of sidecars) {
-    try {
-      const raw = await readFile(join(generatedDir, sidecar), "utf-8");
-      const meta: VideoSeriesMeta = JSON.parse(raw);
-      if (meta.videoSeries?.topic === topic && meta.revisedPrompt) {
-        matches.push({ revisedPrompt: meta.revisedPrompt, createdAt: meta.createdAt ?? 0 });
-      }
-    } catch { /* skip unreadable */ }
-  }
-  matches.sort((a, b) => b.createdAt - a.createdAt);
-  return matches.slice(0, limit).reverse().map((m) => m.revisedPrompt);
-}

package/lib/visibleTextLanguagePolicy.ts

@@ -1,7 +0,0 @@
-export const VISIBLE_TEXT_LANGUAGE_POLICY = [
-  "Visible text and language rule:",
-  "If the image must contain readable text, signage, labels, UI copy, captions, slogans, typography, or keywords in a specific language, explicitly list the exact visible words in that language and script.",
-  "Do not translate, romanize, summarize, substitute, or invent alternate wording.",
-  "Do not use vague placeholders such as \"Korean text\", \"Japanese words\", or \"foreign language text\".",
-  "If exact words are needed, state them as exact visible text items and render only those listed items.",
-].join(" ");

package/routes/agent.ts

@@ -1,308 +0,0 @@
-import type { Express, Request, Response } from "express";
-import {
-  appendAgentTurn,
-  compactAgentSession,
-  createAgentSession,
-  deleteAgentSession,
-  getAgentGenerationSettings,
-  getAgentSession,
-  getAgentWorkspacePayload,
-  renameAgentSession,
-  setAgentCurrentImage,
-  setAgentGenerationSettings,
-  setAgentLocks,
-  setAgentWebSearch,
-} from "../lib/agentStore.js";
-import {
-  cancelAgentQueueItem,
-  createAgentQueueItem,
-  getAgentQueueItem,
-  listAgentQueueItems,
-  retryAgentQueueItem,
-} from "../lib/agentQueueStore.js";
-import { ensureAgentQueueWorker, tickAgentQueueWorker } from "../lib/agentQueueWorker.js";
-import { parseAgentSlashCommand, formatAgentQuestionReply, formatAgentSlashHelp } from "../lib/agentCommandParser.js";
-import { requestAgentQuestionAnswer } from "../lib/agentQuestionResponder.js";
-import { agentAllowedToolPayload, runAgentTurn } from "../lib/agentRuntime.js";
-import { errInfo } from "../lib/errInfo.js";
-import { requireRuntimeContext, type RouteRuntimeContext } from "../lib/runtimeContext.js";
-
-type AgentSessionBody = {
-  title?: unknown;
-  currentImage?: unknown;
-  webSearchEnabled?: unknown;
-  currentImageId?: unknown;
-  styleLocks?: unknown;
-  subjectLocks?: unknown;
-  generationSettings?: unknown;
-};
-
-type AgentTurnBody = {
-  prompt?: unknown;
-  provider?: unknown;
-  quality?: unknown;
-  size?: unknown;
-  format?: unknown;
-  moderation?: unknown;
-  model?: unknown;
-  reasoningEffort?: unknown;
-  requestId?: unknown;
-};
-
-type AgentQueueBody = AgentTurnBody & {
-  options?: unknown;
-};
-
-export function registerAgentRoutes(app: Express, ctxRaw: RouteRuntimeContext) {
-  const ctx = requireRuntimeContext(ctxRaw);
-  ensureAgentQueueWorker(ctx);
-
-  app.get("/api/agent/tools", (_req: Request, res: Response) => {
-    res.json(agentAllowedToolPayload());
-  });
-
-  app.get("/api/agent/sessions", (req: Request, res: Response) => {
-    const selectedId = typeof req.query.selectedSessionId === "string" ? req.query.selectedSessionId : null;
-    res.json(getAgentWorkspacePayload(selectedId));
-  });
-
-  app.post("/api/agent/sessions", (req: Request, res: Response) => {
-    try {
-      const body = (req.body ?? {}) as AgentSessionBody;
-      const session = createAgentSession({
-        title: body.title,
-        currentImage: normalizeCurrentImage(body.currentImage),
-        webSearchEnabled: body.webSearchEnabled !== false,
-      });
-      res.status(201).json(getAgentWorkspacePayload(session.id));
-    } catch (error) {
-      sendError(res, error);
-    }
-  });
-
-  app.get("/api/agent/sessions/:sessionId", (req: Request<{ sessionId: string }>, res: Response) => {
-    const session = getAgentSession(req.params.sessionId);
-    if (!session) return sendError(res, notFound(req.params.sessionId));
-    res.json(getAgentWorkspacePayload(req.params.sessionId));
-  });
-
-  app.patch("/api/agent/sessions/:sessionId", (req: Request<{ sessionId: string }>, res: Response) => {
-    try {
-      const body = (req.body ?? {}) as AgentSessionBody;
-      if (Object.prototype.hasOwnProperty.call(body, "title")) renameAgentSession(req.params.sessionId, body.title);
-      if (typeof body.webSearchEnabled === "boolean") setAgentWebSearch(req.params.sessionId, body.webSearchEnabled);
-      if (Object.prototype.hasOwnProperty.call(body, "generationSettings")) {
-        setAgentGenerationSettings(req.params.sessionId, body.generationSettings);
-      }
-      if (Object.prototype.hasOwnProperty.call(body, "currentImageId")) {
-        const ok = setAgentCurrentImage(req.params.sessionId, body.currentImageId);
-        if (!ok) throw imageNotFound(req.params.sessionId);
-      }
-      if (Array.isArray(body.styleLocks) || Array.isArray(body.subjectLocks)) setAgentLocks(req.params.sessionId, body);
-      res.json(getAgentWorkspacePayload(req.params.sessionId));
-    } catch (error) {
-      sendError(res, error);
-    }
-  });
-
-  app.delete("/api/agent/sessions/:sessionId", (req: Request<{ sessionId: string }>, res: Response) => {
-    const ok = deleteAgentSession(req.params.sessionId);
-    if (!ok) return sendError(res, notFound(req.params.sessionId));
-    res.json(getAgentWorkspacePayload(null));
-  });
-
-  app.post("/api/agent/sessions/:sessionId/compact", (req: Request<{ sessionId: string }>, res: Response) => {
-    try {
-      if (!getAgentSession(req.params.sessionId)) throw notFound(req.params.sessionId);
-      compactAgentSession(req.params.sessionId);
-      res.json(getAgentWorkspacePayload(req.params.sessionId));
-    } catch (error) {
-      sendError(res, error);
-    }
-  });
-
-  app.get("/api/agent/sessions/:sessionId/manifest", (req: Request<{ sessionId: string }>, res: Response) => {
-    const payload = getAgentWorkspacePayload(req.params.sessionId);
-    if (!payload.selectedSessionId) return sendError(res, notFound(req.params.sessionId));
-    res.type("application/xml").send(payload.manifest ?? "");
-  });
-
-  app.post("/api/agent/sessions/:sessionId/turns", async (req: Request<{ sessionId: string }>, res: Response) => {
-    try {
-      const body = (req.body ?? {}) as AgentTurnBody;
-      const prompt = cleanPrompt(body.prompt);
-      await runAgentTurn(ctx, req.params.sessionId, prompt, {
-        provider: cleanOption(body.provider),
-        quality: cleanOption(body.quality),
-        size: cleanOption(body.size),
-        format: cleanOption(body.format),
-        moderation: cleanOption(body.moderation),
-        model: cleanOption(body.model),
-        reasoningEffort: cleanOption(body.reasoningEffort),
-        requestId: cleanOption(body.requestId),
-      });
-      res.json(getAgentWorkspacePayload(req.params.sessionId));
-    } catch (error) {
-      sendError(res, error);
-    }
-  });
-
-  app.get("/api/agent/queue", (_req: Request, res: Response) => {
-    res.json({ queue: listAgentQueueItems() });
-  });
-
-  app.get("/api/agent/sessions/:sessionId/queue", (req: Request<{ sessionId: string }>, res: Response) => {
-    if (!getAgentSession(req.params.sessionId)) return sendError(res, notFound(req.params.sessionId));
-    res.json({ queue: listAgentQueueItems(req.params.sessionId) });
-  });
-
-  app.post("/api/agent/sessions/:sessionId/queue", async (req: Request<{ sessionId: string }>, res: Response) => {
-    try {
-      if (!getAgentSession(req.params.sessionId)) throw notFound(req.params.sessionId);
-      const body = (req.body ?? {}) as AgentQueueBody;
-      const rawPrompt = cleanPrompt(body.prompt);
-      const command = parseAgentSlashCommand(rawPrompt);
-      appendAgentTurn({ sessionId: req.params.sessionId, role: "user", text: rawPrompt, status: "complete" });
-      if (command?.name === "help") {
-        appendAgentTurn({
-          sessionId: req.params.sessionId,
-          role: "assistant",
-          text: formatAgentSlashHelp(),
-          status: "complete",
-        });
-        return res.status(200).json({ queueItem: null, workspace: getAgentWorkspacePayload(req.params.sessionId) });
-      }
-      if (command?.name === "question") {
-        const options = normalizeQueueOptions(req.params.sessionId, body);
-        const question = command.prompt.trim();
-        const answer = question
-          ? (await requestAgentQuestionAnswer(ctx, question, {
-              provider: cleanOption(options.provider),
-              model: cleanOption(options.model),
-              reasoningEffort: cleanOption(options.reasoningEffort),
-              requestId: cleanOption(body.requestId),
-            })).text
-          : formatAgentQuestionReply(command.prompt);
-        appendAgentTurn({
-          sessionId: req.params.sessionId,
-          role: "assistant",
-          text: answer,
-          status: "complete",
-        });
-        return res.status(200).json({ queueItem: null, workspace: getAgentWorkspacePayload(req.params.sessionId) });
-      }
-      const prompt = command ? cleanPrompt(command.prompt) : rawPrompt;
-      const queueItem = createAgentQueueItem({
-        sessionId: req.params.sessionId,
-        prompt,
-        options: normalizeQueueOptions(req.params.sessionId, body),
-        command,
-      });
-      void tickAgentQueueWorker(ctx);
-      res.status(202).json({ queueItem, workspace: getAgentWorkspacePayload(req.params.sessionId) });
-    } catch (error) {
-      sendError(res, error);
-    }
-  });
-
-  app.post("/api/agent/queue/:itemId/cancel", (req: Request<{ itemId: string }>, res: Response) => {
-    const item = getAgentQueueItem(req.params.itemId);
-    if (!item) return sendError(res, queueItemNotFound(req.params.itemId));
-    const ok = cancelAgentQueueItem(item.id);
-    if (!ok) return sendError(res, queueActionError("AGENT_QUEUE_CANCEL_FAILED", "Only queued Agent work can be canceled."));
-    res.json(getAgentWorkspacePayload(item.sessionId));
-  });
-
-  app.post("/api/agent/queue/:itemId/retry", (req: Request<{ itemId: string }>, res: Response) => {
-    const item = getAgentQueueItem(req.params.itemId);
-    if (!item) return sendError(res, queueItemNotFound(req.params.itemId));
-    const ok = retryAgentQueueItem(item.id);
-    if (!ok) return sendError(res, queueActionError("AGENT_QUEUE_RETRY_FAILED", "Only failed or canceled Agent work can be retried."));
-    void tickAgentQueueWorker(ctx);
-    res.json(getAgentWorkspacePayload(item.sessionId));
-  });
-}
-
-function normalizeCurrentImage(value: unknown) {
-  if (!value || typeof value !== "object") return null;
-  const item = value as Record<string, unknown>;
-  return {
-    id: cleanOption(item.id),
-    filename: cleanOption(item.filename),
-    url: cleanOption(item.url) ?? cleanOption(item.image),
-    thumbUrl: cleanOption(item.thumbUrl) ?? cleanOption(item.thumb),
-    prompt: cleanOption(item.prompt) ?? cleanOption(item.userPrompt),
-    revisedPrompt: cleanOption(item.revisedPrompt),
-    createdAt: typeof item.createdAt === "number" ? item.createdAt : null,
-  };
-}
-
-function cleanOption(value: unknown) {
-  return typeof value === "string" && value.trim() ? value.trim() : undefined;
-}
-
-function cleanPrompt(value: unknown) {
-  const prompt = cleanOption(value);
-  if (prompt) return prompt;
-  const err = new Error("Prompt is required") as Error & { code?: string; status?: number };
-  err.code = "AGENT_PROMPT_REQUIRED";
-  err.status = 400;
-  throw err;
-}
-
-function normalizeQueueOptions(sessionId: string, body: AgentQueueBody) {
-  const current = getAgentGenerationSettings(sessionId);
-  const input = body.options && typeof body.options === "object" ? body.options as Record<string, unknown> : {};
-  return {
-    ...current,
-    ...input,
-    provider: cleanOption(body.provider) ?? input.provider ?? current.provider,
-    quality: cleanOption(body.quality) ?? input.quality ?? current.quality,
-    size: cleanOption(body.size) ?? input.size ?? current.size,
-    format: cleanOption(body.format) ?? input.format ?? current.format,
-    moderation: cleanOption(body.moderation) ?? input.moderation ?? current.moderation,
-    model: cleanOption(body.model) ?? input.model ?? current.model,
-    reasoningEffort: cleanOption(body.reasoningEffort) ?? input.reasoningEffort ?? current.reasoningEffort,
-    webSearchEnabled: typeof input.webSearchEnabled === "boolean" ? input.webSearchEnabled : current.webSearchEnabled,
-    generationStrategy: input.generationStrategy ?? current.generationStrategy,
-    variants: input.variants ?? current.variants,
-    maxAutoVariants: input.maxAutoVariants ?? current.maxAutoVariants,
-    parallelism: input.parallelism ?? current.parallelism,
-  };
-}
-
-function queueActionError(code: string, message: string) {
-  const err = new Error(message) as Error & { code?: string; status?: number };
-  err.code = code;
-  err.status = 409;
-  return err;
-}
-
-function queueItemNotFound(itemId: string) {
-  const err = new Error(`Agent queue item not found: ${itemId}`) as Error & { code?: string; status?: number };
-  err.code = "AGENT_QUEUE_ITEM_NOT_FOUND";
-  err.status = 404;
-  return err;
-}
-
-function sendError(res: Response, error: unknown) {
-  const err = errInfo(error);
-  res.status(err.status || 500).json({
-    error: { code: err.code || "AGENT_ERROR", message: err.message },
-    code: err.code || "AGENT_ERROR",
-  });
-}
-
-function notFound(sessionId: string) {
-  const err = new Error(`Agent session not found: ${sessionId}`) as Error & { code?: string; status?: number };
-  err.code = "AGENT_SESSION_NOT_FOUND";
-  err.status = 404;
-  return err;
-}
-
-function imageNotFound(sessionId: string) {
-  const err = new Error(`Agent image not found in session: ${sessionId}`) as Error & { code?: string; status?: number };
-  err.code = "AGENT_IMAGE_NOT_FOUND";
-  err.status = 404;
-  return err;
-}

package/routes/annotations.ts

@@ -1,118 +0,0 @@
-import type { Express, Request, Response } from "express";
-import { getDb } from "../lib/db.js";
-
-import { errInfo } from "../lib/errInfo.js";
-import type { RouteRuntimeContext } from "../lib/runtimeContext.js";
-const MAX_ANNOTATION_PAYLOAD_CHARS = 256 * 1024;
-
-function getBrowserId(req: Request): string | null {
-  const browserId = req.headers["x-ima2-browser-id"];
-  return typeof browserId === "string" && browserId.trim() ? browserId.trim() : null;
-}
-
-function isSafeFilename(filename: unknown): filename is string {
-  return (
-    typeof filename === "string" &&
-    filename.length > 0 &&
-    filename.length <= 240 &&
-    !filename.includes("..") &&
-    !filename.startsWith("/") &&
-    !filename.includes("\\")
-  );
-}
-
-interface AnnotationPayload {
-  paths?: unknown;
-  boxes?: unknown;
-  memos?: unknown;
-  annotations?: AnnotationPayload;
-}
-
-interface NormalizedPayload {
-  payload?: { paths: unknown[]; boxes: unknown[]; memos: unknown[] };
-  text?: string;
-  error?: string;
-}
-
-function normalizePayload(value: unknown): NormalizedPayload {
-  const v = value as AnnotationPayload | null | undefined;
-  const payload = (v && typeof v === "object" && "annotations" in v ? v.annotations : v) as
-    | AnnotationPayload
-    | null
-    | undefined;
-  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
-    return { error: "annotations payload is required" };
-  }
-  const paths = Array.isArray(payload.paths) ? payload.paths : [];
-  const boxes = Array.isArray(payload.boxes) ? payload.boxes : [];
-  const memos = Array.isArray(payload.memos) ? payload.memos : [];
-  const normalized = { paths, boxes, memos };
-  const text = JSON.stringify(normalized);
-  if (text.length > MAX_ANNOTATION_PAYLOAD_CHARS) {
-    return { error: "annotations payload is too large" };
-  }
-  return { payload: normalized, text };
-}
-
-export function registerAnnotationRoutes(app: Express, _ctx: RouteRuntimeContext) {
-  app.get("/api/annotations/:filename", (req: Request<{ filename: string }>, res: Response) => {
-    try {
-      const browserId = getBrowserId(req);
-      const filename = decodeURIComponent(req.params.filename);
-      if (!browserId) return res.status(400).json({ error: "X-Ima2-Browser-Id header is required" });
-      if (!isSafeFilename(filename)) return res.status(400).json({ error: "invalid filename" });
-
-      const row = getDb()
-        .prepare("SELECT payload FROM image_annotations WHERE browser_id = ? AND filename = ?")
-        .get(browserId, filename) as { payload: string } | undefined;
-      const annotations = row ? JSON.parse(row.payload) : null;
-      res.json({ annotations });
-    } catch (e) {
-      const err = errInfo(e);
-      res.status(500).json({ error: err.message });
-    }
-  });
-
-  app.put("/api/annotations/:filename", (req: Request<{ filename: string }>, res: Response) => {
-    try {
-      const browserId = getBrowserId(req);
-      const filename = decodeURIComponent(req.params.filename);
-      if (!browserId) return res.status(400).json({ error: "X-Ima2-Browser-Id header is required" });
-      if (!isSafeFilename(filename)) return res.status(400).json({ error: "invalid filename" });
-
-      const normalized = normalizePayload(req.body);
-      if (normalized.error) return res.status(400).json({ error: normalized.error });
-
-      const id = `${browserId}:${filename}`;
-      getDb().prepare(`
-        INSERT INTO image_annotations (id, browser_id, filename, payload, schema_version, updated_at)
-        VALUES (?, ?, ?, ?, 1, unixepoch())
-        ON CONFLICT(browser_id, filename) DO UPDATE SET
-          payload = excluded.payload,
-          schema_version = excluded.schema_version,
-          updated_at = unixepoch()
-      `).run(id, browserId, filename, normalized.text);
-      res.json({ ok: true });
-    } catch (e) {
-      const err = errInfo(e);
-      res.status(500).json({ error: err.message });
-    }
-  });
-
-  app.delete("/api/annotations/:filename", (req: Request<{ filename: string }>, res: Response) => {
-    try {
-      const browserId = getBrowserId(req);
-      const filename = decodeURIComponent(req.params.filename);
-      if (!browserId) return res.status(400).json({ error: "X-Ima2-Browser-Id header is required" });
-      if (!isSafeFilename(filename)) return res.status(400).json({ error: "invalid filename" });
-
-      getDb()
-        .prepare("DELETE FROM image_annotations WHERE browser_id = ? AND filename = ?")
-        .run(browserId, filename);
-      res.json({ ok: true });
-    } catch (e) {
-      const err = errInfo(e);
-      res.status(500).json({ error: err.message });
-    }
-  });
-}

package/routes/canvasVersions.ts

@@ -1,69 +0,0 @@
-import express, { type Express, type Request, type Response } from "express";
-import { createCanvasVersion, updateCanvasVersion } from "../lib/canvasVersionStore.js";
-
-import { errInfo } from "../lib/errInfo.js";
-import { requireRuntimeContext, type RouteRuntimeContext } from "../lib/runtimeContext.js";
-function decodeHeader(value: unknown): string | null {
-  if (typeof value !== "string" || !value) return null;
-  try {
-    return decodeURIComponent(value);
-  } catch {
-    return value;
-  }
-}
-
-function getRequestBuffer(req: Request): Buffer {
-  return Buffer.isBuffer(req.body) ? req.body : Buffer.alloc(0);
-}
-
-function getPrompt(req: Request): string | null {
-  return decodeHeader(req.headers["x-ima2-canvas-prompt"]);
-}
-
-export function registerCanvasVersionRoutes(app: Express, ctxRaw: RouteRuntimeContext) {
-  const ctx = requireRuntimeContext(ctxRaw);
-  const rawPng = express.raw({ type: "image/png", limit: ctx.config.server.bodyLimit });
-
-  app.post("/api/canvas-versions", rawPng, async (req: Request, res: Response) => {
-    try {
-      const sourceFilename =
-        typeof req.query.sourceFilename === "string"
-          ? req.query.sourceFilename
-          : decodeHeader(req.headers["x-ima2-canvas-source-filename"]);
-      const item = await createCanvasVersion(ctx, {
-        sourceFilename,
-        prompt: getPrompt(req),
-        buffer: getRequestBuffer(req),
-      });
-      res.status(201).json({ item });
-    } catch (e) {
-      const err = errInfo(e);
-      res.status(err.status || 500).json({
-        error: err.message,
-        code: err.code || "CANVAS_VERSION_SAVE_FAILED",
-      });
-    }
-  });
-
-  app.put("/api/canvas-versions/:filename", rawPng, async (req: Request<{ filename: string }>, res: Response) => {
-    try {
-      const filename = decodeURIComponent(req.params.filename);
-      const sourceFilename =
-        typeof req.query.sourceFilename === "string"
-          ? req.query.sourceFilename
-          : decodeHeader(req.headers["x-ima2-canvas-source-filename"]);
-      const item = await updateCanvasVersion(ctx, filename, {
-        sourceFilename,
-        prompt: getPrompt(req),
-        buffer: getRequestBuffer(req),
-      });
-      res.json({ item });
-    } catch (e) {
-      const err = errInfo(e);
-      res.status(err.status || 500).json({
-        error: err.message,
-        code: err.code || "CANVAS_VERSION_SAVE_FAILED",
-      });
-    }
-  });
-}

package/routes/capabilities.ts

@@ -1,18 +0,0 @@
-import type { Express, Request, Response } from "express";
-import { buildIma2Capabilities } from "../lib/capabilities.js";
-import { requireRuntimeContext, type RouteRuntimeContext } from "../lib/runtimeContext.js";
-
-export function registerCapabilitiesRoutes(app: Express, ctxRaw: RouteRuntimeContext) {
-  const ctx = requireRuntimeContext(ctxRaw);
-
-  app.get("/api/capabilities", (_req: Request, res: Response) => {
-    res.json(
-      buildIma2Capabilities({
-        appConfig: ctx.config,
-        packageVersion: ctx.packageVersion,
-        source: "server",
-        server: ctx.serverUrl || `http://localhost:${ctx.serverActualPort || ctx.config.server.port}`,
-      }),
-    );
-  });
-}