@proagentstore/cli 0.4.85 → 0.4.86

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. */
@@ -209,7 +210,13 @@ export function parseLocalBrowserResult(raw) {
     // 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

@@ -28,6 +28,26 @@ 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 { 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) {
@@ -412,7 +440,13 @@ export class LocalBrowserRuntime {
             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.86",
   "description": "CLI for creating, publishing, and running ProAgentStore agents",
   "license": "MIT",
   "type": "module",