@ruifung/codemode-bridge 1.0.8 → 1.0.9

package/dist/cli/index.js

@@ -19,14 +19,27 @@
 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 { getExecutorStatus } from "../mcp/executor-status.js";
 import * as fs from "node:fs";
 const pkg = JSON.parse(fs.readFileSync(new URL("../../package.json", import.meta.url), "utf-8"));
 const defaultConfigPath = getConfigFilePath();
 const program = new Command();
+// Add logic to get available executors for version output
+let versionString = pkg.version;
+if (process.argv.includes("-V") || process.argv.includes("--version")) {
+    const statuses = await getExecutorStatus();
+    const available = statuses
+        .filter((s) => s.isAvailable)
+        .map((s) => s.type)
+        .join(", ");
+    if (available) {
+        versionString = `${pkg.version} (executors: ${available})`;
+    }
+}
 program
     .name("codemode-bridge")
     .description("Code Mode Bridge CLI - Connects to multiple MCP servers and exposes them as a single tool")
-    .version(pkg.version);
+    .version(versionString);
 // Main 'run' command
 program
     .command("run", { isDefault: true })

package/dist/executor/container-executor.js

@@ -57,18 +57,25 @@ function getScriptPaths() {
 }
 // ── ContainerExecutor ───────────────────────────────────────────────
 export class ContainerExecutor {
+    runtime;
+    image;
+    containerUser;
+    containerCommand;
+    timeout;
+    memoryLimit;
+    cpuLimit;
+    containerId = null;
+    process = null;
+    readline = null;
+    ready = false;
+    /** Resolved when the container sends { type: 'ready' } */
+    readyResolve = null;
+    /** Pending execution — only one at a time */
+    pendingExecution = null;
+    initPromise = null;
     constructor(options = {}) {
-        this.containerId = null;
-        this.process = null;
-        this.readline = null;
-        this.ready = false;
-        /** Resolved when the container sends { type: 'ready' } */
-        this.readyResolve = null;
-        /** Pending execution — only one at a time */
-        this.pendingExecution = null;
-        this.initPromise = null;
         this.timeout = options.timeout ?? 30000;
-        this.memoryLimit = options.memoryLimit ?? '256m';
+        this.memoryLimit = options.memoryLimit ?? '512M';
         this.cpuLimit = options.cpuLimit ?? 1.0;
         this.runtime = detectRuntime(options.runtime);
         // Platform-specific defaults
@@ -171,7 +178,7 @@ export class ContainerExecutor {
             '--user', this.containerUser,
             '--memory', this.memoryLimit,
             `--cpus=${this.cpuLimit}`,
-            '--pids-limit=64', // limit process spawning
+            '--pids-limit=128', // limit process spawning
             '-v', `${scripts.runner}:/app/container-runner.mjs:ro`, // mount runner script
             '-v', `${scripts.worker}:/app/container-worker.mjs:ro`, // mount worker script
             '-w', '/app',

package/dist/executor/deno-executor.js

@@ -37,13 +37,15 @@ function getScriptPaths() {
 }
 // ── DenoExecutor ────────────────────────────────────────────────────
 export class DenoExecutor {
+    denoPath;
+    timeout;
+    process = null;
+    readline = null;
+    ready = false;
+    readyResolve = null;
+    pendingExecution = null;
+    initPromise = null;
     constructor(options = {}) {
-        this.process = null;
-        this.readline = null;
-        this.ready = false;
-        this.readyResolve = null;
-        this.pendingExecution = null;
-        this.initPromise = null;
         this.timeout = options.timeout ?? 30000;
         this.denoPath = detectDeno(options.denoPath);
         this.init().catch(err => {

package/dist/executor/isolated-vm-executor.js

@@ -55,9 +55,11 @@ function stringify(value) {
  * - Explicit serialization boundaries
  */
 export class IsolatedVmExecutor {
+    isolate;
+    context = null;
+    metrics = null;
+    options;
     constructor(options = {}) {
-        this.context = null;
-        this.metrics = null;
         this.options = {
             memoryLimit: options.memoryLimit ?? 128,
             inspector: options.inspector ?? false,

package/dist/executor/vm2-executor.js

@@ -9,6 +9,7 @@ import { wrapCode } from "./wrap-code.js";
  * Runs LLM-generated code in an isolated sandbox with access to tools via codemode.* namespace
  */
 export class VM2Executor {
+    timeout;
     constructor(timeout = 30000) {
         this.timeout = timeout;
     }

package/dist/mcp/executor-status.d.ts

@@ -0,0 +1,6 @@
+export type ExecutorType = 'isolated-vm' | 'container' | 'deno' | 'vm2';
+export interface ExecutorStatus {
+    type: ExecutorType;
+    isAvailable: boolean;
+}
+export declare function getExecutorStatus(): Promise<ExecutorStatus[]>;

package/dist/mcp/executor-status.js

@@ -0,0 +1,58 @@
+import { execFileSync } from "node:child_process";
+import { isNode, isDeno, isBun, getNodeMajorVersion } from "../utils/env.js";
+async function isDenoAvailable() {
+    return isDeno();
+}
+async function isIsolatedVmAvailable() {
+    const majorVersion = getNodeMajorVersion();
+    const isEvenVersion = majorVersion > 0 && majorVersion % 2 === 0;
+    if (!isNode() || !isEvenVersion) {
+        return false;
+    }
+    try {
+        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: 2000 });
+        return true;
+    }
+    catch (err) {
+        return false;
+    }
+}
+async function isContainerRuntimeAvailable() {
+    for (const cmd of ['docker', 'podman']) {
+        try {
+            execFileSync(cmd, ['ps'], { stdio: 'ignore', timeout: 2000 });
+            return true;
+        }
+        catch (err) {
+            // not available
+        }
+    }
+    return false;
+}
+async function isVM2Available() {
+    if (isBun())
+        return false;
+    try {
+        await import('vm2');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function getExecutorStatus() {
+    const statuses = [
+        { type: 'deno', isAvailable: await isDenoAvailable() },
+        { type: 'isolated-vm', isAvailable: await isIsolatedVmAvailable() },
+        { type: 'container', isAvailable: await isContainerRuntimeAvailable() },
+        { type: 'vm2', isAvailable: await isVM2Available() },
+    ];
+    return statuses;
+}

package/dist/mcp/mcp-client.js

@@ -19,6 +19,15 @@ import { logDebug, logInfo } from "../utils/logger.js";
  * Supports both pre-registered clients and dynamic client registration (RFC 7591)
  */
 class SimpleOAuthProvider {
+    config;
+    serverUrl;
+    static DEFAULT_REDIRECT_URL = 'http://localhost:3000/oauth/callback';
+    _tokens;
+    _codeVerifier;
+    _clientInfo;
+    _discoveryState;
+    _callbackServer;
+    _finishAuthCallback;
     constructor(config, serverUrl) {
         this.config = config;
         this.serverUrl = serverUrl;
@@ -196,15 +205,17 @@ class SimpleOAuthProvider {
         return undefined;
     }
 }
-SimpleOAuthProvider.DEFAULT_REDIRECT_URL = 'http://localhost:3000/oauth/callback';
 /**
  * MCP Client wrapper using official SDK
  */
 export class MCPClient {
+    config;
+    client;
+    transport = null;
+    connected = false;
+    oauthProvider;
     constructor(config) {
         this.config = config;
-        this.transport = null;
-        this.connected = false;
         this.client = new Client({
             name: `codemode-bridge-client-${config.name}`,
             version: "1.0.0",

package/dist/mcp/oauth-handler.js

@@ -12,9 +12,11 @@ import { URL } from 'node:url';
  * Loopback HTTP server that listens for OAuth2 redirect callbacks
  */
 export class OAuthCallbackServer {
+    server;
+    port = 0; // 0 means OS will assign an available port
+    host = 'localhost';
+    pendingAuthorization;
     constructor(redirectUrl) {
-        this.port = 0; // 0 means OS will assign an available port
-        this.host = 'localhost';
         // Parse redirect URL to extract host and port
         if (redirectUrl) {
             try {

package/dist/mcp/token-persistence.js

@@ -11,8 +11,10 @@ import { homedir } from 'node:os';
  * Manages OAuth token storage for MCP server connections
  */
 export class TokenPersistence {
+    configDir;
+    tokenFile;
+    storage = {};
     constructor() {
-        this.storage = {};
         this.configDir = join(homedir(), '.config', 'codemode-bridge');
         this.tokenFile = join(this.configDir, 'mcp-tokens.json');
         this.loadStorage();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ruifung/codemode-bridge",
-  "version": "1.0.8",
+  "version": "1.0.9",
   "description": "MCP bridge that connects to upstream MCP servers and exposes tools via a single codemode tool for orchestration",
   "main": "dist/index.js",
   "bin": {
@@ -14,8 +14,11 @@
     "build": "tsc",
     "prepare": "npm run build",
     "dev": "tsx src/cli/index.ts",
+    "dev:bun": "bun run src/cli/index.ts",
+    "dev:deno": "deno run --allow-net --allow-read src/cli/index.ts",
     "test": "vitest",
-    "test:e2e": "vitest run src/mcp/e2e-bridge-runner.test.ts --reporter=verbose"
+    "test:bun": "bun test",
+    "test:deno": "deno run -A npm:vitest"
   },
   "keywords": [
     "mcp",