@proagentstore/cli 0.4.146 → 0.4.148

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

@@ -31,6 +31,7 @@ import { ELEMENT_PROBE_FN } from "../commit-guard.js";
 import { normalize } from "../local-artifact/engine.js";
 import { evaluateResult, hostOf, refRole } from "../local-browser/bridge.js";
 import { looksLikeSignIn, siteKeyOf } from "./site-session.js";
+import { followOpenedTab, tabCount } from "./follow-tab.js";
 const READ_TOOLS = new Set(["browser_navigate", "browser_navigate_back", "browser_snapshot", "browser_wait_for"]);
 const FILL_TOOLS = new Set(["browser_type", "browser_select_option"]);
 const BRIDGE_TOOLS = ["upload_artifact", "request_answer", "ready_for_review", "supervisor_checkpoint"];
@@ -424,10 +425,7 @@ export class ApplyBridge {
         if (NAV_ROLES.has(t.role) || (t.role === "button" && PAGINATION_NAME.test(t.name.trim()))) {
             if (this.pages >= this.host.limits.maxPages)
                 return this.refuse("browser_click", "read", `The run's limit of ${this.host.limits.maxPages} pages is reached. Call ready_for_review now.`);
-            const res = await this.browser.callTool("browser_click", forward);
-            if (res.isError)
-                return { content: [{ type: "text", text: textOf(res) }], isError: true };
-            return this.afterMove("browser_click", textOf(res));
+            return this.clickAndFollow(forward);
         }
         // A native file input opens the file chooser for upload_artifact — a DOM fact, whatever its label.
         const fileInput = facts.tag === "input" && facts.type === "file";
@@ -643,10 +641,18 @@ export class ApplyBridge {
         if (this.pages >= this.host.limits.maxPages)
             return this.refuse("browser_click", "read", `The run's limit of ${this.host.limits.maxPages} pages is reached. Call ready_for_review now.`);
         this.host.emit({ type: "policy.decision", detail: { tool: "browser_click", class: "entry", decision: "allowed", reason, role: t.role } });
+        return this.clickAndFollow(forward);
+    }
+    /** A page-changing click — followed into a tab it opened (#1133, `follow-tab.ts`). */
+    async clickAndFollow(forward) {
+        const before = await tabCount(this.browser);
         const res = await this.browser.callTool("browser_click", forward);
         if (res.isError)
             return { content: [{ type: "text", text: textOf(res) }], isError: true };
-        return this.afterMove("browser_click", textOf(res));
+        if (!(await followOpenedTab(this.browser, before)))
+            return this.afterMove("browser_click", textOf(res));
+        this.host.emit({ type: "policy.decision", detail: { tool: "browser_click", class: "read", decision: "followed", reason: "opened_new_tab" } });
+        return this.afterMove("browser_click", `That click opened a new tab; the run now works in it. Take a browser_snapshot to read it.\n${textOf(res)}`);
     }
     /** The final Submit. Never under fill_and_review; once, gated and traced, under auto_submit. */
     async submit(forward, why = "terminal_label") {

package/dist/browser-runner/local-apply/follow-tab.js

@@ -0,0 +1,32 @@
+/**
+ * The tab a click OPENED (#1133).
+ *
+ * SEEK's "Apply" can open its sign-in in a NEW tab. Playwright MCP adds a popup to its tab list but keeps
+ * the current tab where it was (`_onPageCreated` sets `_currentTab` only when there is none), and the CLI
+ * may not switch tabs (`browser_tabs` is refused to it). So every page check after that click — landing,
+ * checkpoint, ready_for_review, all of #1100's sign-in detection — read the job ad the click started on,
+ * saw no sign-in, and the run ended `review.ready` count 0 (f63b2963, on runner 0.4.145, after #1100).
+ *
+ * The bridge therefore counts tabs around a page-changing click and selects one that appeared DURING it,
+ * so its checks read the page the click led to. Only a new tab: the profile is the owner's real browser,
+ * and a tab already open is theirs.
+ */
+export async function tabCount(browser) {
+    const res = await browser.callTool("browser_tabs", { action: "list" }).catch(() => null);
+    if (!res || res.isError)
+        return null;
+    const body = (res.content ?? []).map((c) => c.text ?? "").join("\n");
+    // Only the `### Result` section: Playwright MCP may repeat the same list under `### Open tabs`.
+    const result = /### Result\n([\s\S]*?)(?=\n### |$)/.exec(body)?.[1] ?? body;
+    return (result.match(/^- \d+:/gm) ?? []).length;
+}
+/** Select the newest tab when the count grew across a click; true when the run now works in it. */
+export async function followOpenedTab(browser, before) {
+    if (before === null)
+        return false;
+    const after = await tabCount(browser);
+    if (after === null || after <= before)
+        return false;
+    const selected = await browser.callTool("browser_tabs", { action: "select", index: after - 1 }).catch(() => null);
+    return !!selected && !selected.isError;
+}

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

@@ -48,6 +48,12 @@ const SAFE_ID = /^[A-Za-z0-9_.:-]{1,300}$/;
 const HASH = /^[a-f0-9]{64}$/;
 /** One application at a time per agent: two runs on one employer's form is how duplicates happen. */
 const MAX_ACTIVE = 1;
+/**
+ * Pauses that wait on a DECISION, not on the page (#1121): the owner's stored answer satisfies them on
+ * a fresh fill, so a run paused on one gives the machine back. Every other pause — sign-in, CAPTCHA,
+ * consent, a redirect, the supervisor's checkpoint — needs this exact live page and keeps it.
+ */
+const PARKABLE_PAUSES = new Set(["missing_answer", "screening_ambiguity"]);
 class Blocked extends Error {
     reason;
     questions;
@@ -554,6 +560,21 @@ export class LocalApplyRuntime {
     pause(run, p) {
         if (run.state === "ended" || run.cancelled)
             return Promise.resolve("stopped");
+        // #1121: a question only the owner can answer does not need this page — park it. The run ENDS
+        // `blocked` with the question, the browser and the CLI stop, and the machine's one slot is free
+        // for the next application. The owner's answer is stored (#1079) and re-fills this application
+        // from a fresh page, with the answer as a source. Never once a submit was attempted: that run
+        // must not be filled again (#1013, #1073), so it keeps holding the slot and its page.
+        if (run.state === "running" && PARKABLE_PAUSES.has(p.reason) && !run.bridge?.submitAttempted) {
+            this.emit(run, { type: "run.paused", pauseReason: p.reason });
+            this.end(run, {
+                outcome: "blocked",
+                blockReason: p.reason,
+                questions: p.question ? [p.question] : [],
+                summary: "Parked for the owner's answer; this machine was freed. Nothing was submitted.",
+            });
+            return Promise.resolve("stopped");
+        }
         if (run.state === "running") {
             run.activeMs += this.now() - run.activeSince;
             run.state = "paused";

package/dist/browser-runner/test-chromium.js

@@ -0,0 +1,29 @@
+/**
+ * Launch Chromium for a test that runs real DOM — after making sure Chromium is installed.
+ *
+ * In CI the browsers are installed AFTER the unit + integration step (ci.yml). The binary those tests
+ * use arrives mid-run, because `LocalRunner` installs it on first launch (`ensureChromiumInstalled`,
+ * `runner-browser.test.ts`). A file that called `chromium.launch()` on its own passed only if vitest
+ * happened to schedule it after that download finished. `masked-page-screenshot.test.ts` (#1067) lost
+ * that race on every CI run from 98b25b98: "Executable doesn't exist … chrome-headless-shell", 1.7s
+ * before the download completed. `inspect-page.test.ts` won it by scheduling luck.
+ *
+ * So this runs the same idempotent `playwright install chromium` the runner runs. It is a quick check
+ * when the binary is present, and Playwright's own install lock makes a concurrent install wait rather
+ * than collide. `PAGS_SKIP_PLAYWRIGHT_INSTALL=1` skips it, as it does for the runner. Test-only.
+ */
+import { spawnSync } from "node:child_process";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { chromium } from "playwright";
+let installed = false;
+export async function launchTestChromium() {
+    if (!installed && process.env.PAGS_SKIP_PLAYWRIGHT_INSTALL !== "1") {
+        const cli = join(dirname(createRequire(import.meta.url).resolve("playwright")), "cli.js");
+        const r = spawnSync(process.execPath, [cli, "install", "chromium"], { stdio: "inherit", env: process.env });
+        if (r.status !== 0)
+            throw new Error("`playwright install chromium` failed — real-DOM tests cannot run without it.");
+        installed = true;
+    }
+    return chromium.launch();
+}

package/package.json

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