ima2-gen 1.1.7 → 1.1.9

package/bin/commands/metadata.js

@@ -0,0 +1,45 @@
+import { parseArgs } from "../lib/args.js";
+import { resolveServer, request } from "../lib/client.js";
+import { fileToDataUri } from "../lib/files.js";
+import { out, die, json, exitCodeForError } from "../lib/output.js";
+const SPEC = {
+    flags: {
+        json: { type: "boolean" },
+        server: { type: "string" },
+        help: { short: "h", type: "boolean" },
+    },
+};
+const HELP = `
+  ima2 metadata <imagefile> [--json]
+
+  Read embedded metadata from any local image file.
+  POSTs { dataUrl } to /api/metadata/read.
+`;
+export default async function metadataCmd(argv) {
+    const args = parseArgs(argv, SPEC);
+    if (args.help) {
+        out(HELP);
+        return;
+    }
+    const file = args.positional[0];
+    if (!file)
+        die(2, "image file required");
+    const dataUrl = await fileToDataUri(file);
+    let server;
+    try {
+        server = await resolveServer({ serverFlag: args.server });
+    }
+    catch (e) {
+        die(exitCodeForError(e), e.message);
+        throw e;
+    }
+    const resp = await request(server.base, "/api/metadata/read", {
+        method: "POST",
+        body: { dataUrl },
+    }).catch((e) => die(exitCodeForError(e), `${e.message}${e.code ? ` (${e.code})` : ""}`));
+    if (args.json) {
+        json(resp);
+    }
+    else
+        out(JSON.stringify(resp, null, 2));
+}

package/bin/commands/metadata.ts

@@ -0,0 +1,36 @@
+import { parseArgs } from "../lib/args.js";
+import { resolveServer, request } from "../lib/client.js";
+import { fileToDataUri } from "../lib/files.js";
+import { out, die, json, exitCodeForError } from "../lib/output.js";
+
+const SPEC = {
+  flags: {
+    json: { type: "boolean" },
+    server: { type: "string" },
+    help: { short: "h", type: "boolean" },
+  },
+};
+
+const HELP = `
+  ima2 metadata <imagefile> [--json]
+
+  Read embedded metadata from any local image file.
+  POSTs { dataUrl } to /api/metadata/read.
+`;
+
+export default async function metadataCmd(argv) {
+  const args = parseArgs(argv, SPEC);
+  if (args.help) { out(HELP); return; }
+  const file = args.positional[0];
+  if (!file) die(2, "image file required");
+  const dataUrl = await fileToDataUri(file);
+  let server;
+  try { server = await resolveServer({ serverFlag: args.server }); }
+  catch (e: any) { die(exitCodeForError(e), e.message); throw e; }
+  const resp = await request(server.base, "/api/metadata/read", {
+    method: "POST",
+    body: { dataUrl },
+  }).catch((e) => die(exitCodeForError(e), `${e.message}${e.code ? ` (${e.code})` : ""}`));
+  if (args.json) { json(resp); }
+  else out(JSON.stringify(resp, null, 2));
+}

package/bin/commands/multimode.js

@@ -0,0 +1,159 @@
+import { parseArgs } from "../lib/args.js";
+import { resolveServer } from "../lib/client.js";
+import { streamSse } from "../lib/sse.js";
+import { dataUriToFile, defaultOutName } from "../lib/files.js";
+import { out, die, color, json, exitCodeForError } from "../lib/output.js";
+import { config } from "../../config.js";
+const SPEC = {
+    flags: {
+        quality: { short: "q", type: "string", default: "low" },
+        size: { short: "s", type: "string", default: "1024x1024" },
+        "max-images": { type: "string", default: "4" },
+        out: { short: "o", type: "string" },
+        "out-dir": { short: "d", type: "string" },
+        json: { type: "boolean" },
+        timeout: { type: "string", default: "600" },
+        server: { type: "string" },
+        model: { type: "string" },
+        "reasoning-effort": { type: "string" },
+        "web-search": { type: "boolean" },
+        "no-web-search": { type: "boolean" },
+        moderation: { type: "string", default: "low" },
+        session: { type: "string" },
+        "show-partial": { type: "boolean" },
+        help: { short: "h", type: "boolean" },
+    },
+};
+const HELP = `
+  ima2 multimode <prompt...> [options]
+
+  Stream multi-image generation via SSE (phase / partial / image / done / error).
+
+  Options:
+    -q, --quality <low|medium|high>     Default: low
+    -s, --size <WxH>                    Default: 1024x1024
+        --max-images <1..8>             Default: 4
+    -o, --out <file>                    First image (implies --max-images 1)
+    -d, --out-dir <dir>                 Output dir for multiple images
+        --json
+        --model <gpt-5.5|gpt-5.4|gpt-5.4-mini>
+        --reasoning-effort <none|low|medium|high|xhigh>
+        --web-search / --no-web-search
+        --moderation <auto|low>
+        --session <id>
+        --show-partial                  Print [partial #N received] notices
+        --timeout <sec>                 Default: 600
+`;
+export default async function multimodeCmd(argv) {
+    const args = parseArgs(argv, SPEC);
+    if (args.help) {
+        out(HELP);
+        return;
+    }
+    const prompt = args.positional.join(" ");
+    if (!prompt)
+        die(2, "prompt required");
+    const VALID_REASONING = new Set(["none", "low", "medium", "high", "xhigh"]);
+    if (args["reasoning-effort"] && !VALID_REASONING.has(args["reasoning-effort"])) {
+        die(2, "--reasoning-effort must be one of: none, low, medium, high, xhigh");
+    }
+    if (args["web-search"] && args["no-web-search"]) {
+        die(2, "--web-search and --no-web-search are mutually exclusive");
+    }
+    let server;
+    try {
+        server = await resolveServer({ serverFlag: args.server });
+    }
+    catch (e) {
+        die(exitCodeForError(e), e.message);
+        throw e;
+    }
+    const maxImages = Math.max(1, Math.min(8, parseInt(args["max-images"]) || 4));
+    const body = {
+        prompt,
+        quality: args.quality,
+        size: args.size,
+        maxImages,
+        moderation: args.moderation,
+        sessionId: args.session,
+    };
+    if (args.model)
+        body.model = args.model;
+    if (args["reasoning-effort"])
+        body.reasoningEffort = args["reasoning-effort"];
+    if (args["no-web-search"])
+        body.webSearchEnabled = false;
+    else if (args["web-search"])
+        body.webSearchEnabled = true;
+    const ac = new AbortController();
+    const onSig = () => { ac.abort(); process.exit(130); };
+    process.once("SIGINT", onSig);
+    process.once("SIGTERM", onSig);
+    const url = `${server.base}/api/generate/multimode`;
+    const images = [];
+    let doneInfo = null;
+    try {
+        for await (const ev of streamSse(url, { body, signal: ac.signal })) {
+            switch (ev.event) {
+                case "phase":
+                    if (!args.json)
+                        out(color.dim(`[phase] ${ev.data.phase} (max ${ev.data.maxImages ?? maxImages})`));
+                    break;
+                case "partial":
+                    if (args["show-partial"] && !args.json) {
+                        const len = (ev.data.image || "").length;
+                        out(color.dim(`[partial #${ev.data.index}] (${len}B preview)`));
+                    }
+                    break;
+                case "image":
+                    images.push(ev.data);
+                    if (!args.json)
+                        out(color.green(`✓ image ${images.length}`));
+                    break;
+                case "done":
+                    doneInfo = ev.data;
+                    break;
+                case "error":
+                    die(1, `multimode error: ${ev.data.error || ev.data}${ev.data.code ? ` (${ev.data.code})` : ""}`);
+            }
+        }
+    }
+    catch (e) {
+        if (e.name === "AbortError")
+            return;
+        die(exitCodeForError(e), `${e.message}${e.code ? ` (${e.code})` : ""}`);
+    }
+    // Save images
+    const outDir = args["out-dir"] || null;
+    const explicitOut = args.out || null;
+    if (explicitOut && images.length > 1) {
+        if (!args.json)
+            out(color.yellow(`(received ${images.length} images, --out only saves first)`));
+    }
+    const savedPaths = [];
+    for (let i = 0; i < images.length; i++) {
+        const im = images[i];
+        if (!im.image)
+            continue;
+        let target;
+        if (explicitOut && i === 0)
+            target = explicitOut;
+        else if (outDir)
+            target = `${outDir}/${defaultOutName(i, images.length)}`;
+        else
+            target = `${config.storage.generatedDir}/${defaultOutName(i, images.length)}`;
+        if (target) {
+            await dataUriToFile(im.image, target);
+            savedPaths.push(target);
+        }
+    }
+    if (args.json) {
+        json({ ok: true, requestId: doneInfo?.requestId, returned: doneInfo?.returned, paths: savedPaths });
+    }
+    else {
+        for (const p of savedPaths)
+            out(color.green("✓ ") + p);
+        if (doneInfo)
+            out(color.dim(`done: ${doneInfo.returned}/${doneInfo.requested ?? maxImages}`));
+    }
+}

package/bin/commands/multimode.ts

@@ -0,0 +1,146 @@
+import { writeFile } from "fs/promises";
+import { parseArgs } from "../lib/args.js";
+import { resolveServer } from "../lib/client.js";
+import { streamSse } from "../lib/sse.js";
+import { dataUriToFile, defaultOutName } from "../lib/files.js";
+import { out, die, color, json, exitCodeForError } from "../lib/output.js";
+import { config } from "../../config.js";
+
+const SPEC = {
+  flags: {
+    quality: { short: "q", type: "string", default: "low" },
+    size:    { short: "s", type: "string", default: "1024x1024" },
+    "max-images": { type: "string", default: "4" },
+    out:     { short: "o", type: "string" },
+    "out-dir": { short: "d", type: "string" },
+    json:    { type: "boolean" },
+    timeout: { type: "string", default: "600" },
+    server:  { type: "string" },
+    model:   { type: "string" },
+    "reasoning-effort": { type: "string" },
+    "web-search":    { type: "boolean" },
+    "no-web-search": { type: "boolean" },
+    moderation: { type: "string", default: "low" },
+    session: { type: "string" },
+    "show-partial": { type: "boolean" },
+    help: { short: "h", type: "boolean" },
+  },
+};
+
+const HELP = `
+  ima2 multimode <prompt...> [options]
+
+  Stream multi-image generation via SSE (phase / partial / image / done / error).
+
+  Options:
+    -q, --quality <low|medium|high>     Default: low
+    -s, --size <WxH>                    Default: 1024x1024
+        --max-images <1..8>             Default: 4
+    -o, --out <file>                    First image (implies --max-images 1)
+    -d, --out-dir <dir>                 Output dir for multiple images
+        --json
+        --model <gpt-5.5|gpt-5.4|gpt-5.4-mini>
+        --reasoning-effort <none|low|medium|high|xhigh>
+        --web-search / --no-web-search
+        --moderation <auto|low>
+        --session <id>
+        --show-partial                  Print [partial #N received] notices
+        --timeout <sec>                 Default: 600
+`;
+
+export default async function multimodeCmd(argv) {
+  const args = parseArgs(argv, SPEC);
+  if (args.help) { out(HELP); return; }
+  const prompt = args.positional.join(" ");
+  if (!prompt) die(2, "prompt required");
+
+  const VALID_REASONING = new Set(["none", "low", "medium", "high", "xhigh"]);
+  if (args["reasoning-effort"] && !VALID_REASONING.has(args["reasoning-effort"])) {
+    die(2, "--reasoning-effort must be one of: none, low, medium, high, xhigh");
+  }
+  if (args["web-search"] && args["no-web-search"]) {
+    die(2, "--web-search and --no-web-search are mutually exclusive");
+  }
+
+  let server;
+  try { server = await resolveServer({ serverFlag: args.server }); }
+  catch (e: any) { die(exitCodeForError(e), e.message); throw e; }
+
+  const maxImages = Math.max(1, Math.min(8, parseInt(args["max-images"]) || 4));
+  const body: any = {
+    prompt,
+    quality: args.quality,
+    size: args.size,
+    maxImages,
+    moderation: args.moderation,
+    sessionId: args.session,
+  };
+  if (args.model) body.model = args.model;
+  if (args["reasoning-effort"]) body.reasoningEffort = args["reasoning-effort"];
+  if (args["no-web-search"]) body.webSearchEnabled = false;
+  else if (args["web-search"]) body.webSearchEnabled = true;
+
+  const ac = new AbortController();
+  const onSig = () => { ac.abort(); process.exit(130); };
+  process.once("SIGINT", onSig);
+  process.once("SIGTERM", onSig);
+
+  const url = `${server.base}/api/generate/multimode`;
+  const images: any[] = [];
+  let doneInfo: any = null;
+  try {
+    for await (const ev of streamSse(url, { body, signal: ac.signal })) {
+      switch (ev.event) {
+        case "phase":
+          if (!args.json) out(color.dim(`[phase] ${ev.data.phase} (max ${ev.data.maxImages ?? maxImages})`));
+          break;
+        case "partial":
+          if (args["show-partial"] && !args.json) {
+            const len = (ev.data.image || "").length;
+            out(color.dim(`[partial #${ev.data.index}] (${len}B preview)`));
+          }
+          break;
+        case "image":
+          images.push(ev.data);
+          if (!args.json) out(color.green(`✓ image ${images.length}`));
+          break;
+        case "done":
+          doneInfo = ev.data;
+          break;
+        case "error":
+          die(1, `multimode error: ${ev.data.error || ev.data}${ev.data.code ? ` (${ev.data.code})` : ""}`);
+      }
+    }
+  } catch (e: any) {
+    if (e.name === "AbortError") return;
+    die(exitCodeForError(e), `${e.message}${e.code ? ` (${e.code})` : ""}`);
+  }
+
+  // Save images
+  const outDir = args["out-dir"] || null;
+  const explicitOut = args.out || null;
+  if (explicitOut && images.length > 1) {
+    if (!args.json) out(color.yellow(`(received ${images.length} images, --out only saves first)`));
+  }
+
+  const savedPaths: string[] = [];
+  for (let i = 0; i < images.length; i++) {
+    const im = images[i];
+    if (!im.image) continue;
+    let target;
+    if (explicitOut && i === 0) target = explicitOut;
+    else if (outDir) target = `${outDir}/${defaultOutName(i, images.length)}`;
+    else target = `${config.storage.generatedDir}/${defaultOutName(i, images.length)}`;
+    if (target) {
+      await dataUriToFile(im.image, target);
+      savedPaths.push(target);
+    }
+  }
+
+  if (args.json) {
+    json({ ok: true, requestId: doneInfo?.requestId, returned: doneInfo?.returned, paths: savedPaths });
+  } else {
+    for (const p of savedPaths) out(color.green("✓ ") + p);
+    if (doneInfo) out(color.dim(`done: ${doneInfo.returned}/${doneInfo.requested ?? maxImages}`));
+  }
+}

package/bin/commands/node.js

@@ -0,0 +1,176 @@
+import { parseArgs } from "../lib/args.js";
+import { resolveServer, request } from "../lib/client.js";
+import { streamSse } from "../lib/sse.js";
+import { fileToDataUri, dataUriToFile, defaultOutName } from "../lib/files.js";
+import { out, die, color, json, exitCodeForError } from "../lib/output.js";
+import { config } from "../../config.js";
+const HELP = `
+  ima2 node <subcommand> [options]
+
+  Subcommands:
+    generate <prompt...> [--parent <nodeId>] [--ref <file>...] [--no-stream] [...gen-style flags]
+    show <nodeId> [--json]
+`;
+const GEN_FLAGS = {
+    quality: { short: "q", type: "string", default: "low" },
+    size: { short: "s", type: "string", default: "1024x1024" },
+    count: { short: "n", type: "string", default: "1" },
+    ref: { type: "string", repeatable: true },
+    out: { short: "o", type: "string" },
+    json: { type: "boolean" },
+    timeout: { type: "string", default: "600" },
+    server: { type: "string" },
+    model: { type: "string" },
+    parent: { type: "string" },
+    "reasoning-effort": { type: "string" },
+    "web-search": { type: "boolean" },
+    "no-web-search": { type: "boolean" },
+    moderation: { type: "string", default: "low" },
+    session: { type: "string" },
+    "no-stream": { type: "boolean" },
+    help: { short: "h", type: "boolean" },
+};
+const SHOW_FLAGS = {
+    json: { type: "boolean" },
+    server: { type: "string" },
+    help: { short: "h", type: "boolean" },
+};
+async function getServer(args) {
+    try {
+        return await resolveServer({ serverFlag: args.server });
+    }
+    catch (e) {
+        die(exitCodeForError(e), e.message);
+        throw e;
+    }
+}
+async function generateSub(argv) {
+    const args = parseArgs(argv, { flags: GEN_FLAGS });
+    if (args.help) {
+        out(HELP);
+        return;
+    }
+    const prompt = args.positional.join(" ");
+    if (!prompt)
+        die(2, "prompt required");
+    const refs = args.ref || [];
+    const VALID_REASONING = new Set(["none", "low", "medium", "high", "xhigh"]);
+    if (args["reasoning-effort"] && !VALID_REASONING.has(args["reasoning-effort"])) {
+        die(2, "--reasoning-effort must be one of: none, low, medium, high, xhigh");
+    }
+    if (args["web-search"] && args["no-web-search"]) {
+        die(2, "--web-search and --no-web-search are mutually exclusive");
+    }
+    const references = await Promise.all(refs.map((p) => fileToDataUri(p)));
+    const server = await getServer(args);
+    const body = {
+        prompt,
+        quality: args.quality,
+        size: args.size,
+        n: Math.max(1, Math.min(8, parseInt(args.count) || 1)),
+        references,
+        moderation: args.moderation,
+        sessionId: args.session,
+    };
+    if (args.model)
+        body.model = args.model;
+    if (args.parent)
+        body.parentNodeId = args.parent;
+    if (args["reasoning-effort"])
+        body.reasoningEffort = args["reasoning-effort"];
+    if (args["no-web-search"])
+        body.webSearchEnabled = false;
+    else if (args["web-search"])
+        body.webSearchEnabled = true;
+    if (args["no-stream"]) {
+        const resp = await request(server.base, "/api/node/generate", {
+            method: "POST",
+            body,
+            timeoutMs: (parseInt(args.timeout) || 600) * 1000,
+        }).catch((e) => die(exitCodeForError(e), `${e.message}${e.code ? ` (${e.code})` : ""}`));
+        if (args.json) {
+            json(resp);
+            return;
+        }
+        out(color.green("✓ node ") + (resp?.node?.id || "(no id)"));
+        return;
+    }
+    const ac = new AbortController();
+    const onSig = () => { ac.abort(); process.exit(130); };
+    process.once("SIGINT", onSig);
+    process.once("SIGTERM", onSig);
+    const url = `${server.base}/api/node/generate`;
+    const images = [];
+    let doneInfo = null;
+    try {
+        for await (const ev of streamSse(url, { body, signal: ac.signal })) {
+            switch (ev.event) {
+                case "phase":
+                    if (!args.json)
+                        out(color.dim(`[phase] ${ev.data.phase || ev.data}`));
+                    break;
+                case "partial":
+                    if (!args.json)
+                        out(color.dim(`[partial #${ev.data.index ?? "?"}]`));
+                    break;
+                case "image":
+                    images.push(ev.data);
+                    if (!args.json)
+                        out(color.green(`✓ image ${images.length}`));
+                    break;
+                case "done":
+                    doneInfo = ev.data;
+                    break;
+                case "error":
+                    die(1, `node generate error: ${ev.data.error || ev.data}${ev.data.code ? ` (${ev.data.code})` : ""}`);
+            }
+        }
+    }
+    catch (e) {
+        if (e.name === "AbortError")
+            return;
+        die(exitCodeForError(e), `${e.message}${e.code ? ` (${e.code})` : ""}`);
+    }
+    const savedPaths = [];
+    for (let i = 0; i < images.length; i++) {
+        const im = images[i];
+        if (!im.image)
+            continue;
+        const target = args.out && i === 0
+            ? args.out
+            : `${config.storage.generatedDir}/${defaultOutName(i, images.length)}`;
+        await dataUriToFile(im.image, target);
+        savedPaths.push(target);
+    }
+    if (args.json) {
+        json({ ok: true, paths: savedPaths, doneInfo });
+    }
+    else {
+        for (const p of savedPaths)
+            out(color.green("✓ ") + p);
+    }
+}
+async function showSub(argv) {
+    const args = parseArgs(argv, { flags: SHOW_FLAGS });
+    const id = args.positional[0];
+    if (!id)
+        die(2, "nodeId required");
+    const server = await getServer(args);
+    const resp = await request(server.base, `/api/node/${encodeURIComponent(id)}`).catch((e) => die(exitCodeForError(e), e.message));
+    json(resp);
+}
+const SUB = {
+    generate: generateSub,
+    show: showSub,
+};
+export default async function nodeCmd(argv) {
+    const sub = argv[0];
+    if (!sub || sub === "--help" || sub === "-h") {
+        out(HELP);
+        return;
+    }
+    const handler = SUB[sub];
+    if (!handler)
+        die(2, `unknown subcommand: ${sub}\n${HELP}`);
+    return handler(argv.slice(1));
+}