ima2-gen 1.1.21 → 1.1.23

package/routes/history.ts

@@ -1,221 +0,0 @@
-import type { Express, Request, Response } from "express";
-import { trashAsset, restoreAsset, deleteAssetPermanent } from "../lib/assetLifecycle.js";
-import {
-  getHistoryIndex,
-  invalidateFavoriteOverlay,
-  invalidateHistoryIndex,
-  type HistoryIndexRow,
-} from "../lib/historyIndex.js";
-import { getSessionTitleMap } from "../lib/sessionStore.js";
-import { logError, logEvent } from "../lib/logger.js";
-import { getDb } from "../lib/db.js";
-
-import { errInfo } from "../lib/errInfo.js";
-import { requireRuntimeContext, type RouteRuntimeContext } from "../lib/runtimeContext.js";
-
-function asStr(value: unknown): string {
-  return typeof value === "string" ? value : "";
-}
-
-function matchesHistoryFilters(
-  row: HistoryIndexRow,
-  params: {
-    sinceTs: number;
-    beforeTs: number;
-    beforeFn: string | null;
-    sessionId: string | null;
-    requestId: string | null;
-    favoritesOnly: boolean;
-    favoriteSet: Set<string>;
-  },
-): boolean {
-  if (Number.isFinite(params.sinceTs) && row.createdAt <= params.sinceTs) return false;
-  if (Number.isFinite(params.beforeTs)) {
-    if (row.createdAt > params.beforeTs) return false;
-    if (row.createdAt === params.beforeTs) {
-      if (!params.beforeFn || row.filename >= params.beforeFn) return false;
-    }
-  }
-  if (params.sessionId && row.sessionId !== params.sessionId) return false;
-  if (params.requestId && row.requestId !== params.requestId) return false;
-  if (params.favoritesOnly && !params.favoriteSet.has(row.filename)) return false;
-  return true;
-}
-
-function selectHistoryPage(
-  rows: HistoryIndexRow[],
-  limit: number,
-  params: Parameters<typeof matchesHistoryFilters>[1],
-) {
-  const selected: HistoryIndexRow[] = [];
-  for (const row of rows) {
-    if (!matchesHistoryFilters(row, params)) continue;
-    selected.push(row);
-    if (selected.length > limit) break;
-  }
-  const pageRows = selected.slice(0, limit);
-  const page = pageRows.map((r) => ({ ...r, isFavorite: params.favoriteSet.has(r.filename) }));
-  const last = page[page.length - 1];
-  return {
-    page,
-    nextCursor: selected.length > limit && last
-      ? { before: last.createdAt, beforeFilename: last.filename }
-      : null,
-  };
-}
-
-export function registerHistoryRoutes(app: Express, ctxRaw: RouteRuntimeContext) {
-  const ctx = requireRuntimeContext(ctxRaw);
-  app.get("/api/history", async (req: Request, res: Response) => {
-    try {
-      const limitRaw = parseInt(asStr(req.query.limit));
-      const limit = Math.min(
-        Number.isFinite(limitRaw) && limitRaw > 0 ? limitRaw : ctx.config.history.defaultPageSize,
-        ctx.config.history.maxPageCap,
-      );
-      const beforeTs = parseInt(asStr(req.query.before));
-      const beforeFn = typeof req.query.beforeFilename === "string" ? req.query.beforeFilename : null;
-      const sinceTs = parseInt(asStr(req.query.since));
-      const sessionId = typeof req.query.sessionId === "string" ? req.query.sessionId : null;
-      const requestId = typeof req.query.requestId === "string" ? req.query.requestId : null;
-      const groupBy = req.query.groupBy === "session" ? "session" : null;
-      const favoritesOnly =
-        req.query.favoritesOnly === "1" || req.query.favoritesOnly === "true";
-      const browserId = typeof req.headers["x-ima2-browser-id"] === "string"
-        ? req.headers["x-ima2-browser-id"]
-        : null;
-
-      const { rows } = await getHistoryIndex(ctx.config.storage.generatedDir);
-
-      // Enrich with favorite status
-      let favoriteSet = new Set<string>();
-      if (browserId) {
-        const db = getDb();
-        const favRows = db.prepare("SELECT filename FROM gallery_favorites WHERE browser_id = ?").all(browserId) as Array<{ filename: string }>;
-        favoriteSet = new Set(favRows.map((r) => r.filename));
-      }
-
-      const { page, nextCursor } = selectHistoryPage(rows, limit, {
-        sinceTs,
-        beforeTs,
-        beforeFn,
-        sessionId,
-        requestId,
-        favoritesOnly,
-        favoriteSet,
-      });
-
-      if (groupBy === "session") {
-        const groups = new Map<string, { sessionId: any; items: any[]; lastUsedAt: any }>();
-        const loose: any[] = [];
-        for (const row of page) {
-          if (row.sessionId) {
-            let group = groups.get(row.sessionId);
-            if (!group) {
-              group = { sessionId: row.sessionId, items: [], lastUsedAt: row.createdAt };
-              groups.set(row.sessionId, group);
-            }
-            group.items.push(row);
-            if (row.createdAt > group.lastUsedAt) group.lastUsedAt = row.createdAt;
-          } else {
-            loose.push(row);
-          }
-        }
-        const titleMap = getSessionTitleMap(Array.from(groups.keys()));
-        const sessions = Array.from(groups.values())
-          .map((group) => ({
-            ...group,
-            title: titleMap.get(group.sessionId) || null,
-            label: titleMap.get(group.sessionId) || group.sessionId.slice(0, 8),
-          }))
-          .sort((a, b) => b.lastUsedAt - a.lastUsedAt);
-        logEvent("history", "grouped", {
-          sessions: sessions.length,
-          loose: loose.length,
-          total: rows.length,
-        });
-        return res.json({ sessions, loose, total: rows.length, nextCursor });
-      }
-
-      res.json({ items: page, total: rows.length, nextCursor });
-    } catch (e) {
-      const err = errInfo(e);
-      logError("history", "error", err.raw);
-      res.status(500).json({ error: err.message });
-    }
-  });
-
-  app.delete("/api/history/:filename/permanent", async (req: Request<{ filename: string }>, res: Response) => {
-    try {
-      const filename = decodeURIComponent(req.params.filename);
-      const result = await deleteAssetPermanent(ctx.rootDir, filename);
-      invalidateHistoryIndex();
-      res.json(result);
-    } catch (e) {
-      const err = errInfo(e);
-      res.status(err.status || 500).json({ error: err.message, code: err.code });
-    }
-  });
-
-  app.delete("/api/history/:filename", async (req: Request<{ filename: string }>, res: Response) => {
-    try {
-      const filename = decodeURIComponent(req.params.filename);
-      const result = await trashAsset(ctx.rootDir, filename);
-      invalidateHistoryIndex();
-      res.json(result);
-    } catch (e) {
-      const err = errInfo(e);
-      res.status(err.status || 500).json({ error: err.message, code: err.code });
-    }
-  });
-
-  app.post("/api/history/:filename/restore", async (req: Request<{ filename: string }>, res: Response) => {
-    try {
-      const filename = decodeURIComponent(req.params.filename);
-      const body = (req.body ?? {}) as { trashId?: unknown };
-      const trashId = typeof body.trashId === "string" ? body.trashId : null;
-      if (!trashId) return res.status(400).json({ error: "trashId required" });
-      const result = await restoreAsset(ctx.rootDir, trashId, filename);
-      invalidateHistoryIndex();
-      res.json(result);
-    } catch (e) {
-      const err = errInfo(e);
-      res.status(err.status || 500).json({ error: err.message });
-    }
-  });
-
-  app.post("/api/history/favorite", async (req: Request, res: Response) => {
-    try {
-      const db = getDb();
-      const body = (req.body ?? {}) as { filename?: unknown };
-      const { filename } = body;
-      const browserId = req.headers["x-ima2-browser-id"];
-
-      if (!filename || typeof filename !== "string") {
-        return res.status(400).json({ error: "filename is required" });
-      }
-      if (!browserId || typeof browserId !== "string") {
-        return res.status(400).json({ error: "X-Ima2-Browser-Id header is required" });
-      }
-
-      const existing = db.prepare("SELECT id FROM gallery_favorites WHERE browser_id = ? AND filename = ?").get(browserId, filename);
-
-      if (existing) {
-        db.prepare("DELETE FROM gallery_favorites WHERE browser_id = ? AND filename = ?").run(browserId, filename);
-        invalidateFavoriteOverlay();
-        res.json({ isFavorite: false });
-      } else {
-        const id = `${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
-        db.prepare(
-          "INSERT INTO gallery_favorites (id, browser_id, filename, favorited_at) VALUES (?, ?, ?, ?)"
-        ).run(id, browserId, filename, Math.floor(Date.now() / 1000));
-        invalidateFavoriteOverlay();
-        res.json({ isFavorite: true });
-      }
-    } catch (e) {
-      const err = errInfo(e);
-      logError("history", "favorite_error", err.raw);
-      res.status(500).json({ error: err.message });
-    }
-  });
-}

package/routes/imageImport.ts

@@ -1,37 +0,0 @@
-import express, { type Express, type Request, type Response } from "express";
-import { createLocalImport } from "../lib/localImportStore.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;
-  }
-}
-
-export function registerImageImportRoutes(app: Express, ctxRaw: RouteRuntimeContext) {
-  const ctx = requireRuntimeContext(ctxRaw);
-  const rawImage = express.raw({
-    type: ["image/png", "image/jpeg", "image/webp"],
-    limit: ctx.config.server.bodyLimit,
-  });
-
-  app.post("/api/history/import-local", rawImage, async (req: Request, res: Response) => {
-    try {
-      const item = await createLocalImport(ctx, {
-        buffer: Buffer.isBuffer(req.body) ? req.body : Buffer.alloc(0),
-        originalFilename: decodeHeader(req.headers["x-ima2-original-filename"]),
-      });
-      res.status(201).json({ item });
-    } catch (e) {
-      const err = errInfo(e);
-      res.status(err.status || 500).json({
-        error: err.message,
-        code: err.code || "IMPORT_FAILED",
-      });
-    }
-  });
-}

package/routes/index.ts

@@ -1,52 +0,0 @@
-import type { Express } from "express";
-import { registerCapabilitiesRoutes } from "./capabilities.js";
-import { registerHealthRoutes } from "./health.js";
-import { registerHistoryRoutes } from "./history.js";
-import { registerSessionRoutes } from "./sessions.js";
-import { registerEditRoutes } from "./edit.js";
-import { registerNodeRoutes } from "./nodes.js";
-import { registerGenerateRoutes } from "./generate.js";
-import { registerMultimodeRoutes } from "./multimode.js";
-import { registerStorageRoutes } from "./storage.js";
-import { registerCardNewsRoutes } from "./cardNews.js";
-import { registerMetadataRoutes } from "./metadata.js";
-import { registerPromptRoutes } from "./prompts.js";
-import { registerPromptImportRoutes } from "./promptImport.js";
-import { registerAnnotationRoutes } from "./annotations.js";
-import { registerCanvasVersionRoutes } from "./canvasVersions.js";
-import { registerComfyRoutes } from "./comfy.js";
-import { registerImageImportRoutes } from "./imageImport.js";
-import { registerPromptBuilderRoutes } from "./promptBuilder.js";
-import { registerAgentRoutes } from "./agent.js";
-import { registerGrokRoutes } from "./grok.js";
-import { registerVideoRoutes } from "./video.js";
-import { registerVideoExtendedRoutes } from "./videoExtended.js";
-import { registerQuotaRoutes } from "./quota.js";
-import { type RouteRuntimeContext, requireRuntimeContext } from "../lib/runtimeContext.js";
-
-export function configureRoutes(app: Express, ctxRaw: RouteRuntimeContext) {
-  const ctx = requireRuntimeContext(ctxRaw);
-  registerHealthRoutes(app, ctx);
-  registerCapabilitiesRoutes(app, ctx);
-  registerStorageRoutes(app, ctx);
-  registerMetadataRoutes(app, ctx);
-  registerHistoryRoutes(app, ctx);
-  registerAnnotationRoutes(app, ctx);
-  registerCanvasVersionRoutes(app, ctx);
-  registerImageImportRoutes(app, ctx);
-  registerComfyRoutes(app, ctx);
-  registerSessionRoutes(app, ctx);
-  registerEditRoutes(app, ctx);
-  registerNodeRoutes(app, ctx);
-  if (ctx.config.features.cardNews) registerCardNewsRoutes(app, ctx);
-  registerMultimodeRoutes(app, ctx);
-  registerGenerateRoutes(app, ctx);
-  registerAgentRoutes(app, ctx);
-  registerPromptBuilderRoutes(app, ctx);
-  registerPromptRoutes(app, ctx);
-  registerPromptImportRoutes(app, ctx);
-  registerGrokRoutes(app, ctx);
-  registerVideoRoutes(app, ctx);
-  registerVideoExtendedRoutes(app, ctx);
-  registerQuotaRoutes(app, ctx);
-}

package/routes/metadata.ts

@@ -1,77 +0,0 @@
-import { Buffer } from "node:buffer";
-import type { Express, Request, Response } from "express";
-import { errInfo } from "../lib/errInfo.js";
-import {
-  isSupportedMetadataFormat,
-  normalizeImageMetadataFormat,
-  readEmbeddedImageMetadata,
-} from "../lib/imageMetadataStore.js";
-import { requireRuntimeContext, type RouteRuntimeContext } from "../lib/runtimeContext.js";
-
-const MIME_FORMATS: Record<string, string> = {
-  "image/png": "png",
-  "image/jpeg": "jpeg",
-  "image/webp": "webp",
-};
-
-function parseDataUrl(dataUrl: unknown): { mime: string; rawB64: string } | null {
-  if (typeof dataUrl !== "string") return null;
-  const match = /^data:([^;,]+);base64,(.+)$/s.exec(dataUrl);
-  if (!match) return null;
-  return { mime: match[1].toLowerCase(), rawB64: match[2] };
-}
-
-export function registerMetadataRoutes(app: Express, ctxRaw: RouteRuntimeContext) {
-  const ctx = requireRuntimeContext(ctxRaw);
-  app.post("/api/metadata/read", async (req: Request, res: Response) => {
-    try {
-      const body = (req.body ?? {}) as { dataUrl?: unknown };
-      const parsed = parseDataUrl(body.dataUrl);
-      if (!parsed) {
-        return res.status(400).json({
-          ok: false,
-          code: "IMAGE_METADATA_INVALID",
-          error: "A base64 image data URL is required.",
-        });
-      }
-      if (parsed.rawB64.length > ctx.config.limits.maxMetadataReadB64Bytes) {
-        return res.status(413).json({
-          ok: false,
-          code: "IMAGE_METADATA_TOO_LARGE",
-          error: "Image is too large to inspect for metadata.",
-        });
-      }
-      const format = normalizeImageMetadataFormat(MIME_FORMATS[parsed.mime]);
-      if (!isSupportedMetadataFormat(format)) {
-        return res.status(400).json({
-          ok: false,
-          code: "IMAGE_METADATA_UNSUPPORTED_FORMAT",
-          error: "Only PNG, JPEG, and WebP metadata can be inspected.",
-        });
-      }
-      const result = await readEmbeddedImageMetadata(Buffer.from(parsed.rawB64, "base64"));
-      if (!result.metadata) {
-        return res.json({
-          ok: true,
-          metadata: null,
-          source: null,
-          code: "IMAGE_METADATA_NOT_FOUND",
-          warnings: result.warnings,
-        });
-      }
-      return res.json({
-        ok: true,
-        metadata: result.metadata,
-        source: result.source,
-        warnings: result.warnings,
-      });
-    } catch (error) {
-      const err = errInfo(error);
-      return res.status(400).json({
-        ok: false,
-        code: err.code || "IMAGE_METADATA_INVALID",
-        error: err.message || "Could not read image metadata.",
-      });
-    }
-  });
-}