@proagentstore/cli 0.4.85 → 0.4.87

package/dist/browser-runner/local-browser/contract.js

@@ -50,6 +50,7 @@ export const LOCAL_BROWSER_EVENT_TYPES = [
 export const LOCAL_BROWSER_PLATFORM_EVENT_TYPES = ["run.requested", "runner.dispatched", "run.ended", "review.decision"];
 export const LOCAL_BROWSER_ENGINE_AUTHS = ["subscription", "machine-login", "api-key", "missing_login", "unknown"];
 export const LOCAL_BROWSER_SOURCE_FAILURE_REASONS = ["login_required", "captcha", "paywall", "access_denied", "robots", "timeout", "error"];
+export const LOCAL_BROWSER_ERROR_CODES = ["browser_unavailable", "engine_not_installed", "engine_not_signed_in", "bridge_unused", "consent_declined", "time_limit", "cancelled", "engine_failed"];
 export const LOCAL_BROWSER_CAPS = { findings: 200, sourceFailures: 200, text: 4000, fieldCount: 40 };
 const SENSITIVE_KEY = /cookie|password|passwd|secret|token|authorization|api[_-]?key|otp|form[_-]?values?|credential/i;
 /** An env var NAME whose value is a credential. */
@@ -147,6 +148,36 @@ export function parseLocalBrowserEvent(raw) {
         event.detail = detail;
     return event;
 }
+/**
+ * A finding, with every free-text part redacted (#947).
+ *
+ * The gap this closes: the result envelope's `summary` and `error` went through {@link redactText}
+ * and its FINDINGS did not. `title`, `evidence` and `detail` were length-capped only, and `fields`
+ * was filtered by KEY ({@link SENSITIVE_KEY}) — so a credential-shaped value under an innocuous key
+ * (`{"note": "sk-ant-api03-…"}`) survived, and a secret environment value quoted into `evidence`
+ * survived verbatim. Both are written by the same CLI, on the same machine, in the same envelope as
+ * the summary that WAS cleaned, and findings are the part that persists furthest: the run's result
+ * row, the console, MCP, and then the owner's own collection record. #947's observability rule —
+ * "do not retain … secret environment values" — was therefore breached on the longest-lived path.
+ *
+ * One definition, used by the runner (which knows the machine's secret env values and passes them)
+ * and again by the API when it parses what arrived (which does not, and catches shapes). Defence in
+ * depth on purpose: the runner is where secrets are knowable, and the cloud is where a runner that
+ * skipped the step is still caught.
+ */
+export function redactFinding(f, secrets = []) {
+    const fields = {};
+    for (const [k, v] of Object.entries(f.fields ?? {})) {
+        if (SENSITIVE_KEY.test(k))
+            continue;
+        fields[k] = typeof v === "string" ? redactText(v, secrets) : v;
+    }
+    return { title: redactText(f.title, secrets), url: f.url, evidence: redactText(f.evidence, secrets), fields };
+}
+/** The same for a source failure's free text; its `reason` is a closed vocabulary and its url is a url. */
+export function redactSourceFailure(f, secrets = []) {
+    return f.detail === undefined ? f : { ...f, detail: redactText(f.detail, secrets) };
+}
 /**
  * A validated result envelope, or the reason it is not one.
  *
@@ -193,7 +224,9 @@ export function parseLocalBrowserResult(raw) {
             else if (typeof v === "number" || typeof v === "boolean" || v === null)
                 fields[k.slice(0, 100)] = v;
         }
-        findings.push({ title, url, evidence, fields });
+        // #947: capped and key-filtered is not redacted. A finding is the longest-lived thing a run
+        // produces, and its free text was the one part of this envelope nothing cleaned.
+        findings.push(redactFinding({ title, url, evidence, fields }));
     }
     const sourceFailures = [];
     for (const [i, f] of o.sourceFailures.entries()) {
@@ -203,13 +236,19 @@ export function parseLocalBrowserResult(raw) {
         if (!url || !reason)
             return { error: `sourceFailures[${i}] needs url and a known reason` };
         const detail = str(r.detail, 1000);
-        sourceFailures.push(detail ? { url, reason, detail } : { url, reason });
+        sourceFailures.push(redactSourceFailure(detail ? { url, reason, detail } : { url, reason }));
     }
     const out = { runId, outcome, findings, sourceFailures, summary: redactText(str(o.summary, LOCAL_BROWSER_CAPS.text) ?? ""), traceId, engineAuth };
     // Redacted again here, whatever the runner did: an error is CLI output, and CLIs print keys.
     const rawError = str(o.error, 1000);
     const error = rawError === null ? null : redactText(rawError);
-    if (outcome === "failed")
+    if (outcome === "failed") {
         out.error = error ?? "The run failed without a reason.";
+        // #944: the runner's own name for the cause, when it gave one. An unrecognised code is
+        // dropped rather than passed through, so the stored vocabulary stays closed.
+        const code = oneOf(LOCAL_BROWSER_ERROR_CODES, o.errorCode);
+        if (code)
+            out.errorCode = code;
+    }
     return { result: out };
 }

package/dist/browser-runner/local-browser/runtime.js

@@ -26,8 +26,28 @@ import { fileURLToPath } from "node:url";
 import { RunnerInputError } from "../errors.js";
 import { BrowserBridge, domainWithin } from "./bridge.js";
 import { BRIDGE_ENV } from "./bridge-stdio.js";
-import { LOCAL_BROWSER_AUTH_MODES, LOCAL_BROWSER_ENGINES, LOCAL_BROWSER_TASK_TYPE, redactDetail, redactText, secretEnvValues, } from "./contract.js";
+import { LOCAL_BROWSER_AUTH_MODES, LOCAL_BROWSER_ENGINES, LOCAL_BROWSER_TASK_TYPE, redactDetail, redactFinding, redactSourceFailure, redactText, secretEnvValues, } from "./contract.js";
 import { bridgeUnused, buildEngineSpec, finalText, missingLogin, observedEngineAuth, researchPrompt, signInHelp } from "./engine.js";
+/**
+ * Why the run could not be launched, in words the owner can act on (#944).
+ *
+ * Two shapes reach here: the owner declining the signed-in profile, which is a DECISION and not a
+ * fault, and the browser failing to start — the "missing browser" state the acceptance criteria
+ * ask for. Everything a browser can refuse at startup is fixed at the machine (install Chrome, free
+ * the profile another window is holding, allow the automation port), so the sentence says that; the
+ * raw message rides along, because it is the half that names which of those it was.
+ */
+function launchFailure(err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (/did not allow research in their signed-in browser profile/i.test(message)) {
+        return { outcome: "failed", error: message, errorCode: "consent_declined" };
+    }
+    return {
+        outcome: "failed",
+        error: `The browser for this run could not be started on this machine: ${message.slice(0, 400)}. Check that Chrome or Chromium is installed, that no other window is holding the profile this run uses, and that \`pags up\` may launch it — then start the run again.`,
+        errorCode: "browser_unavailable",
+    };
+}
 const MAX_EVENTS = 2000;
 const OUTPUT_LINES = 400;
 const SAFE_ID = /^[A-Za-z0-9_.:-]{1,100}$/;
@@ -172,7 +192,10 @@ export class LocalBrowserRuntime {
         this.runs.set(envelope.runId, run);
         // Not awaited: a signed-in-profile consent pause can hold the launch for minutes, and the
         // relay command that started the run must answer now. Everything after this is in `status`.
-        void this.launch(run, selfUrl).catch((err) => this.end(run, { outcome: "failed", error: err instanceof Error ? err.message : String(err) }));
+        // #944: a launch failure is the one the acceptance criteria call "missing browser", and it was
+        // the one cause with no name: it ended the run with whatever the browser threw, which the
+        // cloud then filed as `engine_failed` — the CLI blamed for a browser that never started.
+        void this.launch(run, selfUrl).catch((err) => this.end(run, launchFailure(err)));
         return { runId: envelope.runId, taskId: envelope.runId, status: run.state, existing: false };
     }
     async launch(run, selfUrl) {
@@ -230,7 +253,12 @@ export class LocalBrowserRuntime {
         child.stderr?.on("data", keep);
         child.on("error", (err) => {
             const missing = err.code === "ENOENT";
-            this.end(run, { outcome: "failed", error: missing ? `The ${e.engine === "claude" ? "Claude Code" : "Codex"} CLI is not installed on this machine (\`${spec.command}\` was not found).` : err.message });
+            this.end(run, {
+                outcome: "failed",
+                ...(missing
+                    ? { error: `The ${e.engine === "claude" ? "Claude Code" : "Codex"} CLI is not installed on this machine (\`${spec.command}\` was not found).`, errorCode: "engine_not_installed" }
+                    : { error: err.message }),
+            });
         });
         child.on("close", (code) => {
             if (buf.trim())
@@ -377,12 +405,12 @@ export class LocalBrowserRuntime {
         const summary = bridge?.summary ?? finalText(e.engine, run.output);
         const found = (bridge?.findings.length ?? 0) > 0;
         if (run.cancelled)
-            return { outcome: "failed", error: "Cancelled by the owner" };
+            return { outcome: "failed", error: "Cancelled by the owner", errorCode: "cancelled" };
         if (missingLogin(e.engine, run.output.join("\n")) && !found)
-            return { outcome: "failed", error: signInHelp(e.engine), engineAuth: "missing_login" };
+            return { outcome: "failed", error: signInHelp(e.engine), errorCode: "engine_not_signed_in", engineAuth: "missing_login" };
         const limit = `Stopped at the ${e.limits.maxMinutes}-minute limit.`;
         if (run.timedOut)
-            return { outcome: found ? "completed" : "failed", summary: summary || limit, error: limit };
+            return { outcome: found ? "completed" : "failed", summary: summary || limit, error: limit, errorCode: "time_limit" };
         if (code !== 0 && !bridge?.summary) {
             const tail = run.output.slice(-5).join("\n").slice(-800);
             return { outcome: "failed", summary, error: `The ${e.engine} CLI exited with code ${code}${tail ? `: ${tail}` : ""}` };
@@ -391,7 +419,7 @@ export class LocalBrowserRuntime {
         // says. Live run aac758dc (#952) ended `completed` with "the browser bridge required approval":
         // no page opened, and the run looked like a success with nothing found.
         if (!bridge?.calls)
-            return { outcome: "failed", summary, error: bridgeUnused(e.engine, summary) };
+            return { outcome: "failed", summary, error: bridgeUnused(e.engine, summary), errorCode: "bridge_unused" };
         return { outcome: "completed", summary };
     }
     end(run, r) {
@@ -406,13 +434,22 @@ export class LocalBrowserRuntime {
         run.result = {
             runId: run.envelope.runId,
             outcome: r.outcome,
-            findings: run.bridge?.findings ?? [],
-            sourceFailures: run.bridge?.sourceFailures ?? [],
+            // #947: the machine's own secret env values are knowable HERE and nowhere later, so the
+            // findings are cleaned with them — the same treatment `summary` and `error` below already
+            // had, and the part of this envelope that previously kept whatever the CLI wrote.
+            findings: (run.bridge?.findings ?? []).map((f) => redactFinding(f, run.secrets)),
+            sourceFailures: (run.bridge?.sourceFailures ?? []).map((f) => redactSourceFailure(f, run.secrets)),
             summary: redactText((r.summary ?? "").slice(0, 4000), run.secrets),
             traceId: run.envelope.runId,
             engineAuth: r.engineAuth ?? run.engineAuth,
             // CLI output becomes this text, and a CLI prints whatever it was given: redacted before it is kept.
-            ...(r.outcome === "failed" ? { error: redactText((r.error ?? "The run failed without a reason.").slice(0, 1000), run.secrets) } : {}),
+            ...(r.outcome === "failed"
+                ? {
+                    error: redactText((r.error ?? "The run failed without a reason.").slice(0, 1000), run.secrets),
+                    // #944: WHICH cause, named here rather than guessed by the cloud from `engineAuth`.
+                    errorCode: r.errorCode ?? "engine_failed",
+                }
+                : {}),
         };
         if (run.child && run.child.exitCode === null)
             this.kill(run);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@proagentstore/cli",
-  "version": "0.4.85",
+  "version": "0.4.87",
   "description": "CLI for creating, publishing, and running ProAgentStore agents",
   "license": "MIT",
   "type": "module",