@proagentstore/cli 0.4.142 → 0.4.144

package/dist/browser-runner/coding/repo.js

@@ -1,6 +1,7 @@
 import { execFileSync, spawnSync } from "node:child_process";
 import { existsSync, mkdirSync, readdirSync, rmSync, statSync } from "node:fs";
 import { join } from "node:path";
+import { RunnerInputError } from "../errors.js";
 /**
  * Inspect a workdir: does it exist, does it hold anything, is it a checkout. Never throws —
  * every failure is a `false`, because this function exists to REPORT a broken path and one that
@@ -175,10 +176,11 @@ export function ensureRepo(dir, opts = {}) {
             // The owner's own folder (a monorepo subfolder, a plain project) — run in it untouched.
             if (opts.ownFolder)
                 return dir;
-            throw new Error(`Refusing to clone into non-empty directory "${dir}" (no .git found) — move it aside or point at an empty path.`);
+            // A refusal about the owner's folder, answered as one (#1116) — never a runner crash.
+            throw new RunnerInputError(`Refusing to clone into non-empty directory "${dir}" (no .git found) — move it aside or point at an empty path.`, 409);
         }
         if (opts.ownFolder && checkWorkdir(dir).insideWorkTree) {
-            throw new Error(`"${dir}" is an empty folder inside another git checkout — not cloning a second repository into it. Point this repo at the checkout itself, or remove the folder.`);
+            throw new RunnerInputError(`"${dir}" is an empty folder inside another git checkout — not cloning a second repository into it. Point this repo at the checkout itself, or remove the folder.`, 409);
         }
         rmSync(dir, { recursive: true, force: true });
     }

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

@@ -314,7 +314,7 @@ export class CodingRuntime {
                 session.interrupt();
                 break;
             default:
-                throw new Error(`Unknown coding action: ${action.kind}`);
+                throw new RunnerInputError(`Unknown coding action: ${action.kind}`);
         }
         return this.snapshot(sessionId);
     }
@@ -472,8 +472,9 @@ export class CodingRuntime {
     }
     require(sessionId) {
         const session = this.sessions.get(sessionId);
+        // A caller naming a session this runner does not hold is a lookup, not a crash (#1116): 404, with the same sentence.
         if (!session)
-            throw new Error(`No coding session: ${sessionId}`);
+            throw new RunnerInputError(`No coding session: ${sessionId}`, 404);
         return session;
     }
 }

package/dist/browser-runner/coding/terminal.js

@@ -1,6 +1,7 @@
 import { execFileSync } from "node:child_process";
 import { homedir } from "node:os";
 import { resolve } from "node:path";
+import { RunnerInputError } from "../errors.js";
 import { capturePane, createSession, killSession, listSessionsDetailed, runCommand as tmuxRunCommand, sendKey as tmuxSendKey, sendText as tmuxSendText, sessionExists, tmuxExec } from "./tmux.js";
 function shellPath() {
     return process.env.SHELL || "/bin/zsh";
@@ -14,7 +15,7 @@ export function splitTerminalTarget(raw, fallback) {
     if (m)
         return { backend: m[1].toLowerCase(), id: m[2].trim() };
     if (!fallback)
-        throw new Error("A target must include a backend prefix like `tmux:main`, or pass `backend` separately.");
+        throw new RunnerInputError("A target must include a backend prefix like `tmux:main`, or pass `backend` separately.");
     return { backend: fallback, id: value };
 }
 export function listTerminalTargets(backend = "all") {
@@ -43,7 +44,7 @@ export function captureTerminalTarget(target, opts = {}) {
     switch (t.backend) {
         case "tmux":
             if (!sessionExists(t.id))
-                throw new Error(`No tmux session "${t.id}".`);
+                throw new RunnerInputError(`No tmux session "${t.id}".`, 404);
             return capturePane(t.id, Math.min(Math.max(Number(opts.lines) || 200, 1), 2000));
         case "kitty":
             return kittyExec(["@", "get-text", "--match", `id:${t.id}`, "--extent", "all"], 5000);
@@ -227,11 +228,11 @@ function kittyForegroundCommand(id) {
 export function runTerminalCommand(target, command, backend) {
     const t = splitTerminalTarget(target, backend);
     if (!command.trim())
-        throw new Error("A `command` is required.");
+        throw new RunnerInputError("A `command` is required.");
     switch (t.backend) {
         case "tmux":
             if (!sessionExists(t.id))
-                throw new Error(`No tmux session "${t.id}".`);
+                throw new RunnerInputError(`No tmux session "${t.id}".`, 404);
             tmuxRunCommand(t.id, command);
             return capturePane(t.id, 200);
         case "kitty":
@@ -246,11 +247,11 @@ export function runTerminalCommand(target, command, backend) {
 export function sendTerminalKeys(target, opts) {
     const t = splitTerminalTarget(target, opts.backend);
     if (opts.text == null && (!opts.keys || opts.keys.length === 0))
-        throw new Error("Provide `text` and/or `keys` to send.");
+        throw new RunnerInputError("Provide `text` and/or `keys` to send.");
     switch (t.backend) {
         case "tmux":
             if (!sessionExists(t.id))
-                throw new Error(`No tmux session "${t.id}".`);
+                throw new RunnerInputError(`No tmux session "${t.id}".`, 404);
             if (opts.text != null)
                 tmuxSendText(t.id, opts.text);
             for (const key of opts.keys ?? [])
@@ -264,7 +265,7 @@ export function sendTerminalKeys(target, opts) {
             return captureTerminalTarget(t.id, { backend: "kitty" });
         case "iterm2":
             if ((opts.keys ?? []).length > 0)
-                throw new Error("iTerm2 generic key events are not supported yet; send text or run a command.");
+                throw new RunnerInputError("iTerm2 generic key events are not supported yet; send text or run a command.");
             itermSessionScript(t.id, `tell theSession to write text ${appleString(opts.text ?? "")}`);
             return captureTerminalTarget(t.id, { backend: "iterm2" });
     }
@@ -275,7 +276,7 @@ export function createTerminalTarget(opts) {
         case "tmux": {
             const name = String(opts.name || "").trim();
             if (!name)
-                throw new Error("A `name` is required for tmux.");
+                throw new RunnerInputError("A `name` is required for tmux.");
             if (sessionExists(name))
                 return { backend: "tmux", id: name, name, existed: true, workDir };
             createSession(name, workDir, opts.command);

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

@@ -262,9 +262,11 @@ export function parseLocalApplyResult(raw) {
         const gateId = str(s.gateId, 100);
         if (mode !== "auto_submit")
             return { error: "a submitted outcome requires a run in auto_submit mode" };
-        if (!url || !isHttpUrl(url) || !at || Number.isNaN(Date.parse(at)) || !gateId)
+        if (!url || !isHttpUrl(url) || !traceUrl(url) || !at || Number.isNaN(Date.parse(at)) || !gateId)
             return { error: "a submitted outcome needs the confirmed url, its time and the gateId" };
-        out.submitted = { url, at, gateId };
+        // A page URL kept as a fact keeps origin and path only, as a trace's does (#1069): a confirmation
+        // page's query can carry session or application tokens, and the receipt is the page, not its query.
+        out.submitted = { url: traceUrl(url), at, gateId };
         out.submitAttempted = true;
     }
     // #975 — accepted ONLY as the closed vocabulary it declares. A runner that sends prose here gets
@@ -296,10 +298,10 @@ export function parseLocalApplyResult(raw) {
             const reason = oneOf(LOCAL_APPLY_UNAVAILABLE_REASONS, evidence.reason);
             const url = str(evidence.url, 2000);
             const observedAt = str(evidence.observedAt, 40);
-            if (!reason || !url || !isHttpUrl(url) || !observedAt || Number.isNaN(Date.parse(observedAt)) || evidence.source !== "page_notice") {
+            if (!reason || !url || !isHttpUrl(url) || !traceUrl(url) || !observedAt || Number.isNaN(Date.parse(observedAt)) || evidence.source !== "page_notice") {
                 return { error: "a job_unavailable result needs runner-verified unavailable evidence (reason, url, observedAt, source)" };
             }
-            out.unavailable = { reason, url, observedAt, source: "page_notice" };
+            out.unavailable = { reason, url: traceUrl(url), observedAt, source: "page_notice" };
         }
         else if (o.unavailable !== undefined)
             return { error: "unavailable evidence is only valid for a job_unavailable result" };

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

@@ -122,6 +122,20 @@ export function redactDetail(detail, depth = 0, secrets = []) {
 const str = (v, max) => (typeof v === "string" && v.trim() ? v.trim().slice(0, max) : null);
 const isHttpUrl = (v) => /^https?:\/\/[^\s/]+/i.test(v);
 const oneOf = (list, v) => (list.includes(v) ? v : null);
+/**
+ * A page URL as a trace may keep it (#1069): origin and path — no query, no fragment, no credentials
+ * (`origin` never carries a `user:pass@`). The same rule as the local-apply contract's `traceUrl`;
+ * restated here because each vendored contract imports nothing. Empty when it is not an http(s) URL.
+ */
+export function traceUrl(raw) {
+    try {
+        const u = new URL(raw);
+        return u.protocol === "http:" || u.protocol === "https:" ? `${u.origin}${u.pathname}` : "";
+    }
+    catch {
+        return "";
+    }
+}
 /** A validated event, or null. */
 export function parseLocalBrowserEvent(raw) {
     if (!raw || typeof raw !== "object")
@@ -132,9 +146,14 @@ export function parseLocalBrowserEvent(raw) {
     if (!type || !at || Number.isNaN(Date.parse(at)))
         return null;
     const event = { type, at };
+    // Origin and path only (#1069): a research trace keeps where the browser went, never a page's query
+    // or fragment — a sign-in page's OAuth state/nonce/PKCE values or a session id ride there.
     const url = str(o.url, 2000);
-    if (url && isHttpUrl(url))
-        event.url = url;
+    if (url && isHttpUrl(url)) {
+        const kept = traceUrl(url);
+        if (kept)
+            event.url = kept;
+    }
     const domain = str(o.domain, 253);
     if (domain)
         event.domain = domain.toLowerCase();

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

@@ -27,7 +27,7 @@ import { RunnerInputError } from "../errors.js";
 import { BrowserBridge, domainWithin } from "./bridge.js";
 import { SCOUT_SHOT_CAP, ShotRecorder } from "./replay.js";
 import { BRIDGE_ENV } from "./bridge-stdio.js";
-import { LOCAL_BROWSER_AUTH_MODES, LOCAL_BROWSER_ENGINES, LOCAL_BROWSER_TASK_TYPE, redactDetail, redactFinding, redactSourceFailure, redactText, secretEnvValues, } from "./contract.js";
+import { LOCAL_BROWSER_AUTH_MODES, LOCAL_BROWSER_ENGINES, LOCAL_BROWSER_TASK_TYPE, redactDetail, redactFinding, redactSourceFailure, redactText, secretEnvValues, traceUrl, } 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).
@@ -303,9 +303,11 @@ export class LocalBrowserRuntime {
     emit(run, ev) {
         if (run.events.length >= MAX_EVENTS)
             return;
-        const { detail: raw, ...rest } = ev;
+        // Origin and path only, before anything leaves the machine (#1069) — the cloud reduces it again.
+        const { detail: raw, url: rawUrl, ...rest } = ev;
+        const url = rawUrl ? traceUrl(rawUrl) : "";
         const detail = redactDetail(raw, 0, run.secrets);
-        run.events.push({ ...rest, ...(detail && Object.keys(detail).length ? { detail } : {}), at: new Date(this.now()).toISOString(), seq: ++run.seq });
+        run.events.push({ ...rest, ...(url ? { url } : {}), ...(detail && Object.keys(detail).length ? { detail } : {}), at: new Date(this.now()).toISOString(), seq: ++run.seq });
     }
     pause(run, reason, detail) {
         if (run.state === "ended" || run.cancelled)

package/dist/browser-runner/runner.js

@@ -242,7 +242,7 @@ export class LocalRunner {
     async approveTask(id) {
         const task = this.requireTask(id);
         if (task.status !== "needs_approval") {
-            throw new Error(`Task is not waiting for approval: ${task.status}`);
+            throw new RunnerInputError(`Task is not waiting for approval: ${task.status}`, 409);
         }
         task.status = "queued";
         task.updatedAt = new Date().toISOString();
@@ -662,7 +662,7 @@ export class LocalRunner {
         if (task.type === "browser.open") {
             const url = String(task.input.url || "");
             if (!url || !/^https?:\/\//.test(url)) {
-                throw new Error("browser.open requires an http(s) url");
+                throw new RunnerInputError("browser.open requires an http(s) url");
             }
             const context = await this.getBrowserContext();
             const page = context.pages()[0] || (await context.newPage());
@@ -701,12 +701,12 @@ export class LocalRunner {
             this.addTaskEvent(task, "browser.goto.completed", "Browser page loaded", output);
             return output;
         }
-        throw new Error(`Unknown task type: ${task.type}`);
+        throw new RunnerInputError(`Unknown task type: ${task.type}`);
     }
     requireTask(id) {
         const task = this.store.getTask(id);
         if (!task)
-            throw new Error(`Task not found: ${id}`);
+            throw new RunnerInputError(`Task not found: ${id}`, 404);
         return task;
     }
     async getBrowserContext() {

package/package.json

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