@weavetab/mcp 2.5.0-beta.0

package/dist/cdp/walker.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=walker.test.d.ts.map

package/dist/cdp/walker.test.js

@@ -0,0 +1,172 @@
+/**
+ * walker.test.ts — Phase 1.1
+ * Unit tests for walker.ts utility functions (no CDP session needed).
+ * buildActionMap and buildAXTreeMap require live browser — not tested here.
+ */
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { toRefEntries, findAllMatches, findBestMatch, toMarkdownTable, safeSelector, clearViewportCache, setShadowDomCache, clearShadowDomCache, clearAXTreeCache, resetFallbackIdCounter as resetIdCounter, } from "./walker.js";
+function makeEl(overrides = {}) {
+    return {
+        id: "w:1",
+        role: "button",
+        label: "Submit",
+        group: "form",
+        fingerprint: "button:submit:form:1",
+        depth: 0,
+        ...overrides,
+    };
+}
+test("toRefEntries: converts ActionElements to RefEntries", () => {
+    const els = [
+        makeEl({ id: "w:1", label: "Sign In", role: "button", type: "submit", fingerprint: "a" }),
+        makeEl({ id: "w:2", label: "Email", role: "textbox", type: "email", fingerprint: "b" }),
+    ];
+    const refs = toRefEntries(els);
+    assert.equal(refs.length, 2);
+    assert.equal(refs[0].id, "w:1");
+    assert.equal(refs[0].label, "Sign In");
+    assert.equal(refs[0].type, "submit");
+    assert.equal(refs[0].disabled, false);
+    assert.equal(refs[1].id, "w:2");
+});
+test("toRefEntries: empty array returns empty", () => {
+    assert.deepEqual(toRefEntries([]), []);
+});
+test("findAllMatches: exact label match", () => {
+    const els = [
+        makeEl({ id: "w:1", label: "Sign In" }),
+        makeEl({ id: "w:2", label: "Sign Out" }),
+        makeEl({ id: "w:3", label: "Email" }),
+    ];
+    const matches = findAllMatches(els, "Sign In");
+    assert.equal(matches.length, 1);
+    assert.equal(matches[0].id, "w:1");
+});
+test("findAllMatches: partial label match", () => {
+    const els = [
+        makeEl({ id: "w:1", label: "Sign In" }),
+        makeEl({ id: "w:2", label: "Sign Out" }),
+        makeEl({ id: "w:3", label: "Email" }),
+    ];
+    const matches = findAllMatches(els, "Sign");
+    assert.equal(matches.length, 2);
+    assert.ok(matches.find(m => m.id === "w:1"));
+    assert.ok(matches.find(m => m.id === "w:2"));
+});
+test("findAllMatches: case insensitive", () => {
+    const els = [makeEl({ id: "w:1", label: "SIGN IN" })];
+    const matches = findAllMatches(els, "sign in");
+    assert.equal(matches.length, 1);
+});
+test("findAllMatches: placeholder match", () => {
+    const els = [makeEl({ id: "w:1", label: "", placeholder: "Enter name" })];
+    const matches = findAllMatches(els, "Enter name");
+    assert.equal(matches.length, 1);
+    assert.equal(matches[0].id, "w:1");
+});
+test("findAllMatches: empty query returns empty", () => {
+    const els = [makeEl({ id: "w:1", label: "Submit" })];
+    assert.deepEqual(findAllMatches(els, ""), []);
+    assert.deepEqual(findAllMatches(els, "  "), []);
+    assert.deepEqual(findAllMatches(els, "\t"), []);
+});
+test("findAllMatches: fuzzy multi-word match", () => {
+    const els = [
+        makeEl({ id: "w:1", label: "Create New Account" }),
+        makeEl({ id: "w:2", label: "Create Post" }),
+    ];
+    const matches = findAllMatches(els, "Create Account");
+    assert.equal(matches.length, 1);
+    assert.equal(matches[0].id, "w:1");
+});
+test("findAllMatches: returns unique elements only", () => {
+    const els = [makeEl({ id: "w:1", label: "Submit" })];
+    // label and type both match "Submit"
+    const matches = findAllMatches(els, "Submit");
+    assert.equal(matches.length, 1);
+});
+test("findBestMatch: returns first match", () => {
+    const els = [
+        makeEl({ id: "w:1", label: "Sign In" }),
+        makeEl({ id: "w:2", label: "Sign Out" }),
+    ];
+    const best = findBestMatch(els, "Sign");
+    assert.ok(best);
+    assert.equal(best.id, "w:1");
+});
+test("findBestMatch: undefined on no match", () => {
+    assert.equal(findBestMatch([], "nonexistent"), undefined);
+});
+test("toMarkdownTable: basic formatting", () => {
+    const els = [
+        makeEl({ id: "w:1", label: "Submit", role: "button", depth: 0 }),
+        makeEl({ id: "w:2", label: "Email", role: "textbox", depth: 0 }),
+    ];
+    const md = toMarkdownTable(els, "https://example.com", "Test Page");
+    assert.ok(md.includes("https://example.com"));
+    assert.ok(md.includes("Test Page"));
+    assert.ok(md.includes("Submit"));
+    assert.ok(md.includes("Email"));
+    assert.ok(md.includes("(Btn)"));
+    assert.ok(md.includes("(Input)"));
+});
+test("toMarkdownTable: respects depth indentation", () => {
+    const els = [
+        makeEl({ id: "w:1", label: "Root", role: "button", depth: 0 }),
+        makeEl({ id: "w:2", label: "Child", role: "textbox", depth: 1 }),
+    ];
+    const md = toMarkdownTable(els, "https://x.com", "X");
+    // child should be indented
+    const lines = md.split("\n");
+    const childLine = lines.find(l => l.includes("Child"));
+    assert.ok(childLine, "Child line should exist");
+    assert.ok(childLine.startsWith("  "), "Child should be indented");
+});
+test("toMarkdownTable: strips non-interactive elements without label", () => {
+    const els = [
+        makeEl({ id: "", label: "", role: "generic", depth: 0 }),
+        makeEl({ id: "w:1", label: "Real", role: "button", depth: 0 }),
+    ];
+    const md = toMarkdownTable(els, "https://x.com", "X");
+    assert.ok(!md.includes("generic"), "Empty generic should be stripped");
+    assert.ok(md.includes("Real"));
+});
+test("safeSelector: returns selector when present", () => {
+    const el = makeEl({ selector: "#submit-btn" });
+    assert.equal(safeSelector(el), "#submit-btn");
+});
+test("safeSelector: returns undefined when no selector", () => {
+    assert.equal(safeSelector(makeEl()), undefined);
+});
+test("safeSelector: returns undefined on undefined input", () => {
+    assert.equal(safeSelector(undefined), undefined);
+});
+test("clearViewportCache: no-op smoke test", () => {
+    clearViewportCache("test-target");
+    assert.ok(true, "clearViewportCache should not throw");
+});
+test("resetFallbackIdCounter: no-op smoke test", () => {
+    resetIdCounter();
+    assert.ok(true, "resetFallbackIdCounter should not throw");
+});
+test("shadowDomCache: set and clear", () => {
+    setShadowDomCache("target-a", true);
+    setShadowDomCache("target-b", false);
+    clearShadowDomCache("target-a");
+    clearShadowDomCache("target-b");
+    assert.ok(true, "shadowDomCache should not throw");
+});
+test("clearAXTreeCache: no-op smoke test", () => {
+    clearAXTreeCache("any-target");
+    assert.ok(true, "clearAXTreeCache should not throw");
+});
+test("findAllMatches: type match fallback", () => {
+    const els = [
+        makeEl({ id: "w:1", label: "", type: "checkbox" }),
+        makeEl({ id: "w:2", label: "Checkbox", type: "text" }),
+    ];
+    const matches = findAllMatches(els, "checkbox");
+    assert.equal(matches.length, 2);
+});
+//# sourceMappingURL=walker.test.js.map

package/dist/cdp/websocket_transport.d.ts

@@ -0,0 +1,15 @@
+import type { Transport, TransportSendOptions } from "@modelcontextprotocol/sdk/shared/transport.js";
+import type { JSONRPCMessage } from "@modelcontextprotocol/sdk/types.js";
+export declare function getWebSocketSecret(): string;
+export declare class WebSocketServerTransport implements Transport {
+    private wss;
+    private activeSocket;
+    private authenticated;
+    onclose?: () => void;
+    onerror?: (error: Error) => void;
+    onmessage?: (message: JSONRPCMessage) => void;
+    constructor(port: number);
+    start(): Promise<void>;
+    send(message: JSONRPCMessage, options?: TransportSendOptions): Promise<void>;
+    close(): Promise<void>;
+}

package/dist/cdp/websocket_transport.js

@@ -0,0 +1,118 @@
+import { WebSocketServer } from "ws";
+import * as crypto from "node:crypto";
+import * as os from "node:os";
+import * as path from "node:path";
+import * as fs from "node:fs";
+// WebSocket authentication: generate or load a shared secret for authentication
+const WS_SECRET_FILE = path.join(os.homedir(), ".weavetab-system", "ws-secret");
+let wsSecret;
+export function getWebSocketSecret() {
+    if (wsSecret)
+        return wsSecret;
+    try {
+        if (fs.existsSync(WS_SECRET_FILE)) {
+            wsSecret = fs.readFileSync(WS_SECRET_FILE, "utf-8").trim();
+        }
+        else {
+            wsSecret = crypto.randomBytes(32).toString("hex");
+            const dir = path.dirname(WS_SECRET_FILE);
+            if (!fs.existsSync(dir))
+                fs.mkdirSync(dir, { recursive: true });
+            fs.writeFileSync(WS_SECRET_FILE, wsSecret, { mode: 0o600 });
+        }
+    }
+    catch {
+        wsSecret = crypto.randomBytes(32).toString("hex");
+    }
+    return wsSecret;
+}
+export class WebSocketServerTransport {
+    wss;
+    activeSocket = null;
+    authenticated = false;
+    onclose;
+    onerror;
+    onmessage;
+    constructor(port) {
+        this.wss = new WebSocketServer({ port, maxPayload: 1024 * 1024 }); // 1MB limit
+        this.wss.on("connection", (ws) => {
+            if (this.activeSocket) {
+                ws.close(1013, "Only one concurrent connection allowed");
+                return;
+            }
+            // Require authentication before accepting messages
+            this.authenticated = false;
+            ws.on("message", (data) => {
+                try {
+                    const rawMessage = data.toString();
+                    const message = JSON.parse(rawMessage);
+                    // Check for authentication handshake
+                    if (!this.authenticated) {
+                        const msg = message;
+                        if (msg.method === "authenticate" && msg.params && Array.isArray(msg.params)) {
+                            const providedSecret = msg.params[0];
+                            const expectedSecret = getWebSocketSecret();
+                            if (providedSecret === expectedSecret) {
+                                this.authenticated = true;
+                                this.activeSocket = ws;
+                                ws.send(JSON.stringify({ result: { authenticated: true }, id: msg.id }));
+                                return;
+                            }
+                            else {
+                                ws.send(JSON.stringify({ error: { code: -32000, message: "Authentication failed" }, id: msg.id }));
+                                ws.close(1008, "Authentication failed");
+                                return;
+                            }
+                        }
+                        else {
+                            ws.send(JSON.stringify({ error: { code: -32001, message: "Authentication required" }, id: msg.id }));
+                            return;
+                        }
+                    }
+                    // Only process messages after authentication
+                    this.onmessage?.(message);
+                }
+                catch (err) {
+                    this.onerror?.(err);
+                }
+            });
+            ws.on("error", (err) => {
+                this.onerror?.(err);
+            });
+            ws.on("close", () => {
+                this.activeSocket = null;
+                this.authenticated = false;
+                this.onclose?.();
+            });
+        });
+        this.wss.on("error", (err) => {
+            this.onerror?.(err);
+        });
+    }
+    async start() {
+        // Already started listening on construction
+    }
+    async send(message, options) {
+        if (!this.activeSocket) {
+            throw new Error("No active WebSocket connection");
+        }
+        const socket = this.activeSocket;
+        return new Promise((resolve, reject) => {
+            socket.send(JSON.stringify(message), (err) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve();
+            });
+        });
+    }
+    async close() {
+        if (this.activeSocket) {
+            this.activeSocket.close();
+            this.activeSocket = null;
+        }
+        return new Promise((resolve) => {
+            this.wss.close(() => resolve());
+        });
+    }
+}

package/dist/cli/plugin.d.ts

@@ -0,0 +1,9 @@
+export declare function runPluginAdd(inputName: string, args?: string[]): Promise<void>;
+export declare function runPluginList(): Promise<void>;
+export declare function runPluginSearch(query?: string): Promise<void>;
+export declare function runPluginBrowse(): Promise<void>;
+export declare function runPluginRemove(pkgName: string, args?: string[]): Promise<void>;
+export declare function runPluginVerify(pkgName: string): Promise<void>;
+export declare function runPluginInit(args?: string[]): Promise<void>;
+export declare function runPluginBuild(args?: string[]): Promise<void>;
+export declare function runPluginCli(args: string[]): Promise<void>;