@proagentstore/cli 0.4.145 → 0.4.147

package/dist/browser-runner/challenge.js

@@ -1,3 +1,4 @@
+import { maskedPageScreenshot } from "./local-browser/replay.js";
 /**
  * Detect an anti-bot human challenge on the page (reCAPTCHA, hCaptcha,
  * Cloudflare Turnstile, generic captcha). These can't be solved by the model,
@@ -74,13 +75,13 @@ export async function challengeSolved(page) {
     })
         .catch(() => false);
 }
-/** Capture a downscaled JPEG screenshot as a data URL for the human-takeover UI. */
+/**
+ * Capture a downscaled JPEG screenshot as a data URL for the human-takeover UI — the STILL stored with a
+ * handoff. Form controls are blurred first and no still is kept when that cannot be confirmed (#1067): a
+ * handoff can be raised mid-form, and the person acts through the live takeover view (which is not
+ * blurred — it is the control surface), never through this preview.
+ */
 export async function captureScreenshotDataUrl(page) {
-    try {
-        const buf = await page.screenshot({ type: "jpeg", quality: 55 });
-        return `data:image/jpeg;base64,${buf.toString("base64")}`;
-    }
-    catch {
-        return undefined;
-    }
+    const shot = await maskedPageScreenshot(page, { quality: 55, timeout: 8_000 });
+    return shot ? `data:image/jpeg;base64,${shot}` : undefined;
 }

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-browser/replay.js

@@ -19,6 +19,29 @@ export const MASK_FORM_CONTROLS = `() => {
 	return document.getElementById(${JSON.stringify(MASK_ID)}) ? "masked" : "unmasked";
 }`;
 export const UNMASK_FORM_CONTROLS = `() => { const s = document.getElementById(${JSON.stringify(MASK_ID)}); if (s) s.remove(); return "unmasked"; }`;
+/**
+ * The same form-control policy for a Playwright `Page` (#1067) — the legacy workflow browser tasks
+ * (`runtime_task`: JOB_APPLY / BROWSER_TASK), whose per-action frames were taken with nothing blurred,
+ * so a step that had just typed a phone number stored it in plain pixels. Blur, capture, unblur — and
+ * NO frame (undefined) when the blur cannot be confirmed, exactly as {@link ShotRecorder.capture}. The
+ * unblur runs even when the capture throws, so a failed frame never leaves the page blurred.
+ */
+export async function maskedPageScreenshot(page, opts) {
+    try {
+        if ((await page.evaluate(`(${MASK_FORM_CONTROLS})()`)) !== "masked")
+            return undefined;
+        try {
+            const buf = await page.screenshot({ type: "jpeg", quality: opts.quality, scale: "css", timeout: opts.timeout });
+            return buf.toString("base64");
+        }
+        finally {
+            await page.evaluate(`(${UNMASK_FORM_CONTROLS})()`).catch(() => undefined);
+        }
+    }
+    catch {
+        return undefined;
+    }
+}
 const textOf = (r) => (r.content ?? []).map((c) => c.text ?? "").join("\n");
 export class ShotRecorder {
     cap;

package/dist/browser-runner/runner.js

@@ -16,6 +16,7 @@ import { RunnerStore } from "./store.js";
 import { CodingRuntime } from "./coding/runtime.js";
 import { LocalBrowserRuntime } from "./local-browser/runtime.js";
 import { LOCAL_BROWSER_TASK_TYPE } from "./local-browser/contract.js";
+import { maskedPageScreenshot } from "./local-browser/replay.js";
 import { LocalArtifactRuntime } from "./local-artifact/runtime.js";
 import { LOCAL_ARTIFACT_TASK_TYPE } from "./local-artifact/contract.js";
 import { LocalApplyRuntime } from "./local-apply/runtime.js";
@@ -908,17 +909,13 @@ export class LocalRunner {
         return head.slice(0, 400);
     }
     /** A small JPEG screenshot (base64, no data: prefix) of the page — one per action,
-     *  so the cloud can store it per step and the whole run can be replayed visually. */
+     *  so the cloud can store it per step and the whole run can be replayed visually.
+     *  Form controls are BLURRED first, and no frame is kept when that cannot be confirmed (#1067) —
+     *  the Scout/Runner replay policy (#1063), which this legacy path used to skip.
+     *  scale:"css" avoids 2× retina bloat; a short timeout means a stuck page never delays the
+     *  action (the screenshot is best-effort, not the point). */
     async shot(page) {
-        try {
-            // scale:"css" avoids 2× retina bloat; a short timeout means a stuck page
-            // never delays the action (the screenshot is best-effort, not the point).
-            const buf = await page.screenshot({ type: "jpeg", quality: 45, scale: "css", timeout: 8_000 });
-            return buf.toString("base64");
-        }
-        catch {
-            return undefined;
-        }
+        return maskedPageScreenshot(page, { quality: 45, timeout: 8_000 });
     }
     /**
      * After a WRITE action, read the field's REAL value back via the standard

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.145",
+  "version": "0.4.147",
   "description": "CLI for creating, publishing, and running ProAgentStore agents",
   "license": "MIT",
   "type": "module",