@proagentstore/cli 0.4.1 → 0.4.3

package/dist/browser-runner/runner.js

@@ -680,6 +680,45 @@ export class LocalRunner {
         const head = (cut >= 0 ? text.slice(0, cut) : text).replace(/```[a-z]*\n?|```/g, " ").replace(/\s+/g, " ").trim();
         return head.slice(0, 400);
     }
+    /**
+     * After a WRITE action, read the field's REAL value back via the standard
+     * browser_evaluate tool (evaluates on the element by ref — no reinvented DOM
+     * traversal). Masked/intl fields transform input (e.g. "0404453580" → "+61404453580"),
+     * so without this signal the brain can't tell the value "took" and oscillates
+     * between formats. Returns the prompt's expected "…now reads…" / "REJECTED…" line.
+     * Never throws — best-effort feedback.
+     */
+    async readBackField(mcp, action) {
+        if (!action.ref)
+            return "";
+        const fn = "el => ({ v: el.value !== undefined ? String(el.value) : (el.getAttribute('aria-checked') ?? el.textContent ?? '').trim(), " +
+            "bad: el.getAttribute('aria-invalid') === 'true' || !!(el.validity && !el.validity.valid), " +
+            "msg: el.validationMessage || '' })";
+        const res = await mcp.callTool("browser_evaluate", { element: action.name || "field", target: action.ref, function: fn }).catch(() => null);
+        if (!res || res.isError)
+            return "";
+        const txt = mcp.textOf(res);
+        const i = txt.indexOf("### Result");
+        if (i < 0)
+            return "";
+        const after = txt.slice(i + "### Result".length).trim();
+        const end = after.indexOf("\n###");
+        const block = (end >= 0 ? after.slice(0, end) : after).trim();
+        let parsed;
+        try {
+            parsed = JSON.parse(block);
+        }
+        catch {
+            return "";
+        }
+        if (typeof parsed?.v !== "string")
+            return "";
+        const name = action.name || "field";
+        const shown = parsed.v.length > 80 ? `${parsed.v.slice(0, 80)}…` : parsed.v;
+        if (parsed.bad)
+            return `⚠ "${name}" REJECTED: now reads "${shown}"${parsed.msg ? ` — ${parsed.msg.slice(0, 80)}` : ""}`;
+        return `"${name}" now reads "${shown}"`;
+    }
     /** The snapshot ref the brain must target the element by (standard-tool `target`). */
     refOf(action) {
         const ref = (action.ref || "").trim();
@@ -712,8 +751,7 @@ export class LocalRunner {
                 return mcp.callTool("browser_select_option", { element: label, target: this.refOf(a), values: [a.text ?? ""] });
             case "key":
                 return mcp.callTool("browser_press_key", { key: a.key || "Enter" });
-            case "scroll":
-                return mcp.callTool("browser_evaluate", { function: `() => window.scrollBy(0, ${Math.round(a.dy ?? 600)})` });
+            // scroll is handled before this mapper (mouse-wheel on the live page).
             case "wait":
                 return mcp.callTool("browser_wait_for", { time: Math.min(5, Math.max(0.1, (a.ms ?? 1000) / 1000)) });
             default:
@@ -764,6 +802,22 @@ export class LocalRunner {
         }
         if (this.applyResumePath)
             this.armFileAutoAttach(page, this.applyResumePath);
+        // Scroll is a VIEWPORT primitive, not an element action — no ref, no standard
+        // tool in @playwright/mcp 0.0.77. Use the mouse wheel on the live page (as the
+        // prior runtime did): it scrolls the actual hovered/inner scroll container,
+        // whereas window.scrollBy is a no-op on sites that scroll an inner panel (e.g.
+        // PageUp/Coles), which made the brain scroll-loop forever.
+        if (action.action === "scroll") {
+            await page.mouse.wheel(0, Math.round(action.dy ?? 600)).catch(() => undefined);
+            await page.waitForTimeout(300).catch(() => undefined);
+            const active = await this.getActivePage();
+            return {
+                ok: true,
+                url: active.url(),
+                title: await active.title().catch(() => ""),
+                challenge: await detectHumanChallenge(active),
+            };
+        }
         const mcp = await this.getMcp();
         const res = await this.callBrowserTool(mcp, action);
         const text = mcp.textOf(res).trim();
@@ -802,12 +856,21 @@ export class LocalRunner {
         if (action.action === "click" || action.action === "navigate" || action.action === "key") {
             await active.waitForLoadState("networkidle", { timeout: 3_500 }).catch(() => undefined);
         }
+        // For a WRITE, read the field's real value back (masked/intl fields transform
+        // input, e.g. "0404453580" → "+61404453580") so the brain knows it took and
+        // stops oscillating between formats — the signal inspectField used to give.
+        let feedback = this.conciseFeedback(text);
+        if (action.action === "type" || action.action === "select" || action.action === "check") {
+            const rb = await this.readBackField(mcp, action);
+            if (rb)
+                feedback = rb;
+        }
         return {
             ok: true,
             url: active.url(),
             title: await active.title().catch(() => ""),
             challenge: await detectHumanChallenge(active),
-            feedback: this.conciseFeedback(text) || undefined,
+            feedback: feedback || undefined,
         };
     }
     // ── Agent-driven application lifecycle (called by the remote Workflow brain) ──

package/package.json

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