browxai 0.7.0

package/dist/sdk/registry.js

@@ -0,0 +1,94 @@
+// Stable SDK tool registry — the curated subset of MCP tools exposed on the
+// `BrowxaiClient` interface. Each entry binds a method name to its underlying
+// MCP tool name AND the capability gate that governs it. The capability
+// reference is the SAME map the server's `gateCheck` consults (see
+// `src/util/capabilities.ts`), so a method is only exposed when the SDK's
+// capability set includes its gate — identical posture to the MCP path.
+//
+// Adding a method: add an entry here, then add the typed wrapper to
+// `src/sdk/client.ts`. Removing/renaming an existing entry is a semver-major
+// change for the SDK surface.
+import { TOOL_CAPABILITY } from "../util/capabilities.js";
+/** Tools the SDK exposes as typed methods on `BrowxaiClient`. */
+export const SDK_TOOLS = [
+    // read
+    "snapshot",
+    "find",
+    "screenshot",
+    "console_read",
+    "network_read",
+    "ws_read",
+    "inspect",
+    "text_search",
+    "extract",
+    "verify_visible",
+    "verify_text",
+    "verify_value",
+    "verify_count",
+    "verify_attribute",
+    "verify_predicate",
+    "generate_locator",
+    "plan",
+    // navigation
+    "navigate",
+    "go_back",
+    "go_forward",
+    "scroll",
+    "set_viewport",
+    // action
+    "click",
+    "fill",
+    "press",
+    "shortcut",
+    "hover",
+    "select",
+    "choose_option",
+    "fill_form",
+    "wait_for",
+    "execute",
+    // human / coordination
+    "await_human",
+    "name_ref",
+    // session management — needed by every consumer
+    "open_session",
+    "close_session",
+    "close_sessions",
+    "list_sessions",
+    // capability-gated tools below: present in the registry so the runtime
+    // walker can ALSO emit them when the matching capability is opted in.
+    // The TS surface for them is intentionally hidden behind a typed escape
+    // hatch — see `BrowxaiClient.callTool`.
+    "eval_js",
+    "network_body",
+    "upload_file",
+    "register_secret",
+    // diagnostics. `diagnostics_note` rides the off-by-default
+    // `diagnostics` capability; the two read-side queries ride `read` so an
+    // adopter who only enabled diagnostics for a prior run can still pull the
+    // report from a fresh SDK client.
+    "diagnostics_note",
+    "diagnostics_search",
+    "diagnostics_report",
+];
+/**
+ * Tool → capability lookup the SDK uses to decide which methods to expose.
+ * Pulled from the same `TOOL_CAPABILITY` map the MCP server uses so the two
+ * paths cannot drift.
+ */
+export function capabilityFor(tool) {
+    return TOOL_CAPABILITY[tool] ?? "human";
+}
+/**
+ * SDK methods always exposed regardless of capability set — these are the
+ * coordination / session-management primitives whose capability is `human`
+ * (always-enabled by the server) plus the SDK lifecycle method itself.
+ * Used by the registry walker to short-circuit the gate check.
+ */
+export const ALWAYS_EXPOSED = new Set([
+    "await_human",
+    "name_ref",
+    "open_session",
+    "close_session",
+    "close_sessions",
+    "list_sessions",
+]);

package/dist/sdk/socket-transport.d.ts

@@ -0,0 +1,20 @@
+import type { Socket } from "node:net";
+import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+import type { JSONRPCMessage } from "@modelcontextprotocol/sdk/types.js";
+export declare class SocketTransport implements Transport {
+    private readonly _socket;
+    private readonly _readBuffer;
+    private _started;
+    private _closed;
+    onclose?: () => void;
+    onerror?: (error: Error) => void;
+    onmessage?: (message: JSONRPCMessage) => void;
+    constructor(socket: Socket);
+    start(): Promise<void>;
+    send(message: JSONRPCMessage): Promise<void>;
+    close(): Promise<void>;
+    private _onData;
+    private _onError;
+    private _onClose;
+    private _processBuffer;
+}

package/dist/sdk/socket-transport.js

@@ -0,0 +1,90 @@
+// Shared MCP-over-Unix-socket transport. Reuses the MCP SDK's existing
+// newline-delimited JSON framing (`ReadBuffer` + `serializeMessage` /
+// `deserializeMessage`) so the wire format on a socket is byte-identical to
+// the stdio path. The class implements the MCP `Transport` interface and is
+// usable on BOTH ends:
+//
+//   - server side: `new SocketTransport(socket).start()` after `net.Server`
+//     accepts a connection, then `mcpServer.connect(socketTransport)`.
+//
+//   - client side: `new SocketTransport(socket).start()` after `net.connect`
+//     resolves, then `mcpClient.connect(socketTransport)`.
+//
+// Why not extend the existing stdio transport? Its constructor is bound to
+// `process.stdin` / `process.stdout` and would attach a real `data` handler
+// to stdin, which is exactly the side-effect we want to avoid in a server
+// embedding the SDK. A small dedicated transport keeps the surface tight.
+import { ReadBuffer, serializeMessage } from "@modelcontextprotocol/sdk/shared/stdio.js";
+export class SocketTransport {
+    _socket;
+    _readBuffer = new ReadBuffer();
+    _started = false;
+    _closed = false;
+    onclose;
+    onerror;
+    onmessage;
+    constructor(socket) {
+        this._socket = socket;
+    }
+    start() {
+        if (this._started) {
+            return Promise.reject(new Error("SocketTransport already started"));
+        }
+        this._started = true;
+        this._socket.on("data", this._onData);
+        this._socket.on("error", this._onError);
+        this._socket.on("close", this._onClose);
+        return Promise.resolve();
+    }
+    async send(message) {
+        if (this._closed)
+            throw new Error("SocketTransport: send after close");
+        return new Promise((resolve, reject) => {
+            const line = serializeMessage(message);
+            this._socket.write(line, (err) => (err ? reject(err) : resolve()));
+        });
+    }
+    async close() {
+        if (this._closed)
+            return;
+        this._closed = true;
+        this._socket.removeListener("data", this._onData);
+        this._socket.removeListener("error", this._onError);
+        this._socket.removeListener("close", this._onClose);
+        this._readBuffer.clear();
+        await new Promise((resolve) => {
+            if (this._socket.destroyed)
+                return resolve();
+            this._socket.end(() => resolve());
+        });
+        this.onclose?.();
+    }
+    _onData = (chunk) => {
+        this._readBuffer.append(chunk);
+        this._processBuffer();
+    };
+    _onError = (err) => {
+        this.onerror?.(err);
+    };
+    _onClose = () => {
+        if (this._closed)
+            return;
+        this._closed = true;
+        this._readBuffer.clear();
+        this.onclose?.();
+    };
+    _processBuffer() {
+        for (;;) {
+            try {
+                const msg = this._readBuffer.readMessage();
+                if (!msg)
+                    return;
+                this.onmessage?.(msg);
+            }
+            catch (err) {
+                this.onerror?.(err instanceof Error ? err : new Error(String(err)));
+                return;
+            }
+        }
+    }
+}