@willjackson/claude-code-bridge 0.2.4 → 0.4.1

package/dist/cli.js

@@ -1,18 +1,12 @@
 #!/usr/bin/env node
 import {
   Bridge,
+  BridgeMcpServer,
   ConnectionState,
   WebSocketTransport,
   createLogger,
-  detectEnvironment,
-  discoverDdevProjects,
-  discoverDockerPeers,
-  discoverDocksalProjects,
-  discoverLandoProjects,
-  getDefaultConfig,
-  getHostGateway,
   loadConfigSync
-} from "./chunk-5HWFDZKH.js";
+} from "./chunk-MHUQYPTB.js";
 
 // src/cli/index.ts
 import { Command as Command7 } from "commander";
@@ -22,6 +16,7 @@ import { Command } from "commander";
 import * as fs from "fs";
 import * as path from "path";
 import * as os from "os";
+import { spawn } from "child_process";
 import { minimatch } from "minimatch";
 
 // src/cli/utils.ts
@@ -303,6 +298,59 @@ function registerHandlers(bridge, config) {
         };
       }
     }
+    if (taskData?.action === "list_directory") {
+      const dirPath = taskData.path;
+      if (!dirPath) {
+        return {
+          success: false,
+          data: { error: "list_directory requires path" }
+        };
+      }
+      const fullPath = path.isAbsolute(dirPath) ? dirPath : path.join(cwd, dirPath);
+      const resolvedPath = path.resolve(fullPath);
+      const resolvedCwd = path.resolve(cwd);
+      if (!resolvedPath.startsWith(resolvedCwd)) {
+        return {
+          success: false,
+          data: { error: "Cannot list directories outside project directory" }
+        };
+      }
+      try {
+        if (!fs.existsSync(resolvedPath)) {
+          return {
+            success: false,
+            data: { error: `Directory not found: ${dirPath}` }
+          };
+        }
+        const stats = fs.statSync(resolvedPath);
+        if (!stats.isDirectory()) {
+          return {
+            success: false,
+            data: { error: `Not a directory: ${dirPath}` }
+          };
+        }
+        const entries = fs.readdirSync(resolvedPath, { withFileTypes: true });
+        const listing = entries.map((entry) => ({
+          name: entry.name,
+          type: entry.isDirectory() ? "directory" : "file"
+        }));
+        logger.info({ path: dirPath, count: listing.length }, "Directory listed successfully");
+        return {
+          success: true,
+          data: {
+            action: "list_directory",
+            path: dirPath,
+            entries: listing
+          }
+        };
+      } catch (err) {
+        logger.error({ error: err.message, path: dirPath }, "Failed to list directory");
+        return {
+          success: false,
+          data: { error: `Failed to list directory: ${err.message}` }
+        };
+      }
+    }
     const projectInfo = {
       cwd,
       platform: process.platform,
@@ -366,18 +414,6 @@ function registerHandlers(bridge, config) {
 }
 function buildBridgeConfig(options, globalOptions) {
   const fileConfig = loadConfigSync(globalOptions.config);
-  let envConfig = {};
-  if (options.auto) {
-    const env = detectEnvironment();
-    const defaultEnvConfig = getDefaultConfig(env);
-    logger.info({ environment: env.type, isContainer: env.isContainer }, "Auto-detected environment");
-    envConfig = {
-      mode: defaultEnvConfig.mode,
-      instanceName: defaultEnvConfig.instanceName,
-      listen: defaultEnvConfig.listen,
-      connect: defaultEnvConfig.connect
-    };
-  }
   const cliConfig = {};
   if (options.port) {
     cliConfig.listen = {
@@ -398,19 +434,19 @@ function buildBridgeConfig(options, globalOptions) {
     };
   }
   let mode = "peer";
-  const hasListen = cliConfig.listen || envConfig.listen || fileConfig.listen;
-  const hasConnect = cliConfig.connect || envConfig.connect || fileConfig.connect;
+  const hasListen = cliConfig.listen || fileConfig.listen;
+  const hasConnect = cliConfig.connect || fileConfig.connect;
   if (hasListen && !hasConnect) {
     mode = "host";
   } else if (hasConnect && !hasListen) {
     mode = "client";
   }
   const finalConfig = {
-    mode: cliConfig.mode ?? envConfig.mode ?? fileConfig.mode ?? mode,
-    instanceName: cliConfig.instanceName ?? envConfig.instanceName ?? fileConfig.instanceName ?? `bridge-${process.pid}`,
+    mode: cliConfig.mode ?? fileConfig.mode ?? mode,
+    instanceName: cliConfig.instanceName ?? fileConfig.instanceName ?? `bridge-${process.pid}`,
     listen: {
-      port: cliConfig.listen?.port ?? envConfig.listen?.port ?? fileConfig.listen.port,
-      host: cliConfig.listen?.host ?? envConfig.listen?.host ?? fileConfig.listen.host
+      port: cliConfig.listen?.port ?? fileConfig.listen.port,
+      host: cliConfig.listen?.host ?? fileConfig.listen.host
     },
     taskTimeout: fileConfig.interaction.taskTimeout,
     contextSharing: {
@@ -418,7 +454,7 @@ function buildBridgeConfig(options, globalOptions) {
       syncInterval: fileConfig.contextSharing.syncInterval
     }
   };
-  const connectUrl = cliConfig.connect?.url ?? envConfig.connect?.url ?? fileConfig.connect?.url;
+  const connectUrl = cliConfig.connect?.url ?? fileConfig.connect?.url;
   if (connectUrl) {
     finalConfig.connect = {
       url: connectUrl
@@ -427,10 +463,12 @@ function buildBridgeConfig(options, globalOptions) {
   return finalConfig;
 }
 async function startBridge(options, globalOptions) {
-  const { running, pid } = isAlreadyRunning();
-  if (running) {
-    console.error(`Bridge is already running (PID: ${pid})`);
-    process.exit(1);
+  if (!process.env.CLAUDE_BRIDGE_DAEMON_CHILD) {
+    const { running, pid } = isAlreadyRunning();
+    if (running) {
+      console.error(`Bridge is already running (PID: ${pid})`);
+      process.exit(1);
+    }
   }
   const config = buildBridgeConfig(options, globalOptions);
   console.log("Starting Claude Code Bridge...");
@@ -442,9 +480,24 @@ async function startBridge(options, globalOptions) {
   if (config.connect) {
     console.log(`  Connecting to: ${config.connect.url}`);
   }
-  if (options.daemon) {
-    console.log("  Running in daemon mode");
-    writePidFile(process.pid);
+  if (options.daemon && !process.env.CLAUDE_BRIDGE_DAEMON_CHILD) {
+    const logFile = path.join(os.homedir(), ".claude-bridge", "bridge.log");
+    ensureBridgeDir();
+    const args = process.argv.slice(2).filter((arg) => arg !== "-d" && arg !== "--daemon");
+    const out = fs.openSync(logFile, "a");
+    const err = fs.openSync(logFile, "a");
+    const child = spawn(process.execPath, [process.argv[1], ...args], {
+      detached: true,
+      stdio: ["ignore", out, err],
+      env: { ...process.env, CLAUDE_BRIDGE_DAEMON_CHILD: "1" }
+    });
+    child.unref();
+    writePidFile(child.pid);
+    console.log(`  Running in background (PID: ${child.pid})`);
+    console.log(`  Log file: ${logFile}`);
+    console.log(`  Use 'claude-bridge status' to check status`);
+    console.log(`  Use 'claude-bridge stop' to stop the bridge`);
+    process.exit(0);
   }
   const bridge = new Bridge(config);
   setupGracefulShutdown({
@@ -453,7 +506,7 @@ async function startBridge(options, globalOptions) {
       await bridge.stop();
       logger.info("Bridge stopped");
     },
-    afterCleanup: options.daemon ? removePidFile : void 0,
+    afterCleanup: process.env.CLAUDE_BRIDGE_DAEMON_CHILD ? removePidFile : void 0,
     verbose: true,
     timeout: 1e4
   });
@@ -470,7 +523,7 @@ async function startBridge(options, globalOptions) {
         excludePatterns: fileConfig.contextSharing.excludePatterns
       });
     }
-    if (options.daemon) {
+    if (process.env.CLAUDE_BRIDGE_DAEMON_CHILD) {
       writePidFile(process.pid);
     }
     console.log("Bridge started successfully.");
@@ -480,13 +533,13 @@ async function startBridge(options, globalOptions) {
 To connect from another bridge:`);
       console.log(`  claude-bridge connect ws://localhost:${config.listen.port}`);
     }
-    if (!options.daemon) {
+    if (!process.env.CLAUDE_BRIDGE_DAEMON_CHILD) {
       console.log("\nPress Ctrl+C to stop.");
     }
   } catch (error) {
     logger.error({ error: error.message }, "Failed to start bridge");
     console.error(`Failed to start bridge: ${error.message}`);
-    if (options.daemon) {
+    if (process.env.CLAUDE_BRIDGE_DAEMON_CHILD) {
       removePidFile();
     }
     process.exit(1);
@@ -494,7 +547,7 @@ To connect from another bridge:`);
 }
 function createStartCommand() {
   const command = new Command("start");
-  command.description("Start the bridge server").option("-p, --port <port>", "Port to listen on (default: 8765 in container, 8766 native)").option("-h, --host <host>", "Host to bind to (default: 0.0.0.0)").option("-c, --connect <url>", "URL to connect to on startup (e.g., ws://localhost:8765)").option("-a, --auto", "Auto-detect environment and configure").option("-d, --daemon", "Run in background").option("--with-handlers", "Enable file reading and task handling capabilities").action(async (options) => {
+  command.description("Start the bridge server").option("-p, --port <port>", "Port to listen on (default: 8765)").option("-h, --host <host>", "Host to bind to (default: 0.0.0.0)").option("-c, --connect <url>", "URL to connect to on startup (e.g., ws://localhost:8765)").option("-d, --daemon", "Run in background").option("--with-handlers", "Enable file reading and task handling capabilities").action(async (options) => {
     const globalOptions = command.parent?.opts();
     await startBridge(options, globalOptions);
   });
@@ -841,76 +894,12 @@ function createConnectCommand() {
   return command;
 }
 
-// src/cli/commands/discover.ts
-import { Command as Command5 } from "commander";
-var logger5 = createLogger("cli:discover");
-function printPeersTable(peers) {
-  if (peers.length === 0) {
-    console.log("No bridges found.");
-    console.log("");
-    console.log("Suggestions:");
-    console.log("  - Start a bridge: claude-bridge start");
-    console.log("  - Add bridge labels to Docker containers");
-    console.log("  - Install bridge addon in your Docksal/DDEV project");
-    return;
-  }
-  const cols = {
-    name: { title: "Name", width: 25 },
-    source: { title: "Source", width: 12 },
-    url: { title: "URL", width: 35 },
-    status: { title: "Status", width: 12 }
-  };
-  console.log(
-    cols.name.title.padEnd(cols.name.width) + cols.source.title.padEnd(cols.source.width) + cols.url.title.padEnd(cols.url.width) + cols.status.title.padEnd(cols.status.width)
-  );
-  console.log(
-    "-".repeat(cols.name.width - 1) + " " + "-".repeat(cols.source.width - 1) + " " + "-".repeat(cols.url.width - 1) + " " + "-".repeat(cols.status.width - 1)
-  );
-  for (const peer of peers) {
-    const row = peer.name.slice(0, cols.name.width - 1).padEnd(cols.name.width) + peer.source.padEnd(cols.source.width) + peer.url.slice(0, cols.url.width - 1).padEnd(cols.url.width) + (peer.status || "unknown").padEnd(cols.status.width);
-    console.log(row);
-  }
-  console.log("");
-  console.log("To connect to a bridge:");
-  console.log("  claude-bridge connect <url>");
-}
-async function discoverBridges() {
-  console.log("Discovering bridges on local network...\n");
-  const allPeers = [];
-  const dockerPeers = discoverDockerPeers();
-  allPeers.push(...dockerPeers);
-  logger5.debug({ count: dockerPeers.length }, "Docker peers discovered");
-  const docksalPeers = discoverDocksalProjects();
-  allPeers.push(...docksalPeers);
-  logger5.debug({ count: docksalPeers.length }, "Docksal peers discovered");
-  const ddevPeers = discoverDdevProjects();
-  allPeers.push(...ddevPeers);
-  logger5.debug({ count: ddevPeers.length }, "DDEV peers discovered");
-  const landoPeers = discoverLandoProjects();
-  allPeers.push(...landoPeers);
-  logger5.debug({ count: landoPeers.length }, "Lando peers discovered");
-  printPeersTable(allPeers);
-}
-function createDiscoverCommand() {
-  const command = new Command5("discover");
-  command.description("Discover bridges on local network").action(async () => {
-    try {
-      await discoverBridges();
-    } catch (error) {
-      logger5.error({ error: error.message }, "Discover command failed");
-      console.error(`Error: ${error.message}`);
-      process.exit(1);
-    }
-  });
-  return command;
-}
-
 // src/cli/commands/info.ts
-import { Command as Command6 } from "commander";
+import { Command as Command5 } from "commander";
 import * as fs4 from "fs";
 import * as path4 from "path";
 import * as os4 from "os";
-var logger6 = createLogger("cli:info");
+var logger5 = createLogger("cli:info");
 function getConfigFilePath() {
   const localConfig = path4.join(process.cwd(), ".claude-bridge.yml");
   if (fs4.existsSync(localConfig)) {
@@ -944,30 +933,25 @@ function printKeyValue(key, value, indent = 0) {
   console.log(`${prefix}${key}: ${formatValue(value)}`);
 }
 function showInfo(globalOptions) {
-  console.log("Claude Code Bridge - Environment Information");
-  console.log("=".repeat(45));
-  printSection("Environment");
-  const env = detectEnvironment();
-  printKeyValue("Type", env.type);
-  printKeyValue("Platform", env.platform);
-  printKeyValue("Is Container", env.isContainer);
-  printKeyValue("Project Name", env.projectName);
-  printKeyValue("Project Root", env.projectRoot);
+  console.log("Claude Code Bridge - System Information");
+  console.log("=".repeat(40));
+  printSection("System");
+  printKeyValue("Node Version", process.version);
+  printKeyValue("OS", `${os4.type()} ${os4.release()}`);
+  printKeyValue("Platform", process.platform);
+  printKeyValue("Arch", os4.arch());
+  printKeyValue("Home Directory", os4.homedir());
+  printKeyValue("Working Directory", process.cwd());
   printSection("Network");
-  const hostGateway = getHostGateway();
-  const envDefaults = getDefaultConfig(env);
-  const listenPort = envDefaults.listen?.port ?? 8765;
-  const listenHost = envDefaults.listen?.host ?? "0.0.0.0";
-  printKeyValue("Host Gateway", hostGateway);
-  printKeyValue("Recommended Port", listenPort);
-  printKeyValue("Default Host", listenHost);
-  if (env.isContainer) {
-    console.log("");
-    console.log("  Note: To connect from host machine:");
-    console.log(`    ws://localhost:${listenPort}`);
-    console.log("");
-    console.log("  To connect to host from this container:");
-    console.log(`    ws://${hostGateway}:8766`);
+  const interfaces = os4.networkInterfaces();
+  for (const [name, addrs] of Object.entries(interfaces)) {
+    if (addrs) {
+      for (const addr of addrs) {
+        if (addr.family === "IPv4" && !addr.internal) {
+          printKeyValue(name, addr.address);
+        }
+      }
+    }
   }
   printSection("Configuration");
   const configPath = globalOptions.config || getConfigFilePath();
@@ -1006,43 +990,16 @@ function showInfo(globalOptions) {
   printKeyValue("Require Confirmation", config.interaction.requireConfirmation, 2);
   printKeyValue("Notify On Activity", config.interaction.notifyOnActivity, 2);
   printKeyValue("Task Timeout", `${config.interaction.taskTimeout}ms`, 2);
-  printSection("System");
-  printKeyValue("Node Version", process.version);
-  printKeyValue("OS", `${os4.type()} ${os4.release()}`);
-  printKeyValue("Arch", os4.arch());
-  printKeyValue("Home Directory", os4.homedir());
-  printKeyValue("Working Directory", process.cwd());
-  printSection("Environment Variables");
-  const relevantEnvVars = [
-    "DOCKSAL_STACK",
-    "DOCKSAL_PROJECT",
-    "IS_DDEV_PROJECT",
-    "DDEV_PROJECT",
-    "LANDO",
-    "LANDO_APP_NAME",
-    "LOG_LEVEL"
-  ];
-  let hasEnvVars = false;
-  for (const varName of relevantEnvVars) {
-    const value = process.env[varName];
-    if (value !== void 0) {
-      printKeyValue(varName, value);
-      hasEnvVars = true;
-    }
-  }
-  if (!hasEnvVars) {
-    console.log("  (no relevant environment variables set)");
-  }
   console.log("");
 }
 function createInfoCommand() {
-  const command = new Command6("info");
-  command.description("Show environment and configuration info").action(() => {
+  const command = new Command5("info");
+  command.description("Show system and configuration info").action(() => {
     try {
       const globalOptions = command.parent?.opts() ?? {};
       showInfo(globalOptions);
     } catch (error) {
-      logger6.error({ error: error.message }, "Info command failed");
+      logger5.error({ error: error.message }, "Info command failed");
       console.error(`Error: ${error.message}`);
       process.exit(1);
     }
@@ -1050,6 +1007,135 @@ function createInfoCommand() {
   return command;
 }
 
+// src/cli/commands/mcp-server.ts
+import { Command as Command6 } from "commander";
+import * as fs5 from "fs";
+import * as path5 from "path";
+import * as os5 from "os";
+import { spawn as spawn2 } from "child_process";
+var logger6 = createLogger("cli:mcp-server");
+var DEFAULT_DAEMON_PORT = 8766;
+function getStatusFilePath2() {
+  const bridgeDir = path5.join(os5.homedir(), ".claude-bridge");
+  return path5.join(bridgeDir, "status.json");
+}
+function getPidFilePath4() {
+  const bridgeDir = path5.join(os5.homedir(), ".claude-bridge");
+  return path5.join(bridgeDir, "bridge.pid");
+}
+function isDaemonRunning() {
+  const pidFile = getPidFilePath4();
+  if (!fs5.existsSync(pidFile)) {
+    return { running: false };
+  }
+  try {
+    const pid = parseInt(fs5.readFileSync(pidFile, "utf-8").trim(), 10);
+    process.kill(pid, 0);
+    const statusFile = getStatusFilePath2();
+    if (fs5.existsSync(statusFile)) {
+      const status = JSON.parse(fs5.readFileSync(statusFile, "utf-8"));
+      return { running: true, pid, port: status.port };
+    }
+    return { running: true, pid };
+  } catch {
+    return { running: false };
+  }
+}
+async function waitForDaemon(port, timeoutMs) {
+  const startTime = Date.now();
+  while (Date.now() - startTime < timeoutMs) {
+    const { running, port: runningPort } = isDaemonRunning();
+    if (running && (runningPort === port || runningPort === void 0)) {
+      await new Promise((resolve2) => setTimeout(resolve2, 500));
+      return;
+    }
+    await new Promise((resolve2) => setTimeout(resolve2, 200));
+  }
+  throw new Error(`Daemon did not start within ${timeoutMs}ms`);
+}
+function ensureBridgeDir2() {
+  const bridgeDir = path5.join(os5.homedir(), ".claude-bridge");
+  if (!fs5.existsSync(bridgeDir)) {
+    fs5.mkdirSync(bridgeDir, { recursive: true });
+  }
+}
+async function ensureDaemonRunning(port) {
+  const { running, pid, port: runningPort } = isDaemonRunning();
+  if (running) {
+    const effectivePort = runningPort ?? port;
+    console.error(`[MCP] Bridge daemon already running (PID: ${pid}, port: ${effectivePort})`);
+    return effectivePort;
+  }
+  console.error("[MCP] Starting bridge daemon...");
+  ensureBridgeDir2();
+  const logFile = path5.join(os5.homedir(), ".claude-bridge", "bridge.log");
+  const out = fs5.openSync(logFile, "a");
+  const err = fs5.openSync(logFile, "a");
+  const cliPath = process.argv[1];
+  const child = spawn2(process.execPath, [cliPath, "start", "--daemon", "--port", String(port)], {
+    detached: true,
+    stdio: ["ignore", out, err]
+  });
+  child.unref();
+  console.error(`[MCP] Daemon starting (PID: ${child.pid})`);
+  try {
+    await waitForDaemon(port, 5e3);
+    console.error(`[MCP] Daemon ready on port ${port}`);
+    return port;
+  } catch (error) {
+    console.error(`[MCP] Warning: Could not verify daemon is ready: ${error.message}`);
+    return port;
+  }
+}
+async function startMcpServer(options, _globalOptions) {
+  let bridgeUrl = options.connect ?? `ws://localhost:${DEFAULT_DAEMON_PORT}`;
+  if (!options.connect) {
+    try {
+      const port = await ensureDaemonRunning(DEFAULT_DAEMON_PORT);
+      bridgeUrl = `ws://localhost:${port}`;
+    } catch (error) {
+      console.error(`[MCP] Warning: Could not ensure daemon is running: ${error.message}`);
+    }
+  }
+  const config = {
+    bridgeUrl,
+    name: options.name ?? "claude-bridge",
+    version: "0.4.0",
+    instanceName: `mcp-server-${process.pid}`,
+    taskTimeout: 6e4
+  };
+  const server = new BridgeMcpServer(config);
+  setupGracefulShutdown({
+    cleanup: async () => {
+      console.error("[MCP] Shutting down...");
+      await server.stop();
+    },
+    verbose: false,
+    timeout: 5e3
+  });
+  handleUnhandledRejections({
+    exit: true,
+    logger: (msg, err) => {
+      console.error(`[MCP] ${msg}: ${err.message}`);
+      logger6.error({ error: err.message }, msg);
+    }
+  });
+  try {
+    await server.start();
+  } catch (error) {
+    console.error(`[MCP] Failed to start MCP server: ${error.message}`);
+    process.exit(1);
+  }
+}
+function createMcpServerCommand() {
+  const command = new Command6("mcp-server");
+  command.description("Start the MCP server for Claude Code integration").option("-c, --connect <url>", `Bridge WebSocket URL (default: ws://localhost:${DEFAULT_DAEMON_PORT})`).option("--name <name>", "MCP server name (default: claude-bridge)").action(async (options) => {
+    const globalOptions = command.parent?.opts();
+    await startMcpServer(options, globalOptions);
+  });
+  return command;
+}
+
 // src/cli/index.ts
 var VERSION = "0.1.0";
 var logger7 = createLogger("cli");
@@ -1073,8 +1159,8 @@ async function main() {
   program.addCommand(createStopCommand());
   program.addCommand(createStatusCommand());
   program.addCommand(createConnectCommand());
-  program.addCommand(createDiscoverCommand());
   program.addCommand(createInfoCommand());
+  program.addCommand(createMcpServerCommand());
   await program.parseAsync(process.argv);
 }
 main().catch((error) => {