ima2-gen 1.0.7 → 1.0.8

package/README.md

@@ -214,7 +214,7 @@ environment variables > ~/.ima2/config.json > built-in defaults
 | `IMA2_OAUTH_PROXY_PORT` / `OAUTH_PORT` | `10531` | OAuth proxy port |
 | `IMA2_SERVER` | — | CLI target override |
 | `IMA2_CONFIG_DIR` | `~/.ima2` | Config and SQLite location |
-| `IMA2_GENERATED_DIR` | `generated/` | Generated image directory |
+| `IMA2_GENERATED_DIR` | `~/.ima2/generated` | Generated image directory |
 | `IMA2_NO_OAUTH_PROXY` | — | Set `1` to disable auto-starting the OAuth proxy |
 | `IMA2_INFLIGHT_TERMINAL_TTL_MS` | `30000` | Retention for opt-in terminal in-flight debug jobs |
 | `VITE_IMA2_NODE_MODE` | enabled | Set `0` at UI build time to hide node mode |

package/config.js

@@ -108,8 +108,8 @@ export const config = {
   storage: {
     configDir,
     packageRoot,
-    generatedDir: pickStr(env.IMA2_GENERATED_DIR, fileCfg.storage?.generatedDir, join(packageRoot, "generated")),
-    trashDir: pickStr(env.IMA2_TRASH_DIR, fileCfg.storage?.trashDir, join(packageRoot, "generated", ".trash")),
+    generatedDir: pickStr(env.IMA2_GENERATED_DIR, fileCfg.storage?.generatedDir, join(configDir, "generated")),
+    trashDir: pickStr(env.IMA2_TRASH_DIR, fileCfg.storage?.trashDir, join(configDir, "generated", ".trash")),
     generatedDirName: pickStr(env.IMA2_GENERATED_DIRNAME, fileCfg.storage?.generatedDirName, "generated"),
     trashDirName: pickStr(env.IMA2_TRASH_DIRNAME, fileCfg.storage?.trashDirName, ".trash"),
     dbPath: pickStr(env.IMA2_DB_PATH, fileCfg.storage?.dbPath, join(configDir, "sessions.db")),

package/lib/assetLifecycle.js

@@ -8,6 +8,7 @@ const TRASH = config.storage.trashDirName;
 const TRASH_TTL_MS = config.trash.ttlMs;
 
 function resolveInGenerated(rootDir, relPath) {
+  void rootDir;
   if (typeof relPath !== "string" || relPath.length === 0) {
     const err = new Error("filename required");
     err.status = 400;
@@ -20,7 +21,7 @@ function resolveInGenerated(rootDir, relPath) {
     err.code = "INVALID_FILENAME";
     throw err;
   }
-  const baseDir = resolve(rootDir, DIR);
+  const baseDir = resolve(config.storage.generatedDir);
   const target = resolve(baseDir, relPath);
   if (target !== baseDir && !target.startsWith(baseDir + sep)) {
     const err = new Error("filename escapes generated/");
@@ -78,7 +79,7 @@ export async function trashAsset(rootDir, filename) {
     err.code = "ASSET_NOT_FOUND";
     throw err;
   }
-  const trashDir = resolve(rootDir, DIR, TRASH);
+  const trashDir = resolve(config.storage.trashDir);
   await mkdir(trashDir, { recursive: true });
   // Flatten filename (subdir separators -> __) so trash is flat & easy to restore
   const flat = filename.replace(/[\\/]+/g, "__");
@@ -107,7 +108,8 @@ export async function trashAsset(rootDir, filename) {
 }
 
 export async function restoreAsset(rootDir, trashId, originalFilename) {
-  const trashDir = resolve(rootDir, DIR, TRASH);
+  void rootDir;
+  const trashDir = resolve(config.storage.trashDir);
   const src = resolve(trashDir, trashId);
   if (!src.startsWith(trashDir + sep) && src !== trashDir) {
     const err = new Error("invalid trashId");

package/lib/historyList.js

@@ -52,6 +52,7 @@ export async function listHistoryRows(baseDir = config.storage.generatedDir) {
       nodeId: meta?.nodeId || null,
       parentNodeId: meta?.parentNodeId || null,
       clientNodeId: meta?.clientNodeId || null,
+      requestId: meta?.requestId || null,
       kind: meta?.kind || null,
       refsCount: Number.isFinite(meta?.refsCount) ? meta.refsCount : 0,
     };

package/lib/nodeStore.js

@@ -3,16 +3,15 @@ import { join, resolve, sep } from "path";
 import { randomBytes } from "crypto";
 import { config } from "../config.js";
 
-const DIR = config.storage.generatedDirName;
-
 export function newNodeId() {
   return "n_" + randomBytes(config.ids.nodeHexBytes).toString("hex");
 }
 
 export async function saveNode(rootDir, { nodeId, b64, meta, ext = "png" }) {
+  void rootDir;
   const filename = `${nodeId}.${ext}`;
-  await writeFile(join(rootDir, DIR, filename), Buffer.from(b64, "base64"));
-  await writeFile(join(rootDir, DIR, filename + ".json"), JSON.stringify(meta, null, 2));
+  await writeFile(join(config.storage.generatedDir, filename), Buffer.from(b64, "base64"));
+  await writeFile(join(config.storage.generatedDir, filename + ".json"), JSON.stringify(meta, null, 2));
   return { filename };
 }
 
@@ -29,8 +28,9 @@ export async function loadNodeB64(rootDir, filename) {
 }
 
 export async function loadNodeMeta(rootDir, nodeId, ext = "png") {
+  void rootDir;
   try {
-    return JSON.parse(await readFile(join(rootDir, DIR, `${nodeId}.${ext}.json`), "utf-8"));
+    return JSON.parse(await readFile(join(config.storage.generatedDir, `${nodeId}.${ext}.json`), "utf-8"));
   } catch {
     return null;
   }
@@ -49,13 +49,14 @@ export async function loadAssetB64(rootDir, externalSrc) {
 }
 
 function resolveGeneratedPath(rootDir, relPath) {
+  void rootDir;
   if (typeof relPath !== "string" || relPath.length === 0) {
     const err = new Error("Asset path is required");
     err.code = "NODE_SOURCE_INVALID";
     err.status = 400;
     throw err;
   }
-  const baseDir = resolve(rootDir, DIR);
+  const baseDir = resolve(config.storage.generatedDir);
   const target = resolve(baseDir, relPath);
   if (target !== baseDir && !target.startsWith(baseDir + sep)) {
     const err = new Error(`Asset path escapes generated/: ${relPath}`);

package/lib/oauthProxy.js

@@ -46,6 +46,24 @@ function extractSseData(block) {
   return eventData;
 }
 
+function extractPartialImage(data) {
+  if (typeof data?.type !== "string" || !data.type.includes("partial")) return null;
+  const item = data.item || {};
+  const b64 =
+    data.partial_image ||
+    data.image ||
+    data.result ||
+    item.partial_image ||
+    item.image ||
+    item.result;
+  if (typeof b64 !== "string" || b64.length === 0) return null;
+  const index =
+    Number.isFinite(data.index) ? data.index :
+      Number.isFinite(item.index) ? item.index :
+        null;
+  return { b64, index, eventType: data.type };
+}
+
 function makeOAuthError(message, { status, code = "OAUTH_UPSTREAM_ERROR", upstreamBodyChars, eventType } = {}) {
   const err = new Error(message);
   err.code = code;
@@ -55,7 +73,7 @@ function makeOAuthError(message, { status, code = "OAUTH_UPSTREAM_ERROR", upstre
   return err;
 }
 
-async function readImageStream(res, { requestId = null, scope = "oauth" } = {}) {
+async function readImageStream(res, { requestId = null, scope = "oauth", onPartialImage = null } = {}) {
   const reader = res.body.getReader();
   const decoder = new TextDecoder();
   let buffer = "";
@@ -81,6 +99,17 @@ async function readImageStream(res, { requestId = null, scope = "oauth" } = {})
         const data = JSON.parse(eventData);
         eventCount++;
 
+        const partial = extractPartialImage(data);
+        if (partial) {
+          logEvent(scope, "partial", {
+            requestId,
+            index: partial.index,
+            imageChars: partial.b64.length,
+            eventType: partial.eventType,
+          });
+          if (requestId) setJobPhase(requestId, "partial");
+          if (typeof onPartialImage === "function") onPartialImage(partial);
+        }
         if (data.type === "response.output_item.done" && data.item?.type === "image_generation_call") {
           if (data.item.result) {
             imageB64 = data.item.result;
@@ -123,11 +152,18 @@ export async function generateViaOAuth(
   requestId = null,
   mode = "auto",
   ctx = {},
+  options = {},
 ) {
   const oauthUrl = getOAuthUrl(ctx);
   const tools = [
     { type: "web_search" },
-    { type: "image_generation", quality, size, moderation },
+    {
+      type: "image_generation",
+      quality,
+      size,
+      moderation,
+      ...(options.partialImages ? { partial_images: options.partialImages } : {}),
+    },
   ];
 
   const textPrompt = buildUserTextPrompt(prompt, mode);
@@ -187,7 +223,11 @@ export async function generateViaOAuth(
     throw new Error("No image data in response (non-stream mode)");
   }
 
-  const { imageB64, usage, webSearchCalls, revisedPrompt, eventCount } = await readImageStream(res, { requestId, scope: "oauth" });
+  const { imageB64, usage, webSearchCalls, revisedPrompt, eventCount } = await readImageStream(res, {
+    requestId,
+    scope: "oauth",
+    onPartialImage: options.onPartialImage,
+  });
   logEvent("oauth", "stream_end", { requestId, events: eventCount, hasImage: !!imageB64 });
 
   if (!imageB64) {

package/lib/storageMigration.js

@@ -0,0 +1,41 @@
+import { mkdir, readdir, copyFile, stat } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { join, resolve, sep } from "node:path";
+
+async function copyMissingTree(srcDir, dstDir) {
+  await mkdir(dstDir, { recursive: true });
+  const entries = await readdir(srcDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const src = join(srcDir, entry.name);
+    const dst = join(dstDir, entry.name);
+    if (entry.isDirectory()) {
+      await copyMissingTree(src, dst);
+      continue;
+    }
+    if (!entry.isFile()) continue;
+    if (existsSync(dst)) continue;
+    await copyFile(src, dst);
+  }
+}
+
+function isSameOrInside(child, parent) {
+  const a = resolve(child);
+  const b = resolve(parent);
+  return a === b || a.startsWith(b + sep);
+}
+
+export async function migrateGeneratedStorage(ctx) {
+  const legacyDir = join(ctx.rootDir, "generated");
+  const targetDir = ctx.config.storage.generatedDir;
+  if (isSameOrInside(legacyDir, targetDir) || isSameOrInside(targetDir, legacyDir)) return;
+  try {
+    const legacyStat = await stat(legacyDir);
+    if (!legacyStat.isDirectory()) return;
+    await copyMissingTree(legacyDir, targetDir);
+    console.log(`[storage] migrated generated assets to ${targetDir}`);
+  } catch (err) {
+    if (err?.code !== "ENOENT") {
+      console.warn("[storage] generated asset migration skipped:", err.message);
+    }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ima2-gen",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "description": "GPT Image 2 generator with OAuth & API key support",
   "type": "module",
   "bin": {

package/routes/nodes.js

@@ -22,9 +22,40 @@ function validateModeration(ctx, moderation) {
   return { moderation };
 }
 
+function wantsSse(req) {
+  const accept = typeof req.headers.accept === "string" ? req.headers.accept : "";
+  return accept.includes("text/event-stream");
+}
+
+function writeSse(res, event, data) {
+  res.write(`event: ${event}\n`);
+  res.write(`data: ${JSON.stringify(data)}\n\n`);
+}
+
+function writeNodeError(res, status, code, message, parentNodeId) {
+  if (res.headersSent) {
+    writeSse(res, "error", {
+      error: { code, message },
+      parentNodeId,
+      status,
+    });
+    res.end();
+    return;
+  }
+  res.status(status).json({
+    error: { code, message },
+    parentNodeId,
+  });
+}
+
+function dataUrlFromB64(format, b64) {
+  return `data:image/${format === "jpeg" ? "jpeg" : format};base64,${b64}`;
+}
+
 export function registerNodeRoutes(app, ctx) {
   app.post("/api/node/generate", async (req, res) => {
     const body = req.body || {};
+    const streamResponse = wantsSse(req);
     const parentNodeId = body.parentNodeId ?? null;
     const requestId = typeof body.requestId === "string" ? body.requestId : null;
     const sessionId = typeof body.sessionId === "string" ? body.sessionId : null;
@@ -144,6 +175,15 @@ export function registerNodeRoutes(app, ctx) {
         styleSheetApplied: !!styleSheetApplied,
       });
 
+      if (streamResponse) {
+        res.writeHead(200, {
+          "Content-Type": "text/event-stream; charset=utf-8",
+          "Cache-Control": "no-cache, no-transform",
+          Connection: "keep-alive",
+        });
+        writeSse(res, "phase", { requestId, phase: "streaming" });
+      }
+
       let b64, usage, webSearchCalls = 0, revisedPrompt = null;
       const MAX_RETRIES = 1;
       let lastErr;
@@ -151,7 +191,27 @@ export function registerNodeRoutes(app, ctx) {
         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);
+            : await generateViaOAuth(
+                effectivePrompt,
+                quality,
+                size,
+                moderation,
+                refCheck.refs,
+                requestId,
+                normalizedPromptMode,
+                ctx,
+                {
+                  partialImages: streamResponse ? 2 : 0,
+                  onPartialImage: streamResponse
+                    ? (partial) =>
+                        writeSse(res, "partial", {
+                          requestId,
+                          image: dataUrlFromB64(format, partial.b64),
+                          index: partial.index,
+                        })
+                    : null,
+                },
+              );
           if (r.b64) {
             b64 = r.b64;
             usage = r.usage;
@@ -172,10 +232,13 @@ export function registerNodeRoutes(app, ctx) {
         finishStatus = "error";
         finishHttpStatus = 422;
         finishErrorCode = "SAFETY_REFUSAL";
-        return res.status(422).json({
-          error: { code: "SAFETY_REFUSAL", message: lastErr?.message || "Empty response after retry" },
+        return writeNodeError(
+          res,
+          422,
+          "SAFETY_REFUSAL",
+          lastErr?.message || "Empty response after retry",
           parentNodeId,
-        });
+        );
       }
 
       const nodeId = newNodeId();
@@ -199,6 +262,7 @@ export function registerNodeRoutes(app, ctx) {
         webSearchCalls,
         provider: "oauth",
         kind: parentB64 ? "edit" : "generate",
+        requestId,
         refsCount: refCheck.refs.length,
         quality,
         size,
@@ -217,11 +281,11 @@ export function registerNodeRoutes(app, ctx) {
         elapsedMs: Date.now() - startTime,
       });
 
-      res.json({
+      const payload = {
         nodeId,
         parentNodeId,
         requestId,
-        image: `data:image/${format === "jpeg" ? "jpeg" : format};base64,${b64}`,
+        image: dataUrlFromB64(format, b64),
         filename,
         url: `/generated/${filename}`,
         elapsed,
@@ -233,17 +297,21 @@ export function registerNodeRoutes(app, ctx) {
         warnings: qualityWarnings,
         revisedPrompt,
         promptMode: normalizedPromptMode,
-      });
+      };
+
+      if (streamResponse) {
+        writeSse(res, "done", payload);
+        res.end();
+      } else {
+        res.json(payload);
+      }
     } 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,
-      });
+      writeNodeError(res, err.status || 500, code, err.message, parentNodeId);
     } finally {
       finishJob(requestId, {
         status: finishStatus,

package/routes/sessions.js

@@ -266,7 +266,15 @@ export function registerSessionRoutes(app, ctx) {
       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 });
+      if (code === "GRAPH_VERSION_CONFLICT") {
+        logEvent("session", "graph_conflict", {
+          sessionId: req.params.id,
+          code,
+          currentVersion: err.currentVersion,
+        });
+      } else {
+        logError("session", "graph_error", err, { sessionId: req.params.id, code });
+      }
       res.status(err.status || 500).json(payload);
     }
   });

package/server.js

@@ -13,6 +13,7 @@ import { fileURLToPath, pathToFileURL } from "url";
 import { onShutdown } from "./bin/lib/platform.js";
 import { ensureDefaultSession } from "./lib/sessionStore.js";
 import { startOAuthProxy } from "./lib/oauthLauncher.js";
+import { migrateGeneratedStorage } from "./lib/storageMigration.js";
 import { configureRoutes } from "./routes/index.js";
 import { config } from "./config.js";
 
@@ -114,6 +115,7 @@ export async function createRuntimeContext(overrides = {}) {
 
 export async function startServer(overrides = {}) {
   const ctx = await createRuntimeContext(overrides);
+  await migrateGeneratedStorage(ctx);
   const app = buildApp(ctx);
   const oauthChild =
     overrides.oauthChild !== undefined