@willjackson/claude-code-bridge 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1848 @@
+import { z } from 'zod';
+import pino from 'pino';
+
+/**
+ * Protocol definitions for Claude Code Bridge
+ * Defines message types, schemas, and serialization utilities
+ */
+
+declare const MessageType: z.ZodEnum<["request", "response", "context_sync", "task_delegate", "notification"]>;
+type MessageType = z.infer<typeof MessageType>;
+declare const FileChunkSchema: z.ZodObject<{
+    path: z.ZodString;
+    content: z.ZodString;
+    startLine: z.ZodOptional<z.ZodNumber>;
+    endLine: z.ZodOptional<z.ZodNumber>;
+    language: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    content: string;
+    startLine?: number | undefined;
+    endLine?: number | undefined;
+    language?: string | undefined;
+}, {
+    path: string;
+    content: string;
+    startLine?: number | undefined;
+    endLine?: number | undefined;
+    language?: string | undefined;
+}>;
+type FileChunk = z.infer<typeof FileChunkSchema>;
+declare const DirectoryTreeSchema: z.ZodType<DirectoryTree>;
+interface DirectoryTree {
+    name: string;
+    type: 'file' | 'directory';
+    children?: DirectoryTree[];
+}
+declare const ArtifactSchema: z.ZodObject<{
+    path: z.ZodString;
+    action: z.ZodEnum<["created", "modified", "deleted"]>;
+    diff: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    action: "created" | "modified" | "deleted";
+    diff?: string | undefined;
+}, {
+    path: string;
+    action: "created" | "modified" | "deleted";
+    diff?: string | undefined;
+}>;
+type Artifact = z.infer<typeof ArtifactSchema>;
+declare const ContextSchema: z.ZodObject<{
+    files: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        content: z.ZodString;
+        startLine: z.ZodOptional<z.ZodNumber>;
+        endLine: z.ZodOptional<z.ZodNumber>;
+        language: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        content: string;
+        startLine?: number | undefined;
+        endLine?: number | undefined;
+        language?: string | undefined;
+    }, {
+        path: string;
+        content: string;
+        startLine?: number | undefined;
+        endLine?: number | undefined;
+        language?: string | undefined;
+    }>, "many">>;
+    tree: z.ZodOptional<z.ZodType<DirectoryTree, z.ZodTypeDef, DirectoryTree>>;
+    summary: z.ZodOptional<z.ZodString>;
+    variables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, "strip", z.ZodTypeAny, {
+    files?: {
+        path: string;
+        content: string;
+        startLine?: number | undefined;
+        endLine?: number | undefined;
+        language?: string | undefined;
+    }[] | undefined;
+    tree?: DirectoryTree | undefined;
+    summary?: string | undefined;
+    variables?: Record<string, any> | undefined;
+}, {
+    files?: {
+        path: string;
+        content: string;
+        startLine?: number | undefined;
+        endLine?: number | undefined;
+        language?: string | undefined;
+    }[] | undefined;
+    tree?: DirectoryTree | undefined;
+    summary?: string | undefined;
+    variables?: Record<string, any> | undefined;
+}>;
+type Context = z.infer<typeof ContextSchema>;
+declare const TaskRequestSchema: z.ZodObject<{
+    id: z.ZodString;
+    description: z.ZodString;
+    scope: z.ZodEnum<["execute", "analyze", "suggest"]>;
+    constraints: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    returnFormat: z.ZodOptional<z.ZodEnum<["full", "summary", "diff"]>>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    description: string;
+    scope: "execute" | "analyze" | "suggest";
+    constraints?: string[] | undefined;
+    returnFormat?: "diff" | "summary" | "full" | undefined;
+    timeout?: number | undefined;
+}, {
+    id: string;
+    description: string;
+    scope: "execute" | "analyze" | "suggest";
+    constraints?: string[] | undefined;
+    returnFormat?: "diff" | "summary" | "full" | undefined;
+    timeout?: number | undefined;
+}>;
+type TaskRequest = z.infer<typeof TaskRequestSchema>;
+declare const TaskResultSchema: z.ZodObject<{
+    taskId: z.ZodOptional<z.ZodString>;
+    success: z.ZodBoolean;
+    data: z.ZodAny;
+    artifacts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        action: z.ZodEnum<["created", "modified", "deleted"]>;
+        diff: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        action: "created" | "modified" | "deleted";
+        diff?: string | undefined;
+    }, {
+        path: string;
+        action: "created" | "modified" | "deleted";
+        diff?: string | undefined;
+    }>, "many">>;
+    followUp: z.ZodOptional<z.ZodString>;
+    error: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    success: boolean;
+    error?: string | undefined;
+    taskId?: string | undefined;
+    data?: any;
+    artifacts?: {
+        path: string;
+        action: "created" | "modified" | "deleted";
+        diff?: string | undefined;
+    }[] | undefined;
+    followUp?: string | undefined;
+}, {
+    success: boolean;
+    error?: string | undefined;
+    taskId?: string | undefined;
+    data?: any;
+    artifacts?: {
+        path: string;
+        action: "created" | "modified" | "deleted";
+        diff?: string | undefined;
+    }[] | undefined;
+    followUp?: string | undefined;
+}>;
+type TaskResult = z.infer<typeof TaskResultSchema>;
+declare const BridgeMessageSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodEnum<["request", "response", "context_sync", "task_delegate", "notification"]>;
+    source: z.ZodString;
+    timestamp: z.ZodNumber;
+    context: z.ZodOptional<z.ZodObject<{
+        files: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            content: z.ZodString;
+            startLine: z.ZodOptional<z.ZodNumber>;
+            endLine: z.ZodOptional<z.ZodNumber>;
+            language: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            path: string;
+            content: string;
+            startLine?: number | undefined;
+            endLine?: number | undefined;
+            language?: string | undefined;
+        }, {
+            path: string;
+            content: string;
+            startLine?: number | undefined;
+            endLine?: number | undefined;
+            language?: string | undefined;
+        }>, "many">>;
+        tree: z.ZodOptional<z.ZodType<DirectoryTree, z.ZodTypeDef, DirectoryTree>>;
+        summary: z.ZodOptional<z.ZodString>;
+        variables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, "strip", z.ZodTypeAny, {
+        files?: {
+            path: string;
+            content: string;
+            startLine?: number | undefined;
+            endLine?: number | undefined;
+            language?: string | undefined;
+        }[] | undefined;
+        tree?: DirectoryTree | undefined;
+        summary?: string | undefined;
+        variables?: Record<string, any> | undefined;
+    }, {
+        files?: {
+            path: string;
+            content: string;
+            startLine?: number | undefined;
+            endLine?: number | undefined;
+            language?: string | undefined;
+        }[] | undefined;
+        tree?: DirectoryTree | undefined;
+        summary?: string | undefined;
+        variables?: Record<string, any> | undefined;
+    }>>;
+    task: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        description: z.ZodString;
+        scope: z.ZodEnum<["execute", "analyze", "suggest"]>;
+        constraints: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        returnFormat: z.ZodOptional<z.ZodEnum<["full", "summary", "diff"]>>;
+        timeout: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        description: string;
+        scope: "execute" | "analyze" | "suggest";
+        constraints?: string[] | undefined;
+        returnFormat?: "diff" | "summary" | "full" | undefined;
+        timeout?: number | undefined;
+    }, {
+        id: string;
+        description: string;
+        scope: "execute" | "analyze" | "suggest";
+        constraints?: string[] | undefined;
+        returnFormat?: "diff" | "summary" | "full" | undefined;
+        timeout?: number | undefined;
+    }>>;
+    result: z.ZodOptional<z.ZodObject<{
+        taskId: z.ZodOptional<z.ZodString>;
+        success: z.ZodBoolean;
+        data: z.ZodAny;
+        artifacts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            action: z.ZodEnum<["created", "modified", "deleted"]>;
+            diff: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            path: string;
+            action: "created" | "modified" | "deleted";
+            diff?: string | undefined;
+        }, {
+            path: string;
+            action: "created" | "modified" | "deleted";
+            diff?: string | undefined;
+        }>, "many">>;
+        followUp: z.ZodOptional<z.ZodString>;
+        error: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        success: boolean;
+        error?: string | undefined;
+        taskId?: string | undefined;
+        data?: any;
+        artifacts?: {
+            path: string;
+            action: "created" | "modified" | "deleted";
+            diff?: string | undefined;
+        }[] | undefined;
+        followUp?: string | undefined;
+    }, {
+        success: boolean;
+        error?: string | undefined;
+        taskId?: string | undefined;
+        data?: any;
+        artifacts?: {
+            path: string;
+            action: "created" | "modified" | "deleted";
+            diff?: string | undefined;
+        }[] | undefined;
+        followUp?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    type: "request" | "response" | "context_sync" | "task_delegate" | "notification";
+    id: string;
+    source: string;
+    timestamp: number;
+    context?: {
+        files?: {
+            path: string;
+            content: string;
+            startLine?: number | undefined;
+            endLine?: number | undefined;
+            language?: string | undefined;
+        }[] | undefined;
+        tree?: DirectoryTree | undefined;
+        summary?: string | undefined;
+        variables?: Record<string, any> | undefined;
+    } | undefined;
+    task?: {
+        id: string;
+        description: string;
+        scope: "execute" | "analyze" | "suggest";
+        constraints?: string[] | undefined;
+        returnFormat?: "diff" | "summary" | "full" | undefined;
+        timeout?: number | undefined;
+    } | undefined;
+    result?: {
+        success: boolean;
+        error?: string | undefined;
+        taskId?: string | undefined;
+        data?: any;
+        artifacts?: {
+            path: string;
+            action: "created" | "modified" | "deleted";
+            diff?: string | undefined;
+        }[] | undefined;
+        followUp?: string | undefined;
+    } | undefined;
+}, {
+    type: "request" | "response" | "context_sync" | "task_delegate" | "notification";
+    id: string;
+    source: string;
+    timestamp: number;
+    context?: {
+        files?: {
+            path: string;
+            content: string;
+            startLine?: number | undefined;
+            endLine?: number | undefined;
+            language?: string | undefined;
+        }[] | undefined;
+        tree?: DirectoryTree | undefined;
+        summary?: string | undefined;
+        variables?: Record<string, any> | undefined;
+    } | undefined;
+    task?: {
+        id: string;
+        description: string;
+        scope: "execute" | "analyze" | "suggest";
+        constraints?: string[] | undefined;
+        returnFormat?: "diff" | "summary" | "full" | undefined;
+        timeout?: number | undefined;
+    } | undefined;
+    result?: {
+        success: boolean;
+        error?: string | undefined;
+        taskId?: string | undefined;
+        data?: any;
+        artifacts?: {
+            path: string;
+            action: "created" | "modified" | "deleted";
+            diff?: string | undefined;
+        }[] | undefined;
+        followUp?: string | undefined;
+    } | undefined;
+}>;
+type BridgeMessage = z.infer<typeof BridgeMessageSchema>;
+/**
+ * Creates a base message with auto-generated UUID and timestamp
+ * @param type The message type
+ * @param source The source instance identifier
+ * @returns A partial BridgeMessage with id, type, source, and timestamp
+ */
+declare function createMessage(type: MessageType, source: string): BridgeMessage;
+/**
+ * Validates a message against the BridgeMessage schema
+ * @param data The data to validate
+ * @returns The validated BridgeMessage or throws if invalid
+ */
+declare function validateMessage(data: unknown): BridgeMessage;
+/**
+ * Safe validation that returns a result object instead of throwing
+ * @param data The data to validate
+ * @returns A Zod SafeParseReturnType with success/error information
+ */
+declare function safeValidateMessage(data: unknown): z.SafeParseReturnType<{
+    type: "request" | "response" | "context_sync" | "task_delegate" | "notification";
+    id: string;
+    source: string;
+    timestamp: number;
+    context?: {
+        files?: {
+            path: string;
+            content: string;
+            startLine?: number | undefined;
+            endLine?: number | undefined;
+            language?: string | undefined;
+        }[] | undefined;
+        tree?: DirectoryTree | undefined;
+        summary?: string | undefined;
+        variables?: Record<string, any> | undefined;
+    } | undefined;
+    task?: {
+        id: string;
+        description: string;
+        scope: "execute" | "analyze" | "suggest";
+        constraints?: string[] | undefined;
+        returnFormat?: "diff" | "summary" | "full" | undefined;
+        timeout?: number | undefined;
+    } | undefined;
+    result?: {
+        success: boolean;
+        error?: string | undefined;
+        taskId?: string | undefined;
+        data?: any;
+        artifacts?: {
+            path: string;
+            action: "created" | "modified" | "deleted";
+            diff?: string | undefined;
+        }[] | undefined;
+        followUp?: string | undefined;
+    } | undefined;
+}, {
+    type: "request" | "response" | "context_sync" | "task_delegate" | "notification";
+    id: string;
+    source: string;
+    timestamp: number;
+    context?: {
+        files?: {
+            path: string;
+            content: string;
+            startLine?: number | undefined;
+            endLine?: number | undefined;
+            language?: string | undefined;
+        }[] | undefined;
+        tree?: DirectoryTree | undefined;
+        summary?: string | undefined;
+        variables?: Record<string, any> | undefined;
+    } | undefined;
+    task?: {
+        id: string;
+        description: string;
+        scope: "execute" | "analyze" | "suggest";
+        constraints?: string[] | undefined;
+        returnFormat?: "diff" | "summary" | "full" | undefined;
+        timeout?: number | undefined;
+    } | undefined;
+    result?: {
+        success: boolean;
+        error?: string | undefined;
+        taskId?: string | undefined;
+        data?: any;
+        artifacts?: {
+            path: string;
+            action: "created" | "modified" | "deleted";
+            diff?: string | undefined;
+        }[] | undefined;
+        followUp?: string | undefined;
+    } | undefined;
+}>;
+/**
+ * Serializes a BridgeMessage to JSON string
+ * @param message The message to serialize
+ * @returns JSON string representation
+ */
+declare function serializeMessage(message: BridgeMessage): string;
+/**
+ * Deserializes a JSON string to a validated BridgeMessage
+ * @param json The JSON string to deserialize
+ * @returns The validated BridgeMessage
+ * @throws Error if JSON is invalid or message doesn't match schema
+ */
+declare function deserializeMessage(json: string): BridgeMessage;
+/**
+ * Safe deserialization that returns a result object instead of throwing
+ * @param json The JSON string to deserialize
+ * @returns A Zod SafeParseReturnType with success/error information
+ */
+declare function safeDeserializeMessage(json: string): z.SafeParseSuccess<{
+    type: "request" | "response" | "context_sync" | "task_delegate" | "notification";
+    id: string;
+    source: string;
+    timestamp: number;
+    context?: {
+        files?: {
+            path: string;
+            content: string;
+            startLine?: number | undefined;
+            endLine?: number | undefined;
+            language?: string | undefined;
+        }[] | undefined;
+        tree?: DirectoryTree | undefined;
+        summary?: string | undefined;
+        variables?: Record<string, any> | undefined;
+    } | undefined;
+    task?: {
+        id: string;
+        description: string;
+        scope: "execute" | "analyze" | "suggest";
+        constraints?: string[] | undefined;
+        returnFormat?: "diff" | "summary" | "full" | undefined;
+        timeout?: number | undefined;
+    } | undefined;
+    result?: {
+        success: boolean;
+        error?: string | undefined;
+        taskId?: string | undefined;
+        data?: any;
+        artifacts?: {
+            path: string;
+            action: "created" | "modified" | "deleted";
+            diff?: string | undefined;
+        }[] | undefined;
+        followUp?: string | undefined;
+    } | undefined;
+}> | {
+    success: false;
+    error: z.ZodError<any>;
+};
+
+/**
+ * Bridge Core - Main orchestration class for Claude Code Bridge
+ * Handles peer connections, message routing, and lifecycle management
+ */
+
+/**
+ * Bridge operation mode
+ * - 'host': Listen for incoming connections only
+ * - 'client': Connect to a remote bridge only
+ * - 'peer': Both listen and connect (bidirectional)
+ */
+type BridgeMode = 'host' | 'client' | 'peer';
+/**
+ * Configuration for the bridge's listening server
+ */
+interface BridgeListenConfig {
+    /** Port to listen on */
+    port: number;
+    /** Host to bind to (default: 0.0.0.0) */
+    host?: string;
+}
+/**
+ * Configuration for connecting to a remote bridge
+ */
+interface BridgeConnectConfig {
+    /** Full WebSocket URL (e.g., ws://localhost:8765) */
+    url?: string;
+    /** Use host.docker.internal for container-to-host connection */
+    hostGateway?: boolean;
+    /** Port to connect to (used if url is not provided) */
+    port?: number;
+}
+/**
+ * Context sharing configuration
+ */
+interface ContextSharingConfig$1 {
+    /** Enable automatic context synchronization */
+    autoSync?: boolean;
+    /** Interval in milliseconds for auto-sync (default: 5000) */
+    syncInterval?: number;
+}
+/**
+ * Full configuration for Bridge initialization
+ */
+interface BridgeConfig$1 {
+    /** Operation mode: 'host', 'client', or 'peer' */
+    mode: BridgeMode;
+    /** Unique identifier for this bridge instance */
+    instanceName: string;
+    /** Server configuration (required for 'host' and 'peer' modes) */
+    listen?: BridgeListenConfig;
+    /** Connection configuration (required for 'client' and 'peer' modes) */
+    connect?: BridgeConnectConfig;
+    /** Task timeout in milliseconds (default: 300000 / 5 minutes) */
+    taskTimeout?: number;
+    /** Context sharing configuration */
+    contextSharing?: ContextSharingConfig$1;
+}
+/**
+ * Information about a connected peer
+ */
+interface PeerInfo {
+    /** Unique identifier for the peer connection */
+    id: string;
+    /** Name of the peer instance */
+    name: string;
+    /** Environment type of the peer */
+    environment?: string;
+    /** Timestamp when the peer connected */
+    connectedAt: number;
+    /** Timestamp of last activity from the peer */
+    lastActivity: number;
+}
+/**
+ * Handler for peer connection events
+ */
+type PeerConnectedHandler = (peer: PeerInfo) => void;
+/**
+ * Handler for peer disconnection events
+ */
+type PeerDisconnectedHandler = (peer: PeerInfo) => void;
+/**
+ * Handler for incoming messages from peers
+ */
+type MessageReceivedHandler = (message: BridgeMessage, peerId: string) => void;
+/**
+ * Handler for incoming task delegation requests
+ * Returns a TaskResult or Promise<TaskResult>
+ */
+type TaskReceivedHandler = (task: TaskRequest, peerId: string) => TaskResult | Promise<TaskResult>;
+/**
+ * Handler for incoming context synchronization
+ */
+type ContextReceivedHandler = (context: Context, peerId: string) => void;
+/**
+ * Handler for incoming context requests
+ * Returns FileChunk[] or Promise<FileChunk[]>
+ */
+type ContextRequestedHandler = (query: string, peerId: string) => FileChunk[] | Promise<FileChunk[]>;
+/**
+ * Main Bridge class for managing peer-to-peer communication
+ * Supports three modes of operation:
+ * - 'host': Acts as a server, accepting incoming connections
+ * - 'client': Acts as a client, connecting to a remote server
+ * - 'peer': Both listens for connections and connects to a remote peer
+ */
+declare class Bridge {
+    private config;
+    private server;
+    private clientTransport;
+    private peers;
+    private started;
+    private peerConnectedHandlers;
+    private peerDisconnectedHandlers;
+    private messageReceivedHandlers;
+    private taskReceivedHandler;
+    private contextReceivedHandlers;
+    private contextRequestedHandler;
+    private pendingTasks;
+    private pendingContextRequests;
+    private autoSyncIntervalId;
+    /**
+     * Create a new Bridge instance
+     * @param config Bridge configuration
+     */
+    constructor(config: BridgeConfig$1);
+    /**
+     * Validate the configuration based on mode requirements
+     */
+    private validateConfig;
+    /**
+     * Start the bridge based on configured mode
+     * - 'host': Starts WebSocket server
+     * - 'client': Connects to remote bridge
+     * - 'peer': Both starts server and connects to remote
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the bridge and close all connections
+     */
+    stop(): Promise<void>;
+    /**
+     * Get list of connected peers
+     */
+    getPeers(): PeerInfo[];
+    /**
+     * Connect to a remote bridge
+     * @param url WebSocket URL to connect to
+     */
+    connectToPeer(url: string): Promise<void>;
+    /**
+     * Disconnect from a specific peer
+     * @param peerId ID of the peer to disconnect from
+     */
+    disconnectFromPeer(peerId: string): Promise<void>;
+    /**
+     * Send a message to a specific peer
+     * @param peerId ID of the peer to send to
+     * @param message Message to send
+     */
+    sendToPeer(peerId: string, message: BridgeMessage): Promise<void>;
+    /**
+     * Broadcast a message to all connected peers
+     * @param message Message to broadcast
+     */
+    broadcast(message: BridgeMessage): Promise<void>;
+    /**
+     * Register a handler for peer connection events
+     */
+    onPeerConnected(handler: PeerConnectedHandler): void;
+    /**
+     * Register a handler for peer disconnection events
+     */
+    onPeerDisconnected(handler: PeerDisconnectedHandler): void;
+    /**
+     * Register a handler for incoming messages
+     */
+    onMessage(handler: MessageReceivedHandler): void;
+    /**
+     * 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: TaskReceivedHandler): void;
+    /**
+     * Register a handler for incoming context synchronization
+     * Multiple handlers can be registered
+     * @param handler Function that receives context and peerId
+     */
+    onContextReceived(handler: ContextReceivedHandler): void;
+    /**
+     * 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: ContextRequestedHandler): void;
+    /**
+     * 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
+     */
+    delegateTask(task: TaskRequest, peerId?: string): Promise<TaskResult>;
+    /**
+     * 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)
+     */
+    syncContext(context?: Context, peerId?: string): Promise<void>;
+    /**
+     * 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
+     */
+    requestContext(query: string, peerId?: string, timeout?: number): Promise<FileChunk[]>;
+    /**
+     * Start automatic context synchronization
+     * Uses interval from config.contextSharing.syncInterval (default: 5000ms)
+     * @param contextProvider Optional function that returns context to sync
+     */
+    startAutoSync(contextProvider?: () => Context | Promise<Context>): void;
+    /**
+     * Stop automatic context synchronization
+     */
+    stopAutoSync(): void;
+    /**
+     * Start the WebSocket server
+     */
+    private startServer;
+    /**
+     * Handle a new incoming connection
+     */
+    private handleNewConnection;
+    /**
+     * Connect to a remote bridge as a client
+     */
+    private connectToRemote;
+    /**
+     * Handle client transport disconnect
+     */
+    private handleClientDisconnect;
+    /**
+     * Handle an incoming message
+     */
+    private handleMessage;
+    /**
+     * Handle incoming task delegation request
+     */
+    private handleTaskDelegate;
+    /**
+     * Handle task response message (correlate with pending task)
+     */
+    private handleTaskResponse;
+    /**
+     * Handle incoming context sync message
+     */
+    private handleContextSync;
+    /**
+     * Handle incoming context request message
+     */
+    private handleContextRequest;
+    /**
+     * Handle context response message (correlate with pending context request)
+     */
+    private handleContextResponse;
+    private notifyPeerConnected;
+    private notifyPeerDisconnected;
+    private notifyMessageReceived;
+    private notifyContextReceived;
+    /**
+     * Clean up all resources
+     */
+    private cleanup;
+    /**
+     * Check if the bridge is started
+     */
+    isStarted(): boolean;
+    /**
+     * Get the instance name
+     */
+    getInstanceName(): string;
+    /**
+     * Get the operation mode
+     */
+    getMode(): BridgeMode;
+    /**
+     * Get the number of connected peers
+     */
+    getPeerCount(): number;
+}
+
+/**
+ * Message builder factory functions for Claude Code Bridge
+ * Provides convenient functions to create specific message types
+ */
+
+/**
+ * Notification data structure for notification messages
+ */
+interface NotificationData {
+    type: string;
+    message: string;
+    data?: Record<string, unknown>;
+}
+/**
+ * Creates a context synchronization message
+ * Used to share context (files, tree, summary) with a peer
+ * @param source The source instance identifier
+ * @param context The context to synchronize
+ * @returns A BridgeMessage with type 'context_sync'
+ */
+declare function createContextSyncMessage(source: string, context: Context): BridgeMessage;
+/**
+ * Creates a task delegation message
+ * Used to delegate a task to a peer instance
+ * @param source The source instance identifier
+ * @param task The task to delegate
+ * @returns A BridgeMessage with type 'task_delegate'
+ */
+declare function createTaskDelegateMessage(source: string, task: TaskRequest): BridgeMessage;
+/**
+ * Creates a task response message
+ * Used to respond to a delegated task
+ * @param source The source instance identifier
+ * @param taskId The ID of the task being responded to
+ * @param result The result of the task execution
+ * @returns A BridgeMessage with type 'response'
+ */
+declare function createTaskResponseMessage(source: string, taskId: string, result: Omit<TaskResult, 'taskId'>): BridgeMessage;
+/**
+ * Creates a context request message
+ * Used to request specific context from a peer
+ * @param source The source instance identifier
+ * @param query A description of what context is being requested
+ * @returns A BridgeMessage with type 'request'
+ */
+declare function createContextRequestMessage(source: string, query: string): BridgeMessage;
+/**
+ * Creates a notification message
+ * Used to send notifications to peers (events, status updates, etc.)
+ * @param source The source instance identifier
+ * @param notification The notification data
+ * @returns A BridgeMessage with type 'notification'
+ */
+declare function createNotificationMessage(source: string, notification: NotificationData): BridgeMessage;
+
+/**
+ * Context Manager for Claude Code Bridge
+ *
+ * Handles project context management including:
+ * - Project snapshot generation
+ * - Relevant context extraction with token limits
+ * - Delta synchronization between snapshots
+ */
+
+/**
+ * Options for building a directory tree
+ */
+interface BuildDirectoryTreeOptions {
+    /** Glob patterns for files to include */
+    includePatterns?: string[];
+    /** Glob patterns for files to exclude */
+    excludePatterns?: string[];
+    /** Maximum depth for directory tree building (default: 10) */
+    maxDepth?: number;
+}
+/**
+ * Build a directory tree structure starting from a root path
+ *
+ * This standalone function creates a DirectoryTree representation
+ * of the file system, respecting include/exclude patterns and depth limits.
+ * Symlinks are handled safely to prevent infinite loops.
+ *
+ * @param rootPath The root path to start building from
+ * @param options Configuration options
+ * @returns DirectoryTree representation of the directory structure
+ *
+ * @example
+ * ```typescript
+ * const tree = buildDirectoryTree('/path/to/project', {
+ *   includePatterns: ['src/**\/*.ts'],
+ *   excludePatterns: ['node_modules/**'],
+ *   maxDepth: 5
+ * });
+ * ```
+ */
+declare function buildDirectoryTree(rootPath: string, options?: BuildDirectoryTreeOptions): DirectoryTree;
+/**
+ * Configuration options for ContextManager
+ */
+interface ContextManagerOptions {
+    /** Root path of the project to manage context for */
+    rootPath: string;
+    /** Glob patterns for files to include */
+    includePatterns: string[];
+    /** Glob patterns for files to exclude */
+    excludePatterns: string[];
+    /** Maximum depth for directory tree building (default: 10) */
+    maxDepth?: number;
+}
+/**
+ * Snapshot of the project state at a point in time
+ */
+interface ProjectSnapshot {
+    /** Unique identifier for this snapshot */
+    id: string;
+    /** Unix timestamp when snapshot was created */
+    timestamp: number;
+    /** Directory tree structure */
+    tree: DirectoryTree;
+    /** Summary of the project (file count, languages, etc.) */
+    summary: string;
+    /** List of key files identified in the project */
+    keyFiles: string[];
+}
+/**
+ * Represents a change to a file between snapshots
+ */
+interface FileChange {
+    /** Relative path of the file */
+    path: string;
+    /** Type of change detected */
+    action: 'added' | 'modified' | 'deleted';
+    /** Diff content for modified files */
+    diff?: string;
+}
+/**
+ * Delta between two snapshots
+ */
+interface ContextDelta {
+    /** ID of the source snapshot */
+    fromSyncId: string;
+    /** ID of the target snapshot */
+    toSyncId: string;
+    /** List of file changes */
+    changes: FileChange[];
+}
+/**
+ * ContextManager handles project context extraction and management
+ */
+declare class ContextManager {
+    private readonly rootPath;
+    private readonly includePatterns;
+    private readonly excludePatterns;
+    private readonly maxDepth;
+    /** Stored snapshots for delta comparison */
+    private readonly snapshotStates;
+    /**
+     * Create a new ContextManager
+     * @param options Configuration options
+     */
+    constructor(options: ContextManagerOptions);
+    /**
+     * Generate a complete snapshot of the current project state
+     * @returns ProjectSnapshot with tree structure, summary, and key files
+     */
+    generateSnapshot(): Promise<ProjectSnapshot>;
+    /**
+     * Get changes since the last snapshot
+     *
+     * Compares the current file system state with a previously stored snapshot
+     * to detect added, modified, and deleted files.
+     *
+     * @param lastSyncId ID of the last snapshot to compare against
+     * @returns ContextDelta with changes since the last sync
+     * @throws Error if lastSyncId is not found
+     */
+    getDelta(lastSyncId: string): Promise<ContextDelta>;
+    /**
+     * Generate a simple diff for a modified file
+     * Returns the new content (simplified diff for now)
+     */
+    private generateFileDiff;
+    /**
+     * Get relevant file chunks based on a task description, respecting token limits
+     * @param task Description of the task to get context for
+     * @param maxTokens Maximum tokens for the returned context
+     * @returns Array of FileChunk objects within the token limit
+     */
+    getRelevantContext(task: string, maxTokens: number): Promise<FileChunk[]>;
+    /**
+     * Collect all files matching include patterns and not matching exclude patterns
+     */
+    private collectMatchingFiles;
+    private collectFilesRecursive;
+    /**
+     * Check if a path matches any include pattern
+     */
+    private isIncluded;
+    /**
+     * Check if a path matches any exclude pattern
+     */
+    private isExcluded;
+    /**
+     * Check if a directory should be traversed based on include patterns
+     */
+    private shouldIncludeDirectory;
+    /**
+     * Identify key files in the project (config files, entry points, etc.)
+     */
+    private identifyKeyFiles;
+    /**
+     * Generate a summary string describing the project
+     */
+    private generateSummary;
+    /**
+     * Rank files by relevance to a task description
+     * Files with matching keywords are ranked higher
+     */
+    private rankFilesForTask;
+    /**
+     * Get programming language from file extension
+     */
+    private getLanguage;
+    /**
+     * Truncate file content to fit within a token limit
+     */
+    private truncateContent;
+}
+
+/**
+ * Transport layer interface and types for Claude Code Bridge
+ * Defines the abstract transport interface for communication between bridge instances
+ */
+
+/**
+ * Represents the current state of a transport connection
+ */
+declare enum ConnectionState {
+    /** Not connected to any peer */
+    DISCONNECTED = "DISCONNECTED",
+    /** Currently attempting to establish connection */
+    CONNECTING = "CONNECTING",
+    /** Successfully connected and ready for communication */
+    CONNECTED = "CONNECTED",
+    /** Connection lost, attempting to reconnect */
+    RECONNECTING = "RECONNECTING"
+}
+/**
+ * Authentication configuration for transport connections
+ */
+interface AuthConfig {
+    /** Authentication type */
+    type: 'token' | 'none';
+    /** Authentication token (required if type is 'token') */
+    token?: string;
+}
+/**
+ * Configuration for establishing a transport connection
+ */
+interface ConnectionConfig {
+    /** Full WebSocket URL (e.g., ws://localhost:8765) */
+    url?: string;
+    /** Host to connect to (used if url is not provided) */
+    host?: string;
+    /** Port to connect to (used if url is not provided) */
+    port?: number;
+    /** Enable automatic reconnection on disconnect */
+    reconnect?: boolean;
+    /** Interval between reconnection attempts in milliseconds */
+    reconnectInterval?: number;
+    /** Maximum number of reconnection attempts before giving up */
+    maxReconnectAttempts?: number;
+    /** Authentication configuration */
+    auth?: AuthConfig;
+}
+/**
+ * Handler for incoming messages
+ */
+type MessageHandler = (message: BridgeMessage) => void;
+/**
+ * Handler for disconnect events
+ */
+type DisconnectHandler = () => void;
+/**
+ * Handler for error events
+ */
+type ErrorHandler = (error: Error) => void;
+/**
+ * Abstract transport interface for bridge communication
+ * Implementations handle the actual network protocol (WebSocket, TCP, etc.)
+ */
+interface Transport {
+    /**
+     * Establish connection to a remote peer
+     * @param config Connection configuration
+     * @returns Promise that resolves when connection is established
+     * @throws Error if connection fails
+     */
+    connect(config: ConnectionConfig): Promise<void>;
+    /**
+     * Cleanly close the current connection
+     * @returns Promise that resolves when disconnection is complete
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Send a message to the connected peer
+     * @param message The message to send
+     * @returns Promise that resolves when message is sent
+     * @throws Error if not connected and message cannot be queued
+     */
+    send(message: BridgeMessage): Promise<void>;
+    /**
+     * Register a handler for incoming messages
+     * @param handler Function to call when a message is received
+     */
+    onMessage(handler: MessageHandler): void;
+    /**
+     * Register a handler for disconnect events
+     * @param handler Function to call when connection is lost
+     */
+    onDisconnect(handler: DisconnectHandler): void;
+    /**
+     * Register a handler for error events
+     * @param handler Function to call when an error occurs
+     */
+    onError(handler: ErrorHandler): void;
+    /**
+     * Check if the transport is currently connected
+     * @returns true if connected, false otherwise
+     */
+    isConnected(): boolean;
+    /**
+     * Get the current connection state
+     * @returns The current ConnectionState
+     */
+    getState(): ConnectionState;
+}
+
+/**
+ * WebSocket Transport implementation for Claude Code Bridge
+ * Provides WebSocket-based communication between bridge instances
+ */
+
+/**
+ * WebSocket-based transport implementation
+ * Handles connection lifecycle, message sending/receiving, and event handling
+ * Supports auto-reconnection, message queuing, and heartbeat monitoring
+ */
+declare class WebSocketTransport implements Transport {
+    private ws;
+    private state;
+    private config;
+    private reconnectAttempts;
+    private reconnectTimer;
+    private intentionalDisconnect;
+    private messageQueue;
+    private heartbeatInterval;
+    private heartbeatTimeout;
+    private awaitingPong;
+    private messageHandlers;
+    private disconnectHandlers;
+    private errorHandlers;
+    private reconnectingHandlers;
+    /**
+     * Build the WebSocket URL from the connection configuration
+     */
+    private buildUrl;
+    /**
+     * Establish connection to a remote peer
+     */
+    connect(config: ConnectionConfig): Promise<void>;
+    /**
+     * Internal method to establish WebSocket connection
+     * Used for both initial connection and reconnection attempts
+     */
+    private establishConnection;
+    /**
+     * Cleanly close the current connection
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Send a message to the connected peer
+     * If disconnected and reconnection is enabled, queues the message for later delivery
+     */
+    send(message: BridgeMessage): Promise<void>;
+    /**
+     * Immediately send a message over the WebSocket
+     */
+    private sendImmediate;
+    /**
+     * Queue a message for later delivery when reconnected
+     */
+    private queueMessage;
+    /**
+     * Flush all queued messages after reconnection
+     */
+    private flushMessageQueue;
+    /**
+     * Register a handler for incoming messages
+     */
+    onMessage(handler: MessageHandler): void;
+    /**
+     * Register a handler for disconnect events
+     */
+    onDisconnect(handler: DisconnectHandler): void;
+    /**
+     * Register a handler for error events
+     */
+    onError(handler: ErrorHandler): void;
+    /**
+     * Register a handler for reconnecting events
+     */
+    onReconnecting(handler: (attempt: number, maxAttempts: number) => void): void;
+    /**
+     * Check if the transport is currently connected
+     */
+    isConnected(): boolean;
+    /**
+     * Get the current connection state
+     */
+    getState(): ConnectionState;
+    /**
+     * Handle incoming WebSocket messages
+     */
+    private handleIncomingMessage;
+    /**
+     * Notify all disconnect handlers
+     */
+    private notifyDisconnect;
+    /**
+     * Notify all error handlers
+     */
+    private notifyError;
+    /**
+     * Notify all reconnecting handlers
+     */
+    private notifyReconnecting;
+    /**
+     * Check if reconnection should be attempted
+     */
+    private shouldReconnect;
+    /**
+     * Schedule a reconnection attempt
+     */
+    private scheduleReconnect;
+    /**
+     * Clear any pending reconnection timer
+     */
+    private clearReconnectTimer;
+    /**
+     * Start the heartbeat monitoring
+     */
+    private startHeartbeat;
+    /**
+     * Stop the heartbeat monitoring
+     */
+    private stopHeartbeat;
+    /**
+     * Send a ping to the peer
+     */
+    private sendPing;
+    /**
+     * Handle pong response from peer
+     */
+    private handlePong;
+    /**
+     * Handle heartbeat timeout (no pong received)
+     */
+    private handleHeartbeatTimeout;
+    /**
+     * Get the current message queue length (for testing)
+     */
+    getQueueLength(): number;
+    /**
+     * Get the number of reconnection attempts (for testing)
+     */
+    getReconnectAttempts(): number;
+}
+
+/**
+ * Peer Discovery Module
+ *
+ * Provides functions to discover bridge-enabled Docker containers
+ * and development environment projects.
+ */
+/**
+ * Discovered peer information
+ */
+interface DiscoveredPeer {
+    name: string;
+    source: 'docker' | 'docksal' | 'ddev' | 'lando';
+    url: string;
+    containerId?: string;
+    status?: string;
+}
+/**
+ * Bridge label configuration parsed from Docker container labels
+ */
+interface BridgeLabelConfig {
+    enabled: boolean;
+    port?: number;
+    name?: string;
+}
+/**
+ * Parse Docker container labels to extract bridge configuration
+ *
+ * @param labels - Comma-separated label string from Docker
+ * @returns Parsed bridge configuration or null if bridge not enabled
+ */
+declare function parseDockerLabels(labels: string): BridgeLabelConfig | null;
+/**
+ * Check if Docker daemon is available and running
+ */
+declare function isDockerAvailable(): boolean;
+/**
+ * Discover Docker containers with bridge labels
+ *
+ * Searches for running containers that have the claude.bridge.enabled=true label
+ * and extracts connection information from their labels.
+ *
+ * @returns Array of discovered peers with connection URLs
+ */
+declare function discoverDockerPeers(): DiscoveredPeer[];
+/**
+ * Discover Docksal projects with bridges
+ *
+ * Uses the `fin project list` command to find running Docksal projects.
+ *
+ * @returns Array of discovered peers with connection URLs
+ */
+declare function discoverDocksalProjects(): DiscoveredPeer[];
+/**
+ * Discover DDEV projects with bridges
+ *
+ * Uses the `ddev list` command to find running DDEV projects.
+ *
+ * @returns Array of discovered peers with connection URLs
+ */
+declare function discoverDdevProjects(): DiscoveredPeer[];
+/**
+ * Discover Lando projects with bridges
+ *
+ * Uses the `lando list` command to find running Lando apps.
+ *
+ * @returns Array of discovered peers with connection URLs
+ */
+declare function discoverLandoProjects(): DiscoveredPeer[];
+/**
+ * Discover all peers from all sources
+ *
+ * Aggregates peers from Docker containers and all supported development
+ * environments (Docksal, DDEV, Lando).
+ *
+ * @returns Array of all discovered peers
+ */
+declare function discoverAllPeers(): DiscoveredPeer[];
+
+/**
+ * Transport module exports
+ */
+
+type TransportType = 'websocket';
+/**
+ * Options for creating a transport
+ */
+interface CreateTransportOptions {
+    /** Configuration to use when connecting */
+    config?: ConnectionConfig;
+}
+/**
+ * Factory function to create transport instances
+ * @param type The type of transport to create
+ * @param options Optional configuration options
+ * @returns A Transport instance
+ * @throws Error if the transport type is not supported
+ */
+declare function createTransport(type: TransportType, options?: CreateTransportOptions): Transport;
+
+/**
+ * Configuration for the bridge's listening socket
+ */
+interface ListenConfig {
+    port: number;
+    host: string;
+}
+/**
+ * Configuration for connecting to a remote bridge
+ */
+interface ConnectConfig {
+    url?: string;
+    hostGateway?: boolean;
+    port?: number;
+}
+/**
+ * Configuration for context sharing behavior
+ */
+interface ContextSharingConfig {
+    autoSync: boolean;
+    syncInterval: number;
+    maxChunkTokens: number;
+    includePatterns: string[];
+    excludePatterns: string[];
+}
+/**
+ * Configuration for interaction behavior
+ */
+interface InteractionConfig {
+    requireConfirmation: boolean;
+    notifyOnActivity: boolean;
+    taskTimeout: number;
+}
+/**
+ * Full bridge configuration
+ */
+interface BridgeConfig {
+    instanceName?: string;
+    mode?: 'host' | 'client' | 'peer';
+    listen: ListenConfig;
+    connect?: ConnectConfig;
+    contextSharing: ContextSharingConfig;
+    interaction: InteractionConfig;
+}
+/**
+ * Default configuration values
+ */
+declare const DEFAULT_CONFIG: BridgeConfig;
+/**
+ * Deep merges a partial config with the default config
+ *
+ * @param partial - Partial configuration to merge
+ * @returns Complete configuration with defaults for missing values
+ */
+declare function mergeConfig(partial: Partial<BridgeConfig>): BridgeConfig;
+/**
+ * Loads configuration from file(s) and merges with defaults
+ *
+ * Searches for config files in the following order:
+ * 1. Explicit path (if provided)
+ * 2. .claude-bridge.yml in current working directory
+ * 3. ~/.claude-bridge/config.yml
+ *
+ * @param configPath - Optional explicit path to config file
+ * @returns Complete configuration with defaults for missing values
+ *
+ * @example
+ * ```typescript
+ * // Load from default locations
+ * const config = await loadConfig();
+ *
+ * // Load from specific path
+ * const config = await loadConfig('/path/to/config.yml');
+ * ```
+ */
+declare function loadConfig(configPath?: string): Promise<BridgeConfig>;
+/**
+ * Synchronous version of loadConfig for simpler usage patterns
+ *
+ * @param configPath - Optional explicit path to config file
+ * @returns Complete configuration with defaults for missing values
+ */
+declare function loadConfigSync(configPath?: string): BridgeConfig;
+
+/**
+ * Environment detection utilities for Claude Code Bridge
+ *
+ * Detects the runtime environment (Docksal, DDEV, Lando, Docker, or native)
+ * and provides appropriate configuration defaults.
+ */
+
+/**
+ * Supported Docker environment types
+ */
+type DockerEnvironment = 'docksal' | 'ddev' | 'lando' | 'docker-compose' | 'docker' | 'native';
+/**
+ * Information about the detected runtime environment
+ */
+interface EnvironmentInfo {
+    /** The type of environment detected */
+    type: DockerEnvironment;
+    /** Whether running inside a container */
+    isContainer: boolean;
+    /** Project name (if applicable) */
+    projectName?: string;
+    /** Project root path (if applicable) */
+    projectRoot?: string;
+    /** Host gateway address for container-to-host communication */
+    hostGateway?: string;
+    /** Operating system platform */
+    platform: NodeJS.Platform;
+    /** Additional environment-specific metadata */
+    meta?: Record<string, string>;
+}
+/**
+ * Detect the current runtime environment
+ *
+ * Detection order (first match wins):
+ * 1. Docksal (DOCKSAL_STACK env var)
+ * 2. DDEV (IS_DDEV_PROJECT=true env var)
+ * 3. Lando (LANDO=ON env var)
+ * 4. Docker Compose (COMPOSE_PROJECT_NAME env var)
+ * 5. Generic Docker (/.dockerenv file exists)
+ * 6. Native (fallback)
+ *
+ * @returns EnvironmentInfo object with detected environment details
+ */
+declare function detectEnvironment(): EnvironmentInfo;
+/**
+ * Get the host gateway address for container-to-host communication
+ *
+ * - macOS and Windows: Use host.docker.internal (provided by Docker Desktop)
+ * - Linux: May need to use bridge gateway IP or host-gateway flag
+ *
+ * @returns The hostname or IP to reach the Docker host from inside a container
+ */
+declare function getHostGateway(): string;
+/**
+ * Get default bridge configuration based on the detected environment
+ *
+ * Different environments may have different port defaults or connection
+ * preferences.
+ *
+ * @param env - The detected environment info
+ * @returns Partial BridgeConfig with environment-specific defaults
+ */
+declare function getDefaultConfig(env: EnvironmentInfo): Partial<BridgeConfig>;
+
+/**
+ * Docksal-specific helper functions for Claude Code Bridge
+ *
+ * Provides utilities to extract project information from the Docksal environment.
+ * Docksal is a Docker-based development environment primarily used for
+ * Drupal and other PHP projects.
+ *
+ * @see https://docksal.io/
+ */
+/**
+ * Information about a Docksal project
+ */
+interface DocksalProjectInfo {
+    /** Project name from DOCKSAL_PROJECT env var */
+    projectName: string;
+    /** Project root path from PROJECT_ROOT env var */
+    projectRoot: string;
+    /** Docksal stack name from DOCKSAL_STACK env var */
+    stack: string;
+}
+/**
+ * Get Docksal project information from environment variables
+ *
+ * Extracts project details from the standard Docksal environment variables:
+ * - DOCKSAL_PROJECT: The project name
+ * - PROJECT_ROOT: The project root directory
+ * - DOCKSAL_STACK: The Docksal stack being used (e.g., 'default', 'acquia')
+ *
+ * @returns DocksalProjectInfo if in Docksal environment, null otherwise
+ *
+ * @example
+ * ```typescript
+ * const info = getDocksalProjectInfo();
+ * if (info) {
+ *   console.log(`Project: ${info.projectName}`);
+ *   console.log(`Root: ${info.projectRoot}`);
+ *   console.log(`Stack: ${info.stack}`);
+ * }
+ * ```
+ */
+declare function getDocksalProjectInfo(): DocksalProjectInfo | null;
+
+/**
+ * DDEV-specific helper functions for Claude Code Bridge
+ *
+ * Provides utilities to extract project information from the DDEV environment.
+ * DDEV is a Docker-based development environment for PHP and other projects.
+ *
+ * @see https://ddev.readthedocs.io/
+ */
+/**
+ * Information about a DDEV project
+ */
+interface DdevProjectInfo {
+    /** Project name from DDEV_PROJECT env var */
+    projectName: string;
+    /** Project document root from DDEV_DOCROOT env var */
+    projectRoot: string;
+}
+/**
+ * Get DDEV project information from environment variables
+ *
+ * Extracts project details from the standard DDEV environment variables:
+ * - DDEV_PROJECT: The project name
+ * - DDEV_DOCROOT: The document root directory (web root)
+ *
+ * @returns DdevProjectInfo if in DDEV environment, null otherwise
+ *
+ * @example
+ * ```typescript
+ * const info = getDdevProjectInfo();
+ * if (info) {
+ *   console.log(`Project: ${info.projectName}`);
+ *   console.log(`Root: ${info.projectRoot}`);
+ * }
+ * ```
+ */
+declare function getDdevProjectInfo(): DdevProjectInfo | null;
+
+/**
+ * Lando-specific helper functions for Claude Code Bridge
+ *
+ * Provides utilities to extract project information from the Lando environment.
+ * Lando is a Docker-based development environment for PHP, Node.js, and other projects.
+ *
+ * @see https://docs.lando.dev/
+ */
+/**
+ * Information about a Lando project
+ */
+interface LandoProjectInfo {
+    /** Project name (app name) from LANDO_APP_NAME env var */
+    projectName: string;
+}
+/**
+ * Get Lando project information from environment variables
+ *
+ * Extracts project details from the standard Lando environment variables:
+ * - LANDO_APP_NAME: The application/project name
+ *
+ * @returns LandoProjectInfo if in Lando environment, null otherwise
+ *
+ * @example
+ * ```typescript
+ * const info = getLandoProjectInfo();
+ * if (info) {
+ *   console.log(`Project: ${info.projectName}`);
+ * }
+ * ```
+ */
+declare function getLandoProjectInfo(): LandoProjectInfo | null;
+
+/**
+ * Log levels supported by the logger
+ */
+type LogLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal';
+/**
+ * Logger interface (subset of pino.Logger for public API)
+ */
+type Logger = pino.Logger;
+/**
+ * Creates a logger instance with the given component name
+ *
+ * @param name - Component name to include in log output
+ * @param level - Optional log level override (defaults to LOG_LEVEL env var or 'info')
+ * @returns A pino logger instance configured for the component
+ *
+ * @example
+ * ```typescript
+ * const logger = createLogger('bridge');
+ * logger.info('Bridge started');
+ * logger.error({ err }, 'Connection failed');
+ * ```
+ */
+declare function createLogger(name: string, level?: LogLevel): Logger;
+/**
+ * Creates a child logger from an existing logger with additional context
+ *
+ * @param parent - Parent logger instance
+ * @param bindings - Additional context to include in all log messages
+ * @returns A child logger instance
+ */
+declare function createChildLogger(parent: Logger, bindings: Record<string, unknown>): Logger;
+
+/**
+ * Token counting utilities for context chunking.
+ * Uses word-based approximation since exact token counting requires
+ * a tokenizer specific to the model being used.
+ */
+/**
+ * Estimates the number of tokens in a given text.
+ * Uses a simple word-based approximation (roughly 1.3 tokens per word).
+ *
+ * @param text - The text to estimate tokens for
+ * @returns Estimated number of tokens
+ */
+declare function estimateTokens(text: string): number;
+/**
+ * Truncates text to fit within a token limit while preserving complete words.
+ *
+ * @param text - The text to truncate
+ * @param maxTokens - The maximum number of tokens allowed
+ * @returns Truncated text that fits within the token limit
+ */
+declare function truncateToTokenLimit(text: string, maxTokens: number): string;
+
+/**
+ * Custom error classes for Claude Code Bridge
+ *
+ * Provides structured error types with clear, actionable messages
+ * for different error scenarios.
+ */
+/**
+ * Base error class for bridge errors
+ */
+declare class BridgeError extends Error {
+    readonly code: string;
+    readonly context?: Record<string, unknown>;
+    constructor(message: string, code: string, context?: Record<string, unknown>);
+    /**
+     * Get formatted error message with context
+     */
+    toDetailedString(): string;
+}
+/**
+ * Error codes for bridge errors
+ */
+declare const ErrorCodes: {
+    readonly CONFIG_INVALID: "CONFIG_INVALID";
+    readonly CONFIG_MISSING: "CONFIG_MISSING";
+    readonly CONFIG_PARSE_ERROR: "CONFIG_PARSE_ERROR";
+    readonly CONNECTION_FAILED: "CONNECTION_FAILED";
+    readonly CONNECTION_REFUSED: "CONNECTION_REFUSED";
+    readonly CONNECTION_TIMEOUT: "CONNECTION_TIMEOUT";
+    readonly CONNECTION_CLOSED: "CONNECTION_CLOSED";
+    readonly NOT_CONNECTED: "NOT_CONNECTED";
+    readonly ALREADY_CONNECTED: "ALREADY_CONNECTED";
+    readonly PEER_NOT_FOUND: "PEER_NOT_FOUND";
+    readonly NO_PEERS_CONNECTED: "NO_PEERS_CONNECTED";
+    readonly PEER_DISCONNECTED: "PEER_DISCONNECTED";
+    readonly TASK_TIMEOUT: "TASK_TIMEOUT";
+    readonly TASK_FAILED: "TASK_FAILED";
+    readonly NO_TASK_HANDLER: "NO_TASK_HANDLER";
+    readonly CONTEXT_TIMEOUT: "CONTEXT_TIMEOUT";
+    readonly CONTEXT_SYNC_FAILED: "CONTEXT_SYNC_FAILED";
+    readonly SNAPSHOT_NOT_FOUND: "SNAPSHOT_NOT_FOUND";
+    readonly INVALID_MESSAGE: "INVALID_MESSAGE";
+    readonly SERIALIZATION_ERROR: "SERIALIZATION_ERROR";
+    readonly BRIDGE_ALREADY_STARTED: "BRIDGE_ALREADY_STARTED";
+    readonly BRIDGE_NOT_STARTED: "BRIDGE_NOT_STARTED";
+    readonly BRIDGE_SHUTDOWN: "BRIDGE_SHUTDOWN";
+    readonly UNKNOWN: "UNKNOWN";
+};
+type ErrorCode = typeof ErrorCodes[keyof typeof ErrorCodes];
+/**
+ * Configuration error
+ */
+declare class ConfigurationError extends BridgeError {
+    readonly setting?: string;
+    constructor(message: string, code: ErrorCode, setting?: string, context?: Record<string, unknown>);
+    static missing(setting: string): ConfigurationError;
+    static invalid(setting: string, reason: string, value?: unknown): ConfigurationError;
+    static parseError(filePath: string, error: Error): ConfigurationError;
+}
+/**
+ * Connection error with network details
+ */
+declare class ConnectionError extends BridgeError {
+    readonly url?: string;
+    readonly host?: string;
+    readonly port?: number;
+    constructor(message: string, code?: ErrorCode, options?: {
+        url?: string;
+        host?: string;
+        port?: number;
+        cause?: Error;
+    });
+    static refused(url: string): ConnectionError;
+    static timeout(url: string, timeoutMs: number): ConnectionError;
+    static closed(url: string, reason?: string): ConnectionError;
+    static notConnected(): ConnectionError;
+    static alreadyConnected(): ConnectionError;
+}
+/**
+ * Peer-related error
+ */
+declare class PeerError extends BridgeError {
+    readonly peerId?: string;
+    constructor(message: string, code: ErrorCode, peerId?: string);
+    static notFound(peerId: string): PeerError;
+    static noPeersConnected(): PeerError;
+    static disconnected(peerId: string): PeerError;
+}
+/**
+ * Task-related error
+ */
+declare class TaskError extends BridgeError {
+    readonly taskId?: string;
+    constructor(message: string, code: ErrorCode, taskId?: string, context?: Record<string, unknown>);
+    static timeout(taskId: string, timeoutMs: number): TaskError;
+    static failed(taskId: string, reason: string): TaskError;
+    static noHandler(): TaskError;
+}
+/**
+ * Context synchronization error
+ */
+declare class ContextError extends BridgeError {
+    constructor(message: string, code: ErrorCode, context?: Record<string, unknown>);
+    static timeout(timeoutMs: number): ContextError;
+    static syncFailed(reason: string): ContextError;
+    static snapshotNotFound(snapshotId: string): ContextError;
+}
+/**
+ * Protocol/message error
+ */
+declare class ProtocolError extends BridgeError {
+    constructor(message: string, code?: ErrorCode, context?: Record<string, unknown>);
+    static invalidMessage(reason: string, data?: unknown): ProtocolError;
+    static serializationError(error: Error): ProtocolError;
+}
+/**
+ * Bridge lifecycle error
+ */
+declare class BridgeLifecycleError extends BridgeError {
+    constructor(message: string, code: ErrorCode);
+    static alreadyStarted(): BridgeLifecycleError;
+    static notStarted(): BridgeLifecycleError;
+    static shuttingDown(): BridgeLifecycleError;
+}
+/**
+ * Format an error for logging with context
+ */
+declare function formatErrorForLogging(error: unknown): {
+    message: string;
+    code?: string;
+    context?: Record<string, unknown>;
+    stack?: string;
+};
+/**
+ * Wrap an error with additional context
+ */
+declare function wrapError(error: unknown, context: string): BridgeError;
+/**
+ * Check if an error is of a specific type
+ */
+declare function isErrorCode(error: unknown, code: ErrorCode): boolean;
+
+/**
+ * Claude Code Bridge
+ *
+ * A bidirectional communication system that enables two separate Claude Code instances
+ * to collaborate across different environments. The primary use case is connecting a
+ * native macOS Claude Code instance with a Claude Code instance running inside a
+ * Docker-based development environment (Docksal, DDEV, Lando, or plain Docker).
+ *
+ * @packageDocumentation
+ */
+declare const VERSION = "0.1.0";
+
+export { type Artifact, ArtifactSchema, Bridge, type BridgeConfig$1 as BridgeConfig, type BridgeConnectConfig, BridgeError, type BridgeLabelConfig, BridgeLifecycleError, type BridgeListenConfig, type BridgeMessage, BridgeMessageSchema, type BridgeMode, type BuildDirectoryTreeOptions, ConfigurationError, type ConnectConfig, type ConnectionConfig, ConnectionError, ConnectionState, type Context, type ContextDelta, ContextError, ContextManager, type ContextManagerOptions, type ContextReceivedHandler, type ContextRequestedHandler, ContextSchema, type ContextSharingConfig$1 as ContextSharingConfig, DEFAULT_CONFIG, type DdevProjectInfo, type DirectoryTree, DirectoryTreeSchema, type DiscoveredPeer, type DockerEnvironment, type DocksalProjectInfo, type EnvironmentInfo, type ErrorCode, ErrorCodes, type FileChange, type FileChunk, FileChunkSchema, type InteractionConfig, type LandoProjectInfo, type ListenConfig, type LogLevel, type Logger, type MessageReceivedHandler, MessageType, type NotificationData, type PeerConnectedHandler, type PeerDisconnectedHandler, PeerError, type PeerInfo, type ProjectSnapshot, ProtocolError, TaskError, type TaskReceivedHandler, type TaskRequest, TaskRequestSchema, type TaskResult, TaskResultSchema, type Transport, type BridgeConfig as UtilsBridgeConfig, type ContextSharingConfig as UtilsContextSharingConfig, VERSION, WebSocketTransport, buildDirectoryTree, createChildLogger, createContextRequestMessage, createContextSyncMessage, createLogger, createMessage, createNotificationMessage, createTaskDelegateMessage, createTaskResponseMessage, createTransport, deserializeMessage, detectEnvironment, discoverAllPeers, discoverDdevProjects, discoverDockerPeers, discoverDocksalProjects, discoverLandoProjects, estimateTokens, formatErrorForLogging, getDdevProjectInfo, getDefaultConfig, getDocksalProjectInfo, getHostGateway, getLandoProjectInfo, isDockerAvailable, isErrorCode, loadConfig, loadConfigSync, mergeConfig, parseDockerLabels, safeDeserializeMessage, safeValidateMessage, serializeMessage, truncateToTokenLimit, validateMessage, wrapError };