@aiaiai-pt/martha-cli 0.51.2 → 0.51.7

package/CHANGELOG.md

@@ -4,6 +4,43 @@ All notable changes to `@aiaiai-pt/martha-cli`. Format: [Keep a Changelog](https
 
 ## [Unreleased]
 
+## [0.51.5] — 2026-07-20
+
+### Fixed — host tools ran in a doubled working directory
+
+- The runner concatenated its scoped `--cwd` with a per-call `cwd`
+  (`` `${state.cwd}/${req.cwd}` ``), so an ABSOLUTE request path — what an agent
+  sends naturally when its prompt names the repo — became
+  `/Users/me/repo//Users/me/repo` and every `host_exec` failed with ENOENT /
+  MODULE_NOT_FOUND. Now resolved properly (absolute used as-is, relative joined)
+  and still confined inside the scoped workspace.
+
+## [0.51.4] — 2026-07-20
+
+### Added — `MARTHA_BROWSER_HEADFUL` for WAF-protected pages
+
+- `host_browser` launched Chromium headless unconditionally, so any site that
+  fingerprints headless Chrome (Cloudflare & co.) served it 403 — exactly the
+  pages the tool exists to reach. Set `MARTHA_BROWSER_HEADFUL=1` on the runner
+  to launch headful with a real Chrome UA and a 1440x900 viewport. Default is
+  unchanged (headless), so CI and display-less servers are unaffected.
+- Verified against `piscapisca.pt/carros`: 403 headless, 200 headful with live
+  listing data, same machine and same tool.
+
+## [0.51.3] — 2026-07-20
+
+### Fixed — `host_browser` could never find playwright
+
+- `host_browser` resolved `playwright` with a bare specifier, i.e. relative to
+  `martha-cli/dist/` — never the runner's `--cwd`. Its own error message told
+  users to `npm i -D playwright` (naturally read as "in my project"), which was
+  exactly where the CLI would not look, so the tool reported "not installed"
+  forever on fully-provisioned machines. Now resolved from `process.cwd()`
+  first, falling back to the CLI-local install; the failure message names both
+  locations searched.
+- Accept playwright's CJS export shape (`.default`) when loaded by file URL —
+  otherwise resolution succeeded but `chromium` was `undefined`.
+
 ## [0.51.2] — 2026-07-19
 
 ### Fixed — selected-client local execution (#968)

package/dist/index.js

@@ -11042,6 +11042,7 @@ ${items.length} ${config.typeNamePlural}`));
     if (config.normalizeBody)
       body = config.normalizeBody(body);
     const result = await ctx.api.put(`${config.apiPath}/${encodeURIComponent(name)}`, body);
+    config.verifyUpdateResult?.(body, result);
     if (isJson()) {
       console.log(JSON.stringify(result, null, 2));
       return;
@@ -11119,7 +11120,7 @@ init_config();
 init_errors();
 
 // src/version.ts
-var CLI_VERSION = "0.51.2";
+var CLI_VERSION = "0.51.7";
 
 // src/commands/sessions.ts
 function relativeTime(iso) {
@@ -12262,6 +12263,7 @@ function parseLocalAgentRequests(data) {
 }
 
 // src/lib/local-tool-runner.ts
+import path7 from "node:path";
 import { createHash as createHash2 } from "node:crypto";
 init_errors();
 
@@ -12686,23 +12688,54 @@ ${lines.join(`
     return { error: true, message: `${req.action} failed: ${String(e)}` };
   }
 }
+var REAL_UA = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 " + "(KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36";
 
 class BrowserSession {
   browser = null;
   page = null;
   consoleBuffer = [];
+  headful() {
+    const v = (process.env.MARTHA_BROWSER_HEADFUL || "").toLowerCase();
+    return v === "1" || v === "true" || v === "yes";
+  }
   async ensurePage() {
     if (this.page)
       return this.page;
     const moduleName = "playwright";
     let chromium;
+    const candidates = [];
     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`");
+      const { createRequire: createRequire2 } = await import("node:module");
+      const { pathToFileURL } = await import("node:url");
+      const path5 = await import("node:path");
+      const req = createRequire2(pathToFileURL(path5.join(process.cwd(), "noop.js")));
+      candidates.push(pathToFileURL(req.resolve(moduleName)).href);
+    } catch {}
+    candidates.push(moduleName);
+    let lastErr;
+    let loaded = null;
+    for (const spec of candidates) {
+      try {
+        loaded = await import(spec);
+        break;
+      } catch (e) {
+        lastErr = e;
+      }
+    }
+    if (!loaded) {
+      throw new Error(`playwright is not installed where the runner can load it (looked in ${process.cwd()} and alongside the martha CLI). Install it in the runner's --cwd: \`npm i -D playwright && npx playwright install chromium\`` + (lastErr instanceof Error ? ` — ${lastErr.message}` : ""));
+    }
+    const pw = loaded.chromium ? loaded : loaded.default;
+    if (!pw?.chromium) {
+      throw new Error(`playwright loaded but exposes no \`chromium\` export (from ${process.cwd()}); check the installed playwright version.`);
     }
-    this.browser = await chromium.launch({ headless: true });
-    this.page = await this.browser.newPage();
+    chromium = pw.chromium;
+    const headful = this.headful();
+    this.browser = await chromium.launch({ headless: !headful });
+    this.page = headful ? await (await this.browser.newContext({
+      userAgent: REAL_UA,
+      viewport: { width: 1440, height: 900 }
+    })).newPage() : await this.browser.newPage();
     this.page.on("console", (msg) => this.consoleBuffer.push({
       kind: "console",
       level: msg.type(),
@@ -13078,6 +13111,15 @@ function parseJobToolRequests(data, toolName) {
 }
 
 // src/lib/local-tool-runner.ts
+function resolveRequestCwd(stateCwd, reqCwd) {
+  if (!reqCwd)
+    return stateCwd;
+  const base = path7.resolve(stateCwd);
+  const target = path7.isAbsolute(reqCwd) ? path7.resolve(reqCwd) : path7.resolve(base, reqCwd);
+  const rel = path7.relative(base, target);
+  const escapes = rel.startsWith("..") || path7.isAbsolute(rel);
+  return escapes ? base : target;
+}
 function selectedClientOptions(clientId) {
   return clientId ? { params: { selected_client: clientId } } : undefined;
 }
@@ -13118,7 +13160,7 @@ async function resolveHostExec(sessionId, toolCallId, req, state) {
       message: "Host execution declined; re-run with --yes to allow."
     };
   }
-  const cwd = req.cwd ? `${state.cwd}/${req.cwd}` : state.cwd;
+  const cwd = resolveRequestCwd(state.cwd, req.cwd);
   if (req.background) {
     const jobId = mintJobId();
     process.stderr.write(source_default.dim(`
@@ -13281,7 +13323,7 @@ async function resolveLocalAgent(sessionId, toolCallId, req, state) {
       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 cwd = resolveRequestCwd(state.cwd, req.cwd);
   const { bin, args, stdin } = buildSpawn(invocation, req.task);
   if (req.background) {
     const jobId = mintJobId();
@@ -14512,9 +14554,195 @@ function registerConfigCommand(program2) {
 
 // src/commands/definitions-apply.ts
 import fs8 from "node:fs";
-import path7 from "node:path";
+import path8 from "node:path";
 init_dist();
 init_errors();
+
+// src/commands/definition-payload.ts
+init_errors();
+var MUTABLE_FIELDS = {
+  Function: new Set([
+    "tool_name",
+    "description",
+    "endpoint",
+    "http_method",
+    "handler",
+    "category",
+    "parameters",
+    "request_body",
+    "auth",
+    "extra_headers",
+    "tags",
+    "is_active",
+    "collection_id_param",
+    "risk_tags",
+    "risk_level"
+  ]),
+  Workflow: new Set([
+    "description",
+    "format_version",
+    "nodes",
+    "edges",
+    "variables",
+    "input_schema",
+    "on_error",
+    "timeout_seconds",
+    "ui_metadata",
+    "is_active"
+  ])
+};
+function isPlainObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function valuesEqual(left, right) {
+  if (left === right)
+    return true;
+  if (left === null || right === null)
+    return false;
+  if (left === undefined || right === undefined)
+    return false;
+  if (typeof left !== typeof right)
+    return false;
+  if (Array.isArray(left) || Array.isArray(right)) {
+    if (!Array.isArray(left) || !Array.isArray(right))
+      return false;
+    return left.length === right.length && left.every((value, index) => valuesEqual(value, right[index]));
+  }
+  if (isPlainObject(left) && isPlainObject(right)) {
+    const leftKeys = Object.keys(left);
+    const rightKeys = Object.keys(right);
+    return leftKeys.length === rightKeys.length && leftKeys.every((key) => (key in right) && valuesEqual(left[key], right[key]));
+  }
+  return false;
+}
+function requestedValueMatches(requested, observed) {
+  if (requested === observed)
+    return true;
+  if (requested === null || requested === undefined) {
+    return observed === null || observed === undefined;
+  }
+  if (observed === null || observed === undefined)
+    return false;
+  if (typeof requested !== typeof observed)
+    return false;
+  if (Array.isArray(requested)) {
+    if (!Array.isArray(observed) || requested.length !== observed.length) {
+      return false;
+    }
+    return requested.every((value, index) => requestedValueMatches(value, observed[index]));
+  }
+  if (isPlainObject(requested)) {
+    if (!isPlainObject(observed))
+      return false;
+    const requestedKeys = Object.keys(requested);
+    if (requestedKeys.length === 0) {
+      return Object.keys(observed).length === 0;
+    }
+    return requestedKeys.every((key) => requestedValueMatches(requested[key], observed[key]));
+  }
+  return false;
+}
+function normalizeDefinitionWriteBody(kind, body) {
+  const normalized = { ...body };
+  if (!("definition" in normalized))
+    return normalized;
+  const nested = normalized.definition;
+  if (!isPlainObject(nested)) {
+    throw new CLIError("'definition' must be an object", 4 /* Validation */);
+  }
+  if ("definition" in nested) {
+    throw new CLIError("Only one 'definition' wrapper is supported", 4 /* Validation */);
+  }
+  delete normalized.definition;
+  for (const [key, nestedValue] of Object.entries(nested)) {
+    if (key in normalized && !valuesEqual(normalized[key], nestedValue)) {
+      throw new CLIError(`Conflicting values for '${key}' in flat and nested ${kind} fields`, 4 /* Validation */);
+    }
+    if (!(key in normalized))
+      normalized[key] = nestedValue;
+  }
+  return normalized;
+}
+function canonicalizeWireValue(kind, field, value) {
+  if (kind === "Function" && field === "http_method") {
+    return typeof value === "string" ? value.toUpperCase() : value;
+  }
+  if (kind === "Function" && field === "request_body" && isPlainObject(value)) {
+    const canonical = {
+      content_type: "application/json",
+      required: false,
+      schema_def: null,
+      ...value
+    };
+    if ("schema" in canonical) {
+      canonical.schema_def = canonical.schema;
+      delete canonical.schema;
+    }
+    return canonical;
+  }
+  if (kind === "Function" && field === "auth" && isPlainObject(value)) {
+    return {
+      scheme: null,
+      header: null,
+      query_param: null,
+      value: null,
+      credential_source: null,
+      ...value
+    };
+  }
+  if (kind === "Workflow" && field === "nodes" && Array.isArray(value)) {
+    return value.map((node) => isPlainObject(node) ? { label: null, config: {}, position: null, ...node } : node);
+  }
+  if (kind === "Workflow" && field === "edges" && Array.isArray(value)) {
+    return value.map((edge) => isPlainObject(edge) ? { source_handle: null, condition: null, label: null, ...edge } : edge);
+  }
+  return value;
+}
+function canonicalizeParameter(value) {
+  if (!isPlainObject(value))
+    return value;
+  return {
+    description: null,
+    required: false,
+    location: "query",
+    enum: null,
+    default: null,
+    ...value
+  };
+}
+function parameterMapMatches(requested, observed) {
+  if (!isPlainObject(requested) || !isPlainObject(observed)) {
+    return requestedValueMatches(requested, observed);
+  }
+  const requestedNames = Object.keys(requested);
+  const observedNames = Object.keys(observed);
+  return requestedNames.length === observedNames.length && requestedNames.every((name) => (name in observed) && valuesEqual(canonicalizeParameter(requested[name]), canonicalizeParameter(observed[name])));
+}
+function fieldValueMatches(kind, field, requested, observed) {
+  if (kind === "Function" && field === "parameters") {
+    return parameterMapMatches(requested, observed);
+  }
+  const isExactTypedValue = kind === "Function" && (field === "request_body" || field === "auth") || kind === "Workflow" && (field === "nodes" || field === "edges");
+  if (isExactTypedValue) {
+    return valuesEqual(requested, observed);
+  }
+  const isExactReplacementMap = kind === "Function" && field === "extra_headers" || kind === "Workflow" && (field === "variables" || field === "input_schema" || field === "ui_metadata");
+  if (isExactReplacementMap) {
+    return valuesEqual(requested, observed);
+  }
+  return requestedValueMatches(requested, observed);
+}
+function verifyDefinitionUpdateResponse(kind, requestedBody, response) {
+  const requested = normalizeDefinitionWriteBody(kind, requestedBody);
+  const observed = normalizeDefinitionWriteBody(kind, response);
+  const mutableFields = MUTABLE_FIELDS[kind];
+  const mismatches = Object.keys(requested).filter((field) => mutableFields.has(field) && !fieldValueMatches(kind, field, canonicalizeWireValue(kind, field, requested[field]), canonicalizeWireValue(kind, field, observed[field])));
+  if (mismatches.length > 0) {
+    throw new CLIError(`Server response did not persist requested field(s): ${mismatches.join(", ")}`, 1 /* Error */);
+  }
+}
+
+// src/commands/definitions-apply.ts
 var VALID_KINDS = new Set([
   "Function",
   "Workflow",
@@ -14549,12 +14777,11 @@ var SERVER_GENERATED_FIELDS = new Set([
   "has_parallel",
   "has_conditions",
   "function_refs",
-  "format_version",
   "tenant_id"
 ]);
 var AGENT_MANAGED_FIELDS = new Set(["functions", "workflows"]);
 function loadDefinitions(inputPath) {
-  const resolved = path7.resolve(inputPath);
+  const resolved = path8.resolve(inputPath);
   if (!fs8.existsSync(resolved)) {
     throw new CLIError(`Path not found: ${inputPath}`, 1 /* Error */);
   }
@@ -14567,7 +14794,7 @@ function loadDefinitions(inputPath) {
 function loadDirectory(dirPath) {
   const entries = fs8.readdirSync(dirPath).sort();
   const validExts = new Set([".yaml", ".yml", ".json"]);
-  const files = entries.filter((e) => validExts.has(path7.extname(e).toLowerCase())).map((e) => path7.join(dirPath, e));
+  const files = entries.filter((e) => validExts.has(path8.extname(e).toLowerCase())).map((e) => path8.join(dirPath, e));
   if (files.length === 0) {
     throw new CLIError(`No YAML or JSON files found in ${dirPath}`, 4 /* Validation */);
   }
@@ -14579,7 +14806,7 @@ function loadDirectory(dirPath) {
 }
 function loadFile(filePath) {
   const content = fs8.readFileSync(filePath, "utf-8");
-  const ext = path7.extname(filePath).toLowerCase();
+  const ext = path8.extname(filePath).toLowerCase();
   if (ext === ".json") {
     const parsed = parseJsonFile(content, filePath);
     return [toLocalDefinition(parsed, filePath)];
@@ -14639,7 +14866,9 @@ function toLocalDefinition(raw, source) {
       continue;
     body[k] = v;
   }
-  return { kind, name, body, source };
+  const typedKind = kind;
+  const normalizedBody = typedKind === "Function" || typedKind === "Workflow" ? normalizeDefinitionWriteBody(typedKind, body) : body;
+  return { kind: typedKind, name, body: normalizedBody, source };
 }
 async function computeOperations(defs, api) {
   const ops = [];
@@ -14814,7 +15043,7 @@ async function executeApply(api, ops, defs, warnings) {
     }
     const def = defsByKey.get(`${op.kind}:${op.name}`);
     const apiPath = KIND_TO_API_PATH[op.kind];
-    const body = { ...def.body };
+    const body = op.kind === "Function" || op.kind === "Workflow" ? normalizeDefinitionWriteBody(op.kind, def.body) : { ...def.body };
     if (op.kind === "Agent") {
       for (const field of AGENT_MANAGED_FIELDS) {
         if (field in body) {
@@ -14841,6 +15070,9 @@ async function executeApply(api, ops, defs, warnings) {
         });
       } else {
         const res = await api.put(`${apiPath}/${encodeURIComponent(op.name)}`, body);
+        if (op.kind === "Function" || op.kind === "Workflow") {
+          verifyDefinitionUpdateResponse(op.kind, body, res);
+        }
         const portWarnings = extractPortWarnings(res);
         results.push({
           name: op.name,
@@ -15123,6 +15355,8 @@ var functionsConfig = {
   typeName: "function",
   typeNamePlural: "functions",
   apiPath: "/api/admin/definitions/functions",
+  normalizeBody: (body) => normalizeDefinitionWriteBody("Function", body),
+  verifyUpdateResult: (body, result) => verifyDefinitionUpdateResponse("Function", body, result),
   extractList: (data) => {
     if (!Array.isArray(data)) {
       throw new Error("Unexpected API response shape for functions list");
@@ -15754,6 +15988,8 @@ var workflowsConfig = {
   typeName: "workflow",
   typeNamePlural: "workflows",
   apiPath: "/api/admin/definitions/workflows",
+  normalizeBody: (body) => normalizeDefinitionWriteBody("Workflow", body),
+  verifyUpdateResult: (body, result) => verifyDefinitionUpdateResponse("Workflow", body, result),
   extractList: (data) => {
     if (!Array.isArray(data)) {
       throw new Error("Unexpected API response shape for workflows list");
@@ -16141,6 +16377,14 @@ function colorStatus2(status) {
   const fn = STATUS_COLORS2[status] ?? source_default.white;
   return fn(status);
 }
+function unwrapList(res) {
+  if (Array.isArray(res))
+    return res;
+  return res?.items ?? [];
+}
+function ingestionLabel(doc) {
+  return doc.ingestion_status ?? "not ingested";
+}
 async function pollIngestionUntilDone(ctx, documentId, intervalMs = 2000, timeoutMs = 300000) {
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
@@ -16380,7 +16624,9 @@ ${items.length} collections`));
     const ctx = getCtx();
     const col = await resolveCollection(ctx, id);
     const extraPromptIds = opts.clear ? [] : promptIds;
-    const result = await ctx.api.put(`/api/admin/collections/${encodeURIComponent(col.id)}`, { extra_prompt_ids: extraPromptIds });
+    const result = await ctx.api.put(`/api/admin/collections/${encodeURIComponent(col.id)}`, {
+      extra_prompt_ids: extraPromptIds
+    });
     if (isJson()) {
       console.log(JSON.stringify({ extra_prompt_ids: result.extra_prompt_ids ?? [] }, null, 2));
       return;
@@ -16486,9 +16732,10 @@ ${items.length} collections`));
     const params = {};
     if (!opts.inactive)
       params.active_only = "true";
-    const items = await ctx.api.get(`/api/admin/collections/${encodeURIComponent(collectionId)}/documents`, { params });
+    const res = await ctx.api.get(`/api/admin/collections/${encodeURIComponent(collectionId)}/documents`, { params });
+    const items = unwrapList(res);
     if (isJson()) {
-      console.log(JSON.stringify(items, null, 2));
+      console.log(JSON.stringify(res, null, 2));
       return;
     }
     const columns = [
@@ -16502,8 +16749,8 @@ ${items.length} collections`));
         accessor: (i) => i.size_bytes != null ? formatBytes(i.size_bytes) : "-"
       },
       {
-        header: "STATUS",
-        accessor: (i) => i.ingestion_status ?? i.status ?? "-"
+        header: "INGESTION",
+        accessor: (i) => ingestionLabel(i)
       }
     ];
     const widths = columns.map((col) => items.length === 0 ? col.header.length : Math.max(col.header.length, ...items.map((item) => col.accessor(item).length)));
@@ -16532,9 +16779,11 @@ ${items.length} documents`));
     if (doc.size_bytes != null) {
       console.log(`  Size:      ${formatBytes(doc.size_bytes)}`);
     }
-    console.log(`  Status:    ${colorStatus2(doc.ingestion_status ?? doc.status ?? "-")}`);
+    console.log(`  Upload:    ${colorStatus2(doc.status ?? "-")}`);
+    console.log(`  Ingestion: ${colorStatus2(ingestionLabel(doc))}`);
     if (doc.chunk_count != null) {
-      console.log(`  Chunks:    ${doc.chunk_count}`);
+      const warn = doc.ingestion_status === "ready" && doc.chunk_count === 0 ? source_default.yellow("  ← ready but nothing retrievable") : "";
+      console.log(`  Chunks:    ${doc.chunk_count}${warn}`);
     }
     console.log(`  Active:    ${doc.is_active !== false ? source_default.green("yes") : source_default.dim("no")}`);
     if (doc.created_at)
@@ -18204,8 +18453,11 @@ ${data.length} spec(s)`));
     if (opts.force)
       params.force = "true";
     const result = await ctx.api.post(`/api/admin/definitions/openapi-specs/${encodeURIComponent(id)}/sync`, undefined, { params });
+    const syncFailed = result.status === "error" || result.status === "partial";
     if (isJson()) {
       console.log(JSON.stringify(result, null, 2));
+      if (syncFailed)
+        process.exitCode = 1 /* Error */;
       return;
     }
     console.log(result.message ?? "Sync completed.");
@@ -18221,6 +18473,8 @@ ${data.length} spec(s)`));
         console.log(source_default.red(`    - ${err}`));
       }
     }
+    if (syncFailed)
+      process.exitCode = 1 /* Error */;
   });
   cmd.command("import-openapi").description("Import an OpenAPI spec").requiredOption("--source <url>", "OpenAPI spec URL").requiredOption("--name <name>", "Integration name").option("--prefix <prefix>", "Function name prefix").option("--include-tags <tags>", "Comma-separated tags to include").option("--exclude-tags <tags>", "Comma-separated tags to exclude").option("--dry-run", "Preview without creating (default)", true).option("--no-dry-run", "Actually create the functions").option("--force", "Force import even with conflicts").option("--auth-scheme <scheme>", "Auth scheme: apiKey, bearer, basic, oauth2, none").option("--auth-header <header>", "Header name for auth (default: Authorization)").option("--auth-value <value>", "Auth value or env var reference (${VAR})").option("--auth-query-param <param>", "Query parameter name for apiKey auth").option("--auth-credential-source <key>", "Vault credential lookup key").action(async (opts) => {
     const ctx = getCtx();
@@ -18370,8 +18624,8 @@ ${data.length} spec(s)`));
 Resources:
 `));
       for (const r of resources) {
-        const path8 = r.path || `/${r.name}`;
-        console.log(`  ${source_default.cyan(r.label || r.name)}` + source_default.dim(` → ${path8}`));
+        const path9 = r.path || `/${r.name}`;
+        console.log(`  ${source_default.cyan(r.label || r.name)}` + source_default.dim(` → ${path9}`));
       }
     }
     try {
@@ -18391,14 +18645,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, path8, 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, path9, 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 = path8.startsWith("/") ? path8.slice(1) : path8;
+    const cleanPath = path9.startsWith("/") ? path9.slice(1) : path9;
     const proxyUrl = `/api/admin/plugins/${encodeURIComponent(name)}/${cleanPath}`;
     const params = {};
     if (opts.query) {
@@ -18776,11 +19030,11 @@ async function readStdin2() {
 
 // src/commands/messaging.ts
 init_errors();
-async function messagingFetch(baseUrl, path8, opts) {
-  if (/^(https?:)?\/\//i.test(path8)) {
+async function messagingFetch(baseUrl, path9, opts) {
+  if (/^(https?:)?\/\//i.test(path9)) {
     throw new CLIError("Absolute URL paths are not allowed", 1 /* Error */);
   }
-  const url = new URL(path8, baseUrl);
+  const url = new URL(path9, baseUrl);
   const headers = {
     "Content-Type": "application/json"
   };
@@ -20218,16 +20472,16 @@ ${wikis.length} wiki${wikis.length === 1 ? "" : "s"}`));
     console.log(source_default.dim(`
 ${pages.length} pages`));
   });
-  cmd.command("get <path>").description("Fetch the raw markdown body of a wiki page").option("--wiki <slug>", "Wiki slug (default: the tenant default wiki)").option("--out <file>", "Write body to file instead of stdout").action(async (path8, opts) => {
+  cmd.command("get <path>").description("Fetch the raw markdown body of a wiki page").option("--wiki <slug>", "Wiki slug (default: the tenant default wiki)").option("--out <file>", "Write body to file instead of stdout").action(async (path9, opts) => {
     const ctx = getCtx();
-    const safe = path8.split("/").map(encodeURIComponent).join("/");
+    const safe = path9.split("/").map(encodeURIComponent).join("/");
     const slug = encodeURIComponent(opts.wiki ?? DEFAULT_WIKI_SLUG);
     const endpoint = `/api/wiki/${slug}/pages/${safe}`;
     const resp = await ctx.api.getRaw(endpoint, {
       headers: { Accept: "text/markdown,*/*" }
     });
     if (resp.status === 404) {
-      throw new CLIError(`page not found: ${path8}`, 3 /* NotFound */);
+      throw new CLIError(`page not found: ${path9}`, 3 /* NotFound */);
     }
     if (!resp.ok) {
       const detail = await resp.text();
@@ -20239,12 +20493,12 @@ ${pages.length} pages`));
       if (!isJson()) {
         console.log(source_default.dim(`wrote ${body.length} bytes to ${opts.out}`));
       } else {
-        console.log(JSON.stringify({ path: path8, bytes: body.length, file: opts.out }));
+        console.log(JSON.stringify({ path: path9, bytes: body.length, file: opts.out }));
       }
       return;
     }
     if (isJson()) {
-      console.log(JSON.stringify({ path: path8, body, etag: resp.headers.get("ETag") }));
+      console.log(JSON.stringify({ path: path9, body, etag: resp.headers.get("ETag") }));
     } else {
       process.stdout.write(body);
     }
@@ -21936,11 +22190,11 @@ function registerInitCommand(program2) {
 
 // src/commands/doctor.ts
 var FETCH_TIMEOUT_MS = 5000;
-function resolveApiUrl(base, path8) {
-  return new URL(path8, base).toString();
+function resolveApiUrl(base, path9) {
+  return new URL(path9, base).toString();
 }
-function apiUrl(ctx, path8) {
-  return resolveApiUrl(ctx.profile.api_url, path8);
+function apiUrl(ctx, path9) {
+  return resolveApiUrl(ctx.profile.api_url, path9);
 }
 async function fetchJSON(url, init) {
   const res = await fetch(url, {
@@ -22238,15 +22492,15 @@ function registerDoctorCommand(program2) {
 // src/commands/skill.ts
 init_errors();
 import fs12 from "node:fs";
-import path8 from "node:path";
+import path9 from "node:path";
 import { fileURLToPath } from "node:url";
 function locateSkill() {
-  const here = path8.dirname(fileURLToPath(import.meta.url));
+  const here = path9.dirname(fileURLToPath(import.meta.url));
   const candidates = [
-    path8.join(here, "skills", "martha-cli", "SKILL.md"),
-    path8.join(here, "..", "skills", "martha-cli", "SKILL.md"),
-    path8.join(here, "..", "..", "..", "skills", "martha-cli", "SKILL.md"),
-    path8.join(here, "..", "..", "skills", "martha-cli", "SKILL.md")
+    path9.join(here, "skills", "martha-cli", "SKILL.md"),
+    path9.join(here, "..", "skills", "martha-cli", "SKILL.md"),
+    path9.join(here, "..", "..", "..", "skills", "martha-cli", "SKILL.md"),
+    path9.join(here, "..", "..", "skills", "martha-cli", "SKILL.md")
   ];
   for (const p of candidates) {
     if (fs12.existsSync(p))

package/package.json

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