ima2-gen 1.1.21 → 1.1.22

package/bin/commands/gen.ts

@@ -1,214 +0,0 @@
-import { parseArgs } from "../lib/args.js";
-import { resolveServer, request, normalizeGenerate } from "../lib/client.js";
-import { fileToDataUri, dataUriToFile, defaultOutName, readStdin } from "../lib/files.js";
-import { out, die, dieWithError, color, json } from "../lib/output.js";
-import { config } from "../../config.js";
-import { createCliRequestId, recoverGeneratedOutputs, formatRecoveryHint } from "../lib/recover-output.js";
-
-import { errInfo } from "../../lib/errInfo.js";
-const VALID_MODES = new Set(["auto", "direct"]);
-const VALID_MODERATION = new Set(["auto", "low"]);
-const VALID_PROVIDERS = new Set(["auto", "oauth", "api", "grok"]);
-const KNOWN_IMAGE_MODELS = new Set(["gpt-5.5", "gpt-5.4", "gpt-5.4-mini", "gpt-5.3-codex-spark", "grok-imagine-image", "grok-imagine-image-quality"]);
-
-const SPEC = {
-  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" },
-    "out-dir": { short: "d", type: "string" },
-    json:      {              type: "boolean" },
-    "no-save": {              type: "boolean" },
-    force:     {              type: "boolean" },
-    stdin:     {              type: "boolean" },
-    timeout:   {              type: "string", default: "180" },
-    server:    {              type: "string" },
-    model:     {              type: "string" },
-    provider:  {              type: "string" },
-    mode:      {              type: "string", default: "auto" },
-    moderation: {              type: "string", default: "low" },
-    session:   {              type: "string" },
-    "reasoning-effort": {     type: "string" },
-    "web-search":      {     type: "boolean" },
-    "no-web-search":   {     type: "boolean" },
-    help:      { short: "h", type: "boolean" },
-  },
-};
-
-const HELP = `
-  ima2 gen <prompt...> [options]
-
-  Generate image(s) via the running ima2 server.
-
-  Options:
-    -q, --quality <low|medium|high>         Default: low
-    -s, --size <WxH | auto>                 Default: 1024x1024
-    -n, --count <1..8>                      Default: 1
-        --ref <file>                        Attach reference image (repeatable, max 5)
-    -o, --out <file>                        Single-image output path (implies -n 1)
-    -d, --out-dir <dir>                     Output dir for multiple images
-        --json                              Print JSON result to stdout
-        --no-save                           Skip save; print b64 to stdout (use --force for TTY)
-        --stdin                              Read prompt from stdin
-        --timeout <sec>                     Default: 180
-        --server <url>                      Override server URL
-        --model <gpt-5.5|gpt-5.4|gpt-5.4-mini|grok-imagine-image|grok-imagine-image-quality>
-        --provider <auto|oauth|api|grok>    Provider (oauth = GPT OAuth; grok = xAI Grok)
-        --mode <auto|direct>                Prompt handling mode. Default: auto
-        --moderation <auto|low>             Default: low
-        --session <id>                      Apply session style sheet if enabled
-        --reasoning-effort <none|low|medium|high|xhigh>
-                                            Override server's reasoning effort
-        --web-search / --no-web-search      Override default web-search toggle
-
-  Examples:
-    ima2 gen "a shiba in space"
-    ima2 gen "poster" --model gpt-5.4 --mode direct --moderation low
-    ima2 gen "merge" --ref a.png --ref b.png -q high -o out.png
-    cat prompt.txt | ima2 gen --stdin -n 2 -d ./out
-`;
-
-export default async function genCmd(argv: string[]) {
-  const args = parseArgs(argv, SPEC);
-  if (args.help) { out(HELP); return; }
-
-  let prompt = args.positional.join(" ");
-  if (args.stdin) {
-    const piped = await readStdin();
-    if (piped) prompt = prompt ? `${prompt} ${piped}` : piped;
-  }
-  if (!prompt) die(2, "prompt is required (positional or via --stdin)");
-
-  const refs = (Array.isArray(args.ref) ? args.ref : []) as string[];
-  if (refs.length > 5) die(2, "max 5 --ref attachments");
-  if (!VALID_MODES.has(String(args.mode))) die(2, "--mode must be one of: auto, direct");
-  if (!VALID_MODERATION.has(String(args.moderation))) die(2, "--moderation must be one of: auto, low");
-  if (args.provider && !VALID_PROVIDERS.has(String(args.provider))) {
-    die(2, "--provider must be one of: auto, oauth, api, grok");
-  }
-  if (args.model && !KNOWN_IMAGE_MODELS.has(String(args.model))) {
-    die(2, "--model must be one of: gpt-5.5, gpt-5.4, gpt-5.4-mini, gpt-5.3-codex-spark, grok-imagine-image, grok-imagine-image-quality");
-  }
-  const VALID_REASONING = new Set(["none", "low", "medium", "high", "xhigh"]);
-  if (args["reasoning-effort"] && !VALID_REASONING.has(String(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 n = Math.max(1, Math.min(8, parseInt(String(args.count)) || 1));
-  const timeoutMs = (parseInt(String(args.timeout)) || 180) * 1000;
-
-  let server;
-  try {
-    server = await resolveServer({ serverFlag: args.server });
-  } catch (e) {
-    const err = errInfo(e);
-    if (args.json) json({ ok: false, error: err.message, code: err.code, status: err.status });
-    dieWithError(e);
-  }
-
-  const references = await Promise.all(refs.map((p: string) => fileToDataUri(p)));
-
-  const outDir = args["out-dir"] ? String(args["out-dir"]) : null;
-  const explicitOut = args.out ? String(args.out) : null;
-  const requestId = createCliRequestId("req_cli_gen");
-
-  const body: any = {
-    prompt,
-    quality: args.quality,
-    size: args.size,
-    n,
-    references,
-    model: args.model,
-    mode: args.mode,
-    moderation: args.moderation,
-    sessionId: args.session,
-    requestId,
-  };
-  if (args["reasoning-effort"]) body.reasoningEffort = args["reasoning-effort"];
-  if (args.provider) body.provider = args.provider;
-  if (args["no-web-search"]) body.webSearchEnabled = false;
-  else if (args["web-search"]) body.webSearchEnabled = true;
-
-  let resp;
-  try {
-    resp = await request(server.base, "/api/generate", {
-      method: "POST",
-      body,
-      timeoutMs,
-      headers: { "X-Request-Id": requestId },
-    });
-  } catch (e) {
-    const err = errInfo(e);
-    const isTimeout = err.name === "TimeoutError" || err.name === "AbortError";
-    if (isTimeout && (explicitOut || outDir)) {
-      const result = await recoverGeneratedOutputs(server.base, requestId, {
-        explicitOut,
-        outDir,
-        expectedCount: n,
-        json: Boolean(args.json),
-      });
-      if (result.recovered) {
-        if (args.json) {
-          json({ ok: true, requestId, recovered: true, images: result.paths.map((p) => ({ path: p })) });
-        } else {
-          out(formatRecoveryHint(result));
-          for (const p of result.paths) out(color.green("✓ ") + p + color.dim(" (recovered)"));
-        }
-        return;
-      }
-      if (!args.json) out(formatRecoveryHint(result));
-    }
-    if (args.json) json({ ok: false, error: err.message, code: err.code, status: err.status, requestId });
-    dieWithError(e);
-  }
-
-  const norm = normalizeGenerate(resp);
-  if (norm.images.length === 0) die(1, "server returned no images");
-
-  // --no-save path
-  if (args["no-save"]) {
-    const totalBytes = norm.images.reduce((s: number, im) => s + (im.image?.length ?? 0), 0);
-    if (process.stdout.isTTY && totalBytes > 2 * 1024 * 1024 && !args.force) {
-      die(2, "refusing to print >2MB of b64 to TTY; use --force or drop --no-save");
-    }
-    for (const im of norm.images) out(im.image);
-    return;
-  }
-
-  // Save path
-  if (explicitOut && norm.images.length > 1) {
-    die(2, "--out only supports a single image; use --out-dir for n>1");
-  }
-
-  const savedPaths: string[] = [];
-  for (let i = 0; i < norm.images.length; i++) {
-    const im = norm.images[i];
-    let target: string;
-    if (explicitOut) {
-      target = explicitOut;
-    } else if (outDir) {
-      target = `${outDir}/${defaultOutName(i, norm.images.length)}`;
-    } else {
-      target = `${config.storage.generatedDir}/${defaultOutName(i, norm.images.length)}`;
-    }
-    await dataUriToFile(String(im.image), target);
-    savedPaths.push(target);
-  }
-
-  if (args.json) {
-    json({
-      ok: true,
-      requestId: norm.requestId,
-      elapsed: norm.elapsed,
-      images: savedPaths.map((p, i) => ({ path: p, filename: norm.images[i].filename })),
-    });
-  } else {
-    for (const p of savedPaths) out(color.green("✓ ") + p);
-    if (norm.elapsed) out(color.dim(`elapsed ${norm.elapsed}s`));
-  }
-}

package/bin/commands/grok.ts

@@ -1,90 +0,0 @@
-import { spawn } from "node:child_process";
-import { dirname, join, delimiter } from "node:path";
-import { fileURLToPath } from "node:url";
-import { color, die, out } from "../lib/output.js";
-import { isWin } from "../lib/platform.js";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const ROOT = join(__dirname, "..", "..");
-const HELP = `
-  ima2 grok <subcommand> [options]
-
-  Manage the bundled progrok runtime used by the Grok image provider.
-  No separate progrok install is required.
-
-  Subcommands:
-    login [options]        Log in to xAI OAuth (default: --manual-paste)
-    logout                 Remove stored xAI credentials
-    status                 Show bundled progrok authentication status
-    models                 List available Grok models
-    proxy [options]        Start the bundled proxy directly
-
-  Notes:
-    ima2 serve auto-starts the bundled proxy on 127.0.0.1:18645 by default.
-    ima2 grok login defaults to --manual-paste for reliable copy/paste auth.
-    Use IMA2_NO_GROK_PROXY=1 to disable automatic proxy startup.
-`;
-
-const MANUAL_PASTE_FLAG = "--manual-paste";
-const NON_MANUAL_LOGIN_FLOW_FLAGS = new Set(["--device-code", "--browser"]);
-
-function localBinPath() {
-  return join(ROOT, "node_modules", ".bin");
-}
-
-function spawnProgrok(argv: string[], env: NodeJS.ProcessEnv): Promise<number | null> {
-  return new Promise((resolve, reject) => {
-    const progrokBin = join(localBinPath(), isWin ? "progrok.cmd" : "progrok");
-    const child = spawn(progrokBin, argv, {
-      cwd: ROOT,
-      env,
-      stdio: "inherit",
-      shell: isWin,
-      windowsHide: true,
-    });
-    child.on("error", (err) => reject(err));
-    child.on("close", resolve);
-  });
-}
-
-export function normalizeGrokLoginArgs(argv: string[]): string[] {
-  const sub = argv[0];
-  if (sub !== "login") return argv;
-  const normalized = argv.filter((arg) => !NON_MANUAL_LOGIN_FLOW_FLAGS.has(arg));
-  if (normalized.includes(MANUAL_PASTE_FLAG)) return normalized;
-  return [...normalized, MANUAL_PASTE_FLAG];
-}
-
-export default async function grokCmd(argv: string[]) {
-  const sub = argv[0];
-  if (!sub || sub === "--help" || sub === "-h") {
-    out(HELP);
-    return;
-  }
-
-  const env = {
-    ...process.env,
-    PATH: `${localBinPath()}${delimiter}${process.env.PATH || ""}`,
-  };
-
-  try {
-    argv = normalizeGrokLoginArgs(argv);
-
-    const code = await spawnProgrok(argv, env);
-    if (code && code !== 0) {
-      if (sub === "login") {
-        out(color.yellow("⚠ ") + "Login failed. Try again with:\n");
-        out("  ima2 grok login\n");
-        die(code, "bundled Grok OAuth login failed");
-      } else {
-        die(code, `bundled progrok exited with code ${code}`);
-      }
-    }
-  } catch (err: any) {
-    die(1, `bundled progrok failed to start: ${err.message}`);
-  }
-
-  if (sub === "login") {
-    out(color.green("✓ ") + "Grok OAuth is ready for ima2 serve");
-  }
-}

package/bin/commands/history.ts

@@ -1,146 +0,0 @@
-import { readFile } from "fs/promises";
-import { extname, basename } from "path";
-import { parseArgs, type ParsedArgs } from "../lib/args.js";
-import { resolveServer, request } from "../lib/client.js";
-import { out, die, color, json, exitCodeForError } from "../lib/output.js";
-import { getCliBrowserId } from "../lib/browser-id.js";
-
-const HELP = `
-  ima2 history <subcommand> [options]
-
-  Subcommands:
-    rm <filename> [--permanent] [--yes]    Soft-delete (default) or hard-delete
-    restore <filename> --trash-id <id>     Restore from trash
-    favorite <filename>                    Toggle favorite status
-    import <localfile>                     Import a local image into history
-
-  Common options:
-        --server <url>                     Override server URL
-        --json                             JSON output
-        --yes                              Skip destructive confirmation
-`;
-
-const COMMON_FLAGS = {
-  json: { type: "boolean" },
-  server: { type: "string" },
-  yes: { type: "boolean" },
-  permanent: { type: "boolean" },
-  "trash-id": { type: "string" },
-  help: { short: "h", type: "boolean" },
-};
-
-async function getServer(args: ParsedArgs) {
-  try { return await resolveServer({ serverFlag: args.server }); }
-  catch (e: any) { die(exitCodeForError(e), e.message); throw e; }
-}
-
-function handle(e: unknown) {
-  const err = e as { message?: string; code?: string };
-  die(exitCodeForError(e), `${err.message}${err.code ? ` (${err.code})` : ""}`);
-}
-
-async function readLine(): Promise<string> {
-  return new Promise((resolve) => {
-    let buf = "";
-    process.stdin.setEncoding("utf-8");
-    const onData = (chunk: Buffer | string) => {
-      buf += chunk;
-      const nl = buf.indexOf("\n");
-      if (nl !== -1) {
-        process.stdin.removeListener("data", onData);
-        process.stdin.pause();
-        resolve(buf.slice(0, nl));
-      }
-    };
-    process.stdin.resume();
-    process.stdin.on("data", onData);
-  });
-}
-
-async function rmSub(argv: string[]) {
-  const args = parseArgs(argv, { flags: COMMON_FLAGS });
-  const filename = args.positional[0];
-  if (!filename) die(2, "filename required");
-  if (!args.yes && !process.stdin.isTTY) die(2, "destructive: pass --yes for non-TTY");
-  if (!args.yes) {
-    process.stdout.write(`${args.permanent ? "PERMANENTLY delete" : "Soft-delete"} ${filename}? [y/N] `);
-    const ans = await readLine();
-    if (!/^y(es)?$/i.test(ans.trim())) { out("(canceled)"); return; }
-  }
-  const server = await getServer(args);
-  const path = args.permanent
-    ? `/api/history/${encodeURIComponent(filename)}/permanent`
-    : `/api/history/${encodeURIComponent(filename)}`;
-  const resp = await request(server.base, path, { method: "DELETE" }).catch(handle);
-  if (args.json) { json(resp); return; }
-  out(color.green(args.permanent ? "✓ permanently deleted" : "✓ moved to trash"));
-  if (resp?.trashId) out(color.dim(`  trashId: ${resp.trashId}`));
-}
-
-async function restoreSub(argv: string[]) {
-  const args = parseArgs(argv, { flags: COMMON_FLAGS });
-  const filename = args.positional[0];
-  if (!filename) die(2, "filename required");
-  const trashId = args["trash-id"];
-  if (!trashId) die(2, "--trash-id required (returned by `history rm <filename>`)");
-  const server = await getServer(args);
-  const resp = await request(server.base, `/api/history/${encodeURIComponent(filename)}/restore`, {
-    method: "POST",
-    body: { trashId },
-  }).catch(handle);
-  if (args.json) { json(resp); return; }
-  out(color.green("✓ restored"));
-}
-
-async function favoriteSub(argv: string[]) {
-  const args = parseArgs(argv, { flags: COMMON_FLAGS });
-  const filename = args.positional[0];
-  if (!filename) die(2, "filename required");
-  const server = await getServer(args);
-  const browserId = getCliBrowserId();
-  const resp: any = await request(server.base, "/api/history/favorite", {
-    method: "POST",
-    body: { filename },
-    headers: { "X-Ima2-Browser-Id": browserId },
-  }).catch(handle);
-  if (args.json) { json(resp); return; }
-  out(color.green(resp.isFavorite ? "✓ favorited" : "✓ unfavorited"));
-}
-
-async function importSub(argv: string[]) {
-  const args = parseArgs(argv, { flags: COMMON_FLAGS });
-  const filepath = args.positional[0];
-  if (!filepath) die(2, "filename required");
-  const buf = await readFile(filepath);
-  const ext = extname(filepath).toLowerCase();
-  const mime =
-    ext === ".jpg" || ext === ".jpeg" ? "image/jpeg" :
-    ext === ".webp" ? "image/webp" : "image/png";
-  const server = await getServer(args);
-  const resp: any = await request(server.base, "/api/history/import-local", {
-    method: "POST",
-    body: buf,
-    raw: true,
-    headers: {
-      "Content-Type": mime,
-      "X-Ima2-Original-Filename": basename(filepath),
-    },
-  }).catch(handle);
-  if (args.json) { json(resp); return; }
-  out(color.green("✓ imported as ") + (resp?.item?.filename || "(unknown)"));
-}
-
-const SUB: Record<string, (argv: any[]) => Promise<void>> = {
-  rm: rmSub,
-  restore: restoreSub,
-  favorite: favoriteSub,
-  import: importSub,
-};
-
-export default async function historyCmd(argv: string[]) {
-  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));
-}

package/bin/commands/ls.ts

@@ -1,64 +0,0 @@
-import { parseArgs } from "../lib/args.js";
-import { resolveServer, request } from "../lib/client.js";
-import { out, die, color, json, table, exitCodeForError } from "../lib/output.js";
-
-import { errInfo } from "../../lib/errInfo.js";
-const SPEC = {
-  flags: {
-    count:  { short: "n", type: "string", default: "20" },
-    json:   { type: "boolean" },
-    session: { type: "string" },
-    favorites: { type: "boolean" },
-    server: { type: "string" },
-    help:   { short: "h", type: "boolean" },
-  },
-};
-
-export default async function lsCmd(argv: string[]) {
-  const args = parseArgs(argv, SPEC);
-  if (args.help) {
-    out("ima2 ls [-n count] [--session <id>] [--favorites] [--json]");
-    return;
-  }
-
-  let server;
-  try { server = await resolveServer({ serverFlag: args.server }); }
-  catch (e) {
-    const err = errInfo(e); die(exitCodeForError(e), err.message); }
-
-  const limit = parseInt(String(args.count)) || 20;
-  const qs = new URLSearchParams();
-  if (args.session) qs.set("sessionId", String(args.session));
-  if (args.favorites) qs.set("favoritesOnly", "1");
-  qs.set("limit", String(limit));
-  const path = `/api/history?${qs.toString()}`;
-  let resp;
-  try { resp = await request(server.base, path); }
-  catch (e) {
-    const err = errInfo(e); die(exitCodeForError(e), err.message); }
-
-  let items: Record<string, unknown>[] = (resp.items || resp.history || []);
-  if (args.favorites) items = items.filter((it: Record<string, unknown>) => it.isFavorite === true);
-  items = items.slice(0, limit);
-
-  if (args.json) { json({ items }); return; }
-
-  if (items.length === 0) {
-    out(color.dim("(no history)"));
-    return;
-  }
-  table(items, [
-    { key: "filename", label: "FILENAME" },
-    { key: "quality",  label: "Q" },
-    { key: "size",     label: "SIZE" },
-    { key: "createdAt", label: "WHEN", format: (v: unknown) => {
-      if (!v) return "";
-      const d = new Date(v as string);
-      return d.toISOString().replace("T", " ").slice(0, 19);
-    } },
-    { key: "prompt", label: "PROMPT", format: (v: unknown) => {
-      const s = String(v || "").replace(/\s+/g, " ");
-      return s.length > 48 ? s.slice(0, 45) + "…" : s;
-    } },
-  ]);
-}

package/bin/commands/metadata.ts

@@ -1,39 +0,0 @@
-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: string[]) {
-  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: unknown) => {
-    const err = e as { message?: string; code?: string };
-    die(exitCodeForError(e), `${err.message}${err.code ? ` (${err.code})` : ""}`);
-  });
-  if (args.json) { json(resp); }
-  else out(JSON.stringify(resp, null, 2));
-}