ima2-gen 1.1.21 → 1.1.23

package/lib/inflight.ts

@@ -1,281 +0,0 @@
-import { config } from "../config.js";
-import { getDb } from "./db.js";
-import { logEvent } from "./logger.js";
-
-// SQLite-backed inflight job registry.
-// Tracks generation requests that are currently running on the server so clients
-// can reconcile optimistic UI state after a reload or across tabs.
-//
-// A restarted process cannot continue the original upstream fetch, but keeping
-// metadata durable lets the UI reconcile requestIds and eventually prune stale
-// work without losing the recovery breadcrumb.
-
-interface InflightRow {
-  request_id: string;
-  kind: string;
-  prompt?: string | null;
-  meta?: string | null;
-  session_id?: string | null;
-  parent_node_id?: string | null;
-  client_node_id?: string | null;
-  started_at: number;
-  phase?: string | null;
-  phase_at?: number | null;
-}
-
-interface InflightJob {
-  requestId: string;
-  kind: string;
-  prompt: string;
-  meta: Record<string, unknown>;
-  startedAt: number;
-  phase: string;
-  phaseAt: number;
-}
-
-interface TerminalJob {
-  requestId: string;
-  kind: string;
-  status: string;
-  startedAt: number;
-  finishedAt: number;
-  durationMs: number;
-  phase: string;
-  phaseAt: number;
-  httpStatus?: number | undefined;
-  errorCode?: string | undefined;
-  prompt?: string | null;
-  meta: Record<string, unknown>;
-}
-
-const terminalJobs = new Map<string, TerminalJob>(); // requestId -> terminal snapshot, active-only API stays default
-const abortControllers = new Map<string, AbortController>();
-
-// Phases: "queued" → "streaming" (upstream connection open, waiting for image)
-//                 → "decoding" (b64 received, writing to disk)
-export function startJob({ requestId, kind, prompt, meta = {} }: {
-  requestId: string;
-  kind: string;
-  prompt?: string | null;
-  meta?: Record<string, unknown>;
-}) {
-  if (!requestId) return;
-  const startedAt = Date.now();
-  const normalizedPrompt = typeof prompt === "string" ? prompt.slice(0, 500) : "";
-  const normalizedMeta = normalizeMeta(meta);
-  getDb()
-    .prepare(`
-      INSERT OR REPLACE INTO inflight (
-        request_id,
-        kind,
-        prompt,
-        meta,
-        session_id,
-        parent_node_id,
-        client_node_id,
-        started_at,
-        phase,
-        phase_at
-      )
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `)
-    .run(
-      requestId,
-      kind,
-      normalizedPrompt,
-      JSON.stringify(normalizedMeta),
-      stringOrNull(normalizedMeta.sessionId),
-      stringOrNull(normalizedMeta.parentNodeId),
-      stringOrNull(normalizedMeta.clientNodeId),
-      startedAt,
-      "queued",
-      startedAt,
-    );
-  terminalJobs.delete(requestId);
-  abortControllers.delete(requestId);
-  logEvent("inflight", "start", {
-    requestId,
-    kind,
-    sessionId: normalizedMeta.sessionId || null,
-    parentNodeId: normalizedMeta.parentNodeId || null,
-    clientNodeId: normalizedMeta.clientNodeId || null,
-    promptChars: typeof prompt === "string" ? prompt.length : 0,
-  });
-}
-
-export function registerJobAbortController(
-  requestId: string | null | undefined,
-  controller: AbortController,
-) {
-  if (!requestId) return;
-  abortControllers.set(requestId, controller);
-}
-
-export function abortJob(requestId: string | null | undefined) {
-  if (!requestId) return { requestId: "", active: false, aborted: false };
-  const controller = abortControllers.get(requestId);
-  const active = Boolean(getJob(requestId));
-  let aborted = false;
-  if (controller && !controller.signal.aborted) {
-    controller.abort();
-    aborted = true;
-  }
-  finishJob(requestId, {
-    canceled: true,
-    httpStatus: 499,
-    errorCode: "GENERATION_CANCELED",
-  });
-  return { requestId, active, aborted };
-}
-
-export function isJobCanceled(requestId: string | null | undefined): boolean {
-  if (!requestId) return false;
-  return terminalJobs.get(requestId)?.status === "canceled";
-}
-
-export function setJobPhase(requestId: string | null | undefined, phase: string) {
-  if (!requestId) return;
-  const j = getJob(requestId);
-  if (!j) return;
-  getDb()
-    .prepare("UPDATE inflight SET phase = ?, phase_at = ? WHERE request_id = ?")
-    .run(phase, Date.now(), requestId);
-  logEvent("inflight", "phase", { requestId, kind: j.kind, phase });
-}
-
-export function finishJob(requestId: string | null | undefined, options: any = {}) {
-  if (!requestId) return;
-  const j = getJob(requestId);
-  if (j) {
-    const finishedAt = Date.now();
-    const status = options.canceled ? "canceled" : options.status || "completed";
-    terminalJobs.set(requestId, {
-      requestId,
-      kind: j.kind,
-      status,
-      startedAt: j.startedAt,
-      finishedAt,
-      durationMs: finishedAt - j.startedAt,
-      phase: j.phase,
-      phaseAt: j.phaseAt,
-      httpStatus: options.httpStatus,
-      errorCode: options.errorCode,
-      meta: {
-        ...j.meta,
-        ...(options.meta || {}),
-      },
-    });
-    logEvent("inflight", "finish", {
-      requestId,
-      kind: j.kind,
-      status,
-      durationMs: finishedAt - j.startedAt,
-      httpStatus: options.httpStatus,
-      errorCode: options.errorCode,
-    });
-  }
-  getDb().prepare("DELETE FROM inflight WHERE request_id = ?").run(requestId);
-  abortControllers.delete(requestId);
-  reapTerminalJobs();
-}
-
-function reapTerminalJobs() {
-  const now = Date.now();
-  for (const [id, j] of terminalJobs) {
-    if (now - j.finishedAt > config.inflight.terminalTtlMs) terminalJobs.delete(id);
-  }
-}
-
-export function listJobs(filters: any = {}) {
-  purgeStaleJobs();
-  const { kind, sessionId } = filters;
-  const clauses: string[] = [];
-  const params: unknown[] = [];
-  if (kind) {
-    clauses.push("kind = ?");
-    params.push(kind);
-  }
-  if (sessionId) {
-    clauses.push("session_id = ?");
-    params.push(sessionId);
-  }
-  const where = clauses.length ? ` WHERE ${clauses.join(" AND ")}` : "";
-  return getDb()
-    .prepare(`SELECT * FROM inflight${where} ORDER BY started_at ASC`)
-    .all(...params)
-    .map((row) => rowToJob(row as InflightRow));
-}
-
-export function listTerminalJobs(filters: any = {}) {
-  reapTerminalJobs();
-  const { kind, sessionId } = filters;
-  return Array.from(terminalJobs.values())
-    .filter((j) => {
-      if (kind && j.kind !== kind) return false;
-      if (sessionId && j.meta?.sessionId !== sessionId) return false;
-      return true;
-    })
-    .sort((a, b) => b.finishedAt - a.finishedAt);
-}
-
-export function _resetForTests() {
-  getDb().prepare("DELETE FROM inflight").run();
-  terminalJobs.clear();
-  abortControllers.clear();
-}
-
-export function purgeStaleJobs(now = Date.now()) {
-  getDb()
-    .prepare("DELETE FROM inflight WHERE started_at < ?")
-    .run(now - config.inflight.ttlMs);
-}
-
-function getJob(requestId: string): InflightJob | null {
-  const row = getDb()
-    .prepare("SELECT * FROM inflight WHERE request_id = ?")
-    .get(requestId) as InflightRow | undefined;
-  return row ? rowToJob(row) : null;
-}
-
-function rowToJob(row: InflightRow): InflightJob {
-  const meta = normalizeMeta(parseMeta(row.meta));
-  const sessionId = stringOrNull(row.session_id) ?? stringOrNull(meta.sessionId);
-  const parentNodeId =
-    stringOrNull(row.parent_node_id) ?? stringOrNull(meta.parentNodeId);
-  const clientNodeId =
-    stringOrNull(row.client_node_id) ?? stringOrNull(meta.clientNodeId);
-  return {
-    requestId: row.request_id,
-    kind: row.kind,
-    prompt: row.prompt || "",
-    meta: {
-      ...meta,
-      ...(sessionId ? { sessionId } : {}),
-      ...(parentNodeId ? { parentNodeId } : {}),
-      ...(clientNodeId ? { clientNodeId } : {}),
-    },
-    startedAt: Number(row.started_at),
-    phase: row.phase || "queued",
-    phaseAt: Number(row.phase_at || row.started_at),
-  };
-}
-
-function parseMeta(raw: unknown): Record<string, unknown> {
-  if (typeof raw !== "string" || !raw) return {};
-  try {
-    const parsed: unknown = JSON.parse(raw);
-    return parsed && typeof parsed === "object" && !Array.isArray(parsed)
-      ? (parsed as Record<string, unknown>)
-      : {};
-  } catch {
-    return {};
-  }
-}
-
-function normalizeMeta(meta: unknown): Record<string, unknown> {
-  return meta && typeof meta === "object" && !Array.isArray(meta) ? (meta as Record<string, unknown>) : {};
-}
-
-function stringOrNull(value: unknown): string | null {
-  return typeof value === "string" && value.length > 0 ? value : null;
-}

package/lib/localImportStore.ts

@@ -1,114 +0,0 @@
-import type { RuntimeContext } from "./runtimeContext.js";
-import { mkdir, writeFile } from "fs/promises";
-import { basename, join, normalize } from "path";
-import { randomBytes } from "crypto";
-import { embedImageMetadataBestEffort } from "./imageMetadataStore.js";
-import { invalidateHistoryIndex } from "./historyIndex.js";
-
-const PNG_SIGNATURE_HEX = "89504e470d0a1a0a";
-const JPEG_SIGNATURE_HEX = "ffd8ff";
-const WEBP_RIFF_HEAD = "52494646";
-const WEBP_VP_TAIL = "57454250";
-
-function detectFormat(buffer: Buffer) {
-  if (!Buffer.isBuffer(buffer) || buffer.length < 12) return null;
-  const head8 = buffer.subarray(0, 8).toString("hex");
-  if (head8 === PNG_SIGNATURE_HEX) return "png";
-  if (head8.startsWith(JPEG_SIGNATURE_HEX)) return "jpeg";
-  if (
-    buffer.subarray(0, 4).toString("hex") === WEBP_RIFF_HEAD &&
-    buffer.subarray(8, 12).toString("hex") === WEBP_VP_TAIL
-  ) {
-    return "webp";
-  }
-  return null;
-}
-
-function ensureInsideGeneratedDir(generatedDir: string, filename: string) {
-  const full = normalize(join(generatedDir, filename));
-  const root = normalize(generatedDir);
-  if (!full.startsWith(root)) {
-    const err: any = new Error("Imported path escapes generated directory");
-    err.status = 400;
-    err.code = "IMPORT_PATH_ESCAPE";
-    throw err;
-  }
-  return full;
-}
-
-function makeImportedFilename(format: string) {
-  const stamp = new Date().toISOString().slice(0, 19).replace(/[-:T]/g, "");
-  const rand = randomBytes(3).toString("hex");
-  return `imported-${stamp}-${rand}.${format}`;
-}
-
-function safeOriginalName(input: unknown) {
-  if (typeof input !== "string" || !input) return null;
-  const trimmed = input.slice(0, 200);
-  return basename(trimmed);
-}
-
-export async function createLocalImport(ctx: RuntimeContext, { buffer, originalFilename }: { buffer: Buffer; originalFilename?: string | null }) {
-  if (!Buffer.isBuffer(buffer) || buffer.length === 0) {
-    const err: any = new Error("Image body is required");
-    err.status = 400;
-    err.code = "EMPTY_IMPORT";
-    throw err;
-  }
-  const format = detectFormat(buffer);
-  if (!format) {
-    const err: any = new Error("Only PNG, JPEG, or WebP is supported");
-    err.status = 400;
-    err.code = "IMPORT_BAD_FORMAT";
-    throw err;
-  }
-  const filename = makeImportedFilename(format);
-  const fullPath = ensureInsideGeneratedDir(ctx.config.storage.generatedDir, filename);
-  await mkdir(ctx.config.storage.generatedDir, { recursive: true });
-
-  const meta = {
-    schema: "ima2.generation.v1",
-    app: "ima2-gen",
-    version: ctx.packageVersion,
-    createdAt: Date.now(),
-    kind: "imported",
-    canvasVersion: false,
-    originalFilename: safeOriginalName(originalFilename),
-    format,
-  };
-  const embedded = await embedImageMetadataBestEffort(buffer, format, meta, {
-    version: ctx.packageVersion,
-  });
-  await writeFile(fullPath, embedded.buffer);
-  await writeFile(`${fullPath}.json`, JSON.stringify(meta)).catch(() => {});
-  invalidateHistoryIndex();
-
-  const url = `/generated/${encodeURIComponent(filename)}`;
-  return {
-    filename,
-    url,
-    image: url,
-    thumb: url,
-    createdAt: meta.createdAt,
-    format,
-    kind: "imported",
-    canvasVersion: false,
-    canvasSourceFilename: null,
-    canvasEditableFilename: null,
-    prompt: null,
-    userPrompt: null,
-    revisedPrompt: null,
-    promptMode: null,
-    quality: null,
-    size: null,
-    model: null,
-    provider: null,
-    usage: null,
-    webSearchCalls: 0,
-    sessionId: null,
-    nodeId: null,
-    parentNodeId: null,
-    refsCount: 0,
-    isFavorite: false,
-  };
-}

package/lib/logger.ts

@@ -1,161 +0,0 @@
-const REDACTED = "[redacted]";
-const MAX_VALUE_LEN = 240;
-const LOG_LEVELS = {
-  debug: 10,
-  info: 20,
-  warn: 30,
-  error: 40,
-  silent: 50,
-};
-
-const SECRET_KEYS = new Set([
-  "authorization",
-  "cookie",
-  "headers",
-  "apiKey",
-  "token",
-  "password",
-  "secret",
-  "body",
-  "prompt",
-  "effectivePrompt",
-  "userPrompt",
-  "revisedPrompt",
-  "textPrompt",
-  "styleSheet",
-  "style_sheet",
-  "image",
-  "imageB64",
-  "image_url",
-  "references",
-  "rawResponse",
-]);
-
-const ALLOWED_PROMPT_METRICS = new Set(["promptChars", "promptMode"]);
-
-type LogLevel = "debug" | "info" | "warn" | "error" | "silent";
-type LogSink = {
-  log?: (line: string) => void;
-  debug?: (line: string) => void;
-  info?: (line: string) => void;
-  warn?: (line: string) => void;
-  error?: (line: string) => void;
-};
-
-let activeLevel: LogLevel = "info";
-let activeSink: LogSink = console;
-
-function shouldRedactKey(key: string) {
-  if (ALLOWED_PROMPT_METRICS.has(key)) return false;
-  if (SECRET_KEYS.has(key)) return true;
-  const lower = key.toLowerCase();
-  return (
-    lower.includes("token") ||
-    lower.includes("authorization") ||
-    lower.includes("cookie") ||
-    lower.includes("apikey") ||
-    lower.includes("api_key") ||
-    lower.includes("secret") ||
-    lower.includes("b64") ||
-    lower.includes("base64") ||
-    lower.includes("dataurl")
-  );
-}
-
-function sanitizeValue(value: unknown): unknown {
-  if (value == null) return value;
-  if (value instanceof Error) return sanitizeError(value);
-  if (Array.isArray(value)) return `[array:${value.length}]`;
-  if (Buffer.isBuffer(value)) return `[buffer:${value.length}]`;
-  if (typeof value === "object") return "[object]";
-  if (typeof value === "string") {
-    const oneLine = value
-      .replace(/Bearer\s+[A-Za-z0-9._~+/=-]+/gi, "Bearer [redacted]")
-      .replace(/data:image\/[a-z0-9.+-]+;base64,[A-Za-z0-9+/=]+/gi, "data:image/[redacted]")
-      .replace(/\s+/g, " ")
-      .trim();
-    return oneLine.length > MAX_VALUE_LEN ? `${oneLine.slice(0, MAX_VALUE_LEN)}...` : oneLine;
-  }
-  return value;
-}
-
-export function sanitizeError(err: unknown) {
-  if (!err) return { message: "Unknown error" };
-  const e = err as { name?: string; code?: string; status?: number; message?: string };
-  return {
-    name: e.name || "Error",
-    code: e.code || undefined,
-    status: e.status || undefined,
-    message: sanitizeValue(e.message || "Unknown error"),
-  };
-}
-
-export function sanitizeFields(fields: Record<string, unknown> = {}) {
-  const out: Record<string, unknown> = {};
-  for (const [key, value] of Object.entries(fields)) {
-    out[key] = shouldRedactKey(key) ? REDACTED : sanitizeValue(value);
-  }
-  return out;
-}
-
-function formatValue(value: unknown): string | undefined {
-  if (value === undefined) return undefined;
-  if (value === null) return "null";
-  if (typeof value === "boolean" || typeof value === "number") return String(value);
-  return JSON.stringify(String(value));
-}
-
-export function formatLog(scope: string, event: string, fields: Record<string, unknown> = {}) {
-  const safeFields = sanitizeFields(fields);
-  const parts = Object.entries(safeFields)
-    .map(([key, value]) => {
-      const formatted = formatValue(value);
-      return formatted === undefined ? null : `${key}=${formatted}`;
-    })
-    .filter(Boolean);
-  return `[${scope}.${event}]${parts.length ? ` ${parts.join(" ")}` : ""}`;
-}
-
-export function normalizeLogLevel(level: unknown): LogLevel {
-  return typeof level === "string" && Object.hasOwn(LOG_LEVELS, level) ? (level as LogLevel) : "info";
-}
-
-export function configureLogger(options: { level?: unknown; sink?: LogSink } = {}) {
-  activeLevel = normalizeLogLevel(options.level);
-  activeSink = options.sink || console;
-}
-
-export function shouldLog(level: unknown) {
-  const normalized = normalizeLogLevel(level);
-  return LOG_LEVELS[normalized] >= LOG_LEVELS[activeLevel] && activeLevel !== "silent";
-}
-
-function writeLog(level: LogLevel, line: string) {
-  if (!shouldLog(level)) return;
-  const sink = activeSink as Record<string, ((line: string) => void) | undefined>;
-  const writer = sink[level] || sink.log || console.log;
-  writer.call(activeSink, line);
-}
-
-export function logDebug(scope: string, event: string, fields: Record<string, unknown> = {}) {
-  writeLog("debug", formatLog(scope, event, fields));
-}
-
-export function logEvent(scope: string, event: string, fields: Record<string, unknown> = {}) {
-  writeLog("info", formatLog(scope, event, fields));
-}
-
-export function logWarn(scope: string, event: string, fields: Record<string, unknown> = {}) {
-  writeLog("warn", formatLog(scope, event, fields));
-}
-
-export function logError(scope: string, event: string, err: unknown, fields: Record<string, unknown> = {}) {
-  const safe = sanitizeError(err);
-  writeLog("error", formatLog(scope, event, {
-    ...fields,
-    errorName: safe.name,
-    errorCode: safe.code,
-    errorStatus: safe.status,
-    errorMessage: safe.message,
-  }));
-}

package/lib/nodeStore.ts

@@ -1,91 +0,0 @@
-import { writeFile, readFile, access, mkdir } from "fs/promises";
-import { join, resolve, sep } from "path";
-import { randomBytes } from "crypto";
-import { config } from "../config.js";
-import { embedImageMetadataBestEffort } from "./imageMetadataStore.js";
-import { invalidateHistoryIndex } from "./historyIndex.js";
-
-export function newNodeId() {
-  return "n_" + randomBytes(config.ids.nodeHexBytes).toString("hex");
-}
-
-interface SaveNodeOptions {
-  nodeId: string;
-  b64: string;
-  meta: Record<string, unknown>;
-  ext?: string;
-  generatedDir?: string;
-}
-
-export async function saveNode(rootDir: string, { nodeId, b64, meta, ext = "png", generatedDir = config.storage.generatedDir }: SaveNodeOptions) {
-  void rootDir;
-  const filename = `${nodeId}.${ext}`;
-  await mkdir(generatedDir, { recursive: true });
-  const imageMeta = {
-    ...meta,
-    kind: meta?.kind || "node",
-    nodeId: meta?.nodeId || nodeId,
-    format: meta?.format || ext,
-  };
-  const rawBuffer = Buffer.from(b64, "base64");
-  const embedded = await embedImageMetadataBestEffort(rawBuffer, ext, imageMeta) as { embedded: boolean; warning?: string; buffer: Buffer };
-  if (!embedded.embedded) {
-    console.warn("[nodeStore] metadata embed skipped:", embedded.warning);
-  }
-  await writeFile(join(generatedDir, filename), embedded.buffer);
-  await writeFile(join(generatedDir, filename + ".json"), JSON.stringify(meta, null, 2));
-  invalidateHistoryIndex();
-  return { filename };
-}
-
-export async function loadNodeB64(rootDir: string, filename: string, generatedDir = config.storage.generatedDir) {
-  const p = resolveGeneratedPath(rootDir, filename, generatedDir);
-  try { await access(p); } catch {
-    const err = new Error(`Node file not found: ${filename}`) as Error & { code?: string; status?: number };
-    err.code = "NODE_NOT_FOUND";
-    err.status = 404;
-    throw err;
-  }
-  const buf = await readFile(p);
-  return buf.toString("base64");
-}
-
-export async function loadNodeMeta(rootDir: string, nodeId: string, ext = "png", generatedDir = config.storage.generatedDir) {
-  void rootDir;
-  try {
-    return JSON.parse(await readFile(join(generatedDir, `${nodeId}.${ext}.json`), "utf-8"));
-  } catch {
-    return null;
-  }
-}
-
-export async function loadAssetB64(rootDir: string, externalSrc: string, generatedDir = config.storage.generatedDir) {
-  const p = resolveGeneratedPath(rootDir, externalSrc, generatedDir);
-  try { await access(p); } catch {
-    const err = new Error(`Asset file not found: ${externalSrc}`) as Error & { code?: string; status?: number };
-    err.code = "NODE_NOT_FOUND";
-    err.status = 404;
-    throw err;
-  }
-  const buf = await readFile(p);
-  return buf.toString("base64");
-}
-
-function resolveGeneratedPath(rootDir: string, relPath: string, generatedDir = config.storage.generatedDir) {
-  void rootDir;
-  if (typeof relPath !== "string" || relPath.length === 0) {
-    const err = new Error("Asset path is required") as Error & { code?: string; status?: number };
-    err.code = "NODE_SOURCE_INVALID";
-    err.status = 400;
-    throw err;
-  }
-  const baseDir = resolve(generatedDir);
-  const target = resolve(baseDir, relPath);
-  if (target !== baseDir && !target.startsWith(baseDir + sep)) {
-    const err = new Error(`Asset path escapes generated/: ${relPath}`) as Error & { code?: string; status?: number };
-    err.code = "NODE_SOURCE_INVALID";
-    err.status = 400;
-    throw err;
-  }
-  return target;
-}