@aexol/spectral 0.8.7 → 0.8.9

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

@@ -0,0 +1,54 @@
+/**
+ * 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.
+ */
+export function registerDialogTools(ext, bs) {
+    const dialogTool = {
+        name: "browser_handle_dialog",
+        label: "Browser Handle Dialog",
+        description: "Handle a JavaScript dialog (alert, confirm, prompt) that appeared on the page. " +
+            "Call this AFTER performing an action that triggers a dialog.",
+        promptSnippet: "`browser_handle_dialog { accept, promptText }` — accept or dismiss a browser dialog",
+        parameters: {
+            type: "object",
+            properties: {
+                accept: {
+                    type: "boolean",
+                    description: "Whether to accept (true) or dismiss (false) the dialog.",
+                },
+                promptText: {
+                    type: "string",
+                    description: "Text to enter for prompt dialogs (only when accept is true).",
+                },
+            },
+            required: ["accept"],
+        },
+        async execute(_toolCallId, params) {
+            const p = params;
+            try {
+                const message = await bs.handleDialog(p.accept, p.promptText);
+                const action = p.accept
+                    ? (p.promptText ? `accepted with "${p.promptText}"` : "accepted")
+                    : "dismissed";
+                return {
+                    content: [{ type: "text", text: `✓ Dialog ${action}: "${message}"` }],
+                    details: {},
+                };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { content: [{ type: "text", text: `Dialog handling failed: ${msg}` }], details: { isError: true } };
+            }
+        },
+    };
+    try {
+        ext.registerTool(dialogTool);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`[browser] Failed to register browser_handle_dialog: ${msg}\n`);
+    }
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"drop.d.ts","sourceRoot":"","sources":["../../../../src/extensions/browser/tools/drop.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,CAuG7E"}

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

@@ -0,0 +1,93 @@
+/**
+ * Drop tool: browser_drop.
+ */
+export function registerDropTools(ext, bs) {
+    const dropTool = {
+        name: "browser_drop",
+        label: "Browser Drop",
+        description: "Drop files or MIME-typed data onto an element, as if dragged from outside the page. " +
+            "At least one of 'paths' or 'data' must be provided.",
+        promptSnippet: "`browser_drop { element, paths, data }` — drop files or data onto an element",
+        parameters: {
+            type: "object",
+            properties: {
+                element: {
+                    type: "string",
+                    description: "CSS selector of the drop target element.",
+                },
+                paths: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "File paths to drop onto the element.",
+                },
+                data: {
+                    type: "array",
+                    items: {
+                        type: "object",
+                        properties: {
+                            mimeType: { type: "string", description: "MIME type of the data (e.g. 'text/plain')." },
+                            content: { type: "string", description: "The data content." },
+                        },
+                        required: ["mimeType", "content"],
+                    },
+                    description: "MIME-typed data items to drop.",
+                },
+            },
+            required: ["element"],
+        },
+        async execute(_toolCallId, params) {
+            const p = params;
+            try {
+                const page = bs.getActivePage();
+                if (!p.paths && !p.data) {
+                    return {
+                        content: [{ type: "text", text: "Error: At least one of 'paths' or 'data' must be provided." }],
+                        details: { isError: true },
+                    };
+                }
+                // Dispatch the drag-and-drop via dataTransfer
+                await page.evaluate(({ element, paths, data }) => {
+                    const target = document.querySelector(element);
+                    if (!target)
+                        throw new Error(`Element not found: ${element}`);
+                    const dt = new DataTransfer();
+                    if (paths) {
+                        // Note: DataTransfer files from paths won't actually contain file data
+                        // in most browser contexts — use data for inline content instead
+                        for (const path of paths) {
+                            dt.items.add(path, "application/octet-stream");
+                        }
+                    }
+                    if (data) {
+                        for (const item of data) {
+                            dt.setData(item.mimeType, item.content);
+                        }
+                    }
+                    target.dispatchEvent(new DragEvent("drop", { dataTransfer: dt, bubbles: true }));
+                }, { element: p.element, paths: p.paths, data: p.data });
+                const droppedItems = [
+                    ...(p.paths ?? []).map((path) => `file: ${path}`),
+                    ...(p.data ?? []).map((d) => `${d.mimeType}: ${d.content.slice(0, 50)}`),
+                ];
+                return {
+                    content: [{
+                            type: "text",
+                            text: `✓ Dropped onto ${p.element}:\n${droppedItems.map((i) => `  - ${i}`).join("\n")}`,
+                        }],
+                    details: {},
+                };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { content: [{ type: "text", text: `Drop failed: ${msg}` }], details: { isError: true } };
+            }
+        },
+    };
+    try {
+        ext.registerTool(dropTool);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`[browser] Failed to register browser_drop: ${msg}\n`);
+    }
+}

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

@@ -0,0 +1,7 @@
+/**
+ * Evaluate tools: browser_evaluate, browser_run_code_unsafe.
+ */
+import type { ExtensionAPI } from "../../../sdk/coding-agent/index.js";
+import { BrowserService } from "../browser-service.js";
+export declare function registerEvaluateTools(ext: ExtensionAPI, bs: BrowserService): void;
+//# sourceMappingURL=evaluate.d.ts.map

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

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

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

@@ -0,0 +1,105 @@
+/**
+ * Evaluate tools: browser_evaluate, browser_run_code_unsafe.
+ */
+export function registerEvaluateTools(ext, bs) {
+    const evaluateTool = {
+        name: "browser_evaluate",
+        label: "Browser Evaluate",
+        description: "Evaluate a JavaScript expression on the page or on a specific element. " +
+            "Returns the result as JSON. Use this to read page state or interact with the DOM.",
+        promptSnippet: "`browser_evaluate { expression }` — run JS and get the result",
+        parameters: {
+            type: "object",
+            properties: {
+                expression: {
+                    type: "string",
+                    description: "JavaScript expression to evaluate. Use 'return' for complex logic. " +
+                        "Example: 'document.title' or 'Array.from(document.querySelectorAll(\"a\")).map(a => a.href)'",
+                },
+                ref: {
+                    type: "string",
+                    description: "Snapshot reference to evaluate on. If provided, expression runs on the element identified by this ref.",
+                },
+            },
+            required: ["expression"],
+        },
+        async execute(_toolCallId, params) {
+            const { expression } = params;
+            try {
+                const page = bs.getActivePage();
+                const result = await page.evaluate(expression);
+                if (result === undefined) {
+                    return { content: [{ type: "text", text: "undefined" }], details: {} };
+                }
+                const text = typeof result === "string"
+                    ? result
+                    : JSON.stringify(result, null, 2);
+                return {
+                    content: [{
+                            type: "text",
+                            text: text.length > 50000 ? text.slice(0, 50000) + "\n\n[truncated]" : text,
+                        }],
+                    details: {},
+                };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { content: [{ type: "text", text: `Evaluate failed: ${msg}` }], details: { isError: true } };
+            }
+        },
+    };
+    const runCodeTool = {
+        name: "browser_run_code_unsafe",
+        label: "Browser Run Code (Unsafe)",
+        description: "Run a Playwright code snippet in the Node.js server process. " +
+            "WARNING: This executes arbitrary JavaScript and is RCE-equivalent. " +
+            "Use only when browser_evaluate is insufficient.",
+        promptSnippet: "`browser_run_code_unsafe { code }` — run arbitrary Node.js+Playwright code",
+        parameters: {
+            type: "object",
+            properties: {
+                code: {
+                    type: "string",
+                    description: "A JavaScript function body that receives (page) as argument. " +
+                        "Example: 'await page.goto(\"https://example.com\"); return await page.title();'",
+                },
+            },
+            required: ["code"],
+        },
+        async execute(_toolCallId, params) {
+            const { code } = params;
+            try {
+                const page = bs.getActivePage();
+                // Create an async function from the code string with page in scope
+                const fn = new Function("page", `return (async () => { ${code} })()`);
+                const result = await fn(page);
+                if (result === undefined) {
+                    return { content: [{ type: "text", text: "undefined" }], details: {} };
+                }
+                const text = typeof result === "string"
+                    ? result
+                    : JSON.stringify(result, null, 2);
+                return {
+                    content: [{
+                            type: "text",
+                            text: text.length > 50000 ? text.slice(0, 50000) + "\n\n[truncated]" : text,
+                        }],
+                    details: {},
+                };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { content: [{ type: "text", text: `Run code failed: ${msg}` }], details: { isError: true } };
+            }
+        },
+    };
+    for (const tool of [evaluateTool, runCodeTool]) {
+        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/input.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Input tools: click, type, press_key, hover, drag, select_option, fill_form, file_upload.
+ */
+import type { ExtensionAPI } from "../../../sdk/coding-agent/index.js";
+import { BrowserService } from "../browser-service.js";
+export declare function registerInputTools(ext: ExtensionAPI, bs: BrowserService): void;
+//# sourceMappingURL=input.d.ts.map

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

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

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

@@ -0,0 +1,290 @@
+/**
+ * Input tools: click, type, press_key, hover, drag, select_option, fill_form, file_upload.
+ */
+export function registerInputTools(ext, bs) {
+    // ── browser_click ─────────────────────────────────────────────────
+    const clickTool = {
+        name: "browser_click",
+        label: "Browser Click",
+        description: "Click on an element identified by CSS selector or text match.",
+        promptSnippet: "`browser_click { element }` — click an element",
+        parameters: {
+            type: "object",
+            properties: {
+                element: { type: "string", description: "CSS selector or text to click." },
+                ref: { type: "string", description: "Snapshot reference (from browser_snapshot), ignored for CSS selectors." },
+                button: { type: "string", enum: ["left", "right", "middle"], description: "Mouse button. Default: left." },
+                modifiers: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Modifier keys: Alt, Control, Meta, Shift.",
+                },
+            },
+            required: ["element"],
+        },
+        async execute(_toolCallId, params) {
+            const p = params;
+            try {
+                const page = bs.getActivePage();
+                await page.click(p.element, {
+                    button: p.button ?? "left",
+                    modifiers: p.modifiers,
+                    timeout: 5000,
+                });
+                return { content: [{ type: "text", text: `✓ Clicked: ${p.element}` }], details: {} };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { content: [{ type: "text", text: `Click failed: ${msg}` }], details: { isError: true } };
+            }
+        },
+    };
+    // ── browser_type ──────────────────────────────────────────────────
+    const typeTool = {
+        name: "browser_type",
+        label: "Browser Type",
+        description: "Type text into an editable element.",
+        promptSnippet: "`browser_type { element, text }` — type text into an element",
+        parameters: {
+            type: "object",
+            properties: {
+                element: { type: "string", description: "CSS selector of the input element." },
+                text: { type: "string", description: "Text to type." },
+                ref: { type: "string", description: "Snapshot reference (from browser_snapshot)." },
+                slowly: { type: "boolean", description: "Type one character at a time (human-like). Default: false." },
+            },
+            required: ["element", "text"],
+        },
+        async execute(_toolCallId, params) {
+            const p = params;
+            try {
+                const page = bs.getActivePage();
+                await page.click(p.element);
+                await page.fill(p.element, "", { timeout: 5000 });
+                await page.type(p.element, p.text, { delay: p.slowly ? 50 : 0 });
+                return { content: [{ type: "text", text: `✓ Typed into ${p.element}: "${p.text.slice(0, 100)}"` }], details: {} };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { content: [{ type: "text", text: `Type failed: ${msg}` }], details: { isError: true } };
+            }
+        },
+    };
+    // ── browser_press_key ─────────────────────────────────────────────
+    const pressKeyTool = {
+        name: "browser_press_key",
+        label: "Browser Press Key",
+        description: "Press a keyboard key. Use single keys like 'Enter', 'Escape', 'Tab', 'ArrowDown', etc.",
+        promptSnippet: "`browser_press_key { key }` — press a keyboard key",
+        parameters: {
+            type: "object",
+            properties: {
+                key: { type: "string", description: "Key to press, e.g. Enter, Escape, Tab, ArrowDown, Backspace." },
+            },
+            required: ["key"],
+        },
+        async execute(_toolCallId, params) {
+            const { key } = params;
+            try {
+                const page = bs.getActivePage();
+                await page.keyboard.press(key);
+                return { content: [{ type: "text", text: `✓ Pressed key: ${key}` }], details: {} };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { content: [{ type: "text", text: `Press key failed: ${msg}` }], details: { isError: true } };
+            }
+        },
+    };
+    // ── browser_hover ─────────────────────────────────────────────────
+    const hoverTool = {
+        name: "browser_hover",
+        label: "Browser Hover",
+        description: "Hover the mouse over an element.",
+        promptSnippet: "`browser_hover { element }` — hover over an element",
+        parameters: {
+            type: "object",
+            properties: {
+                element: { type: "string", description: "CSS selector of the element to hover." },
+                ref: { type: "string", description: "Snapshot reference (from browser_snapshot)." },
+            },
+            required: ["element"],
+        },
+        async execute(_toolCallId, params) {
+            const { element } = params;
+            try {
+                const page = bs.getActivePage();
+                await page.hover(element, { timeout: 5000 });
+                return { content: [{ type: "text", text: `✓ Hovered: ${element}` }], details: {} };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { content: [{ type: "text", text: `Hover failed: ${msg}` }], details: { isError: true } };
+            }
+        },
+    };
+    // ── browser_drag ──────────────────────────────────────────────────
+    const dragTool = {
+        name: "browser_drag",
+        label: "Browser Drag",
+        description: "Drag an element from one location to another.",
+        promptSnippet: "`browser_drag { startElement, endElement }` — drag and drop",
+        parameters: {
+            type: "object",
+            properties: {
+                startElement: { type: "string", description: "CSS selector of the element to drag." },
+                endElement: { type: "string", description: "CSS selector of the drop target." },
+            },
+            required: ["startElement", "endElement"],
+        },
+        async execute(_toolCallId, params) {
+            const { startElement, endElement } = params;
+            try {
+                const page = bs.getActivePage();
+                await page.dragAndDrop(startElement, endElement, { timeout: 5000 });
+                return { content: [{ type: "text", text: `✓ Dragged ${startElement} → ${endElement}` }], details: {} };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { content: [{ type: "text", text: `Drag failed: ${msg}` }], details: { isError: true } };
+            }
+        },
+    };
+    // ── browser_select_option ─────────────────────────────────────────
+    const selectTool = {
+        name: "browser_select_option",
+        label: "Browser Select Option",
+        description: "Select option(s) in a <select> dropdown element.",
+        promptSnippet: "`browser_select_option { element, values }` — select dropdown options",
+        parameters: {
+            type: "object",
+            properties: {
+                element: { type: "string", description: "CSS selector of the <select> element." },
+                values: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Option values or labels to select.",
+                },
+            },
+            required: ["element", "values"],
+        },
+        async execute(_toolCallId, params) {
+            const { element, values } = params;
+            try {
+                const page = bs.getActivePage();
+                await page.selectOption(element, values, { timeout: 5000 });
+                return { content: [{ type: "text", text: `✓ Selected [${values.join(", ")}] in ${element}` }], details: {} };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { content: [{ type: "text", text: `Select option failed: ${msg}` }], details: { isError: true } };
+            }
+        },
+    };
+    // ── browser_fill_form ─────────────────────────────────────────────
+    const fillFormTool = {
+        name: "browser_fill_form",
+        label: "Browser Fill Form",
+        description: "Fill multiple form fields at once.",
+        promptSnippet: "`browser_fill_form { fields }` — fill multiple form fields",
+        parameters: {
+            type: "object",
+            properties: {
+                fields: {
+                    type: "array",
+                    items: {
+                        type: "object",
+                        properties: {
+                            name: { type: "string", description: "CSS selector, name, or label of the form field." },
+                            type: { type: "string", enum: ["text", "select", "checkbox", "radio"], description: "Input type." },
+                            value: { type: "string", description: "Value to fill. For checkbox/radio use 'true' or 'false'." },
+                        },
+                        required: ["name", "type", "value"],
+                    },
+                    description: "Array of form fields to fill.",
+                },
+            },
+            required: ["fields"],
+        },
+        async execute(_toolCallId, params) {
+            const { fields } = params;
+            try {
+                const page = bs.getActivePage();
+                const results = [];
+                for (const f of fields) {
+                    switch (f.type) {
+                        case "select":
+                            await page.selectOption(f.name, f.value, { timeout: 5000 });
+                            results.push(`✓ [select] ${f.name} = ${f.value}`);
+                            break;
+                        case "checkbox":
+                        case "radio":
+                            if (f.value === "true") {
+                                await page.check(f.name, { timeout: 5000 });
+                            }
+                            else {
+                                await page.uncheck(f.name, { timeout: 5000 });
+                            }
+                            results.push(`✓ [${f.type}] ${f.name} = ${f.value}`);
+                            break;
+                        default:
+                            await page.click(f.name, { timeout: 5000 });
+                            await page.fill(f.name, "", { timeout: 5000 });
+                            await page.type(f.name, f.value);
+                            results.push(`✓ [text] ${f.name} = "${f.value}"`);
+                    }
+                }
+                return { content: [{ type: "text", text: results.join("\n") }], details: {} };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { content: [{ type: "text", text: `Fill form failed: ${msg}` }], details: { isError: true } };
+            }
+        },
+    };
+    // ── browser_file_upload ───────────────────────────────────────────
+    const fileUploadTool = {
+        name: "browser_file_upload",
+        label: "Browser File Upload",
+        description: "Upload one or more files through a file input element.",
+        promptSnippet: "`browser_file_upload { paths }` — upload files",
+        parameters: {
+            type: "object",
+            properties: {
+                element: { type: "string", description: "CSS selector of the file input element. Default: input[type=file]." },
+                paths: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Absolute or relative paths to files to upload.",
+                },
+            },
+            required: ["paths"],
+        },
+        async execute(_toolCallId, params) {
+            const p = params;
+            try {
+                const page = bs.getActivePage();
+                const selector = p.element ?? "input[type=file]";
+                const fileChooserPromise = page.waitForEvent("filechooser");
+                await page.click(selector, { timeout: 5000 });
+                const fileChooser = await fileChooserPromise;
+                await fileChooser.setFiles(p.paths);
+                return { content: [{ type: "text", text: `✓ Uploaded: ${p.paths.join(", ")}` }], details: {} };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return { content: [{ type: "text", text: `File upload failed: ${msg}` }], details: { isError: true } };
+            }
+        },
+    };
+    const tools = [clickTool, typeTool, pressKeyTool, hoverTool, dragTool, selectTool, fillFormTool, fileUploadTool];
+    for (const tool of tools) {
+        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/network.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Network tools: browser_network_requests, browser_network_request.
+ */
+import type { ExtensionAPI } from "../../../sdk/coding-agent/index.js";
+import { BrowserService } from "../browser-service.js";
+export declare function registerNetworkTools(ext: ExtensionAPI, bs: BrowserService): void;
+//# sourceMappingURL=network.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"network.d.ts","sourceRoot":"","sources":["../../../../src/extensions/browser/tools/network.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,CAwHhF"}