@ruifung/codemode-bridge 1.0.6 → 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' });

package/dist/cli/index.js

@@ -34,9 +34,10 @@ program
     .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();

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.6",
+  "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": {