ignis-agent-cli 0.1.0

package/README.md

@@ -0,0 +1,41 @@
+# Ignis
+
+Node CLI for the Ultra-Mai Agent V2 CLI facade.
+
+## Install
+
+```bash
+npm install -g ignis-agent-cli
+```
+
+## Configure
+
+```bash
+ignis login --base-url http://127.0.0.1:57988 --token <cli_token>
+```
+
+This stores config in `~/.ignis/config.json` and reuses the current working directory as the default session context.
+
+## Commands
+
+```bash
+ignis ask "帮我继续这个话题"
+ignis ask --prompt-file prompt.md --attach image.png --json
+ignis ask --file-id image_123.png "继续分析这张图"
+ignis history
+ignis skills --query video
+ignis status <turn_id>
+ignis resume <turn_id> --answer "继续"
+ignis cancel <turn_id>
+ignis upload ./demo.png
+```
+
+## Auth
+
+The CLI sends:
+
+```text
+Authorization: Bearer <cli_token>
+```
+
+It expects the backend `/api/cli/*` routes to be enabled and backed by the `cli_tokens` table.

package/dist/index.js

@@ -0,0 +1,926 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command as Command10 } from "commander";
+
+// src/commands/ask.ts
+import { readFile as readFile3 } from "fs/promises";
+import crypto from "crypto";
+import { Command as Command2, Option as Option2 } from "commander";
+
+// src/client.ts
+import { readFile } from "fs/promises";
+import path from "path";
+var TERMINAL_STATUSES = /* @__PURE__ */ new Set(["completed", "interrupted", "failed", "cancelled"]);
+var IgnisCliError = class extends Error {
+  code;
+  statusCode;
+  details;
+  constructor(message, options) {
+    super(message);
+    this.name = "IgnisCliError";
+    this.code = options?.code ?? "cli_error";
+    this.statusCode = options?.statusCode;
+    this.details = options?.details;
+  }
+};
+var IgnisClient = class {
+  baseUrl;
+  token;
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+    this.token = options.token;
+  }
+  async createTurn(payload) {
+    return this.requestJson("/api/cli/turns", {
+      method: "POST",
+      body: JSON.stringify(payload),
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+  }
+  async getTurn(turnId) {
+    return this.requestJson(`/api/cli/turns/${encodeURIComponent(turnId)}`, {
+      method: "GET"
+    });
+  }
+  async getLatestSessionTurn(sessionId) {
+    return this.requestJson(`/api/cli/sessions/${encodeURIComponent(sessionId)}/status`, {
+      method: "GET"
+    });
+  }
+  async getSessionHistory(sessionId, options) {
+    const params = new URLSearchParams();
+    if (typeof options?.limit === "number") {
+      params.set("limit", String(options.limit));
+    }
+    if (typeof options?.offset === "number") {
+      params.set("offset", String(options.offset));
+    }
+    if (options?.view) {
+      params.set("view", options.view);
+    }
+    const query = params.toString();
+    const suffix = query ? `?${query}` : "";
+    return this.requestJson(
+      `/api/cli/sessions/${encodeURIComponent(sessionId)}/history${suffix}`,
+      { method: "GET" }
+    );
+  }
+  async getSkills(options) {
+    const params = new URLSearchParams();
+    if (options?.query) {
+      params.set("query", options.query);
+    }
+    if (typeof options?.limit === "number") {
+      params.set("limit", String(options.limit));
+    }
+    if (typeof options?.offset === "number") {
+      params.set("offset", String(options.offset));
+    }
+    const query = params.toString();
+    const suffix = query ? `?${query}` : "";
+    return this.requestJson(`/api/cli/skills${suffix}`, {
+      method: "GET"
+    });
+  }
+  async resumeTurn(turnId, payload) {
+    return this.requestJson(`/api/cli/turns/${encodeURIComponent(turnId)}/resume`, {
+      method: "POST",
+      body: JSON.stringify(payload),
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+  }
+  async cancelTurn(turnId) {
+    return this.requestJson(`/api/cli/turns/${encodeURIComponent(turnId)}/cancel`, {
+      method: "POST"
+    });
+  }
+  async uploadFile(filePath) {
+    const content = await readFile(filePath);
+    const blob = new Blob([content]);
+    const form = new FormData();
+    form.append("file", blob, path.basename(filePath));
+    return this.requestJson("/api/cli/files", {
+      method: "POST",
+      body: form
+    });
+  }
+  async waitForTurn(turn, options) {
+    const startedAt = Date.now();
+    let current = turn;
+    while (!TERMINAL_STATUSES.has(current.status)) {
+      if (Date.now() - startedAt >= options.timeoutMs) {
+        throw new IgnisCliError(
+          `Timed out waiting for turn ${current.turn_id}. Last status: ${current.status}`,
+          { code: "timeout" }
+        );
+      }
+      const delayMs = Math.max(250, Math.min(Number(current.poll_after_ms) || 1e3, 5e3));
+      await sleep(delayMs);
+      current = await this.getTurn(current.turn_id);
+      options.onPoll?.(current);
+    }
+    return current;
+  }
+  async requestJson(pathname, init) {
+    const response = await fetch(`${this.baseUrl}${pathname}`, {
+      ...init,
+      headers: {
+        Accept: "application/json",
+        Authorization: `Bearer ${this.token}`,
+        ...init.headers ?? {}
+      }
+    });
+    const payload = await parseResponse(response);
+    if (!response.ok) {
+      const message = getObjectString(payload, "message") ?? getObjectString(payload, "detail") ?? `Request failed with status ${response.status}`;
+      const code = getObjectString(payload, "error") ?? getObjectString(payload, "code") ?? "http_error";
+      throw new IgnisCliError(message, {
+        code,
+        statusCode: response.status,
+        details: payload
+      });
+    }
+    return payload;
+  }
+};
+async function parseResponse(response) {
+  const text = await response.text();
+  if (!text) {
+    return {};
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    return { message: text };
+  }
+}
+function getObjectString(payload, key) {
+  if (!payload || typeof payload !== "object") {
+    return void 0;
+  }
+  const value = payload[key];
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/config.ts
+import { chmod, mkdir, readFile as readFile2, writeFile } from "fs/promises";
+import os from "os";
+import path2 from "path";
+var CONFIG_DIR = path2.join(os.homedir(), ".ignis");
+var CONFIG_PATH = path2.join(CONFIG_DIR, "config.json");
+var LEGACY_CONFIG_PATH = path2.join(os.homedir(), ".mai", "config.json");
+var DEFAULT_CONFIG = {
+  sessions: {}
+};
+function normalizeBaseUrl(baseUrl) {
+  return baseUrl.trim().replace(/\/+$/, "");
+}
+function getConfigPath() {
+  return CONFIG_PATH;
+}
+async function loadConfig() {
+  try {
+    const raw = await readConfigFile();
+    const parsed = JSON.parse(raw);
+    return {
+      baseUrl: typeof parsed.baseUrl === "string" ? normalizeBaseUrl(parsed.baseUrl) : void 0,
+      cliToken: typeof parsed.cliToken === "string" ? parsed.cliToken.trim() : void 0,
+      sessions: parsed.sessions && typeof parsed.sessions === "object" ? parsed.sessions : {}
+    };
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return { ...DEFAULT_CONFIG };
+    }
+    throw error;
+  }
+}
+async function readConfigFile() {
+  try {
+    return await readFile2(CONFIG_PATH, "utf8");
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+  return readFile2(LEGACY_CONFIG_PATH, "utf8");
+}
+async function saveConfig(config) {
+  await mkdir(CONFIG_DIR, { recursive: true, mode: 448 });
+  await writeFile(CONFIG_PATH, `${JSON.stringify(config, null, 2)}
+`, {
+    encoding: "utf8",
+    mode: 384
+  });
+  await chmod(CONFIG_PATH, 384);
+}
+function resolveBaseUrl(config, override) {
+  const value = override ?? process.env.IGNIS_BASE_URL ?? process.env.MAI_BASE_URL ?? config.baseUrl;
+  if (!value || !value.trim()) {
+    throw new Error("Missing base URL. Run `ignis login --base-url ... --token ...` or pass --base-url.");
+  }
+  return normalizeBaseUrl(value);
+}
+function resolveCliToken(config, override) {
+  const value = override ?? process.env.IGNIS_CLI_TOKEN ?? process.env.MAI_CLI_TOKEN ?? config.cliToken;
+  if (!value || !value.trim()) {
+    throw new Error("Missing CLI token. Run `ignis login --base-url ... --token ...` or pass --token.");
+  }
+  return value.trim();
+}
+function getContextKey(cwd = process.cwd()) {
+  return path2.resolve(cwd);
+}
+function getSessionForContext(config, cwd = process.cwd()) {
+  return config.sessions[getContextKey(cwd)];
+}
+function setSessionForContext(config, sessionId, cwd = process.cwd()) {
+  const next = {
+    ...config,
+    sessions: {
+      ...config.sessions,
+      [getContextKey(cwd)]: sessionId
+    }
+  };
+  return next;
+}
+
+// src/output.ts
+function printJson(value) {
+  process.stdout.write(`${JSON.stringify(value, null, 2)}
+`);
+}
+function printTurnHuman(turn) {
+  if (turn.status === "completed") {
+    const text = turn.assistant_message?.text?.trim() ?? "";
+    if (text) {
+      process.stdout.write(`${text}
+`);
+    }
+    printTurnSummary(turn);
+    process.stderr.write(`turn=${turn.turn_id} session=${turn.session_id ?? "-"} status=completed
+`);
+    return;
+  }
+  if (turn.status === "interrupted") {
+    const partial = turn.assistant_message?.text?.trim() ?? "";
+    if (partial) {
+      process.stdout.write(`${partial}
+`);
+    }
+    printTurnSummary(turn);
+    process.stderr.write(`turn=${turn.turn_id} session=${turn.session_id ?? "-"} status=interrupted
+`);
+    process.stderr.write(`${JSON.stringify(turn.interrupt ?? {}, null, 2)}
+`);
+    return;
+  }
+  if (turn.status === "cancelled") {
+    process.stderr.write(`turn=${turn.turn_id} session=${turn.session_id ?? "-"} status=cancelled
+`);
+    return;
+  }
+  if (turn.status === "failed") {
+    const message = turn.error?.message ?? "Turn failed";
+    process.stderr.write(`turn=${turn.turn_id} session=${turn.session_id ?? "-"} status=failed: ${message}
+`);
+    return;
+  }
+  process.stderr.write(`turn=${turn.turn_id} session=${turn.session_id ?? "-"} status=${turn.status}
+`);
+}
+function printUploadHuman(file) {
+  process.stdout.write(`${file.file_id}
+`);
+  process.stderr.write(`uploaded ${file.original_filename} -> ${file.file_id}
+`);
+}
+function printLoginHuman(configPath) {
+  process.stderr.write(`saved config to ${configPath}
+`);
+}
+function printSkillsHuman(response) {
+  const skills = response.skills ?? [];
+  skills.forEach((skill, index) => {
+    const source = skill.source?.trim() || "unknown";
+    const enabled = skill.enabled === false ? "disabled" : "enabled";
+    process.stdout.write(`[${index + 1}] ${skill.skill_name} (${skill.skill_id}) ${source} ${enabled}
+`);
+    const title = skill.title?.trim();
+    if (title) {
+      process.stdout.write(`title: ${title}
+`);
+    }
+    const summary = skill.short_description?.trim() || skill.description?.trim() || "";
+    if (summary) {
+      process.stdout.write(`${summary}
+`);
+    }
+    const tags = (skill.tags ?? []).filter((value) => value.trim());
+    if (tags.length > 0) {
+      process.stdout.write(`tags: ${tags.join(", ")}
+`);
+    }
+    process.stdout.write("\n");
+  });
+  process.stderr.write(
+    `returned=${skills.length} total=${response.count} query=${response.query || "-"}
+`
+  );
+}
+function printHistoryHuman(history) {
+  const messages = history.messages ?? [];
+  messages.forEach((message, index) => {
+    const header = `[${index + 1}] ${labelForMessage(message)}`;
+    process.stdout.write(`${header}
+`);
+    const body = renderMessageBody(message);
+    if (body) {
+      process.stdout.write(`${body}
+`);
+    }
+    process.stdout.write("\n");
+  });
+  process.stderr.write(
+    `session=${history.session_id} returned=${messages.length} total=${history.total}
+`
+  );
+}
+function printTurnHistoryHuman(history) {
+  const turns = history.turns ?? [];
+  turns.forEach((turn, index) => {
+    const header = `[${index + 1}] turn ${turn.turn_id} status=${turn.status ?? "unknown"}`;
+    process.stdout.write(`${header}
+`);
+    const canvasId = turn.canvas_id?.trim();
+    if (canvasId) {
+      process.stdout.write(`canvas_id=${canvasId}
+`);
+    }
+    const inputText = turn.input?.message?.trim();
+    if (inputText) {
+      process.stdout.write(`user: ${inputText}
+`);
+    }
+    const inputFileIds = (turn.input?.file_ids ?? []).filter((value) => value.trim());
+    if (inputFileIds.length > 0) {
+      process.stdout.write(`[input_file_ids] ${inputFileIds.join(", ")}
+`);
+    }
+    const toolNames = (turn.tool_summary?.names ?? []).filter((value) => value.trim());
+    if (toolNames.length > 0) {
+      process.stdout.write(`[tools] ${toolNames.join(", ")}
+`);
+    }
+    const artifactIds = (turn.artifact_summary?.file_ids ?? []).filter((value) => value.trim());
+    if (artifactIds.length > 0) {
+      process.stdout.write(`[artifact_file_ids] ${artifactIds.join(", ")}
+`);
+    }
+    const assistantText = turn.assistant_message?.text?.trim();
+    if (assistantText) {
+      process.stdout.write(`assistant: ${assistantText}
+`);
+    }
+    if (turn.error && Object.keys(turn.error).length > 0) {
+      process.stdout.write(`[error] ${JSON.stringify(turn.error)}
+`);
+    }
+    if (turn.interrupt && Object.keys(turn.interrupt).length > 0) {
+      process.stdout.write(`[interrupt] ${JSON.stringify(turn.interrupt)}
+`);
+    }
+    process.stdout.write("\n");
+  });
+  process.stderr.write(
+    `session=${history.session_id} canvas=${history.canvas_id ?? "-"} returned=${turns.length} total=${history.total}
+`
+  );
+}
+function labelForMessage(message) {
+  if (message.type === "user_message") {
+    return "user";
+  }
+  if (message.type === "agent_text") {
+    return "assistant";
+  }
+  if (message.type === "interrupt_question") {
+    return "interrupt";
+  }
+  if (message.type === "interrupt_response") {
+    return "resume";
+  }
+  if (message.type === "agent_attachment") {
+    return "attachment";
+  }
+  if (message.type === "system_error") {
+    return "error";
+  }
+  return message.type;
+}
+function renderMessageBody(message) {
+  const lines = [];
+  const content = message.content?.trim();
+  if (content) {
+    lines.push(content);
+  }
+  const references = Array.isArray(message.metadata?.references) ? message.metadata?.references : [];
+  const referenceIds = references.map((reference) => String(reference.id ?? "").trim()).filter(Boolean);
+  if (referenceIds.length > 0) {
+    lines.push(`[file_ids] ${referenceIds.join(", ")}`);
+  }
+  if (message.attachment_data) {
+    const fileId = String(message.attachment_data.file_id ?? "").trim();
+    const caption = String(message.attachment_data.caption ?? "").trim();
+    const attachmentLine = [fileId && `file_id=${fileId}`, caption && `caption=${caption}`].filter(Boolean).join(" ");
+    if (attachmentLine) {
+      lines.push(attachmentLine);
+    }
+  }
+  if (message.tool_data) {
+    const toolName = String(message.tool_data.tool_name ?? "").trim();
+    const status = String(message.tool_data.status ?? "").trim();
+    const toolId = String(message.tool_data.tool_id ?? "").trim();
+    const toolMessage = String(message.tool_data.message ?? "").trim();
+    const outputFileIds = Array.isArray(message.tool_data.output_file_ids) ? message.tool_data.output_file_ids.map((value) => String(value).trim()).filter(Boolean) : [];
+    const toolLine = [
+      toolName && `tool=${toolName}`,
+      status && `status=${status}`,
+      toolId && `tool_id=${toolId}`,
+      toolMessage && `message=${toolMessage}`
+    ].filter(Boolean).join(" ");
+    if (toolLine) {
+      lines.push(toolLine);
+    }
+    if (outputFileIds.length > 0) {
+      lines.push(`[output_file_ids] ${outputFileIds.join(", ")}`);
+    }
+  }
+  if (lines.length === 0) {
+    const metadata = message.metadata && Object.keys(message.metadata).length > 0 ? JSON.stringify(message.metadata, null, 2) : "";
+    if (metadata) {
+      lines.push(metadata);
+    }
+  }
+  return lines.join("\n");
+}
+function printTurnSummary(turn) {
+  const canvasId = turn.canvas_id?.trim();
+  if (canvasId) {
+    process.stderr.write(`canvas=${canvasId}
+`);
+  }
+  const inputFileIds = (turn.input?.file_ids ?? []).filter((value) => value.trim());
+  if (inputFileIds.length > 0) {
+    process.stderr.write(`input_file_ids=${inputFileIds.join(",")}
+`);
+  }
+  const toolNames = (turn.tool_summary?.names ?? []).filter((value) => value.trim());
+  if (toolNames.length > 0) {
+    process.stderr.write(`tools=${toolNames.join(",")}
+`);
+  }
+  const artifactIds = (turn.artifact_summary?.file_ids ?? []).filter((value) => value.trim());
+  if (artifactIds.length > 0) {
+    process.stderr.write(`artifact_file_ids=${artifactIds.join(",")}
+`);
+  }
+}
+
+// src/commands/common.ts
+import { Option } from "commander";
+function addRuntimeOptions(command, options) {
+  command.addOption(new Option("--base-url <url>", "Override configured backend base URL"));
+  command.addOption(new Option("--token <token>", "Override configured CLI token"));
+  if (options?.includeJson !== false) {
+    command.addOption(new Option("--json", "Print machine-readable JSON output"));
+  }
+  return command;
+}
+async function createClient(options) {
+  const config = await loadConfig();
+  const client = new IgnisClient({
+    baseUrl: resolveBaseUrl(config, options.baseUrl),
+    token: resolveCliToken(config, options.token)
+  });
+  return { client, config };
+}
+function collectValues(value, previous) {
+  return [...previous, value];
+}
+function mapTurnExitCode(status) {
+  if (status === "completed") {
+    return 0;
+  }
+  if (status === "interrupted") {
+    return 10;
+  }
+  if (status === "cancelled") {
+    return 130;
+  }
+  if (status === "failed") {
+    return 30;
+  }
+  return 1;
+}
+function printProgress(message) {
+  process.stderr.write(`${message}
+`);
+}
+function wrapCommand(handler) {
+  return async (...args) => {
+    try {
+      const exitCode = await handler(...args);
+      process.exitCode = typeof exitCode === "number" ? exitCode : 0;
+    } catch (error) {
+      const cliError = normalizeError(error);
+      process.stderr.write(`${cliError.message}
+`);
+      if (cliError.details) {
+        process.stderr.write(`${JSON.stringify(cliError.details, null, 2)}
+`);
+      }
+      if (cliError.code === "pending_interrupt") {
+        process.stderr.write("Use `ignis resume <turn_id>` to continue, or `ignis ask --new ...` to start a fresh session.\n");
+      }
+      process.exitCode = inferExitCode(cliError);
+    }
+  };
+}
+function normalizeError(error) {
+  if (error instanceof IgnisCliError) {
+    return error;
+  }
+  if (error instanceof Error) {
+    return new IgnisCliError(error.message);
+  }
+  return new IgnisCliError(String(error));
+}
+function inferExitCode(error) {
+  if (error.code === "pending_interrupt") {
+    return 10;
+  }
+  if (error.code === "timeout") {
+    return 12;
+  }
+  if (error.statusCode && error.statusCode >= 500) {
+    return 30;
+  }
+  if (error.statusCode && [400, 401, 403, 404, 409, 422].includes(error.statusCode)) {
+    return 20;
+  }
+  return 1;
+}
+
+// src/commands/ask.ts
+function buildAskCommand() {
+  const command = new Command2("ask");
+  command.description("Submit one turn").argument("[message]", "Message text").addOption(new Option2("--prompt-file <path>", "Read prompt text from file")).addOption(new Option2("--attach <path>", "Upload and attach a file").default([], void 0).argParser(collectValues)).addOption(new Option2("--file-id <id>", "Reuse an existing uploaded file_id").default([], void 0).argParser(collectValues)).addOption(new Option2("--session <id>", "Continue an existing session")).addOption(new Option2("--new", "Start a new session instead of reusing the cwd session")).addOption(new Option2("--canvas <id>", "Create a new session under an existing canvas")).addOption(new Option2("--agent <name>", "Override agent name")).addOption(new Option2("--skill <id>", "Skill ID").default("base")).addOption(new Option2("--async", "Return immediately after submission without polling")).addOption(new Option2("--wait-ms <ms>", "Per-request server wait window").default("25000")).addOption(new Option2("--timeout-ms <ms>", "Client-side polling timeout").default("300000")).addOption(new Option2("--no-session-cache", "Do not read or write cwd-scoped session cache")).hook("preAction", () => {
+  }).action(
+    wrapCommand(async (messageArg, options) => {
+      const message = await resolvePrompt(messageArg, options.promptFile);
+      if (options.new && options.session?.trim()) {
+        throw new IgnisCliError("--new cannot be combined with --session");
+      }
+      if (!message.trim() && options.attach.length === 0 && options.fileId.length === 0) {
+        throw new IgnisCliError("Message is empty. Pass text, --prompt-file, stdin, --attach, or --file-id.");
+      }
+      const { client, config } = await createClient(options);
+      const uploadedFileIds = await uploadAttachments(client, options.attach, Boolean(options.json));
+      const fileIds = [
+        ...options.fileId.map((value) => value.trim()).filter(Boolean),
+        ...uploadedFileIds
+      ];
+      const sessionId = options.new ? void 0 : options.session?.trim() || (options.noSessionCache ? void 0 : getSessionForContext(config));
+      const payload = {
+        session_id: sessionId,
+        canvas_id: options.canvas?.trim() || void 0,
+        message,
+        file_ids: fileIds,
+        agent: options.agent?.trim() || void 0,
+        skill_id: options.skill,
+        wait_ms: options.async ? 0 : toPositiveInt(options.waitMs, 25e3),
+        idempotency_key: crypto.randomUUID()
+      };
+      let turn = await client.createTurn(payload);
+      if (!options.async && (turn.status === "running" || turn.status === "queued")) {
+        turn = await client.waitForTurn(turn, {
+          timeoutMs: toPositiveInt(options.timeoutMs, 3e5)
+        });
+      }
+      if (!options.noSessionCache && turn.session_id) {
+        await saveConfig(setSessionForContext(config, turn.session_id));
+      }
+      if (options.json) {
+        printJson(turn);
+      } else {
+        printTurnHuman(turn);
+      }
+      if (options.async && (turn.status === "running" || turn.status === "queued")) {
+        return 0;
+      }
+      return mapTurnExitCode(turn.status);
+    })
+  );
+  return addRuntimeOptions(command);
+}
+async function resolvePrompt(messageArg, promptFile) {
+  if (promptFile) {
+    return readFile3(promptFile, "utf8");
+  }
+  if (typeof messageArg === "string" && messageArg.trim()) {
+    return messageArg;
+  }
+  if (!process.stdin.isTTY) {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+    }
+    return Buffer.concat(chunks).toString("utf8");
+  }
+  return "";
+}
+async function uploadAttachments(client, attachments, jsonOutput) {
+  if (attachments.length === 0) {
+    return [];
+  }
+  const fileIds = [];
+  for (const filePath of attachments) {
+    if (!jsonOutput) {
+      printProgress(`uploading ${filePath}`);
+    }
+    const uploaded = await client.uploadFile(filePath);
+    fileIds.push(uploaded.file_id);
+  }
+  return fileIds;
+}
+function toPositiveInt(value, fallbackValue) {
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallbackValue;
+}
+
+// src/commands/cancel.ts
+import { Command as Command3 } from "commander";
+function buildCancelCommand() {
+  const command = new Command3("cancel");
+  command.description("Cancel a running turn").argument("<turn-id>", "Turn ID").action(
+    wrapCommand(async (turnId, options) => {
+      const { client } = await createClient(options);
+      const turn = await client.cancelTurn(turnId);
+      if (options.json) {
+        printJson(turn);
+      } else {
+        printTurnHuman(turn);
+      }
+      return mapTurnExitCode(turn.status);
+    })
+  );
+  return addRuntimeOptions(command);
+}
+
+// src/commands/history.ts
+import { Command as Command4, Option as Option3 } from "commander";
+var DEFAULT_VISIBLE_TYPES = /* @__PURE__ */ new Set([
+  "user_message",
+  "agent_text",
+  "agent_attachment",
+  "interrupt_question",
+  "interrupt_response",
+  "system_error"
+]);
+function buildHistoryCommand() {
+  const command = new Command4("history");
+  command.description("Show recent history for a session").addOption(new Option3("--session <id>", "Read history for an explicit session")).addOption(new Option3("--limit <n>", "Number of turns to fetch").default("20")).addOption(new Option3("--offset <n>", "Number of newest turns to skip").default("0")).addOption(new Option3("--messages", "Show raw message history instead of turn summaries")).addOption(new Option3("--all", "Include tool and system event messages when using --messages")).action(
+    wrapCommand(async (options) => {
+      const { client, config } = await createClient(options);
+      const sessionId = options.session?.trim() || getSessionForContext(config);
+      if (!sessionId) {
+        throw new IgnisCliError("No session selected. Pass --session or run `ignis ask` in this directory first.");
+      }
+      const history = await client.getSessionHistory(sessionId, {
+        limit: toNonNegativeInt(options.limit, 20),
+        offset: toNonNegativeInt(options.offset, 0),
+        view: options.messages ? "messages" : "turns"
+      });
+      const output = options.messages && !options.all ? filterHistory(history) : history;
+      if (options.json) {
+        printJson(output);
+      } else {
+        if (options.messages) {
+          printHistoryHuman(output);
+        } else {
+          printTurnHistoryHuman(output);
+        }
+      }
+      return 0;
+    })
+  );
+  return addRuntimeOptions(command);
+}
+function filterHistory(history) {
+  const filteredMessages = (history.messages ?? []).filter((message) => DEFAULT_VISIBLE_TYPES.has(message.type));
+  return {
+    ...history,
+    messages: filteredMessages
+  };
+}
+function toNonNegativeInt(value, fallbackValue) {
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    return fallbackValue;
+  }
+  return parsed;
+}
+
+// src/commands/login.ts
+import { Command as Command5 } from "commander";
+function buildLoginCommand() {
+  const command = new Command5("login");
+  command.description("Store CLI token and base URL in ~/.ignis/config.json").requiredOption("--base-url <url>", "Backend base URL").requiredOption("--token <token>", "CLI token").option("--json", "Print machine-readable JSON output").action(
+    wrapCommand(async (options) => {
+      const config = await loadConfig();
+      const nextConfig = {
+        ...config,
+        baseUrl: options.baseUrl.trim().replace(/\/+$/, ""),
+        cliToken: options.token.trim()
+      };
+      await saveConfig(nextConfig);
+      if (options.json) {
+        printJson({
+          ok: true,
+          config_path: getConfigPath(),
+          base_url: nextConfig.baseUrl
+        });
+      } else {
+        printLoginHuman(getConfigPath());
+      }
+      return 0;
+    })
+  );
+  return command;
+}
+
+// src/commands/resume.ts
+import { readFile as readFile4 } from "fs/promises";
+import { Command as Command6, Option as Option4 } from "commander";
+function buildResumeCommand() {
+  const command = new Command6("resume");
+  command.description("Resume an interrupted turn").argument("<turn-id>", "Interrupted turn ID").addOption(new Option4("--answer <text>", "Provide one answer value").default([], void 0).argParser(collectValues)).addOption(new Option4("--payload <json-or-@file>", "Raw resume payload JSON")).addOption(new Option4("--cancel", "Cancel the interrupted turn instead of answering")).addOption(new Option4("--async", "Return immediately after submission without polling")).addOption(new Option4("--wait-ms <ms>", "Per-request server wait window").default("25000")).addOption(new Option4("--timeout-ms <ms>", "Client-side polling timeout").default("300000")).action(
+    wrapCommand(async (turnId, options) => {
+      const { client } = await createClient(options);
+      const response = await buildResumePayload(options);
+      let turn = await client.resumeTurn(turnId, {
+        response,
+        wait_ms: options.async ? 0 : Number.parseInt(options.waitMs, 10) || 25e3
+      });
+      if (!options.async && (turn.status === "running" || turn.status === "queued")) {
+        turn = await client.waitForTurn(turn, {
+          timeoutMs: Number.parseInt(options.timeoutMs, 10) || 3e5
+        });
+      }
+      if (options.json) {
+        printJson(turn);
+      } else {
+        printTurnHuman(turn);
+      }
+      if (options.async && (turn.status === "running" || turn.status === "queued")) {
+        return 0;
+      }
+      return mapTurnExitCode(turn.status);
+    })
+  );
+  return addRuntimeOptions(command);
+}
+async function buildResumePayload(options) {
+  if (options.payload && (options.answer.length > 0 || options.cancel)) {
+    throw new IgnisCliError("--payload cannot be combined with --answer or --cancel");
+  }
+  if (options.payload) {
+    return parseJsonInput(options.payload);
+  }
+  if (options.cancel) {
+    return { cancelled: true };
+  }
+  if (options.answer.length === 0) {
+    throw new IgnisCliError("Provide at least one --answer, --payload, or --cancel");
+  }
+  return { answers: options.answer };
+}
+async function parseJsonInput(value) {
+  const raw = value.startsWith("@") ? await readFile4(value.slice(1), "utf8") : value;
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    throw new IgnisCliError(`Invalid JSON payload: ${error.message}`);
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new IgnisCliError("Resume payload must be a JSON object");
+  }
+  return parsed;
+}
+
+// src/commands/skills.ts
+import { Command as Command7, Option as Option5 } from "commander";
+function buildSkillsCommand() {
+  const command = new Command7("skills");
+  command.description("List/search available skills").addOption(new Option5("--query <text>", "Search skills by keyword").default("")).addOption(new Option5("--limit <n>", "Number of skills to fetch").default("50")).addOption(new Option5("--offset <n>", "Number of skills to skip").default("0")).action(wrapCommand(async (options) => handleSkillsList(options)));
+  addRuntimeOptions(command);
+  const listCommand = new Command7("list");
+  listCommand.description("List/search available skills").addOption(new Option5("--query <text>", "Search skills by keyword").default("")).addOption(new Option5("--limit <n>", "Number of skills to fetch").default("50")).addOption(new Option5("--offset <n>", "Number of skills to skip").default("0")).action(wrapCommand(async (options) => handleSkillsList(options)));
+  addRuntimeOptions(listCommand);
+  command.addCommand(listCommand);
+  return command;
+}
+async function handleSkillsList(options) {
+  const { client } = await createClient(options);
+  const response = await client.getSkills({
+    query: options.query?.trim() || "",
+    limit: toNonNegativeInt2(options.limit, 50),
+    offset: toNonNegativeInt2(options.offset, 0)
+  });
+  if (options.json) {
+    printJson(response);
+  } else {
+    printSkillsHuman(response);
+  }
+  return 0;
+}
+function toNonNegativeInt2(value, fallbackValue) {
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    return fallbackValue;
+  }
+  return parsed;
+}
+
+// src/commands/status.ts
+import { Command as Command8, Option as Option6 } from "commander";
+function buildStatusCommand() {
+  const command = new Command8("status");
+  command.description("Fetch the latest state of a turn or session").argument("[turn-id]", "Turn ID").addOption(new Option6("--session <id>", "Resolve the latest turn from a session")).addOption(new Option6("--wait", "Poll until terminal state")).addOption(new Option6("--timeout-ms <ms>", "Client-side polling timeout").default("300000")).action(
+    wrapCommand(async (turnId, options) => {
+      const { client, config } = await createClient(options);
+      const sessionId = options.session?.trim() || getSessionForContext(config);
+      let turn;
+      if (turnId?.trim()) {
+        turn = await client.getTurn(turnId.trim());
+      } else if (sessionId) {
+        turn = await client.getLatestSessionTurn(sessionId);
+      } else {
+        throw new IgnisCliError("No turn or session selected. Pass <turn-id>, --session, or run `ignis ask` in this directory first.");
+      }
+      if (options.wait && (turn.status === "running" || turn.status === "queued")) {
+        turn = await client.waitForTurn(turn, {
+          timeoutMs: Number.parseInt(options.timeoutMs, 10) || 3e5
+        });
+      }
+      if (options.json) {
+        printJson(turn);
+      } else {
+        printTurnHuman(turn);
+      }
+      return mapTurnExitCode(turn.status);
+    })
+  );
+  return addRuntimeOptions(command);
+}
+
+// src/commands/upload.ts
+import { Command as Command9 } from "commander";
+function buildUploadCommand() {
+  const command = new Command9("upload");
+  command.description("Upload a file and return its file_id").argument("<path>", "Local file path").action(
+    wrapCommand(async (filePath, options) => {
+      const { client } = await createClient(options);
+      const uploaded = await client.uploadFile(filePath);
+      if (options.json) {
+        printJson(uploaded);
+      } else {
+        printUploadHuman(uploaded);
+      }
+      return 0;
+    })
+  );
+  return addRuntimeOptions(command);
+}
+
+// src/index.ts
+var program = new Command10();
+program.name("ignis").description("Ignis CLI for Ultra-Mai").version("0.1.0");
+program.addCommand(buildLoginCommand());
+program.addCommand(buildAskCommand());
+program.addCommand(buildHistoryCommand());
+program.addCommand(buildSkillsCommand());
+program.addCommand(buildStatusCommand());
+program.addCommand(buildResumeCommand());
+program.addCommand(buildCancelCommand());
+program.addCommand(buildUploadCommand());
+await program.parseAsync(process.argv);

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "ignis-agent-cli",
+  "version": "0.1.0",
+  "description": "Stateless CLI for the Ultra-Mai Agent V2 service",
+  "license": "UNLICENSED",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/adtech-crypto/mai-2-tmp.git"
+  },
+  "bugs": {
+    "url": "https://github.com/adtech-crypto/mai-2-tmp/issues"
+  },
+  "homepage": "https://github.com/adtech-crypto/mai-2-tmp/tree/test/ignis",
+  "keywords": [
+    "ignis",
+    "cli",
+    "agent",
+    "funplus",
+    "fastapi"
+  ],
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "bin": {
+    "ignis": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --target node18 --out-dir dist --clean",
+    "dev": "node --loader ts-node/esm src/index.ts",
+    "prepack": "npm run build",
+    "typecheck": "tsc --noEmit"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "commander": "^13.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.10",
+    "ts-node": "^10.9.2",
+    "tsup": "^8.4.0",
+    "typescript": "^5.8.2"
+  }
+}