@proagentstore/cli 0.3.2 → 0.3.4

package/dist/browser-runner/browser-actions.js

@@ -194,3 +194,69 @@ export async function performBrowserAction(page, action, clickRobustly, resumeFi
         }
     }
 }
+/**
+ * After a WRITE action (type/select/check), read back what the field actually
+ * holds now + any validation error rendered near it. This is the semantic
+ * feedback the brain otherwise lacks: `fill()` succeeding doesn't mean the value
+ * "took" (masked/intl widgets concatenate; validators reject a format). Returns a
+ * short human string for the action log, or "" when there's nothing notable.
+ * Never throws.
+ */
+export async function inspectField(page, action) {
+    if (action.action !== "type" && action.action !== "select" && action.action !== "check")
+        return "";
+    if (!action.name)
+        return "";
+    try {
+        const role = action.role;
+        let loc = role ? page.getByRole(role, { name: action.name }) : page.getByText(action.name, { exact: false });
+        loc = typeof action.nth === "number" ? loc.nth(action.nth) : loc.first();
+        const el = await loc.elementHandle({ timeout: 1_500 }).catch(() => null);
+        if (!el)
+            return "";
+        const info = await el
+            .evaluate((node) => {
+            const e = node;
+            const raw = typeof e.value === "string" ? e.value : (e.getAttribute("aria-checked") ?? e.textContent ?? "");
+            const value = String(raw).trim().slice(0, 120);
+            const invalid = e.getAttribute("aria-invalid") === "true" || (typeof e.matches === "function" && e.matches(":invalid"));
+            let err = "";
+            const rx = /invalid|required|must|valid|error|format|enter a|please/i;
+            const describedby = e.getAttribute("aria-describedby");
+            if (describedby) {
+                for (const id of describedby.split(/\s+/)) {
+                    const d = document.getElementById(id);
+                    const t = (d?.textContent || "").trim();
+                    if (t && rx.test(t)) {
+                        err = t;
+                        break;
+                    }
+                }
+            }
+            if (!err) {
+                const scope = e.closest("[class*=field], [class*=form-group], [class*=form-item], fieldset") || e.parentElement;
+                const cand = scope?.querySelector('[role="alert"], [class*=error i], [class*=invalid i], [class*=danger i], [class*=help-block i]');
+                const t = (cand?.textContent || "").trim();
+                if (t && rx.test(t) && t.length < 180)
+                    err = t;
+            }
+            return { value, invalid, err: err.replace(/\s+/g, " ").slice(0, 180) };
+        })
+            .catch(() => null);
+        if (!info)
+            return "";
+        const typed = String(action.text ?? "").trim();
+        const parts = [];
+        if (info.err)
+            parts.push(`⚠ "${action.name}" REJECTED: "${info.err}"`);
+        if (info.value && (info.invalid || info.err || (typed && info.value !== typed))) {
+            parts.push(`"${action.name}" now reads "${info.value}"${typed && info.value !== typed ? ` (you sent "${typed}")` : ""}`);
+        }
+        if (info.invalid && !info.err)
+            parts.push(`"${action.name}" is marked invalid`);
+        return parts.join("; ");
+    }
+    catch {
+        return "";
+    }
+}

package/dist/browser-runner/index.js

@@ -55,6 +55,17 @@ Endpoints:
     process.exit(0);
 }
 const config = configFromArgs();
+// SECURITY: the runner's endpoints spawn CLIs and drive a browser as the user.
+// Without a token, `authorize()` allows every request, so a tokenless runner must
+// never be reachable off the local machine. Refuse to start if bound to a
+// non-loopback address without a token. (`pags up` always generates one; this
+// only guards the low-level binary run manually with --host 0.0.0.0 and no token.)
+const LOOPBACK = new Set(["127.0.0.1", "localhost", "::1", "[::1]"]);
+if (!config.token && !LOOPBACK.has(config.host)) {
+    process.stderr.write(`Refusing to start: --host ${config.host} exposes the runner off-machine with no --token. ` +
+        `Set --token (or PAGS_RUNNER_TOKEN), or bind to 127.0.0.1.\n`);
+    process.exit(1);
+}
 const started = await startRunnerServer(config);
 process.stdout.write(`FAGS browser runtime listening at ${started.url}\n`);
 process.stdout.write(`Data dir: ${config.dataDir}\n`);

package/dist/browser-runner/runner.js

@@ -5,7 +5,7 @@ import { basename, dirname, join, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
 import { captureScreenshotDataUrl, challengeSolved, detectHumanChallenge } from "./challenge.js";
 import { resolveRealChromeProfileDir, seedProfileCopy } from "./browser-profile.js";
-import { performBrowserAction } from "./browser-actions.js";
+import { inspectField, performBrowserAction } from "./browser-actions.js";
 import { HumanHandoffError, RunnerInputError } from "./errors.js";
 import { RunnerStore } from "./store.js";
 import { CodingRuntime } from "./coding/runtime.js";
@@ -664,11 +664,15 @@ export class LocalRunner {
         if (action.action === "click" || action.action === "navigate" || action.action === "key") {
             await active.waitForLoadState("networkidle", { timeout: 3_500 }).catch(() => undefined);
         }
+        // Read back what a write action actually did (real field value + any validation
+        // error) so the brain gets semantic feedback, not just "Playwright didn't throw".
+        const feedback = await inspectField(active, action).catch(() => "");
         return {
             ok: true,
             url: active.url(),
             title: await active.title().catch(() => ""),
             challenge: await detectHumanChallenge(active),
+            feedback: feedback || undefined,
         };
     }
     /**

package/dist/index.js

@@ -824,7 +824,8 @@ async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force =
     }
   }
   for (const id of instanceIds) {
-    openRelaySocket(id, apiBase, pagsToken, localUrl, runnerToken, force);
+    const mintToken = () => requestPags("POST", `/v1/relay/${apiPathSegment(id)}/token`, { ...opts, pagsToken }, {}).then((r) => r.token);
+    openRelaySocket(id, apiBase, mintToken, localUrl, runnerToken, force);
   }
   writeLine("Runtime registered with PAGS \u2713");
   writeLine("");
@@ -844,11 +845,24 @@ async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force =
   };
   heartbeat();
 }
-function openRelaySocket(instanceId, wsBase, pagsToken, localUrl, runnerToken, force = false) {
+function openRelaySocket(instanceId, wsBase, mintToken, localUrl, runnerToken, force = false) {
   let backoffMs = 1e3;
   let reconnecting = false;
-  const connect = () => {
-    const url = `${wsBase}/v1/relay/${encodeURIComponent(instanceId)}/connect?token=${encodeURIComponent(pagsToken)}${force ? "&force=1" : ""}`;
+  const connect = async () => {
+    let relayToken;
+    try {
+      relayToken = await mintToken();
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      const hint = /401|token|sign/i.test(msg) ? " (run `pags login`)" : "";
+      writeLine(`Relay token mint failed: ${instanceId.slice(0, 8)}\u2026${hint} \u2014 retrying in ${Math.round(backoffMs / 1e3)}s`);
+      setTimeout(() => {
+        connect();
+      }, backoffMs);
+      backoffMs = Math.min(backoffMs * 2, 3e4);
+      return;
+    }
+    const url = `${wsBase}/v1/relay/${encodeURIComponent(instanceId)}/connect?token=${encodeURIComponent(relayToken)}${force ? "&force=1" : ""}`;
     const ws = new WebSocket(url);
     ws.onopen = () => {
       backoffMs = 1e3;

package/package.json

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