@ank1015/llm-extension 0.0.1

package/dist/sdk/action/script.js

@@ -0,0 +1,359 @@
+function isObject(value) {
+    return typeof value === 'object' && value !== null;
+}
+export function buildActionScript(payload) {
+    const serializedPayload = JSON.stringify(payload);
+    return `
+(() => {
+  const payload = ${serializedPayload};
+
+  const normalizeText = (value, maxLength = 180) => {
+    if (typeof value !== 'string') return '';
+    const compact = value.replace(/\\s+/g, ' ').trim();
+    if (!compact) return '';
+    if (compact.length <= maxLength) return compact;
+    return compact.slice(0, Math.max(1, maxLength - 3)) + '...';
+  };
+
+  const result = (success, action, message, selectorUsed) => ({
+    success,
+    action,
+    message,
+    selectorUsed: selectorUsed || '',
+  });
+
+  const resolveElement = (selectors) => {
+    if (!Array.isArray(selectors)) {
+      return { element: null, selectorUsed: '' };
+    }
+
+    for (const selector of selectors) {
+      if (typeof selector !== 'string' || !selector.trim()) {
+        continue;
+      }
+
+      try {
+        const element = document.querySelector(selector);
+        if (element) {
+          return {
+            element,
+            selectorUsed: selector,
+          };
+        }
+      } catch {
+        // Ignore invalid selectors and keep trying.
+      }
+    }
+
+    return { element: null, selectorUsed: '' };
+  };
+
+  const focusElement = (element) => {
+    if (typeof element.focus === 'function') {
+      element.focus();
+    }
+  };
+
+  const scrollIntoView = (element, behavior = 'auto') => {
+    if (typeof element.scrollIntoView === 'function') {
+      element.scrollIntoView({ block: 'center', inline: 'nearest', behavior });
+    }
+  };
+
+  const dispatchInputEvents = (element) => {
+    element.dispatchEvent(new Event('input', { bubbles: true, cancelable: true }));
+    element.dispatchEvent(new Event('change', { bubbles: true, cancelable: true }));
+  };
+
+  const isContentEditable = (element) => {
+    if (!element) return false;
+    if (element.isContentEditable) return true;
+    const attr =
+      typeof element.getAttribute === 'function' ? element.getAttribute('contenteditable') : null;
+    if (typeof attr !== 'string') return false;
+    const normalized = attr.trim().toLowerCase();
+    return normalized === '' || normalized === 'true' || normalized === 'plaintext-only';
+  };
+
+  const getTypeableElement = (element) => {
+    if (!element) return null;
+    if (element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement) {
+      return element;
+    }
+    if (isContentEditable(element)) {
+      return element;
+    }
+    const nested = element.querySelector(
+      'input:not([type="hidden"]), textarea, [contenteditable], [role="textbox"], [role="searchbox"], [role="combobox"]'
+    );
+    if (!nested) return null;
+    if (nested instanceof HTMLInputElement || nested instanceof HTMLTextAreaElement) return nested;
+    if (isContentEditable(nested)) return nested;
+    return null;
+  };
+
+  const setInputValue = (element, value) => {
+    const prototype = Object.getPrototypeOf(element);
+    const descriptor =
+      Object.getOwnPropertyDescriptor(prototype, 'value') ||
+      Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, 'value') ||
+      Object.getOwnPropertyDescriptor(HTMLTextAreaElement.prototype, 'value');
+
+    if (descriptor && typeof descriptor.set === 'function') {
+      descriptor.set.call(element, value);
+    } else {
+      element.value = value;
+    }
+  };
+
+  const clickElement = (element) => {
+    focusElement(element);
+    element.dispatchEvent(new MouseEvent('pointerdown', { bubbles: true, cancelable: true }));
+    element.dispatchEvent(new MouseEvent('mousedown', { bubbles: true, cancelable: true }));
+    element.dispatchEvent(new MouseEvent('pointerup', { bubbles: true, cancelable: true }));
+    element.dispatchEvent(new MouseEvent('mouseup', { bubbles: true, cancelable: true }));
+    if (typeof element.click === 'function') {
+      element.click();
+    } else {
+      element.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true }));
+    }
+  };
+
+  const hoverElement = (element) => {
+    element.dispatchEvent(new MouseEvent('pointerover', { bubbles: true, cancelable: true }));
+    element.dispatchEvent(new MouseEvent('mouseover', { bubbles: true, cancelable: true }));
+    element.dispatchEvent(new MouseEvent('mouseenter', { bubbles: true, cancelable: true }));
+    element.dispatchEvent(new MouseEvent('mousemove', { bubbles: true, cancelable: true }));
+  };
+
+  const pressEnter = (element) => {
+    focusElement(element);
+    const eventInit = {
+      key: 'Enter',
+      code: 'Enter',
+      keyCode: 13,
+      which: 13,
+      bubbles: true,
+      cancelable: true,
+    };
+    element.dispatchEvent(new KeyboardEvent('keydown', eventInit));
+    element.dispatchEvent(new KeyboardEvent('keypress', eventInit));
+    element.dispatchEvent(new KeyboardEvent('keyup', eventInit));
+
+    const form = typeof element.closest === 'function' ? element.closest('form') : null;
+    if (form && typeof form.requestSubmit === 'function') {
+      form.requestSubmit();
+    }
+  };
+
+  const action = payload.action;
+  const resolved = resolveElement(payload.selectors || []);
+  const element = resolved.element;
+  const selectorUsed = resolved.selectorUsed;
+
+  try {
+    if (action === 'scroll') {
+      if (element) {
+        scrollIntoView(element, payload.scroll?.behavior || 'auto');
+        return result(true, action, 'Scrolled target into view', selectorUsed);
+      }
+
+      if (payload.scroll && payload.scroll.to) {
+        const behavior = payload.scroll.behavior || 'auto';
+        if (payload.scroll.to === 'top') {
+          window.scrollTo({ top: 0, behavior });
+          return result(true, action, 'Scrolled page to top', '');
+        }
+        if (payload.scroll.to === 'bottom') {
+          window.scrollTo({
+            top: Math.max(0, document.documentElement.scrollHeight - window.innerHeight),
+            behavior,
+          });
+          return result(true, action, 'Scrolled page to bottom', '');
+        }
+        if (payload.scroll.to === 'left') {
+          window.scrollTo({ left: 0, behavior });
+          return result(true, action, 'Scrolled page to left edge', '');
+        }
+        if (payload.scroll.to === 'right') {
+          window.scrollTo({
+            left: Math.max(0, document.documentElement.scrollWidth - window.innerWidth),
+            behavior,
+          });
+          return result(true, action, 'Scrolled page to right edge', '');
+        }
+      }
+
+      const x = typeof payload.scroll?.x === 'number' ? payload.scroll.x : 0;
+      const y =
+        typeof payload.scroll?.y === 'number' ? payload.scroll.y : Math.round(window.innerHeight * 0.8);
+      window.scrollBy({
+        left: x,
+        top: y,
+        behavior: payload.scroll?.behavior || 'auto',
+      });
+      return result(true, action, 'Scrolled page', '');
+    }
+
+    if (!element) {
+      return result(false, action, 'Target element not found', '');
+    }
+
+    scrollIntoView(element, 'auto');
+
+    if (action === 'focus') {
+      focusElement(element);
+      const active = document.activeElement;
+      const focused = active === element || element.contains(active);
+      return result(focused, action, focused ? 'Focused target element' : 'Focus had no effect', selectorUsed);
+    }
+
+    if (action === 'hover') {
+      hoverElement(element);
+      return result(true, action, 'Hovered target element', selectorUsed);
+    }
+
+    if (action === 'click') {
+      clickElement(element);
+      return result(true, action, 'Clicked target element', selectorUsed);
+    }
+
+    if (action === 'pressEnter') {
+      pressEnter(element);
+      return result(true, action, 'Pressed Enter on target element', selectorUsed);
+    }
+
+    if (action === 'toggle') {
+      const type = normalizeText(element.getAttribute('type') || '', 40).toLowerCase();
+      if (type === 'checkbox' || type === 'radio') {
+        clickElement(element);
+        return result(true, action, 'Toggled input', selectorUsed);
+      }
+
+      if (element.getAttribute('aria-pressed') !== null) {
+        clickElement(element);
+        return result(true, action, 'Toggled aria-pressed control', selectorUsed);
+      }
+
+      return result(false, action, 'Toggle requires checkbox, radio, or aria-pressed control', selectorUsed);
+    }
+
+    if (action === 'clear') {
+      const typeable = getTypeableElement(element);
+      if (!typeable) {
+        return result(false, action, 'Clear requires an editable target', selectorUsed);
+      }
+
+      focusElement(typeable);
+      if (isContentEditable(typeable)) {
+        typeable.textContent = '';
+        dispatchInputEvents(typeable);
+        return result(true, action, 'Cleared editable target', selectorUsed);
+      }
+
+      setInputValue(typeable, '');
+      dispatchInputEvents(typeable);
+      return result(true, action, 'Cleared input value', selectorUsed);
+    }
+
+    if (action === 'type') {
+      if (typeof payload.value !== 'string') {
+        return result(false, action, 'Type requires a string value', selectorUsed);
+      }
+
+      const typeable = getTypeableElement(element);
+      if (!typeable) {
+        return result(false, action, 'Type requires an editable target', selectorUsed);
+      }
+
+      focusElement(typeable);
+      const clearBeforeType = payload.clearBeforeType !== false;
+      const value = payload.value;
+
+      if (isContentEditable(typeable)) {
+        const previous = typeof typeable.textContent === 'string' ? typeable.textContent : '';
+        typeable.textContent = clearBeforeType ? value : previous + value;
+        dispatchInputEvents(typeable);
+      } else {
+        const previous = typeof typeable.value === 'string' ? typeable.value : '';
+        setInputValue(typeable, clearBeforeType ? value : previous + value);
+        dispatchInputEvents(typeable);
+      }
+
+      if (payload.pressEnter) {
+        pressEnter(typeable);
+      }
+
+      return result(
+        true,
+        action,
+        payload.pressEnter ? 'Typed into target and pressed Enter' : 'Typed into target',
+        selectorUsed
+      );
+    }
+
+    if (action === 'select') {
+      if (typeof payload.value !== 'string') {
+        return result(false, action, 'Select requires a string value', selectorUsed);
+      }
+
+      const selectElement =
+        element instanceof HTMLSelectElement
+          ? element
+          : element.querySelector('select');
+
+      if (!(selectElement instanceof HTMLSelectElement)) {
+        return result(false, action, 'Select requires a <select> target', selectorUsed);
+      }
+
+      const value = payload.value;
+      const normalized = normalizeText(value, 180).toLowerCase();
+      const matched =
+        Array.from(selectElement.options).find((option) => option.value === value) ||
+        Array.from(selectElement.options).find(
+          (option) => normalizeText(option.textContent || '', 180).toLowerCase() === normalized
+        ) ||
+        Array.from(selectElement.options).find((option) =>
+          normalizeText(option.textContent || '', 180).toLowerCase().includes(normalized)
+        );
+
+      if (!matched) {
+        return result(false, action, 'No matching select option found', selectorUsed);
+      }
+
+      selectElement.value = matched.value;
+      dispatchInputEvents(selectElement);
+
+      return result(true, action, 'Selected option', selectorUsed);
+    }
+
+    return result(false, action, 'Unsupported action type', selectorUsed);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return result(false, action, message, selectorUsed);
+  }
+})()
+`.trim();
+}
+export function parseActionExecutionResult(raw) {
+    if (!isObject(raw)) {
+        throw new Error('Action returned an invalid payload');
+    }
+    const success = raw.success;
+    const action = raw.action;
+    const message = raw.message;
+    const selectorUsed = raw.selectorUsed;
+    if (typeof success !== 'boolean' || typeof action !== 'string' || typeof message !== 'string') {
+        throw new Error('Action payload is missing required fields');
+    }
+    const parsed = {
+        success,
+        action,
+        message,
+    };
+    if (typeof selectorUsed === 'string') {
+        parsed.selectorUsed = selectorUsed;
+    }
+    return parsed;
+}
+//# sourceMappingURL=script.js.map

package/dist/sdk/action/script.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"script.js","sourceRoot":"","sources":["../../../src/sdk/action/script.ts"],"names":[],"mappings":"AAEA,SAAS,QAAQ,CAAC,KAAc;IAC9B,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,CAAC;AACrD,CAAC;AAED,MAAM,UAAU,iBAAiB,CAAC,OAAkC;IAClE,MAAM,iBAAiB,GAAG,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;IAElD,OAAO;;oBAEW,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwUpC,CAAC,IAAI,EAAE,CAAC;AACT,CAAC;AAED,MAAM,UAAU,0BAA0B,CAAC,GAAY;IACrD,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;QACnB,MAAM,IAAI,KAAK,CAAC,oCAAoC,CAAC,CAAC;IACxD,CAAC;IAED,MAAM,OAAO,GAAG,GAAG,CAAC,OAAO,CAAC;IAC5B,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC;IAC1B,MAAM,OAAO,GAAG,GAAG,CAAC,OAAO,CAAC;IAC5B,MAAM,YAAY,GAAG,GAAG,CAAC,YAAY,CAAC;IAEtC,IAAI,OAAO,OAAO,KAAK,SAAS,IAAI,OAAO,MAAM,KAAK,QAAQ,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE,CAAC;QAC9F,MAAM,IAAI,KAAK,CAAC,2CAA2C,CAAC,CAAC;IAC/D,CAAC;IAED,MAAM,MAAM,GAAgC;QAC1C,OAAO;QACP,MAAM;QACN,OAAO;KACR,CAAC;IAEF,IAAI,OAAO,YAAY,KAAK,QAAQ,EAAE,CAAC;QACrC,MAAM,CAAC,YAAY,GAAG,YAAY,CAAC;IACrC,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/dist/sdk/action/types.d.ts

@@ -0,0 +1,47 @@
+import type { ObserveLocator } from '../observe/types.js';
+export interface WindowActionOptions {
+    tabId?: number;
+    timeoutMs?: number;
+}
+export interface WindowTypeOptions extends WindowActionOptions {
+    clearBeforeType?: boolean;
+    pressEnter?: boolean;
+}
+export type WindowScrollBehavior = 'auto' | 'smooth';
+export interface WindowScrollOptions extends WindowActionOptions {
+    targetId?: string;
+    x?: number;
+    y?: number;
+    to?: 'top' | 'bottom' | 'left' | 'right';
+    behavior?: WindowScrollBehavior;
+}
+export type WindowTargetActionType = 'click' | 'hover' | 'focus' | 'pressEnter' | 'clear' | 'type' | 'select' | 'toggle';
+export interface WindowObservedActionTarget {
+    id: string;
+    tag: string;
+    role: string;
+    name: string;
+    href?: string;
+    locator: ObserveLocator;
+    actions: string[];
+}
+export interface WindowActionScriptPayload {
+    action: WindowTargetActionType | 'scroll';
+    selectors: string[];
+    value?: string;
+    clearBeforeType?: boolean;
+    pressEnter?: boolean;
+    scroll?: {
+        x?: number;
+        y?: number;
+        to?: 'top' | 'bottom' | 'left' | 'right';
+        behavior?: WindowScrollBehavior;
+    };
+}
+export interface WindowActionExecutionResult {
+    success: boolean;
+    action: string;
+    message: string;
+    selectorUsed?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/sdk/action/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/sdk/action/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAE1D,MAAM,WAAW,mBAAmB;IAClC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,iBAAkB,SAAQ,mBAAmB;IAC5D,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED,MAAM,MAAM,oBAAoB,GAAG,MAAM,GAAG,QAAQ,CAAC;AAErD,MAAM,WAAW,mBAAoB,SAAQ,mBAAmB;IAC9D,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,EAAE,CAAC,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,OAAO,CAAC;IACzC,QAAQ,CAAC,EAAE,oBAAoB,CAAC;CACjC;AAED,MAAM,MAAM,sBAAsB,GAC9B,OAAO,GACP,OAAO,GACP,OAAO,GACP,YAAY,GACZ,OAAO,GACP,MAAM,GACN,QAAQ,GACR,QAAQ,CAAC;AAEb,MAAM,WAAW,0BAA0B;IACzC,EAAE,EAAE,MAAM,CAAC;IACX,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,cAAc,CAAC;IACxB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,MAAM,WAAW,yBAAyB;IACxC,MAAM,EAAE,sBAAsB,GAAG,QAAQ,CAAC;IAC1C,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,MAAM,CAAC,EAAE;QACP,CAAC,CAAC,EAAE,MAAM,CAAC;QACX,CAAC,CAAC,EAAE,MAAM,CAAC;QACX,EAAE,CAAC,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,OAAO,CAAC;QACzC,QAAQ,CAAC,EAAE,oBAAoB,CAAC;KACjC,CAAC;CACH;AAED,MAAM,WAAW,2BAA2B;IAC1C,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB"}

package/dist/sdk/action/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/sdk/action/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/sdk/action/types.ts"],"names":[],"mappings":""}

package/dist/sdk/client.d.ts

@@ -0,0 +1,42 @@
+import type { Readable, Writable } from 'node:stream';
+export interface ChromeClientOptions {
+    input?: Readable;
+    output?: Writable;
+    maxIncomingMessageSizeBytes?: number;
+    maxOutgoingMessageSizeBytes?: number;
+}
+/**
+ * RPC client for calling Chrome APIs over native messaging.
+ *
+ * Sends call/subscribe/unsubscribe messages to Chrome and routes
+ * incoming result/error/event responses to the correct handlers.
+ */
+export declare class ChromeClient {
+    private input;
+    private output;
+    private pendingCalls;
+    private eventCallbacks;
+    private closed;
+    private maxIncomingMessageSizeBytes;
+    private maxOutgoingMessageSizeBytes;
+    constructor(opts?: ChromeClientOptions);
+    /** Call a Chrome API method and wait for the result. */
+    call(method: string, ...args: unknown[]): Promise<unknown>;
+    /**
+     * Subscribe to a Chrome event. Returns an unsubscribe function.
+     *
+     * The callback is invoked with the event arguments array each time
+     * the Chrome event fires.
+     */
+    subscribe(event: string, callback: (data: unknown) => void): () => void;
+    /**
+     * Start the read loop. Runs until stdin closes (EOF).
+     *
+     * Must be running for `call()` and `subscribe()` to receive responses.
+     * The returned promise resolves on clean disconnect, rejects on read errors.
+     */
+    run(): Promise<void>;
+    private send;
+    private cleanup;
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/sdk/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/sdk/client.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEtD,MAAM,WAAW,mBAAmB;IAClC,KAAK,CAAC,EAAE,QAAQ,CAAC;IACjB,MAAM,CAAC,EAAE,QAAQ,CAAC;IAClB,2BAA2B,CAAC,EAAE,MAAM,CAAC;IACrC,2BAA2B,CAAC,EAAE,MAAM,CAAC;CACtC;AAOD;;;;;GAKG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,KAAK,CAAuB;IACpC,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,YAAY,CAAkC;IACtD,OAAO,CAAC,cAAc,CAA8C;IACpE,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,2BAA2B,CAAS;IAC5C,OAAO,CAAC,2BAA2B,CAAS;gBAEhC,IAAI,CAAC,EAAE,mBAAmB;IAOtC,wDAAwD;IAClD,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC;IAahE;;;;;OAKG;IACH,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,GAAG,MAAM,IAAI;IAevE;;;;;OAKG;IACG,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;IAkD1B,OAAO,CAAC,IAAI;IAMZ,OAAO,CAAC,OAAO;CAQhB"}

package/dist/sdk/client.js

@@ -0,0 +1,118 @@
+import { randomUUID } from 'node:crypto';
+import { readMessageWithOptions, writeMessageWithOptions } from '../native/stdio.js';
+import { MAX_MESSAGE_SIZE_BYTES } from '../protocol/constants.js';
+/**
+ * RPC client for calling Chrome APIs over native messaging.
+ *
+ * Sends call/subscribe/unsubscribe messages to Chrome and routes
+ * incoming result/error/event responses to the correct handlers.
+ */
+export class ChromeClient {
+    input;
+    output;
+    pendingCalls = new Map();
+    eventCallbacks = new Map();
+    closed = false;
+    maxIncomingMessageSizeBytes;
+    maxOutgoingMessageSizeBytes;
+    constructor(opts) {
+        this.input = opts?.input;
+        this.output = opts?.output;
+        this.maxIncomingMessageSizeBytes = opts?.maxIncomingMessageSizeBytes ?? MAX_MESSAGE_SIZE_BYTES;
+        this.maxOutgoingMessageSizeBytes = opts?.maxOutgoingMessageSizeBytes ?? MAX_MESSAGE_SIZE_BYTES;
+    }
+    /** Call a Chrome API method and wait for the result. */
+    async call(method, ...args) {
+        if (this.closed) {
+            throw new Error('ChromeClient connection is closed');
+        }
+        const id = randomUUID();
+        this.send({ id, type: 'call', method, args });
+        return new Promise((resolve, reject) => {
+            this.pendingCalls.set(id, { resolve, reject });
+        });
+    }
+    /**
+     * Subscribe to a Chrome event. Returns an unsubscribe function.
+     *
+     * The callback is invoked with the event arguments array each time
+     * the Chrome event fires.
+     */
+    subscribe(event, callback) {
+        if (this.closed) {
+            throw new Error('ChromeClient connection is closed');
+        }
+        const id = randomUUID();
+        this.send({ id, type: 'subscribe', event });
+        this.eventCallbacks.set(id, callback);
+        return () => {
+            this.send({ id, type: 'unsubscribe' });
+            this.eventCallbacks.delete(id);
+        };
+    }
+    /**
+     * Start the read loop. Runs until stdin closes (EOF).
+     *
+     * Must be running for `call()` and `subscribe()` to receive responses.
+     * The returned promise resolves on clean disconnect, rejects on read errors.
+     */
+    async run() {
+        while (true) {
+            let message;
+            try {
+                message = await readMessageWithOptions(this.input, {
+                    maxMessageSizeBytes: this.maxIncomingMessageSizeBytes,
+                });
+            }
+            catch (error) {
+                this.cleanup(error instanceof Error ? error : new Error(String(error)));
+                throw error;
+            }
+            if (message === null) {
+                this.cleanup(new Error('Connection closed'));
+                return;
+            }
+            switch (message.type) {
+                case 'result': {
+                    const pending = this.pendingCalls.get(message.id);
+                    if (pending) {
+                        this.pendingCalls.delete(message.id);
+                        pending.resolve(message.data);
+                    }
+                    break;
+                }
+                case 'error': {
+                    const pending = this.pendingCalls.get(message.id);
+                    if (pending) {
+                        this.pendingCalls.delete(message.id);
+                        pending.reject(new Error(message.error));
+                    }
+                    // If error was for a subscription setup, clean it up
+                    if (this.eventCallbacks.has(message.id)) {
+                        this.eventCallbacks.delete(message.id);
+                    }
+                    break;
+                }
+                case 'event': {
+                    const callback = this.eventCallbacks.get(message.id);
+                    callback?.(message.data);
+                    break;
+                }
+            }
+        }
+    }
+    send(message) {
+        writeMessageWithOptions(message, this.output, {
+            maxMessageSizeBytes: this.maxOutgoingMessageSizeBytes,
+        });
+    }
+    cleanup(error) {
+        this.closed = true;
+        for (const [, pending] of this.pendingCalls) {
+            pending.reject(error);
+        }
+        this.pendingCalls.clear();
+        this.eventCallbacks.clear();
+    }
+}
+//# sourceMappingURL=client.js.map

package/dist/sdk/client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","sourceRoot":"","sources":["../../src/sdk/client.ts"],"names":[],"mappings":"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"}

package/dist/sdk/connect.d.ts

@@ -0,0 +1,29 @@
+import { ChromeClient } from './client.js';
+export interface ConnectOptions {
+    port?: number;
+    host?: string;
+    /** Launch Chrome automatically if connection fails. Default: false */
+    launch?: boolean;
+    /** Max ms to wait for Chrome + native host to be ready. Default: 30000 */
+    launchTimeout?: number;
+}
+/**
+ * Connect to the Chrome RPC server over TCP.
+ *
+ * Returns a ChromeClient with the same `call()` and `subscribe()` API
+ * as the native host uses directly. The connection is multiplexed —
+ * multiple calls and subscriptions can be in-flight simultaneously.
+ *
+ * When `launch: true` is set, Chrome will be opened automatically
+ * if the connection fails, then retried until the native host is ready.
+ *
+ * @example
+ * ```ts
+ * import { connect } from '@ank1015/llm-extension';
+ *
+ * const chrome = await connect({ launch: true });
+ * const tabs = await chrome.call('tabs.query', { active: true });
+ * ```
+ */
+export declare function connect(opts?: ConnectOptions): Promise<ChromeClient>;
+//# sourceMappingURL=connect.d.ts.map

package/dist/sdk/connect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connect.d.ts","sourceRoot":"","sources":["../../src/sdk/connect.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE3C,MAAM,WAAW,cAAc;IAC7B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,sEAAsE;IACtE,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,0EAA0E;IAC1E,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAID;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,OAAO,CAAC,IAAI,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,YAAY,CAAC,CAgC1E"}