ima2-gen 1.0.6 → 1.0.7

package/routes/nodes.js

@@ -0,0 +1,272 @@
+import { mkdir } from "fs/promises";
+import {
+  newNodeId,
+  saveNode,
+  loadNodeB64,
+  loadNodeMeta,
+  loadAssetB64,
+} from "../lib/nodeStore.js";
+import { startJob, finishJob } from "../lib/inflight.js";
+import { validateAndNormalizeRefs } from "../lib/refs.js";
+import { classifyUpstreamError } from "../lib/errorClassify.js";
+import { normalizeOAuthParams } from "../lib/oauthNormalize.js";
+import { generateViaOAuth, editViaOAuth } from "../lib/oauthProxy.js";
+import { getStyleSheet } from "../lib/sessionStore.js";
+import { renderStyleSheetPrefix } from "../lib/styleSheet.js";
+import { logEvent, logError } from "../lib/logger.js";
+
+function validateModeration(ctx, moderation) {
+  if (typeof moderation !== "string" || !ctx.config.oauth.validModeration.has(moderation)) {
+    return { error: "moderation must be one of: auto, low" };
+  }
+  return { moderation };
+}
+
+export function registerNodeRoutes(app, ctx) {
+  app.post("/api/node/generate", async (req, res) => {
+    const body = req.body || {};
+    const parentNodeId = body.parentNodeId ?? null;
+    const requestId = typeof body.requestId === "string" ? body.requestId : null;
+    const sessionId = typeof body.sessionId === "string" ? body.sessionId : null;
+    const clientNodeId = typeof body.clientNodeId === "string" ? body.clientNodeId : null;
+    let finishMeta = {};
+    let finishStatus = "completed";
+    let finishHttpStatus;
+    let finishErrorCode;
+    startJob({
+      requestId,
+      kind: "node",
+      prompt: body.prompt,
+      meta: { kind: "node", sessionId, parentNodeId, clientNodeId },
+    });
+
+    try {
+      const {
+        prompt,
+        quality: rawQuality = "medium",
+        size = "1024x1024",
+        format = "png",
+        moderation = "low",
+        references = [],
+        externalSrc = null,
+        mode: promptMode = "auto",
+      } = body;
+      const { provider = "oauth" } = body;
+      const { quality, warnings: qualityWarnings } = normalizeOAuthParams({ provider, quality: rawQuality });
+      const normalizedPromptMode = promptMode === "direct" ? "direct" : "auto";
+
+      if (provider === "api") {
+        finishStatus = "error";
+        finishHttpStatus = 403;
+        finishErrorCode = "APIKEY_DISABLED";
+        return res.status(403).json({
+          error: { code: "APIKEY_DISABLED", message: "API key provider is disabled. Use OAuth." },
+          parentNodeId,
+        });
+      }
+      if (!prompt || typeof prompt !== "string") {
+        finishStatus = "error";
+        finishHttpStatus = 400;
+        finishErrorCode = "INVALID_PROMPT";
+        return res.status(400).json({
+          error: { code: "INVALID_PROMPT", message: "Prompt is required" },
+          parentNodeId,
+        });
+      }
+      const refCheck = validateAndNormalizeRefs(references);
+      if (refCheck.error) {
+        finishStatus = "error";
+        finishHttpStatus = 400;
+        finishErrorCode = refCheck.code;
+        return res.status(400).json({
+          error: { code: refCheck.code, message: refCheck.error },
+          code: refCheck.code,
+          parentNodeId,
+        });
+      }
+      if ((parentNodeId || externalSrc) && refCheck.refs.length > 0) {
+        finishStatus = "error";
+        finishHttpStatus = 400;
+        finishErrorCode = "NODE_REFS_UNSUPPORTED_FOR_EDIT";
+        return res.status(400).json({
+          error: {
+            code: "NODE_REFS_UNSUPPORTED_FOR_EDIT",
+            message: "Extra references are only supported for root node generation.",
+          },
+          parentNodeId,
+        });
+      }
+      const moderationCheck = validateModeration(ctx, moderation);
+      if (moderationCheck.error) {
+        finishStatus = "error";
+        finishHttpStatus = 400;
+        finishErrorCode = "INVALID_MODERATION";
+        return res.status(400).json({
+          error: { code: "INVALID_MODERATION", message: moderationCheck.error },
+          parentNodeId,
+        });
+      }
+
+      let effectivePrompt = prompt;
+      let styleSheetApplied = null;
+      if (sessionId) {
+        try {
+          const data = getStyleSheet(sessionId);
+          if (data && data.enabled && data.styleSheet) {
+            const prefix = renderStyleSheetPrefix(data.styleSheet);
+            if (prefix) {
+              effectivePrompt = `${prefix} ${prompt}`.slice(0, 4000);
+              styleSheetApplied = data.styleSheet;
+            }
+          }
+        } catch {}
+      }
+
+      const startTime = Date.now();
+      let parentB64 = null;
+      if (parentNodeId) {
+        parentB64 = await loadNodeB64(ctx.rootDir, `${parentNodeId}.png`);
+      } else if (typeof externalSrc === "string" && externalSrc.length > 0) {
+        parentB64 = await loadAssetB64(ctx.rootDir, externalSrc);
+      }
+      logEvent("node", "request", {
+        requestId,
+        operation: parentB64 ? "edit" : "generate",
+        sessionId,
+        parentNodeId,
+        clientNodeId,
+        quality,
+        size,
+        moderation,
+        refs: refCheck.refs.length,
+        promptChars: prompt.length,
+        promptMode: normalizedPromptMode,
+        styleSheetApplied: !!styleSheetApplied,
+      });
+
+      let b64, usage, webSearchCalls = 0, revisedPrompt = null;
+      const MAX_RETRIES = 1;
+      let lastErr;
+      for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+        try {
+          const r = parentB64
+            ? await editViaOAuth(effectivePrompt, parentB64, quality, size, moderation, normalizedPromptMode, ctx, requestId)
+            : await generateViaOAuth(effectivePrompt, quality, size, moderation, refCheck.refs, requestId, normalizedPromptMode, ctx);
+          if (r.b64) {
+            b64 = r.b64;
+            usage = r.usage;
+            webSearchCalls = r.webSearchCalls || 0;
+            revisedPrompt = r.revisedPrompt || null;
+            break;
+          }
+          lastErr = new Error("Empty response (safety refusal)");
+        } catch (e) {
+          lastErr = e;
+        }
+        if (attempt < MAX_RETRIES) {
+          logEvent("node", "retry", { requestId, attempt: attempt + 1, errorCode: lastErr?.code });
+        }
+      }
+
+      if (!b64) {
+        finishStatus = "error";
+        finishHttpStatus = 422;
+        finishErrorCode = "SAFETY_REFUSAL";
+        return res.status(422).json({
+          error: { code: "SAFETY_REFUSAL", message: lastErr?.message || "Empty response after retry" },
+          parentNodeId,
+        });
+      }
+
+      const nodeId = newNodeId();
+      const elapsed = +((Date.now() - startTime) / 1000).toFixed(1);
+      const meta = {
+        nodeId,
+        parentNodeId,
+        sessionId,
+        clientNodeId,
+        prompt,
+        userPrompt: prompt,
+        revisedPrompt,
+        promptMode: normalizedPromptMode,
+        effectivePrompt: styleSheetApplied ? effectivePrompt : undefined,
+        styleSheetApplied: styleSheetApplied || undefined,
+        options: { quality, size, format, moderation },
+        createdAt: Date.now(),
+        createdAtIso: new Date().toISOString(),
+        elapsed,
+        usage: usage || null,
+        webSearchCalls,
+        provider: "oauth",
+        kind: parentB64 ? "edit" : "generate",
+        refsCount: refCheck.refs.length,
+        quality,
+        size,
+        format,
+        moderation,
+      };
+      await mkdir(ctx.config.storage.generatedDir, { recursive: true });
+      const { filename } = await saveNode(ctx.rootDir, { nodeId, b64, meta, ext: format });
+      finishMeta = { nodeId, filename, imageChars: b64.length };
+      finishHttpStatus = 200;
+      logEvent("node", "saved", {
+        requestId,
+        nodeId,
+        filename,
+        imageChars: b64.length,
+        elapsedMs: Date.now() - startTime,
+      });
+
+      res.json({
+        nodeId,
+        parentNodeId,
+        requestId,
+        image: `data:image/${format === "jpeg" ? "jpeg" : format};base64,${b64}`,
+        filename,
+        url: `/generated/${filename}`,
+        elapsed,
+        usage,
+        webSearchCalls,
+        provider: "oauth",
+        moderation,
+        refsCount: refCheck.refs.length,
+        warnings: qualityWarnings,
+        revisedPrompt,
+        promptMode: normalizedPromptMode,
+      });
+    } catch (err) {
+      const code = err.code || classifyUpstreamError(err.message) || "NODE_GEN_FAILED";
+      finishStatus = "error";
+      finishHttpStatus = err.status || 500;
+      finishErrorCode = code;
+      logError("node", "error", err, { requestId, code, parentNodeId, sessionId, clientNodeId });
+      res.status(err.status || 500).json({
+        error: { code, message: err.message },
+        parentNodeId,
+      });
+    } finally {
+      finishJob(requestId, {
+        status: finishStatus,
+        httpStatus: finishHttpStatus,
+        errorCode: finishErrorCode,
+        meta: finishMeta,
+      });
+    }
+  });
+
+  app.get("/api/node/:nodeId", async (req, res) => {
+    try {
+      const { nodeId } = req.params;
+      const meta = await loadNodeMeta(ctx.rootDir, nodeId);
+      if (!meta) {
+        return res.status(404).json({ error: { code: "NODE_NOT_FOUND", message: "Node metadata missing" } });
+      }
+      const ext = meta?.options?.format || meta?.format || "png";
+      res.json({ nodeId, meta, url: `/generated/${nodeId}.${ext}` });
+    } catch (err) {
+      res.status(err.status || 500).json({
+        error: { code: err.code || "NODE_FETCH_FAILED", message: err.message },
+      });
+    }
+  });
+}

package/routes/sessions.js

@@ -0,0 +1,273 @@
+import {
+  createSession,
+  listSessions,
+  getSession,
+  renameSession,
+  deleteSession,
+  saveGraph,
+  getStyleSheet,
+  setStyleSheet,
+  setStyleSheetEnabled,
+} from "../lib/sessionStore.js";
+import { extractStyleSheet } from "../lib/styleSheet.js";
+import { logError, logEvent } from "../lib/logger.js";
+
+function safeJsonChars(value) {
+  try {
+    return JSON.stringify(value ?? null).length;
+  } catch {
+    return 0;
+  }
+}
+
+export function registerSessionRoutes(app, ctx) {
+  app.get("/api/sessions", (_req, res) => {
+    try {
+      res.json({ sessions: listSessions() });
+    } catch (err) {
+      res.status(500).json({ error: { code: "DB_ERROR", message: err.message } });
+    }
+  });
+
+  app.post("/api/sessions", (req, res) => {
+    try {
+      const title = (req.body?.title || "Untitled").slice(0, 200);
+      const session = createSession({ title });
+      logEvent("session", "create", {
+        sessionId: session.id,
+        titleChars: session.title.length,
+      });
+      res.status(201).json({ session });
+    } catch (err) {
+      res.status(500).json({ error: { code: "DB_ERROR", message: err.message } });
+    }
+  });
+
+  app.get("/api/sessions/:id", (req, res) => {
+    try {
+      const session = getSession(req.params.id);
+      if (!session) {
+        return res.status(404).json({
+          error: { code: "SESSION_NOT_FOUND", message: "Session not found" },
+        });
+      }
+      res.json({ session });
+    } catch (err) {
+      res.status(500).json({ error: { code: "DB_ERROR", message: err.message } });
+    }
+  });
+
+  app.patch("/api/sessions/:id", (req, res) => {
+    try {
+      const title = req.body?.title;
+      if (typeof title !== "string" || !title.trim()) {
+        return res.status(400).json({
+          error: { code: "INVALID_TITLE", message: "Title required" },
+        });
+      }
+      const ok = renameSession(req.params.id, title.slice(0, 200));
+      if (!ok) {
+        return res.status(404).json({
+          error: { code: "SESSION_NOT_FOUND", message: "Session not found" },
+        });
+      }
+      logEvent("session", "rename", {
+        sessionId: req.params.id,
+        titleChars: title.slice(0, 200).length,
+      });
+      res.json({ ok: true });
+    } catch (err) {
+      res.status(500).json({ error: { code: "DB_ERROR", message: err.message } });
+    }
+  });
+
+  app.delete("/api/sessions/:id", (req, res) => {
+    try {
+      const ok = deleteSession(req.params.id);
+      if (!ok) {
+        return res.status(404).json({
+          error: { code: "SESSION_NOT_FOUND", message: "Session not found" },
+        });
+      }
+      logEvent("session", "delete", { sessionId: req.params.id });
+      res.json({ ok: true });
+    } catch (err) {
+      res.status(500).json({ error: { code: "DB_ERROR", message: err.message } });
+    }
+  });
+
+  app.get("/api/sessions/:id/style-sheet", (req, res) => {
+    try {
+      const data = getStyleSheet(req.params.id);
+      if (!data) {
+        return res.status(404).json({
+          error: { code: "SESSION_NOT_FOUND", message: "Session not found" },
+        });
+      }
+      logEvent("session", "stylesheet_get", {
+        sessionId: req.params.id,
+        enabled: data.enabled,
+        hasSheet: !!data.styleSheet,
+        sheetChars: safeJsonChars(data.styleSheet),
+      });
+      res.json(data);
+    } catch (err) {
+      res.status(500).json({ error: { code: "DB_ERROR", message: err.message } });
+    }
+  });
+
+  app.put("/api/sessions/:id/style-sheet", (req, res) => {
+    try {
+      const { styleSheet, enabled } = req.body || {};
+      if (styleSheet !== null && (typeof styleSheet !== "object" || Array.isArray(styleSheet))) {
+        return res.status(400).json({
+          error: { code: "INVALID_SHEET", message: "styleSheet must be an object or null" },
+        });
+      }
+      if (enabled !== undefined && typeof enabled !== "boolean") {
+        return res.status(400).json({
+          error: { code: "INVALID_ENABLED", message: "enabled must be boolean when provided" },
+        });
+      }
+      const ok = setStyleSheet(req.params.id, styleSheet);
+      if (!ok) {
+        return res.status(404).json({
+          error: { code: "SESSION_NOT_FOUND", message: "Session not found" },
+        });
+      }
+      if (typeof enabled === "boolean") setStyleSheetEnabled(req.params.id, enabled);
+      logEvent("session", "stylesheet_save", {
+        sessionId: req.params.id,
+        enabled: typeof enabled === "boolean" ? enabled : undefined,
+        hasSheet: !!styleSheet,
+        sheetChars: safeJsonChars(styleSheet),
+      });
+      res.json({ ok: true });
+    } catch (err) {
+      res.status(500).json({ error: { code: "DB_ERROR", message: err.message } });
+    }
+  });
+
+  app.patch("/api/sessions/:id/style-sheet/enabled", (req, res) => {
+    try {
+      const { enabled } = req.body || {};
+      if (typeof enabled !== "boolean") {
+        return res.status(400).json({
+          error: { code: "INVALID_ENABLED", message: "enabled must be boolean" },
+        });
+      }
+      const ok = setStyleSheetEnabled(req.params.id, enabled);
+      if (!ok) {
+        return res.status(404).json({
+          error: { code: "SESSION_NOT_FOUND", message: "Session not found" },
+        });
+      }
+      logEvent("session", "stylesheet_toggle", {
+        sessionId: req.params.id,
+        enabled,
+      });
+      res.json({ ok: true, enabled });
+    } catch (err) {
+      res.status(500).json({ error: { code: "DB_ERROR", message: err.message } });
+    }
+  });
+
+  app.post("/api/sessions/:id/style-sheet/extract", async (req, res) => {
+    try {
+      if (!ctx.openai) {
+        return res.status(400).json({
+          error: {
+            code: "STYLE_SHEET_NO_KEY",
+            message: "Style-sheet extraction requires an OpenAI API key. Connect one via setup.",
+          },
+        });
+      }
+      const { prompt, referenceDataUrl } = req.body || {};
+      if (typeof prompt !== "string" || !prompt.trim()) {
+        return res.status(400).json({
+          error: { code: "STYLE_SHEET_BAD_INPUT", message: "prompt required" },
+        });
+      }
+      if (!getSession(req.params.id)) {
+        return res.status(404).json({
+          error: { code: "SESSION_NOT_FOUND", message: "Session not found" },
+        });
+      }
+      logEvent("session", "stylesheet_extract_start", {
+        sessionId: req.params.id,
+        promptChars: prompt.length,
+        hasReference: typeof referenceDataUrl === "string" && referenceDataUrl.length > 0,
+      });
+      const sheet = await extractStyleSheet(ctx.openai, {
+        prompt: prompt.slice(0, 4000),
+        referenceDataUrl: typeof referenceDataUrl === "string" ? referenceDataUrl : undefined,
+      });
+      const persisted = setStyleSheet(req.params.id, sheet);
+      if (!persisted) {
+        return res.status(404).json({
+          error: { code: "SESSION_NOT_FOUND", message: "Session not found" },
+        });
+      }
+      logEvent("session", "stylesheet_extract_done", {
+        sessionId: req.params.id,
+        sheetChars: safeJsonChars(sheet),
+      });
+      res.json({ styleSheet: sheet });
+    } catch (err) {
+      const code = err.code || "STYLE_SHEET_ERROR";
+      const status =
+        code === "STYLE_SHEET_NO_KEY" || code === "STYLE_SHEET_BAD_INPUT"
+          ? 400
+          : code === "STYLE_SHEET_EMPTY" || code === "STYLE_SHEET_PARSE" || code === "STYLE_SHEET_SHAPE"
+            ? 422
+            : 500;
+      logError("session", "stylesheet_extract_error", err, { sessionId: req.params.id, code });
+      res.status(status).json({ error: { code, message: err.message } });
+    }
+  });
+
+  app.put("/api/sessions/:id/graph", (req, res) => {
+    try {
+      const { nodes, edges } = req.body || {};
+      const rawIfMatch = req.get("If-Match");
+      if (!Array.isArray(nodes) || !Array.isArray(edges)) {
+        return res.status(400).json({
+          error: { code: "INVALID_GRAPH", message: "nodes and edges arrays required" },
+        });
+      }
+      if (!rawIfMatch) {
+        return res.status(428).json({
+          error: { code: "GRAPH_VERSION_REQUIRED", message: "If-Match header required" },
+        });
+      }
+      if (nodes.length > 500 || edges.length > 1000) {
+        return res.status(413).json({
+          error: {
+            code: "GRAPH_TOO_LARGE",
+            message: `Graph too large (max 500 nodes / 1000 edges), got ${nodes.length}/${edges.length}`,
+          },
+        });
+      }
+      const expectedVersion = Number(String(rawIfMatch).replace(/"/g, ""));
+      if (!Number.isFinite(expectedVersion)) {
+        return res.status(400).json({
+          error: { code: "INVALID_GRAPH_VERSION", message: "If-Match must be a finite integer" },
+        });
+      }
+      const result = saveGraph(req.params.id, { nodes, edges, expectedVersion });
+      logEvent("session", "graph_save", {
+        sessionId: req.params.id,
+        nodes: nodes.length,
+        edges: edges.length,
+        graphVersion: result.graphVersion,
+      });
+      res.json({ ok: true, nodes: nodes.length, edges: edges.length, graphVersion: result.graphVersion });
+    } catch (err) {
+      const code = err.code || "DB_ERROR";
+      const payload = { error: { code, message: err.message } };
+      if (typeof err.currentVersion === "number") payload.currentVersion = err.currentVersion;
+      logError("session", "graph_error", err, { sessionId: req.params.id, code });
+      res.status(err.status || 500).json(payload);
+    }
+  });
+}