@aiaiai-pt/martha-cli 0.22.0 → 0.23.0

package/dist/index.js

@@ -11077,7 +11077,7 @@ import { createInterface as createInterface2 } from "node:readline";
 init_errors();
 
 // src/version.ts
-var CLI_VERSION = "0.22.0";
+var CLI_VERSION = "0.23.0";
 
 // src/commands/sessions.ts
 function relativeTime(iso) {
@@ -11538,7 +11538,387 @@ function parseHostScreenshotRequests(data) {
   return out;
 }
 
+// src/lib/host-browser.ts
+var DOM_CAP = 16 * 1024;
+var CONSOLE_CAP = 200;
+function parseHostBrowserRequests(data) {
+  let tools;
+  try {
+    tools = JSON.parse(data);
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(tools))
+    return [];
+  const valid = [
+    "navigate",
+    "click",
+    "read_console",
+    "read_dom",
+    "screenshot"
+  ];
+  const out = [];
+  for (const t of tools) {
+    if (t.tool_name !== "host_browser" || t.status !== "awaiting_input")
+      continue;
+    if (!t.tool_call_id)
+      continue;
+    const action = t.args?.action;
+    if (!action || !valid.includes(action))
+      continue;
+    out.push({
+      toolCallId: t.tool_call_id,
+      action,
+      url: t.args?.url,
+      selector: t.args?.selector,
+      waitMs: typeof t.args?.wait_ms === "number" ? t.args.wait_ms : 500,
+      fullPage: t.args?.full_page !== false
+    });
+  }
+  return out;
+}
+async function applyBrowserAction(page, consoleBuffer, req) {
+  try {
+    switch (req.action) {
+      case "navigate": {
+        if (!req.url)
+          return { error: true, message: "navigate requires `url`" };
+        await page.goto(req.url, { waitUntil: "load", timeout: 30000 });
+        if (req.waitMs > 0)
+          await page.waitForTimeout(req.waitMs);
+        const title = await page.title();
+        const url = page.url();
+        return { text: `Navigated to ${url} (title: ${title || "<none>"}).` };
+      }
+      case "click": {
+        if (!req.selector)
+          return { error: true, message: "click requires `selector`" };
+        await page.click(req.selector, { timeout: 1e4 });
+        if (req.waitMs > 0)
+          await page.waitForTimeout(req.waitMs);
+        return { text: `Clicked ${req.selector}.` };
+      }
+      case "read_console": {
+        if (req.waitMs > 0)
+          await page.waitForTimeout(req.waitMs);
+        const entries = consoleBuffer.slice(-CONSOLE_CAP);
+        if (entries.length === 0)
+          return {
+            text: "No console messages, page errors, or failed requests captured yet."
+          };
+        const lines = entries.map((e) => {
+          if (e.kind === "console")
+            return `[console.${e.level}] ${e.text}`;
+          if (e.kind === "pageerror")
+            return `[pageerror] ${e.text}`;
+          return `[requestfailed] ${e.url} — ${e.text}`;
+        });
+        return {
+          text: `Captured ${entries.length} console/error/network entries:
+${lines.join(`
+`)}`
+        };
+      }
+      case "read_dom": {
+        if (req.waitMs > 0)
+          await page.waitForTimeout(req.waitMs);
+        let html;
+        if (req.selector) {
+          html = await page.evaluate((sel) => {
+            const el = document.querySelector(sel);
+            return el ? el.outerHTML : `__NOT_FOUND__:${sel}`;
+          }, req.selector);
+          if (typeof html === "string" && html.startsWith("__NOT_FOUND__:"))
+            return {
+              error: true,
+              message: `No element matched selector: ${req.selector}`
+            };
+        } else {
+          html = await page.content();
+        }
+        const truncated = html.length > DOM_CAP;
+        return {
+          text: (truncated ? html.slice(0, DOM_CAP) + `
+…[truncated]` : html) || ""
+        };
+      }
+      case "screenshot": {
+        if (req.waitMs > 0)
+          await page.waitForTimeout(req.waitMs);
+        const buf = await page.screenshot({
+          fullPage: req.fullPage,
+          type: "png"
+        });
+        return { png: buf };
+      }
+      default:
+        return { error: true, message: `unknown action: ${req.action}` };
+    }
+  } catch (e) {
+    return { error: true, message: `${req.action} failed: ${String(e)}` };
+  }
+}
+
+class BrowserSession {
+  browser = null;
+  page = null;
+  consoleBuffer = [];
+  async ensurePage() {
+    if (this.page)
+      return this.page;
+    const moduleName = "playwright";
+    let chromium;
+    try {
+      ({ chromium } = await import(moduleName));
+    } catch {
+      throw new Error("playwright is not installed on the runner. Install it to use host_browser: `npm i -D playwright && npx playwright install chromium`");
+    }
+    this.browser = await chromium.launch({ headless: true });
+    this.page = await this.browser.newPage();
+    this.page.on("console", (msg) => this.consoleBuffer.push({
+      kind: "console",
+      level: msg.type(),
+      text: msg.text()
+    }));
+    this.page.on("pageerror", (err) => this.consoleBuffer.push({
+      kind: "pageerror",
+      text: String(err?.message ?? err)
+    }));
+    this.page.on("requestfailed", (request) => this.consoleBuffer.push({
+      kind: "requestfailed",
+      url: request.url(),
+      text: request.failure()?.errorText ?? "failed"
+    }));
+    return this.page;
+  }
+  async run(req) {
+    let page;
+    try {
+      page = await this.ensurePage();
+    } catch (e) {
+      return { error: true, message: String(e) };
+    }
+    return applyBrowserAction(page, this.consoleBuffer, req);
+  }
+  async close() {
+    if (this.browser) {
+      try {
+        await this.browser.close();
+      } catch {}
+      this.browser = null;
+      this.page = null;
+    }
+  }
+}
+
+// src/lib/host-files.ts
+import { promises as fs6 } from "node:fs";
+import * as path5 from "node:path";
+var READ_CAP = 256 * 1024;
+function resolvePath(cwd, p) {
+  return path5.isAbsolute(p) ? p : path5.resolve(cwd, p);
+}
+async function applyFileAction(cwd, req) {
+  if (!req.path)
+    return { error: true, message: `${req.action} requires \`path\`` };
+  const abs = resolvePath(cwd, req.path);
+  try {
+    switch (req.action) {
+      case "host_read": {
+        const raw = await fs6.readFile(abs, "utf8");
+        let body = raw;
+        if (typeof req.offset === "number" || typeof req.limit === "number") {
+          const lines = raw.split(`
+`);
+          const start = Math.max(0, (req.offset ?? 1) - 1);
+          const end = typeof req.limit === "number" ? start + req.limit : lines.length;
+          body = lines.slice(start, end).join(`
+`);
+        }
+        const truncated = body.length > READ_CAP;
+        if (truncated)
+          body = body.slice(0, READ_CAP) + `
+…[truncated]`;
+        return { text: body === "" ? "(empty file)" : body };
+      }
+      case "host_write": {
+        if (typeof req.content !== "string")
+          return { error: true, message: "host_write requires `content`" };
+        await fs6.mkdir(path5.dirname(abs), { recursive: true });
+        await fs6.writeFile(abs, req.content, "utf8");
+        return {
+          text: `Wrote ${Buffer.byteLength(req.content, "utf8")} bytes to ${req.path}.`
+        };
+      }
+      case "host_edit": {
+        if (typeof req.oldString !== "string" || typeof req.newString !== "string")
+          return {
+            error: true,
+            message: "host_edit requires `old_string` and `new_string`"
+          };
+        if (req.oldString === req.newString)
+          return {
+            error: true,
+            message: "old_string and new_string are identical"
+          };
+        const raw = await fs6.readFile(abs, "utf8");
+        const count = req.oldString ? raw.split(req.oldString).length - 1 : 0;
+        if (count === 0)
+          return { error: true, message: "old_string not found in file" };
+        if (count > 1 && !req.replaceAll)
+          return {
+            error: true,
+            message: `old_string is not unique (${count} matches); pass replace_all=true to replace all`
+          };
+        const next = req.replaceAll ? raw.split(req.oldString).join(req.newString) : raw.replace(req.oldString, req.newString);
+        await fs6.writeFile(abs, next, "utf8");
+        return {
+          text: `Edited ${req.path} (${req.replaceAll ? count : 1} replacement${(req.replaceAll ? count : 1) === 1 ? "" : "s"}).`
+        };
+      }
+      default:
+        return { error: true, message: `unknown file action: ${req.action}` };
+    }
+  } catch (e) {
+    return { error: true, message: `${req.action} failed: ${String(e)}` };
+  }
+}
+var VALID = ["host_read", "host_write", "host_edit"];
+function parseHostFileRequests(data) {
+  let tools;
+  try {
+    tools = JSON.parse(data);
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(tools))
+    return [];
+  const out = [];
+  for (const t of tools) {
+    if (t.status !== "awaiting_input" || !t.tool_call_id)
+      continue;
+    if (!VALID.includes(t.tool_name))
+      continue;
+    const a = t.args ?? {};
+    out.push({
+      toolCallId: t.tool_call_id,
+      action: t.tool_name,
+      path: a.path,
+      offset: typeof a.offset === "number" ? a.offset : undefined,
+      limit: typeof a.limit === "number" ? a.limit : undefined,
+      content: typeof a.content === "string" ? a.content : undefined,
+      oldString: typeof a.old_string === "string" ? a.old_string : undefined,
+      newString: typeof a.new_string === "string" ? a.new_string : undefined,
+      replaceAll: a.replace_all === true
+    });
+  }
+  return out;
+}
+
+// src/lib/local-agent.ts
+import { spawn as spawn2 } from "node:child_process";
+var DEFAULT_LOCAL_AGENT_CMD = "codex exec";
+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");
+    };
+    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 });
+    });
+  });
+}
+function parseLocalAgentRequests(data) {
+  let tools;
+  try {
+    tools = JSON.parse(data);
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(tools))
+    return [];
+  const out = [];
+  for (const t of tools) {
+    if (t.tool_name !== "local_agent" || t.status !== "awaiting_input")
+      continue;
+    if (!t.tool_call_id || !t.args?.task)
+      continue;
+    out.push({
+      toolCallId: t.tool_call_id,
+      task: t.args.task,
+      cwd: typeof t.args.cwd === "string" ? t.args.cwd : undefined
+    });
+  }
+  return out;
+}
+
 // src/commands/chat.ts
+async function uploadImageArtifact(ctx, sessionId, png) {
+  try {
+    const mint = await ctx.api.post(`/api/chat/${encodeURIComponent(sessionId)}/local-artifact-upload`, {
+      content_type: "image/png"
+    });
+    const put = await fetch(mint.upload_url, {
+      method: "PUT",
+      headers: { "Content-Type": "image/png" },
+      body: new Uint8Array(png)
+    });
+    if (!put.ok)
+      return { error: `image upload failed: HTTP ${put.status}` };
+    return { storage_key: mint.storage_key };
+  } catch (e) {
+    return { error: `image upload failed: ${String(e)}` };
+  }
+}
 async function resolveHostExec(sessionId, toolCallId, command, state) {
   const decision = decideFromJournal(await state.journal.lookup(sessionId, toolCallId));
   if (decision.kind === "replay")
@@ -11596,27 +11976,89 @@ async function resolveHostScreenshot(ctx, sessionId, req, state) {
   } catch (e) {
     return { error: true, message: `screenshot failed: ${String(e)}` };
   }
+  const uploaded = await uploadImageArtifact(ctx, sessionId, png);
+  if ("error" in uploaded)
+    return { error: true, message: uploaded.error };
+  return {
+    text: `Screenshot of ${req.url} captured (${png.length} bytes).`,
+    _images: [{ storage_key: uploaded.storage_key }]
+  };
+}
+async function resolveHostBrowser(ctx, sessionId, req, state) {
+  if (!state.autoYes) {
+    process.stderr.write(source_default.yellow(`
+[host_browser] refused (re-run with --yes to allow): ${req.action}${req.url ? ` ${req.url}` : ""}
+`));
+    return {
+      declined: true,
+      message: "Host browser declined; re-run with --yes to allow."
+    };
+  }
+  process.stderr.write(source_default.dim(`
+[host_browser] ${req.action}${req.url ? ` ${req.url}` : ""}${req.selector ? ` (${req.selector})` : ""}
+`));
+  if (!state.browser)
+    state.browser = new BrowserSession;
+  const result = await state.browser.run(req);
+  if ("error" in result)
+    return { error: true, message: result.message };
+  if ("png" in result) {
+    const uploaded = await uploadImageArtifact(ctx, sessionId, result.png);
+    if ("error" in uploaded)
+      return { error: true, message: uploaded.error };
+    return {
+      text: `Screenshot of the current page captured (${result.png.length} bytes).`,
+      _images: [{ storage_key: uploaded.storage_key }]
+    };
+  }
+  return result;
+}
+async function resolveHostFile(req, state) {
+  const mutating = req.action === "host_write" || req.action === "host_edit";
+  if (mutating && !state.autoYes) {
+    process.stderr.write(source_default.yellow(`
+[${req.action}] refused (re-run with --yes to allow): ${req.path}
+`));
+    return {
+      declined: true,
+      message: `${req.action} declined; re-run with --yes to allow.`
+    };
+  }
+  process.stderr.write(source_default.dim(`
+[${req.action}] ${req.path ?? "<no path>"}
+`));
+  const result = await applyFileAction(state.cwd, req);
+  if ("error" in result)
+    return { error: true, message: result.message };
+  return result;
+}
+async function resolveLocalAgent(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)}
+`));
+    return {
+      declined: true,
+      message: "Local agent delegation declined; re-run with --yes to allow."
+    };
+  }
+  const agentCmd = process.env.MARTHA_LOCAL_AGENT_CMD || DEFAULT_LOCAL_AGENT_CMD;
+  const cwd = req.cwd ? `${state.cwd}/${req.cwd}` : state.cwd;
+  process.stderr.write(source_default.dim(`
+[local_agent] (${agentCmd}) ${req.task.slice(0, 100)}
+`));
   try {
-    const mint = await ctx.api.post(`/api/chat/${encodeURIComponent(sessionId)}/local-artifact-upload`, {
-      content_type: "image/png"
-    });
-    const put = await fetch(mint.upload_url, {
-      method: "PUT",
-      headers: { "Content-Type": "image/png" },
-      body: new Uint8Array(png)
-    });
-    if (!put.ok) {
-      return {
-        error: true,
-        message: `image upload failed: HTTP ${put.status}`
-      };
-    }
+    const result = await runLocalAgent(req.task, { cwd, agentCmd });
     return {
-      text: `Screenshot of ${req.url} captured (${png.length} bytes).`,
-      _images: [{ storage_key: mint.storage_key }]
+      text: result.text || "(local agent produced no output)",
+      exit_code: result.exit_code,
+      ...result.timed_out ? { timed_out: true } : {}
     };
   } catch (e) {
-    return { error: true, message: `image upload failed: ${String(e)}` };
+    return {
+      error: true,
+      message: `local agent failed to start (${agentCmd}): ${String(e)}. ` + `Set MARTHA_LOCAL_AGENT_CMD to an installed agent command.`
+    };
   }
 }
 async function _postToolResult(ctx, sessionId, toolCallId, result, label) {
@@ -11644,6 +12086,30 @@ async function handleHostExecFrame(ctx, sessionId, data, state) {
     const result = await resolveHostScreenshot(ctx, sessionId, req, state);
     await _postToolResult(ctx, sessionId, id, result, "host_screenshot");
   }
+  for (const req of parseHostBrowserRequests(data)) {
+    const id = req.toolCallId;
+    if (state.handled.has(id))
+      continue;
+    state.handled.add(id);
+    const result = await resolveHostBrowser(ctx, sessionId, req, state);
+    await _postToolResult(ctx, sessionId, id, result, "host_browser");
+  }
+  for (const req of parseHostFileRequests(data)) {
+    const id = req.toolCallId;
+    if (state.handled.has(id))
+      continue;
+    state.handled.add(id);
+    const result = await resolveHostFile(req, state);
+    await _postToolResult(ctx, sessionId, id, result, req.action);
+  }
+  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");
+  }
 }
 function parseSlashCommand(input) {
   const trimmed = input.trim();
@@ -11768,6 +12234,9 @@ async function sendMessage(ctx, sessionId, message, opts = {}) {
         return { response: fullResponse, aborted: true };
       }
       throw err;
+    } finally {
+      if (localExecState?.browser)
+        await localExecState.browser.close();
     }
   } else {
     const text = await res.text();
@@ -11818,11 +12287,11 @@ function formatToolStatus(data) {
   }
 }
 function promptPick(rl, count) {
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     rl.question(source_default.dim(`Pick 1-${count} (or Enter to cancel): `), (ans) => {
       const trimmed = ans.trim();
       if (!trimmed) {
-        resolve(-1);
+        resolve2(-1);
         return;
       }
       const n = parseInt(trimmed, 10);
@@ -11830,10 +12299,10 @@ function promptPick(rl, count) {
         process.stderr.write(source_default.yellow(`Invalid choice.
 
 `));
-        resolve(-1);
+        resolve2(-1);
         return;
       }
-      resolve(n - 1);
+      resolve2(n - 1);
     });
   });
 }
@@ -12276,9 +12745,9 @@ init_errors();
 import { createInterface as createInterface3 } from "node:readline";
 function prompt(rl, question, defaultValue) {
   const suffix = defaultValue ? ` [${defaultValue}]` : "";
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     rl.question(`${question}${suffix}: `, (answer) => {
-      resolve(answer.trim() || defaultValue || "");
+      resolve2(answer.trim() || defaultValue || "");
     });
   });
 }
@@ -12574,14 +13043,14 @@ function registerConfigCommand(program2) {
       if (!process.stdin.isTTY) {
         throw new CLIError("Cannot confirm in non-interactive mode.", 4 /* Validation */, "Use --yes to skip confirmation.");
       }
-      const ok = await new Promise((resolve) => {
+      const ok = await new Promise((resolve2) => {
         const rl = createInterface3({
           input: process.stdin,
           output: process.stderr
         });
         rl.question(`Delete profile '${name}'? (y/N) `, (answer) => {
           rl.close();
-          resolve(answer.trim().toLowerCase() === "y");
+          resolve2(answer.trim().toLowerCase() === "y");
         });
       });
       if (!ok) {
@@ -12604,8 +13073,8 @@ function registerConfigCommand(program2) {
 }
 
 // src/commands/definitions-apply.ts
-import fs6 from "node:fs";
-import path5 from "node:path";
+import fs7 from "node:fs";
+import path6 from "node:path";
 init_dist();
 init_errors();
 var VALID_KINDS = new Set([
@@ -12647,20 +13116,20 @@ var SERVER_GENERATED_FIELDS = new Set([
 ]);
 var AGENT_MANAGED_FIELDS = new Set(["functions", "workflows"]);
 function loadDefinitions(inputPath) {
-  const resolved = path5.resolve(inputPath);
-  if (!fs6.existsSync(resolved)) {
+  const resolved = path6.resolve(inputPath);
+  if (!fs7.existsSync(resolved)) {
     throw new CLIError(`Path not found: ${inputPath}`, 1 /* Error */);
   }
-  const stat = fs6.statSync(resolved);
+  const stat = fs7.statSync(resolved);
   if (stat.isDirectory()) {
     return loadDirectory(resolved);
   }
   return loadFile(resolved);
 }
 function loadDirectory(dirPath) {
-  const entries = fs6.readdirSync(dirPath).sort();
+  const entries = fs7.readdirSync(dirPath).sort();
   const validExts = new Set([".yaml", ".yml", ".json"]);
-  const files = entries.filter((e) => validExts.has(path5.extname(e).toLowerCase())).map((e) => path5.join(dirPath, e));
+  const files = entries.filter((e) => validExts.has(path6.extname(e).toLowerCase())).map((e) => path6.join(dirPath, e));
   if (files.length === 0) {
     throw new CLIError(`No YAML or JSON files found in ${dirPath}`, 4 /* Validation */);
   }
@@ -12671,8 +13140,8 @@ function loadDirectory(dirPath) {
   return results;
 }
 function loadFile(filePath) {
-  const content = fs6.readFileSync(filePath, "utf-8");
-  const ext = path5.extname(filePath).toLowerCase();
+  const content = fs7.readFileSync(filePath, "utf-8");
+  const ext = path6.extname(filePath).toLowerCase();
   if (ext === ".json") {
     const parsed = parseJsonFile(content, filePath);
     return [toLocalDefinition(parsed, filePath)];
@@ -13094,7 +13563,7 @@ Examples:
 }
 
 // src/commands/definitions-export.ts
-import fs7 from "node:fs";
+import fs8 from "node:fs";
 init_errors();
 async function exportDefinitions(ctx, opts, isJsonMode) {
   const params = {};
@@ -13110,7 +13579,7 @@ async function exportDefinitions(ctx, opts, isJsonMode) {
   const text = await res.text();
   if (opts.output) {
     try {
-      fs7.writeFileSync(opts.output, text);
+      fs8.writeFileSync(opts.output, text);
     } catch (err) {
       throw new CLIError(`Failed to write ${opts.output}: ${err instanceof Error ? err.message : String(err)}`, 1 /* Error */);
     }
@@ -13419,7 +13888,7 @@ function colorStatus(status) {
   return fn(status);
 }
 function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 async function pollUntilDone(ctx, executionId, intervalMs = 2000, timeoutMs = 300000) {
   const deadline = Date.now() + timeoutMs;
@@ -13830,8 +14299,8 @@ function registerProjectionCommands(parentCmd, getCtx, isJson) {
       } catch {}
     }
     if (opts.output) {
-      const fs8 = await import("node:fs/promises");
-      await fs8.writeFile(opts.output, toWrite, "utf-8");
+      const fs9 = await import("node:fs/promises");
+      await fs9.writeFile(opts.output, toWrite, "utf-8");
       if (!isJson()) {
         console.error(source_default.dim(`Wrote ${format} projection of '${name}' to ${opts.output}`));
       }
@@ -14238,8 +14707,8 @@ Usage:
     });
     parentCmd.command("self-grant <agent>").description("View or configure an agent's self-provisioning policy (request-then-approve). " + "With no flags, prints the current policy.").option("--enable", "Allow the agent to REQUEST capability grants").option("--disable", "Disallow self-provisioning").option("--scope <scope>", "Scope ceiling: none | read_only | read_write").option("--allow <ref...>", "Add allow-list refs (function:NAME or mcp:integration/name)").option("--remove <ref...>", "Remove allow-list refs").option("--collection-root <id...>", "Add collection-subtree roots the agent may self-grant collection-scoped functions into").option("--remove-collection-root <id...>", "Remove collection roots").option("--max-pending <n>", "Max concurrently-pending requests").action(async (agent, opts) => {
       const ctx = getCtx();
-      const path6 = `${API_PATH}/${encodeURIComponent(agent)}`;
-      const current = await ctx.api.get(path6);
+      const path7 = `${API_PATH}/${encodeURIComponent(agent)}`;
+      const current = await ctx.api.get(path7);
       const mutating = opts.enable || opts.disable || opts.scope !== undefined || (opts.allow?.length ?? 0) > 0 || (opts.remove?.length ?? 0) > 0 || (opts.collectionRoot?.length ?? 0) > 0 || (opts.removeCollectionRoot?.length ?? 0) > 0 || opts.maxPending !== undefined;
       if (!mutating) {
         if (isJson()) {
@@ -14291,7 +14760,7 @@ Usage:
           roots.delete(c);
         body.self_grant_collection_roots = [...roots];
       }
-      const updated = await ctx.api.put(path6, body);
+      const updated = await ctx.api.put(path7, body);
       if (isJson()) {
         console.log(JSON.stringify(policyView(updated), null, 2));
         return;
@@ -14416,7 +14885,7 @@ var triggersConfig = {
 };
 
 // src/commands/documents.ts
-import fs8 from "node:fs";
+import fs9 from "node:fs";
 init_errors();
 var TERMINAL_STATUSES2 = new Set(["ready", "error"]);
 var SPINNER_FRAMES2 = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
@@ -14427,7 +14896,7 @@ function nextSpinner() {
   return frame;
 }
 function sleep2(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 function formatBytes(bytes) {
   if (bytes < 1024)
@@ -14718,7 +15187,7 @@ ${items.length} collections`));
   });
   cmd.command("upload <collection-id> <file>").description("Upload a document to a collection").option("--wait", "Wait for ingestion to complete").option("--follow", "Follow ingestion progress in real time").action(async (collectionId, filePath, opts) => {
     const ctx = getCtx();
-    if (!fs8.existsSync(filePath)) {
+    if (!fs9.existsSync(filePath)) {
       throw new CLIError(`File not found: ${filePath}`, 4 /* Validation */);
     }
     const result = await ctx.api.upload(`/api/admin/collections/${encodeURIComponent(collectionId)}/documents`, filePath);
@@ -15350,18 +15819,18 @@ function registerApprovalCommands(program2) {
 import { readFileSync } from "node:fs";
 init_errors();
 var truncate2 = (s, n) => s.length > n ? s.slice(0, n - 1) + "…" : s;
-var sleep3 = (ms, signal) => new Promise((resolve) => {
+var sleep3 = (ms, signal) => new Promise((resolve2) => {
   if (signal?.aborted) {
-    resolve();
+    resolve2();
     return;
   }
   const t = setTimeout(() => {
     signal?.removeEventListener("abort", onAbort);
-    resolve();
+    resolve2();
   }, ms);
   const onAbort = () => {
     clearTimeout(t);
-    resolve();
+    resolve2();
   };
   signal?.addEventListener("abort", onAbort, { once: true });
 });
@@ -16295,8 +16764,8 @@ ${data.length} spec(s)`));
 Resources:
 `));
       for (const r of resources) {
-        const path6 = r.path || `/${r.name}`;
-        console.log(`  ${source_default.cyan(r.label || r.name)}` + source_default.dim(` → ${path6}`));
+        const path7 = r.path || `/${r.name}`;
+        console.log(`  ${source_default.cyan(r.label || r.name)}` + source_default.dim(` → ${path7}`));
       }
     }
     try {
@@ -16316,14 +16785,14 @@ Functions:
     console.log(source_default.dim(`
 Proxy: martha integrations proxy ${name} GET /<path>`));
   });
-  cmd.command("proxy <name> <method> <path>").description("Send a request through the plugin proxy").option("--data <json>", "JSON request body").option("--query <params>", "Query params as key=val&key=val").action(async (name, method, path6, opts) => {
+  cmd.command("proxy <name> <method> <path>").description("Send a request through the plugin proxy").option("--data <json>", "JSON request body").option("--query <params>", "Query params as key=val&key=val").action(async (name, method, path7, opts) => {
     const ctx = getCtx();
     const upperMethod = method.toUpperCase();
     const allowed = new Set(["GET", "POST", "PUT", "PATCH", "DELETE"]);
     if (!allowed.has(upperMethod)) {
       throw new CLIError(`Invalid method: ${method}`, 4 /* Validation */, "Allowed: GET, POST, PUT, PATCH, DELETE");
     }
-    const cleanPath = path6.startsWith("/") ? path6.slice(1) : path6;
+    const cleanPath = path7.startsWith("/") ? path7.slice(1) : path7;
     const proxyUrl = `/api/admin/plugins/${encodeURIComponent(name)}/${cleanPath}`;
     const params = {};
     if (opts.query) {
@@ -16533,8 +17002,8 @@ async function resolveCredentialValue(value) {
   if (value === "-")
     return readStdin();
   if (value.startsWith("@")) {
-    const fs9 = await import("node:fs/promises");
-    return (await fs9.readFile(value.slice(1), "utf-8")).trim();
+    const fs10 = await import("node:fs/promises");
+    return (await fs10.readFile(value.slice(1), "utf-8")).trim();
   }
   return value;
 }
@@ -16649,8 +17118,8 @@ Notification connections`));
     if (credentialValue === "-") {
       credentialValue = await readStdin2();
     } else if (credentialValue?.startsWith("@")) {
-      const fs9 = await import("node:fs/promises");
-      credentialValue = await fs9.readFile(credentialValue.slice(1), "utf-8");
+      const fs10 = await import("node:fs/promises");
+      credentialValue = await fs10.readFile(credentialValue.slice(1), "utf-8");
     }
     if (!credentialValue) {
       throw new Error("--credential-value is required (use '-' for stdin or '@path' for file).");
@@ -16700,11 +17169,11 @@ async function readStdin2() {
 
 // src/commands/messaging.ts
 init_errors();
-async function messagingFetch(baseUrl, path6, opts) {
-  if (/^(https?:)?\/\//i.test(path6)) {
+async function messagingFetch(baseUrl, path7, opts) {
+  if (/^(https?:)?\/\//i.test(path7)) {
     throw new CLIError("Absolute URL paths are not allowed", 1 /* Error */);
   }
-  const url = new URL(path6, baseUrl);
+  const url = new URL(path7, baseUrl);
   const headers = {
     "Content-Type": "application/json"
   };
@@ -17984,7 +18453,7 @@ ${models.length} models`));
 }
 
 // src/commands/wiki.ts
-import fs9 from "node:fs";
+import fs10 from "node:fs";
 init_errors();
 function registerWikiCommands(program2) {
   const cmd = program2.command("wiki").description("Manage tenant wiki pages, settings, schema, recompile (#245 D5.4)");
@@ -18031,14 +18500,14 @@ function registerWikiCommands(program2) {
     console.log(source_default.dim(`
 ${pages.length} pages`));
   });
-  cmd.command("get <path>").description("Fetch the raw markdown body of a wiki page").option("--out <file>", "Write body to file instead of stdout").action(async (path6, opts) => {
+  cmd.command("get <path>").description("Fetch the raw markdown body of a wiki page").option("--out <file>", "Write body to file instead of stdout").action(async (path7, opts) => {
     const ctx = getCtx();
-    const safe = path6.split("/").map(encodeURIComponent).join("/");
+    const safe = path7.split("/").map(encodeURIComponent).join("/");
     const resp = await ctx.api.getRaw(`/api/wiki/pages/${safe}`, {
       headers: { Accept: "text/markdown,*/*" }
     });
     if (resp.status === 404) {
-      throw new CLIError(`page not found: ${path6}`, 3 /* NotFound */);
+      throw new CLIError(`page not found: ${path7}`, 3 /* NotFound */);
     }
     if (!resp.ok) {
       const detail = await resp.text();
@@ -18046,16 +18515,16 @@ ${pages.length} pages`));
     }
     const body = await resp.text();
     if (opts.out) {
-      fs9.writeFileSync(opts.out, body);
+      fs10.writeFileSync(opts.out, body);
       if (!isJson()) {
         console.log(source_default.dim(`wrote ${body.length} bytes to ${opts.out}`));
       } else {
-        console.log(JSON.stringify({ path: path6, bytes: body.length, file: opts.out }));
+        console.log(JSON.stringify({ path: path7, bytes: body.length, file: opts.out }));
       }
       return;
     }
     if (isJson()) {
-      console.log(JSON.stringify({ path: path6, body, etag: resp.headers.get("ETag") }));
+      console.log(JSON.stringify({ path: path7, body, etag: resp.headers.get("ETag") }));
     } else {
       process.stdout.write(body);
     }
@@ -18150,10 +18619,10 @@ ${pages.length} pages`));
     }
     if (opts.compilePromptOverrideFile) {
       const file = String(opts.compilePromptOverrideFile);
-      if (!fs9.existsSync(file)) {
+      if (!fs10.existsSync(file)) {
         throw new CLIError(`override file not found: ${file}`, 3 /* NotFound */);
       }
-      const content = fs9.readFileSync(file, "utf8");
+      const content = fs10.readFileSync(file, "utf8");
       const bytes = Buffer.byteLength(content, "utf8");
       if (bytes > 16 * 1024) {
         throw new CLIError(`compile prompt override exceeds 16 KB (${bytes} bytes)`, 4 /* Validation */);
@@ -18177,7 +18646,7 @@ ${pages.length} pages`));
     const ctx = getCtx();
     const resp = await ctx.api.get("/api/wiki/schema");
     if (opts.out) {
-      fs9.writeFileSync(opts.out, resp.body);
+      fs10.writeFileSync(opts.out, resp.body);
       if (!isJson()) {
         console.log(source_default.dim(`wrote ${resp.body.length} bytes to ${opts.out}`));
       } else {
@@ -18193,10 +18662,10 @@ ${pages.length} pages`));
   });
   schemaCmd.command("set").description("Replace the tenant wiki schema with the contents of <file>").requiredOption("--file <file>", "Path to schema markdown file").action(async (opts) => {
     const ctx = getCtx();
-    if (!fs9.existsSync(opts.file)) {
+    if (!fs10.existsSync(opts.file)) {
       throw new CLIError(`schema file not found: ${opts.file}`, 3 /* NotFound */);
     }
-    const body = fs9.readFileSync(opts.file, "utf8");
+    const body = fs10.readFileSync(opts.file, "utf8");
     const bytes = Buffer.byteLength(body, "utf8");
     if (bytes > 64 * 1024) {
       throw new CLIError(`schema body exceeds 64 KB (${bytes} bytes)`, 4 /* Validation */);
@@ -18532,7 +19001,7 @@ async function pollConnectionActive(ctx, connectionId) {
     });
     if (conn?.status === "active")
       return;
-    await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    await new Promise((resolve2) => setTimeout(resolve2, intervalMs));
   }
   throw new CLIError(`Timed out waiting for OAuth authorization (${Math.round(timeoutMs / 1000)}s).`, 1 /* Error */, "The browser consent may not have completed. Re-run to try again, or check " + "the connection status in the admin UI.");
 }
@@ -18594,7 +19063,7 @@ async function pollExecution(ctx, executionId, timeoutMs) {
     if (["completed", "failed", "cancelled", "timeout"].includes(last.status)) {
       return last;
     }
-    await new Promise((resolve) => setTimeout(resolve, 1000));
+    await new Promise((resolve2) => setTimeout(resolve2, 1000));
   }
   throw new CLIError(`Timed out waiting for MCP workflow execution ${executionId}`, 1 /* Error */, last ? `Last status: ${last.status}` : undefined);
 }
@@ -18722,8 +19191,8 @@ async function resolveCredentialFlag(value) {
     return Buffer.concat(chunks).toString("utf-8").trim();
   }
   if (value.startsWith("@")) {
-    const fs10 = await import("node:fs/promises");
-    return (await fs10.readFile(value.slice(1), "utf-8")).trim();
+    const fs11 = await import("node:fs/promises");
+    return (await fs11.readFile(value.slice(1), "utf-8")).trim();
   }
   return value;
 }
@@ -19909,19 +20378,19 @@ function registerDoctorCommand(program2) {
 
 // src/commands/skill.ts
 init_errors();
-import fs10 from "node:fs";
-import path6 from "node:path";
+import fs11 from "node:fs";
+import path7 from "node:path";
 import { fileURLToPath } from "node:url";
 function locateSkill() {
-  const here = path6.dirname(fileURLToPath(import.meta.url));
+  const here = path7.dirname(fileURLToPath(import.meta.url));
   const candidates = [
-    path6.join(here, "skills", "martha-cli", "SKILL.md"),
-    path6.join(here, "..", "skills", "martha-cli", "SKILL.md"),
-    path6.join(here, "..", "..", "..", "skills", "martha-cli", "SKILL.md"),
-    path6.join(here, "..", "..", "skills", "martha-cli", "SKILL.md")
+    path7.join(here, "skills", "martha-cli", "SKILL.md"),
+    path7.join(here, "..", "skills", "martha-cli", "SKILL.md"),
+    path7.join(here, "..", "..", "..", "skills", "martha-cli", "SKILL.md"),
+    path7.join(here, "..", "..", "skills", "martha-cli", "SKILL.md")
   ];
   for (const p of candidates) {
-    if (fs10.existsSync(p))
+    if (fs11.existsSync(p))
       return p;
   }
   return null;
@@ -19931,7 +20400,7 @@ async function skillCommand() {
   if (!skillPath) {
     throw new CLIError("SKILL.md not found in the installed package. Reinstall via `npm i -g @aiaiai-pt/martha-cli` or `npx -y @aiaiai-pt/martha-cli@latest skill`.", 1 /* Error */);
   }
-  const body = fs10.readFileSync(skillPath, "utf-8");
+  const body = fs11.readFileSync(skillPath, "utf-8");
   process.stdout.write(body);
 }
 function registerSkillCommand(program2) {

package/package.json

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