ima2-gen 1.0.8 → 1.0.10

package/lib/nodeStore.js

@@ -1,4 +1,4 @@
-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";
@@ -7,16 +7,17 @@ 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(config.storage.generatedDir, filename), Buffer.from(b64, "base64"));
-  await writeFile(join(config.storage.generatedDir, 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";
@@ -27,17 +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(config.storage.generatedDir, `${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,7 +49,7 @@ 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");
@@ -56,7 +57,7 @@ function resolveGeneratedPath(rootDir, relPath) {
     err.status = 400;
     throw err;
   }
-  const baseDir = resolve(config.storage.generatedDir);
+  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/storageMigration.js

@@ -1,21 +1,37 @@
 import { mkdir, readdir, copyFile, stat } from "node:fs/promises";
 import { existsSync } from "node:fs";
-import { join, resolve, sep } from "node:path";
+import { dirname, isAbsolute, 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()) {
-      await copyMissingTree(src, dst);
+      stats = addStats(stats, await copyMissingTree(src, dst));
       continue;
     }
     if (!entry.isFile()) continue;
-    if (existsSync(dst)) continue;
+    if (existsSync(dst)) {
+      stats.skippedExisting += 1;
+      continue;
+    }
     await copyFile(src, dst);
+    stats.copied += 1;
   }
+  return stats;
 }
 
 function isSameOrInside(child, parent) {
@@ -24,18 +40,80 @@ function isSameOrInside(child, parent) {
   return a === b || a.startsWith(b + sep);
 }
 
-export async function migrateGeneratedStorage(ctx) {
-  const legacyDir = join(ctx.rootDir, "generated");
+export async function migrateGeneratedStorage(ctx, options = {}) {
   const targetDir = ctx.config.storage.generatedDir;
-  if (isSameOrInside(legacyDir, targetDir) || isSameOrInside(targetDir, legacyDir)) return;
+  const candidates = options.legacyDirs || getLegacyGeneratedCandidates(ctx, options.env);
+  const result = {
+    copied: 0,
+    skippedExisting: 0,
+    sourcesScanned: 0,
+    sourcesSkipped: 0,
+  };
   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);
+    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 = env.IMA2_TEST_HOME || homedir();
+  const execPath = env.IMA2_TEST_EXEC_PATH || process.execPath;
+  const argv1 = env.IMA2_TEST_ARGV1 || process.argv[1] || "";
+  const nodePrefix = dirname(dirname(execPath));
+  const prefixes = getGlobalPrefixCandidates({ env, execPath, argv1 });
+  const appData = env.APPDATA || join(home, "AppData", "Roaming");
+
+  const candidates = [
+    join(ctx.rootDir, "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"),
+    join(home, ".volta", "tools", "image", "packages", PACKAGE_NAME, "lib", "node_modules", PACKAGE_NAME, "generated"),
+    join(home, ".fnm", "node-versions", process.version, "installation", "lib", "node_modules", PACKAGE_NAME, "generated"),
+  ];
+
+  for (const prefix of prefixes) {
+    candidates.push(join(prefix, "lib", "node_modules", PACKAGE_NAME, "generated"));
+    candidates.push(join(prefix, "node_modules", PACKAGE_NAME, "generated"));
+  }
+
+  candidates.push(join(nodePrefix, "lib", "node_modules", PACKAGE_NAME, "generated"));
+  return Array.from(new Set(candidates.map((p) => resolve(p))));
+}
+
+function getGlobalPrefixCandidates({ env, execPath, argv1 }) {
+  const prefixes = new Set();
+  if (env.npm_config_prefix) prefixes.add(env.npm_config_prefix);
+  if (isAbsolute(argv1)) prefixes.add(dirname(dirname(argv1)));
+  prefixes.add(dirname(dirname(execPath)));
+  addHomebrewPrefix(prefixes, execPath);
+  prefixes.add("/opt/homebrew");
+  prefixes.add("/usr/local");
+  return Array.from(prefixes);
+}
+
+function addHomebrewPrefix(prefixes, execPath) {
+  const marker = `${sep}Cellar${sep}node`;
+  const idx = execPath.indexOf(marker);
+  if (idx > 0) prefixes.add(execPath.slice(0, idx));
 }

package/package.json

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

package/routes/nodes.js

@@ -156,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,
@@ -270,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", {
@@ -325,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,13 +266,7 @@ 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;
-      if (code === "GRAPH_VERSION_CONFLICT") {
-        logEvent("session", "graph_conflict", {
-          sessionId: req.params.id,
-          code,
-          currentVersion: err.currentVersion,
-        });
-      } else {
+      if (code !== "GRAPH_VERSION_CONFLICT") {
         logError("session", "graph_error", err, { sessionId: req.params.id, code });
       }
       res.status(err.status || 500).json(payload);