ima2-gen 1.0.7 → 1.0.9

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

@@ -1,23 +1,23 @@
-import { writeFile, readFile, access } from "fs/promises";
+import { writeFile, readFile, access, mkdir } from "fs/promises";
 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" }) {
+export async function saveNode(rootDir, { nodeId, b64, meta, ext = "png", generatedDir = config.storage.generatedDir }) {
+  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 mkdir(generatedDir, { recursive: true });
+  await writeFile(join(generatedDir, filename), Buffer.from(b64, "base64"));
+  await writeFile(join(generatedDir, filename + ".json"), JSON.stringify(meta, null, 2));
   return { filename };
 }
 
-export async function loadNodeB64(rootDir, filename) {
-  const p = resolveGeneratedPath(rootDir, filename);
+export async function loadNodeB64(rootDir, filename, generatedDir = config.storage.generatedDir) {
+  const p = resolveGeneratedPath(rootDir, filename, generatedDir);
   try { await access(p); } catch {
     const err = new Error(`Node file not found: ${filename}`);
     err.code = "NODE_NOT_FOUND";
@@ -28,16 +28,17 @@ export async function loadNodeB64(rootDir, filename) {
   return buf.toString("base64");
 }
 
-export async function loadNodeMeta(rootDir, nodeId, ext = "png") {
+export async function loadNodeMeta(rootDir, nodeId, ext = "png", generatedDir = config.storage.generatedDir) {
+  void rootDir;
   try {
-    return JSON.parse(await readFile(join(rootDir, DIR, `${nodeId}.${ext}.json`), "utf-8"));
+    return JSON.parse(await readFile(join(generatedDir, `${nodeId}.${ext}.json`), "utf-8"));
   } catch {
     return null;
   }
 }
 
-export async function loadAssetB64(rootDir, externalSrc) {
-  const p = resolveGeneratedPath(rootDir, externalSrc);
+export async function loadAssetB64(rootDir, externalSrc, generatedDir = config.storage.generatedDir) {
+  const p = resolveGeneratedPath(rootDir, externalSrc, generatedDir);
   try { await access(p); } catch {
     const err = new Error(`Asset file not found: ${externalSrc}`);
     err.code = "NODE_NOT_FOUND";
@@ -48,14 +49,15 @@ export async function loadAssetB64(rootDir, externalSrc) {
   return buf.toString("base64");
 }
 
-function resolveGeneratedPath(rootDir, relPath) {
+function resolveGeneratedPath(rootDir, relPath, generatedDir = config.storage.generatedDir) {
+  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(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,91 @@
+import { mkdir, readdir, copyFile, stat } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { dirname, join, resolve, sep } from "node:path";
+import { homedir } from "node:os";
+
+const PACKAGE_NAME = "ima2-gen";
+
+function addStats(a, b) {
+  return {
+    copied: a.copied + b.copied,
+    skippedExisting: a.skippedExisting + b.skippedExisting,
+  };
+}
+
+async function copyMissingTree(srcDir, dstDir) {
+  await mkdir(dstDir, { recursive: true });
+  const entries = await readdir(srcDir, { withFileTypes: true });
+  let stats = { copied: 0, skippedExisting: 0 };
+  for (const entry of entries) {
+    const src = join(srcDir, entry.name);
+    const dst = join(dstDir, entry.name);
+    if (entry.isDirectory()) {
+      stats = addStats(stats, await copyMissingTree(src, dst));
+      continue;
+    }
+    if (!entry.isFile()) continue;
+    if (existsSync(dst)) {
+      stats.skippedExisting += 1;
+      continue;
+    }
+    await copyFile(src, dst);
+    stats.copied += 1;
+  }
+  return stats;
+}
+
+function isSameOrInside(child, parent) {
+  const a = resolve(child);
+  const b = resolve(parent);
+  return a === b || a.startsWith(b + sep);
+}
+
+export async function migrateGeneratedStorage(ctx, options = {}) {
+  const targetDir = ctx.config.storage.generatedDir;
+  const candidates = options.legacyDirs || getLegacyGeneratedCandidates(ctx, options.env);
+  const result = {
+    copied: 0,
+    skippedExisting: 0,
+    sourcesScanned: 0,
+    sourcesSkipped: 0,
+  };
+  try {
+    for (const legacyDir of candidates) {
+      if (isSameOrInside(legacyDir, targetDir) || isSameOrInside(targetDir, legacyDir)) {
+        result.sourcesSkipped += 1;
+        continue;
+      }
+      try {
+        const legacyStat = await stat(legacyDir);
+        if (!legacyStat.isDirectory()) continue;
+        result.sourcesScanned += 1;
+        const copyStats = await copyMissingTree(legacyDir, targetDir);
+        result.copied += copyStats.copied;
+        result.skippedExisting += copyStats.skippedExisting;
+      } catch (err) {
+        if (err?.code !== "ENOENT") {
+          console.warn("[storage] generated asset migration source skipped:", legacyDir, err.message);
+        }
+      }
+    }
+    if (result.copied > 0) console.log(`[storage] migrated ${result.copied} generated assets to ${targetDir}`);
+  } catch (err) {
+    console.warn("[storage] generated asset migration skipped:", err.message);
+  }
+  return result;
+}
+
+export function getLegacyGeneratedCandidates(ctx, env = process.env) {
+  const home = homedir();
+  const nodePrefix = dirname(dirname(process.execPath));
+  const npmPrefix = env.npm_config_prefix || nodePrefix;
+  const appData = env.APPDATA || join(home, "AppData", "Roaming");
+  return Array.from(new Set([
+    join(ctx.rootDir, "generated"),
+    join(npmPrefix, "lib", "node_modules", PACKAGE_NAME, "generated"),
+    join(npmPrefix, "node_modules", PACKAGE_NAME, "generated"),
+    join(appData, "npm", "node_modules", PACKAGE_NAME, "generated"),
+    join(home, ".npm-global", "lib", "node_modules", PACKAGE_NAME, "generated"),
+    join(home, ".nvm", "versions", "node", process.version, "lib", "node_modules", PACKAGE_NAME, "generated"),
+  ].map((p) => resolve(p))));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ima2-gen",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "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;
@@ -125,9 +156,9 @@ export function registerNodeRoutes(app, ctx) {
       const startTime = Date.now();
       let parentB64 = null;
       if (parentNodeId) {
-        parentB64 = await loadNodeB64(ctx.rootDir, `${parentNodeId}.png`);
+        parentB64 = await loadNodeB64(ctx.rootDir, `${parentNodeId}.png`, ctx.config.storage.generatedDir);
       } else if (typeof externalSrc === "string" && externalSrc.length > 0) {
-        parentB64 = await loadAssetB64(ctx.rootDir, externalSrc);
+        parentB64 = await loadAssetB64(ctx.rootDir, externalSrc, ctx.config.storage.generatedDir);
       }
       logEvent("node", "request", {
         requestId,
@@ -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,
@@ -206,7 +270,13 @@ export function registerNodeRoutes(app, ctx) {
         moderation,
       };
       await mkdir(ctx.config.storage.generatedDir, { recursive: true });
-      const { filename } = await saveNode(ctx.rootDir, { nodeId, b64, meta, ext: format });
+      const { filename } = await saveNode(ctx.rootDir, {
+        nodeId,
+        b64,
+        meta,
+        ext: format,
+        generatedDir: ctx.config.storage.generatedDir,
+      });
       finishMeta = { nodeId, filename, imageChars: b64.length };
       finishHttpStatus = 200;
       logEvent("node", "saved", {
@@ -217,11 +287,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 +303,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,
@@ -257,7 +331,7 @@ export function registerNodeRoutes(app, ctx) {
   app.get("/api/node/:nodeId", async (req, res) => {
     try {
       const { nodeId } = req.params;
-      const meta = await loadNodeMeta(ctx.rootDir, nodeId);
+      const meta = await loadNodeMeta(ctx.rootDir, nodeId, "png", ctx.config.storage.generatedDir);
       if (!meta) {
         return res.status(404).json({ error: { code: "NODE_NOT_FOUND", message: "Node metadata missing" } });
       }

package/routes/sessions.js

@@ -266,7 +266,9 @@ 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") {
+        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