@tuttiai/cli 0.15.0 → 0.16.0

package/dist/index.js

@@ -2603,8 +2603,8 @@ async function replayCommand(sessionId, opts = {}) {
   const rl = createInterface3({ input: process.stdin, output: process.stdout });
   try {
     while (true) {
-      const prompt4 = chalk17.cyan("replay [" + cursor + "/" + (messages.length - 1) + "]> ");
-      const raw = await rl.question(prompt4);
+      const prompt5 = chalk17.cyan("replay [" + cursor + "/" + (messages.length - 1) + "]> ");
+      const raw = await rl.question(prompt5);
       const input = raw.trim();
       if (!input) continue;
       const [cmd, ...args] = input.split(/\s+/);
@@ -3443,6 +3443,369 @@ async function memoryExportCommand(opts) {
   }
 }
 
+// src/commands/interrupts.ts
+import chalk24 from "chalk";
+import Enquirer4 from "enquirer";
+import { SecretsManager as SecretsManager11 } from "@tuttiai/core";
+
+// src/commands/interrupts-render.ts
+import chalk23 from "chalk";
+function visibleLen3(s) {
+  return s.replace(/\u001b\[[0-9;]*m/g, "").length;
+}
+function pad6(s, len) {
+  const v = visibleLen3(s);
+  return v >= len ? s : s + " ".repeat(len - v);
+}
+function truncate2(text, max) {
+  const oneLine = text.replace(/\s+/g, " ").trim();
+  return oneLine.length > max ? oneLine.slice(0, max - 1) + "\u2026" : oneLine;
+}
+function formatIsoShort(d) {
+  const iso = d.toISOString();
+  return iso.slice(0, 10) + " " + iso.slice(11, 19);
+}
+function formatRelativeTime(requested_at, now = /* @__PURE__ */ new Date()) {
+  const diffMs = now.getTime() - requested_at.getTime();
+  if (diffMs < 0) return "now";
+  const s = Math.floor(diffMs / 1e3);
+  if (s < 60) return s + "s ago";
+  const m = Math.floor(s / 60);
+  if (m < 60) return m + "m ago";
+  const h = Math.floor(m / 60);
+  if (h < 24) return h + "h ago";
+  const d = Math.floor(h / 24);
+  return d + "d ago";
+}
+function truncateArgs(tool_args, max = 80) {
+  let json;
+  try {
+    json = JSON.stringify(tool_args);
+  } catch {
+    json = String(tool_args);
+  }
+  if (json === void 0) return "";
+  return truncate2(json, max);
+}
+function renderInterruptsList(interrupts, now = /* @__PURE__ */ new Date()) {
+  if (interrupts.length === 0) {
+    return chalk23.dim("No pending interrupts.");
+  }
+  const lines = [];
+  lines.push("");
+  lines.push(
+    chalk23.dim(
+      "  " + pad6("ID", 10) + pad6("SESSION", 14) + pad6("TOOL", 22) + pad6("ARGS", 52) + "AGE"
+    )
+  );
+  lines.push(chalk23.dim("  " + "\u2500".repeat(110)));
+  for (const r of interrupts) {
+    const idShort = r.interrupt_id.slice(0, 8);
+    const sessionShort = r.session_id.slice(0, 12);
+    const toolName = truncate2(r.tool_name, 20);
+    const argsPreview = truncateArgs(r.tool_args, 50);
+    const age = formatRelativeTime(r.requested_at, now);
+    lines.push(
+      "  " + chalk23.bold(pad6(idShort, 10)) + pad6(sessionShort, 14) + pad6(chalk23.cyan(toolName), 22) + pad6(chalk23.dim(argsPreview), 52) + chalk23.dim(age)
+    );
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function renderInterruptDetail(interrupt, now = /* @__PURE__ */ new Date()) {
+  const lines = [];
+  lines.push("");
+  lines.push(chalk23.bold("Interrupt ") + chalk23.dim(interrupt.interrupt_id));
+  lines.push(chalk23.dim("\u2500".repeat(60)));
+  lines.push(chalk23.dim("Session:     ") + interrupt.session_id);
+  lines.push(chalk23.dim("Tool:        ") + chalk23.cyan(interrupt.tool_name));
+  lines.push(
+    chalk23.dim("Requested:   ") + formatIsoShort(interrupt.requested_at) + chalk23.dim(" (" + formatRelativeTime(interrupt.requested_at, now) + ")")
+  );
+  lines.push(chalk23.dim("Status:      ") + colorStatus2(interrupt.status));
+  if (interrupt.resolved_at) {
+    lines.push(chalk23.dim("Resolved:    ") + formatIsoShort(interrupt.resolved_at));
+  }
+  if (interrupt.resolved_by) {
+    lines.push(chalk23.dim("Resolved by: ") + interrupt.resolved_by);
+  }
+  if (interrupt.denial_reason) {
+    lines.push(chalk23.dim("Reason:      ") + interrupt.denial_reason);
+  }
+  lines.push("");
+  lines.push(chalk23.dim("Arguments:"));
+  lines.push(prettyJson(interrupt.tool_args));
+  lines.push("");
+  return lines.join("\n");
+}
+function prettyJson(value) {
+  try {
+    return JSON.stringify(value, null, 2);
+  } catch {
+    return String(value);
+  }
+}
+function colorStatus2(status) {
+  if (status === "approved") return chalk23.green("approved");
+  if (status === "denied") return chalk23.red("denied");
+  return chalk23.yellow("pending");
+}
+function renderApproved(interrupt) {
+  return chalk23.green("\u2713") + " Approved " + chalk23.bold(interrupt.interrupt_id.slice(0, 8)) + chalk23.dim(" (" + interrupt.tool_name + ")") + (interrupt.resolved_by ? chalk23.dim(" by " + interrupt.resolved_by) : "");
+}
+function renderDenied(interrupt) {
+  return chalk23.red("\u2717") + " Denied " + chalk23.bold(interrupt.interrupt_id.slice(0, 8)) + chalk23.dim(" (" + interrupt.tool_name + ")") + (interrupt.denial_reason ? chalk23.dim(' \u2014 "' + interrupt.denial_reason + '"') : "");
+}
+
+// src/commands/interrupts.ts
+var { prompt: prompt4 } = Enquirer4;
+var DEFAULT_SERVER_URL2 = "http://127.0.0.1:3847";
+var POLL_INTERVAL_MS = 2e3;
+function resolveUrl2(opts) {
+  return opts.url ?? SecretsManager11.optional("TUTTI_SERVER_URL") ?? DEFAULT_SERVER_URL2;
+}
+function resolveAuthHeader2(opts) {
+  const key = opts.apiKey ?? SecretsManager11.optional("TUTTI_API_KEY");
+  return key ? { Authorization: "Bearer " + key } : {};
+}
+function explainConnectionError2(err, baseUrl) {
+  const msg = err instanceof Error ? err.message : String(err);
+  console.error(chalk24.red("Failed to reach Tutti server at " + baseUrl));
+  console.error(chalk24.dim("  " + msg));
+  console.error(
+    chalk24.dim("  Is `tutti-ai serve` running? Set --url or TUTTI_SERVER_URL to override.")
+  );
+  process.exit(1);
+}
+function reviveInterrupt(wire) {
+  const req = {
+    interrupt_id: wire["interrupt_id"],
+    session_id: wire["session_id"],
+    tool_name: wire["tool_name"],
+    tool_args: wire["tool_args"],
+    requested_at: new Date(wire["requested_at"]),
+    status: wire["status"]
+  };
+  if (typeof wire["resolved_at"] === "string") {
+    req.resolved_at = new Date(wire["resolved_at"]);
+  }
+  if (typeof wire["resolved_by"] === "string") {
+    req.resolved_by = wire["resolved_by"];
+  }
+  if (typeof wire["denial_reason"] === "string") {
+    req.denial_reason = wire["denial_reason"];
+  }
+  return req;
+}
+async function httpJson(opts, method, path, body) {
+  const baseUrl = resolveUrl2(opts);
+  const url = baseUrl.replace(/\/$/, "") + path;
+  let res;
+  try {
+    res = await fetch(url, {
+      method,
+      headers: {
+        "Content-Type": "application/json",
+        ...resolveAuthHeader2(opts)
+      },
+      ...body !== void 0 ? { body: JSON.stringify(body) } : {}
+    });
+  } catch (err) {
+    explainConnectionError2(err, baseUrl);
+  }
+  const text = await res.text();
+  const parsed = text === "" ? null : JSON.parse(text);
+  return { status: res.status, body: parsed };
+}
+async function fetchPending(opts) {
+  const { status, body } = await httpJson(
+    opts,
+    "GET",
+    "/interrupts/pending"
+  );
+  if (status === 401) {
+    console.error(chalk24.red("Unauthorized \u2014 set --api-key or TUTTI_API_KEY."));
+    process.exit(1);
+  }
+  if (status === 503) {
+    console.error(
+      chalk24.red(
+        "The server has no InterruptStore configured. Start `tutti-ai serve` with an interrupt store attached."
+      )
+    );
+    process.exit(1);
+  }
+  if (status < 200 || status >= 300 || !("interrupts" in body)) {
+    console.error(chalk24.red("Unexpected server response: " + status));
+    process.exit(1);
+  }
+  return body.interrupts.map(reviveInterrupt);
+}
+async function postResolve(opts, interruptId, action, payload) {
+  const { status, body } = await httpJson(
+    opts,
+    "POST",
+    "/interrupts/" + encodeURIComponent(interruptId) + "/" + action,
+    payload
+  );
+  if (status === 401) {
+    console.error(chalk24.red("Unauthorized \u2014 set --api-key or TUTTI_API_KEY."));
+    process.exit(1);
+  }
+  if (status === 404) {
+    console.error(chalk24.red('Interrupt "' + interruptId + '" not found.'));
+    process.exit(1);
+  }
+  if (status === 409) {
+    const current = body.current;
+    const currentStatus = current && typeof current["status"] === "string" ? current["status"] : "resolved";
+    console.error(
+      chalk24.red("Interrupt already " + currentStatus + " \u2014 refusing to override.")
+    );
+    process.exit(1);
+  }
+  if (status < 200 || status >= 300) {
+    console.error(chalk24.red("Unexpected server response: " + status));
+    process.exit(1);
+  }
+  return reviveInterrupt(body);
+}
+async function interruptsListCommand(opts) {
+  const pending = await fetchPending(opts);
+  console.log(renderInterruptsList(pending));
+}
+async function interruptsApproveCommand(interruptId, opts) {
+  const resolved = await postResolve(opts, interruptId, "approve", {
+    ...opts.resolvedBy !== void 0 ? { resolved_by: opts.resolvedBy } : {}
+  });
+  console.log(renderApproved(resolved));
+}
+async function interruptsDenyCommand(interruptId, opts) {
+  const resolved = await postResolve(opts, interruptId, "deny", {
+    ...opts.reason !== void 0 ? { reason: opts.reason } : {},
+    ...opts.resolvedBy !== void 0 ? { resolved_by: opts.resolvedBy } : {}
+  });
+  console.log(renderDenied(resolved));
+}
+function clearScreen() {
+  process.stdout.write("\x1B[2J\x1B[H");
+}
+function readKey() {
+  const input = process.stdin;
+  if (!input.isTTY) return Promise.resolve(null);
+  return new Promise((resolve18) => {
+    input.setRawMode(true);
+    input.resume();
+    input.setEncoding("utf8");
+    const onData = (data) => {
+      input.removeListener("data", onData);
+      input.setRawMode(false);
+      input.pause();
+      resolve18(data);
+    };
+    input.on("data", onData);
+  });
+}
+async function readKeyOrTimeout(ms) {
+  let timer;
+  const timeout = new Promise((resolve18) => {
+    timer = setTimeout(() => resolve18(null), ms);
+  });
+  try {
+    const winner = await Promise.race([readKey(), timeout]);
+    return winner;
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+async function interruptsTUICommand(opts) {
+  if (!process.stdin.isTTY) {
+    await interruptsListCommand(opts);
+    return;
+  }
+  const sigint = () => {
+    if (process.stdin.isTTY) process.stdin.setRawMode(false);
+    process.stdout.write("\n");
+    process.exit(0);
+  };
+  process.on("SIGINT", sigint);
+  try {
+    for (; ; ) {
+      const pending = await fetchPending(opts);
+      clearScreen();
+      console.log(
+        chalk24.bold("Tutti \u2014 pending interrupts") + chalk24.dim("   (auto-refresh every " + POLL_INTERVAL_MS / 1e3 + "s)")
+      );
+      console.log(renderInterruptsList(pending));
+      if (pending.length > 0) {
+        console.log(
+          chalk24.dim(
+            "Press a number to inspect, 'r' to refresh, 'q' to quit."
+          )
+        );
+      } else {
+        console.log(chalk24.dim("Press 'r' to refresh, 'q' to quit."));
+      }
+      const indexed = pending.slice(0, 9);
+      const key = await readKeyOrTimeout(POLL_INTERVAL_MS);
+      if (key === null) continue;
+      if (key === "q" || key === "") return;
+      if (key === "r") continue;
+      const digit = parseInt(key, 10);
+      if (!Number.isNaN(digit) && digit >= 1 && digit <= indexed.length) {
+        const chosen = indexed[digit - 1];
+        const shouldContinue = await runDetailView(opts, chosen);
+        if (!shouldContinue) return;
+      }
+    }
+  } finally {
+    process.off("SIGINT", sigint);
+    if (process.stdin.isTTY) process.stdin.setRawMode(false);
+  }
+}
+async function runDetailView(opts, interrupt) {
+  clearScreen();
+  console.log(renderInterruptDetail(interrupt));
+  console.log(
+    chalk24.dim(
+      "Press 'a' to approve, 'd' to deny, 'q' to go back to the list."
+    )
+  );
+  const key = await readKey();
+  if (key === null || key === "q" || key === "") return true;
+  if (key === "a") {
+    const resolved = await postResolve(opts, interrupt.interrupt_id, "approve", {});
+    clearScreen();
+    console.log(renderApproved(resolved));
+    await pause();
+    return true;
+  }
+  if (key === "d") {
+    const { reason } = await prompt4({
+      type: "input",
+      name: "reason",
+      message: "Reason (optional):"
+    });
+    const payload = {};
+    if (reason && reason.trim() !== "") payload["reason"] = reason.trim();
+    const resolved = await postResolve(
+      opts,
+      interrupt.interrupt_id,
+      "deny",
+      payload
+    );
+    clearScreen();
+    console.log(renderDenied(resolved));
+    await pause();
+    return true;
+  }
+  return true;
+}
+async function pause() {
+  console.log(chalk24.dim("\nPress any key to continue..."));
+  await readKey();
+}
+
 // src/index.ts
 config();
 var logger16 = createLogger16("tutti-cli");
@@ -3593,5 +3956,34 @@ memoryCmd.command("export").description("Export every memory for a user as JSON
     ...opts.out !== void 0 ? { out: opts.out } : {}
   });
 });
+function toInterruptsOptions(raw) {
+  return {
+    ...raw.url !== void 0 ? { url: raw.url } : {},
+    ...raw.apiKey !== void 0 ? { apiKey: raw.apiKey } : {}
+  };
+}
+var interruptsCmd = program.command("interrupts").description("Review and resolve approval-gated tool calls");
+interruptsCmd.option("-u, --url <url>", "Server URL (default: http://127.0.0.1:3847)").option("-k, --api-key <key>", "Bearer token (default: TUTTI_API_KEY env)").action(async (opts) => {
+  await interruptsTUICommand(toInterruptsOptions(opts));
+});
+interruptsCmd.command("list").description("Print pending interrupts as a table and exit (script-friendly)").option("-u, --url <url>", "Server URL (default: http://127.0.0.1:3847)").option("-k, --api-key <key>", "Bearer token (default: TUTTI_API_KEY env)").action(async (opts) => {
+  await interruptsListCommand(toInterruptsOptions(opts));
+});
+interruptsCmd.command("approve <interrupt-id>").description("Approve an interrupt directly").option("-u, --url <url>", "Server URL (default: http://127.0.0.1:3847)").option("-k, --api-key <key>", "Bearer token (default: TUTTI_API_KEY env)").option("--by <name>", "Reviewer identifier (resolved_by field)").action(async (id, opts) => {
+  await interruptsApproveCommand(id, {
+    ...toInterruptsOptions(opts),
+    ...opts.by !== void 0 ? { resolvedBy: opts.by } : {}
+  });
+});
+interruptsCmd.command("deny <interrupt-id>").description("Deny an interrupt directly").option("-u, --url <url>", "Server URL (default: http://127.0.0.1:3847)").option("-k, --api-key <key>", "Bearer token (default: TUTTI_API_KEY env)").option("--reason <text>", "Free-text denial reason").option("--by <name>", "Reviewer identifier (resolved_by field)").action(async (id, opts) => {
+  await interruptsDenyCommand(id, {
+    ...toInterruptsOptions(opts),
+    ...opts.reason !== void 0 ? { reason: opts.reason } : {},
+    ...opts.by !== void 0 ? { resolvedBy: opts.by } : {}
+  });
+});
+program.command("approve").description("Alias for `tutti-ai interrupts` \u2014 interactive approval TUI").option("-u, --url <url>", "Server URL (default: http://127.0.0.1:3847)").option("-k, --api-key <key>", "Bearer token (default: TUTTI_API_KEY env)").action(async (opts) => {
+  await interruptsTUICommand(toInterruptsOptions(opts));
+});
 program.parse();
 //# sourceMappingURL=index.js.map