@willjackson/claude-code-bridge 0.1.0

package/dist/cli.js

@@ -0,0 +1,844 @@
+#!/usr/bin/env node
+import {
+  Bridge,
+  ConnectionState,
+  WebSocketTransport,
+  createLogger,
+  detectEnvironment,
+  discoverDdevProjects,
+  discoverDockerPeers,
+  discoverDocksalProjects,
+  discoverLandoProjects,
+  getDefaultConfig,
+  getHostGateway,
+  loadConfigSync
+} from "./chunk-BRH476VK.js";
+
+// src/cli/index.ts
+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";
+
+// src/cli/utils.ts
+function setupGracefulShutdown(options) {
+  const {
+    cleanup,
+    afterCleanup,
+    verbose = true,
+    timeout = 1e4
+  } = options;
+  let isShuttingDown = false;
+  const handler = async (signal) => {
+    if (isShuttingDown) {
+      if (verbose) {
+        console.log("Shutdown already in progress...");
+      }
+      return;
+    }
+    isShuttingDown = true;
+    if (verbose) {
+      console.log(`
+Received ${signal}, shutting down gracefully...`);
+    }
+    const forceExitTimeout = setTimeout(() => {
+      if (verbose) {
+        console.error("Shutdown timeout - forcing exit");
+      }
+      process.exit(1);
+    }, timeout);
+    try {
+      await cleanup();
+      if (afterCleanup) {
+        afterCleanup();
+      }
+      clearTimeout(forceExitTimeout);
+      if (verbose) {
+        console.log("Shutdown complete.");
+      }
+      process.exit(0);
+    } catch (error) {
+      clearTimeout(forceExitTimeout);
+      if (verbose) {
+        console.error(`Error during shutdown: ${error.message}`);
+      }
+      process.exit(1);
+    }
+  };
+  const sigintHandler = () => handler("SIGINT");
+  const sigtermHandler = () => handler("SIGTERM");
+  process.on("SIGINT", sigintHandler);
+  process.on("SIGTERM", sigtermHandler);
+  return () => {
+    process.off("SIGINT", sigintHandler);
+    process.off("SIGTERM", sigtermHandler);
+  };
+}
+function handleUnhandledRejections(options = {}) {
+  const { exit = false, logger: logger8 = console.error } = options;
+  process.on("unhandledRejection", (reason, promise) => {
+    const error = reason instanceof Error ? reason : new Error(String(reason));
+    logger8("Unhandled promise rejection:", error);
+    if (exit) {
+      process.exit(1);
+    }
+  });
+}
+
+// src/cli/commands/start.ts
+var logger = createLogger("cli:start");
+function getPidFilePath() {
+  const bridgeDir = path.join(os.homedir(), ".claude-bridge");
+  return path.join(bridgeDir, "bridge.pid");
+}
+function ensureBridgeDir() {
+  const bridgeDir = path.join(os.homedir(), ".claude-bridge");
+  if (!fs.existsSync(bridgeDir)) {
+    fs.mkdirSync(bridgeDir, { recursive: true });
+  }
+}
+function writePidFile(pid) {
+  ensureBridgeDir();
+  const pidFile = getPidFilePath();
+  fs.writeFileSync(pidFile, pid.toString(), "utf-8");
+}
+function removePidFile() {
+  const pidFile = getPidFilePath();
+  if (fs.existsSync(pidFile)) {
+    fs.unlinkSync(pidFile);
+  }
+}
+function isAlreadyRunning() {
+  const pidFile = getPidFilePath();
+  if (!fs.existsSync(pidFile)) {
+    return { running: false };
+  }
+  try {
+    const pid = parseInt(fs.readFileSync(pidFile, "utf-8").trim(), 10);
+    process.kill(pid, 0);
+    return { running: true, pid };
+  } catch {
+    removePidFile();
+    return { running: false };
+  }
+}
+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 = {
+      ...cliConfig.listen,
+      port: parseInt(options.port, 10),
+      host: options.host ?? "0.0.0.0"
+    };
+  }
+  if (options.host && !cliConfig.listen) {
+    cliConfig.listen = {
+      port: fileConfig.listen.port,
+      host: options.host
+    };
+  }
+  if (options.connect) {
+    cliConfig.connect = {
+      url: options.connect
+    };
+  }
+  let mode = "peer";
+  const hasListen = cliConfig.listen || envConfig.listen || fileConfig.listen;
+  const hasConnect = cliConfig.connect || envConfig.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}`,
+    listen: {
+      port: cliConfig.listen?.port ?? envConfig.listen?.port ?? fileConfig.listen.port,
+      host: cliConfig.listen?.host ?? envConfig.listen?.host ?? fileConfig.listen.host
+    },
+    taskTimeout: fileConfig.interaction.taskTimeout,
+    contextSharing: {
+      autoSync: fileConfig.contextSharing.autoSync,
+      syncInterval: fileConfig.contextSharing.syncInterval
+    }
+  };
+  const connectUrl = cliConfig.connect?.url ?? envConfig.connect?.url ?? fileConfig.connect?.url;
+  if (connectUrl) {
+    finalConfig.connect = {
+      url: connectUrl
+    };
+  }
+  return finalConfig;
+}
+async function startBridge(options, globalOptions) {
+  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...");
+  console.log(`  Instance: ${config.instanceName}`);
+  console.log(`  Mode: ${config.mode}`);
+  if (config.listen) {
+    console.log(`  Listening: ${config.listen.host}:${config.listen.port}`);
+  }
+  if (config.connect) {
+    console.log(`  Connecting to: ${config.connect.url}`);
+  }
+  if (options.daemon) {
+    console.log("  Running in daemon mode");
+    writePidFile(process.pid);
+  }
+  const bridge = new Bridge(config);
+  setupGracefulShutdown({
+    cleanup: async () => {
+      logger.info("Stopping bridge...");
+      await bridge.stop();
+      logger.info("Bridge stopped");
+    },
+    afterCleanup: options.daemon ? removePidFile : void 0,
+    verbose: true,
+    timeout: 1e4
+  });
+  handleUnhandledRejections({
+    exit: false,
+    logger: (msg, err) => logger.error({ error: err.message }, msg)
+  });
+  try {
+    await bridge.start();
+    if (options.daemon) {
+      writePidFile(process.pid);
+    }
+    console.log("Bridge started successfully.");
+    console.log(`Connected peers: ${bridge.getPeerCount()}`);
+    if (config.listen) {
+      console.log(`
+To connect from another bridge:`);
+      console.log(`  claude-bridge connect ws://localhost:${config.listen.port}`);
+    }
+    if (!options.daemon) {
+      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) {
+      removePidFile();
+    }
+    process.exit(1);
+  }
+}
+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").action(async (options) => {
+    const globalOptions = command.parent?.opts();
+    await startBridge(options, globalOptions);
+  });
+  return command;
+}
+
+// src/cli/commands/stop.ts
+import { Command as Command2 } from "commander";
+import * as fs2 from "fs";
+import * as path2 from "path";
+import * as os2 from "os";
+var logger2 = createLogger("cli:stop");
+function getPidFilePath2() {
+  const bridgeDir = path2.join(os2.homedir(), ".claude-bridge");
+  return path2.join(bridgeDir, "bridge.pid");
+}
+function removePidFile2() {
+  const pidFile = getPidFilePath2();
+  if (fs2.existsSync(pidFile)) {
+    fs2.unlinkSync(pidFile);
+  }
+}
+function readPidFile() {
+  const pidFile = getPidFilePath2();
+  if (!fs2.existsSync(pidFile)) {
+    return null;
+  }
+  try {
+    const content = fs2.readFileSync(pidFile, "utf-8").trim();
+    const pid = parseInt(content, 10);
+    if (isNaN(pid) || pid <= 0) {
+      logger2.warn({ content }, "Invalid PID file content");
+      return null;
+    }
+    return pid;
+  } catch (error) {
+    logger2.error({ error: error.message }, "Failed to read PID file");
+    return null;
+  }
+}
+function isProcessRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function waitForProcessExit(pid, timeoutMs = 5e3) {
+  const startTime = Date.now();
+  const checkInterval = 100;
+  while (Date.now() - startTime < timeoutMs) {
+    if (!isProcessRunning(pid)) {
+      return true;
+    }
+    await new Promise((resolve) => setTimeout(resolve, checkInterval));
+  }
+  return false;
+}
+async function stopBridge() {
+  const pid = readPidFile();
+  if (pid === null) {
+    console.log("Bridge is not running (no PID file found).");
+    return;
+  }
+  if (!isProcessRunning(pid)) {
+    console.log(`Bridge is not running (stale PID file, process ${pid} not found).`);
+    removePidFile2();
+    return;
+  }
+  console.log(`Stopping bridge (PID: ${pid})...`);
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch (error) {
+    if (error.code === "ESRCH") {
+      console.log("Bridge process not found.");
+      removePidFile2();
+      return;
+    }
+    if (error.code === "EPERM") {
+      console.error(`Permission denied: cannot stop bridge (PID: ${pid}).`);
+      console.error("Try running with elevated privileges.");
+      process.exit(1);
+    }
+    throw error;
+  }
+  const exited = await waitForProcessExit(pid);
+  if (exited) {
+    console.log("Bridge stopped successfully.");
+    removePidFile2();
+  } else {
+    console.log("Bridge is still shutting down. Check status with: claude-bridge status");
+    console.log(`To force stop: kill -9 ${pid}`);
+  }
+}
+function createStopCommand() {
+  const command = new Command2("stop");
+  command.description("Stop the running bridge").action(async () => {
+    try {
+      await stopBridge();
+    } catch (error) {
+      logger2.error({ error: error.message }, "Failed to stop bridge");
+      console.error(`Failed to stop bridge: ${error.message}`);
+      process.exit(1);
+    }
+  });
+  return command;
+}
+
+// src/cli/commands/status.ts
+import { Command as Command3 } from "commander";
+import * as fs3 from "fs";
+import * as path3 from "path";
+import * as os3 from "os";
+var logger3 = createLogger("cli:status");
+function getPidFilePath3() {
+  const bridgeDir = path3.join(os3.homedir(), ".claude-bridge");
+  return path3.join(bridgeDir, "bridge.pid");
+}
+function getStatusFilePath() {
+  const bridgeDir = path3.join(os3.homedir(), ".claude-bridge");
+  return path3.join(bridgeDir, "status.json");
+}
+function readPidFile2() {
+  const pidFile = getPidFilePath3();
+  if (!fs3.existsSync(pidFile)) {
+    return null;
+  }
+  try {
+    const content = fs3.readFileSync(pidFile, "utf-8").trim();
+    const pid = parseInt(content, 10);
+    if (isNaN(pid) || pid <= 0) {
+      return null;
+    }
+    return pid;
+  } catch {
+    return null;
+  }
+}
+function isProcessRunning2(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function readStatusFile() {
+  const statusFile = getStatusFilePath();
+  if (!fs3.existsSync(statusFile)) {
+    return null;
+  }
+  try {
+    const content = fs3.readFileSync(statusFile, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function formatDate(dateStr) {
+  try {
+    const date = new Date(dateStr);
+    return date.toLocaleString();
+  } catch {
+    return dateStr;
+  }
+}
+function padRight(str, width) {
+  return str.padEnd(width);
+}
+function printPeerTable(peers) {
+  if (peers.length === 0) {
+    console.log("  No peers connected.");
+    return;
+  }
+  const cols = {
+    id: { title: "ID", width: 38 },
+    name: { title: "Name", width: 20 },
+    connected: { title: "Connected", width: 22 },
+    lastActivity: { title: "Last Activity", width: 22 }
+  };
+  console.log("");
+  console.log(
+    "  " + padRight(cols.id.title, cols.id.width) + padRight(cols.name.title, cols.name.width) + padRight(cols.connected.title, cols.connected.width) + padRight(cols.lastActivity.title, cols.lastActivity.width)
+  );
+  const separator = "  " + "-".repeat(cols.id.width - 1) + " " + "-".repeat(cols.name.width - 1) + " " + "-".repeat(cols.connected.width - 1) + " " + "-".repeat(cols.lastActivity.width - 1);
+  console.log(separator);
+  for (const peer of peers) {
+    const row = "  " + padRight(peer.id, cols.id.width) + padRight(peer.name.slice(0, cols.name.width - 1), cols.name.width) + padRight(formatDate(peer.connectedAt), cols.connected.width) + padRight(formatDate(peer.lastActivity), cols.lastActivity.width);
+    console.log(row);
+  }
+  console.log("");
+}
+function getBridgeStatus() {
+  const pid = readPidFile2();
+  if (pid === null) {
+    return { running: false };
+  }
+  if (!isProcessRunning2(pid)) {
+    return { running: false };
+  }
+  const statusInfo = readStatusFile();
+  return {
+    running: true,
+    pid,
+    port: statusInfo?.port,
+    peers: statusInfo?.peers
+  };
+}
+function showStatus(options) {
+  console.log("Claude Code Bridge Status");
+  console.log("=".repeat(26));
+  console.log("");
+  const status = getBridgeStatus();
+  if (!status.running) {
+    console.log("Status: stopped");
+    console.log("");
+    console.log("To start the bridge:");
+    console.log("  claude-bridge start");
+    return;
+  }
+  console.log("Status: running");
+  console.log(`PID: ${status.pid}`);
+  if (status.port !== void 0) {
+    console.log(`Port: ${status.port}`);
+  }
+  console.log("");
+  console.log("Connected Peers:");
+  if (status.peers) {
+    printPeerTable(status.peers);
+  } else {
+    console.log("  Unable to retrieve peer information.");
+    console.log("  (Status file not found or unreadable)");
+  }
+  console.log("To stop the bridge:");
+  console.log("  claude-bridge stop");
+}
+function createStatusCommand() {
+  const command = new Command3("status");
+  command.description("Show bridge status and connected peers").option("-p, --port <port>", "Check status for a specific port").action((options) => {
+    try {
+      showStatus(options);
+    } catch (error) {
+      logger3.error({ error: error.message }, "Failed to get status");
+      console.error(`Failed to get status: ${error.message}`);
+      process.exit(1);
+    }
+  });
+  return command;
+}
+
+// src/cli/commands/connect.ts
+import { Command as Command4 } from "commander";
+var logger4 = createLogger("cli:connect");
+function validateWebSocketUrl(url) {
+  if (!url.startsWith("ws://") && !url.startsWith("wss://")) {
+    throw new Error(`Invalid URL protocol. Expected ws:// or wss://, got: ${url}`);
+  }
+  try {
+    const parsed = new URL(url);
+    if (!parsed.hostname) {
+      throw new Error("URL must include a hostname");
+    }
+    if (!parsed.port) {
+      const defaultPort = parsed.protocol === "wss:" ? "443" : "80";
+      logger4.debug(`No port specified, will use default: ${defaultPort}`);
+    }
+    return true;
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("Invalid URL")) {
+      throw new Error(`Invalid URL format: ${url}`);
+    }
+    throw error;
+  }
+}
+async function connectToBridge(url) {
+  try {
+    validateWebSocketUrl(url);
+  } catch (error) {
+    console.error(`Error: ${error.message}`);
+    process.exit(1);
+  }
+  console.log(`Connecting to bridge at ${url}...`);
+  const transport = new WebSocketTransport();
+  const timeoutMs = 1e4;
+  const timeout = setTimeout(() => {
+    console.error(`Error: Connection timeout after ${timeoutMs / 1e3} seconds`);
+    transport.disconnect().catch(() => {
+    });
+    process.exit(1);
+  }, timeoutMs);
+  try {
+    await transport.connect({
+      url,
+      reconnect: false
+      // Don't auto-reconnect for this test
+    });
+    clearTimeout(timeout);
+    if (transport.getState() === "CONNECTED" /* CONNECTED */) {
+      console.log("Successfully connected to bridge!");
+      console.log("");
+      console.log("Connection details:");
+      console.log(`  URL: ${url}`);
+      console.log(`  State: ${ConnectionState[transport.getState()]}`);
+      console.log("");
+      console.log("To start a bridge that auto-connects on startup:");
+      console.log(`  claude-bridge start --connect ${url}`);
+    } else {
+      console.error(`Connection failed. State: ${ConnectionState[transport.getState()]}`);
+      process.exit(1);
+    }
+    await transport.disconnect();
+    console.log("\nConnection test complete. Disconnected.");
+  } catch (error) {
+    clearTimeout(timeout);
+    const errorMessage = error.message;
+    console.error(`Error: Failed to connect - ${errorMessage}`);
+    if (errorMessage.includes("ECONNREFUSED")) {
+      console.log("");
+      console.log("Suggestions:");
+      console.log("  - Ensure a bridge is running at the specified address");
+      console.log("  - Check the port number is correct");
+      console.log("  - Verify no firewall is blocking the connection");
+    } else if (errorMessage.includes("ENOTFOUND")) {
+      console.log("");
+      console.log("Suggestions:");
+      console.log("  - Check the hostname is correct");
+      console.log("  - Ensure DNS resolution is working");
+    }
+    process.exit(1);
+  }
+}
+function createConnectCommand() {
+  const command = new Command4("connect");
+  command.description("Connect to a remote bridge").argument("<url>", "WebSocket URL to connect to (e.g., ws://localhost:8765)").action(async (url) => {
+    try {
+      await connectToBridge(url);
+    } catch (error) {
+      logger4.error({ error: error.message }, "Connect command failed");
+      console.error(`Error: ${error.message}`);
+      process.exit(1);
+    }
+  });
+  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 * as fs4 from "fs";
+import * as path4 from "path";
+import * as os4 from "os";
+var logger6 = createLogger("cli:info");
+function getConfigFilePath() {
+  const localConfig = path4.join(process.cwd(), ".claude-bridge.yml");
+  if (fs4.existsSync(localConfig)) {
+    return localConfig;
+  }
+  const homeConfig = path4.join(os4.homedir(), ".claude-bridge", "config.yml");
+  if (fs4.existsSync(homeConfig)) {
+    return homeConfig;
+  }
+  return null;
+}
+function formatValue(value) {
+  if (value === void 0) {
+    return "(not set)";
+  }
+  if (value === null) {
+    return "(null)";
+  }
+  if (typeof value === "object") {
+    return JSON.stringify(value);
+  }
+  return String(value);
+}
+function printSection(title) {
+  console.log("");
+  console.log(title);
+  console.log("-".repeat(title.length));
+}
+function printKeyValue(key, value, indent = 0) {
+  const prefix = "  ".repeat(indent);
+  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);
+  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`);
+  }
+  printSection("Configuration");
+  const configPath = globalOptions.config || getConfigFilePath();
+  printKeyValue("Config File", configPath || "(using defaults)");
+  const config = loadConfigSync(globalOptions.config);
+  console.log("");
+  console.log("  Current Settings:");
+  printKeyValue("Mode", config.mode, 2);
+  printKeyValue("Instance Name", config.instanceName, 2);
+  console.log("");
+  console.log("  Listen:");
+  printKeyValue("Port", config.listen.port, 2);
+  printKeyValue("Host", config.listen.host, 2);
+  console.log("");
+  console.log("  Connect:");
+  printKeyValue("URL", config.connect?.url, 2);
+  console.log("");
+  console.log("  Context Sharing:");
+  printKeyValue("Auto Sync", config.contextSharing.autoSync, 2);
+  printKeyValue("Sync Interval", `${config.contextSharing.syncInterval}ms`, 2);
+  printKeyValue("Max Chunk Tokens", config.contextSharing.maxChunkTokens, 2);
+  if (config.contextSharing.includePatterns.length > 0) {
+    console.log("    Include Patterns:");
+    for (const pattern of config.contextSharing.includePatterns) {
+      console.log(`      - ${pattern}`);
+    }
+  }
+  if (config.contextSharing.excludePatterns.length > 0) {
+    console.log("    Exclude Patterns:");
+    for (const pattern of config.contextSharing.excludePatterns) {
+      console.log(`      - ${pattern}`);
+    }
+  }
+  console.log("");
+  console.log("  Interaction:");
+  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(() => {
+    try {
+      const globalOptions = command.parent?.opts() ?? {};
+      showInfo(globalOptions);
+    } catch (error) {
+      logger6.error({ error: error.message }, "Info command failed");
+      console.error(`Error: ${error.message}`);
+      process.exit(1);
+    }
+  });
+  return command;
+}
+
+// src/cli/index.ts
+var VERSION = "0.1.0";
+var logger7 = createLogger("cli");
+function createProgram() {
+  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();
+    if (opts.verbose) {
+      process.env.LOG_LEVEL = "debug";
+    }
+  });
+  return program;
+}
+function getGlobalOptions(program) {
+  return program.opts();
+}
+async function main() {
+  const program = createProgram();
+  program.addCommand(createStartCommand());
+  program.addCommand(createStopCommand());
+  program.addCommand(createStatusCommand());
+  program.addCommand(createConnectCommand());
+  program.addCommand(createDiscoverCommand());
+  program.addCommand(createInfoCommand());
+  await program.parseAsync(process.argv);
+}
+main().catch((error) => {
+  logger7.error({ err: error }, "CLI error");
+  process.exit(1);
+});
+export {
+  createProgram as createCLI,
+  createProgram,
+  getGlobalOptions,
+  main
+};
+//# sourceMappingURL=cli.js.map