@ruifung/codemode-bridge 1.0.3-1

package/dist/mcp/executor.js

@@ -0,0 +1,121 @@
+/**
+ * Executor factory and registry for Codemode SDK
+ * Selects the best available executor (isolated-vm → container → vm2)
+ */
+import { execFileSync } from "node:child_process";
+import { logInfo } from "../utils/logger.js";
+// ── Availability checks (cached) ────────────────────────────────────
+let _isolatedVmAvailable = null;
+async function isIsolatedVmAvailable() {
+    if (_isolatedVmAvailable !== null)
+        return _isolatedVmAvailable;
+    try {
+        // @ts-ignore - isolated-vm is an optional dependency
+        await import('isolated-vm');
+        _isolatedVmAvailable = true;
+    }
+    catch {
+        _isolatedVmAvailable = false;
+    }
+    return _isolatedVmAvailable;
+}
+let _containerRuntimeAvailable = null;
+function isContainerRuntimeAvailable() {
+    if (_containerRuntimeAvailable !== null)
+        return _containerRuntimeAvailable;
+    for (const cmd of ['docker', 'podman']) {
+        try {
+            execFileSync(cmd, ['--version'], { stdio: 'ignore', timeout: 5000 });
+            _containerRuntimeAvailable = true;
+            return true;
+        }
+        catch {
+            // not available
+        }
+    }
+    _containerRuntimeAvailable = false;
+    return false;
+}
+// ── Executor registry (sorted by preference, lowest first) ─────────
+const executorRegistry = [
+    {
+        type: 'isolated-vm',
+        preference: 0,
+        isAvailable: isIsolatedVmAvailable,
+        async create(timeout) {
+            const { createIsolatedVmExecutor } = await import('../executor/isolated-vm-executor.js');
+            return createIsolatedVmExecutor({ timeout });
+        },
+    },
+    {
+        type: 'container',
+        preference: 1,
+        isAvailable: async () => isContainerRuntimeAvailable(),
+        async create(timeout) {
+            const { createContainerExecutor } = await import('../executor/container-executor.js');
+            return createContainerExecutor({ timeout });
+        },
+    },
+    {
+        type: 'vm2',
+        preference: 2,
+        isAvailable: async () => {
+            try {
+                await import('vm2');
+                return true;
+            }
+            catch {
+                return false;
+            }
+        },
+        async create(timeout) {
+            const { createVM2Executor } = await import('../executor/vm2-executor.js');
+            return createVM2Executor({ timeout });
+        },
+    },
+];
+// ── Factory ─────────────────────────────────────────────────────────
+/**
+ * Factory function to create an Executor instance.
+ *
+ * Selection logic:
+ *   - 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();
+    // 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}`);
+        }
+        const available = await entry.isAvailable();
+        if (!available) {
+            throw new Error(`EXECUTOR_TYPE=${requested} but it is not available in this environment.`);
+        }
+        logInfo(`Using ${entry.type} executor (EXECUTOR_TYPE=${requested})`, { component: 'Executor' });
+        return {
+            executor: await entry.create(timeout),
+            info: { type: entry.type, reason: 'explicit', timeout },
+        };
+    }
+    // Auto-detect — walk registry in preference order
+    const sorted = [...executorRegistry].sort((a, b) => a.preference - b.preference);
+    for (const entry of sorted) {
+        const available = await entry.isAvailable();
+        if (available) {
+            logInfo(`Using ${entry.type} executor (auto-detected)`, { component: 'Executor' });
+            return {
+                executor: await entry.create(timeout),
+                info: { type: entry.type, reason: 'auto-detected', timeout },
+            };
+        }
+    }
+    // Should never happen since vm2 is always available
+    throw new Error('No executor implementation available.');
+}

package/dist/mcp/mcp-adapter.d.ts

@@ -0,0 +1,12 @@
+/**
+ * MCP Adapter - Shim layer between AI SDK Tools and MCP Protocol
+ *
+ * Converts AI SDK Tool format (from @cloudflare/codemode) to MCP protocol format
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { Tool } from "ai";
+/**
+ * Adapts an AI SDK Tool to MCP protocol format
+ * Takes a codemode SDK tool and registers it with the MCP server
+ */
+export declare function adaptAISDKToolToMCP(mcp: McpServer, tool: Tool<any, any>): Promise<void>;

package/dist/mcp/mcp-adapter.js

@@ -0,0 +1,49 @@
+/**
+ * MCP Adapter - Shim layer between AI SDK Tools and MCP Protocol
+ *
+ * Converts AI SDK Tool format (from @cloudflare/codemode) to MCP protocol format
+ */
+import { z } from "zod";
+/**
+ * Adapts an AI SDK Tool to MCP protocol format
+ * Takes a codemode SDK tool and registers it with the MCP server
+ */
+export async function adaptAISDKToolToMCP(mcp, tool) {
+    // The tool from createCodeTool has:
+    // - tool.description
+    // - tool.inputSchema (Zod schema)
+    // - tool.execute (async function)
+    // Extract tool name from description or use default
+    const toolName = "eval";
+    // Register the tool with the MCP server
+    mcp.registerTool(toolName, {
+        description: tool.description || "Execute code with tool orchestration",
+        // Use the Zod schema directly - MCP's registerTool handles conversion
+        // Cast to any to avoid schema compatibility issues between AI SDK and MCP
+        inputSchema: tool.inputSchema || z.object({}).strict(),
+    }, 
+    // Handler for MCP tool calls
+    async (args) => {
+        try {
+            // Call the AI SDK tool's execute method
+            // The execute function expects the input args
+            const result = await tool.execute(args);
+            // If result is a string (from fallback tool), use as-is
+            // Otherwise format to JSON
+            const text = typeof result === 'string' ? result : JSON.stringify(result, null, 2);
+            return {
+                content: [{ type: "text", text }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Tool execution failed: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    });
+}

package/dist/mcp/mcp-client.d.ts

@@ -0,0 +1,85 @@
+/**
+ * MCP Client - Wrapper around official MCP SDK for connecting to upstream MCP servers
+ *
+ * This client:
+ * 1. Uses the official @modelcontextprotocol/sdk Client API
+ * 2. Supports stdio, HTTP (Streamable HTTP), and SSE transports
+ * 3. Returns tools in native MCP format (JSON Schema for inputSchema)
+ * 4. Provides tool execution via callTool()
+ */
+/**
+ * OAuth2 configuration for HTTP/SSE transports
+ */
+export interface OAuth2Config {
+    /**
+     * OAuth client ID (optional for dynamic registration).
+     * If not provided, the client will attempt dynamic registration with the server.
+     */
+    clientId?: string;
+    /** OAuth client secret (optional for public clients) */
+    clientSecret?: string;
+    /**
+     * OAuth redirect URL for authorization flow.
+     * Defaults to "http://localhost:3000/oauth/callback" if not provided.
+     */
+    redirectUrl?: string;
+    /** OAuth scopes to request */
+    scope?: string;
+    /** Grant type: 'authorization_code' or 'client_credentials' */
+    grantType?: 'authorization_code' | 'client_credentials';
+}
+/**
+ * Configuration for an MCP server to connect to upstream
+ */
+export interface MCPServerConfig {
+    name: string;
+    type: "stdio" | "http" | "sse";
+    command?: string;
+    args?: string[];
+    url?: string;
+    env?: Record<string, string>;
+    /** OAuth2 configuration (only for http/sse transports) */
+    oauth?: OAuth2Config;
+}
+/**
+ * MCP Tool definition in native format
+ */
+export interface MCPTool {
+    name: string;
+    description?: string;
+    inputSchema: any;
+}
+/**
+ * MCP Client wrapper using official SDK
+ */
+export declare class MCPClient {
+    private config;
+    private client;
+    private transport;
+    private connected;
+    private oauthProvider?;
+    constructor(config: MCPServerConfig);
+    /**
+     * Authenticate with OAuth server and obtain tokens without connecting the full client.
+     * This is useful for CLI auth flows where we just want to get tokens without initializing
+     * the full MCP client.
+     */
+    authenticateOAuth(): Promise<void>;
+    /**
+     * Connect to the upstream MCP server
+     */
+    connect(): Promise<void>;
+    /**
+     * List all tools from the upstream server
+     * Returns tools in native MCP format with JSON Schema
+     */
+    listTools(): Promise<MCPTool[]>;
+    /**
+     * Call a tool on the upstream server
+     */
+    callTool(name: string, args: any): Promise<any>;
+    /**
+     * Close the connection to the upstream server
+     */
+    close(): Promise<void>;
+}