@ruifung/codemode-bridge 1.0.5 → 1.0.7

package/dist/cli/commands.d.ts

@@ -6,7 +6,7 @@
 /**
  * Run the bridge server
  */
-export declare function runServer(configPath?: string, servers?: string[], debug?: boolean): Promise<void>;
+export declare function runServer(configPath?: string, servers?: string[], debug?: boolean, executor?: string): Promise<void>;
 /**
  * List all configured servers
  */

package/dist/cli/commands.js

@@ -15,7 +15,7 @@ import { MCPClient } from "../mcp/mcp-client.js";
 /**
  * Run the bridge server
  */
-export async function runServer(configPath, servers, debug) {
+export async function runServer(configPath, servers, debug, executor) {
     try {
         // Initialize logger with debug mode if requested
         initializeLogger(debug);
@@ -53,7 +53,7 @@ export async function runServer(configPath, servers, debug) {
         }
         logInfo(`Starting bridge with ${serverConfigs.length} server(s)`, { component: 'CLI' });
         // Start the MCP bridge server
-        await startCodeModeBridgeServer(serverConfigs);
+        await startCodeModeBridgeServer(serverConfigs, executor);
         // Flush buffered stderr output from stdio tools now that Bridge is fully running
         flushStderrBuffer();
         logInfo("Bridge is running!", { component: 'CLI' });
@@ -136,7 +136,7 @@ export function addServerCommand(name, options, configPath) {
         };
         if (options.type === "stdio") {
             if (!options.command) {
-                console.error(chalk.red("✗") + ' Missing --command for stdio server');
+                console.error(chalk.red("✗") + " Missing command for stdio server");
                 process.exit(1);
             }
             entry.command = options.command;
@@ -146,7 +146,7 @@ export function addServerCommand(name, options, configPath) {
         }
         else if (options.type === "http") {
             if (!options.url) {
-                console.error(chalk.red("✗") + ' Missing --url for http server');
+                console.error(chalk.red("✗") + " Missing --url for http server");
                 process.exit(1);
             }
             entry.url = options.url;

package/dist/cli/index.js

@@ -18,20 +18,26 @@
  */
 import { Command } from "commander";
 import { runServer, listServersCommand, showServerCommand, addServerCommand, removeServerCommand, editServerCommand, configInfoCommand, authLoginCommand, authLogoutCommand, authListCommand, } from "./commands.js";
+import { getConfigFilePath } from "./config-manager.js";
 import * as fs from "fs";
 const pkg = JSON.parse(fs.readFileSync(new URL("../../package.json", import.meta.url), "utf-8"));
+const defaultConfigPath = getConfigFilePath();
 const program = new Command();
-program.name("codemode-bridge").description("Code Mode Bridge CLI").version(pkg.version);
+program
+    .name("codemode-bridge")
+    .description("Code Mode Bridge CLI - Connects to multiple MCP servers and exposes them as a single tool")
+    .version(pkg.version);
 // Main 'run' command
 program
-    .command("run")
+    .command("run", { isDefault: true })
     .description("Start the bridge MCP server (default command)")
-    .option("-c, --config <path>", "Path to mcp.json configuration file (default: ~/.config/codemode-bridge/mcp.json)")
+    .option("-c, --config <path>", `Path to mcp.json configuration file (default: ${defaultConfigPath})`)
     .option("-s, --servers <names>", "Comma-separated list of servers to connect to")
     .option("-d, --debug", "Enable debug logging")
+    .option("-e, --executor <type>", "Executor type (isolated-vm, container, vm2)")
     .action(async (options) => {
     const servers = options.servers ? options.servers.split(",").map((s) => s.trim()) : undefined;
-    await runServer(options.config, servers, options.debug);
+    await runServer(options.config, servers, options.debug, options.executor);
 });
 // Config command group
 const config = program.command("config").description("Manage bridge configuration").enablePositionalOptions();
@@ -43,20 +49,27 @@ config
     listServersCommand(options.config);
 });
 config
-    .command("show <name>")
+    .command("show <server-name>")
     .description("Show a server configuration")
     .option("-c, --config <path>", "Path to mcp.json configuration file")
     .action((name, options) => {
     showServerCommand(name, options.config);
 });
 config
-    .command("add <name> [commandAndArgs...]")
+    .command("add <server-name> [commandAndArgs...]")
     .description("Add a new server configuration (use -- before commands with flags, e.g. -- npx -y @some/pkg)")
     .passThroughOptions()
     .requiredOption("-t, --type <type>", "Server type (stdio or http)")
     .option("--url <url>", "Server URL (required for http servers)")
     .option("--env <env...>", 'Environment variables as KEY=VALUE pairs')
     .option("-c, --config <path>", "Path to mcp.json configuration file")
+    .addHelpText("after", `
+Examples:
+  $ codemode-bridge config add my-server --type stdio node /path/to/server.js
+  $ codemode-bridge config add remote-server --type http --url https://api.example.com/mcp
+  $ codemode-bridge config add secure-server --type stdio --env API_KEY=secret python server.py
+  $ codemode-bridge config add npx-server --type stdio -- npx -y @modelcontextprotocol/server-everything
+`)
     .action((name, commandAndArgs, options) => {
     let command;
     let args;
@@ -85,19 +98,25 @@ config
     }, options.config);
 });
 config
-    .command("remove <name>")
+    .command("remove <server-name>")
     .description("Remove a server configuration")
     .option("-c, --config <path>", "Path to mcp.json configuration file")
     .action((name, options) => {
     removeServerCommand(name, options.config);
 });
 config
-    .command("edit <name> [commandAndArgs...]")
+    .command("edit <server-name> [commandAndArgs...]")
     .description("Edit a server configuration")
     .option("-t, --type <type>", "Server type (stdio or http)")
     .option("--url <url>", "Server URL (for http servers)")
     .option("--env <env...>", 'Environment variables as KEY=VALUE pairs')
     .option("-c, --config <path>", "Path to mcp.json configuration file")
+    .addHelpText("after", `
+Examples:
+  $ codemode-bridge config edit my-server node /new/path/to/server.js
+  $ codemode-bridge config edit remote-server --url https://new-api.example.com/mcp
+  $ codemode-bridge config edit secure-server --env API_KEY=new-secret
+`)
     .action((name, commandAndArgs, options) => {
     let command;
     let args;
@@ -155,12 +174,4 @@ auth
     .action((serverName, options) => {
     authLogoutCommand(serverName, options.config);
 });
-// Default command: run if no command specified
-program.action(async () => {
-    // If no command is specified, run the bridge
-    const args = process.argv.slice(2);
-    if (args.length === 0) {
-        await runServer(undefined, undefined, false);
-    }
-});
 program.parse();

package/dist/executor/container-executor.js

@@ -71,6 +71,11 @@ export class ContainerExecutor {
         this.memoryLimit = options.memoryLimit ?? '256m';
         this.cpuLimit = options.cpuLimit ?? 1.0;
         this.runtime = detectRuntime(options.runtime);
+        // Start initialization immediately to create the container before the first execution.
+        // Errors are caught and logged, but will also be thrown when execute() awaits this.init().
+        this.init().catch(err => {
+            process.stderr.write(`[container-executor] Immediate initialization failed: ${err.message}\n`);
+        });
     }
     /**
      * Start the container and wait for the runner to signal readiness.

package/dist/mcp/executor.d.ts

@@ -19,13 +19,14 @@ export interface ExecutorInfo {
  * Factory function to create an Executor instance.
  *
  * Selection logic:
+ *   - If explicitType is provided, that executor is used (throws if unavailable).
  *   - If EXECUTOR_TYPE is set, that executor is used (throws if unavailable).
  *   - Otherwise, executors are tried in preference order (isolated-vm →
  *     container → vm2) and the first available one is selected.
  *
  * Returns both the executor and metadata about the selection.
  */
-export declare function createExecutor(timeout?: number): Promise<{
+export declare function createExecutor(timeout?: number, explicitType?: ExecutorType): Promise<{
     executor: Executor;
     info: ExecutorInfo;
 }>;

package/dist/mcp/executor.js

@@ -3,36 +3,57 @@
  * Selects the best available executor (isolated-vm → container → vm2)
  */
 import { execFileSync } from "node:child_process";
-import { logInfo } from "../utils/logger.js";
+import { logInfo, logDebug } from "../utils/logger.js";
 // ── Availability checks (cached) ────────────────────────────────────
 let _isolatedVmAvailable = null;
 async function isIsolatedVmAvailable() {
     if (_isolatedVmAvailable !== null)
         return _isolatedVmAvailable;
+    logDebug('Checking isolated-vm availability...', { component: 'Executor' });
     try {
-        // @ts-ignore - isolated-vm is an optional dependency
-        await import('isolated-vm');
+        // We run the check in a separate process because isolated-vm can cause 
+        // segmentation faults if native dependencies or environment are incompatible.
+        // Running it here ensures a crash doesn't take down the main bridge process.
+        const checkScript = `
+      import ivm from 'isolated-vm';
+      const isolate = new ivm.Isolate({ memoryLimit: 8 });
+      isolate.dispose();
+      process.exit(0);
+    `;
+        const { execSync } = await import('node:child_process');
+        execSync(`node -e "${checkScript.replace(/"/g, '\\"').replace(/\n/g, '')}"`, { stdio: 'ignore', timeout: 5000 });
+        logDebug('isolated-vm is available and functional (verified via subprocess)', { component: 'Executor' });
         _isolatedVmAvailable = true;
     }
-    catch {
+    catch (err) {
+        logDebug(`isolated-vm check failed or crashed: ${err instanceof Error ? err.message : String(err)}`, { component: 'Executor' });
         _isolatedVmAvailable = false;
     }
     return _isolatedVmAvailable;
 }
 let _containerRuntimeAvailable = null;
-function isContainerRuntimeAvailable() {
+async function isContainerRuntimeAvailable() {
     if (_containerRuntimeAvailable !== null)
         return _containerRuntimeAvailable;
+    logDebug('Checking container runtime availability...', { component: 'Executor' });
+    // Check for docker or podman
     for (const cmd of ['docker', 'podman']) {
         try {
-            execFileSync(cmd, ['--version'], { stdio: 'ignore', timeout: 5000 });
+            logDebug(`Testing container runtime: ${cmd}`, { component: 'Executor' });
+            // Use 'ps' instead of '--version' because 'ps' requires the 
+            // runtime daemon/service to be actually running and responsive.
+            // execFileSync is okay here as it's a one-time check during startup/first-use.
+            execFileSync(cmd, ['ps'], { stdio: 'ignore', timeout: 3000 });
+            logDebug(`Container runtime "${cmd}" is available and responsive`, { component: 'Executor' });
             _containerRuntimeAvailable = true;
             return true;
         }
-        catch {
-            // not available
+        catch (err) {
+            logDebug(`Container runtime "${cmd}" check failed: ${err instanceof Error ? err.message : String(err)}`, { component: 'Executor' });
+            // not available or not running
         }
     }
+    logDebug('No responsive container runtime found', { component: 'Executor' });
     _containerRuntimeAvailable = false;
     return false;
 }
@@ -50,7 +71,7 @@ const executorRegistry = [
     {
         type: 'container',
         preference: 1,
-        isAvailable: async () => isContainerRuntimeAvailable(),
+        isAvailable: isContainerRuntimeAvailable,
         async create(timeout) {
             const { createContainerExecutor } = await import('../executor/container-executor.js');
             return createContainerExecutor({ timeout });
@@ -79,26 +100,27 @@ const executorRegistry = [
  * Factory function to create an Executor instance.
  *
  * Selection logic:
+ *   - If explicitType is provided, that executor is used (throws if unavailable).
  *   - If EXECUTOR_TYPE is set, that executor is used (throws if unavailable).
  *   - Otherwise, executors are tried in preference order (isolated-vm →
  *     container → vm2) and the first available one is selected.
  *
  * Returns both the executor and metadata about the selection.
  */
-export async function createExecutor(timeout = 30000) {
-    const requested = process.env.EXECUTOR_TYPE?.toLowerCase();
+export async function createExecutor(timeout = 30000, explicitType) {
+    const requested = (explicitType || process.env.EXECUTOR_TYPE?.toLowerCase());
     // Explicit selection — must succeed or throw
     if (requested) {
         const entry = executorRegistry.find(e => e.type === requested);
         if (!entry) {
             const known = executorRegistry.map(e => e.type).join(', ');
-            throw new Error(`Unknown EXECUTOR_TYPE="${requested}". Valid types: ${known}`);
+            throw new Error(`Unknown executor type "${requested}". Valid types: ${known}`);
         }
         const available = await entry.isAvailable();
         if (!available) {
-            throw new Error(`EXECUTOR_TYPE=${requested} but it is not available in this environment.`);
+            throw new Error(`Executor type ${requested} requested but it is not available in this environment.`);
         }
-        logInfo(`Using ${entry.type} executor (EXECUTOR_TYPE=${requested})`, { component: 'Executor' });
+        logInfo(`Using ${entry.type} executor (${explicitType ? 'explicit option' : `EXECUTOR_TYPE=${requested}`})`, { component: 'Executor' });
         return {
             executor: await entry.create(timeout),
             info: { type: entry.type, reason: 'explicit', timeout },

package/dist/mcp/server.d.ts

@@ -15,11 +15,12 @@
  * 6. Exposes the "codemode" tool via MCP protocol downstream
  */
 import { z } from "zod";
+import { type ExecutorType } from "./executor.js";
 import { type MCPServerConfig } from "./mcp-client.js";
-export type { MCPServerConfig };
+export type { MCPServerConfig, ExecutorType };
 /**
  * Convert JSON Schema to Zod schema
  * MCP tools use JSON Schema, but createCodeTool expects Zod schemas
  */
 export declare function jsonSchemaToZod(schema: any): z.ZodType<any>;
-export declare function startCodeModeBridgeServer(serverConfigs: MCPServerConfig[]): Promise<void>;
+export declare function startCodeModeBridgeServer(serverConfigs: MCPServerConfig[], executorType?: ExecutorType): Promise<void>;

package/dist/mcp/server.js

@@ -219,7 +219,7 @@ function convertMCPToolToDescriptor(toolDef, client, toolName, serverName) {
         },
     };
 }
-export async function startCodeModeBridgeServer(serverConfigs) {
+export async function startCodeModeBridgeServer(serverConfigs, executorType) {
     // Enable buffering of stderr output from stdio tools during startup
     enableStderrBuffering();
     const mcp = new McpServer({
@@ -276,7 +276,7 @@ export async function startCodeModeBridgeServer(serverConfigs) {
         }
     }
     // Create the executor using the codemode SDK pattern
-    const { executor, info: executorInfo } = await createExecutor(30000); // 30 second timeout
+    const { executor, info: executorInfo } = await createExecutor(30000, executorType); // 30 second timeout
     // Create the codemode tool using the codemode SDK
     // Pass ToolDescriptor format (with Zod schemas and execute functions)
     logInfo(`Creating codemode tool with ${totalToolCount} tools from ${serverConfigs.length} server(s)`, { component: 'Bridge' });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ruifung/codemode-bridge",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "MCP bridge that connects to upstream MCP servers and exposes tools via a single codemode tool for orchestration",
   "main": "dist/index.js",
   "bin": {