@willjackson/claude-code-bridge 0.1.0

package/dist/chunk-BRH476VK.js

@@ -0,0 +1,1993 @@
+// src/utils/logger.ts
+import pino from "pino";
+function isDevelopment() {
+  return process.env.NODE_ENV !== "production";
+}
+function getDefaultLevel() {
+  const envLevel = process.env.LOG_LEVEL?.toLowerCase();
+  const validLevels = ["trace", "debug", "info", "warn", "error", "fatal"];
+  if (envLevel && validLevels.includes(envLevel)) {
+    return envLevel;
+  }
+  return "info";
+}
+function createLogger(name, level) {
+  const logLevel = level ?? getDefaultLevel();
+  const options = {
+    name,
+    level: logLevel
+  };
+  if (isDevelopment()) {
+    options.transport = {
+      target: "pino-pretty",
+      options: {
+        colorize: true,
+        translateTime: "SYS:standard",
+        ignore: "pid,hostname"
+      }
+    };
+  }
+  return pino(options);
+}
+function createChildLogger(parent, bindings) {
+  return parent.child(bindings);
+}
+
+// src/bridge/protocol.ts
+import { z } from "zod";
+import { v4 as uuidv4 } from "uuid";
+var MessageType = z.enum([
+  "request",
+  "response",
+  "context_sync",
+  "task_delegate",
+  "notification"
+]);
+var FileChunkSchema = z.object({
+  path: z.string(),
+  content: z.string(),
+  startLine: z.number().optional(),
+  endLine: z.number().optional(),
+  language: z.string().optional()
+});
+var DirectoryTreeSchema = z.lazy(
+  () => z.object({
+    name: z.string(),
+    type: z.enum(["file", "directory"]),
+    children: z.array(DirectoryTreeSchema).optional()
+  })
+);
+var ArtifactSchema = z.object({
+  path: z.string(),
+  action: z.enum(["created", "modified", "deleted"]),
+  diff: z.string().optional()
+});
+var ContextSchema = z.object({
+  files: z.array(FileChunkSchema).optional(),
+  tree: DirectoryTreeSchema.optional(),
+  summary: z.string().optional(),
+  variables: z.record(z.any()).optional()
+});
+var TaskRequestSchema = z.object({
+  id: z.string(),
+  description: z.string(),
+  scope: z.enum(["execute", "analyze", "suggest"]),
+  constraints: z.array(z.string()).optional(),
+  returnFormat: z.enum(["full", "summary", "diff"]).optional(),
+  timeout: z.number().optional()
+});
+var TaskResultSchema = z.object({
+  taskId: z.string().optional(),
+  success: z.boolean(),
+  data: z.any(),
+  artifacts: z.array(ArtifactSchema).optional(),
+  followUp: z.string().optional(),
+  error: z.string().optional()
+});
+var BridgeMessageSchema = z.object({
+  id: z.string().uuid(),
+  type: MessageType,
+  source: z.string(),
+  timestamp: z.number(),
+  context: ContextSchema.optional(),
+  task: TaskRequestSchema.optional(),
+  result: TaskResultSchema.optional()
+});
+function createMessage(type, source) {
+  return {
+    id: uuidv4(),
+    type,
+    source,
+    timestamp: Date.now()
+  };
+}
+function validateMessage(data) {
+  return BridgeMessageSchema.parse(data);
+}
+function safeValidateMessage(data) {
+  return BridgeMessageSchema.safeParse(data);
+}
+function serializeMessage(message) {
+  return JSON.stringify(message);
+}
+function deserializeMessage(json) {
+  let parsed;
+  try {
+    parsed = JSON.parse(json);
+  } catch {
+    throw new Error("Invalid JSON");
+  }
+  return validateMessage(parsed);
+}
+function safeDeserializeMessage(json) {
+  let parsed;
+  try {
+    parsed = JSON.parse(json);
+  } catch {
+    return {
+      success: false,
+      error: new z.ZodError([
+        {
+          code: "custom",
+          message: "Invalid JSON",
+          path: []
+        }
+      ])
+    };
+  }
+  return BridgeMessageSchema.safeParse(parsed);
+}
+
+// src/transport/interface.ts
+var ConnectionState = /* @__PURE__ */ ((ConnectionState2) => {
+  ConnectionState2["DISCONNECTED"] = "DISCONNECTED";
+  ConnectionState2["CONNECTING"] = "CONNECTING";
+  ConnectionState2["CONNECTED"] = "CONNECTED";
+  ConnectionState2["RECONNECTING"] = "RECONNECTING";
+  return ConnectionState2;
+})(ConnectionState || {});
+
+// src/transport/websocket.ts
+import WebSocket from "ws";
+var logger = createLogger("websocket-transport");
+var DEFAULT_RECONNECT_INTERVAL = 1e3;
+var DEFAULT_MAX_RECONNECT_ATTEMPTS = 10;
+var DEFAULT_HEARTBEAT_INTERVAL = 3e4;
+var HEARTBEAT_TIMEOUT = 1e4;
+var WebSocketTransport = class {
+  ws = null;
+  state = "DISCONNECTED" /* DISCONNECTED */;
+  config = null;
+  // Reconnection state
+  reconnectAttempts = 0;
+  reconnectTimer = null;
+  intentionalDisconnect = false;
+  // Message queue for offline messages
+  messageQueue = [];
+  // Heartbeat state
+  heartbeatInterval = null;
+  heartbeatTimeout = null;
+  awaitingPong = false;
+  // Event handlers
+  messageHandlers = [];
+  disconnectHandlers = [];
+  errorHandlers = [];
+  reconnectingHandlers = [];
+  /**
+   * Build the WebSocket URL from the connection configuration
+   */
+  buildUrl(config) {
+    if (config.url) {
+      return config.url;
+    }
+    const host = config.host ?? "localhost";
+    const port = config.port ?? 8765;
+    return `ws://${host}:${port}`;
+  }
+  /**
+   * Establish connection to a remote peer
+   */
+  async connect(config) {
+    if (this.state === "CONNECTED" /* CONNECTED */) {
+      throw new Error("Already connected");
+    }
+    this.config = config;
+    this.intentionalDisconnect = false;
+    this.reconnectAttempts = 0;
+    return this.establishConnection();
+  }
+  /**
+   * Internal method to establish WebSocket connection
+   * Used for both initial connection and reconnection attempts
+   */
+  async establishConnection() {
+    if (!this.config) {
+      throw new Error("No configuration set");
+    }
+    this.state = "CONNECTING" /* CONNECTING */;
+    const url = this.buildUrl(this.config);
+    logger.debug({ url, attempt: this.reconnectAttempts }, "Connecting to WebSocket server");
+    return new Promise((resolve, reject) => {
+      try {
+        this.ws = new WebSocket(url);
+        this.ws.on("open", () => {
+          this.state = "CONNECTED" /* CONNECTED */;
+          this.reconnectAttempts = 0;
+          logger.info({ url }, "WebSocket connection established");
+          this.startHeartbeat();
+          this.flushMessageQueue();
+          resolve();
+        });
+        this.ws.on("message", (data) => {
+          this.handleIncomingMessage(data);
+        });
+        this.ws.on("pong", () => {
+          this.handlePong();
+        });
+        this.ws.on("close", (code, reason) => {
+          const wasConnected = this.state === "CONNECTED" /* CONNECTED */;
+          const wasReconnecting = this.state === "RECONNECTING" /* RECONNECTING */;
+          this.stopHeartbeat();
+          logger.info({ code, reason: reason.toString() }, "WebSocket connection closed");
+          if (wasConnected) {
+            this.notifyDisconnect();
+          }
+          if (!this.intentionalDisconnect && this.shouldReconnect()) {
+            this.scheduleReconnect();
+          } else if (!wasReconnecting) {
+            this.state = "DISCONNECTED" /* DISCONNECTED */;
+          }
+        });
+        this.ws.on("error", (error) => {
+          logger.error({ error: error.message }, "WebSocket error");
+          if (this.state === "CONNECTING" /* CONNECTING */ && this.reconnectAttempts === 0) {
+            this.state = "DISCONNECTED" /* DISCONNECTED */;
+            reject(error);
+            return;
+          }
+          this.notifyError(error);
+        });
+      } catch (error) {
+        this.state = "DISCONNECTED" /* DISCONNECTED */;
+        reject(error);
+      }
+    });
+  }
+  /**
+   * Cleanly close the current connection
+   */
+  async disconnect() {
+    this.intentionalDisconnect = true;
+    this.clearReconnectTimer();
+    this.stopHeartbeat();
+    this.messageQueue = [];
+    if (!this.ws || this.state === "DISCONNECTED" /* DISCONNECTED */) {
+      this.state = "DISCONNECTED" /* DISCONNECTED */;
+      return;
+    }
+    logger.debug("Disconnecting WebSocket");
+    return new Promise((resolve) => {
+      if (!this.ws) {
+        this.state = "DISCONNECTED" /* DISCONNECTED */;
+        resolve();
+        return;
+      }
+      const onClose = () => {
+        this.state = "DISCONNECTED" /* DISCONNECTED */;
+        this.ws = null;
+        resolve();
+      };
+      if (this.ws.readyState === WebSocket.CLOSED) {
+        onClose();
+        return;
+      }
+      const timeout = setTimeout(() => {
+        this.state = "DISCONNECTED" /* DISCONNECTED */;
+        this.ws = null;
+        resolve();
+      }, 5e3);
+      this.ws.once("close", () => {
+        clearTimeout(timeout);
+        onClose();
+      });
+      this.ws.close(1e3, "Disconnect requested");
+    });
+  }
+  /**
+   * Send a message to the connected peer
+   * If disconnected and reconnection is enabled, queues the message for later delivery
+   */
+  async send(message) {
+    if (this.ws && this.state === "CONNECTED" /* CONNECTED */) {
+      return this.sendImmediate(message);
+    }
+    if (this.shouldReconnect() && (this.state === "RECONNECTING" /* RECONNECTING */ || this.state === "DISCONNECTED" /* DISCONNECTED */)) {
+      this.queueMessage(message);
+      return;
+    }
+    throw new Error("Not connected");
+  }
+  /**
+   * Immediately send a message over the WebSocket
+   */
+  async sendImmediate(message) {
+    if (!this.ws || this.state !== "CONNECTED" /* CONNECTED */) {
+      throw new Error("Not connected");
+    }
+    const serialized = serializeMessage(message);
+    logger.debug({ messageId: message.id, type: message.type }, "Sending message");
+    return new Promise((resolve, reject) => {
+      this.ws.send(serialized, (error) => {
+        if (error) {
+          logger.error({ error: error.message, messageId: message.id }, "Failed to send message");
+          reject(error);
+        } else {
+          resolve();
+        }
+      });
+    });
+  }
+  /**
+   * Queue a message for later delivery when reconnected
+   */
+  queueMessage(message) {
+    this.messageQueue.push(message);
+    logger.debug({ messageId: message.id, queueLength: this.messageQueue.length }, "Message queued for delivery");
+  }
+  /**
+   * Flush all queued messages after reconnection
+   */
+  async flushMessageQueue() {
+    if (this.messageQueue.length === 0) {
+      return;
+    }
+    logger.info({ queueLength: this.messageQueue.length }, "Flushing message queue");
+    const messages = [...this.messageQueue];
+    this.messageQueue = [];
+    for (const message of messages) {
+      try {
+        await this.sendImmediate(message);
+      } catch (error) {
+        logger.error({ error: error.message, messageId: message.id }, "Failed to send queued message");
+        this.messageQueue.unshift(message);
+        break;
+      }
+    }
+  }
+  /**
+   * Register a handler for incoming messages
+   */
+  onMessage(handler) {
+    this.messageHandlers.push(handler);
+  }
+  /**
+   * Register a handler for disconnect events
+   */
+  onDisconnect(handler) {
+    this.disconnectHandlers.push(handler);
+  }
+  /**
+   * Register a handler for error events
+   */
+  onError(handler) {
+    this.errorHandlers.push(handler);
+  }
+  /**
+   * Register a handler for reconnecting events
+   */
+  onReconnecting(handler) {
+    this.reconnectingHandlers.push(handler);
+  }
+  /**
+   * Check if the transport is currently connected
+   */
+  isConnected() {
+    return this.state === "CONNECTED" /* CONNECTED */;
+  }
+  /**
+   * Get the current connection state
+   */
+  getState() {
+    return this.state;
+  }
+  /**
+   * Handle incoming WebSocket messages
+   */
+  handleIncomingMessage(data) {
+    const messageString = data.toString();
+    logger.debug({ dataLength: messageString.length }, "Received message");
+    const result = safeDeserializeMessage(messageString);
+    if (!result.success) {
+      logger.warn({ error: result.error.message }, "Failed to parse incoming message");
+      this.notifyError(new Error(`Invalid message format: ${result.error.message}`));
+      return;
+    }
+    const message = result.data;
+    logger.debug({ messageId: message.id, type: message.type }, "Parsed message");
+    for (const handler of this.messageHandlers) {
+      try {
+        handler(message);
+      } catch (error) {
+        logger.error({ error: error.message }, "Message handler threw error");
+      }
+    }
+  }
+  /**
+   * Notify all disconnect handlers
+   */
+  notifyDisconnect() {
+    for (const handler of this.disconnectHandlers) {
+      try {
+        handler();
+      } catch (error) {
+        logger.error({ error: error.message }, "Disconnect handler threw error");
+      }
+    }
+  }
+  /**
+   * Notify all error handlers
+   */
+  notifyError(error) {
+    for (const handler of this.errorHandlers) {
+      try {
+        handler(error);
+      } catch (handlerError) {
+        logger.error({ error: handlerError.message }, "Error handler threw error");
+      }
+    }
+  }
+  /**
+   * Notify all reconnecting handlers
+   */
+  notifyReconnecting(attempt, maxAttempts) {
+    for (const handler of this.reconnectingHandlers) {
+      try {
+        handler(attempt, maxAttempts);
+      } catch (error) {
+        logger.error({ error: error.message }, "Reconnecting handler threw error");
+      }
+    }
+  }
+  // ============================================================================
+  // Reconnection Methods
+  // ============================================================================
+  /**
+   * Check if reconnection should be attempted
+   */
+  shouldReconnect() {
+    if (!this.config?.reconnect) {
+      return false;
+    }
+    const maxAttempts = this.config.maxReconnectAttempts ?? DEFAULT_MAX_RECONNECT_ATTEMPTS;
+    return this.reconnectAttempts < maxAttempts;
+  }
+  /**
+   * Schedule a reconnection attempt
+   */
+  scheduleReconnect() {
+    if (this.reconnectTimer) {
+      return;
+    }
+    this.state = "RECONNECTING" /* RECONNECTING */;
+    this.reconnectAttempts++;
+    const maxAttempts = this.config?.maxReconnectAttempts ?? DEFAULT_MAX_RECONNECT_ATTEMPTS;
+    const interval = this.config?.reconnectInterval ?? DEFAULT_RECONNECT_INTERVAL;
+    logger.info(
+      { attempt: this.reconnectAttempts, maxAttempts, interval },
+      "Scheduling reconnection attempt"
+    );
+    this.notifyReconnecting(this.reconnectAttempts, maxAttempts);
+    this.reconnectTimer = setTimeout(async () => {
+      this.reconnectTimer = null;
+      try {
+        await this.establishConnection();
+        logger.info({ attempts: this.reconnectAttempts }, "Reconnection successful");
+      } catch (error) {
+        logger.warn({ error: error.message }, "Reconnection attempt failed");
+        if (this.shouldReconnect()) {
+          this.scheduleReconnect();
+        } else {
+          logger.error({ maxAttempts }, "Max reconnection attempts reached, giving up");
+          this.state = "DISCONNECTED" /* DISCONNECTED */;
+          this.notifyError(new Error(`Failed to reconnect after ${maxAttempts} attempts`));
+        }
+      }
+    }, interval);
+  }
+  /**
+   * Clear any pending reconnection timer
+   */
+  clearReconnectTimer() {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+  }
+  // ============================================================================
+  // Heartbeat Methods
+  // ============================================================================
+  /**
+   * Start the heartbeat monitoring
+   */
+  startHeartbeat() {
+    this.stopHeartbeat();
+    this.heartbeatInterval = setInterval(() => {
+      this.sendPing();
+    }, DEFAULT_HEARTBEAT_INTERVAL);
+    logger.debug({ interval: DEFAULT_HEARTBEAT_INTERVAL }, "Heartbeat monitoring started");
+  }
+  /**
+   * Stop the heartbeat monitoring
+   */
+  stopHeartbeat() {
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = null;
+    }
+    if (this.heartbeatTimeout) {
+      clearTimeout(this.heartbeatTimeout);
+      this.heartbeatTimeout = null;
+    }
+    this.awaitingPong = false;
+  }
+  /**
+   * Send a ping to the peer
+   */
+  sendPing() {
+    if (!this.ws || this.state !== "CONNECTED" /* CONNECTED */) {
+      return;
+    }
+    if (this.awaitingPong) {
+      logger.warn("No pong received, connection may be dead");
+      this.handleHeartbeatTimeout();
+      return;
+    }
+    this.awaitingPong = true;
+    this.ws.ping();
+    this.heartbeatTimeout = setTimeout(() => {
+      if (this.awaitingPong) {
+        this.handleHeartbeatTimeout();
+      }
+    }, HEARTBEAT_TIMEOUT);
+    logger.debug("Ping sent");
+  }
+  /**
+   * Handle pong response from peer
+   */
+  handlePong() {
+    this.awaitingPong = false;
+    if (this.heartbeatTimeout) {
+      clearTimeout(this.heartbeatTimeout);
+      this.heartbeatTimeout = null;
+    }
+    logger.debug("Pong received");
+  }
+  /**
+   * Handle heartbeat timeout (no pong received)
+   */
+  handleHeartbeatTimeout() {
+    logger.warn("Heartbeat timeout - closing connection");
+    this.awaitingPong = false;
+    if (this.heartbeatTimeout) {
+      clearTimeout(this.heartbeatTimeout);
+      this.heartbeatTimeout = null;
+    }
+    if (this.ws) {
+      this.ws.terminate();
+    }
+  }
+  // ============================================================================
+  // Getters for testing/debugging
+  // ============================================================================
+  /**
+   * Get the current message queue length (for testing)
+   */
+  getQueueLength() {
+    return this.messageQueue.length;
+  }
+  /**
+   * Get the number of reconnection attempts (for testing)
+   */
+  getReconnectAttempts() {
+    return this.reconnectAttempts;
+  }
+};
+
+// src/bridge/messages.ts
+function createContextSyncMessage(source, context) {
+  const message = createMessage("context_sync", source);
+  return {
+    ...message,
+    context
+  };
+}
+function createTaskDelegateMessage(source, task) {
+  const message = createMessage("task_delegate", source);
+  return {
+    ...message,
+    task
+  };
+}
+function createTaskResponseMessage(source, taskId, result) {
+  const message = createMessage("response", source);
+  return {
+    ...message,
+    result: {
+      ...result,
+      taskId
+    }
+  };
+}
+function createContextRequestMessage(source, query) {
+  const message = createMessage("request", source);
+  return {
+    ...message,
+    context: {
+      summary: query
+    }
+  };
+}
+function createNotificationMessage(source, notification) {
+  const message = createMessage("notification", source);
+  return {
+    ...message,
+    context: {
+      summary: notification.message,
+      variables: {
+        notificationType: notification.type,
+        ...notification.data
+      }
+    }
+  };
+}
+
+// src/bridge/core.ts
+import { WebSocketServer } from "ws";
+import { v4 as uuidv42 } from "uuid";
+var logger2 = createLogger("bridge");
+var Bridge = class {
+  config;
+  server = null;
+  clientTransport = null;
+  peers = /* @__PURE__ */ new Map();
+  started = false;
+  // Event handlers
+  peerConnectedHandlers = [];
+  peerDisconnectedHandlers = [];
+  messageReceivedHandlers = [];
+  taskReceivedHandler = null;
+  contextReceivedHandlers = [];
+  contextRequestedHandler = null;
+  // Task correlation
+  pendingTasks = /* @__PURE__ */ new Map();
+  // Context request correlation
+  pendingContextRequests = /* @__PURE__ */ new Map();
+  // Auto-sync interval timer
+  autoSyncIntervalId = null;
+  /**
+   * Create a new Bridge instance
+   * @param config Bridge configuration
+   */
+  constructor(config) {
+    this.config = config;
+    this.validateConfig();
+    logger2.info({ instanceName: config.instanceName, mode: config.mode }, "Bridge instance created");
+  }
+  /**
+   * Validate the configuration based on mode requirements
+   */
+  validateConfig() {
+    const { mode, listen, connect } = this.config;
+    if (mode === "host" && !listen) {
+      throw new Error("'host' mode requires 'listen' configuration");
+    }
+    if (mode === "client" && !connect) {
+      throw new Error("'client' mode requires 'connect' configuration");
+    }
+    if (mode === "peer" && !listen && !connect) {
+      throw new Error("'peer' mode requires either 'listen' or 'connect' configuration (or both)");
+    }
+  }
+  /**
+   * Start the bridge based on configured mode
+   * - 'host': Starts WebSocket server
+   * - 'client': Connects to remote bridge
+   * - 'peer': Both starts server and connects to remote
+   */
+  async start() {
+    if (this.started) {
+      throw new Error("Bridge is already started");
+    }
+    const { mode } = this.config;
+    logger2.info({ mode }, "Starting bridge");
+    try {
+      if ((mode === "host" || mode === "peer") && this.config.listen) {
+        await this.startServer();
+      }
+      if ((mode === "client" || mode === "peer") && this.config.connect) {
+        await this.connectToRemote();
+      }
+      this.started = true;
+      logger2.info({ mode, instanceName: this.config.instanceName }, "Bridge started successfully");
+    } catch (error) {
+      await this.cleanup();
+      throw error;
+    }
+  }
+  /**
+   * Stop the bridge and close all connections
+   */
+  async stop() {
+    if (!this.started) {
+      return;
+    }
+    logger2.info("Stopping bridge");
+    await this.cleanup();
+    this.started = false;
+    logger2.info("Bridge stopped");
+  }
+  /**
+   * Get list of connected peers
+   */
+  getPeers() {
+    return Array.from(this.peers.values()).map((p) => p.info);
+  }
+  /**
+   * Connect to a remote bridge
+   * @param url WebSocket URL to connect to
+   */
+  async connectToPeer(url) {
+    const transport = new WebSocketTransport();
+    transport.onMessage((message) => {
+      this.handleMessage(message, transport);
+    });
+    transport.onDisconnect(() => {
+      this.handleClientDisconnect(transport);
+    });
+    try {
+      await transport.connect({
+        url,
+        reconnect: true,
+        reconnectInterval: 1e3,
+        maxReconnectAttempts: 10
+      });
+      const peerId = uuidv42();
+      const peerInfo = {
+        id: peerId,
+        name: "remote",
+        // Will be updated when we receive peer info
+        connectedAt: Date.now(),
+        lastActivity: Date.now()
+      };
+      this.peers.set(peerId, {
+        info: peerInfo,
+        transport
+      });
+      transport._peerId = peerId;
+      this.notifyPeerConnected(peerInfo);
+      logger2.info({ peerId, url }, "Connected to remote peer");
+    } catch (error) {
+      logger2.error({ error: error.message, url }, "Failed to connect to remote peer");
+      throw error;
+    }
+  }
+  /**
+   * Disconnect from a specific peer
+   * @param peerId ID of the peer to disconnect from
+   */
+  async disconnectFromPeer(peerId) {
+    const peer = this.peers.get(peerId);
+    if (!peer) {
+      throw new Error(`Peer not found: ${peerId}`);
+    }
+    if (peer.transport) {
+      await peer.transport.disconnect();
+    }
+    if (peer.ws) {
+      peer.ws.close(1e3, "Disconnect requested");
+    }
+    this.peers.delete(peerId);
+    this.notifyPeerDisconnected(peer.info);
+    logger2.info({ peerId }, "Disconnected from peer");
+  }
+  /**
+   * Send a message to a specific peer
+   * @param peerId ID of the peer to send to
+   * @param message Message to send
+   */
+  async sendToPeer(peerId, message) {
+    const peer = this.peers.get(peerId);
+    if (!peer) {
+      throw new Error(`Peer not found: ${peerId}`);
+    }
+    if (peer.transport) {
+      await peer.transport.send(message);
+    } else if (peer.ws) {
+      const serialized = serializeMessage(message);
+      await new Promise((resolve, reject) => {
+        peer.ws.send(serialized, (error) => {
+          if (error) {
+            reject(error);
+          } else {
+            resolve();
+          }
+        });
+      });
+    } else {
+      throw new Error("No transport available for peer");
+    }
+    logger2.debug({ peerId, messageId: message.id, type: message.type }, "Sent message to peer");
+  }
+  /**
+   * Broadcast a message to all connected peers
+   * @param message Message to broadcast
+   */
+  async broadcast(message) {
+    const sendPromises = Array.from(this.peers.keys()).map(
+      (peerId) => this.sendToPeer(peerId, message).catch((error) => {
+        logger2.error({ error: error.message, peerId }, "Failed to send to peer");
+      })
+    );
+    await Promise.all(sendPromises);
+    logger2.debug({ messageId: message.id, peerCount: this.peers.size }, "Broadcast message sent");
+  }
+  // ============================================================================
+  // Event Registration
+  // ============================================================================
+  /**
+   * Register a handler for peer connection events
+   */
+  onPeerConnected(handler) {
+    this.peerConnectedHandlers.push(handler);
+  }
+  /**
+   * Register a handler for peer disconnection events
+   */
+  onPeerDisconnected(handler) {
+    this.peerDisconnectedHandlers.push(handler);
+  }
+  /**
+   * Register a handler for incoming messages
+   */
+  onMessage(handler) {
+    this.messageReceivedHandlers.push(handler);
+  }
+  /**
+   * Register a handler for incoming task delegation requests
+   * Only one handler can be registered at a time
+   * @param handler Function that receives a TaskRequest and returns a TaskResult
+   */
+  onTaskReceived(handler) {
+    this.taskReceivedHandler = handler;
+  }
+  /**
+   * Register a handler for incoming context synchronization
+   * Multiple handlers can be registered
+   * @param handler Function that receives context and peerId
+   */
+  onContextReceived(handler) {
+    this.contextReceivedHandlers.push(handler);
+  }
+  /**
+   * Register a handler for incoming context requests
+   * Only one handler can be registered at a time
+   * @param handler Function that receives a query and returns FileChunk[]
+   */
+  onContextRequested(handler) {
+    this.contextRequestedHandler = handler;
+  }
+  // ============================================================================
+  // Task Delegation
+  // ============================================================================
+  /**
+   * Delegate a task to a peer and wait for the result
+   * @param task The task request to delegate
+   * @param peerId Optional peer ID to send to (defaults to first peer)
+   * @returns Promise that resolves with the task result
+   * @throws Error if no peers are connected or task times out
+   */
+  async delegateTask(task, peerId) {
+    if (!peerId) {
+      const peers = this.getPeers();
+      if (peers.length === 0) {
+        throw new Error("No peers connected to delegate task to");
+      }
+      peerId = peers[0].id;
+    }
+    if (!this.peers.has(peerId)) {
+      throw new Error(`Peer not found: ${peerId}`);
+    }
+    const timeout = task.timeout ?? this.config.taskTimeout ?? 3e5;
+    return new Promise((resolve, reject) => {
+      const message = createTaskDelegateMessage(this.config.instanceName, task);
+      const timeoutId = setTimeout(() => {
+        const pending = this.pendingTasks.get(task.id);
+        if (pending) {
+          this.pendingTasks.delete(task.id);
+          reject(new Error(`Task '${task.id}' timed out after ${timeout}ms`));
+        }
+      }, timeout);
+      this.pendingTasks.set(task.id, {
+        taskId: task.id,
+        peerId,
+        resolve,
+        reject,
+        timeoutId
+      });
+      this.sendToPeer(peerId, message).catch((error) => {
+        clearTimeout(timeoutId);
+        this.pendingTasks.delete(task.id);
+        reject(error);
+      });
+      logger2.debug({ taskId: task.id, peerId, timeout }, "Task delegated");
+    });
+  }
+  // ============================================================================
+  // Context Synchronization
+  // ============================================================================
+  /**
+   * Synchronize context with connected peers
+   * @param context Optional context to sync. If not provided, broadcasts to all peers
+   * @param peerId Optional peer ID to send to (defaults to all peers)
+   */
+  async syncContext(context, peerId) {
+    const contextToSync = context ?? {};
+    const message = createContextSyncMessage(this.config.instanceName, contextToSync);
+    if (peerId) {
+      await this.sendToPeer(peerId, message);
+      logger2.debug({ peerId, messageId: message.id }, "Context synced to peer");
+    } else {
+      await this.broadcast(message);
+      logger2.debug({ peerCount: this.peers.size, messageId: message.id }, "Context synced to all peers");
+    }
+  }
+  /**
+   * Request context from a peer based on a query
+   * @param query Description of what context is being requested
+   * @param peerId Optional peer ID to request from (defaults to first peer)
+   * @param timeout Optional timeout in milliseconds (default: 30000)
+   * @returns Promise that resolves with FileChunk[] from the peer
+   * @throws Error if no peers are connected or request times out
+   */
+  async requestContext(query, peerId, timeout = 3e4) {
+    if (!peerId) {
+      const peers = this.getPeers();
+      if (peers.length === 0) {
+        throw new Error("No peers connected to request context from");
+      }
+      peerId = peers[0].id;
+    }
+    if (!this.peers.has(peerId)) {
+      throw new Error(`Peer not found: ${peerId}`);
+    }
+    return new Promise((resolve, reject) => {
+      const message = createContextRequestMessage(this.config.instanceName, query);
+      const timeoutId = setTimeout(() => {
+        const pending = this.pendingContextRequests.get(message.id);
+        if (pending) {
+          this.pendingContextRequests.delete(message.id);
+          reject(new Error(`Context request timed out after ${timeout}ms`));
+        }
+      }, timeout);
+      this.pendingContextRequests.set(message.id, {
+        requestId: message.id,
+        peerId,
+        resolve,
+        reject,
+        timeoutId
+      });
+      this.sendToPeer(peerId, message).catch((error) => {
+        clearTimeout(timeoutId);
+        this.pendingContextRequests.delete(message.id);
+        reject(error);
+      });
+      logger2.debug({ requestId: message.id, peerId, query }, "Context requested");
+    });
+  }
+  /**
+   * Start automatic context synchronization
+   * Uses interval from config.contextSharing.syncInterval (default: 5000ms)
+   * @param contextProvider Optional function that returns context to sync
+   */
+  startAutoSync(contextProvider) {
+    this.stopAutoSync();
+    const interval = this.config.contextSharing?.syncInterval ?? 5e3;
+    this.autoSyncIntervalId = setInterval(async () => {
+      try {
+        const context = contextProvider ? await contextProvider() : void 0;
+        await this.syncContext(context);
+      } catch (error) {
+        logger2.error({ error: error.message }, "Auto-sync error");
+      }
+    }, interval);
+    logger2.info({ interval }, "Auto-sync started");
+  }
+  /**
+   * Stop automatic context synchronization
+   */
+  stopAutoSync() {
+    if (this.autoSyncIntervalId) {
+      clearInterval(this.autoSyncIntervalId);
+      this.autoSyncIntervalId = null;
+      logger2.info("Auto-sync stopped");
+    }
+  }
+  // ============================================================================
+  // Private Methods - Server
+  // ============================================================================
+  /**
+   * Start the WebSocket server
+   */
+  async startServer() {
+    const { listen } = this.config;
+    if (!listen) {
+      throw new Error("Listen configuration is required");
+    }
+    return new Promise((resolve, reject) => {
+      const host = listen.host ?? "0.0.0.0";
+      const port = listen.port;
+      logger2.debug({ host, port }, "Starting WebSocket server");
+      this.server = new WebSocketServer({ host, port });
+      this.server.on("listening", () => {
+        logger2.info({ host, port }, "WebSocket server listening");
+        resolve();
+      });
+      this.server.on("error", (error) => {
+        logger2.error({ error: error.message }, "WebSocket server error");
+        reject(error);
+      });
+      this.server.on("connection", (ws, request) => {
+        this.handleNewConnection(ws, request);
+      });
+    });
+  }
+  /**
+   * Handle a new incoming connection
+   */
+  handleNewConnection(ws, request) {
+    const peerId = uuidv42();
+    const peerInfo = {
+      id: peerId,
+      name: "client",
+      // Will be updated when we receive peer info
+      connectedAt: Date.now(),
+      lastActivity: Date.now()
+    };
+    this.peers.set(peerId, {
+      info: peerInfo,
+      ws
+    });
+    logger2.info({ peerId, url: request.url }, "New peer connected");
+    ws.on("message", (data) => {
+      const messageString = data.toString();
+      const result = safeDeserializeMessage(messageString);
+      if (result.success) {
+        peerInfo.lastActivity = Date.now();
+        this.handleMessage(result.data, ws, peerId);
+      } else {
+        logger2.warn({ peerId, error: result.error.message }, "Invalid message received");
+      }
+    });
+    ws.on("close", (code, reason) => {
+      logger2.info({ peerId, code, reason: reason.toString() }, "Peer disconnected");
+      this.peers.delete(peerId);
+      this.notifyPeerDisconnected(peerInfo);
+    });
+    ws.on("error", (error) => {
+      logger2.error({ peerId, error: error.message }, "Peer connection error");
+    });
+    this.notifyPeerConnected(peerInfo);
+  }
+  // ============================================================================
+  // Private Methods - Client
+  // ============================================================================
+  /**
+   * Connect to a remote bridge as a client
+   */
+  async connectToRemote() {
+    const { connect } = this.config;
+    if (!connect) {
+      throw new Error("Connect configuration is required");
+    }
+    let url = connect.url;
+    if (!url) {
+      const host = connect.hostGateway ? "host.docker.internal" : "localhost";
+      const port = connect.port ?? 8765;
+      url = `ws://${host}:${port}`;
+    }
+    this.clientTransport = new WebSocketTransport();
+    this.clientTransport.onMessage((message) => {
+      this.handleMessage(message, this.clientTransport);
+    });
+    this.clientTransport.onDisconnect(() => {
+      this.handleClientDisconnect(this.clientTransport);
+    });
+    try {
+      await this.clientTransport.connect({
+        url,
+        reconnect: true,
+        reconnectInterval: 1e3,
+        maxReconnectAttempts: 10
+      });
+      const peerId = uuidv42();
+      const peerInfo = {
+        id: peerId,
+        name: "server",
+        connectedAt: Date.now(),
+        lastActivity: Date.now()
+      };
+      this.peers.set(peerId, {
+        info: peerInfo,
+        transport: this.clientTransport
+      });
+      this.clientTransport._peerId = peerId;
+      this.notifyPeerConnected(peerInfo);
+      logger2.info({ peerId, url }, "Connected to remote bridge");
+    } catch (error) {
+      logger2.error({ error: error.message }, "Failed to connect to remote bridge");
+      this.clientTransport = null;
+      throw error;
+    }
+  }
+  /**
+   * Handle client transport disconnect
+   */
+  handleClientDisconnect(transport) {
+    const typedTransport = transport;
+    const peerId = typedTransport._peerId;
+    if (peerId) {
+      const peer = this.peers.get(peerId);
+      if (peer) {
+        this.peers.delete(peerId);
+        this.notifyPeerDisconnected(peer.info);
+        logger2.info({ peerId }, "Client transport disconnected");
+      }
+    }
+  }
+  // ============================================================================
+  // Private Methods - Message Handling
+  // ============================================================================
+  /**
+   * Handle an incoming message
+   */
+  handleMessage(message, source, peerId) {
+    if (!peerId) {
+      const typedSource = source;
+      peerId = typedSource._peerId;
+    }
+    if (!peerId) {
+      for (const [id, peer2] of this.peers) {
+        if (peer2.ws === source || peer2.transport === source) {
+          peerId = id;
+          break;
+        }
+      }
+    }
+    if (!peerId) {
+      logger2.warn({ messageId: message.id }, "Received message from unknown peer");
+      return;
+    }
+    const peer = this.peers.get(peerId);
+    if (peer) {
+      peer.info.lastActivity = Date.now();
+    }
+    logger2.debug({ peerId, messageId: message.id, type: message.type }, "Received message");
+    if (message.type === "task_delegate" && message.task) {
+      this.handleTaskDelegate(message, peerId);
+      return;
+    }
+    if (message.type === "response" && message.result?.taskId) {
+      this.handleTaskResponse(message);
+      return;
+    }
+    if (message.type === "context_sync" && message.context) {
+      this.handleContextSync(message, peerId);
+      return;
+    }
+    if (message.type === "request" && message.context?.summary) {
+      this.handleContextRequest(message, peerId);
+      return;
+    }
+    if (message.type === "response" && message.context?.files !== void 0) {
+      this.handleContextResponse(message);
+      return;
+    }
+    this.notifyMessageReceived(message, peerId);
+  }
+  /**
+   * Handle incoming task delegation request
+   */
+  async handleTaskDelegate(message, peerId) {
+    const task = message.task;
+    logger2.debug({ taskId: task.id, peerId }, "Received task delegation");
+    if (!this.taskReceivedHandler) {
+      logger2.warn({ taskId: task.id }, "No task handler registered");
+      const response = createTaskResponseMessage(
+        this.config.instanceName,
+        task.id,
+        {
+          success: false,
+          data: null,
+          error: "No task handler registered on peer"
+        }
+      );
+      await this.sendToPeer(peerId, response).catch((err) => {
+        logger2.error({ error: err.message, taskId: task.id }, "Failed to send error response");
+      });
+      return;
+    }
+    try {
+      const result = await this.taskReceivedHandler(task, peerId);
+      const response = createTaskResponseMessage(
+        this.config.instanceName,
+        task.id,
+        result
+      );
+      await this.sendToPeer(peerId, response);
+      logger2.debug({ taskId: task.id, success: result.success }, "Task response sent");
+    } catch (error) {
+      const response = createTaskResponseMessage(
+        this.config.instanceName,
+        task.id,
+        {
+          success: false,
+          data: null,
+          error: error.message
+        }
+      );
+      await this.sendToPeer(peerId, response).catch((err) => {
+        logger2.error({ error: err.message, taskId: task.id }, "Failed to send error response");
+      });
+      logger2.error({ taskId: task.id, error: error.message }, "Task handler error");
+    }
+  }
+  /**
+   * Handle task response message (correlate with pending task)
+   */
+  handleTaskResponse(message) {
+    const taskId = message.result.taskId;
+    const pending = this.pendingTasks.get(taskId);
+    if (!pending) {
+      logger2.warn({ taskId }, "Received response for unknown task");
+      return;
+    }
+    clearTimeout(pending.timeoutId);
+    this.pendingTasks.delete(taskId);
+    const result = {
+      taskId: message.result.taskId,
+      success: message.result.success,
+      data: message.result.data,
+      artifacts: message.result.artifacts,
+      followUp: message.result.followUp,
+      error: message.result.error
+    };
+    logger2.debug({ taskId, success: result.success }, "Task result received");
+    pending.resolve(result);
+  }
+  /**
+   * Handle incoming context sync message
+   */
+  handleContextSync(message, peerId) {
+    const context = message.context;
+    logger2.debug({ peerId, messageId: message.id }, "Received context sync");
+    this.notifyContextReceived(context, peerId);
+  }
+  /**
+   * Handle incoming context request message
+   */
+  async handleContextRequest(message, peerId) {
+    const query = message.context.summary;
+    logger2.debug({ peerId, messageId: message.id, query }, "Received context request");
+    if (!this.contextRequestedHandler) {
+      logger2.warn({ messageId: message.id }, "No context request handler registered");
+      const response = createContextSyncMessage(this.config.instanceName, { files: [] });
+      const responseMessage = {
+        ...response,
+        type: "response",
+        context: {
+          ...response.context,
+          variables: { requestId: message.id }
+        }
+      };
+      await this.sendToPeer(peerId, responseMessage).catch((err) => {
+        logger2.error({ error: err.message, messageId: message.id }, "Failed to send empty context response");
+      });
+      return;
+    }
+    try {
+      const files = await this.contextRequestedHandler(query, peerId);
+      const response = createContextSyncMessage(this.config.instanceName, { files });
+      const responseMessage = {
+        ...response,
+        type: "response",
+        context: {
+          ...response.context,
+          variables: { requestId: message.id }
+        }
+      };
+      await this.sendToPeer(peerId, responseMessage);
+      logger2.debug({ messageId: message.id, fileCount: files.length }, "Context response sent");
+    } catch (error) {
+      const response = createContextSyncMessage(this.config.instanceName, {
+        files: [],
+        summary: error.message
+      });
+      const responseMessage = {
+        ...response,
+        type: "response",
+        context: {
+          ...response.context,
+          variables: { requestId: message.id, error: error.message }
+        }
+      };
+      await this.sendToPeer(peerId, responseMessage).catch((err) => {
+        logger2.error({ error: err.message, messageId: message.id }, "Failed to send error context response");
+      });
+      logger2.error({ messageId: message.id, error: error.message }, "Context request handler error");
+    }
+  }
+  /**
+   * Handle context response message (correlate with pending context request)
+   */
+  handleContextResponse(message) {
+    const requestId = message.context?.variables?.requestId;
+    if (!requestId) {
+      logger2.warn({ messageId: message.id }, "Context response without requestId");
+      return;
+    }
+    const pending = this.pendingContextRequests.get(requestId);
+    if (!pending) {
+      logger2.warn({ requestId }, "Received response for unknown context request");
+      return;
+    }
+    clearTimeout(pending.timeoutId);
+    this.pendingContextRequests.delete(requestId);
+    const error = message.context?.variables?.error;
+    if (error) {
+      pending.reject(new Error(error));
+      return;
+    }
+    const files = message.context?.files ?? [];
+    logger2.debug({ requestId, fileCount: files.length }, "Context response received");
+    pending.resolve(files);
+  }
+  // ============================================================================
+  // Private Methods - Event Notification
+  // ============================================================================
+  notifyPeerConnected(peer) {
+    for (const handler of this.peerConnectedHandlers) {
+      try {
+        handler(peer);
+      } catch (error) {
+        logger2.error({ error: error.message }, "Peer connected handler error");
+      }
+    }
+  }
+  notifyPeerDisconnected(peer) {
+    for (const [taskId, pending] of this.pendingTasks) {
+      if (pending.peerId === peer.id) {
+        clearTimeout(pending.timeoutId);
+        this.pendingTasks.delete(taskId);
+        pending.reject(new Error(`Peer '${peer.id}' disconnected while task '${taskId}' was pending`));
+      }
+    }
+    for (const [requestId, pending] of this.pendingContextRequests) {
+      if (pending.peerId === peer.id) {
+        clearTimeout(pending.timeoutId);
+        this.pendingContextRequests.delete(requestId);
+        pending.reject(new Error(`Peer '${peer.id}' disconnected while context request '${requestId}' was pending`));
+      }
+    }
+    for (const handler of this.peerDisconnectedHandlers) {
+      try {
+        handler(peer);
+      } catch (error) {
+        logger2.error({ error: error.message }, "Peer disconnected handler error");
+      }
+    }
+  }
+  notifyMessageReceived(message, peerId) {
+    for (const handler of this.messageReceivedHandlers) {
+      try {
+        handler(message, peerId);
+      } catch (error) {
+        logger2.error({ error: error.message }, "Message received handler error");
+      }
+    }
+  }
+  notifyContextReceived(context, peerId) {
+    for (const handler of this.contextReceivedHandlers) {
+      try {
+        handler(context, peerId);
+      } catch (error) {
+        logger2.error({ error: error.message }, "Context received handler error");
+      }
+    }
+  }
+  // ============================================================================
+  // Private Methods - Cleanup
+  // ============================================================================
+  /**
+   * Clean up all resources
+   */
+  async cleanup() {
+    logger2.debug("Starting cleanup");
+    this.stopAutoSync();
+    logger2.debug("Auto-sync stopped");
+    const pendingTaskCount = this.pendingTasks.size;
+    for (const [taskId, pending] of this.pendingTasks) {
+      clearTimeout(pending.timeoutId);
+      pending.reject(new Error("Bridge is shutting down"));
+    }
+    this.pendingTasks.clear();
+    if (pendingTaskCount > 0) {
+      logger2.debug({ count: pendingTaskCount }, "Pending tasks cancelled");
+    }
+    const pendingContextCount = this.pendingContextRequests.size;
+    for (const [requestId, pending] of this.pendingContextRequests) {
+      clearTimeout(pending.timeoutId);
+      pending.reject(new Error("Bridge is shutting down"));
+    }
+    this.pendingContextRequests.clear();
+    if (pendingContextCount > 0) {
+      logger2.debug({ count: pendingContextCount }, "Pending context requests cancelled");
+    }
+    if (this.clientTransport) {
+      logger2.debug("Disconnecting client transport");
+      try {
+        await this.clientTransport.disconnect();
+        logger2.debug("Client transport disconnected");
+      } catch {
+      }
+      this.clientTransport = null;
+    }
+    const peerCount = this.peers.size;
+    if (peerCount > 0) {
+      logger2.debug({ count: peerCount }, "Closing peer connections");
+    }
+    for (const [peerId, peer] of this.peers) {
+      if (peer.ws) {
+        try {
+          peer.ws.close(1e3, "Bridge stopping");
+        } catch {
+        }
+      }
+      if (peer.transport) {
+        try {
+          await peer.transport.disconnect();
+        } catch {
+        }
+      }
+      logger2.debug({ peerId }, "Peer disconnected");
+    }
+    this.peers.clear();
+    if (this.server) {
+      logger2.debug("Closing WebSocket server");
+      await new Promise((resolve) => {
+        this.server.close(() => {
+          resolve();
+        });
+      });
+      this.server = null;
+      logger2.debug("WebSocket server closed");
+    }
+    logger2.debug("Cleanup complete");
+  }
+  // ============================================================================
+  // Getters for State Inspection
+  // ============================================================================
+  /**
+   * Check if the bridge is started
+   */
+  isStarted() {
+    return this.started;
+  }
+  /**
+   * Get the instance name
+   */
+  getInstanceName() {
+    return this.config.instanceName;
+  }
+  /**
+   * Get the operation mode
+   */
+  getMode() {
+    return this.config.mode;
+  }
+  /**
+   * Get the number of connected peers
+   */
+  getPeerCount() {
+    return this.peers.size;
+  }
+};
+
+// src/transport/discovery.ts
+import { execSync } from "child_process";
+var logger3 = createLogger("transport:discovery");
+function parseDockerLabels(labels) {
+  if (!labels) {
+    return null;
+  }
+  const labelMap = {};
+  for (const label of labels.split(",")) {
+    const [key, value] = label.split("=");
+    if (key && value) {
+      labelMap[key.trim()] = value.trim();
+    }
+  }
+  if (labelMap["claude.bridge.enabled"] !== "true") {
+    return null;
+  }
+  return {
+    enabled: true,
+    port: labelMap["claude.bridge.port"] ? parseInt(labelMap["claude.bridge.port"], 10) : void 0,
+    name: labelMap["claude.bridge.name"]
+  };
+}
+function isDockerAvailable() {
+  try {
+    execSync("docker info", { stdio: "pipe", timeout: 5e3 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function discoverDockerPeers() {
+  const peers = [];
+  if (!isDockerAvailable()) {
+    logger3.debug("Docker is not available");
+    return peers;
+  }
+  try {
+    const output = execSync(
+      'docker ps --format "{{.ID}}|{{.Names}}|{{.Labels}}|{{.Status}}|{{.Ports}}"',
+      {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"],
+        timeout: 1e4
+      }
+    );
+    const lines = output.trim().split("\n").filter(Boolean);
+    for (const line of lines) {
+      const [id, names, labels, status, ports] = line.split("|");
+      if (!id || !names) continue;
+      const bridgeConfig = parseDockerLabels(labels);
+      if (!bridgeConfig) continue;
+      let port = bridgeConfig.port;
+      if (!port && ports) {
+        const portMatch = ports.match(/0\.0\.0\.0:(\d+)/);
+        if (portMatch) {
+          port = parseInt(portMatch[1], 10);
+        }
+      }
+      if (port) {
+        peers.push({
+          name: bridgeConfig.name || names,
+          source: "docker",
+          url: `ws://localhost:${port}`,
+          containerId: id,
+          status
+        });
+        logger3.debug(
+          { containerId: id, name: bridgeConfig.name || names, port },
+          "Found bridge-enabled container"
+        );
+      }
+    }
+  } catch (error) {
+    logger3.debug(
+      { error: error.message },
+      "Failed to discover Docker peers"
+    );
+  }
+  return peers;
+}
+function discoverDocksalProjects() {
+  const peers = [];
+  try {
+    execSync("which fin", { stdio: "pipe" });
+    const output = execSync('fin project list 2>/dev/null || echo ""', {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 1e4
+    });
+    const lines = output.trim().split("\n").filter(Boolean);
+    for (const line of lines) {
+      if (line.includes("NAME") || line.startsWith("-")) continue;
+      const parts = line.trim().split(/\s+/);
+      const projectName = parts[0];
+      const status = parts.slice(1).join(" ");
+      if (projectName && status.toLowerCase().includes("running")) {
+        peers.push({
+          name: projectName,
+          source: "docksal",
+          url: `ws://${projectName}.docksal:8765`,
+          status: "running"
+        });
+        logger3.debug({ projectName }, "Found Docksal project");
+      }
+    }
+  } catch (error) {
+    logger3.debug(
+      { error: error.message },
+      "Docksal not available or no projects found"
+    );
+  }
+  return peers;
+}
+function discoverDdevProjects() {
+  const peers = [];
+  try {
+    execSync("which ddev", { stdio: "pipe" });
+    const output = execSync('ddev list --json-output 2>/dev/null || echo "[]"', {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 1e4
+    });
+    try {
+      const data = JSON.parse(output);
+      const projects = data.raw || [];
+      for (const project of projects) {
+        if (project.status === "running") {
+          peers.push({
+            name: project.name,
+            source: "ddev",
+            url: `ws://${project.name}.ddev.site:8765`,
+            status: "running"
+          });
+          logger3.debug({ projectName: project.name }, "Found DDEV project");
+        }
+      }
+    } catch {
+      logger3.debug("Failed to parse DDEV JSON output, trying text parsing");
+      const lines = output.trim().split("\n").filter(Boolean);
+      for (const line of lines) {
+        if (line.includes("running")) {
+          const parts = line.trim().split(/\s+/);
+          if (parts[0]) {
+            peers.push({
+              name: parts[0],
+              source: "ddev",
+              url: `ws://${parts[0]}.ddev.site:8765`,
+              status: "running"
+            });
+          }
+        }
+      }
+    }
+  } catch (error) {
+    logger3.debug(
+      { error: error.message },
+      "DDEV not available or no projects found"
+    );
+  }
+  return peers;
+}
+function discoverLandoProjects() {
+  const peers = [];
+  try {
+    execSync("which lando", { stdio: "pipe" });
+    const output = execSync('lando list --format json 2>/dev/null || echo "[]"', {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 1e4
+    });
+    try {
+      const apps = JSON.parse(output);
+      for (const app of apps) {
+        if (app.running) {
+          peers.push({
+            name: app.app || app.name,
+            source: "lando",
+            url: `ws://localhost:8765`,
+            // Would need to check app config for actual port
+            status: "running"
+          });
+          logger3.debug({ appName: app.app || app.name }, "Found Lando app");
+        }
+      }
+    } catch {
+      logger3.debug("Failed to parse Lando JSON output");
+    }
+  } catch (error) {
+    logger3.debug(
+      { error: error.message },
+      "Lando not available or no projects found"
+    );
+  }
+  return peers;
+}
+function discoverAllPeers() {
+  const allPeers = [];
+  const dockerPeers = discoverDockerPeers();
+  allPeers.push(...dockerPeers);
+  logger3.debug({ count: dockerPeers.length }, "Docker peers discovered");
+  const docksalPeers = discoverDocksalProjects();
+  allPeers.push(...docksalPeers);
+  logger3.debug({ count: docksalPeers.length }, "Docksal peers discovered");
+  const ddevPeers = discoverDdevProjects();
+  allPeers.push(...ddevPeers);
+  logger3.debug({ count: ddevPeers.length }, "DDEV peers discovered");
+  const landoPeers = discoverLandoProjects();
+  allPeers.push(...landoPeers);
+  logger3.debug({ count: landoPeers.length }, "Lando peers discovered");
+  return allPeers;
+}
+
+// src/environment/detect.ts
+import { existsSync } from "fs";
+function isInDocker() {
+  return existsSync("/.dockerenv");
+}
+function isDocksalEnvironment() {
+  return !!process.env.DOCKSAL_STACK;
+}
+function isDdevEnvironment() {
+  return process.env.IS_DDEV_PROJECT === "true";
+}
+function isLandoEnvironment() {
+  return process.env.LANDO === "ON";
+}
+function isDockerComposeEnvironment() {
+  return !!process.env.COMPOSE_PROJECT_NAME;
+}
+function detectEnvironment() {
+  const platform = process.platform;
+  const inDocker = isInDocker();
+  if (isDocksalEnvironment()) {
+    return {
+      type: "docksal",
+      isContainer: true,
+      projectName: process.env.DOCKSAL_PROJECT,
+      projectRoot: process.env.PROJECT_ROOT,
+      hostGateway: getHostGateway(),
+      platform,
+      meta: {
+        stack: process.env.DOCKSAL_STACK || "",
+        environment: process.env.DOCKSAL_ENVIRONMENT || ""
+      }
+    };
+  }
+  if (isDdevEnvironment()) {
+    return {
+      type: "ddev",
+      isContainer: true,
+      projectName: process.env.DDEV_PROJECT,
+      projectRoot: process.env.DDEV_DOCROOT,
+      hostGateway: getHostGateway(),
+      platform,
+      meta: {
+        hostname: process.env.DDEV_HOSTNAME || "",
+        primaryUrl: process.env.DDEV_PRIMARY_URL || ""
+      }
+    };
+  }
+  if (isLandoEnvironment()) {
+    return {
+      type: "lando",
+      isContainer: true,
+      projectName: process.env.LANDO_APP_NAME,
+      projectRoot: process.env.LANDO_APP_ROOT,
+      hostGateway: getHostGateway(),
+      platform,
+      meta: {
+        service: process.env.LANDO_SERVICE_NAME || "",
+        type: process.env.LANDO_SERVICE_TYPE || ""
+      }
+    };
+  }
+  if (isDockerComposeEnvironment() && inDocker) {
+    return {
+      type: "docker-compose",
+      isContainer: true,
+      projectName: process.env.COMPOSE_PROJECT_NAME,
+      hostGateway: getHostGateway(),
+      platform,
+      meta: {
+        service: process.env.COMPOSE_SERVICE || ""
+      }
+    };
+  }
+  if (inDocker) {
+    return {
+      type: "docker",
+      isContainer: true,
+      hostGateway: getHostGateway(),
+      platform
+    };
+  }
+  return {
+    type: "native",
+    isContainer: false,
+    platform
+  };
+}
+function getHostGateway() {
+  if (process.env.DOCKER_HOST_GATEWAY) {
+    return process.env.DOCKER_HOST_GATEWAY;
+  }
+  if (process.platform === "darwin" || process.platform === "win32") {
+    return "host.docker.internal";
+  }
+  if (isInDocker()) {
+    return "host.docker.internal";
+  }
+  return "localhost";
+}
+function getDefaultConfig(env) {
+  const baseConfig = {
+    mode: "peer",
+    instanceName: env.projectName || `${env.type}-instance`
+  };
+  if (env.isContainer) {
+    return {
+      ...baseConfig,
+      listen: {
+        port: 8765,
+        host: "0.0.0.0"
+      },
+      connect: {
+        url: `ws://${env.hostGateway || "host.docker.internal"}:8766`,
+        hostGateway: true
+      }
+    };
+  }
+  return {
+    ...baseConfig,
+    listen: {
+      port: 8766,
+      host: "0.0.0.0"
+    },
+    connect: {
+      url: "ws://localhost:8765",
+      hostGateway: false
+    }
+  };
+}
+
+// src/utils/config.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { parse as parseYaml } from "yaml";
+var DEFAULT_CONFIG = {
+  listen: {
+    port: 8765,
+    host: "0.0.0.0"
+  },
+  contextSharing: {
+    autoSync: true,
+    syncInterval: 5e3,
+    maxChunkTokens: 4e3,
+    includePatterns: ["src/**/*.ts", "src/**/*.tsx", "*.json"],
+    excludePatterns: ["node_modules/**", "dist/**", ".git/**"]
+  },
+  interaction: {
+    requireConfirmation: false,
+    notifyOnActivity: true,
+    taskTimeout: 3e5
+    // 5 minutes
+  }
+};
+function mergeConfig(partial) {
+  return {
+    ...DEFAULT_CONFIG,
+    ...partial,
+    listen: {
+      ...DEFAULT_CONFIG.listen,
+      ...partial.listen ?? {}
+    },
+    connect: partial.connect ? {
+      ...partial.connect
+    } : void 0,
+    contextSharing: {
+      ...DEFAULT_CONFIG.contextSharing,
+      ...partial.contextSharing ?? {}
+    },
+    interaction: {
+      ...DEFAULT_CONFIG.interaction,
+      ...partial.interaction ?? {}
+    }
+  };
+}
+function readConfigFile(filePath) {
+  try {
+    if (!fs.existsSync(filePath)) {
+      return null;
+    }
+    const content = fs.readFileSync(filePath, "utf-8");
+    const parsed = parseYaml(content);
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function getDefaultConfigPaths() {
+  const homeDir = os.homedir();
+  const cwd = process.cwd();
+  return [
+    // Project-local config takes priority
+    path.join(cwd, ".claude-bridge.yml"),
+    path.join(cwd, ".claude-bridge.yaml"),
+    // User home config as fallback
+    path.join(homeDir, ".claude-bridge", "config.yml"),
+    path.join(homeDir, ".claude-bridge", "config.yaml")
+  ];
+}
+async function loadConfig(configPath) {
+  if (configPath) {
+    const parsed = readConfigFile(configPath);
+    if (parsed) {
+      return mergeConfig(parsed);
+    }
+    return { ...DEFAULT_CONFIG };
+  }
+  const searchPaths = getDefaultConfigPaths();
+  for (const searchPath of searchPaths) {
+    const parsed = readConfigFile(searchPath);
+    if (parsed) {
+      return mergeConfig(parsed);
+    }
+  }
+  return { ...DEFAULT_CONFIG };
+}
+function loadConfigSync(configPath) {
+  if (configPath) {
+    const parsed = readConfigFile(configPath);
+    if (parsed) {
+      return mergeConfig(parsed);
+    }
+    return { ...DEFAULT_CONFIG };
+  }
+  const searchPaths = getDefaultConfigPaths();
+  for (const searchPath of searchPaths) {
+    const parsed = readConfigFile(searchPath);
+    if (parsed) {
+      return mergeConfig(parsed);
+    }
+  }
+  return { ...DEFAULT_CONFIG };
+}
+
+export {
+  createLogger,
+  createChildLogger,
+  MessageType,
+  FileChunkSchema,
+  DirectoryTreeSchema,
+  ArtifactSchema,
+  ContextSchema,
+  TaskRequestSchema,
+  TaskResultSchema,
+  BridgeMessageSchema,
+  createMessage,
+  validateMessage,
+  safeValidateMessage,
+  serializeMessage,
+  deserializeMessage,
+  safeDeserializeMessage,
+  ConnectionState,
+  WebSocketTransport,
+  createContextSyncMessage,
+  createTaskDelegateMessage,
+  createTaskResponseMessage,
+  createContextRequestMessage,
+  createNotificationMessage,
+  Bridge,
+  parseDockerLabels,
+  isDockerAvailable,
+  discoverDockerPeers,
+  discoverDocksalProjects,
+  discoverDdevProjects,
+  discoverLandoProjects,
+  discoverAllPeers,
+  detectEnvironment,
+  getHostGateway,
+  getDefaultConfig,
+  DEFAULT_CONFIG,
+  mergeConfig,
+  loadConfig,
+  loadConfigSync
+};
+//# sourceMappingURL=chunk-BRH476VK.js.map