@aexol/spectral 0.8.7 → 0.8.10

package/dist/extensions/browser/stream/signaling-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signaling-client.d.ts","sourceRoot":"","sources":["../../../../src/extensions/browser/stream/signaling-client.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,MAAM,WAAW,qBAAqB;IACpC,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,KAAK,CAAC;QAChB,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;QACxB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,UAAU,CAAC,EAAE,MAAM,CAAC;KACrB,CAAC,CAAC;CACJ;AAED,qBAAa,eAAe;IAKxB,OAAO,CAAC,QAAQ,CAAC,MAAM;IAJzB,OAAO,CAAC,EAAE,CAA0B;IACpC,OAAO,CAAC,SAAS,CAAS;gBAGP,MAAM,EAAE,qBAAqB;IAG1C,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAgC9B,OAAO,CAAC,aAAa;IAWrB,IAAI,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAMzC,KAAK,IAAI,IAAI;IAQb,WAAW,IAAI,OAAO;CAGvB"}

package/dist/extensions/browser/stream/signaling-client.js

@@ -0,0 +1,69 @@
+/**
+ * Stream signaling client — connects to the backend WebSocket endpoint
+ * for WebRTC signaling relay.
+ *
+ * The backend only relays SDP offers/answers and ICE candidates between
+ * the streamer (this extension) and viewers. No media passes through.
+ */
+import WebSocket from "ws";
+export class SignalingClient {
+    config;
+    ws = null;
+    connected = false;
+    constructor(config) {
+        this.config = config;
+    }
+    async connect() {
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => reject(new Error("Signaling connection timeout")), 10_000);
+            this.ws = new WebSocket(this.config.signalingUrl);
+            this.ws.on("open", () => {
+                clearTimeout(timeout);
+                this.connected = true;
+                this.ws.send(JSON.stringify({
+                    type: "create-session",
+                    sessionId: this.config.sessionId,
+                }));
+                resolve();
+            });
+            this.ws.on("error", (err) => {
+                clearTimeout(timeout);
+                reject(err);
+            });
+            this.ws.on("message", (data) => {
+                try {
+                    const msg = JSON.parse(data.toString());
+                    this.handleMessage(msg);
+                }
+                catch {
+                    // Ignore malformed messages
+                }
+            });
+        });
+    }
+    handleMessage(msg) {
+        // Messages are primarily forwarded to the in-browser WebRTC client
+        // via page.evaluate(). This client just logs them.
+        if (msg.type === "viewer-joined") {
+            process.stderr.write(`[browser-stream] Viewer joined: ${msg.viewerId}\n`);
+        }
+        if (msg.type === "viewer-left") {
+            process.stderr.write(`[browser-stream] Viewer left: ${msg.viewerId}\n`);
+        }
+    }
+    send(data) {
+        if (this.ws && this.connected) {
+            this.ws.send(JSON.stringify(data));
+        }
+    }
+    close() {
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+            this.connected = false;
+        }
+    }
+    isConnected() {
+        return this.connected;
+    }
+}

package/dist/extensions/browser/stream/stream-injector.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Stream injector — WebRTC code injected into the browser page.
+ *
+ * When browser_stream_start is called, this code is injected via
+ * page.addInitScript() and page.evaluate(). It captures the page
+ * visually and streams it via WebRTC through the signaling server.
+ *
+ * Approach: canvas.captureStream() at 15 FPS.
+ * The canvas mirrors the visible viewport content.
+ */
+import type { Page } from "playwright";
+export interface StreamInjectConfig {
+    signalingUrl: string;
+    sessionId: string;
+    iceServers: Array<{
+        urls: string | string[];
+        username?: string;
+        credential?: string;
+    }>;
+}
+/**
+ * Inject WebRTC streaming code into a Playwright page.
+ * Uses addInitScript so it's present on every navigation.
+ */
+export declare function injectStreamingCode(page: Page, config: StreamInjectConfig): Promise<void>;
+/**
+ * Stop the WebRTC stream and clean up injected code.
+ */
+export declare function stopStreaming(page: Page): Promise<void>;
+//# sourceMappingURL=stream-injector.d.ts.map

package/dist/extensions/browser/stream/stream-injector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream-injector.d.ts","sourceRoot":"","sources":["../../../../src/extensions/browser/stream/stream-injector.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAEvC,MAAM,WAAW,kBAAkB;IACjC,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,KAAK,CAAC;QAChB,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;QACxB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,UAAU,CAAC,EAAE,MAAM,CAAC;KACrB,CAAC,CAAC;CACJ;AAED;;;GAGG;AACH,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,IAAI,EACV,MAAM,EAAE,kBAAkB,GACzB,OAAO,CAAC,IAAI,CAAC,CA0If;AAED;;GAEG;AACH,wBAAsB,aAAa,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAM7D"}

package/dist/extensions/browser/stream/stream-injector.js

@@ -0,0 +1,161 @@
+/**
+ * Stream injector — WebRTC code injected into the browser page.
+ *
+ * When browser_stream_start is called, this code is injected via
+ * page.addInitScript() and page.evaluate(). It captures the page
+ * visually and streams it via WebRTC through the signaling server.
+ *
+ * Approach: canvas.captureStream() at 15 FPS.
+ * The canvas mirrors the visible viewport content.
+ */
+/**
+ * Inject WebRTC streaming code into a Playwright page.
+ * Uses addInitScript so it's present on every navigation.
+ */
+export async function injectStreamingCode(page, config) {
+    const iceServersJson = JSON.stringify(config.iceServers);
+    await page.addInitScript(`
+    (() => {
+      if (window.__spectralStreamInstalled) return;
+      window.__spectralStreamInstalled = true;
+
+      const SIGNALING_URL = ${JSON.stringify(config.signalingUrl)};
+      const SESSION_ID = ${JSON.stringify(config.sessionId)};
+      const ICE_SERVERS = ${iceServersJson};
+
+      let pc = null;
+      let localStream = null;
+      let ws = null;
+      let canvas = null;
+      let animationId = null;
+
+      window.__spectralStreamStart = async function() {
+        try {
+          // Connect signaling WebSocket
+          ws = new WebSocket(SIGNALING_URL);
+
+          await new Promise((resolve, reject) => {
+            ws.onopen = () => {
+              ws.send(JSON.stringify({ type: "streamer-join", sessionId: SESSION_ID }));
+              resolve();
+            };
+            ws.onerror = reject;
+          });
+
+          // Capture viewport via canvas
+          canvas = document.createElement("canvas");
+          canvas.width = window.innerWidth;
+          canvas.height = window.innerHeight;
+          const ctx = canvas.getContext("2d");
+
+          localStream = canvas.captureStream(15); // 15 FPS
+
+          // Draw a simple visualization frame
+          function drawFrame() {
+            if (!ctx) return;
+            // Background
+            ctx.fillStyle = "#1a1a2e";
+            ctx.fillRect(0, 0, canvas.width, canvas.height);
+            // Status text
+            ctx.fillStyle = "#ffffff";
+            ctx.font = "20px monospace";
+            ctx.fillText("Spectral Browser Stream", 20, 40);
+            ctx.fillStyle = "#a0a0c0";
+            ctx.font = "14px monospace";
+            ctx.fillText("URL: " + window.location.href, 20, 70);
+            ctx.fillText("Time: " + new Date().toISOString(), 20, 90);
+            animationId = requestAnimationFrame(drawFrame);
+          }
+          drawFrame();
+
+          // Listen for viewer join messages
+          ws.onmessage = async (event) => {
+            const msg = JSON.parse(event.data);
+
+            if (msg.type === "viewer-joined") {
+              await createOfferForViewer(msg.viewerId);
+            }
+
+            if (msg.type === "answer") {
+              const desc = new RTCSessionDescription(msg.sdp);
+              await pc.setRemoteDescription(desc);
+            }
+
+            if (msg.type === "ice-candidate") {
+              try {
+                const candidate = new RTCIceCandidate(msg.candidate);
+                await pc.addIceCandidate(candidate);
+              } catch (e) {
+                console.warn("[spectral-stream] ICE candidate error:", e);
+              }
+            }
+          };
+
+          async function createOfferForViewer(viewerId) {
+            pc = new RTCPeerConnection({ iceServers: ICE_SERVERS });
+
+            for (const track of localStream.getTracks()) {
+              pc.addTrack(track, localStream);
+            }
+
+            pc.onicecandidate = (e) => {
+              if (e.candidate && ws?.readyState === WebSocket.OPEN) {
+                ws.send(JSON.stringify({
+                  type: "ice-candidate",
+                  sessionId: SESSION_ID,
+                  receiverId: viewerId,
+                  candidate: e.candidate.toJSON(),
+                }));
+              }
+            };
+
+            const offer = await pc.createOffer();
+            await pc.setLocalDescription(offer);
+
+            if (ws?.readyState === WebSocket.OPEN) {
+              ws.send(JSON.stringify({
+                type: "offer",
+                sessionId: SESSION_ID,
+                receiverId: viewerId,
+                sdp: pc.localDescription.toJSON(),
+              }));
+            }
+          }
+
+          console.log("[spectral-stream] Streaming started — canvas capture at 15 FPS");
+        } catch (err) {
+          console.error("[spectral-stream] Failed to start:", err);
+        }
+      };
+
+      window.__spectralStreamStop = function() {
+        if (animationId) cancelAnimationFrame(animationId);
+        if (pc) { pc.close(); pc = null; }
+        if (localStream) {
+          localStream.getTracks().forEach(t => t.stop());
+          localStream = null;
+        }
+        if (ws) { ws.close(); ws = null; }
+        if (canvas) { canvas.remove(); canvas = null; }
+        window.__spectralStreamInstalled = false;
+        console.log("[spectral-stream] Streaming stopped");
+      };
+    })();
+  `);
+    // Trigger if page already loaded
+    await page.evaluate(() => {
+        if (window.__spectralStreamStart) {
+            window.__spectralStreamStart();
+        }
+    });
+}
+/**
+ * Stop the WebRTC stream and clean up injected code.
+ */
+export async function stopStreaming(page) {
+    await page.evaluate(() => {
+        if (window.__spectralStreamStop) {
+            window.__spectralStreamStop();
+        }
+    });
+}

package/dist/extensions/browser/stream/stream-tool.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Stream tools: browser_stream_start, browser_stream_stop, browser_stream_status.
+ *
+ * These extend the browser extension with WebRTC streaming capability
+ * so that remote viewers can watch the browser content in real time.
+ */
+import type { ExtensionAPI } from "../../../sdk/coding-agent/index.js";
+import { BrowserService } from "../browser-service.js";
+export declare function registerStreamTools(ext: ExtensionAPI, bs: BrowserService): void;
+//# sourceMappingURL=stream-tool.d.ts.map

package/dist/extensions/browser/stream/stream-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream-tool.d.ts","sourceRoot":"","sources":["../../../../src/extensions/browser/stream/stream-tool.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAkB,MAAM,oCAAoC,CAAC;AACvF,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAYvD,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,YAAY,EAAE,EAAE,EAAE,cAAc,GAAG,IAAI,CA2L/E"}

package/dist/extensions/browser/stream/stream-tool.js

@@ -0,0 +1,182 @@
+/**
+ * Stream tools: browser_stream_start, browser_stream_stop, browser_stream_status.
+ *
+ * These extend the browser extension with WebRTC streaming capability
+ * so that remote viewers can watch the browser content in real time.
+ */
+import { SignalingClient } from "./signaling-client.js";
+import { injectStreamingCode, stopStreaming } from "./stream-injector.js";
+let activeStream = null;
+export function registerStreamTools(ext, bs) {
+    const startTool = {
+        name: "browser_stream_start",
+        label: "Start Browser Stream",
+        description: "Start streaming the browser content via WebRTC. " +
+            "Returns a sessionId that viewers can use to connect through the backend signaling server. " +
+            "The stream uses canvas capture at 15 FPS — not a full screen mirror, but a live visualization. " +
+            "Use browser_stream_stop when done.",
+        promptSnippet: "`browser_stream_start { url }` — start streaming the browser to viewers",
+        parameters: {
+            type: "object",
+            properties: {
+                url: {
+                    type: "string",
+                    description: "Optional initial URL to navigate to before starting the stream.",
+                },
+            },
+        },
+        async execute(_toolCallId, params) {
+            const p = params;
+            if (activeStream) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Stream already active (session: ${activeStream.sessionId}). Use browser_stream_stop first.`,
+                        }],
+                    details: { isError: true },
+                };
+            }
+            try {
+                const { page } = await bs.ensureBrowser();
+                if (p.url) {
+                    await bs.navigate(p.url);
+                }
+                const signalingUrl = process.env.SPECTRAL_STREAM_SIGNALING_URL ?? "ws://localhost:4008/browser-stream";
+                const sessionId = crypto.randomUUID();
+                const iceServers = [
+                    { urls: "stun:stun.l.google.com:19302" },
+                    { urls: "stun:stun1.l.google.com:19302" },
+                    ...(process.env.SPECTRAL_TURN_URL
+                        ? [{
+                                urls: process.env.SPECTRAL_TURN_URL,
+                                username: process.env.SPECTRAL_TURN_USERNAME ?? "",
+                                credential: process.env.SPECTRAL_TURN_CREDENTIAL ?? "",
+                            }]
+                        : []),
+                ];
+                const signalingClient = new SignalingClient({
+                    signalingUrl,
+                    sessionId,
+                    iceServers,
+                });
+                await signalingClient.connect();
+                await injectStreamingCode(page, {
+                    signalingUrl,
+                    sessionId,
+                    iceServers: [
+                        { urls: "stun:stun.l.google.com:19302" },
+                    ],
+                });
+                activeStream = {
+                    sessionId,
+                    signalingClient,
+                    startedAt: Date.now(),
+                };
+                return {
+                    content: [{
+                            type: "text",
+                            text: [
+                                `✓ Browser stream started`,
+                                `Session ID: ${sessionId}`,
+                                `Signaling URL: ${signalingUrl}`,
+                                ``,
+                                `Viewers connect via: ${signalingUrl}?session=${sessionId}`,
+                                ``,
+                                `Use these tools to control the stream:`,
+                                `- browser_stream_stop: stop streaming`,
+                                `- browser_stream_status: check stream status`,
+                                `- browser_navigate: navigate to a different URL`,
+                                `- browser_evaluate: execute JS in the streamed page`,
+                            ].join("\n"),
+                        }],
+                    details: { sessionId },
+                };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return {
+                    content: [{ type: "text", text: `Failed to start browser stream: ${msg}` }],
+                    details: { isError: true },
+                };
+            }
+        },
+    };
+    const stopTool = {
+        name: "browser_stream_stop",
+        label: "Stop Browser Stream",
+        description: "Stop the active browser stream and clean up WebRTC connections.",
+        promptSnippet: "`browser_stream_stop` — stop the active browser stream",
+        parameters: {
+            type: "object",
+            properties: {},
+        },
+        async execute() {
+            if (!activeStream) {
+                return {
+                    content: [{ type: "text", text: "No active stream." }],
+                    details: {},
+                };
+            }
+            try {
+                const page = bs.getActivePage();
+                await stopStreaming(page);
+            }
+            catch { /* ignore page-level errors */ }
+            try {
+                activeStream.signalingClient.close();
+            }
+            catch { /* ignore */ }
+            const duration = Math.round((Date.now() - activeStream.startedAt) / 1000);
+            const sessionId = activeStream.sessionId;
+            activeStream = null;
+            return {
+                content: [{
+                        type: "text",
+                        text: `✓ Stream stopped.\nSession: ${sessionId}\nDuration: ${duration}s`,
+                    }],
+                details: {},
+            };
+        },
+    };
+    const statusTool = {
+        name: "browser_stream_status",
+        label: "Browser Stream Status",
+        description: "Check the status of the current browser stream.",
+        promptSnippet: "`browser_stream_status` — check stream status",
+        parameters: {
+            type: "object",
+            properties: {},
+        },
+        async execute() {
+            if (!activeStream) {
+                return {
+                    content: [{ type: "text", text: "No active stream. Use browser_stream_start to begin." }],
+                    details: {},
+                };
+            }
+            const duration = Math.round((Date.now() - activeStream.startedAt) / 1000);
+            return {
+                content: [{
+                        type: "text",
+                        text: [
+                            `Stream active`,
+                            `Session ID: ${activeStream.sessionId}`,
+                            `Started: ${new Date(activeStream.startedAt).toISOString()}`,
+                            `Duration: ${duration}s`,
+                            `Signaling: ${activeStream.signalingClient.isConnected() ? "connected" : "disconnected"}`,
+                        ].join("\n"),
+                    }],
+                details: {},
+            };
+        },
+    };
+    for (const tool of [startTool, stopTool, statusTool]) {
+        try {
+            ext.registerTool(tool);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            process.stderr.write(`[browser-stream] Failed to register ${tool.name}: ${msg}\n`);
+        }
+    }
+}

package/dist/extensions/browser/tools/console.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Console messages tool: browser_console_messages.
+ */
+import type { ExtensionAPI } from "../../../sdk/coding-agent/index.js";
+import { BrowserService } from "../browser-service.js";
+export declare function registerConsoleTools(ext: ExtensionAPI, bs: BrowserService): void;
+//# sourceMappingURL=console.d.ts.map

package/dist/extensions/browser/tools/console.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"console.d.ts","sourceRoot":"","sources":["../../../../src/extensions/browser/tools/console.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAkB,MAAM,oCAAoC,CAAC;AACvF,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAEvD,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,YAAY,EAAE,EAAE,EAAE,cAAc,GAAG,IAAI,CAyDhF"}

package/dist/extensions/browser/tools/console.js

@@ -0,0 +1,54 @@
+/**
+ * Console messages tool: browser_console_messages.
+ */
+export function registerConsoleTools(ext, bs) {
+    const consoleTool = {
+        name: "browser_console_messages",
+        label: "Browser Console Messages",
+        description: "Returns all console messages from the browser. Each level includes messages of more severe levels.",
+        promptSnippet: "`browser_console_messages` — get browser console output",
+        parameters: {
+            type: "object",
+            properties: {
+                level: {
+                    type: "string",
+                    enum: ["error", "warning", "info", "debug"],
+                    description: "Minimum severity level to return. Default: info (returns info, warning, and error).",
+                },
+                all: {
+                    type: "boolean",
+                    description: "Return all messages since the start of the session, not just the current page. Default: false.",
+                },
+            },
+        },
+        async execute(_toolCallId, params) {
+            const p = params;
+            try {
+                const messages = bs.getConsoleMessages(p.level, p.all ?? false);
+                if (messages.length === 0) {
+                    return { content: [{ type: "text", text: "No console messages." }], details: {} };
+                }
+                const lines = messages.map((m) => `[${m.type.padEnd(7)}] ${m.text.slice(0, 300)}`);
+                const text = lines.join("\n");
+                return {
+                    content: [{
+                            type: "text",
+                            text: text.length > 20_000 ? text.slice(0, 20_000) + "\n\n[truncated]" : text,
+                        }],
+                    details: {},
+                };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { content: [{ type: "text", text: `Console messages failed: ${msg}` }], details: { isError: true } };
+            }
+        },
+    };
+    try {
+        ext.registerTool(consoleTool);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`[browser] Failed to register browser_console_messages: ${msg}\n`);
+    }
+}

package/dist/extensions/browser/tools/core.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Core browser tools: navigate, navigate_back, close, resize.
+ */
+import type { ExtensionAPI } from "../../../sdk/coding-agent/index.js";
+import { BrowserService } from "../browser-service.js";
+export declare function registerCoreTools(ext: ExtensionAPI, bs: BrowserService): void;
+//# sourceMappingURL=core.d.ts.map

package/dist/extensions/browser/tools/core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../../../../src/extensions/browser/tools/core.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAkB,MAAM,oCAAoC,CAAC;AACvF,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAEvD,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,YAAY,EAAE,EAAE,EAAE,cAAc,GAAG,IAAI,CA8G7E"}

package/dist/extensions/browser/tools/core.js

@@ -0,0 +1,115 @@
+/**
+ * Core browser tools: navigate, navigate_back, close, resize.
+ */
+export function registerCoreTools(ext, bs) {
+    const navigateTool = {
+        name: "browser_navigate",
+        label: "Browser Navigate",
+        description: "Navigate to a URL in the browser. Auto-prepends https:// if no protocol is given.",
+        promptSnippet: "`browser_navigate { url }` — navigate the browser to a URL",
+        parameters: {
+            type: "object",
+            properties: {
+                url: {
+                    type: "string",
+                    description: "The URL to navigate to. https:// is prepended automatically if missing.",
+                },
+            },
+            required: ["url"],
+        },
+        async execute(_toolCallId, params) {
+            const { url } = params;
+            if (!url || typeof url !== "string") {
+                return { content: [{ type: "text", text: "Error: url (string) is required." }], details: {} };
+            }
+            try {
+                const result = await bs.navigate(url);
+                return {
+                    content: [{ type: "text", text: `✓ Navigated to: ${result.url}\nTitle: ${result.title}` }],
+                    details: {},
+                };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { content: [{ type: "text", text: `Navigation failed: ${msg}` }], details: { isError: true } };
+            }
+        },
+    };
+    const navigateBackTool = {
+        name: "browser_navigate_back",
+        label: "Browser Navigate Back",
+        description: "Go back to the previous page in browser history.",
+        promptSnippet: "`browser_navigate_back` — go back one page",
+        parameters: {
+            type: "object",
+            properties: {},
+        },
+        async execute() {
+            try {
+                const result = await bs.navigateBack();
+                return {
+                    content: [{ type: "text", text: `✓ Went back to: ${result.url}\nTitle: ${result.title}` }],
+                    details: {},
+                };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { content: [{ type: "text", text: `Navigate back failed: ${msg}` }], details: { isError: true } };
+            }
+        },
+    };
+    const closeTool = {
+        name: "browser_close",
+        label: "Browser Close Page",
+        description: "Close the current page. A blank page is opened if it was the last one.",
+        promptSnippet: "`browser_close` — close the current browser page",
+        parameters: {
+            type: "object",
+            properties: {},
+        },
+        async execute() {
+            try {
+                await bs.closePage();
+                return { content: [{ type: "text", text: "✓ Page closed." }], details: {} };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { content: [{ type: "text", text: `Close failed: ${msg}` }], details: { isError: true } };
+            }
+        },
+    };
+    const resizeTool = {
+        name: "browser_resize",
+        label: "Browser Resize",
+        description: "Resize the browser viewport.",
+        promptSnippet: "`browser_resize { width, height }` — resize the browser viewport",
+        parameters: {
+            type: "object",
+            properties: {
+                width: { type: "number", description: "Width in pixels" },
+                height: { type: "number", description: "Height in pixels" },
+            },
+            required: ["width", "height"],
+        },
+        async execute(_toolCallId, params) {
+            const { width, height } = params;
+            try {
+                await bs.resize(width, height);
+                return { content: [{ type: "text", text: `✓ Viewport resized to ${width}x${height}.` }], details: {} };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { content: [{ type: "text", text: `Resize failed: ${msg}` }], details: { isError: true } };
+            }
+        },
+    };
+    for (const tool of [navigateTool, navigateBackTool, closeTool, resizeTool]) {
+        try {
+            ext.registerTool(tool);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            process.stderr.write(`[browser] Failed to register ${tool.name}: ${msg}\n`);
+        }
+    }
+}

package/dist/extensions/browser/tools/dialog.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Dialog tool: browser_handle_dialog.
+ *
+ * NOTE: BrowserService intercepts all dialogs globally and holds them
+ * until the agent handles them via this tool. This avoids Playwright's
+ * default auto-dismiss behavior.
+ */
+import type { ExtensionAPI } from "../../../sdk/coding-agent/index.js";
+import { BrowserService } from "../browser-service.js";
+export declare function registerDialogTools(ext: ExtensionAPI, bs: BrowserService): void;
+//# sourceMappingURL=dialog.d.ts.map

package/dist/extensions/browser/tools/dialog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dialog.d.ts","sourceRoot":"","sources":["../../../../src/extensions/browser/tools/dialog.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAkB,MAAM,oCAAoC,CAAC;AACvF,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAEvD,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,YAAY,EAAE,EAAE,EAAE,cAAc,GAAG,IAAI,CA8C/E"}