@willjackson/claude-code-bridge 0.1.0

package/dist/index.js

@@ -0,0 +1,976 @@
+import {
+  ArtifactSchema,
+  Bridge,
+  BridgeMessageSchema,
+  ConnectionState,
+  ContextSchema,
+  DEFAULT_CONFIG,
+  DirectoryTreeSchema,
+  FileChunkSchema,
+  MessageType,
+  TaskRequestSchema,
+  TaskResultSchema,
+  WebSocketTransport,
+  createChildLogger,
+  createContextRequestMessage,
+  createContextSyncMessage,
+  createLogger,
+  createMessage,
+  createNotificationMessage,
+  createTaskDelegateMessage,
+  createTaskResponseMessage,
+  deserializeMessage,
+  detectEnvironment,
+  discoverAllPeers,
+  discoverDdevProjects,
+  discoverDockerPeers,
+  discoverDocksalProjects,
+  discoverLandoProjects,
+  getDefaultConfig,
+  getHostGateway,
+  isDockerAvailable,
+  loadConfig,
+  loadConfigSync,
+  mergeConfig,
+  parseDockerLabels,
+  safeDeserializeMessage,
+  safeValidateMessage,
+  serializeMessage,
+  validateMessage
+} from "./chunk-BRH476VK.js";
+
+// src/bridge/context.ts
+import { readdirSync, readFileSync, statSync, realpathSync } from "fs";
+import { join, basename, relative, extname } from "path";
+import { v4 as uuidv4 } from "uuid";
+import { minimatch } from "minimatch";
+
+// src/utils/tokens.ts
+var TOKENS_PER_WORD = 1.3;
+function estimateTokens(text) {
+  if (!text || text.length === 0) {
+    return 0;
+  }
+  const words = text.split(/\s+/).filter((word) => word.length > 0);
+  return Math.ceil(words.length * TOKENS_PER_WORD);
+}
+function truncateToTokenLimit(text, maxTokens) {
+  if (!text || text.length === 0) {
+    return "";
+  }
+  if (maxTokens <= 0) {
+    return "";
+  }
+  if (estimateTokens(text) <= maxTokens) {
+    return text;
+  }
+  const words = text.split(/\s+/).filter((word) => word.length > 0);
+  const maxWords = Math.floor(maxTokens / TOKENS_PER_WORD);
+  if (maxWords <= 0) {
+    return "";
+  }
+  const truncatedWords = words.slice(0, maxWords);
+  return truncatedWords.join(" ");
+}
+
+// src/bridge/context.ts
+function buildDirectoryTree(rootPath, options = {}) {
+  const includePatterns = options.includePatterns ?? [];
+  const excludePatterns = options.excludePatterns ?? [];
+  const maxDepth = options.maxDepth ?? 10;
+  const visitedPaths = /* @__PURE__ */ new Set();
+  function isIncluded(relativePath) {
+    if (includePatterns.length === 0) {
+      return true;
+    }
+    return includePatterns.some((pattern) => minimatch(relativePath, pattern));
+  }
+  function isExcluded(relativePath) {
+    return excludePatterns.some((pattern) => minimatch(relativePath, pattern));
+  }
+  function shouldIncludeDirectory(relativePath) {
+    if (includePatterns.length === 0) {
+      return true;
+    }
+    return includePatterns.some((pattern) => {
+      if (pattern.startsWith("**")) {
+        return true;
+      }
+      const patternParts = pattern.split("/");
+      const pathParts = relativePath.split("/");
+      for (let i = 0; i < pathParts.length && i < patternParts.length; i++) {
+        if (patternParts[i] === "**") {
+          return true;
+        }
+        if (!minimatch(pathParts[i], patternParts[i])) {
+          return false;
+        }
+      }
+      return true;
+    });
+  }
+  function buildTree(dirPath, depth) {
+    const name = basename(dirPath);
+    const tree = {
+      name,
+      type: "directory",
+      children: []
+    };
+    if (depth >= maxDepth) {
+      return tree;
+    }
+    try {
+      const realPath = realpathSync(dirPath);
+      if (visitedPaths.has(realPath)) {
+        return tree;
+      }
+      visitedPaths.add(realPath);
+    } catch {
+      return tree;
+    }
+    try {
+      const entries = readdirSync(dirPath, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = join(dirPath, entry.name);
+        const relativePath = relative(rootPath, fullPath);
+        if (isExcluded(relativePath)) {
+          continue;
+        }
+        if (entry.isSymbolicLink()) {
+          try {
+            const stats = statSync(fullPath);
+            if (stats.isDirectory()) {
+              if (shouldIncludeDirectory(relativePath)) {
+                tree.children.push(buildTree(fullPath, depth + 1));
+              }
+            } else if (stats.isFile()) {
+              if (isIncluded(relativePath)) {
+                tree.children.push({
+                  name: entry.name,
+                  type: "file"
+                });
+              }
+            }
+          } catch {
+            continue;
+          }
+        } else if (entry.isDirectory()) {
+          if (shouldIncludeDirectory(relativePath)) {
+            tree.children.push(buildTree(fullPath, depth + 1));
+          }
+        } else if (entry.isFile()) {
+          if (isIncluded(relativePath)) {
+            tree.children.push({
+              name: entry.name,
+              type: "file"
+            });
+          }
+        }
+      }
+      tree.children.sort((a, b) => {
+        if (a.type !== b.type) {
+          return a.type === "directory" ? -1 : 1;
+        }
+        return a.name.localeCompare(b.name);
+      });
+    } catch {
+    }
+    return tree;
+  }
+  return buildTree(rootPath, 0);
+}
+var ContextManager = class {
+  rootPath;
+  includePatterns;
+  excludePatterns;
+  maxDepth;
+  /** Stored snapshots for delta comparison */
+  snapshotStates = /* @__PURE__ */ new Map();
+  /**
+   * Create a new ContextManager
+   * @param options Configuration options
+   */
+  constructor(options) {
+    this.rootPath = options.rootPath;
+    this.includePatterns = options.includePatterns;
+    this.excludePatterns = options.excludePatterns;
+    this.maxDepth = options.maxDepth ?? 10;
+  }
+  /**
+   * Generate a complete snapshot of the current project state
+   * @returns ProjectSnapshot with tree structure, summary, and key files
+   */
+  async generateSnapshot() {
+    const tree = buildDirectoryTree(this.rootPath, {
+      includePatterns: this.includePatterns,
+      excludePatterns: this.excludePatterns,
+      maxDepth: this.maxDepth
+    });
+    const files = this.collectMatchingFiles(this.rootPath);
+    const keyFiles = this.identifyKeyFiles(files);
+    const summary = this.generateSummary(files);
+    const snapshotId = uuidv4();
+    const fileStates = /* @__PURE__ */ new Map();
+    for (const file of files) {
+      try {
+        const stats = statSync(file);
+        const relativePath = relative(this.rootPath, file);
+        fileStates.set(relativePath, {
+          path: relativePath,
+          mtime: stats.mtimeMs,
+          size: stats.size
+        });
+      } catch {
+      }
+    }
+    this.snapshotStates.set(snapshotId, {
+      id: snapshotId,
+      files: fileStates
+    });
+    return {
+      id: snapshotId,
+      timestamp: Date.now(),
+      tree,
+      summary,
+      keyFiles
+    };
+  }
+  /**
+   * 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
+   */
+  async getDelta(lastSyncId) {
+    const lastState = this.snapshotStates.get(lastSyncId);
+    if (!lastState) {
+      throw new Error(`Snapshot ${lastSyncId} not found`);
+    }
+    const currentSnapshot = await this.generateSnapshot();
+    const currentState = this.snapshotStates.get(currentSnapshot.id);
+    const changes = [];
+    for (const [path, currentFile] of currentState.files) {
+      const lastFile = lastState.files.get(path);
+      if (!lastFile) {
+        changes.push({
+          path,
+          action: "added"
+        });
+      } else if (currentFile.mtime !== lastFile.mtime || currentFile.size !== lastFile.size) {
+        const diff = await this.generateFileDiff(path);
+        changes.push({
+          path,
+          action: "modified",
+          diff
+        });
+      }
+    }
+    for (const path of lastState.files.keys()) {
+      if (!currentState.files.has(path)) {
+        changes.push({
+          path,
+          action: "deleted"
+        });
+      }
+    }
+    return {
+      fromSyncId: lastSyncId,
+      toSyncId: currentSnapshot.id,
+      changes
+    };
+  }
+  /**
+   * Generate a simple diff for a modified file
+   * Returns the new content (simplified diff for now)
+   */
+  async generateFileDiff(relativePath) {
+    try {
+      const fullPath = join(this.rootPath, relativePath);
+      const content = readFileSync(fullPath, "utf-8");
+      return content.length > 1e3 ? content.slice(0, 1e3) + "..." : content;
+    } catch {
+      return "";
+    }
+  }
+  /**
+   * 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
+   */
+  async getRelevantContext(task, maxTokens) {
+    const files = this.collectMatchingFiles(this.rootPath);
+    const rankedFiles = this.rankFilesForTask(files, task);
+    const chunks = [];
+    let currentTokens = 0;
+    for (const filePath of rankedFiles) {
+      try {
+        const content = readFileSync(filePath, "utf-8");
+        const fileTokens = estimateTokens(content);
+        if (currentTokens + fileTokens <= maxTokens) {
+          chunks.push({
+            path: relative(this.rootPath, filePath),
+            content,
+            language: this.getLanguage(filePath)
+          });
+          currentTokens += fileTokens;
+        } else if (chunks.length === 0) {
+          const remainingTokens = maxTokens - currentTokens;
+          const truncatedContent = this.truncateContent(content, remainingTokens);
+          if (truncatedContent) {
+            chunks.push({
+              path: relative(this.rootPath, filePath),
+              content: truncatedContent,
+              language: this.getLanguage(filePath)
+            });
+            break;
+          }
+        }
+        if (currentTokens >= maxTokens) {
+          break;
+        }
+      } catch {
+        continue;
+      }
+    }
+    return chunks;
+  }
+  /**
+   * Collect all files matching include patterns and not matching exclude patterns
+   */
+  collectMatchingFiles(dirPath) {
+    const files = [];
+    this.collectFilesRecursive(dirPath, files, 0);
+    return files;
+  }
+  collectFilesRecursive(dirPath, files, depth) {
+    if (depth >= this.maxDepth) {
+      return;
+    }
+    try {
+      const entries = readdirSync(dirPath, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = join(dirPath, entry.name);
+        const relativePath = relative(this.rootPath, fullPath);
+        if (this.isExcluded(relativePath)) {
+          continue;
+        }
+        if (entry.isDirectory()) {
+          this.collectFilesRecursive(fullPath, files, depth + 1);
+        } else if (entry.isFile() && this.isIncluded(relativePath)) {
+          files.push(fullPath);
+        }
+      }
+    } catch {
+    }
+  }
+  /**
+   * Check if a path matches any include pattern
+   */
+  isIncluded(relativePath) {
+    if (this.includePatterns.length === 0) {
+      return true;
+    }
+    return this.includePatterns.some((pattern) => minimatch(relativePath, pattern));
+  }
+  /**
+   * Check if a path matches any exclude pattern
+   */
+  isExcluded(relativePath) {
+    return this.excludePatterns.some((pattern) => minimatch(relativePath, pattern));
+  }
+  /**
+   * Check if a directory should be traversed based on include patterns
+   */
+  shouldIncludeDirectory(relativePath) {
+    if (this.includePatterns.length === 0) {
+      return true;
+    }
+    return this.includePatterns.some((pattern) => {
+      const patternParts = pattern.split("/");
+      const pathParts = relativePath.split("/");
+      if (pattern.startsWith("**")) {
+        return true;
+      }
+      for (let i = 0; i < pathParts.length && i < patternParts.length; i++) {
+        if (patternParts[i] === "**") {
+          return true;
+        }
+        if (!minimatch(pathParts[i], patternParts[i])) {
+          return false;
+        }
+      }
+      return true;
+    });
+  }
+  /**
+   * Identify key files in the project (config files, entry points, etc.)
+   */
+  identifyKeyFiles(files) {
+    const keyFileNames = [
+      "package.json",
+      "tsconfig.json",
+      "index.ts",
+      "index.js",
+      "main.ts",
+      "main.js",
+      "app.ts",
+      "app.js",
+      "README.md",
+      "CLAUDE.md"
+    ];
+    const keyFiles = [];
+    for (const file of files) {
+      const fileName = basename(file);
+      if (keyFileNames.includes(fileName)) {
+        keyFiles.push(relative(this.rootPath, file));
+      }
+    }
+    return keyFiles;
+  }
+  /**
+   * Generate a summary string describing the project
+   */
+  generateSummary(files) {
+    const extensions = /* @__PURE__ */ new Map();
+    for (const file of files) {
+      const ext = extname(file) || "(no extension)";
+      extensions.set(ext, (extensions.get(ext) || 0) + 1);
+    }
+    const extSummary = Array.from(extensions.entries()).sort((a, b) => b[1] - a[1]).slice(0, 5).map(([ext, count]) => `${ext}: ${count}`).join(", ");
+    return `Project contains ${files.length} files. Top extensions: ${extSummary}`;
+  }
+  /**
+   * Rank files by relevance to a task description
+   * Files with matching keywords are ranked higher
+   */
+  rankFilesForTask(files, task) {
+    const taskLower = task.toLowerCase();
+    const keywords = taskLower.split(/\s+/).filter((w) => w.length > 2);
+    const scored = files.map((file) => {
+      const relativePath = relative(this.rootPath, file).toLowerCase();
+      let score = 0;
+      for (const keyword of keywords) {
+        if (relativePath.includes(keyword)) {
+          score += 10;
+        }
+      }
+      const fileName = basename(file);
+      if (["index.ts", "index.js", "main.ts", "main.js"].includes(fileName)) {
+        score += 5;
+      }
+      if (fileName === "package.json") {
+        score += 3;
+      }
+      return { file, score };
+    });
+    scored.sort((a, b) => {
+      if (a.score !== b.score) {
+        return b.score - a.score;
+      }
+      return a.file.localeCompare(b.file);
+    });
+    return scored.map((s) => s.file);
+  }
+  /**
+   * Get programming language from file extension
+   */
+  getLanguage(filePath) {
+    const ext = extname(filePath).toLowerCase();
+    const languageMap = {
+      ".ts": "typescript",
+      ".tsx": "typescript",
+      ".js": "javascript",
+      ".jsx": "javascript",
+      ".py": "python",
+      ".rb": "ruby",
+      ".go": "go",
+      ".rs": "rust",
+      ".java": "java",
+      ".c": "c",
+      ".cpp": "cpp",
+      ".h": "c",
+      ".hpp": "cpp",
+      ".cs": "csharp",
+      ".php": "php",
+      ".swift": "swift",
+      ".kt": "kotlin",
+      ".scala": "scala",
+      ".md": "markdown",
+      ".json": "json",
+      ".yaml": "yaml",
+      ".yml": "yaml",
+      ".xml": "xml",
+      ".html": "html",
+      ".css": "css",
+      ".scss": "scss",
+      ".less": "less",
+      ".sql": "sql",
+      ".sh": "bash",
+      ".bash": "bash",
+      ".zsh": "zsh"
+    };
+    return languageMap[ext] || "text";
+  }
+  /**
+   * Truncate file content to fit within a token limit
+   */
+  truncateContent(content, maxTokens) {
+    const lines = content.split("\n");
+    const result = [];
+    let currentTokens = 0;
+    for (const line of lines) {
+      const lineTokens = estimateTokens(line);
+      if (currentTokens + lineTokens <= maxTokens) {
+        result.push(line);
+        currentTokens += lineTokens;
+      } else {
+        break;
+      }
+    }
+    return result.join("\n");
+  }
+};
+
+// src/transport/index.ts
+function createTransport(type, options) {
+  switch (type) {
+    case "websocket":
+      return new WebSocketTransport();
+    default:
+      throw new Error(`Unknown transport type: ${type}`);
+  }
+}
+
+// src/environment/docksal.ts
+function isDocksalEnvironment() {
+  return !!process.env.DOCKSAL_STACK;
+}
+function getDocksalProjectInfo() {
+  if (!isDocksalEnvironment()) {
+    return null;
+  }
+  const projectName = process.env.DOCKSAL_PROJECT;
+  const projectRoot = process.env.PROJECT_ROOT;
+  const stack = process.env.DOCKSAL_STACK;
+  if (!projectName || !projectRoot || !stack) {
+    return null;
+  }
+  return {
+    projectName,
+    projectRoot,
+    stack
+  };
+}
+
+// src/environment/ddev.ts
+function isDdevEnvironment() {
+  return process.env.IS_DDEV_PROJECT === "true";
+}
+function getDdevProjectInfo() {
+  if (!isDdevEnvironment()) {
+    return null;
+  }
+  const projectName = process.env.DDEV_PROJECT;
+  const projectRoot = process.env.DDEV_DOCROOT;
+  if (!projectName || !projectRoot) {
+    return null;
+  }
+  return {
+    projectName,
+    projectRoot
+  };
+}
+
+// src/environment/lando.ts
+function isLandoEnvironment() {
+  return process.env.LANDO === "ON";
+}
+function getLandoProjectInfo() {
+  if (!isLandoEnvironment()) {
+    return null;
+  }
+  const projectName = process.env.LANDO_APP_NAME;
+  if (!projectName) {
+    return null;
+  }
+  return {
+    projectName
+  };
+}
+
+// src/utils/errors.ts
+var BridgeError = class extends Error {
+  code;
+  context;
+  constructor(message, code, context) {
+    super(message);
+    this.name = "BridgeError";
+    this.code = code;
+    this.context = context;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+  /**
+   * Get formatted error message with context
+   */
+  toDetailedString() {
+    const parts = [`${this.name}[${this.code}]: ${this.message}`];
+    if (this.context) {
+      parts.push(`Context: ${JSON.stringify(this.context)}`);
+    }
+    return parts.join("\n");
+  }
+};
+var ErrorCodes = {
+  // Configuration errors
+  CONFIG_INVALID: "CONFIG_INVALID",
+  CONFIG_MISSING: "CONFIG_MISSING",
+  CONFIG_PARSE_ERROR: "CONFIG_PARSE_ERROR",
+  // Connection errors
+  CONNECTION_FAILED: "CONNECTION_FAILED",
+  CONNECTION_REFUSED: "CONNECTION_REFUSED",
+  CONNECTION_TIMEOUT: "CONNECTION_TIMEOUT",
+  CONNECTION_CLOSED: "CONNECTION_CLOSED",
+  NOT_CONNECTED: "NOT_CONNECTED",
+  ALREADY_CONNECTED: "ALREADY_CONNECTED",
+  // Peer errors
+  PEER_NOT_FOUND: "PEER_NOT_FOUND",
+  NO_PEERS_CONNECTED: "NO_PEERS_CONNECTED",
+  PEER_DISCONNECTED: "PEER_DISCONNECTED",
+  // Task errors
+  TASK_TIMEOUT: "TASK_TIMEOUT",
+  TASK_FAILED: "TASK_FAILED",
+  NO_TASK_HANDLER: "NO_TASK_HANDLER",
+  // Context errors
+  CONTEXT_TIMEOUT: "CONTEXT_TIMEOUT",
+  CONTEXT_SYNC_FAILED: "CONTEXT_SYNC_FAILED",
+  SNAPSHOT_NOT_FOUND: "SNAPSHOT_NOT_FOUND",
+  // Protocol errors
+  INVALID_MESSAGE: "INVALID_MESSAGE",
+  SERIALIZATION_ERROR: "SERIALIZATION_ERROR",
+  // Bridge lifecycle errors
+  BRIDGE_ALREADY_STARTED: "BRIDGE_ALREADY_STARTED",
+  BRIDGE_NOT_STARTED: "BRIDGE_NOT_STARTED",
+  BRIDGE_SHUTDOWN: "BRIDGE_SHUTDOWN",
+  // General errors
+  UNKNOWN: "UNKNOWN"
+};
+var ConfigurationError = class _ConfigurationError extends BridgeError {
+  setting;
+  constructor(message, code, setting, context) {
+    super(message, code, {
+      ...context,
+      setting
+    });
+    this.name = "ConfigurationError";
+    this.setting = setting;
+  }
+  static missing(setting) {
+    return new _ConfigurationError(
+      `Missing required configuration: '${setting}'`,
+      ErrorCodes.CONFIG_MISSING,
+      setting
+    );
+  }
+  static invalid(setting, reason, value) {
+    return new _ConfigurationError(
+      `Invalid configuration for '${setting}': ${reason}`,
+      ErrorCodes.CONFIG_INVALID,
+      setting,
+      { value }
+    );
+  }
+  static parseError(filePath, error) {
+    return new _ConfigurationError(
+      `Failed to parse configuration file '${filePath}': ${error.message}`,
+      ErrorCodes.CONFIG_PARSE_ERROR,
+      void 0,
+      { filePath, originalError: error.message }
+    );
+  }
+};
+var ConnectionError = class _ConnectionError extends BridgeError {
+  url;
+  host;
+  port;
+  constructor(message, code = ErrorCodes.CONNECTION_FAILED, options) {
+    super(message, code, {
+      url: options?.url,
+      host: options?.host,
+      port: options?.port,
+      cause: options?.cause?.message
+    });
+    this.name = "ConnectionError";
+    this.url = options?.url;
+    this.host = options?.host;
+    this.port = options?.port;
+    if (options?.cause) {
+      this.cause = options.cause;
+    }
+  }
+  static refused(url) {
+    return new _ConnectionError(
+      `Connection refused to ${url}. Ensure the bridge is running and accepting connections.`,
+      ErrorCodes.CONNECTION_REFUSED,
+      { url }
+    );
+  }
+  static timeout(url, timeoutMs) {
+    return new _ConnectionError(
+      `Connection to ${url} timed out after ${timeoutMs}ms. Check network connectivity and firewall settings.`,
+      ErrorCodes.CONNECTION_TIMEOUT,
+      { url }
+    );
+  }
+  static closed(url, reason) {
+    const message = reason ? `Connection to ${url} closed: ${reason}` : `Connection to ${url} closed unexpectedly`;
+    return new _ConnectionError(message, ErrorCodes.CONNECTION_CLOSED, { url });
+  }
+  static notConnected() {
+    return new _ConnectionError(
+      "Not connected to any peer. Call connect() first.",
+      ErrorCodes.NOT_CONNECTED
+    );
+  }
+  static alreadyConnected() {
+    return new _ConnectionError(
+      "Already connected. Disconnect first to establish a new connection.",
+      ErrorCodes.ALREADY_CONNECTED
+    );
+  }
+};
+var PeerError = class _PeerError extends BridgeError {
+  peerId;
+  constructor(message, code, peerId) {
+    super(message, code, { peerId });
+    this.name = "PeerError";
+    this.peerId = peerId;
+  }
+  static notFound(peerId) {
+    return new _PeerError(
+      `Peer '${peerId}' not found. The peer may have disconnected.`,
+      ErrorCodes.PEER_NOT_FOUND,
+      peerId
+    );
+  }
+  static noPeersConnected() {
+    return new _PeerError(
+      "No peers are connected. Wait for a peer to connect or call connectToPeer() first.",
+      ErrorCodes.NO_PEERS_CONNECTED
+    );
+  }
+  static disconnected(peerId) {
+    return new _PeerError(
+      `Peer '${peerId}' has disconnected.`,
+      ErrorCodes.PEER_DISCONNECTED,
+      peerId
+    );
+  }
+};
+var TaskError = class _TaskError extends BridgeError {
+  taskId;
+  constructor(message, code, taskId, context) {
+    super(message, code, { ...context, taskId });
+    this.name = "TaskError";
+    this.taskId = taskId;
+  }
+  static timeout(taskId, timeoutMs) {
+    return new _TaskError(
+      `Task '${taskId}' timed out after ${timeoutMs}ms. Consider increasing the task timeout or breaking the task into smaller pieces.`,
+      ErrorCodes.TASK_TIMEOUT,
+      taskId,
+      { timeoutMs }
+    );
+  }
+  static failed(taskId, reason) {
+    return new _TaskError(
+      `Task '${taskId}' failed: ${reason}`,
+      ErrorCodes.TASK_FAILED,
+      taskId
+    );
+  }
+  static noHandler() {
+    return new _TaskError(
+      "No task handler registered. Register a handler with onTaskReceived() before delegating tasks.",
+      ErrorCodes.NO_TASK_HANDLER
+    );
+  }
+};
+var ContextError = class _ContextError extends BridgeError {
+  constructor(message, code, context) {
+    super(message, code, context);
+    this.name = "ContextError";
+  }
+  static timeout(timeoutMs) {
+    return new _ContextError(
+      `Context request timed out after ${timeoutMs}ms. The peer may be processing a large amount of data.`,
+      ErrorCodes.CONTEXT_TIMEOUT,
+      { timeoutMs }
+    );
+  }
+  static syncFailed(reason) {
+    return new _ContextError(
+      `Context synchronization failed: ${reason}`,
+      ErrorCodes.CONTEXT_SYNC_FAILED
+    );
+  }
+  static snapshotNotFound(snapshotId) {
+    return new _ContextError(
+      `Snapshot '${snapshotId}' not found. It may have expired or never existed.`,
+      ErrorCodes.SNAPSHOT_NOT_FOUND,
+      { snapshotId }
+    );
+  }
+};
+var ProtocolError = class _ProtocolError extends BridgeError {
+  constructor(message, code = ErrorCodes.INVALID_MESSAGE, context) {
+    super(message, code, context);
+    this.name = "ProtocolError";
+  }
+  static invalidMessage(reason, data) {
+    return new _ProtocolError(
+      `Invalid message: ${reason}`,
+      ErrorCodes.INVALID_MESSAGE,
+      { data: data ? String(data).substring(0, 200) : void 0 }
+    );
+  }
+  static serializationError(error) {
+    return new _ProtocolError(
+      `Message serialization failed: ${error.message}`,
+      ErrorCodes.SERIALIZATION_ERROR,
+      { originalError: error.message }
+    );
+  }
+};
+var BridgeLifecycleError = class _BridgeLifecycleError extends BridgeError {
+  constructor(message, code) {
+    super(message, code);
+    this.name = "BridgeLifecycleError";
+  }
+  static alreadyStarted() {
+    return new _BridgeLifecycleError(
+      "Bridge is already started. Call stop() before starting again.",
+      ErrorCodes.BRIDGE_ALREADY_STARTED
+    );
+  }
+  static notStarted() {
+    return new _BridgeLifecycleError(
+      "Bridge is not started. Call start() first.",
+      ErrorCodes.BRIDGE_NOT_STARTED
+    );
+  }
+  static shuttingDown() {
+    return new _BridgeLifecycleError(
+      "Bridge is shutting down.",
+      ErrorCodes.BRIDGE_SHUTDOWN
+    );
+  }
+};
+function formatErrorForLogging(error) {
+  if (error instanceof BridgeError) {
+    return {
+      message: error.message,
+      code: error.code,
+      context: error.context,
+      stack: error.stack
+    };
+  }
+  if (error instanceof Error) {
+    return {
+      message: error.message,
+      stack: error.stack
+    };
+  }
+  return {
+    message: String(error)
+  };
+}
+function wrapError(error, context) {
+  if (error instanceof BridgeError) {
+    return new BridgeError(
+      `${context}: ${error.message}`,
+      error.code,
+      error.context
+    );
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  return new BridgeError(
+    `${context}: ${message}`,
+    ErrorCodes.UNKNOWN,
+    { originalError: message }
+  );
+}
+function isErrorCode(error, code) {
+  return error instanceof BridgeError && error.code === code;
+}
+
+// src/index.ts
+var VERSION = "0.1.0";
+export {
+  ArtifactSchema,
+  Bridge,
+  BridgeError,
+  BridgeLifecycleError,
+  BridgeMessageSchema,
+  ConfigurationError,
+  ConnectionError,
+  ConnectionState,
+  ContextError,
+  ContextManager,
+  ContextSchema,
+  DEFAULT_CONFIG,
+  DirectoryTreeSchema,
+  ErrorCodes,
+  FileChunkSchema,
+  MessageType,
+  PeerError,
+  ProtocolError,
+  TaskError,
+  TaskRequestSchema,
+  TaskResultSchema,
+  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
+};
+//# sourceMappingURL=index.js.map