@aiaiai-pt/martha-cli 0.24.0 → 0.26.0

package/dist/index.js

@@ -2158,6 +2158,8 @@ function extractDetail(body) {
       const nested = obj.detail;
       if (typeof nested.message === "string")
         return nested.message;
+      if (typeof nested.code === "string")
+        return nested.code;
       if (nested.code === "mcp_oauth_authorization_required" && typeof nested.authorization_url === "string") {
         return "MCP OAuth authorization required";
       }
@@ -11073,11 +11075,13 @@ ${items.length} ${config.typeNamePlural}`));
 }
 
 // src/commands/chat.ts
+import { createHash as createHash2 } from "node:crypto";
 import { createInterface as createInterface2 } from "node:readline";
+init_config();
 init_errors();
 
 // src/version.ts
-var CLI_VERSION = "0.24.0";
+var CLI_VERSION = "0.26.0";
 
 // src/commands/sessions.ts
 function relativeTime(iso) {
@@ -11351,6 +11355,7 @@ function createApprovalTagStripper() {
 
 // src/lib/local-exec.ts
 import { spawn } from "node:child_process";
+import { randomBytes as randomBytes2 } from "node:crypto";
 import { closeSync, openSync, promises as fs5 } from "node:fs";
 import * as path4 from "node:path";
 var DEFAULT_TIMEOUT_MS = 20000;
@@ -11373,15 +11378,26 @@ async function runHostCommand(command, toolCallId, opts) {
       return "";
     }
   };
+  const stdin = opts.stdinData != null ? "pipe" : "ignore";
   return await new Promise((resolve, reject) => {
     let settled = false;
-    const child = spawn(command, {
+    const child = opts.argv ? spawn(opts.argv[0], opts.argv.slice(1), {
+      shell: false,
+      cwd: opts.cwd,
+      detached: true,
+      stdio: [stdin, fd, fd]
+    }) : spawn(command, {
       shell: true,
       cwd: opts.cwd,
       detached: true,
-      stdio: ["ignore", fd, fd]
+      stdio: [stdin, fd, fd]
     });
     closeSync(fd);
+    if (opts.stdinData != null && child.stdin) {
+      child.stdin.on("error", () => {});
+      child.stdin.write(opts.stdinData);
+      child.stdin.end();
+    }
     const timer = setTimeout(async () => {
       if (settled)
         return;
@@ -11392,7 +11408,8 @@ async function runHostCommand(command, toolCallId, opts) {
         stderr: "",
         exit_code: 0,
         backgrounded: true,
-        pid: child.pid
+        pid: child.pid,
+        log_path: logPath
       });
     }, opts.timeoutMs ?? DEFAULT_TIMEOUT_MS);
     child.on("error", (e) => {
@@ -11407,13 +11424,21 @@ async function runHostCommand(command, toolCallId, opts) {
         return;
       settled = true;
       clearTimeout(timer);
-      resolve({ stdout: await readLog(), stderr: "", exit_code: code ?? -1 });
+      resolve({
+        stdout: await readLog(),
+        stderr: "",
+        exit_code: code ?? -1,
+        log_path: logPath
+      });
     });
   });
 }
 function safeName(s) {
   return s.replace(/[^a-zA-Z0-9_.-]/g, "_").slice(0, 120) || "task";
 }
+function mintExecSecret() {
+  return randomBytes2(32).toString("hex");
+}
 
 class Journal {
   cwd;
@@ -11425,9 +11450,13 @@ class Journal {
   }
   async load() {
     try {
-      return JSON.parse(await fs5.readFile(this.file(), "utf8"));
+      const raw = JSON.parse(await fs5.readFile(this.file(), "utf8"));
+      if (raw["entries"] !== undefined) {
+        return raw;
+      }
+      return { entries: raw, secrets: {} };
     } catch {
-      return {};
+      return { entries: {}, secrets: {} };
     }
   }
   async save(data) {
@@ -11438,11 +11467,11 @@ class Journal {
     return `${sessionId}:${toolCallId}`;
   }
   async lookup(sessionId, toolCallId) {
-    return (await this.load())[Journal.key(sessionId, toolCallId)];
+    return (await this.load()).entries[Journal.key(sessionId, toolCallId)];
   }
   async recordRunning(sessionId, toolCallId, command, now) {
     const data = await this.load();
-    data[Journal.key(sessionId, toolCallId)] = {
+    data.entries[Journal.key(sessionId, toolCallId)] = {
       state: "running",
       command,
       started_at: now
@@ -11452,8 +11481,8 @@ class Journal {
   async recordDone(sessionId, toolCallId, result) {
     const data = await this.load();
     const k = Journal.key(sessionId, toolCallId);
-    const prev = data[k];
-    data[k] = {
+    const prev = data.entries[k];
+    data.entries[k] = {
       state: "done",
       command: prev?.command ?? "",
       started_at: prev?.started_at ?? "",
@@ -11461,6 +11490,14 @@ class Journal {
     };
     await this.save(data);
   }
+  async recordSecret(sessionId, toolCallId, secret) {
+    const data = await this.load();
+    data.secrets[Journal.key(sessionId, toolCallId)] = secret;
+    await this.save(data);
+  }
+  async lookupSecret(sessionId, toolCallId) {
+    return (await this.load()).secrets[Journal.key(sessionId, toolCallId)];
+  }
 }
 function decideFromJournal(entry) {
   if (!entry)
@@ -11816,66 +11853,51 @@ function parseHostFileRequests(data) {
 }
 
 // src/lib/local-agent.ts
-import { spawn as spawn2 } from "node:child_process";
-var DEFAULT_LOCAL_AGENT_CMD = "codex exec";
+var AGENT_PRESETS = {
+  claude: {
+    name: "claude",
+    command: ["claude", "-p"],
+    promptVia: "argv",
+    description: "Claude Code headless (prompt passed as an argument)."
+  },
+  codex: {
+    name: "codex",
+    command: ["codex", "exec", "--skip-git-repo-check"],
+    promptVia: "stdin",
+    description: "OpenAI Codex CLI (prompt on stdin; runs outside a git repo)."
+  },
+  "cursor-agent": {
+    name: "cursor-agent",
+    command: ["cursor-agent", "--print", "--trust"],
+    promptVia: "argv",
+    description: "Cursor Agent headless (prompt passed as an argument)."
+  }
+};
+var DEFAULT_LOCAL_AGENT = "codex";
 var DEFAULT_LOCAL_AGENT_TIMEOUT_MS = 30 * 60 * 1000;
-var MAX_OUTPUT2 = 256 * 1024;
-function buildAgentArgv(agentCmd, task) {
-  const parts = agentCmd.trim().split(/\s+/).filter(Boolean);
-  if (parts.length === 0)
-    throw new Error("MARTHA_LOCAL_AGENT_CMD is empty");
-  return [...parts, task];
-}
-async function runLocalAgent(task, opts) {
-  const argv = buildAgentArgv(opts.agentCmd, task);
-  const cap = opts.maxOutputBytes ?? MAX_OUTPUT2;
-  const timeoutMs = opts.timeoutMs ?? DEFAULT_LOCAL_AGENT_TIMEOUT_MS;
-  return await new Promise((resolve2, reject) => {
-    let out = "";
-    let settled = false;
-    let child;
-    try {
-      child = spawn2(argv[0], argv.slice(1), {
-        cwd: opts.cwd,
-        shell: false,
-        stdio: ["ignore", "pipe", "pipe"]
-      });
-    } catch (e) {
-      reject(e);
-      return;
-    }
-    const append = (chunk) => {
-      if (out.length < cap)
-        out += chunk.toString("utf8");
+function resolveAgentInvocation(value) {
+  const trimmed = (value || "").trim();
+  if (!trimmed)
+    throw new Error("local agent command is empty");
+  const preset = AGENT_PRESETS[trimmed];
+  if (preset) {
+    return {
+      command: preset.command,
+      promptVia: preset.promptVia,
+      source: preset.name
     };
-    child.stdout?.on("data", append);
-    child.stderr?.on("data", append);
-    const timer = setTimeout(() => {
-      if (settled)
-        return;
-      settled = true;
-      child.kill("SIGKILL");
-      resolve2({
-        text: out.slice(0, cap),
-        exit_code: -1,
-        timed_out: true
-      });
-    }, timeoutMs);
-    child.on("error", (e) => {
-      if (settled)
-        return;
-      settled = true;
-      clearTimeout(timer);
-      reject(e);
-    });
-    child.on("close", (code) => {
-      if (settled)
-        return;
-      settled = true;
-      clearTimeout(timer);
-      resolve2({ text: out.slice(0, cap), exit_code: code ?? -1 });
-    });
-  });
+  }
+  const parts = trimmed.split(/\s+/).filter(Boolean);
+  return { command: parts, promptVia: "argv", source: trimmed };
+}
+function buildSpawn(invocation, task) {
+  if (invocation.command.length === 0)
+    throw new Error("local agent command is empty");
+  const [bin, ...rest] = invocation.command;
+  if (invocation.promptVia === "stdin") {
+    return { bin, args: rest, stdin: task };
+  }
+  return { bin, args: [...rest, task], stdin: null };
 }
 function parseLocalAgentRequests(data) {
   let tools;
@@ -12032,7 +12054,7 @@ async function resolveHostFile(req, state) {
     return { error: true, message: result.message };
   return result;
 }
-async function resolveLocalAgent(req, state) {
+async function resolveLocalAgent(sessionId, toolCallId, req, state) {
   if (!state.autoYes) {
     process.stderr.write(source_default.yellow(`
 [local_agent] refused (re-run with --yes to allow): ${req.task.slice(0, 80)}
@@ -12042,28 +12064,87 @@ async function resolveLocalAgent(req, state) {
       message: "Local agent delegation declined; re-run with --yes to allow."
     };
   }
-  const agentCmd = process.env.MARTHA_LOCAL_AGENT_CMD || DEFAULT_LOCAL_AGENT_CMD;
+  let invocation;
+  try {
+    invocation = resolveAgentInvocation(state.localAgent);
+  } catch (e) {
+    return { error: true, message: `invalid local agent config: ${String(e)}` };
+  }
+  const decision = decideFromJournal(await state.journal.lookup(sessionId, toolCallId));
+  if (decision.kind === "replay")
+    return decision.result;
+  if (decision.kind === "crashed") {
+    return {
+      error: true,
+      exit_code: -1,
+      message: `A previous local_agent run (${decision.command}) did not complete; ` + `not re-running. Its log survives under .martha-runner/ — read it with host_read.`
+    };
+  }
   const cwd = req.cwd ? `${state.cwd}/${req.cwd}` : state.cwd;
+  const { bin, args, stdin } = buildSpawn(invocation, req.task);
   process.stderr.write(source_default.dim(`
-[local_agent] (${agentCmd}) ${req.task.slice(0, 100)}
+[local_agent] (${invocation.source}) ${req.task.slice(0, 100)}
 `));
+  await state.journal.recordRunning(sessionId, toolCallId, `local_agent:${invocation.source}`, new Date().toISOString());
+  let result;
   try {
-    const result = await runLocalAgent(req.task, { cwd, agentCmd });
-    return {
-      text: result.text || "(local agent produced no output)",
-      exit_code: result.exit_code,
-      ...result.timed_out ? { timed_out: true } : {}
-    };
+    result = await runHostCommand(`local_agent:${invocation.source}`, toolCallId, {
+      cwd,
+      argv: [bin, ...args],
+      stdinData: stdin ?? undefined,
+      timeoutMs: DEFAULT_LOCAL_AGENT_TIMEOUT_MS
+    });
   } catch (e) {
+    const failed = {
+      stdout: "",
+      stderr: String(e),
+      exit_code: -1
+    };
+    await state.journal.recordDone(sessionId, toolCallId, failed);
     return {
       error: true,
-      message: `local agent failed to start (${agentCmd}): ${String(e)}. ` + `Set MARTHA_LOCAL_AGENT_CMD to an installed agent command.`
+      message: `local agent failed to start (${invocation.source}): ${String(e)}. ` + `Pick an installed agent with --local-agent <claude|codex|cursor-agent> ` + `or set one via 'martha config set local_agent <name>'.`
+    };
+  }
+  await state.journal.recordDone(sessionId, toolCallId, result);
+  if (result.backgrounded) {
+    const mins = Math.round(DEFAULT_LOCAL_AGENT_TIMEOUT_MS / 60000);
+    return {
+      text: result.stdout || "(no output captured yet)",
+      backgrounded: true,
+      pid: result.pid,
+      log_path: result.log_path,
+      message: `The local agent is still running after ${mins} min; it was left running ` + `in the background (it survives this session). Read its live log and final ` + `result with host_read on ${result.log_path}.`
     };
   }
+  return {
+    text: result.stdout || "(local agent produced no output)",
+    exit_code: result.exit_code,
+    log_path: result.log_path
+  };
 }
-async function _postToolResult(ctx, sessionId, toolCallId, result, label) {
+async function claimGate(ctx, sessionId, toolCallId, state) {
+  if (state.claimed.has(toolCallId))
+    return;
+  const secret = state.secrets.get(toolCallId) ?? mintExecSecret();
+  const secretHash = createHash2("sha256").update(secret).digest("hex");
+  state.secrets.set(toolCallId, secret);
+  await state.journal.recordSecret(sessionId, toolCallId, secret);
   try {
-    await ctx.api.post(`/api/chat/${encodeURIComponent(sessionId)}/tool-result`, { tool_call_id: toolCallId, result });
+    await ctx.api.post(`/api/chat/${encodeURIComponent(sessionId)}/tool-claim`, { tool_call_id: toolCallId, secret_hash: secretHash });
+    state.claimed.add(toolCallId);
+  } catch (e) {
+    process.stderr.write(source_default.yellow(`[local-exec] failed to claim gate for ${toolCallId}: ${String(e)}
+`));
+  }
+}
+async function _postToolResult(ctx, sessionId, toolCallId, result, label, execSecret) {
+  try {
+    await ctx.api.post(`/api/chat/${encodeURIComponent(sessionId)}/tool-result`, {
+      tool_call_id: toolCallId,
+      result,
+      ...execSecret !== undefined ? { exec_secret: execSecret } : {}
+    });
   } catch (e) {
     process.stderr.write(source_default.red(`[${label}] failed to POST result: ${String(e)}
 `));
@@ -12075,40 +12156,45 @@ async function handleHostExecFrame(ctx, sessionId, data, state) {
     if (state.handled.has(id))
       continue;
     state.handled.add(id);
+    await claimGate(ctx, sessionId, id, state);
     const result = await resolveHostExec(sessionId, id, req.command, state);
-    await _postToolResult(ctx, sessionId, id, result, "host_exec");
+    await _postToolResult(ctx, sessionId, id, result, "host_exec", state.secrets.get(id));
   }
   for (const req of parseHostScreenshotRequests(data)) {
     const id = req.toolCallId;
     if (state.handled.has(id))
       continue;
     state.handled.add(id);
+    await claimGate(ctx, sessionId, id, state);
     const result = await resolveHostScreenshot(ctx, sessionId, req, state);
-    await _postToolResult(ctx, sessionId, id, result, "host_screenshot");
+    await _postToolResult(ctx, sessionId, id, result, "host_screenshot", state.secrets.get(id));
   }
   for (const req of parseHostBrowserRequests(data)) {
     const id = req.toolCallId;
     if (state.handled.has(id))
       continue;
     state.handled.add(id);
+    await claimGate(ctx, sessionId, id, state);
     const result = await resolveHostBrowser(ctx, sessionId, req, state);
-    await _postToolResult(ctx, sessionId, id, result, "host_browser");
+    await _postToolResult(ctx, sessionId, id, result, "host_browser", state.secrets.get(id));
   }
   for (const req of parseHostFileRequests(data)) {
     const id = req.toolCallId;
     if (state.handled.has(id))
       continue;
     state.handled.add(id);
+    await claimGate(ctx, sessionId, id, state);
     const result = await resolveHostFile(req, state);
-    await _postToolResult(ctx, sessionId, id, result, req.action);
+    await _postToolResult(ctx, sessionId, id, result, req.action, state.secrets.get(id));
   }
   for (const req of parseLocalAgentRequests(data)) {
     const id = req.toolCallId;
     if (state.handled.has(id))
       continue;
     state.handled.add(id);
-    const result = await resolveLocalAgent(req, state);
-    await _postToolResult(ctx, sessionId, id, result, "local_agent");
+    await claimGate(ctx, sessionId, id, state);
+    const result = await resolveLocalAgent(sessionId, id, req, state);
+    await _postToolResult(ctx, sessionId, id, result, "local_agent", state.secrets.get(id));
   }
 }
 function parseSlashCommand(input) {
@@ -12164,8 +12250,11 @@ async function sendMessage(ctx, sessionId, message, opts = {}) {
   const localExecState = opts.localExec ? {
     cwd: opts.localExec.cwd,
     autoYes: opts.localExec.autoYes,
+    localAgent: opts.localExec.agent,
     handled: new Set,
-    journal: new Journal(opts.localExec.cwd)
+    journal: new Journal(opts.localExec.cwd),
+    secrets: new Map,
+    claimed: new Set
   } : null;
   const reqBody = { content: message };
   if (opts.localExec)
@@ -12685,7 +12774,7 @@ async function runOneShot(ctx, sessionId, message, isJson, clientId, agentName,
   }
 }
 function registerChatCommand(program2) {
-  program2.command("chat").description("Chat with a Martha agent").option("--session <id>", "Resume an existing session").option("--client <nameOrId>", "Use a specific client (name or ID)").option("--agent <name>", "Drive the chat with a specific copilot agent (defaults to profile.default_agent)").option("--message <text>", "Send a single message (non-interactive)").option("--show-tools", "Show tool calls and results during chat").option("--local-exec", "Allow the agent to run host tools on THIS machine (#568). Requires the server to have LOCAL_EXEC_ENABLED=1.").option("--yes", "Auto-approve host tool execution (required with --local-exec for non-interactive runs).").option("--timeout <seconds>", "Per-message HTTP timeout in seconds (default: 600)").action(async (opts) => {
+  program2.command("chat").description("Chat with a Martha agent").option("--session <id>", "Resume an existing session").option("--client <nameOrId>", "Use a specific client (name or ID)").option("--agent <name>", "Drive the chat with a specific copilot agent (defaults to profile.default_agent)").option("--message <text>", "Send a single message (non-interactive)").option("--show-tools", "Show tool calls and results during chat").option("--local-exec", "Allow the agent to run host tools on THIS machine (#568). Requires the server to have LOCAL_EXEC_ENABLED=1.").option("--yes", "Auto-approve host tool execution (required with --local-exec for non-interactive runs).").option("--local-agent <name>", "Which local coding agent `local_agent` delegates to: a preset (claude | codex | cursor-agent) or a raw command. Overrides MARTHA_LOCAL_AGENT_CMD and `config local_agent` for this run.").option("--timeout <seconds>", "Per-message HTTP timeout in seconds (default: 600)").action(async (opts) => {
     const ctx = createContext({
       profileOverride: program2.opts().profile,
       verbose: program2.opts().verbose
@@ -12720,7 +12809,8 @@ function registerChatCommand(program2) {
     }
     const showTools = !!opts.showTools;
     const timeoutMs = opts.timeout ? parseTimeoutSeconds(opts.timeout) * 1000 : undefined;
-    const localExec = opts.localExec ? { cwd: process.cwd(), autoYes: !!opts.yes } : undefined;
+    const localAgentChoice = opts.localAgent || process.env.MARTHA_LOCAL_AGENT_CMD || loadConfig().settings.local_agent || DEFAULT_LOCAL_AGENT;
+    const localExec = opts.localExec ? { cwd: process.cwd(), autoYes: !!opts.yes, agent: localAgentChoice } : undefined;
     if (opts.message) {
       await runOneShot(ctx, sessionId, opts.message, isJson, clientId, agentName, showTools, timeoutMs, localExec);
     } else {
@@ -12841,6 +12931,8 @@ Global Settings
       console.log(`  Editor:       ${settings.editor}`);
     if (settings.pager)
       console.log(`  Pager:        ${settings.pager}`);
+    if (settings.local_agent)
+      console.log(`  Local agent:  ${settings.local_agent}`);
     if (settings.chat) {
       if (settings.chat.show_tool_calls)
         console.log(`  Tool calls:   ${settings.chat.show_tool_calls}`);
@@ -12879,6 +12971,7 @@ var SETTINGS_KEYS = {
   color: (s) => s.color,
   editor: (s) => s.editor,
   pager: (s) => s.pager,
+  local_agent: (s) => s.local_agent,
   "chat.show_tool_calls": (s) => s.chat?.show_tool_calls,
   "chat.markdown": (s) => s.chat?.markdown,
   "chat.history_file": (s) => s.chat?.history_file

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiaiai-pt/martha-cli",
-  "version": "0.24.0",
+  "version": "0.26.0",
   "description": "Terminal-first client for the Martha AI platform",
   "homepage": "https://docs.martha.nomadriver.co",
   "repository": {