@willjackson/claude-code-bridge 0.3.0 → 0.4.1

package/dist/cli.js

@@ -1,20 +1,22 @@
 #!/usr/bin/env node
 import {
   Bridge,
+  BridgeMcpServer,
   ConnectionState,
   WebSocketTransport,
   createLogger,
   loadConfigSync
-} from "./chunk-LUL3SX2F.js";
+} from "./chunk-MHUQYPTB.js";
 
 // src/cli/index.ts
-import { Command as Command6 } from "commander";
+import { Command as Command7 } from "commander";
 
 // src/cli/commands/start.ts
 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
@@ -72,10 +74,10 @@ Received ${signal}, shutting down gracefully...`);
   };
 }
 function handleUnhandledRejections(options = {}) {
-  const { exit = false, logger: logger7 = console.error } = options;
+  const { exit = false, logger: logger8 = console.error } = options;
   process.on("unhandledRejection", (reason, promise) => {
     const error = reason instanceof Error ? reason : new Error(String(reason));
-    logger7("Unhandled promise rejection:", error);
+    logger8("Unhandled promise rejection:", error);
     if (exit) {
       process.exit(1);
     }
@@ -296,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,
@@ -408,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...");
@@ -423,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({
@@ -434,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
   });
@@ -451,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.");
@@ -461,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);
@@ -935,11 +1007,140 @@ 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 logger6 = createLogger("cli");
+var logger7 = createLogger("cli");
 function createProgram() {
-  const program = new Command6();
+  const program = new Command7();
   program.name("claude-bridge").description("Bidirectional communication system for Claude Code instances across environments").version(VERSION, "-V, --version", "Output the version number").option("-v, --verbose", "Enable verbose logging").option("--config <path>", "Path to config file");
   program.hook("preAction", (thisCommand) => {
     const opts = thisCommand.opts();
@@ -959,10 +1160,11 @@ async function main() {
   program.addCommand(createStatusCommand());
   program.addCommand(createConnectCommand());
   program.addCommand(createInfoCommand());
+  program.addCommand(createMcpServerCommand());
   await program.parseAsync(process.argv);
 }
 main().catch((error) => {
-  logger6.error({ err: error }, "CLI error");
+  logger7.error({ err: error }, "CLI error");
   process.exit(1);
 });
 export {