@ank1015/llm-extension 0.0.1

package/README.md

@@ -0,0 +1,214 @@
+# @ank1015/llm-extension
+
+A Chrome extension that exposes Chrome APIs over a general-purpose RPC bridge. Any process on your machine can connect via TCP and call Chrome APIs like `tabs.query`, `scripting.executeScript`, `storage.local.get`, or subscribe to events like `tabs.onUpdated` — all through a simple `call()` / `subscribe()` interface.
+
+## How It Works
+
+```
+Your Agent ── TCP :9224 ──→ Native Host ── stdin/stdout ──→ Chrome Extension
+                                │                               │
+                           ChromeServer                    background.ts
+                           (TCP proxy)                    (RPC proxy)
+```
+
+1. **Chrome extension** installs as a Manifest V3 service worker. On startup, it connects to a native messaging host.
+2. **Native host** is a Node.js process Chrome launches via the [Native Messaging](https://developer.chrome.com/docs/extensions/develop/concepts/native-messaging) protocol. It opens a TCP server on port 9224.
+3. **Your agent** connects to the TCP server and sends RPC messages. The native host forwards them to Chrome over stdin/stdout. Chrome executes the API call and sends the result back through the same chain.
+
+The protocol uses 6 message types: `call`, `subscribe`, `unsubscribe` (agent → Chrome) and `result`, `error`, `event` (Chrome → agent). All messages are length-prefixed JSON, correlated by UUID.
+
+## Setup
+
+### Prerequisites
+
+- Chrome browser
+- Node.js 18+
+- pnpm
+
+### Install
+
+```bash
+# Build the extension and native host
+pnpm build
+
+# Load the extension in Chrome:
+# 1. Open chrome://extensions
+# 2. Enable "Developer mode"
+# 3. Click "Load unpacked" → select packages/extension/dist/chrome/
+# 4. Copy the extension ID shown on the card
+
+# Register the native messaging host
+./manifests/install-host.sh <extension-id>
+
+# Quit and reopen Chrome (required for native host registration)
+```
+
+After this one-time setup, Chrome will automatically launch the native host whenever the extension loads.
+
+### Verify
+
+Check the extension's service worker console (`chrome://extensions` → Inspect views → service worker):
+
+```
+[bg] background service worker loaded
+```
+
+No disconnect error means the native host is running and the TCP server is ready on port 9224.
+
+## Usage
+
+### From TypeScript/JavaScript
+
+```ts
+import { connect } from '@ank1015/llm-extension';
+
+// Auto-launch Chrome if not running, retry until native host is ready
+const chrome = await connect({ launch: true });
+
+// Query tabs
+const tabs = await chrome.call('tabs.query', { active: true, currentWindow: true });
+console.log(tabs);
+
+// Execute JavaScript in a tab
+const result = await chrome.call('scripting.executeScript', {
+  target: { tabId: tabs[0].id },
+  code: 'document.title',
+});
+console.log(result[0].result); // page title
+
+// Use storage
+await chrome.call('storage.local.set', { myKey: 'myValue' });
+const data = await chrome.call('storage.local.get', 'myKey');
+console.log(data.myKey); // 'myValue'
+
+// Subscribe to events
+const unsubscribe = chrome.subscribe('tabs.onUpdated', (args) => {
+  const [tabId, changeInfo, tab] = args;
+  console.log(`Tab ${tabId} updated:`, changeInfo);
+});
+
+// Later...
+unsubscribe();
+```
+
+### From Any Language
+
+The protocol is language-agnostic. Connect to TCP port 9224 and exchange length-prefixed JSON:
+
+```
+[4 bytes: uint32 LE message length][JSON payload]
+```
+
+Send a call:
+
+```json
+{ "id": "uuid-here", "type": "call", "method": "tabs.query", "args": [{ "active": true }] }
+```
+
+Receive the result:
+
+```json
+{ "id": "uuid-here", "type": "result", "data": [{ "id": 1, "url": "https://..." }] }
+```
+
+## API
+
+### `connect(opts?)`
+
+Connect to the Chrome RPC server. Returns a `ChromeClient`.
+
+| Option          | Default       | Description                                         |
+| --------------- | ------------- | --------------------------------------------------- |
+| `port`          | `9224`        | TCP port to connect to                              |
+| `host`          | `'127.0.0.1'` | TCP host to connect to                              |
+| `launch`        | `false`       | Launch Chrome automatically if connection fails     |
+| `launchTimeout` | `30000`       | Max ms to wait for Chrome + native host to be ready |
+
+```ts
+const chrome = await connect();
+const chrome = await connect({ port: 9224, host: '127.0.0.1' });
+const chrome = await connect({ launch: true }); // auto-open Chrome if not running
+const chrome = await connect({ launch: true, launchTimeout: 15000 });
+```
+
+### `ChromeClient.call(method, ...args)`
+
+Call any Chrome API method. The method string maps to `chrome.<method>` in the extension.
+
+```ts
+// chrome.tabs.query({ active: true })
+await chrome.call('tabs.query', { active: true });
+
+// chrome.tabs.get(123)
+await chrome.call('tabs.get', 123);
+
+// chrome.storage.local.get('key')
+await chrome.call('storage.local.get', 'key');
+```
+
+### `ChromeClient.call('scripting.executeScript', opts)`
+
+Special case: pass a `code` string instead of a function reference. The code runs in the page's main world via `eval`.
+
+```ts
+await chrome.call('scripting.executeScript', {
+  target: { tabId: 123 },
+  code: 'document.title',
+});
+
+await chrome.call('scripting.executeScript', {
+  target: { tabId: 123 },
+  code: '({ title: document.title, url: location.href })',
+});
+```
+
+### `ChromeClient.subscribe(event, callback)`
+
+Subscribe to a Chrome event. Returns an unsubscribe function.
+
+```ts
+const unsub = chrome.subscribe('tabs.onUpdated', (args) => {
+  console.log('Tab updated:', args);
+});
+
+// Stop listening
+unsub();
+```
+
+## Configuration
+
+| Variable          | Default | Description                         |
+| ----------------- | ------- | ----------------------------------- |
+| `CHROME_RPC_PORT` | `9224`  | TCP port the native host listens on |
+
+Set in the wrapper script at `~/.local/share/llm-native-host/run-host.sh` or pass via `connect({ port })`.
+
+## Development
+
+```bash
+pnpm dev              # Watch mode (native + chrome)
+pnpm test             # Unit tests (25 tests)
+pnpm test:e2e         # E2E tests against live Chrome
+pnpm typecheck        # Type-check both tsconfigs
+```
+
+### Project Structure
+
+```
+src/
+  protocol/           # Shared message types and constants
+  sdk/                # ChromeClient, connect(), createChromeClient()
+  native/             # Node.js native host (host.ts, server.ts, stdio.ts)
+  chrome/             # Chrome extension (background.ts, manifest.json)
+tests/
+  unit/               # Unit tests (stdio, client, server, factory)
+  e2e/                # E2E tests against live Chrome
+manifests/            # Native host manifest and install script
+```
+
+### Two Build Targets
+
+The package has two runtime contexts with separate TypeScript configs:
+
+- **Node** (`tsconfig.json`): native host + SDK, compiled by `tsc` to `dist/`
+- **Chrome** (`tsconfig.chrome.json`): extension service worker, bundled by `esbuild` to `dist/chrome/`

package/dist/chrome/background.js

@@ -0,0 +1,244 @@
+// src/protocol/constants.ts
+var NATIVE_HOST_NAME = "com.ank1015.llm";
+var MAX_HOST_TO_CHROME_MESSAGE_SIZE_BYTES = 1024 * 1024;
+var MAX_CHROME_TO_HOST_MESSAGE_SIZE_BYTES = 64 * 1024 * 1024;
+var MAX_TCP_MESSAGE_SIZE_BYTES = 64 * 1024 * 1024;
+
+// src/chrome/background.ts
+var nativePort = null;
+var subscriptions = /* @__PURE__ */ new Map();
+function connectNative() {
+  const port = chrome.runtime.connectNative(NATIVE_HOST_NAME);
+  port.onMessage.addListener((message) => {
+    handleHostMessage(message);
+  });
+  port.onDisconnect.addListener(() => {
+    console.warn("[bg] native host disconnected", chrome.runtime.lastError?.message ?? "");
+    nativePort = null;
+    subscriptions.clear();
+  });
+  nativePort = port;
+  return port;
+}
+function sendToHost(message) {
+  if (!nativePort) {
+    connectNative();
+  }
+  nativePort.postMessage(message);
+}
+function handleHostMessage(message) {
+  switch (message.type) {
+    case "call":
+      handleCall(message);
+      break;
+    case "subscribe":
+      handleSubscribe(message);
+      break;
+    case "unsubscribe":
+      handleUnsubscribe(message);
+      break;
+    default:
+      console.warn("[bg] unknown message type:", message.type);
+  }
+}
+async function handleCall(message) {
+  try {
+    let result;
+    if (message.method === "debugger.evaluate") {
+      result = await debuggerEvaluate(message.args);
+    } else if (message.method === "debugger.attach") {
+      result = await debuggerAttach(message.args);
+    } else if (message.method === "debugger.sendCommand") {
+      result = await debuggerSendCommand(message.args);
+    } else if (message.method === "debugger.detach") {
+      result = await debuggerDetach(message.args);
+    } else if (message.method === "debugger.getEvents") {
+      result = debuggerGetEvents(message.args);
+    } else if (message.method === "scripting.executeScript" && hasCodeArg(message.args)) {
+      result = await executeScriptWithCode(message.args);
+    } else {
+      const fn = resolveMethod(message.method);
+      result = await fn(...message.args);
+    }
+    sendToHost({ id: message.id, type: "result", data: result });
+  } catch (error) {
+    sendToHost({
+      id: message.id,
+      type: "error",
+      error: error instanceof Error ? error.message : String(error)
+    });
+  }
+}
+function hasCodeArg(args2) {
+  return args2.length > 0 && typeof args2[0] === "object" && args2[0] !== null && "code" in args2[0];
+}
+async function executeScriptWithCode(args) {
+  const { code, target, world, ...rest } = args[0];
+  return chrome.scripting.executeScript({
+    ...rest,
+    target,
+    world: world ?? "MAIN",
+    // func is serialized by Chrome and executed in the TAB context (not the service worker).
+    // eval is allowed in MAIN world under the page's CSP.
+    func: (codeStr) => eval(codeStr),
+    args: [code]
+  });
+}
+async function debuggerEvaluate(args2) {
+  const {
+    tabId,
+    code: code2,
+    returnByValue = true,
+    awaitPromise = false,
+    userGesture = false
+  } = args2[0];
+  if (typeof tabId !== "number") {
+    throw new Error("debugger.evaluate requires a numeric tabId");
+  }
+  if (typeof code2 !== "string" || !code2) {
+    throw new Error("debugger.evaluate requires a non-empty code string");
+  }
+  let attachedByThisMethod = false;
+  try {
+    await chrome.debugger.attach({ tabId }, "1.3");
+    attachedByThisMethod = true;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (!message.includes("Another debugger is already attached")) {
+      throw new Error(`Failed to attach debugger to tab ${tabId}: ${message}`);
+    }
+  }
+  try {
+    const response = await chrome.debugger.sendCommand({ tabId }, "Runtime.evaluate", {
+      expression: code2,
+      returnByValue,
+      awaitPromise,
+      userGesture
+    });
+    if (response.exceptionDetails) {
+      const detail = response.exceptionDetails.exception?.description ?? response.exceptionDetails.text ?? "Unknown evaluation error";
+      throw new Error(detail);
+    }
+    return { result: response.result?.value, type: response.result?.type };
+  } finally {
+    if (attachedByThisMethod) {
+      try {
+        await chrome.debugger.detach({ tabId });
+      } catch {
+      }
+    }
+  }
+}
+var debuggerSessions = /* @__PURE__ */ new Map();
+function handleDebuggerEvent(source, method, params) {
+  if (source.tabId === void 0) return;
+  const session = debuggerSessions.get(source.tabId);
+  if (session) {
+    session.events.push({ method, params: params ?? {} });
+  }
+}
+chrome.debugger.onEvent.addListener(handleDebuggerEvent);
+async function debuggerAttach(args2) {
+  const { tabId } = args2[0];
+  if (debuggerSessions.has(tabId)) {
+    return { alreadyAttached: true };
+  }
+  await chrome.debugger.attach({ tabId }, "1.3");
+  debuggerSessions.set(tabId, { events: [] });
+  return { attached: true };
+}
+async function debuggerSendCommand(args2) {
+  const { tabId, method, params } = args2[0];
+  if (!debuggerSessions.has(tabId)) {
+    throw new Error(`No debugger session for tab ${tabId} \u2014 call debugger.attach first`);
+  }
+  return chrome.debugger.sendCommand({ tabId }, method, params);
+}
+async function debuggerDetach(args2) {
+  const { tabId } = args2[0];
+  debuggerSessions.delete(tabId);
+  try {
+    await chrome.debugger.detach({ tabId });
+  } catch {
+  }
+  return { detached: true };
+}
+function debuggerGetEvents(args2) {
+  const {
+    tabId,
+    filter,
+    clear = false
+  } = args2[0];
+  const session = debuggerSessions.get(tabId);
+  if (!session) {
+    throw new Error(`No debugger session for tab ${tabId}`);
+  }
+  let events = session.events;
+  if (filter) {
+    events = events.filter((e) => e.method.startsWith(filter));
+  }
+  const result = [...events];
+  if (clear) {
+    if (filter) {
+      session.events = session.events.filter((e) => !e.method.startsWith(filter));
+    } else {
+      session.events = [];
+    }
+  }
+  return result;
+}
+function resolveMethod(method) {
+  const parts = method.split(".");
+  let target2 = chrome;
+  let parent = chrome;
+  for (const part of parts) {
+    parent = target2;
+    target2 = target2[part];
+    if (target2 === void 0) {
+      throw new Error(`chrome.${method} is not available`);
+    }
+  }
+  if (typeof target2 !== "function") {
+    throw new Error(`chrome.${method} is not a function`);
+  }
+  return target2.bind(parent);
+}
+function handleSubscribe(message) {
+  try {
+    const parts = message.event.split(".");
+    let target2 = chrome;
+    for (const part of parts) {
+      target2 = target2[part];
+      if (target2 === void 0) {
+        throw new Error(`chrome.${message.event} is not available`);
+      }
+    }
+    const eventTarget = target2;
+    if (typeof eventTarget.addListener !== "function") {
+      throw new Error(`chrome.${message.event} is not an event`);
+    }
+    const listener = (...args2) => {
+      sendToHost({ id: message.id, type: "event", data: args2 });
+    };
+    eventTarget.addListener(listener);
+    subscriptions.set(message.id, { target: eventTarget, listener });
+  } catch (error) {
+    sendToHost({
+      id: message.id,
+      type: "error",
+      error: error instanceof Error ? error.message : String(error)
+    });
+  }
+}
+function handleUnsubscribe(message) {
+  const sub = subscriptions.get(message.id);
+  if (sub) {
+    sub.target.removeListener(sub.listener);
+    subscriptions.delete(message.id);
+  }
+}
+chrome.runtime.onStartup.addListener(() => {
+  if (!nativePort) connectNative();
+});
+console.warn("[bg] background service worker loaded");
+connectNative();

package/dist/chrome/manifest.json

@@ -0,0 +1,23 @@
+{
+  "manifest_version": 3,
+  "name": "LLM Extension",
+  "version": "0.0.1",
+  "description": "Chrome extension with general-purpose native messaging RPC",
+  "permissions": [
+    "nativeMessaging",
+    "scripting",
+    "activeTab",
+    "tabs",
+    "storage",
+    "cookies",
+    "downloads",
+    "debugger",
+    "accessibilityFeatures.read",
+    "accessibilityFeatures.modify"
+  ],
+  "host_permissions": ["<all_urls>"],
+  "background": {
+    "service_worker": "background.js",
+    "type": "module"
+  }
+}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export type { CallMessage, SubscribeMessage, UnsubscribeMessage, HostMessage, ResultMessage, ErrorMessage, EventMessage, ChromeMessage, } from './protocol/types.js';
+export { NATIVE_HOST_NAME, MAX_HOST_TO_CHROME_MESSAGE_SIZE_BYTES, MAX_CHROME_TO_HOST_MESSAGE_SIZE_BYTES, MAX_TCP_MESSAGE_SIZE_BYTES, MAX_MESSAGE_SIZE_BYTES, LENGTH_PREFIX_BYTES, DEFAULT_PORT, } from './protocol/constants.js';
+export { ChromeClient, createChromeClient, connect, Window } from './sdk/index.js';
+export type { ChromeClientOptions, ConnectOptions, ObserveFilter, WindowActionOptions, WindowDownloadOptions, WindowEvaluateOptions, WindowGetPageOptions, WindowObserveOptions, WindowOpenOptions, WindowScrollBehavior, WindowScrollOptions, WindowSemanticFilter, WindowScreenshotOptions, WindowTab, WindowTypeOptions, } from './sdk/index.js';
+export { ChromeServer } from './native/server.js';
+export type { ChromeServerOptions } from './native/server.js';
+export { readMessage, writeMessage } from './native/stdio.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,YAAY,EACV,WAAW,EACX,gBAAgB,EAChB,kBAAkB,EAClB,WAAW,EACX,aAAa,EACb,YAAY,EACZ,YAAY,EACZ,aAAa,GACd,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EACL,gBAAgB,EAChB,qCAAqC,EACrC,qCAAqC,EACrC,0BAA0B,EAC1B,sBAAsB,EACtB,mBAAmB,EACnB,YAAY,GACb,MAAM,yBAAyB,CAAC;AAGjC,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AACnF,YAAY,EACV,mBAAmB,EACnB,cAAc,EACd,aAAa,EACb,mBAAmB,EACnB,qBAAqB,EACrB,qBAAqB,EACrB,oBAAoB,EACpB,oBAAoB,EACpB,iBAAiB,EACjB,oBAAoB,EACpB,mBAAmB,EACnB,oBAAoB,EACpB,uBAAuB,EACvB,SAAS,EACT,iBAAiB,GAClB,MAAM,gBAAgB,CAAC;AAGxB,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,YAAY,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAG9D,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/index.js

@@ -0,0 +1,8 @@
+export { NATIVE_HOST_NAME, MAX_HOST_TO_CHROME_MESSAGE_SIZE_BYTES, MAX_CHROME_TO_HOST_MESSAGE_SIZE_BYTES, MAX_TCP_MESSAGE_SIZE_BYTES, MAX_MESSAGE_SIZE_BYTES, LENGTH_PREFIX_BYTES, DEFAULT_PORT, } from './protocol/constants.js';
+// SDK
+export { ChromeClient, createChromeClient, connect, Window } from './sdk/index.js';
+// Server
+export { ChromeServer } from './native/server.js';
+// Native host stdio utilities
+export { readMessage, writeMessage } from './native/stdio.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAYA,OAAO,EACL,gBAAgB,EAChB,qCAAqC,EACrC,qCAAqC,EACrC,0BAA0B,EAC1B,sBAAsB,EACtB,mBAAmB,EACnB,YAAY,GACb,MAAM,yBAAyB,CAAC;AAEjC,MAAM;AACN,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAmBnF,SAAS;AACT,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAGlD,8BAA8B;AAC9B,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/native/host-wrapper.sh

@@ -0,0 +1,11 @@
+#!/bin/sh
+# Chrome launches this script as the native messaging host.
+# It resolves its own directory and invokes the Node.js host.
+#
+# NOTE: This wrapper is only used for local development.
+# The install-host.sh script creates a separate wrapper in
+# ~/.local/share/llm-native-host/ with an absolute node path.
+
+DIR="$(cd "$(dirname "$0")" && pwd)"
+export PATH="/opt/homebrew/bin:/usr/local/bin:$PATH"
+exec node "$DIR/native/host.js"

package/dist/native/host.d.ts

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

package/dist/native/host.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"host.d.ts","sourceRoot":"","sources":["../../src/native/host.ts"],"names":[],"mappings":""}

package/dist/native/host.js

@@ -0,0 +1,21 @@
+import { DEFAULT_PORT, MAX_CHROME_TO_HOST_MESSAGE_SIZE_BYTES, MAX_HOST_TO_CHROME_MESSAGE_SIZE_BYTES, } from '../protocol/constants.js';
+import { ChromeClient } from '../sdk/client.js';
+import { ChromeServer } from './server.js';
+function log(msg) {
+    process.stderr.write(`[host] ${msg}\n`);
+}
+log(`started (pid=${process.pid})`);
+const client = new ChromeClient({
+    maxIncomingMessageSizeBytes: MAX_CHROME_TO_HOST_MESSAGE_SIZE_BYTES,
+    maxOutgoingMessageSizeBytes: MAX_HOST_TO_CHROME_MESSAGE_SIZE_BYTES,
+});
+client.run().then(() => {
+    log('Chrome disconnected, exiting');
+    process.exit(0);
+}, (e) => {
+    log(`fatal: ${e instanceof Error ? e.message : String(e)}`);
+    process.exit(1);
+});
+const port = process.env.CHROME_RPC_PORT ? parseInt(process.env.CHROME_RPC_PORT, 10) : DEFAULT_PORT;
+new ChromeServer(client, { port });
+//# sourceMappingURL=host.js.map

package/dist/native/host.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"host.js","sourceRoot":"","sources":["../../src/native/host.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,qCAAqC,EACrC,qCAAqC,GACtC,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAEhD,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE3C,SAAS,GAAG,CAAC,GAAW;IACtB,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,UAAU,GAAG,IAAI,CAAC,CAAC;AAC1C,CAAC;AAED,GAAG,CAAC,gBAAgB,OAAO,CAAC,GAAG,GAAG,CAAC,CAAC;AAEpC,MAAM,MAAM,GAAG,IAAI,YAAY,CAAC;IAC9B,2BAA2B,EAAE,qCAAqC;IAClE,2BAA2B,EAAE,qCAAqC;CACnE,CAAC,CAAC;AACH,MAAM,CAAC,GAAG,EAAE,CAAC,IAAI,CACf,GAAG,EAAE;IACH,GAAG,CAAC,8BAA8B,CAAC,CAAC;IACpC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AAClB,CAAC,EACD,CAAC,CAAC,EAAE,EAAE;IACJ,GAAG,CAAC,UAAU,CAAC,YAAY,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;IAC5D,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AAClB,CAAC,CACF,CAAC;AAEF,MAAM,IAAI,GAAG,OAAO,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,eAAe,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC;AAEpG,IAAI,YAAY,CAAC,MAAM,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC"}

package/dist/native/server.d.ts

@@ -0,0 +1,28 @@
+import type { ChromeClient } from '../sdk/client.js';
+export interface ChromeServerOptions {
+    port?: number;
+    host?: string;
+}
+/**
+ * TCP server that proxies Chrome API calls from external agents
+ * through a ChromeClient connected to Chrome's native messaging.
+ *
+ * Each TCP connection gets its own read loop and subscription tracking.
+ * Multiple agents can connect simultaneously.
+ */
+export declare class ChromeServer {
+    private server;
+    private chromeClient;
+    constructor(chromeClient: ChromeClient, opts?: ChromeServerOptions);
+    private handleConnection;
+    private handleCall;
+    private handleSubscribe;
+    private handleUnsubscribe;
+    private send;
+    close(): void;
+    get address(): {
+        port: number;
+        host: string;
+    } | null;
+}
+//# sourceMappingURL=server.d.ts.map

package/dist/native/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/native/server.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAGrD,MAAM,WAAW,mBAAmB;IAClC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;;;;;GAMG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,YAAY,CAAe;gBAEvB,YAAY,EAAE,YAAY,EAAE,IAAI,CAAC,EAAE,mBAAmB;YAmBpD,gBAAgB;YAuChB,UAAU;IAaxB,OAAO,CAAC,eAAe;IAWvB,OAAO,CAAC,iBAAiB;IAQzB,OAAO,CAAC,IAAI;IAYZ,KAAK,IAAI,IAAI;IAIb,IAAI,OAAO,IAAI;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAMnD;CACF"}