@simulatte/doppler 0.1.9 → 0.2.0

package/src/bridge/extension/background.js

@@ -1,168 +0,0 @@
-
-
-import { log } from '../../debug/index.js';
-
-// ============================================================================
-// Constants
-// ============================================================================
-
-const NATIVE_HOST_NAME = 'dev.reploid.doppler';
-let nextPortCounter = 0;
-
-function createPortId() {
-  const now = Date.now().toString(36);
-  nextPortCounter = (nextPortCounter + 1) >>> 0;
-  return `${now}-${nextPortCounter.toString(36)}`;
-}
-
-// ============================================================================
-// Global State
-// ============================================================================
-
-
-const connections = new Map();
-
-
-const messageQueues = new Map();
-
-// ============================================================================
-// Connection Handling
-// ============================================================================
-
-function handleWebConnection(webPort) {
-  if (webPort.name !== 'doppler-bridge') {
-    log.warn('DopplerBridge', `Unknown connection: ${webPort.name}`);
-    return;
-  }
-
-  log.info('DopplerBridge', 'Web page connected');
-
-  const portId = createPortId();
-  let nativePort;
-
-  // Connect to native host
-  try {
-    nativePort = chrome.runtime.connectNative(NATIVE_HOST_NAME);
-    log.info('DopplerBridge', 'Connected to native host');
-  } catch (err) {
-    log.error('DopplerBridge', `Failed to connect to native host: ${err.message}`);
-    webPort.postMessage({
-      type: 'error',
-      message: `Failed to connect to native host: ${err.message}`,
-    });
-    return;
-  }
-
-  // Store connection
-  connections.set(portId, { webPort, nativePort });
-
-  // Handle messages from web page
-  webPort.onMessage.addListener((message) => {
-    handleWebMessage(portId, message);
-  });
-
-  // Handle messages from native host
-  nativePort.onMessage.addListener((message) => {
-    handleNativeMessage(portId, message);
-  });
-
-  // Handle web page disconnect
-  webPort.onDisconnect.addListener(() => {
-    log.info('DopplerBridge', 'Web page disconnected');
-    cleanupConnection(portId);
-  });
-
-  // Handle native host disconnect
-  nativePort.onDisconnect.addListener(() => {
-    const error = chrome.runtime.lastError;
-    log.warn('DopplerBridge', `Native host disconnected: ${error?.message || 'unknown'}`);
-
-    // Notify web page
-    try {
-      webPort.postMessage({
-        type: 'error',
-        message: error?.message || 'Native host disconnected',
-      });
-    } catch {
-      // Port already closed
-    }
-
-    cleanupConnection(portId);
-  });
-}
-
-
-chrome.runtime.onConnectExternal.addListener(handleWebConnection);
-
-
-function handleWebMessage(portId, message) {
-  const conn = connections.get(portId);
-  if (!conn) {
-    log.error('DopplerBridge', `No connection for port: ${portId}`);
-    return;
-  }
-
-  if (message.type === 'binary') {
-    // Forward binary message to native host
-    // Chrome native messaging uses JSON, so we send as array
-    conn.nativePort.postMessage({
-      type: 'binary',
-      data: message.data,
-    });
-  } else if (message.type === 'ack') {
-    // Forward ACK to native host
-    conn.nativePort.postMessage({
-      type: 'ack',
-      reqId: message.reqId,
-    });
-  } else {
-    log.warn('DopplerBridge', `Unknown message type from web: ${message.type}`);
-  }
-}
-
-
-function handleNativeMessage(portId, message) {
-  const conn = connections.get(portId);
-  if (!conn) {
-    log.error('DopplerBridge', `No connection for port: ${portId}`);
-    return;
-  }
-
-  if (message.type === 'binary') {
-    // Forward binary message to web page
-    conn.webPort.postMessage({
-      type: 'binary',
-      data: message.data,
-    });
-  } else if (message.type === 'error') {
-    conn.webPort.postMessage({
-      type: 'error',
-      message: message.message,
-    });
-  } else {
-    log.warn('DopplerBridge', `Unknown message type from native: ${message.type}`);
-  }
-}
-
-
-function cleanupConnection(portId) {
-  const conn = connections.get(portId);
-  if (conn) {
-    try {
-      conn.nativePort?.disconnect();
-    } catch {
-      // Already disconnected
-    }
-    connections.delete(portId);
-  }
-  messageQueues.delete(portId);
-}
-
-
-chrome.runtime.onConnect.addListener((port) => {
-  if (port.name === 'doppler-bridge') {
-    handleWebConnection(port);
-  }
-});
-
-log.info('DopplerBridge', 'Background script loaded');

package/src/bridge/extension/manifest.json

@@ -1,34 +0,0 @@
-{
-  "manifest_version": 3,
-  "name": "DOPPLER Bridge",
-  "version": "1.0.0",
-  "description": "Native bridge for DOPPLER LLM inference - bypasses browser storage limits",
-
-  "permissions": [
-    "nativeMessaging",
-    "storage"
-  ],
-
-  "host_permissions": [],
-
-  "background": {
-    "service_worker": "background.js",
-    "type": "module"
-  },
-
-  "externally_connectable": {
-    "matches": [
-      "http://localhost:*/*",
-      "https://localhost:*/*",
-      "https://*.reploid.dev/*"
-    ]
-  },
-
-  "icons": {
-    "16": "icons/icon16.png",
-    "48": "icons/icon48.png",
-    "128": "icons/icon128.png"
-  },
-
-  "key": "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA"
-}

package/src/bridge/extension-client.d.ts

@@ -1,114 +0,0 @@
-/**
- * Extension Bridge Client
- * Phase 3: Communication with Native Host via Chrome Extension
- *
- * This module handles:
- * - Connection to background script
- * - Binary message passing with transferables
- * - Backpressure handling
- * - Request/response correlation
- *
- * @module bridge/extension-client
- */
-
-import type { ListEntry } from './protocol.js';
-
-/**
- * Bridge status values
- */
-export declare const BridgeStatus: {
-  readonly DISCONNECTED: 'disconnected';
-  readonly CONNECTING: 'connecting';
-  readonly CONNECTED: 'connected';
-  readonly ERROR: 'error';
-};
-
-export type BridgeStatusType = (typeof BridgeStatus)[keyof typeof BridgeStatus];
-
-/**
- * Status change callback
- */
-export type StatusChangeCallback = (status: BridgeStatusType) => void;
-
-/**
- * Error callback
- */
-export type ErrorCallback = (error: Error) => void;
-
-/**
- * Chunk callback for streaming reads
- */
-export type ChunkCallback = (chunk: Uint8Array, totalReceived: number) => void;
-
-/**
- * Extension Bridge Client
- */
-export declare class ExtensionBridgeClient {
-  /** Status change event handler */
-  onStatusChange: StatusChangeCallback | null;
-  /** Error event handler */
-  onError: ErrorCallback | null;
-
-  /**
-   * Check if the DOPPLER extension is installed
-   */
-  static isExtensionAvailable(): boolean;
-
-  /**
-   * Connect to the DOPPLER extension
-   * @param extensionId - Extension ID (optional, uses known ID)
-   */
-  connect(extensionId?: string | null): Promise<void>;
-
-  /**
-   * Disconnect from the extension
-   */
-  disconnect(): void;
-
-  /**
-   * Read data from a file via native host
-   * @param path - File path
-   * @param offset - Byte offset
-   * @param length - Bytes to read
-   * @param onChunk - Callback for each chunk (for streaming)
-   */
-  read(
-    path: string,
-    offset: number,
-    length: number,
-    onChunk?: ChunkCallback | null
-  ): Promise<Uint8Array>;
-
-  /**
-   * List directory contents via native host
-   * @param path - Directory path
-   */
-  list(path: string): Promise<ListEntry[]>;
-
-  /**
-   * Get current status
-   */
-  getStatus(): BridgeStatusType;
-
-  /**
-   * Get the connected extension target, if any.
-   */
-  getExtensionId(): string | null;
-
-  /**
-   * Check if connected
-   */
-  isConnected(): boolean;
-}
-
-/**
- * Get global bridge client
- */
-export declare function getBridgeClient(): ExtensionBridgeClient;
-
-/**
- * Check if native bridge is available
- */
-export declare function isBridgeAvailable(): boolean;
-
-export default ExtensionBridgeClient;

package/src/bridge/extension-client.js

@@ -1,409 +0,0 @@
-
-
-import {
-  Command,
-  Flag,
-  HEADER_SIZE,
-  encodeMessage,
-  decodeHeader,
-  createReadRequest,
-  createListRequest,
-  parseReadResponse,
-  parseListResponse,
-  parseErrorResponse,
-} from './protocol.js';
-import { log } from '../debug/index.js';
-import { DEFAULT_BRIDGE_TIMEOUT_CONFIG } from '../config/schema/index.js';
-
-// ============================================================================
-// Types and Interfaces
-// ============================================================================
-
-
-export const BridgeStatus = {
-  DISCONNECTED: 'disconnected',
-  CONNECTING: 'connecting',
-  CONNECTED: 'connected',
-  ERROR: 'error',
-};
-
-// ============================================================================
-// Extension Bridge Client Class
-// ============================================================================
-
-
-export class ExtensionBridgeClient {
-  
-  #port = null;
-  
-  #status = BridgeStatus.DISCONNECTED;
-  
-  #nextReqId = 1;
-  
-  #pendingRequests = new Map();
-  
-  #extensionId = null;
-
-  
-  onStatusChange = null;
-  
-  onError = null;
-
-  
-  static isExtensionAvailable() {
-    return (
-      typeof chrome !== 'undefined' &&
-      typeof chrome.runtime !== 'undefined' &&
-      typeof chrome.runtime.connect === 'function'
-    );
-  }
-
-  
-  async connect(extensionId = null) {
-    if (!ExtensionBridgeClient.isExtensionAvailable()) {
-      throw new Error('Chrome extension API not available');
-    }
-
-    if (this.#status === BridgeStatus.CONNECTING) {
-      throw new Error('Bridge client connection already in progress');
-    }
-    if (this.#status === BridgeStatus.CONNECTED) {
-      if ((extensionId ?? null) !== this.#extensionId) {
-        throw new Error('Bridge client already connected to a different extension target');
-      }
-      return;
-    }
-
-    this.#extensionId = extensionId;
-    this.#status = BridgeStatus.CONNECTING;
-    this.#notifyStatusChange();
-
-    return new Promise((resolve, reject) => {
-      try {
-        // Connect to extension's background script
-        const connectInfo = { name: 'doppler-bridge' };
-
-        if (extensionId) {
-          this.#port = chrome.runtime.connect(extensionId, connectInfo);
-        } else {
-          // Try to connect to the extension (requires externally_connectable)
-          this.#port = chrome.runtime.connect(connectInfo);
-        }
-
-        // Set up message handler
-        this.#port.onMessage.addListener((message) => {
-          this.#handleMessage(message);
-        });
-
-        // Set up disconnect handler
-        this.#port.onDisconnect.addListener(() => {
-          this.#handleDisconnect();
-        });
-
-        // Send ping to verify connection
-        const pingReqId = this.#getNextReqId();
-        const pingPromise = this.#createPendingRequest(pingReqId, DEFAULT_BRIDGE_TIMEOUT_CONFIG.pingTimeoutMs);
-
-        this.#port.postMessage({
-          type: 'binary',
-          data: Array.from(new Uint8Array(encodeMessage(Command.PING, pingReqId))),
-        });
-
-        pingPromise
-          .then(() => {
-            this.#status = BridgeStatus.CONNECTED;
-            this.#notifyStatusChange();
-            resolve();
-          })
-          .catch((err) => {
-            this.#status = BridgeStatus.ERROR;
-            this.#notifyStatusChange();
-            reject(err);
-          });
-      } catch (err) {
-        this.#status = BridgeStatus.ERROR;
-        this.#notifyStatusChange();
-        reject(new Error(`Failed to connect to extension: ${err.message}`));
-      }
-    });
-  }
-
-  
-  disconnect() {
-    if (this.#port) {
-      this.#port.disconnect();
-      this.#port = null;
-    }
-
-    // Reject all pending requests
-    for (const [, pending] of this.#pendingRequests) {
-      pending.reject(new Error('Connection closed'));
-    }
-    this.#pendingRequests.clear();
-
-    this.#status = BridgeStatus.DISCONNECTED;
-    this.#notifyStatusChange();
-  }
-
-  
-  async read(path, offset, length, onChunk = null) {
-    if (this.#status !== BridgeStatus.CONNECTED) {
-      throw new Error('Not connected to extension');
-    }
-
-    const reqId = this.#getNextReqId();
-    const request = createReadRequest(reqId, path, offset, length);
-
-    // Create pending request with chunk accumulator
-    const pending = this.#createPendingRequest(reqId, DEFAULT_BRIDGE_TIMEOUT_CONFIG.readTimeoutMs, onChunk);
-
-    // Send request (convert to array for postMessage compatibility)
-    this.#port.postMessage({
-      type: 'binary',
-      data: Array.from(new Uint8Array(request)),
-    });
-
-    return pending;
-  }
-
-  
-  async list(path) {
-    if (this.#status !== BridgeStatus.CONNECTED) {
-      throw new Error('Not connected to extension');
-    }
-
-    const reqId = this.#getNextReqId();
-    const request = createListRequest(reqId, path);
-
-    // Create pending request
-    const pending = this.#createPendingRequest(reqId, DEFAULT_BRIDGE_TIMEOUT_CONFIG.listTimeoutMs);
-
-    // Send request
-    this.#port.postMessage({
-      type: 'binary',
-      data: Array.from(new Uint8Array(request)),
-    });
-
-    return pending;
-  }
-
-  
-  #getNextReqId() {
-    // Wrap at 32-bit unsigned max to avoid overflow
-    const current = this.#nextReqId;
-    this.#nextReqId = (this.#nextReqId + 1) >>> 0;
-    if (this.#nextReqId === 0) {
-      this.#nextReqId = 1;
-    }
-    return current;
-  }
-
-  
-  #createPendingRequest(reqId, timeoutMs = DEFAULT_BRIDGE_TIMEOUT_CONFIG.defaultTimeoutMs, onChunk = null) {
-    return new Promise((resolve, reject) => {
-      const pending = {
-        resolve,
-        reject,
-        chunks: [],
-        totalReceived: 0,
-        onChunk,
-        timeout: setTimeout(() => {
-          this.#pendingRequests.delete(reqId);
-          reject(new Error(`Request ${reqId} timed out`));
-        }, timeoutMs),
-      };
-
-      this.#pendingRequests.set(reqId, pending);
-    });
-  }
-
-  
-  #handleMessage(message) {
-    if (message?.type === 'error') {
-      this.#handleExplicitError(message);
-      return;
-    }
-
-    if (message.type !== 'binary' || !message.data) {
-      log.warn('ExtensionBridge', `Unexpected message type: ${message.type}`);
-      return;
-    }
-
-    // Convert array back to Uint8Array
-    const data = new Uint8Array(message.data);
-
-    if (data.length < HEADER_SIZE) {
-      log.error('ExtensionBridge', 'Message too short');
-      return;
-    }
-
-    const header = decodeHeader(data.buffer);
-    if (!header) {
-      log.error('ExtensionBridge', 'Invalid message header');
-      return;
-    }
-
-    const payload = data.slice(HEADER_SIZE, HEADER_SIZE + header.payloadLen);
-    const pending = this.#pendingRequests.get(header.reqId);
-
-    switch (header.cmd) {
-      case Command.PONG:
-        if (pending) {
-          clearTimeout(pending.timeout);
-          this.#pendingRequests.delete(header.reqId);
-          pending.resolve(undefined);
-        }
-        break;
-
-      case Command.READ_RESPONSE:
-        if (pending) {
-          const { data: chunkData } = parseReadResponse(payload);
-
-          // Accumulate chunk
-          pending.chunks.push(chunkData);
-          pending.totalReceived += chunkData.length;
-
-          // Notify chunk callback
-          if (pending.onChunk) {
-            pending.onChunk(chunkData, pending.totalReceived);
-          }
-
-          // Send ACK for backpressure
-          this.#sendAck(header.reqId);
-
-          // Check if this is the last chunk
-          if (header.flags & Flag.LAST_CHUNK) {
-            clearTimeout(pending.timeout);
-            this.#pendingRequests.delete(header.reqId);
-
-            // Combine chunks
-            const totalSize = pending.chunks.reduce((s, c) => s + c.length, 0);
-            const result = new Uint8Array(totalSize);
-            let pos = 0;
-            for (const chunk of pending.chunks) {
-              result.set(chunk, pos);
-              pos += chunk.length;
-            }
-
-            pending.resolve(result);
-          }
-        }
-        break;
-
-      case Command.LIST_RESPONSE:
-        if (pending) {
-          clearTimeout(pending.timeout);
-          this.#pendingRequests.delete(header.reqId);
-          const entries = parseListResponse(payload);
-          pending.resolve(entries);
-        }
-        break;
-
-      case Command.ERROR:
-        if (pending) {
-          clearTimeout(pending.timeout);
-          this.#pendingRequests.delete(header.reqId);
-          const error = parseErrorResponse(payload);
-          pending.reject(new Error(`Native host error ${error.code}: ${error.message}`));
-        }
-        break;
-
-      default:
-        log.warn('ExtensionBridge', `Unknown command: ${header.cmd}`);
-    }
-  }
-
-  
-  #sendAck(reqId) {
-    if (this.#port) {
-      this.#port.postMessage({
-        type: 'ack',
-        reqId,
-      });
-    }
-  }
-
-  #handleExplicitError(message) {
-    const text = typeof message?.message === 'string' && message.message.length > 0
-      ? message.message
-      : 'Native bridge error';
-    const error = new Error(text);
-
-    this.#port = null;
-    this.#status = BridgeStatus.ERROR;
-    this.#notifyStatusChange();
-
-    for (const [, pending] of this.#pendingRequests) {
-      clearTimeout(pending.timeout);
-      pending.reject(error);
-    }
-    this.#pendingRequests.clear();
-
-    if (this.onError) {
-      this.onError(error);
-    }
-  }
-
-  
-  #handleDisconnect() {
-    const error = chrome.runtime?.lastError;
-    log.warn('ExtensionBridge', `Disconnected: ${error?.message || 'unknown'}`);
-
-    this.#port = null;
-    this.#status = BridgeStatus.DISCONNECTED;
-    this.#notifyStatusChange();
-
-    // Reject pending requests
-    for (const [, pending] of this.#pendingRequests) {
-      pending.reject(new Error('Connection lost'));
-    }
-    this.#pendingRequests.clear();
-
-    if (this.onError) {
-      this.onError(new Error(error?.message || 'Connection lost'));
-    }
-  }
-
-  
-  #notifyStatusChange() {
-    if (this.onStatusChange) {
-      this.onStatusChange(this.#status);
-    }
-  }
-
-  
-  getStatus() {
-    return this.#status;
-  }
-
-  getExtensionId() {
-    return this.#extensionId;
-  }
-
-  
-  isConnected() {
-    return this.#status === BridgeStatus.CONNECTED;
-  }
-}
-
-// ============================================================================
-// Module-level functions
-// ============================================================================
-
-
-let globalClient = null;
-
-
-export function getBridgeClient() {
-  if (!globalClient) {
-    globalClient = new ExtensionBridgeClient();
-  }
-  return globalClient;
-}
-
-
-export function isBridgeAvailable() {
-  return ExtensionBridgeClient.isExtensionAvailable();
-}
-
-export default ExtensionBridgeClient;