ima2-gen 1.0.2 → 1.0.4

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.2",
+  "version": "1.0.4",
   "description": "GPT Image 2 generator with OAuth & API key support",
   "type": "module",
   "bin": {
@@ -9,9 +9,14 @@
   "scripts": {
     "start": "node bin/ima2.js serve",
     "dev": "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 scripts/run-tests.mjs",
     "setup": "node bin/ima2.js setup",
-    "prepublishOnly": "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')\"",
+    "prepublishOnly": "npm run build && npm run lint:pkg",
+    "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"
@@ -30,19 +35,22 @@
   },
   "files": [
     "bin/",
-    "public/",
+    "lib/",
+    "ui/dist/",
     "assets/",
     "server.js",
     ".env.example",
     "README.md"
   ],
   "engines": {
-    "node": ">=18"
+    "node": ">=20"
   },
   "dependencies": {
+    "better-sqlite3": "^12.9.0",
     "dotenv": "^17.4.2",
     "express": "^5.1.0",
     "openai": "^5.8.2",
-    "openai-oauth": "^1.0.2"
+    "openai-oauth": "^1.0.2",
+    "ulid": "^3.0.2"
   }
 }