@proagentstore/cli 0.4.144 → 0.4.146

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/coding/inspect.js

@@ -1,3 +1,4 @@
+import { globMatches, isGlob } from "./path-glob.js";
 import { execFileSync } from "node:child_process";
 import { existsSync, readdirSync, readFileSync, realpathSync, statSync } from "node:fs";
 import { relative, resolve, sep } from "node:path";
@@ -331,9 +332,12 @@ export function repoSearch(workDir, opts) {
     const lines = out.split("\n").filter((l) => l !== "");
     if (mode === "path") {
         // The pattern never reaches git here — the filter is a plain case-insensitive substring
-        // over the path, which is what "find the file called X" actually means.
-        const all = lines.filter((p) => p.toLowerCase().includes(pattern.toLowerCase())).map((p) => ({ path: p }));
-        return { mode, pattern, matches: all.slice(0, limit), shown: Math.min(all.length, limit), total: all.length, truncated: all.length > limit };
+        // over the path, which is what "find the file called X" actually means. A `glob` (#1070) is
+        // matched instead, over the WHOLE list, so `total` counts real matches, not the literal's.
+        const glob = (opts.glob ?? "").trim();
+        const useGlob = glob !== "" && isGlob(glob);
+        const all = lines.filter((p) => (useGlob ? globMatches(glob, p) : p.toLowerCase().includes(pattern.toLowerCase()))).map((p) => ({ path: p }));
+        return { mode, pattern, matches: all.slice(0, limit), shown: Math.min(all.length, limit), total: all.length, truncated: all.length > limit, ...(useGlob ? { glob: true } : {}) };
     }
     const all = lines.map(parseGrepLine).filter((m) => m !== null);
     const perFile = new Map();

package/dist/browser-runner/coding/path-glob.js

@@ -0,0 +1,82 @@
+/**
+ * Glob patterns over repo-relative paths, for `repo_find` (#1070).
+ *
+ * `repo_find` matched its pattern as a plain substring, so `*.test.js` returned NOTHING — no path
+ * contains an asterisk — and an agent concluded a repository with ~90 test files had none. Silent false
+ * negatives are the failure; this is the matcher that ends them.
+ *
+ * Semantics (gitignore/ripgrep-like, case-insensitive like the substring search it extends):
+ *   `*`    any run of characters within ONE path segment (never a `/`)
+ *   `**`   any run across segments; `**` followed by `/` also matches zero folders
+ *   `?`    one character, not `/`
+ *   `[ab]` `[a-z]` `[!ab]`  a character class (`!` negates), never `/`
+ * A pattern WITHOUT a `/` matches any single segment — a file name or a folder name at any depth, a
+ * folder matching taking everything beneath it — so `*.test.js` and `*e2e*` mean what they mean in a
+ * shell or `rg -g`. A pattern WITH a `/` is anchored at the repository root (`src/*.ts`,
+ * `**\/handlers/*.js`); a leading `/` or `./` is accepted and means the same.
+ *
+ * DUPLICATED in `workers/api/src/lib/path-glob.ts`: the cloud filters with it when the runner is too old
+ * to (an old runner ignores `glob`). `workers/api/src/lib/path-glob.parity.test.ts` holds the two equal.
+ */
+/** Does this pattern use glob syntax? A pattern without any is the plain substring search, unchanged. */
+export function isGlob(pattern) {
+    return /[*?[]/.test(pattern);
+}
+function toRegExp(glob) {
+    let re = "";
+    for (let i = 0; i < glob.length; i++) {
+        const c = glob[i];
+        if (c === "*") {
+            if (glob[i + 1] === "*") {
+                i++;
+                if (glob[i + 1] === "/") {
+                    i++;
+                    re += "(?:.*/)?";
+                }
+                else
+                    re += ".*";
+            }
+            else
+                re += "[^/]*";
+        }
+        else if (c === "?")
+            re += "[^/]";
+        else if (c === "[") {
+            const end = glob.indexOf("]", i + 2);
+            if (end === -1) {
+                re += "\\[";
+                continue;
+            }
+            let body = glob.slice(i + 1, end).replace(/[\\^\]]/g, "\\$&");
+            const negate = body.startsWith("!");
+            if (negate)
+                body = body.slice(1);
+            re += `(?!/)[${negate ? "^" : ""}${body}]`;
+            i = end;
+        }
+        else
+            re += c.replace(/[.+^${}()|\\\]/]/g, "\\$&");
+    }
+    return new RegExp(`^${re}$`, "i");
+}
+/** Does `path` (repo-relative, `/`-separated) match `glob`? */
+export function globMatches(glob, path) {
+    const g = glob.trim().replace(/^\.?\/+/, "").replace(/\/+$/, "");
+    if (!g)
+        return false;
+    const re = toRegExp(g);
+    if (g.includes("/"))
+        return re.test(path);
+    return path.split("/").some((segment) => re.test(segment));
+}
+/**
+ * The longest run of literal text a match MUST contain — what an old runner's substring search is given,
+ * so the glob filter then runs over a superset that cannot have dropped a match. `""` when there is none
+ * (`*`, `**`, `???`): nothing literal to search by.
+ */
+export function globLiteral(glob) {
+    // Normalised exactly as `globMatches` normalises, or `./src/*.ts` would ask for "./src", which no path contains.
+    const pieces = glob.trim().replace(/^\.?\/+/, "").split(/\[[^\]]*\]|[*?]+/);
+    const longest = pieces.reduce((a, b) => (b.length > a.length ? b : a), "");
+    return longest.replace(/^\/+|\/+$/g, "");
+}

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/package.json

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