@petukhovart/agent-view 0.12.0 → 0.13.1

package/.claude-plugin/plugin.json

@@ -1,21 +1,21 @@
-{
-  "name": "agent-view",
-  "description": "Visual verification CLI for desktop apps (Electron/Tauri/Browser) via Chrome DevTools Protocol. Ships the verify skill: run DOM, screenshot, eval, watch, console and log-feed checks against a live app.",
-  "version": "0.12.0",
-  "keywords": [
-    "cdp",
-    "electron",
-    "tauri",
-    "desktop",
-    "testing",
-    "accessibility",
-    "screenshot",
-    "automation"
-  ],
-  "author": {
-    "name": "PetukhovArt"
-  },
-  "homepage": "https://github.com/PetukhovArt/agent-view",
-  "repository": "https://github.com/PetukhovArt/agent-view",
-  "license": "MIT"
-}
+{
+  "name": "agent-view",
+  "description": "Visual verification CLI for desktop apps (Electron/Tauri/Browser) via Chrome DevTools Protocol. Ships the verify skill: run DOM, screenshot, eval, watch, console and log-feed checks against a live app.",
+  "version": "0.13.0",
+  "keywords": [
+    "cdp",
+    "electron",
+    "tauri",
+    "desktop",
+    "testing",
+    "accessibility",
+    "screenshot",
+    "automation"
+  ],
+  "author": {
+    "name": "PetukhovArt"
+  },
+  "homepage": "https://github.com/PetukhovArt/agent-view",
+  "repository": "https://github.com/PetukhovArt/agent-view",
+  "license": "MIT"
+}

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2026 Artem Petukhov
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2026 Artem Petukhov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -154,6 +154,8 @@ The daemon is why `dom → click → dom` runs in ~17ms total: one persistent CD
 | `console`     | `console.log` + `Log.entryAdded` per page **and per worker**, with `--follow --until <pattern>`. |
 | `logs`        | Durable file feed of page + worker console, surviving reloads and worker restarts. `tail --grep/--since/--level`, `clear`, plus re-injecting `--probe` scripts. |
 | `network`     | Request/response timeline, headers, timing, bodies, and WebSocket/SSE frames. Filters: `--url`, `--method`, `--status`, `--type`. Captures page-load traffic. |
+| `upload`      | Puts files into a file input — no picker opens. `--selector` reaches the hidden inputs that have no ref. |
+| `dialog`      | JS modals are answered automatically so they cannot freeze the run; sets the answer, and pre-answers native file pickers with `arm`. |
 | `wait`        | Block until an element appears (default 10s).                                            |
 | `scene`       | WebGL scene graph (PixiJS today, engine-pluggable). `--compact` and `--diff` mirror `dom`. |
 | `snap`        | DOM + scene + optional screenshot in one call.                                           |
@@ -320,7 +322,7 @@ Full form with all optional fields:
 | `consoleTargets`    | no       | Target types `agent-view console` auto-attaches to on first call. Any subset of `["page", "iframe", "shared_worker", "service_worker", "worker"]`. Default `["page", "shared_worker", "service_worker"]` |
 | `captureBody`       | no       | `true` to capture response bodies and request payloads for `agent-view network`. Off by default; opt-in since bodies can carry tokens/PII. WebSocket frame payloads are visible regardless              |
 | `networkBufferSize` | no       | Per-target network ring capacity. Positive integer. Default `200` (smaller than console — entries are heavier)                                                                                         |
-| `logFile`           | no       | Feed file for `agent-view logs`. Relative paths resolve against the project root. Default `.agent-view/console.log` (gitignore it)                                                                     |
+| `logFile`           | no       | Feed file for `agent-view logs`. Relative paths resolve against the project root. Default `.agent-view/console.log` (gitignore it). Keep it per-checkout: two ports recording into one file is refused                                                                     |
 | `logMaxBytes`       | no       | Feed size cap in bytes; on overflow it rotates once to `<file>.prev`. Default `8388608` (8 MB)                                                                                                         |
 
 ---
@@ -396,6 +398,44 @@ agent-view drag --from 5 --to 9 --steps 20 --hold-ms 150
 
 `--steps` (default 10) controls intermediate `mouseMoved` events so libraries that throttle on movement deltas still see continuous motion. `--hold-ms` inserts a pause between press and the first move (some libs require >100ms for touch-style activation). `--button` accepts `left|right|middle`.
 
+### `upload`
+
+Puts files into a file input through CDP `DOM.setFileInputFiles`. No picker opens, so there is nothing to arm and nothing to close.
+
+```bash
+agent-view upload --selector "#file-input" --file ./fixtures/a.png
+agent-view upload --selector "#images" --file ./a.png --file ./b.png   # multi-select input
+agent-view upload --ref 12 --file ./a.png
+```
+
+`--selector` is the flag you will usually want: upload inputs are almost always hidden (`display:none`, `class="d-none"`, `v-show="false"`) and clicked from code, which keeps them out of the accessibility tree — so `dom` never prints a `[ref=N]` for them. There is deliberately no `--filter`: an accessible name resolves to the label or the button carrying it, not to the `<input type=file>` behind it. Paths resolve against the current directory and must be real files; CDP accepts a missing path or a directory without complaint and the app then reads an empty file.
+
+### `dialog`
+
+Everything modal. JS modals are answered automatically — this command is how you change that answer, inspect what happened, and pre-answer native file pickers.
+
+```bash
+agent-view dialog                            # standing answer + log of modals and pickers
+agent-view dialog policy accept              # confirm() → true from now on
+agent-view dialog policy accept --text "hi"  # prompt() → "hi"
+agent-view dialog policy dismiss             # back to the default
+agent-view dialog accept | dismiss           # answer the one open right now
+agent-view dialog arm --file ./a.png         # pre-answer the next native file picker
+agent-view dialog arm --cancel               # …as if the user pressed Cancel
+agent-view dialog disarm                     # let real pickers open again
+```
+
+**JS modals.** `connectToPage` enables the CDP `Page` domain, and Chromium then stops showing `alert`/`confirm`/`prompt`/`beforeunload` natively — it blocks the renderer until the client answers. Every page session therefore answers on its own; the default is dismiss. `beforeunload` is always dismissed regardless of the policy: accepting it would navigate away mid-run and lose the state under inspection. Each one is written to the console feed as `[agent-view] confirm auto-dismissed: <message>`, which is how you explain a `confirm()` that returned `false` for no visible reason. `dialog accept` / `dialog dismiss` handle the one case the policy cannot: a modal that was already open before agent-view attached, which produced no event.
+
+**Native file pickers.** `dialog arm` holds an answer ready so the picker never opens, and arms two engines at once — CDP file-chooser interception for webview pickers, and a `window.__TAURI_INTERNALS__.invoke` shim for `@tauri-apps/plugin-dialog`, whose dialog runs in Rust past the webview where CDP cannot reach it. Use it for the input that is created and removed inside the click handler; a selector cannot address that one. Otherwise prefer `upload`.
+
+Two rules that bite:
+
+- **Arm before the click.** A picker cannot be caught once open. The arm is one-shot: the first picker spends it and interception turns itself off, so a later click opens a real OS dialog.
+- **Click with `agent-view click`, not `eval "el.click()"`.** Chromium refuses to open a file picker without user activation, and an eval-driven click has none — the picker is silently dropped and never intercepted.
+
+Out of reach: `showOpenFilePicker()` (File System Access API) exposes no input to fill and can only be cancelled; Electron does not implement `window.prompt`; a native dialog opened from an Electron **main** process is invisible to CDP.
+
 ### `screenshot`
 
 Captures a screenshot, saves to temp dir, prints the file path. PNG by default; WebP (q=80) when `--scale` is set (JPEG fallback for older Chrome/Electron).

package/dist/cdp/console-stream.d.ts

@@ -0,0 +1,35 @@
+import type { RuntimeSession, ConsoleMessage, ConsoleLevel, TargetType } from './types.js';
+export type ConsoleStreamOptions = {
+    /** Per-target ring size. Default 500. */
+    capacity?: number;
+};
+export type ConsoleFilter = {
+    since?: number;
+    level?: ReadonlySet<ConsoleLevel>;
+    targetId?: string;
+};
+export type StampedConsoleMessage = ConsoleMessage & {
+    targetId: string;
+    targetType: TargetType;
+};
+/**
+ * Multi-target console subscription with per-target ring buffer.
+ * Server owns one instance for its lifetime; commands attach/drain.
+ */
+export declare class ConsoleStream {
+    private readonly capacity;
+    private readonly targets;
+    private readonly extraSubscribers;
+    constructor(opts?: ConsoleStreamOptions);
+    get attachedCount(): number;
+    /** Idempotent per target id — second attach for same id is a no-op. */
+    attach(session: RuntimeSession): void;
+    detach(targetId?: string): void;
+    clear(targetId?: string): void;
+    /** Snapshot of buffered messages, sorted by timestamp (oldest first). */
+    drain(filter?: ConsoleFilter): StampedConsoleMessage[];
+    /** Subscribe to live messages. Returns disposer. Used by --follow streaming. */
+    subscribe(handler: (msg: StampedConsoleMessage) => void): () => void;
+    private snapshot;
+}
+//# sourceMappingURL=console-stream.d.ts.map

package/dist/cdp/console-stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"console-stream.d.ts","sourceRoot":"","sources":["../../src/cdp/console-stream.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAI1F,MAAM,MAAM,oBAAoB,GAAG;IACjC,yCAAyC;IACzC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB,CAAA;AAED,MAAM,MAAM,aAAa,GAAG;IAC1B,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,KAAK,CAAC,EAAE,WAAW,CAAC,YAAY,CAAC,CAAA;IACjC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB,CAAA;AAED,MAAM,MAAM,qBAAqB,GAAG,cAAc,GAAG;IACnD,QAAQ,EAAE,MAAM,CAAA;IAChB,UAAU,EAAE,UAAU,CAAA;CACvB,CAAA;AAUD;;;GAGG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAQ;IACjC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAoC;IAC5D,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAkD;gBAEvE,IAAI,GAAE,oBAAyB;IAI3C,IAAI,aAAa,IAAI,MAAM,CAE1B;IAED,uEAAuE;IACvE,MAAM,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI;IA6BrC,MAAM,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI;IAY/B,KAAK,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI;IAc9B,yEAAyE;IACzE,KAAK,CAAC,MAAM,GAAE,aAAkB,GAAG,qBAAqB,EAAE;IAe1D,gFAAgF;IAChF,SAAS,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,qBAAqB,KAAK,IAAI,GAAG,MAAM,IAAI;IAKpE,OAAO,CAAC,QAAQ;CAIjB"}

package/dist/cdp/console-stream.js

@@ -0,0 +1,103 @@
+const DEFAULT_CAPACITY = 500;
+/**
+ * Multi-target console subscription with per-target ring buffer.
+ * Server owns one instance for its lifetime; commands attach/drain.
+ */
+export class ConsoleStream {
+    capacity;
+    targets = new Map();
+    extraSubscribers = new Set();
+    constructor(opts = {}) {
+        this.capacity = opts.capacity ?? DEFAULT_CAPACITY;
+    }
+    get attachedCount() {
+        return this.targets.size;
+    }
+    /** Idempotent per target id — second attach for same id is a no-op. */
+    attach(session) {
+        const id = session.target.id;
+        if (this.targets.has(id))
+            return;
+        const entry = {
+            session,
+            ring: new Array(this.capacity),
+            cursor: 0,
+            full: false,
+            dispose: () => { },
+        };
+        entry.dispose = session.onConsole((msg) => {
+            const stamped = {
+                ...msg,
+                targetId: id,
+                targetType: session.target.type,
+            };
+            entry.ring[entry.cursor] = stamped;
+            entry.cursor = (entry.cursor + 1) % this.capacity;
+            if (entry.cursor === 0)
+                entry.full = true;
+            for (const sub of this.extraSubscribers) {
+                try {
+                    sub(stamped);
+                }
+                catch { /* ignore */ }
+            }
+        });
+        this.targets.set(id, entry);
+    }
+    detach(targetId) {
+        if (targetId === undefined) {
+            for (const t of this.targets.values())
+                t.dispose();
+            this.targets.clear();
+            return;
+        }
+        const t = this.targets.get(targetId);
+        if (!t)
+            return;
+        t.dispose();
+        this.targets.delete(targetId);
+    }
+    clear(targetId) {
+        if (targetId === undefined) {
+            for (const t of this.targets.values()) {
+                t.cursor = 0;
+                t.full = false;
+            }
+            return;
+        }
+        const t = this.targets.get(targetId);
+        if (!t)
+            return;
+        t.cursor = 0;
+        t.full = false;
+    }
+    /** Snapshot of buffered messages, sorted by timestamp (oldest first). */
+    drain(filter = {}) {
+        const result = [];
+        for (const [id, entry] of this.targets) {
+            if (filter.targetId && filter.targetId !== id)
+                continue;
+            const msgs = this.snapshot(entry);
+            for (const m of msgs) {
+                if (filter.since !== undefined && m.ts < filter.since)
+                    continue;
+                if (filter.level && !filter.level.has(m.level))
+                    continue;
+                result.push(m);
+            }
+        }
+        result.sort((a, b) => a.ts - b.ts);
+        return result;
+    }
+    /** Subscribe to live messages. Returns disposer. Used by --follow streaming. */
+    subscribe(handler) {
+        this.extraSubscribers.add(handler);
+        return () => this.extraSubscribers.delete(handler);
+    }
+    snapshot(entry) {
+        if (!entry.full)
+            return entry.ring.slice(0, entry.cursor);
+        return [...entry.ring.slice(entry.cursor), ...entry.ring.slice(0, entry.cursor)];
+    }
+}
+//# sourceMappingURL=console-stream.js.map

package/dist/cdp/console-stream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"console-stream.js","sourceRoot":"","sources":["../../src/cdp/console-stream.ts"],"names":[],"mappings":"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"}

package/dist/cdp/transport.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transport.d.ts","sourceRoot":"","sources":["../../src/cdp/transport.ts"],"names":[],"mappings":"AAEA,OAAO,EAWL,KAAK,SAAS,EAId,KAAK,UAAU,EACf,KAAK,cAAc,EACnB,KAAK,WAAW,EAOjB,MAAM,YAAY,CAAA;AACnB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AA4BhD,qBAAa,eAAgB,SAAQ,KAAK;gBAC5B,OAAO,EAAE,MAAM;CAI5B;AAmCD,wBAAsB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC,CAkBpE;AAED,wBAAsB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC,CAQ9E;AA4YD,wBAAsB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,GAAG,OAAO,CAAC,cAAc,CAAC,CA2BhG;AAED,wBAAsB,aAAa,CACjC,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,UAAU,EAClB,KAAK,EAAE,WAAW,GACjB,OAAO,CAAC,WAAW,CAAC,CA6PtB"}
+{"version":3,"file":"transport.d.ts","sourceRoot":"","sources":["../../src/cdp/transport.ts"],"names":[],"mappings":"AAEA,OAAO,EAaL,KAAK,SAAS,EAId,KAAK,UAAU,EACf,KAAK,cAAc,EACnB,KAAK,WAAW,EAWjB,MAAM,YAAY,CAAA;AACnB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AA4BhD,qBAAa,eAAgB,SAAQ,KAAK;gBAC5B,OAAO,EAAE,MAAM;CAI5B;AAmCD,wBAAsB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC,CAkBpE;AAED,wBAAsB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC,CAQ9E;AAoqBD,wBAAsB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,GAAG,OAAO,CAAC,cAAc,CAAC,CA2BhG;AAED,wBAAsB,aAAa,CACjC,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,UAAU,EAClB,KAAK,EAAE,WAAW,GACjB,OAAO,CAAC,WAAW,CAAC,CA2StB"}

package/dist/cdp/transport.js

@@ -1,6 +1,6 @@
 // @ts-expect-error no types available for chrome-remote-interface
 import CDP from 'chrome-remote-interface';
-import { TargetType, ConsoleLevel, ConsoleSource, EvaluationError, MouseButton, NetworkEventKind, NetworkResourceType, } from './types.js';
+import { TargetType, ConsoleLevel, ConsoleSource, EvaluationError, MouseButton, NetworkEventKind, NetworkResourceType, JsDialogType, FileChooserMode, } from './types.js';
 // CDP hosts to try: IPv4 first, then IPv6 (WebView2/Tauri often listens on ::1)
 const CDP_HOSTS = ['127.0.0.1', '::1'];
 // Maps targetId → host for connection routing
@@ -185,6 +185,228 @@ function attachConsoleSubscription(client) {
         },
     };
 }
+/** Dialogs are rare; a short tail is enough to explain a surprising `confirm()` result. */
+const MAX_TRACKED_DIALOGS = 20;
+const DIALOG_TYPES = new Set(Object.values(JsDialogType));
+function dialogTypeFrom(raw) {
+    return raw && DIALOG_TYPES.has(raw) ? raw : JsDialogType.Alert;
+}
+function dialogNotice(dialog, accept) {
+    const verb = accept ? 'auto-accepted' : 'auto-dismissed';
+    const body = dialog.message ? `: ${dialog.message}` : '';
+    return {
+        ts: Date.now(),
+        level: ConsoleLevel.Warn,
+        source: ConsoleSource.Log,
+        text: `[agent-view] ${dialog.type} ${verb}${body}`,
+    };
+}
+/**
+ * Answers JS dialogs so the renderer never stalls.
+ *
+ * While the Page domain is enabled Chromium stops showing the native dialog and
+ * waits for `Page.handleJavaScriptDialog` instead — with no client answer the
+ * page hangs forever. Since `connectToPage` always enables Page, every page
+ * session must own this. The standing policy dismisses; `setPolicy` changes it.
+ */
+function attachJsDialogSubscription(Page, notice) {
+    const handlers = new Set();
+    const seen = [];
+    let policy = { accept: false };
+    let pending = null;
+    async function send(accept, promptText, automatic) {
+        const params = { accept };
+        if (promptText !== undefined)
+            params.promptText = promptText;
+        const answered = pending;
+        pending = null;
+        try {
+            await Page.handleJavaScriptDialog(params);
+        }
+        catch (err) {
+            // Only the dialog this call was answering may be restored: a later one
+            // may already have taken the slot, and overwriting it would make the
+            // session answer the wrong dialog next time.
+            if (pending === null)
+                pending = answered;
+            throw err;
+        }
+        if (answered) {
+            answered.answer = { accept, promptText, automatic };
+            return;
+        }
+        // A blind answer — the dialog opened before agent-view attached, so no
+        // opening event created a record. Without this the one scenario the manual
+        // command exists for leaves no trace in `dialog status`.
+        record({
+            ts: Date.now(),
+            type: JsDialogType.Alert,
+            message: '(opened before agent-view attached)',
+            url: '',
+            answer: { accept, promptText, automatic },
+        });
+    }
+    function record(dialog) {
+        seen.push(dialog);
+        if (seen.length > MAX_TRACKED_DIALOGS)
+            seen.shift();
+        return dialog;
+    }
+    Page.javascriptDialogOpening((params) => {
+        const dialog = {
+            ts: Date.now(),
+            type: dialogTypeFrom(params.type),
+            message: params.message ?? '',
+            defaultPrompt: params.defaultPrompt,
+            url: params.url ?? '',
+        };
+        pending = dialog;
+        record(dialog);
+        for (const handler of handlers) {
+            try {
+                handler(dialog);
+            }
+            catch { /* one bad handler shouldn't break others */ }
+        }
+        // `beforeunload` is not a question about the app's own state, it is a
+        // question about leaving the page. Accepting it would navigate away in the
+        // middle of a verification run and lose everything under inspection, so the
+        // standing answer — which exists to make `confirm()` return true — does not
+        // reach it. Staying put is always the recoverable outcome.
+        const accept = dialog.type === JsDialogType.BeforeUnload ? false : policy.accept;
+        const promptText = accept ? policy.promptText : undefined;
+        void send(accept, promptText, true)
+            .then(() => notice(dialogNotice(dialog, accept)))
+            .catch(() => { });
+    });
+    return {
+        add(handler) {
+            handlers.add(handler);
+            return () => handlers.delete(handler);
+        },
+        /**
+         * Sent even with nothing pending: a dialog opened before agent-view attached
+         * never produced an opening event, and answering blind is the only way out.
+         */
+        answer: (accept, promptText) => send(accept, promptText, false),
+        setPolicy: (next) => { policy = next; },
+        getPolicy: () => policy,
+        recent: () => [...seen],
+    };
+}
+/**
+ * Intercepts the native file chooser and answers it from the armed value.
+ *
+ * Interception stays off until something is armed: turning it on unconditionally
+ * would suppress a chooser the user actually wanted to see, and the app would
+ * look broken. Arming is one-shot for the same reason — a standing intercept
+ * silently changes behaviour long after the command that set it.
+ */
+function attachFileChooserSubscription(Page, setFiles, dispatchCancel, notice) {
+    const seen = [];
+    let armed = null;
+    const record = (event) => {
+        seen.push(event);
+        if (seen.length > MAX_TRACKED_DIALOGS)
+            seen.shift();
+        return event;
+    };
+    Page.fileChooserOpened((params) => {
+        const pending = armed;
+        armed = null;
+        const event = record({
+            ts: Date.now(),
+            mode: params.mode === FileChooserMode.Multiple ? FileChooserMode.Multiple : FileChooserMode.Single,
+            matchedInput: params.backendNodeId !== undefined,
+            answer: 'unanswered',
+        });
+        /**
+         * Answering is async, so a fresh `arm` can land while this one is still in
+         * flight. Turning interception off then would kill the new arm and let the
+         * next chooser open as a real OS window, while `fileChooserArm()` still
+         * reports it armed — so only the arm that is still current disarms.
+         */
+        const disarm = () => {
+            if (armed !== null)
+                return Promise.resolve();
+            return Page.setInterceptFileChooserDialog({ enabled: false }).catch(() => { });
+        };
+        const cancelOnPage = (backendNodeId, outcome) => {
+            // Suppressing the chooser is not enough: the page is waiting on
+            // `input.oncancel`, and Chromium's own cancel path does not deliver it
+            // here. Without this event the app waits for a user who will never come.
+            void dispatchCancel(backendNodeId)
+                .then(() => notice(chooserNotice(outcome)))
+                .catch((err) => notice(chooserNotice(`cancel could not be delivered: ${errText(err)}`)))
+                .finally(() => disarm());
+        };
+        if (!pending || pending.kind === 'cancel') {
+            event.answer = 'cancel';
+            if (params.backendNodeId !== undefined) {
+                cancelOnPage(params.backendNodeId, 'cancelled');
+                return;
+            }
+            notice(chooserNotice('cancelled'));
+            void disarm();
+            return;
+        }
+        if (params.backendNodeId === undefined) {
+            // Nothing to attach files to. The chooser is already suppressed, so the
+            // call resolves as a cancel — say so instead of reporting a fake success.
+            event.answer = 'cancel';
+            notice(chooserNotice('cancelled — chooser had no file input (File System Access API)'));
+            void disarm();
+            return;
+        }
+        const { backendNodeId } = params;
+        void setFiles(backendNodeId, pending.files)
+            .then(() => {
+            event.answer = 'files';
+            event.files = pending.files;
+            notice(chooserNotice(`answered with ${pending.files.length} file(s)`));
+            void disarm();
+        })
+            .catch((err) => {
+            // The chooser is suppressed either way, so failing to attach the files
+            // must still produce an answer — otherwise the page waits forever,
+            // which is the exact hang this feature exists to prevent.
+            event.answer = 'cancel';
+            cancelOnPage(backendNodeId, `files could not be attached (${errText(err)}), cancelled instead`);
+        });
+    });
+    return {
+        async arm(next) {
+            armed = next;
+            // Interception only suppresses the chooser; what the page sees afterwards
+            // is decided here, not by Chromium's own `cancel` flag.
+            await Page.setInterceptFileChooserDialog(next ? { enabled: true, cancel: false } : { enabled: false });
+        },
+        current: () => armed,
+        recent: () => [...seen],
+        /**
+         * A new document means the click the arm was meant for will never happen.
+         * Leaving it live would answer some later, unrelated chooser — the standing
+         * intercept that one-shot arming exists to avoid.
+         */
+        forget() {
+            if (armed === null)
+                return;
+            armed = null;
+            void Page.setInterceptFileChooserDialog({ enabled: false }).catch(() => { });
+        },
+    };
+}
+function errText(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+function chooserNotice(outcome) {
+    return {
+        ts: Date.now(),
+        level: ConsoleLevel.Warn,
+        source: ConsoleSource.Log,
+        text: `[agent-view] file chooser intercepted, ${outcome}`,
+    };
+}
 const CDP_RESOURCE_TYPE_MAP = {
     Document: NetworkResourceType.Document,
     Stylesheet: NetworkResourceType.Stylesheet,
@@ -446,6 +668,14 @@ export async function connectToPage(port, target, cache) {
     // Subscribe BEFORE enable so we catch buffered console/log entries emitted at enable-time.
     const consoleSub = attachConsoleSubscription(client);
     const networkSub = attachNetworkSubscription(client.Network);
+    const jsDialogSub = attachJsDialogSubscription(Page, consoleSub.emit);
+    const fileChooserSub = attachFileChooserSubscription(Page, (backendNodeId, files) => DOM.setFileInputFiles({ backendNodeId, files }).then(() => undefined), async (backendNodeId) => {
+        const { object } = await DOM.resolveNode({ backendNodeId });
+        await Runtime.callFunctionOn({
+            objectId: object.objectId,
+            functionDeclaration: `function() { this.dispatchEvent(new Event('cancel')) }`,
+        });
+    }, consoleSub.emit);
     const onDisconnect = attachDisconnectSubscription(client);
     let documentBackendNodeId = 0;
     await bringUpSession(client, target, async () => {
@@ -464,6 +694,7 @@ export async function connectToPage(port, target, cache) {
     let webpSupported = null;
     Page.frameNavigated(async () => {
         cache.invalidate(cacheKey);
+        fileChooserSub.forget();
         try {
             const { root: newRoot } = await DOM.getDocument({ depth: 0 });
             documentBackendNodeId = newRoot.backendNodeId;
@@ -522,10 +753,10 @@ export async function connectToPage(port, target, cache) {
         const { object } = await DOM.resolveNode({ backendNodeId });
         const climbed = await Runtime.callFunctionOn({
             objectId: object.objectId,
-            functionDeclaration: `function(levels) {
-        let el = this.nodeType === Node.TEXT_NODE ? this.parentElement : this;
-        for (let i = 0; i < levels && el.parentElement; i++) el = el.parentElement;
-        return el;
+            functionDeclaration: `function(levels) {
+        let el = this.nodeType === Node.TEXT_NODE ? this.parentElement : this;
+        for (let i = 0; i < levels && el.parentElement; i++) el = el.parentElement;
+        return el;
       }`,
             arguments: [{ value: levels }],
         });
@@ -555,6 +786,14 @@ export async function connectToPage(port, target, cache) {
         onNetwork: (handler) => networkSub.add(handler),
         enableNetwork: () => networkSub.enable(),
         getResponseBody: (requestId) => networkSub.getResponseBody(requestId),
+        onJsDialog: (handler) => jsDialogSub.add(handler),
+        answerJsDialog: (accept, promptText) => jsDialogSub.answer(accept, promptText),
+        setJsDialogPolicy: (policy) => jsDialogSub.setPolicy(policy),
+        getJsDialogPolicy: () => jsDialogSub.getPolicy(),
+        recentJsDialogs: () => jsDialogSub.recent(),
+        armFileChooser: (arm) => fileChooserSub.arm(arm),
+        fileChooserArm: () => fileChooserSub.current(),
+        recentFileChoosers: () => fileChooserSub.recent(),
         async getAccessibilityTree() {
             const cached = cache.get(cacheKey);
             if (cached)
@@ -641,18 +880,40 @@ export async function connectToPage(port, target, cache) {
         async dragBetweenPositions(from, to, opts) {
             await dispatchDrag(from, to, opts);
         },
+        async uploadByNodeId(backendNodeId, files) {
+            await DOM.setFileInputFiles({ backendNodeId, files });
+        },
+        async uploadBySelector(selector, files) {
+            // Addressed by objectId rather than nodeId: `DOM.querySelector` needs a
+            // document nodeId, and the document node is re-numbered on every
+            // navigation. A RemoteObject from the page skips that bookkeeping.
+            const { result, exceptionDetails } = await Runtime.evaluate({
+                expression: `document.querySelector(${JSON.stringify(selector)})`,
+                returnByValue: false,
+            });
+            // A malformed selector throws, and the thrown DOMException comes back as
+            // a perfectly good RemoteObject — without this check it would be passed
+            // to setFileInputFiles as if it were the matched node.
+            if (exceptionDetails) {
+                throw new EvaluationError(`Invalid selector ${JSON.stringify(selector)}`);
+            }
+            if (!result.objectId || result.subtype === 'null')
+                return false;
+            await DOM.setFileInputFiles({ objectId: result.objectId, files });
+            return true;
+        },
         async fillByNodeId(backendNodeId, value) {
             const { object } = await DOM.resolveNode({ backendNodeId });
             await DOM.focus({ backendNodeId });
             await Runtime.callFunctionOn({
                 objectId: object.objectId,
-                functionDeclaration: `function(val) {
-          const nativeSetter = Object.getOwnPropertyDescriptor(window.HTMLInputElement.prototype, 'value')?.set
-            || Object.getOwnPropertyDescriptor(window.HTMLTextAreaElement.prototype, 'value')?.set;
-          if (nativeSetter) nativeSetter.call(this, val);
-          else this.value = val;
-          this.dispatchEvent(new Event('input', { bubbles: true }));
-          this.dispatchEvent(new Event('change', { bubbles: true }));
+                functionDeclaration: `function(val) {
+          const nativeSetter = Object.getOwnPropertyDescriptor(window.HTMLInputElement.prototype, 'value')?.set
+            || Object.getOwnPropertyDescriptor(window.HTMLTextAreaElement.prototype, 'value')?.set;
+          if (nativeSetter) nativeSetter.call(this, val);
+          else this.value = val;
+          this.dispatchEvent(new Event('input', { bubbles: true }));
+          this.dispatchEvent(new Event('change', { bubbles: true }));
         }`,
                 arguments: [{ value }],
             });