ima2-gen 1.0.3 → 1.0.4

package/bin/commands/show.js

@@ -1,8 +1,7 @@
 import { parseArgs } from "../lib/args.js";
 import { resolveServer, request } from "../lib/client.js";
-import { execSync } from "node:child_process";
+import { openUrl } from "../lib/platform.js";
 import { out, die, color, json, exitCodeForError } from "../lib/output.js";
-import { join } from "node:path";
 
 const SPEC = {
   flags: {
@@ -42,16 +41,8 @@ export default async function showCmd(argv) {
 
   if (args.reveal) {
     const url = item.url ? `${server.base}${item.url}` : null;
-    try {
-      if (process.platform === "darwin") {
-        execSync(`open "${server.base}${item.url || ""}"`);
-      } else if (process.platform === "win32") {
-        execSync(`start "" "${url}"`);
-      } else {
-        execSync(`xdg-open "${url}"`);
-      }
-    } catch {
-      out(color.yellow("(could not reveal)"));
-    }
+    if (!url) { out(color.yellow("(no url)")); return; }
+    const res = openUrl(url);
+    if (!res.ok) out(color.yellow("(could not reveal)"));
   }
 }

package/bin/ima2.js

@@ -5,12 +5,17 @@ import { join, dirname } from "path";
 import { fileURLToPath } from "url";
 import { spawn, execSync } from "child_process";
 import { networkInterfaces, homedir } from "os";
+import { openUrl, resolveBin } from "./lib/platform.js";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const ROOT = join(__dirname, "..");
 const HOME = homedir();
-const CONFIG_DIR = join(ROOT, ".ima2");
+// Config lives in $IMA2_CONFIG_DIR (tests) or ~/.ima2 to match server.js and
+// ~/.ima2/server.json advertise path. Legacy installs that stored config at
+// <packageRoot>/.ima2/config.json will be migrated on first write.
+const CONFIG_DIR = process.env.IMA2_CONFIG_DIR || join(HOME, ".ima2");
 const CONFIG_FILE = join(CONFIG_DIR, "config.json");
+const LEGACY_CONFIG_FILE = join(ROOT, ".ima2", "config.json");
 
 // Load package.json for version
 let pkg = { version: "?", name: "ima2-gen" };
@@ -22,6 +27,10 @@ function loadConfig() {
   if (existsSync(CONFIG_FILE)) {
     return JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
   }
+  // One-time read from legacy location so users who set up on <1.0.4 don't lose auth.
+  if (existsSync(LEGACY_CONFIG_FILE)) {
+    try { return JSON.parse(readFileSync(LEGACY_CONFIG_FILE, "utf-8")); } catch {}
+  }
   return {};
 }
 
@@ -66,7 +75,7 @@ async function setup() {
     if (!hasAuth) {
       console.log("  Running 'codex login' — follow the browser prompt.\n");
       try {
-        execSync("npx @openai/codex login", { stdio: "inherit" });
+        execSync(`${resolveBin("npx")} @openai/codex login`, { stdio: "inherit" });
       } catch {
         console.log("\n  Login failed or cancelled. You can retry with 'ima2 serve'.\n");
         rl.close();
@@ -98,7 +107,7 @@ async function serve() {
     if (hasUiSrc) {
       console.log("\n  ui/dist missing — running 'npm run build' first...\n");
       try {
-        execSync("npm run build", { stdio: "inherit", cwd: ROOT });
+        execSync(`${resolveBin("npm")} run build`, { stdio: "inherit", cwd: ROOT });
       } catch {
         console.log("\n  Build failed. Try: cd ui && npm install && npm run build\n");
         process.exit(1);
@@ -219,17 +228,10 @@ async function doctor() {
 function openBrowser() {
   const port = process.env.PORT || 3333;
   const url = `http://localhost:${port}`;
-
-  const platform = process.platform;
-  let cmd;
-  if (platform === "darwin") cmd = "open";
-  else if (platform === "win32") cmd = "start";
-  else cmd = "xdg-open";
-
-  try {
-    execSync(`${cmd} ${url}`, { stdio: "ignore" });
+  const res = openUrl(url);
+  if (res.ok) {
     console.log(`\n  Opening ${url} ...\n`);
-  } catch {
+  } else {
     console.log(`\n  Could not open browser. Visit: ${url}\n`);
   }
 }

package/bin/lib/platform.js

@@ -0,0 +1,89 @@
+// Cross-platform helpers (Windows / macOS / Linux / WSL).
+// Keep this file tiny & dependency-free. Node 18+ only.
+
+import { spawn, execSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+
+export const isWin = process.platform === "win32";
+export const isMac = process.platform === "darwin";
+export const isLinux = !isWin && !isMac;
+
+let _wslCached = null;
+export function isWsl() {
+  if (_wslCached !== null) return _wslCached;
+  if (!isLinux) return (_wslCached = false);
+  try {
+    _wslCached = readFileSync("/proc/version", "utf-8").toLowerCase().includes("microsoft");
+  } catch {
+    _wslCached = false;
+  }
+  return _wslCached;
+}
+
+export function hasDesktopSession() {
+  return Boolean(process.env.DISPLAY || process.env.WAYLAND_DISPLAY);
+}
+
+/**
+ * Resolve an executable name that differs between Windows and Unix.
+ * On Windows, npm global shims are .cmd files; spawn() without shell:true
+ * cannot resolve them and fails with ENOENT.
+ */
+export function resolveBin(name) {
+  return isWin ? `${name}.cmd` : name;
+}
+
+/**
+ * spawn() wrapper that works for npm/npx/any PATH-resolved exe on Windows.
+ */
+export function spawnBin(name, args, opts = {}) {
+  return spawn(resolveBin(name), args, { windowsHide: true, ...opts });
+}
+
+/**
+ * Open a URL in the user's default browser.
+ * Returns { ok: boolean, error?: string }.
+ * Handles WSL (via powershell.exe) and refuses on headless Linux without DISPLAY.
+ */
+export function openUrl(url) {
+  try {
+    if (isMac) {
+      execSync(`open ${JSON.stringify(url)}`, { stdio: "ignore" });
+    } else if (isWin) {
+      execSync(`cmd /c start "" ${JSON.stringify(url)}`, { stdio: "ignore" });
+    } else if (isWsl()) {
+      // WSL: hand off to Windows via powershell
+      execSync(`powershell.exe -NoProfile -Command Start-Process ${JSON.stringify(url)}`, { stdio: "ignore" });
+    } else {
+      if (!hasDesktopSession()) {
+        return { ok: false, error: "no desktop session (DISPLAY/WAYLAND_DISPLAY unset)" };
+      }
+      execSync(`xdg-open ${JSON.stringify(url)}`, { stdio: "ignore" });
+    }
+    return { ok: true };
+  } catch (e) {
+    return { ok: false, error: e.message || String(e) };
+  }
+}
+
+/**
+ * Register graceful shutdown handlers.
+ * Windows does NOT raise SIGTERM from the OS — SIGINT (Ctrl+C) and SIGBREAK
+ * (Ctrl+Break) are the observable signals. We still register SIGTERM so that
+ * Node-internal `child.kill("SIGTERM")` calls work in tests.
+ */
+export function onShutdown(handler) {
+  const signals = isWin
+    ? ["SIGINT", "SIGTERM", "SIGBREAK"]
+    : ["SIGINT", "SIGTERM", "SIGHUP"];
+  for (const sig of signals) {
+    try {
+      process.on(sig, () => {
+        try { handler(sig); } finally { process.exit(0); }
+      });
+    } catch {
+      // Some signals aren't installable on certain platforms; ignore.
+    }
+  }
+}
+

package/lib/db.js

@@ -0,0 +1,92 @@
+import Database from "better-sqlite3";
+import { mkdirSync, existsSync } from "fs";
+import { dirname, join } from "path";
+import { homedir } from "os";
+
+const DEFAULT_DB_DIR = join(homedir(), ".ima2");
+const DEFAULT_DB_PATH = join(DEFAULT_DB_DIR, "sessions.db");
+
+let db = null;
+
+export function getDbPath() {
+  return process.env.IMA2_DB_PATH || DEFAULT_DB_PATH;
+}
+
+export function getDb() {
+  if (db) return db;
+  const dbPath = getDbPath();
+  const dir = dirname(dbPath);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+
+  db = new Database(dbPath);
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  migrate(db);
+  return db;
+}
+
+function migrate(database) {
+  database.exec(`
+    CREATE TABLE IF NOT EXISTS _meta (
+      key   TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS sessions (
+      id          TEXT PRIMARY KEY,
+      title       TEXT NOT NULL DEFAULT 'Untitled',
+      created_at  INTEGER NOT NULL,
+      updated_at  INTEGER NOT NULL,
+      graph_version INTEGER NOT NULL DEFAULT 0
+    );
+
+    CREATE TABLE IF NOT EXISTS nodes (
+      session_id  TEXT NOT NULL,
+      id          TEXT NOT NULL,
+      x           REAL NOT NULL DEFAULT 0,
+      y           REAL NOT NULL DEFAULT 0,
+      data        TEXT NOT NULL DEFAULT '{}',
+      PRIMARY KEY (session_id, id),
+      FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE
+    );
+
+    CREATE TABLE IF NOT EXISTS edges (
+      session_id  TEXT NOT NULL,
+      id          TEXT NOT NULL,
+      source      TEXT NOT NULL,
+      target      TEXT NOT NULL,
+      data        TEXT NOT NULL DEFAULT '{}',
+      PRIMARY KEY (session_id, id),
+      FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_nodes_session ON nodes(session_id);
+    CREATE INDEX IF NOT EXISTS idx_edges_session ON edges(session_id);
+  `);
+
+  const sessionColumns = database
+    .prepare("PRAGMA table_info(sessions)")
+    .all()
+    .map((row) => row.name);
+  if (!sessionColumns.includes("graph_version")) {
+    database.exec(
+      "ALTER TABLE sessions ADD COLUMN graph_version INTEGER NOT NULL DEFAULT 0",
+    );
+  }
+
+  const row = database.prepare("SELECT value FROM _meta WHERE key = 'schema_version'").get();
+  if (!row) {
+    database.prepare("INSERT INTO _meta (key, value) VALUES ('schema_version', '2')").run();
+  } else if (row.value !== "2") {
+    database
+      .prepare("UPDATE _meta SET value = '2' WHERE key = 'schema_version'")
+      .run();
+  }
+}
+
+export function closeDb() {
+  if (db) {
+    db.close();
+    db = null;
+  }
+}

package/lib/inflight.js

@@ -0,0 +1,57 @@
+// In-memory inflight job registry.
+// Tracks generation requests that are currently running on the server so clients
+// can reconcile optimistic UI state after a reload or across tabs.
+//
+// This is intentionally process-local: if the server restarts, inflight jobs
+// are lost (which is correct — the fetch they came from is already gone).
+
+const jobs = new Map(); // requestId -> { requestId, kind, prompt, meta, startedAt, phase, phaseAt }
+
+// Phases: "queued" → "streaming" (upstream connection open, waiting for image)
+//                 → "decoding" (b64 received, writing to disk)
+// finishJob removes the entry entirely.
+export function startJob({ requestId, kind, prompt, meta = {} }) {
+  if (!requestId) return;
+  jobs.set(requestId, {
+    requestId,
+    kind,
+    prompt: typeof prompt === "string" ? prompt.slice(0, 500) : "",
+    meta,
+    startedAt: Date.now(),
+    phase: "queued",
+    phaseAt: Date.now(),
+  });
+}
+
+export function setJobPhase(requestId, phase) {
+  if (!requestId) return;
+  const j = jobs.get(requestId);
+  if (!j) return;
+  j.phase = phase;
+  j.phaseAt = Date.now();
+}
+
+export function finishJob(requestId, _options = {}) {
+  if (!requestId) return;
+  jobs.delete(requestId);
+}
+
+export function listJobs(filters = {}) {
+  // Stale reaping: > 10 min is almost certainly a crashed fetch.
+  const now = Date.now();
+  for (const [id, j] of jobs) {
+    if (now - j.startedAt > 10 * 60 * 1000) jobs.delete(id);
+  }
+  const { kind, sessionId } = filters;
+  return Array.from(jobs.values())
+    .filter((j) => {
+      if (kind && j.kind !== kind) return false;
+      if (sessionId && j.meta?.sessionId !== sessionId) return false;
+      return true;
+    })
+    .sort((a, b) => a.startedAt - b.startedAt);
+}
+
+export function _resetForTests() {
+  jobs.clear();
+}

package/lib/nodeStore.js

@@ -0,0 +1,66 @@
+import { writeFile, readFile, access } from "fs/promises";
+import { join, resolve, sep } from "path";
+import { randomBytes } from "crypto";
+
+const DIR = "generated";
+
+export function newNodeId() {
+  return "n_" + randomBytes(5).toString("hex");
+}
+
+export async function saveNode(rootDir, { nodeId, b64, meta, ext = "png" }) {
+  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));
+  return { filename };
+}
+
+export async function loadNodeB64(rootDir, filename) {
+  const p = resolveGeneratedPath(rootDir, filename);
+  try { await access(p); } catch {
+    const err = new Error(`Node file not found: ${filename}`);
+    err.code = "NODE_NOT_FOUND";
+    err.status = 404;
+    throw err;
+  }
+  const buf = await readFile(p);
+  return buf.toString("base64");
+}
+
+export async function loadNodeMeta(rootDir, nodeId, ext = "png") {
+  try {
+    return JSON.parse(await readFile(join(rootDir, DIR, `${nodeId}.${ext}.json`), "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+export async function loadAssetB64(rootDir, externalSrc) {
+  const p = resolveGeneratedPath(rootDir, externalSrc);
+  try { await access(p); } catch {
+    const err = new Error(`Asset file not found: ${externalSrc}`);
+    err.code = "NODE_NOT_FOUND";
+    err.status = 404;
+    throw err;
+  }
+  const buf = await readFile(p);
+  return buf.toString("base64");
+}
+
+function resolveGeneratedPath(rootDir, relPath) {
+  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 target = resolve(baseDir, relPath);
+  if (target !== baseDir && !target.startsWith(baseDir + sep)) {
+    const err = new Error(`Asset path escapes generated/: ${relPath}`);
+    err.code = "NODE_SOURCE_INVALID";
+    err.status = 400;
+    throw err;
+  }
+  return target;
+}

package/lib/sessionStore.js

@@ -0,0 +1,182 @@
+import { ulid } from "ulid";
+import { getDb } from "./db.js";
+
+function now() {
+  return Date.now();
+}
+
+export function createSession({ title = "Untitled" } = {}) {
+  const db = getDb();
+  const id = "s_" + ulid();
+  const t = now();
+  db.prepare(
+    "INSERT INTO sessions (id, title, created_at, updated_at, graph_version) VALUES (?, ?, ?, ?, 0)",
+  ).run(id, title, t, t);
+  return { id, title, createdAt: t, updatedAt: t, graphVersion: 0 };
+}
+
+export function listSessions() {
+  const db = getDb();
+  const rows = db
+    .prepare(
+      "SELECT id, title, created_at AS createdAt, updated_at AS updatedAt, graph_version AS graphVersion FROM sessions ORDER BY updated_at DESC",
+    )
+    .all();
+  return rows.map((r) => ({
+    ...r,
+    nodeCount: db
+      .prepare("SELECT COUNT(*) AS c FROM nodes WHERE session_id = ?")
+      .get(r.id).c,
+  }));
+}
+
+export function getSession(id) {
+  const db = getDb();
+  const session = db
+    .prepare(
+      "SELECT id, title, created_at AS createdAt, updated_at AS updatedAt, graph_version AS graphVersion FROM sessions WHERE id = ?",
+    )
+    .get(id);
+  if (!session) return null;
+  const nodes = db
+    .prepare("SELECT id, x, y, data FROM nodes WHERE session_id = ?")
+    .all(id)
+    .map((n) => ({ id: n.id, x: n.x, y: n.y, data: safeParse(n.data) }));
+  const edges = db
+    .prepare("SELECT id, source, target, data FROM edges WHERE session_id = ?")
+    .all(id)
+    .map((e) => ({
+      id: e.id,
+      source: e.source,
+      target: e.target,
+      data: safeParse(e.data),
+    }));
+  return { ...session, nodes, edges };
+}
+
+export function renameSession(id, title) {
+  const db = getDb();
+  const res = db
+    .prepare("UPDATE sessions SET title = ?, updated_at = ? WHERE id = ?")
+    .run(title, now(), id);
+  return res.changes > 0;
+}
+
+export function deleteSession(id) {
+  const db = getDb();
+  const res = db.prepare("DELETE FROM sessions WHERE id = ?").run(id);
+  return res.changes > 0;
+}
+
+const MAX_STR = 10_000;
+
+function cleanStr(v) {
+  if (typeof v !== "string") return "";
+  return v.length > MAX_STR ? v.slice(0, MAX_STR) : v;
+}
+
+function cleanData(v) {
+  try {
+    const json = JSON.stringify(v ?? {});
+    return json.length > MAX_STR * 10 ? "{}" : json;
+  } catch {
+    return "{}";
+  }
+}
+
+export function saveGraph(sessionId, { nodes = [], edges = [], expectedVersion = null }) {
+  const db = getDb();
+  const sessionExists = db
+    .prepare("SELECT 1 FROM sessions WHERE id = ?")
+    .get(sessionId);
+  if (!sessionExists) {
+    const err = new Error(`Session not found: ${sessionId}`);
+    err.code = "SESSION_NOT_FOUND";
+    err.status = 404;
+    throw err;
+  }
+
+  const versionRow = db
+    .prepare("SELECT graph_version AS graphVersion FROM sessions WHERE id = ?")
+    .get(sessionId);
+  const currentVersion = versionRow?.graphVersion ?? 0;
+  if (
+    typeof expectedVersion === "number" &&
+    Number.isFinite(expectedVersion) &&
+    expectedVersion !== currentVersion
+  ) {
+    const err = new Error(
+      `Graph version conflict for session ${sessionId}: expected ${expectedVersion}, got ${currentVersion}`,
+    );
+    err.code = "GRAPH_VERSION_CONFLICT";
+    err.status = 409;
+    err.currentVersion = currentVersion;
+    throw err;
+  }
+
+  // Validate edges reference existing nodes (drop dangling).
+  const nodeIds = new Set(nodes.map((n) => n?.id).filter(Boolean).map(String));
+  const cleanEdges = edges.filter(
+    (e) => e?.id && e?.source && e?.target && nodeIds.has(String(e.source)) && nodeIds.has(String(e.target)),
+  );
+
+  const tx = db.transaction(() => {
+    db.prepare("DELETE FROM nodes WHERE session_id = ?").run(sessionId);
+    db.prepare("DELETE FROM edges WHERE session_id = ?").run(sessionId);
+
+    const insNode = db.prepare(
+      "INSERT INTO nodes (session_id, id, x, y, data) VALUES (?, ?, ?, ?, ?)",
+    );
+    for (const n of nodes) {
+      if (!n?.id) continue;
+      const x = Number(n.x ?? n.position?.x ?? 0);
+      const y = Number(n.y ?? n.position?.y ?? 0);
+      insNode.run(
+        sessionId,
+        cleanStr(String(n.id)),
+        Number.isFinite(x) ? x : 0,
+        Number.isFinite(y) ? y : 0,
+        cleanData(n.data),
+      );
+    }
+
+    const insEdge = db.prepare(
+      "INSERT INTO edges (session_id, id, source, target, data) VALUES (?, ?, ?, ?, ?)",
+    );
+    for (const e of cleanEdges) {
+      insEdge.run(
+        sessionId,
+        cleanStr(String(e.id)),
+        cleanStr(String(e.source)),
+        cleanStr(String(e.target)),
+        cleanData(e.data),
+      );
+    }
+
+    db.prepare("UPDATE sessions SET updated_at = ?, graph_version = graph_version + 1 WHERE id = ?").run(
+      now(),
+      sessionId,
+    );
+
+    return db
+      .prepare("SELECT graph_version AS graphVersion FROM sessions WHERE id = ?")
+      .get(sessionId).graphVersion;
+  });
+
+  const nextVersion = tx();
+  return { ok: true, graphVersion: nextVersion };
+}
+
+function safeParse(json) {
+  try {
+    return JSON.parse(json);
+  } catch {
+    return {};
+  }
+}
+
+export function ensureDefaultSession() {
+  const sessions = listSessions();
+  if (sessions.length > 0) return sessions[0];
+  return createSession({ title: "My first graph" });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ima2-gen",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "description": "GPT Image 2 generator with OAuth & API key support",
   "type": "module",
   "bin": {
@@ -13,10 +13,10 @@
     "ui:dev": "cd ui && npm run dev",
     "ui:build": "cd ui && npm run build",
     "build": "npm run ui:build",
-    "test": "node --test tests/**/*.test.js",
+    "test": "node scripts/run-tests.mjs",
     "setup": "node bin/ima2.js setup",
     "prepublishOnly": "npm run build && npm run lint:pkg",
-    "lint:pkg": "node -e \"const p=require('./package.json'); if(!p.name||!p.version||!p.bin) throw new Error('missing fields')\"",
+    "lint:pkg": "node -e \"const p=require('./package.json'); const req=['name','version','bin']; for(const k of req){if(!p[k])throw new Error('missing '+k)} const mustInclude=['bin/','lib/','server.js']; for(const f of mustInclude){if(!p.files.includes(f))throw new Error('files[] must include '+f)}\"",
     "release:patch": "npm version patch && npm publish && git push origin main --tags",
     "release:minor": "npm version minor && npm publish && git push origin main --tags",
     "release:major": "npm version major && npm publish && git push origin main --tags"
@@ -35,6 +35,7 @@
   },
   "files": [
     "bin/",
+    "lib/",
     "ui/dist/",
     "assets/",
     "server.js",
@@ -42,7 +43,7 @@
     "README.md"
   ],
   "engines": {
-    "node": ">=18"
+    "node": ">=20"
   },
   "dependencies": {
     "better-sqlite3": "^12.9.0",