@mcp-b/webmcp-local-relay 0.0.0-beta-20260225101008

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 mcp-b contributors
+
+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

@@ -0,0 +1,193 @@
+# @mcp-b/webmcp-local-relay
+
+Local MCP relay for browser WebMCP tools.
+
+This package lets an MCP client (Claude Code, Cursor, etc.) call tools from websites you currently have open, via a localhost bridge.
+
+## Requirement: WebMCP Runtime On The Page
+
+Relay only forwards tools that are registered on `navigator.modelContext`.
+
+A connected page must install one of:
+
+1. `@mcp-b/global` (recommended).
+2. `@mcp-b/webmcp-polyfill` (strict core), with `navigator.modelContextTesting` available (default in the polyfill).
+
+Runtime dispatch behavior:
+
+- If `navigator.modelContext.listTools` + `navigator.modelContext.callTool` exist, relay uses that extension path.
+- Otherwise, relay uses `navigator.modelContextTesting.listTools` + `executeTool`.
+
+## Users First: Install In Claude Code (Plugin)
+
+Recommended path: install the plugin in Claude Code, then use the relayed tools directly.
+
+1. Clone this repository locally.
+2. In Claude Code, run:
+
+```text
+/plugin add /absolute/path/to/npm-packages/packages/webmcp-local-relay/.claude-plugin
+```
+
+Optional scope flag:
+
+```text
+/plugin add /absolute/path/to/npm-packages/packages/webmcp-local-relay/.claude-plugin --scope user
+```
+
+3. Confirm installation:
+
+```text
+/plugin list
+```
+
+4. Start using the relay:
+   - Ask Claude to run `webmcp_list_sources`.
+   - Ask Claude to run `webmcp_list_tools`.
+   - Call the returned `webmcp_*` tools.
+
+Plugin manifest:
+- [`./.claude-plugin/plugin.json`](./.claude-plugin/plugin.json)
+
+Skill included in the plugin:
+- [`./.claude-plugin/skills/webmcp-local-relay/SKILL.md`](./.claude-plugin/skills/webmcp-local-relay/SKILL.md)
+
+## Claude Code Section: Plugin + Skill Behavior
+
+The plugin wires two things:
+
+1. MCP server registration:
+   - Starts `@mcp-b/webmcp-local-relay` via `npx`.
+2. Skill registration:
+   - Provides a focused skill that tells the agent how to discover sources/tools and route calls safely.
+
+The skill guidance is intentionally operational:
+- list sources first
+- list tools second
+- pick the right domain/tab
+- re-list tools if the browser session changes
+
+## Reference Docs (Deep Dive Sources)
+
+- Claude Code plugin creation:
+  - https://docs.anthropic.com/en/docs/claude-code/plugins/create-plugins
+- Claude Code plugin schema and plugin marketplace reference:
+  - https://docs.anthropic.com/en/docs/claude-code/plugins/plugins-reference
+- Claude Code plugin discovery and install commands:
+  - https://docs.anthropic.com/en/docs/claude-code/plugins/discover-plugins
+- Claude Code skill system:
+  - https://docs.anthropic.com/en/docs/claude-code/skills
+- Agent Skills ecosystem project:
+  - https://github.com/agentskills/agent-skills
+
+## Website Owner Setup
+
+Your page should load an embed script that injects a hidden widget iframe.
+
+```html
+<script src="https://yourdomain.example/embed.js"></script>
+```
+
+Minimal `embed.js` pattern:
+
+```js
+(() => {
+  const iframe = document.createElement('iframe');
+  iframe.src = 'https://yourdomain.example/widget';
+  iframe.style.display = 'none';
+  iframe.setAttribute('aria-hidden', 'true');
+  document.body.appendChild(iframe);
+})();
+```
+
+Your page must also register tools using one of the supported WebMCP runtimes.
+
+Example (recommended) with `@mcp-b/global`:
+
+```html
+<script src="https://cdn.jsdelivr.net/npm/@mcp-b/global@latest/dist/index.iife.js"></script>
+<script>
+  navigator.modelContext.registerTool({
+    name: 'get_page_title',
+    description: 'Get page title',
+    inputSchema: { type: 'object', properties: {} },
+    execute: async () => ({ content: [{ type: 'text', text: document.title }] }),
+  });
+</script>
+```
+
+Example with strict `@mcp-b/webmcp-polyfill`:
+
+```html
+<script src="https://cdn.jsdelivr.net/npm/@mcp-b/webmcp-polyfill@latest/dist/index.iife.js"></script>
+<script>
+  navigator.modelContext.registerTool({
+    name: 'get_page_title',
+    description: 'Get page title',
+    inputSchema: { type: 'object', properties: {} },
+    execute: async () => ({ content: [{ type: 'text', text: document.title }] }),
+  });
+</script>
+```
+
+Widget responsibilities:
+- Connect to `ws://127.0.0.1:9333` (or your configured relay port).
+- Send source metadata (`hello`) and current tool list (`tools/list`).
+- Handle `invoke` messages and return `result`.
+- Reconnect automatically when the local relay starts later.
+
+Security baseline:
+- Run relay on loopback only (`127.0.0.1`).
+- Restrict `--widget-origin` to your widget origin in production.
+
+## User Setup Without Plugin (Fallback)
+
+If you do not want plugin install, add the MCP server directly:
+
+```json
+{
+  "mcpServers": {
+    "webmcp-local-relay": {
+      "command": "npx",
+      "args": ["-y", "@mcp-b/webmcp-local-relay@latest"]
+    }
+  }
+}
+```
+
+Then restart Claude Code and call:
+- `webmcp_list_sources`
+- `webmcp_list_tools`
+
+## Developer Setup
+
+From repository root:
+
+```bash
+pnpm install
+pnpm --filter @mcp-b/webmcp-local-relay build
+pnpm --filter @mcp-b/webmcp-local-relay test
+pnpm --filter @mcp-b/webmcp-local-relay test:e2e
+```
+
+Run relay locally:
+
+```bash
+node packages/webmcp-local-relay/dist/cli.js --host 127.0.0.1 --port 9333
+```
+
+Lock widget origin while developing:
+
+```bash
+node packages/webmcp-local-relay/dist/cli.js --host 127.0.0.1 --port 9333 --widget-origin https://your-widget-domain.example
+```
+
+## Tooling Model
+
+Static tools:
+- `webmcp_list_sources`
+- `webmcp_list_tools`
+
+Dynamic tools:
+- registered from browser sources
+- deterministic namespaced IDs for de-duping across tabs and domains

package/dist/cli.d.ts

@@ -0,0 +1 @@
+export { };

package/dist/cli.js

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+import { t as LocalRelayMcpServer } from "./mcpRelayServer-BwF1i7Se.js";
+
+//#region src/cli.ts
+function parseCliOptions(argv) {
+	const options$1 = {
+		host: "127.0.0.1",
+		port: 9333,
+		allowedOrigins: ["*"]
+	};
+	for (let i = 0; i < argv.length; i++) {
+		const token = argv[i];
+		if (!token) continue;
+		if ((token === "--host" || token === "-h") && argv[i + 1]) {
+			options$1.host = argv[++i];
+			continue;
+		}
+		if ((token === "--port" || token === "-p") && argv[i + 1]) {
+			const value = Number.parseInt(argv[++i], 10);
+			if (Number.isFinite(value) && value > 0 && value <= 65535) options$1.port = value;
+			continue;
+		}
+		if ((token === "--widget-origin" || token === "--allowed-origin") && argv[i + 1]) {
+			const split = argv[++i].split(",").map((part) => part.trim()).filter(Boolean);
+			if (split.length > 0) options$1.allowedOrigins = split;
+			continue;
+		}
+		if (token === "--help" || token === "-?") {
+			printHelp();
+			process.exit(0);
+		}
+	}
+	return options$1;
+}
+function printHelp() {
+	process.stderr.write([
+		"webmcp-local-relay",
+		"",
+		"Usage:",
+		"  webmcp-local-relay [--host 127.0.0.1] [--port 9333] [--widget-origin https://yourdomain.com]",
+		"",
+		"Options:",
+		"  --host, -h               Bind host for local websocket relay (default: 127.0.0.1)",
+		"  --port, -p               Bind port for local websocket relay (default: 9333)",
+		"  --widget-origin          Allowed browser origin(s), comma-separated (default: *)",
+		"  --allowed-origin         Alias for --widget-origin",
+		"  --help, -?               Show help",
+		""
+	].join("\n"));
+}
+const options = parseCliOptions(process.argv.slice(2));
+const relay = new LocalRelayMcpServer({ bridgeOptions: {
+	host: options.host,
+	port: options.port,
+	allowedOrigins: options.allowedOrigins
+} });
+await relay.start();
+await relay.startStdio();
+process.stderr.write(`[webmcp-local-relay] listening on ws://${options.host}:${relay.bridge.port} (allowed origins: ${options.allowedOrigins.join(", ")})\n`);
+const shutdown = async (signal) => {
+	process.stderr.write(`[webmcp-local-relay] received ${signal}, shutting down\n`);
+	await relay.stop();
+	process.exit(0);
+};
+process.on("SIGINT", () => {
+	shutdown("SIGINT");
+});
+process.on("SIGTERM", () => {
+	shutdown("SIGTERM");
+});
+
+//#endregion
+export {  };
+//# sourceMappingURL=cli.js.map

package/dist/cli.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.js","names":["options: CliOptions","options"],"sources":["../src/cli.ts"],"sourcesContent":["#!/usr/bin/env node\n\nimport { LocalRelayMcpServer } from './mcpRelayServer.js';\n\ninterface CliOptions {\n  host: string;\n  port: number;\n  allowedOrigins: string[];\n}\n\nfunction parseCliOptions(argv: string[]): CliOptions {\n  const options: CliOptions = {\n    host: '127.0.0.1',\n    port: 9333,\n    allowedOrigins: ['*'],\n  };\n\n  for (let i = 0; i < argv.length; i++) {\n    const token = argv[i];\n    if (!token) continue;\n\n    if ((token === '--host' || token === '-h') && argv[i + 1]) {\n      options.host = argv[++i] as string;\n      continue;\n    }\n\n    if ((token === '--port' || token === '-p') && argv[i + 1]) {\n      const value = Number.parseInt(argv[++i] as string, 10);\n      if (Number.isFinite(value) && value > 0 && value <= 65535) {\n        options.port = value;\n      }\n      continue;\n    }\n\n    if ((token === '--widget-origin' || token === '--allowed-origin') && argv[i + 1]) {\n      const raw = argv[++i] as string;\n      const split = raw\n        .split(',')\n        .map((part) => part.trim())\n        .filter(Boolean);\n\n      if (split.length > 0) {\n        options.allowedOrigins = split;\n      }\n      continue;\n    }\n\n    if (token === '--help' || token === '-?') {\n      printHelp();\n      process.exit(0);\n    }\n  }\n\n  return options;\n}\n\nfunction printHelp(): void {\n  process.stderr.write(\n    [\n      'webmcp-local-relay',\n      '',\n      'Usage:',\n      '  webmcp-local-relay [--host 127.0.0.1] [--port 9333] [--widget-origin https://yourdomain.com]',\n      '',\n      'Options:',\n      '  --host, -h               Bind host for local websocket relay (default: 127.0.0.1)',\n      '  --port, -p               Bind port for local websocket relay (default: 9333)',\n      '  --widget-origin          Allowed browser origin(s), comma-separated (default: *)',\n      '  --allowed-origin         Alias for --widget-origin',\n      '  --help, -?               Show help',\n      '',\n    ].join('\\n')\n  );\n}\n\nconst options = parseCliOptions(process.argv.slice(2));\n\nconst relay = new LocalRelayMcpServer({\n  bridgeOptions: {\n    host: options.host,\n    port: options.port,\n    allowedOrigins: options.allowedOrigins,\n  },\n});\n\nawait relay.start();\nawait relay.startStdio();\n\nprocess.stderr.write(\n  `[webmcp-local-relay] listening on ws://${options.host}:${relay.bridge.port} (allowed origins: ${options.allowedOrigins.join(', ')})\\n`\n);\n\nconst shutdown = async (signal: string) => {\n  process.stderr.write(`[webmcp-local-relay] received ${signal}, shutting down\\n`);\n  await relay.stop();\n  process.exit(0);\n};\n\nprocess.on('SIGINT', () => {\n  void shutdown('SIGINT');\n});\nprocess.on('SIGTERM', () => {\n  void shutdown('SIGTERM');\n});\n"],"mappings":";;;;AAUA,SAAS,gBAAgB,MAA4B;CACnD,MAAMA,YAAsB;EAC1B,MAAM;EACN,MAAM;EACN,gBAAgB,CAAC,IAAI;EACtB;AAED,MAAK,IAAI,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;EACpC,MAAM,QAAQ,KAAK;AACnB,MAAI,CAAC,MAAO;AAEZ,OAAK,UAAU,YAAY,UAAU,SAAS,KAAK,IAAI,IAAI;AACzD,aAAQ,OAAO,KAAK,EAAE;AACtB;;AAGF,OAAK,UAAU,YAAY,UAAU,SAAS,KAAK,IAAI,IAAI;GACzD,MAAM,QAAQ,OAAO,SAAS,KAAK,EAAE,IAAc,GAAG;AACtD,OAAI,OAAO,SAAS,MAAM,IAAI,QAAQ,KAAK,SAAS,MAClD,WAAQ,OAAO;AAEjB;;AAGF,OAAK,UAAU,qBAAqB,UAAU,uBAAuB,KAAK,IAAI,IAAI;GAEhF,MAAM,QADM,KAAK,EAAE,GAEhB,MAAM,IAAI,CACV,KAAK,SAAS,KAAK,MAAM,CAAC,CAC1B,OAAO,QAAQ;AAElB,OAAI,MAAM,SAAS,EACjB,WAAQ,iBAAiB;AAE3B;;AAGF,MAAI,UAAU,YAAY,UAAU,MAAM;AACxC,cAAW;AACX,WAAQ,KAAK,EAAE;;;AAInB,QAAOC;;AAGT,SAAS,YAAkB;AACzB,SAAQ,OAAO,MACb;EACE;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACD,CAAC,KAAK,KAAK,CACb;;AAGH,MAAM,UAAU,gBAAgB,QAAQ,KAAK,MAAM,EAAE,CAAC;AAEtD,MAAM,QAAQ,IAAI,oBAAoB,EACpC,eAAe;CACb,MAAM,QAAQ;CACd,MAAM,QAAQ;CACd,gBAAgB,QAAQ;CACzB,EACF,CAAC;AAEF,MAAM,MAAM,OAAO;AACnB,MAAM,MAAM,YAAY;AAExB,QAAQ,OAAO,MACb,0CAA0C,QAAQ,KAAK,GAAG,MAAM,OAAO,KAAK,qBAAqB,QAAQ,eAAe,KAAK,KAAK,CAAC,KACpI;AAED,MAAM,WAAW,OAAO,WAAmB;AACzC,SAAQ,OAAO,MAAM,iCAAiC,OAAO,mBAAmB;AAChF,OAAM,MAAM,MAAM;AAClB,SAAQ,KAAK,EAAE;;AAGjB,QAAQ,GAAG,gBAAgB;AACzB,CAAK,SAAS,SAAS;EACvB;AACF,QAAQ,GAAG,iBAAiB;AAC1B,CAAK,SAAS,UAAU;EACxB"}

package/dist/index.d.ts

@@ -0,0 +1,314 @@
+import { z } from "zod";
+import { EventEmitter } from "node:events";
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+
+//#region src/schemas.d.ts
+declare const BrowserToolSchema: z.ZodObject<{
+  name: z.ZodString;
+  description: z.ZodOptional<z.ZodString>;
+  inputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  annotations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+  name: string;
+  description?: string | undefined;
+  inputSchema?: Record<string, unknown> | undefined;
+  outputSchema?: Record<string, unknown> | undefined;
+  annotations?: Record<string, unknown> | undefined;
+}, {
+  name: string;
+  description?: string | undefined;
+  inputSchema?: Record<string, unknown> | undefined;
+  outputSchema?: Record<string, unknown> | undefined;
+  annotations?: Record<string, unknown> | undefined;
+}>;
+declare const BrowserHelloMessageSchema: z.ZodObject<{
+  type: z.ZodLiteral<"hello">;
+  tabId: z.ZodString;
+  origin: z.ZodOptional<z.ZodString>;
+  url: z.ZodOptional<z.ZodString>;
+  title: z.ZodOptional<z.ZodString>;
+  iconUrl: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+  type: "hello";
+  tabId: string;
+  origin?: string | undefined;
+  url?: string | undefined;
+  title?: string | undefined;
+  iconUrl?: string | undefined;
+}, {
+  type: "hello";
+  tabId: string;
+  origin?: string | undefined;
+  url?: string | undefined;
+  title?: string | undefined;
+  iconUrl?: string | undefined;
+}>;
+declare const BrowserToRelayMessageSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+  type: z.ZodLiteral<"hello">;
+  tabId: z.ZodString;
+  origin: z.ZodOptional<z.ZodString>;
+  url: z.ZodOptional<z.ZodString>;
+  title: z.ZodOptional<z.ZodString>;
+  iconUrl: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+  type: "hello";
+  tabId: string;
+  origin?: string | undefined;
+  url?: string | undefined;
+  title?: string | undefined;
+  iconUrl?: string | undefined;
+}, {
+  type: "hello";
+  tabId: string;
+  origin?: string | undefined;
+  url?: string | undefined;
+  title?: string | undefined;
+  iconUrl?: string | undefined;
+}>, z.ZodObject<{
+  type: z.ZodLiteral<"tools/list">;
+  tools: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    inputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    annotations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  }, "strip", z.ZodTypeAny, {
+    name: string;
+    description?: string | undefined;
+    inputSchema?: Record<string, unknown> | undefined;
+    outputSchema?: Record<string, unknown> | undefined;
+    annotations?: Record<string, unknown> | undefined;
+  }, {
+    name: string;
+    description?: string | undefined;
+    inputSchema?: Record<string, unknown> | undefined;
+    outputSchema?: Record<string, unknown> | undefined;
+    annotations?: Record<string, unknown> | undefined;
+  }>, "many">;
+}, "strip", z.ZodTypeAny, {
+  type: "tools/list";
+  tools: {
+    name: string;
+    description?: string | undefined;
+    inputSchema?: Record<string, unknown> | undefined;
+    outputSchema?: Record<string, unknown> | undefined;
+    annotations?: Record<string, unknown> | undefined;
+  }[];
+}, {
+  type: "tools/list";
+  tools: {
+    name: string;
+    description?: string | undefined;
+    inputSchema?: Record<string, unknown> | undefined;
+    outputSchema?: Record<string, unknown> | undefined;
+    annotations?: Record<string, unknown> | undefined;
+  }[];
+}>, z.ZodObject<{
+  type: z.ZodLiteral<"tools/changed">;
+  tools: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    inputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    annotations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  }, "strip", z.ZodTypeAny, {
+    name: string;
+    description?: string | undefined;
+    inputSchema?: Record<string, unknown> | undefined;
+    outputSchema?: Record<string, unknown> | undefined;
+    annotations?: Record<string, unknown> | undefined;
+  }, {
+    name: string;
+    description?: string | undefined;
+    inputSchema?: Record<string, unknown> | undefined;
+    outputSchema?: Record<string, unknown> | undefined;
+    annotations?: Record<string, unknown> | undefined;
+  }>, "many">;
+}, "strip", z.ZodTypeAny, {
+  type: "tools/changed";
+  tools: {
+    name: string;
+    description?: string | undefined;
+    inputSchema?: Record<string, unknown> | undefined;
+    outputSchema?: Record<string, unknown> | undefined;
+    annotations?: Record<string, unknown> | undefined;
+  }[];
+}, {
+  type: "tools/changed";
+  tools: {
+    name: string;
+    description?: string | undefined;
+    inputSchema?: Record<string, unknown> | undefined;
+    outputSchema?: Record<string, unknown> | undefined;
+    annotations?: Record<string, unknown> | undefined;
+  }[];
+}>, z.ZodObject<{
+  type: z.ZodLiteral<"result">;
+  callId: z.ZodString;
+  result: z.ZodUnknown;
+}, "strip", z.ZodTypeAny, {
+  type: "result";
+  callId: string;
+  result?: unknown;
+}, {
+  type: "result";
+  callId: string;
+  result?: unknown;
+}>, z.ZodObject<{
+  type: z.ZodLiteral<"pong">;
+}, "strip", z.ZodTypeAny, {
+  type: "pong";
+}, {
+  type: "pong";
+}>]>;
+type BrowserToRelayMessage = z.infer<typeof BrowserToRelayMessageSchema>;
+type BrowserTool = z.infer<typeof BrowserToolSchema>;
+type BrowserHelloMessage = z.infer<typeof BrowserHelloMessageSchema>;
+declare const RelayToBrowserMessageSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+  type: z.ZodLiteral<"invoke">;
+  callId: z.ZodString;
+  toolName: z.ZodString;
+  args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+  type: "invoke";
+  callId: string;
+  toolName: string;
+  args?: Record<string, unknown> | undefined;
+}, {
+  type: "invoke";
+  callId: string;
+  toolName: string;
+  args?: Record<string, unknown> | undefined;
+}>, z.ZodObject<{
+  type: z.ZodLiteral<"ping">;
+}, "strip", z.ZodTypeAny, {
+  type: "ping";
+}, {
+  type: "ping";
+}>]>;
+type RelayToBrowserMessage = z.infer<typeof RelayToBrowserMessageSchema>;
+//#endregion
+//#region src/registry.d.ts
+interface SourceInfo {
+  sourceId: string;
+  tabId: string;
+  origin: string | undefined;
+  url: string | undefined;
+  title: string | undefined;
+  iconUrl: string | undefined;
+  connectedAt: number;
+  lastSeenAt: number;
+  toolCount: number;
+}
+interface AggregatedTool {
+  name: string;
+  originalName: string;
+  description: string | undefined;
+  inputSchema: Record<string, unknown> | undefined;
+  outputSchema: Record<string, unknown> | undefined;
+  annotations: Record<string, unknown> | undefined;
+  sources: SourceInfo[];
+}
+interface ResolvedInvocation {
+  connectionId: string;
+  tool: BrowserTool;
+  publicToolName: string;
+}
+declare class RelayRegistry {
+  private readonly now;
+  private readonly sourceByConnectionId;
+  private readonly toolsByConnectionId;
+  private readonly providersByPublicToolName;
+  constructor(now?: () => number);
+  upsertSource(connectionId: string, hello: BrowserHelloMessage): void;
+  registerTools(connectionId: string, tools: BrowserTool[]): void;
+  removeConnection(connectionId: string): void;
+  touchConnection(connectionId: string): void;
+  listSources(): SourceInfo[];
+  listTools(): AggregatedTool[];
+  resolveInvocation(options: {
+    toolName: string;
+    sourceId?: string;
+    requestTabId?: string;
+  }): ResolvedInvocation | null;
+  private removeConnectionTools;
+  private sortProvidersByRecency;
+  private compareRecency;
+}
+//#endregion
+//#region src/bridgeServer.d.ts
+interface RelayBridgeServerOptions {
+  host?: string;
+  port?: number;
+  allowedOrigins?: string[];
+  maxPayloadBytes?: number;
+  invokeTimeoutMs?: number;
+}
+declare class RelayBridgeServer extends EventEmitter {
+  readonly registry: RelayRegistry;
+  private readonly host;
+  private desiredPort;
+  private readonly allowedOrigins;
+  private readonly maxPayloadBytes;
+  private readonly invokeTimeoutMs;
+  private wss;
+  private readonly socketByConnectionId;
+  private readonly connectionIdBySocket;
+  private readonly pendingInvocations;
+  constructor(options?: RelayBridgeServerOptions, registry?: RelayRegistry);
+  get port(): number;
+  start(): Promise<void>;
+  stop(): Promise<void>;
+  invokeTool(toolName: string, args: Record<string, unknown>, options?: {
+    sourceId?: string;
+    requestTabId?: string;
+  }): Promise<CallToolResult>;
+  private onSocketMessage;
+  private onSocketClose;
+  private isOriginAllowed;
+  private normalizeCallToolResult;
+}
+//#endregion
+//#region src/mcpRelayServer.d.ts
+interface LocalRelayMcpServerOptions {
+  bridge?: RelayBridgeServer;
+  bridgeOptions?: RelayBridgeServerOptions;
+  serverName?: string;
+  serverVersion?: string;
+}
+declare class LocalRelayMcpServer {
+  readonly bridge: RelayBridgeServer;
+  private readonly mcpServer;
+  private readonly dynamicToolHandles;
+  private readonly dynamicToolSignature;
+  private syncing;
+  private syncRequested;
+  private connected;
+  constructor(options?: LocalRelayMcpServerOptions);
+  start(): Promise<void>;
+  connect(transport: Transport): Promise<void>;
+  startStdio(): Promise<void>;
+  stop(): Promise<void>;
+  listDynamicToolNames(): string[];
+  private registerStaticTools;
+  private syncDynamicTools;
+  private applyDynamicTools;
+  private registerDynamicTool;
+  private dynamicToolDescription;
+  private normalizeAnnotations;
+  private toolSignature;
+}
+//#endregion
+//#region src/naming.d.ts
+declare function sanitizeName(value: string): string;
+declare function extractSanitizedDomain(originOrUrl?: string): string;
+declare function buildPublicToolName(options: {
+  domain: string;
+  tabId: string;
+  originalToolName: string;
+}): string;
+//#endregion
+export { type AggregatedTool, type BrowserToRelayMessage, BrowserToRelayMessageSchema, type BrowserTool, LocalRelayMcpServer, type LocalRelayMcpServerOptions, RelayBridgeServer, type RelayBridgeServerOptions, RelayRegistry, type RelayToBrowserMessage, RelayToBrowserMessageSchema, type ResolvedInvocation, type SourceInfo, buildPublicToolName, extractSanitizedDomain, sanitizeName };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/schemas.ts","../src/registry.ts","../src/bridgeServer.ts","../src/mcpRelayServer.ts","../src/naming.ts"],"sourcesContent":[],"mappings":";;;;;;cAIa,mBAAiB,CAAA,CAAA;;;;;EAAjB,WAAA,eAMX,YAAA,YAAA,cAAA,CAAA,CAAA;;;;;;;;;;;;;;cAEW,2BAAyB,CAAA,CAAA;;;;;;;;;EARR,KAAA,EAAA,MAAA;EAAA,MAAA,CAAA,EAAA,MAAA,GAAA,SAAA;EAQjB,GAAA,CAAA,EAAA,MAAA,GAAA,SAAA;;;;;;;;;;;cA6BA,6BAA2B,CAAA,CAAA,+BAAA,CAAA,CAAA;;;;;;EAuBA,OAAA,eAAA,YAAA,CAAA;;;;EAAA,MAAA,CAAA,EAAA,MAAA,GAAA,SAAA;EAAA,GAAA,CAAA,EAAA,MAAA,GAAA,SAAA;EAK5B,KAAA,CAAA,EAAA,MAAA,GAAA,SAAqB;;;;EClEhB,KAAA,EAAA,MAAU;EAYV,MAAA,CAAA,EAAA,MAAA,GAAc,SAAA;EAIhB,GAAA,CAAA,EAAA,MAAA,GAAA,SAAA;EACC,KAAA,CAAA,EAAA,MAAA,GAAA,SAAA;EACD,OAAA,CAAA,EAAA,MAAA,GAAA,SAAA;CACJ,CAAA,aAAA,CAAA;EAAU,IAAA,cAAA,CAAA,YAAA,CAAA;EAqBJ,KAAA,YAAA,YAAkB,CAAA;IAMtB,IAAA,aAAa;IAOkB,WAAA,eAAA,YAAA,CAAA;IAgBC,WAAA,eAAA,YAAA,YAAA,cAAA,CAAA,CAAA;IA+C5B,YAAA,eAAA,YAAA,YAAA,cAAA,CAAA,CAAA;IAWF,WAAA,eAAA,YAAA,YAAA,cAAA,CAAA,CAAA;EAiDT,CAAA,EAAA,OAAA,cAAA,EAAA;IAAkB,IAAA,EAAA,MAAA;;;;IClKP,WAAA,CAAA,QAAA,CAAA,MAAwB,EAAA,OAAA,CAAA,GAAA,SAAA;EAQ5B,CAAA,EAAA;IACQ,IAAA,EAAA,MAAA;IAaE,WAAA,CAAA,EAAA,MAAA,GAAA,SAAA;IAA0C,WAAA,CAAA,QAAA,CAAA,MAAA,EAAA,OAAA,CAAA,GAAA,SAAA;IAehD,YAAA,CAAA,QAAA,CAAA,MAAA,EAAA,OAAA,CAAA,GAAA,SAAA;IAgDD,WAAA,CAAA,QAAA,CAAA,MAAA,EAAA,OAAA,CAAA,GAAA,SAAA;EA+BN,CAAA,CAAA,EAAA,MAAA,CAAA;CAKG,EAAA,OAAA,cAAA,EAAA;EAAR,IAAA,EAAA,YAAA;EAjHkC,KAAA,EAAA;IAAY,IAAA,EAAA,MAAA;;;;ICZlC,WAAA,CAAA,QAAA,CAAA,MAA0B,EAAA,OAAA,CAChC,GAAA,SAAA;EAME,CAAA,EAAA;CACM,EAAA;EAUI,IAAA,EAAA,YAAA;EAeN,KAAA,EAAA;IAKU,IAAA,EAAA,MAAA;IAAY,WAAA,CAAA,EAAA,MAAA,GAAA,SAAA;IASjB,WAAA,CAAA,QAAA,CAAA,MAAA,EAAA,OAAA,CAAA,GAAA,SAAA;IAIN,YAAA,CAAA,QAAA,CAAA,MAAA,EAAA,OAAA,CAAA,GAAA,SAAA;IAAO,WAAA,CAAA,QAAA,CAAA,MAAA,EAAA,OAAA,CAAA,GAAA,SAAA;;;;EC5DP,KAAA,YAAY,YAAA,CAAA;IAIZ,IAAA,aAAA;IA2BA,WAAA,eAAmB,YAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KJcvB,qBAAA,GAAwB,CAAA,CAAE,aAAa;KACvC,WAAA,GAAc,CAAA,CAAE,aAAa;KAC7B,mBAAA,GAAsB,CAAA,CAAE,aAAa;cAapC,6BAA2B,CAAA,CAAA,+BAAA,CAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;KAK5B,qBAAA,GAAwB,CAAA,CAAE,aAAa;;;UClElC,UAAA;;;;;EDCJ,KAAA,EAAA,MAAA,GAAA,SAMX;;;;;;UCKe,cAAA;;;;eAIF;gBACC;eACD;WACJ;;UAqBM,kBAAA;;QAET;;;cAIK,aAAA;;;ED7CiB,iBAAA,mBAAA;EAAA,iBAAA,yBAAA;EAQjB,WAAA,CAAA,GAOX,CAPW,EAAA,GAAA,GAAA,MAOX;4CCqC0C;6CAgBC;;;iBA+C5B;eAWF;;;;;MAiDT;EDvKgC,QAAA,qBAAA;EAAA,QAAA,sBAAA;EA6BzB,QAAA,cAAA;;;;UExBI,wBAAA;;;EFbJ,cAAA,CAAA,EAAA,MAMX,EAAA;;;;cEeW,iBAAA,SAA0B,YAAA;qBAClB;;;;;;;;;;wBAaE,qCAA0C;;WAehD;UAgDD;qCA+BN;;;MAKL,QAAQ;EFtIiB,QAAA,eAAA;EAAA,QAAA,aAAA;EAQjB,QAAA,eAAA;;;;;UGCI,0BAAA;WACN;kBACO;;EHXL,aAAA,CAAA,EAAA,MAMX;;cGUW,mBAAA;mBACM;;;;;;;wBAUI;WAeN;qBAKU,YAAY;gBASjB;UAIN;;;;;;;;;;;;iBC5DA,YAAA;iBAIA,sBAAA;iBA2BA,mBAAA;;;;AJ/BhB,CAAA,CAAA,EAAa,MAAA"}

package/dist/index.js

@@ -0,0 +1,3 @@
+import { a as RelayRegistry, c as sanitizeName, i as RelayToBrowserMessageSchema, n as RelayBridgeServer, o as buildPublicToolName, r as BrowserToRelayMessageSchema, s as extractSanitizedDomain, t as LocalRelayMcpServer } from "./mcpRelayServer-BwF1i7Se.js";
+
+export { BrowserToRelayMessageSchema, LocalRelayMcpServer, RelayBridgeServer, RelayRegistry, RelayToBrowserMessageSchema, buildPublicToolName, extractSanitizedDomain, sanitizeName };