ima2-gen 1.0.2 → 1.0.4

package/bin/ima2.js

@@ -4,16 +4,33 @@ import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
 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 CONFIG_DIR = join(ROOT, ".ima2");
+const HOME = homedir();
+// 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" };
+try {
+  pkg = JSON.parse(readFileSync(join(ROOT, "package.json"), "utf-8"));
+} catch {}
 
 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 {};
 }
 
@@ -52,13 +69,13 @@ async function setup() {
 
     // Check if codex auth exists
     const hasAuth =
-      existsSync(join(process.env.HOME, ".codex", "auth.json")) ||
-      existsSync(join(process.env.HOME, ".chatgpt-local", "auth.json"));
+      existsSync(join(HOME, ".codex", "auth.json")) ||
+      existsSync(join(HOME, ".chatgpt-local", "auth.json"));
 
     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();
@@ -83,6 +100,25 @@ async function serve() {
     config = await setup();
   }
 
+  // Ensure ui/dist exists — if missing, auto-build (dev) or error (installed pkg)
+  const distIndex = join(ROOT, "ui", "dist", "index.html");
+  if (!existsSync(distIndex)) {
+    const hasUiSrc = existsSync(join(ROOT, "ui", "package.json"));
+    if (hasUiSrc) {
+      console.log("\n  ui/dist missing — running 'npm run build' first...\n");
+      try {
+        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);
+      }
+    } else {
+      console.log("\n  ui/dist not found and ui/ source is missing.");
+      console.log("  This installation appears broken. Reinstall: npm i -g ima2-gen\n");
+      process.exit(1);
+    }
+  }
+
   const env = { ...process.env };
 
   if (config.provider === "api" && config.apiKey) {
@@ -102,10 +138,154 @@ async function serve() {
   process.on("SIGTERM", () => child.kill("SIGTERM"));
 }
 
+async function showStatus() {
+  const config = loadConfig();
+  console.log(`\n  ${pkg.name} v${pkg.version}\n`);
+  console.log(`  Config file: ${CONFIG_FILE}`);
+  console.log(`  Exists: ${existsSync(CONFIG_FILE) ? "yes" : "no"}\n`);
+
+  if (config.provider) {
+    console.log(`  Provider: ${config.provider}`);
+    if (config.provider === "api") {
+      const key = config.apiKey || "";
+      console.log(`  API Key: ${key ? key.slice(0, 8) + "..." + key.slice(-4) : "not set"}`);
+    }
+    console.log("");
+  } else {
+    console.log("  Status: not configured");
+    console.log("  Run 'ima2 setup' to configure.\n");
+  }
+
+  // Check OAuth auth files
+  const hasCodexAuth = existsSync(join(HOME, ".codex", "auth.json"));
+  const hasChatgptAuth = existsSync(join(HOME, ".chatgpt-local", "auth.json"));
+  console.log(`  OAuth sessions:`);
+  console.log(`    ~/.codex/auth.json          ${hasCodexAuth ? "✓" : "✗"}`);
+  console.log(`    ~/.chatgpt-local/auth.json  ${hasChatgptAuth ? "✓" : "✗"}`);
+  console.log("");
+}
+
+async function doctor() {
+  console.log(`\n  ${pkg.name} v${pkg.version} — Doctor\n`);
+
+  let ok = 0;
+  let fail = 0;
+
+  // Node version
+  const nodeVersion = process.version;
+  const nodeMajor = parseInt(nodeVersion.slice(1).split(".")[0]);
+  if (nodeMajor >= 18) {
+    console.log(`  ✓ Node.js ${nodeVersion} (>= 18)`);
+    ok++;
+  } else {
+    console.log(`  ✗ Node.js ${nodeVersion} (requires >= 18)`);
+    fail++;
+  }
+
+  // package.json exists
+  if (existsSync(join(ROOT, "package.json"))) {
+    console.log("  ✓ package.json found");
+    ok++;
+  } else {
+    console.log("  ✗ package.json missing");
+    fail++;
+  }
+
+  // node_modules
+  if (existsSync(join(ROOT, "node_modules"))) {
+    console.log("  ✓ node_modules installed");
+    ok++;
+  } else {
+    console.log("  ✗ node_modules missing — run 'npm install'");
+    fail++;
+  }
+
+  // .env
+  if (existsSync(join(ROOT, ".env"))) {
+    console.log("  ✓ .env file exists");
+    ok++;
+  } else {
+    console.log("  ⚠ .env file not found (optional — copy from .env.example)");
+  }
+
+  // Config
+  const config = loadConfig();
+  if (config.provider) {
+    console.log(`  ✓ Configured: ${config.provider}`);
+    ok++;
+  } else {
+    console.log("  ⚠ Not configured — run 'ima2 setup'");
+  }
+
+  // Port availability (simple check)
+  const port = process.env.PORT || 3333;
+  console.log(`  ℹ Default port: ${port}`);
+
+  console.log(`\n  ${ok} passed, ${fail} failed\n`);
+  process.exit(fail > 0 ? 1 : 0);
+}
+
+function openBrowser() {
+  const port = process.env.PORT || 3333;
+  const url = `http://localhost:${port}`;
+  const res = openUrl(url);
+  if (res.ok) {
+    console.log(`\n  Opening ${url} ...\n`);
+  } else {
+    console.log(`\n  Could not open browser. Visit: ${url}\n`);
+  }
+}
+
+function showHelp() {
+  console.log(`
+  ${pkg.name} v${pkg.version} — GPT Image 2 Generator
+
+  Usage: ima2 <command> [options]
+
+  Server commands:
+    serve          Start the image generation server
+    setup, login   Configure API key or OAuth (interactive)
+    status         Show current configuration status
+    doctor         Diagnose environment and setup
+    open           Open web UI in browser
+    reset          Reset configuration
+
+  Client commands (require a running 'ima2 serve'):
+    gen <prompt>   Generate image(s) from prompt  (ima2 gen --help)
+    edit <file>    Edit an existing image         (ima2 edit --help)
+    ls             List recent history            (ima2 ls --help)
+    show <name>    Show one history item          (ima2 show --help)
+    ps             List active jobs               (ima2 ps --help)
+    ping           Ping running server / check health
+
+  Options:
+    -v, --version  Show version
+    -h, --help     Show help
+
+  Examples:
+    ima2 serve                       Start server
+    ima2 gen "a shiba in space"      Generate from CLI
+    ima2 gen "merge" --ref a.png --ref b.png -q high -o out.png
+    ima2 ls -n 10                    Last 10 generations
+    ima2 ping                        Health check
+`);
+}
+
 // ── CLI ──
 const args = process.argv.slice(2);
 const command = args[0];
 
+if (args.includes("-v") || args.includes("--version")) {
+  console.log(pkg.version);
+  process.exit(0);
+}
+
+if ((!command || args.includes("-h") || args.includes("--help"))
+    && !["gen", "edit", "ls", "show", "ps", "ping"].includes(command)) {
+  showHelp();
+  process.exit(command ? 0 : 1);
+}
+
 switch (command) {
   case "serve":
     serve();
@@ -114,21 +294,37 @@ switch (command) {
   case "login":
     setup().then(() => console.log("  Done. Run 'ima2 serve' to start."));
     break;
+  case "status":
+    showStatus();
+    break;
+  case "doctor":
+    doctor();
+    break;
+  case "open":
+    openBrowser();
+    break;
   case "reset":
     if (existsSync(CONFIG_FILE)) {
       writeFileSync(CONFIG_FILE, "{}");
       console.log("  Config reset. Run 'ima2 serve' to reconfigure.");
+    } else {
+      console.log("  No config to reset.");
     }
     break;
+  case "gen":
+  case "edit":
+  case "ls":
+  case "show":
+  case "ps":
+  case "ping": {
+    const { setCliVersion } = await import("./lib/client.js");
+    setCliVersion(pkg.version);
+    const mod = await import(`./commands/${command}.js`);
+    await mod.default(args.slice(1));
+    break;
+  }
   default:
-    console.log(`
-  ima2-gen — GPT Image 2 Generator
-
-  Usage:
-    ima2 serve     Start the image generation server
-    ima2 setup     Configure API key or OAuth (interactive)
-    ima2 reset     Reset configuration
-
-  First run of 'ima2 serve' will prompt for setup automatically.
-`);
+    console.log(`  Unknown command: "${command}"`);
+    console.log("  Run 'ima2 --help' for usage.\n");
+    process.exit(1);
 }

package/bin/lib/args.js

@@ -0,0 +1,73 @@
+// Tiny argv parser — no dependencies.
+// Supports: --long, --long=val, --long val, -s, -s val, repeatable flags, positional, --.
+
+export function parseArgs(argv, spec = {}) {
+  const shortMap = {};
+  for (const [name, def] of Object.entries(spec.flags || {})) {
+    if (def.short) shortMap[def.short] = name;
+  }
+
+  const out = { positional: [], _unknown: [] };
+  for (const [name, def] of Object.entries(spec.flags || {})) {
+    if (def.repeatable) out[name] = [];
+    else if ("default" in def) out[name] = def.default;
+  }
+
+  let i = 0;
+  let doubleDashSeen = false;
+  while (i < argv.length) {
+    const a = argv[i];
+    if (doubleDashSeen) {
+      out.positional.push(a);
+      i++;
+      continue;
+    }
+    if (a === "--") {
+      doubleDashSeen = true;
+      i++;
+      continue;
+    }
+    if (a.startsWith("--")) {
+      const eq = a.indexOf("=");
+      const name = eq > -1 ? a.slice(2, eq) : a.slice(2);
+      const def = (spec.flags || {})[name];
+      if (!def) {
+        out._unknown.push(a);
+        i++;
+        continue;
+      }
+      if (def.type === "boolean") {
+        out[name] = true;
+        i++;
+      } else {
+        const val = eq > -1 ? a.slice(eq + 1) : argv[i + 1];
+        if (eq === -1) i++;
+        if (def.repeatable) out[name].push(val);
+        else out[name] = val;
+        i++;
+      }
+    } else if (a.startsWith("-") && a.length > 1 && !/^-\d/.test(a)) {
+      const short = a.slice(1);
+      const name = shortMap[short];
+      if (!name) {
+        out._unknown.push(a);
+        i++;
+        continue;
+      }
+      const def = spec.flags[name];
+      if (def.type === "boolean") {
+        out[name] = true;
+        i++;
+      } else {
+        const val = argv[i + 1];
+        if (def.repeatable) out[name].push(val);
+        else out[name] = val;
+        i += 2;
+      }
+    } else {
+      out.positional.push(a);
+      i++;
+    }
+  }
+  return out;
+}

package/bin/lib/client.js

@@ -0,0 +1,97 @@
+import { readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+export const DEFAULT_PORT = 3333;
+
+function readAdvertise() {
+  const p = join(homedir(), ".ima2", "server.json");
+  if (!existsSync(p)) return null;
+  try {
+    return JSON.parse(readFileSync(p, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+async function probe(base, timeoutMs = 600) {
+  try {
+    const r = await fetch(`${base}/api/health`, { signal: AbortSignal.timeout(timeoutMs) });
+    if (!r.ok) return null;
+    return await r.json();
+  } catch {
+    return null;
+  }
+}
+
+export async function resolveServer({ serverFlag } = {}) {
+  if (serverFlag) {
+    const base = serverFlag.replace(/\/$/, "");
+    const health = await probe(base);
+    if (health) return { base, health };
+    const err = new Error(`server unreachable at ${base}`);
+    err.code = "SERVER_UNREACHABLE";
+    throw err;
+  }
+  const candidates = [];
+  if (process.env.IMA2_SERVER) candidates.push(process.env.IMA2_SERVER.replace(/\/$/, ""));
+  const adv = readAdvertise();
+  if (adv?.port) candidates.push(`http://localhost:${adv.port}`);
+  candidates.push(`http://localhost:${DEFAULT_PORT}`);
+
+  const seen = new Set();
+  const uniq = candidates.filter((c) => !seen.has(c) && seen.add(c));
+
+  for (const base of uniq) {
+    const health = await probe(base);
+    if (health) return { base, health };
+  }
+  const err = new Error("server unreachable — is 'ima2 serve' running?");
+  err.code = "SERVER_UNREACHABLE";
+  throw err;
+}
+
+export async function request(base, path, { method = "GET", body, timeoutMs = 180_000 } = {}) {
+  const res = await fetch(base + path, {
+    method,
+    headers: {
+      "Content-Type": "application/json",
+      "X-ima2-client": `cli/${CLI_VERSION}`,
+    },
+    body: body !== undefined ? JSON.stringify(body) : undefined,
+    signal: AbortSignal.timeout(timeoutMs),
+  });
+  const text = await res.text();
+  let json = null;
+  try { json = JSON.parse(text); } catch {}
+  if (!res.ok) {
+    const err = new Error(json?.error || `HTTP ${res.status}`);
+    err.status = res.status;
+    err.code = json?.code || null;
+    err.body = json || text;
+    throw err;
+  }
+  return json;
+}
+
+export function normalizeGenerate(resp) {
+  if (!resp) return { images: [], elapsed: null, requestId: null };
+  if (Array.isArray(resp.images)) {
+    return {
+      images: resp.images.map((it) => ({ image: it.image, filename: it.filename })),
+      elapsed: resp.elapsed ?? null,
+      requestId: resp.requestId ?? null,
+    };
+  }
+  if (resp.image) {
+    return {
+      images: [{ image: resp.image, filename: resp.filename || null }],
+      elapsed: resp.elapsed ?? null,
+      requestId: resp.requestId ?? null,
+    };
+  }
+  return { images: [], elapsed: resp.elapsed ?? null, requestId: resp.requestId ?? null };
+}
+
+export let CLI_VERSION = "dev";
+export function setCliVersion(v) { CLI_VERSION = v; }

package/bin/lib/files.js

@@ -0,0 +1,39 @@
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { dirname, extname, basename, join } from "node:path";
+
+const MIME = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  webp: "image/webp",
+};
+
+export async function fileToDataUri(path) {
+  const b64 = (await readFile(path)).toString("base64");
+  const ext = extname(path).slice(1).toLowerCase();
+  const mime = MIME[ext] || "image/png";
+  return `data:${mime};base64,${b64}`;
+}
+
+export async function dataUriToFile(dataUri, outPath) {
+  const m = dataUri.match(/^data:([^;]+);base64,(.+)$/);
+  const raw = m ? m[2] : dataUri;
+  await mkdir(dirname(outPath) || ".", { recursive: true });
+  await writeFile(outPath, Buffer.from(raw, "base64"));
+  return outPath;
+}
+
+export function defaultOutName(index, total, ext = "png") {
+  const now = new Date();
+  const pad = (n) => String(n).padStart(2, "0");
+  const stamp = `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}-${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`;
+  if (total <= 1) return `ima2-${stamp}.${ext}`;
+  return `ima2-${stamp}-${index}.${ext}`;
+}
+
+export async function readStdin() {
+  if (process.stdin.isTTY) return "";
+  const chunks = [];
+  for await (const c of process.stdin) chunks.push(c);
+  return Buffer.concat(chunks).toString("utf-8").trim();
+}

package/bin/lib/output.js

@@ -0,0 +1,48 @@
+const isTty = process.stdout.isTTY && !process.env.NO_COLOR;
+
+export const color = {
+  dim:    (s) => (isTty ? `\x1b[2m${s}\x1b[0m` : s),
+  bold:   (s) => (isTty ? `\x1b[1m${s}\x1b[0m` : s),
+  red:    (s) => (isTty ? `\x1b[31m${s}\x1b[0m` : s),
+  green:  (s) => (isTty ? `\x1b[32m${s}\x1b[0m` : s),
+  yellow: (s) => (isTty ? `\x1b[33m${s}\x1b[0m` : s),
+  cyan:   (s) => (isTty ? `\x1b[36m${s}\x1b[0m` : s),
+};
+
+export function out(msg = "") { process.stdout.write(msg + "\n"); }
+export function err(msg = "") { process.stderr.write(msg + "\n"); }
+
+export function die(code, msg) {
+  if (msg) err(color.red("✗ ") + msg);
+  process.exit(code);
+}
+
+export function json(obj) {
+  process.stdout.write(JSON.stringify(obj) + "\n");
+}
+
+export function table(rows, columns) {
+  if (rows.length === 0) return;
+  const widths = columns.map((c) =>
+    Math.max(c.label.length, ...rows.map((r) => {
+      const v = c.format ? c.format(r[c.key], r) : r[c.key];
+      return String(v ?? "").length;
+    })),
+  );
+  const pad = (s, w) => String(s ?? "").padEnd(w);
+  out(color.dim(columns.map((c, i) => pad(c.label, widths[i])).join("  ")));
+  out(color.dim(widths.map((w) => "─".repeat(w)).join("  ")));
+  for (const r of rows) {
+    out(columns.map((c, i) => pad(c.format ? c.format(r[c.key], r) : r[c.key], widths[i])).join("  "));
+  }
+}
+
+export function exitCodeForError(e) {
+  if (e.code === "SERVER_UNREACHABLE") return 3;
+  if (e.code === "APIKEY_DISABLED") return 4;
+  if (e.code === "SAFETY_REFUSAL") return 7;
+  if (e.name === "TimeoutError" || /abort/i.test(e.message || "")) return 8;
+  if (e.status >= 500) return 6;
+  if (e.status >= 400) return 5;
+  return 1;
+}

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.
+    }
+  }
+}
+