ima2-gen 1.0.3 → 1.0.5

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.5",
   "description": "GPT Image 2 generator with OAuth & API key support",
   "type": "module",
   "bin": {
@@ -8,15 +8,16 @@
   },
   "scripts": {
     "start": "node bin/ima2.js serve",
-    "dev": "node --watch server.js",
+    "dev": "node scripts/dev.mjs",
+    "dev:server": "node --watch server.js",
     "ui:install": "cd ui && npm install",
     "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 +36,7 @@
   },
   "files": [
     "bin/",
+    "lib/",
     "ui/dist/",
     "assets/",
     "server.js",
@@ -42,7 +44,7 @@
     "README.md"
   ],
   "engines": {
-    "node": ">=18"
+    "node": ">=20"
   },
   "dependencies": {
     "better-sqlite3": "^12.9.0",

package/server.js

@@ -4,8 +4,10 @@ import { writeFile, mkdir, readFile, readdir, stat } from "fs/promises";
 import { join, dirname } from "path";
 import { fileURLToPath } from "url";
 import { spawn } from "child_process";
+import { spawnBin, onShutdown } from "./bin/lib/platform.js";
 import { existsSync, writeFileSync, unlinkSync, mkdirSync, readFileSync as fsReadFileSync } from "fs";
 import { homedir } from "os";
+import { randomBytes } from "crypto";
 import { newNodeId, saveNode, loadNodeB64, loadNodeMeta, loadAssetB64 } from "./lib/nodeStore.js";
 import { startJob, finishJob, listJobs, setJobPhase } from "./lib/inflight.js";
 import {
@@ -17,18 +19,25 @@ import {
   saveGraph,
   ensureDefaultSession,
 } from "./lib/sessionStore.js";
+import { trashAsset, restoreAsset } from "./lib/assetLifecycle.js";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const app = express();
 
-// Load API key from env or .ima2/config.json
+// Load API key from env or ${IMA2_CONFIG_DIR || ~/.ima2}/config.json
+// (with legacy fallback to <packageRoot>/.ima2/config.json for existing installs)
 let apiKey = process.env.OPENAI_API_KEY;
 if (!apiKey) {
-  const cfgPath = join(__dirname, ".ima2", "config.json");
-  if (existsSync(cfgPath)) {
+  const configDir = process.env.IMA2_CONFIG_DIR || join(homedir(), ".ima2");
+  const candidates = [
+    join(configDir, "config.json"),
+    join(__dirname, ".ima2", "config.json"),
+  ];
+  for (const cfgPath of candidates) {
+    if (!existsSync(cfgPath)) continue;
     try {
       const cfg = JSON.parse(await readFile(cfgPath, "utf-8"));
-      if (cfg.apiKey) apiKey = cfg.apiKey;
+      if (cfg.apiKey) { apiKey = cfg.apiKey; break; }
     } catch {}
   }
 }
@@ -271,6 +280,7 @@ async function listImages(baseDir) {
   async function walk(dir, depth) {
     const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
     for (const e of entries) {
+      if (e.name === ".trash") continue;
       const full = join(dir, e.name);
       if (e.isDirectory() && depth > 0) {
         await walk(full, depth - 1);
@@ -287,7 +297,14 @@ app.get("/api/history", async (req, res) => {
   try {
     const dir = join(__dirname, "generated");
     await mkdir(dir, { recursive: true });
-    const limit = Math.min(parseInt(req.query.limit) || 50, 200);
+    const limitRaw = parseInt(req.query.limit);
+    const limit = Math.min(Number.isFinite(limitRaw) && limitRaw > 0 ? limitRaw : 50, 500);
+    const beforeTs = parseInt(req.query.before);
+    const beforeFn = typeof req.query.beforeFilename === "string" ? req.query.beforeFilename : null;
+    const sinceTs = parseInt(req.query.since);
+    const sessionId = typeof req.query.sessionId === "string" ? req.query.sessionId : null;
+    const groupBy = req.query.groupBy === "session" ? "session" : null;
+
     const imgs = await listImages(dir);
     const rows = await Promise.all(imgs.map(async ({ full, rel, name }) => {
       const st = await stat(full).catch(() => null);
@@ -309,16 +326,91 @@ app.get("/api/history", async (req, res) => {
         provider: meta?.provider || "oauth",
         usage: meta?.usage || null,
         webSearchCalls: meta?.webSearchCalls || 0,
+        sessionId: meta?.sessionId || null,
+        nodeId: meta?.nodeId || null,
+        parentNodeId: meta?.parentNodeId || null,
+        clientNodeId: meta?.clientNodeId || null,
+        kind: meta?.kind || null,
       };
     }));
-    rows.sort((a, b) => b.createdAt - a.createdAt);
-    res.json({ items: rows.slice(0, limit), total: rows.length });
+
+    // composite sort: createdAt DESC, filename DESC (stable tiebreaker)
+    rows.sort((a, b) => {
+      if (b.createdAt !== a.createdAt) return b.createdAt - a.createdAt;
+      return b.filename < a.filename ? -1 : b.filename > a.filename ? 1 : 0;
+    });
+
+    let filtered = rows;
+    if (Number.isFinite(sinceTs)) {
+      filtered = filtered.filter((r) => r.createdAt > sinceTs);
+    }
+    if (Number.isFinite(beforeTs)) {
+      filtered = filtered.filter((r) => {
+        if (r.createdAt < beforeTs) return true;
+        if (r.createdAt === beforeTs && beforeFn) return r.filename < beforeFn;
+        return false;
+      });
+    }
+    if (sessionId) {
+      filtered = filtered.filter((r) => r.sessionId === sessionId);
+    }
+
+    const page = filtered.slice(0, limit);
+    const nextCursor = page.length === limit && filtered.length > limit
+      ? { before: page[page.length - 1].createdAt, beforeFilename: page[page.length - 1].filename }
+      : null;
+
+    if (groupBy === "session") {
+      // Group by sessionId while preserving createdAt DESC order overall.
+      const groups = new Map(); // sessionId|null -> { sessionId, items, lastUsedAt }
+      const loose = [];
+      for (const r of page) {
+        if (r.sessionId) {
+          let g = groups.get(r.sessionId);
+          if (!g) {
+            g = { sessionId: r.sessionId, items: [], lastUsedAt: r.createdAt };
+            groups.set(r.sessionId, g);
+          }
+          g.items.push(r);
+          if (r.createdAt > g.lastUsedAt) g.lastUsedAt = r.createdAt;
+        } else {
+          loose.push(r);
+        }
+      }
+      const sessions = Array.from(groups.values()).sort((a, b) => b.lastUsedAt - a.lastUsedAt);
+      return res.json({ sessions, loose, total: rows.length, nextCursor });
+    }
+
+    res.json({ items: page, total: rows.length, nextCursor });
   } catch (err) {
     console.error("[history] error:", err.message);
     res.status(500).json({ error: err.message });
   }
 });
 
+// ── Asset lifecycle: soft-delete to .trash/, auto-purge after TTL ──
+app.delete("/api/history/:filename", async (req, res) => {
+  try {
+    const filename = decodeURIComponent(req.params.filename);
+    const result = await trashAsset(__dirname, filename);
+    res.json(result);
+  } catch (err) {
+    res.status(err.status || 500).json({ error: err.message, code: err.code });
+  }
+});
+
+app.post("/api/history/:filename/restore", async (req, res) => {
+  try {
+    const filename = decodeURIComponent(req.params.filename);
+    const trashId = typeof req.body?.trashId === "string" ? req.body.trashId : null;
+    if (!trashId) return res.status(400).json({ error: "trashId required" });
+    const result = await restoreAsset(__dirname, trashId, filename);
+    res.json(result);
+  } catch (err) {
+    res.status(err.status || 500).json({ error: err.message });
+  }
+});
+
 // ── OAuth status ──
 app.get("/api/oauth/status", async (_req, res) => {
   try {
@@ -426,7 +518,8 @@ app.post("/api/generate", async (req, res) => {
     let totalWebSearchCalls = 0;
     for (const r of results) {
       if (r.status === "fulfilled" && r.value.b64) {
-        const filename = `${Date.now()}_${images.length}.${format}`;
+        const rand = randomBytes(4).toString("hex");
+        const filename = `${Date.now()}_${rand}_${images.length}.${format}`;
         await writeFile(join(__dirname, "generated", filename), Buffer.from(r.value.b64, "base64"));
         // Sidecar metadata for /api/history reconstruction
         const meta = {
@@ -574,7 +667,7 @@ app.post("/api/edit", async (req, res) => {
     const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
 
     await mkdir(join(__dirname, "generated"), { recursive: true });
-    const filename = `${Date.now()}.png`;
+    const filename = `${Date.now()}_${randomBytes(4).toString("hex")}.png`;
     await writeFile(join(__dirname, "generated", filename), Buffer.from(resultB64, "base64"));
     const meta = {
       prompt,
@@ -705,6 +798,8 @@ app.post("/api/node/generate", async (req, res) => {
     const meta = {
       nodeId,
       parentNodeId,
+      sessionId,
+      clientNodeId,
       prompt,
       options: { quality, size, format },
       createdAt: Date.now(),
@@ -918,7 +1013,7 @@ app.get("/api/billing", async (_req, res) => {
 // ── Start OAuth proxy as child process ──
 function startOAuthProxy() {
   console.log(`Starting openai-oauth on port ${OAUTH_PORT}...`);
-  const child = spawn("npx", ["openai-oauth", "--port", String(OAUTH_PORT)], {
+  const child = spawnBin("npx", ["openai-oauth", "--port", String(OAUTH_PORT)], {
     stdio: ["ignore", "pipe", "pipe"],
     env: { ...process.env },
   });
@@ -943,7 +1038,12 @@ function startOAuthProxy() {
 
 // ── Boot ──
 const PORT = process.env.PORT || 3333;
-const oauthChild = startOAuthProxy();
+// Tests (and some CI contexts) can opt out of the OAuth proxy subprocess.
+// The proxy is a user-facing login helper, not required for /api/health or
+// offline unit tests, and starting it on Windows CI can add 7-10s latency.
+const oauthChild = process.env.IMA2_NO_OAUTH_PROXY === "1"
+  ? null
+  : startOAuthProxy();
 
 // CLI discovery: advertise running server under ~/.ima2/server.json
 const __advertisePath = join(homedir(), ".ima2", "server.json");
@@ -971,15 +1071,9 @@ function __unadvertise() {
   } catch {}
 }
 
-process.on("SIGINT", () => {
-  __unadvertise();
-  oauthChild.kill();
-  process.exit();
-});
-process.on("SIGTERM", () => {
+onShutdown(() => {
   __unadvertise();
-  oauthChild.kill();
-  process.exit();
+  try { oauthChild?.kill(); } catch {}
 });
 process.on("exit", __unadvertise);