@ruifung/codemode-bridge 1.0.3-1

package/dist/mcp/server.js

@@ -0,0 +1,322 @@
+/**
+ * MCP Server - Exposes the Code Mode bridge as an MCP server
+ *
+ * Architecture:
+ * - Upstream: Use official MCP SDK's Client to connect to and collect tools from other MCP servers
+ * - Orchestration: Pass collected tools to codemode SDK's createCodeTool()
+ * - Downstream: Use MCP SDK to expose the codemode tool via MCP protocol (stdio transport)
+ *
+ * This server:
+ * 1. Connects to upstream MCP servers using official MCP SDK Client
+ * 2. Collects tools from all upstream servers in native MCP format (JSON Schema)
+ * 3. Converts tools to ToolDescriptor format (with Zod schemas)
+ * 4. Uses @cloudflare/codemode SDK to create the "codemode" tool with those tools
+ * 5. Adapts the codemode SDK's AI SDK Tool to MCP protocol using a shim layer
+ * 6. Exposes the "codemode" tool via MCP protocol downstream
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { createCodeTool } from "@cloudflare/codemode/ai";
+import { z } from "zod";
+import { createExecutor } from "./executor.js";
+import { adaptAISDKToolToMCP } from "./mcp-adapter.js";
+import { MCPClient } from "./mcp-client.js";
+import { logDebug, logError, logInfo, enableStderrBuffering } from "../utils/logger.js";
+/**
+ * Convert JSON Schema to Zod schema
+ * MCP tools use JSON Schema, but createCodeTool expects Zod schemas
+ */
+export function jsonSchemaToZod(schema) {
+    // Handle null/undefined
+    if (!schema) {
+        return z.object({}).strict();
+    }
+    // Handle object type
+    if (schema.type === "object" || !schema.type) {
+        const props = {};
+        if (schema.properties) {
+            for (const [key, prop] of Object.entries(schema.properties)) {
+                props[key] = jsonSchemaToZod(prop);
+            }
+        }
+        if (schema.required && Array.isArray(schema.required)) {
+            const required = new Set(schema.required);
+            const finalProps = {};
+            for (const [key, zodSchema] of Object.entries(props)) {
+                if (required.has(key)) {
+                    finalProps[key] = zodSchema;
+                }
+                else {
+                    finalProps[key] = zodSchema.optional();
+                }
+            }
+            return z.object(finalProps).strict();
+        }
+        // Make all fields optional if no required list
+        const optionalProps = {};
+        for (const [key, zodSchema] of Object.entries(props)) {
+            optionalProps[key] = zodSchema.optional();
+        }
+        return z.object(optionalProps).strict();
+    }
+    // Handle array type
+    if (schema.type === "array") {
+        const itemSchema = schema.items ? jsonSchemaToZod(schema.items) : z.any();
+        let arraySchema = z.array(itemSchema);
+        // Apply array constraints
+        if (typeof schema.minItems === "number") {
+            arraySchema = arraySchema.min(schema.minItems);
+        }
+        if (typeof schema.maxItems === "number") {
+            arraySchema = arraySchema.max(schema.maxItems);
+        }
+        return arraySchema;
+    }
+    // Handle string type
+    if (schema.type === "string") {
+        let stringSchema = z.string();
+        // Handle enum
+        if (schema.enum && Array.isArray(schema.enum)) {
+            return z.enum(schema.enum);
+        }
+        // Apply string format constraints
+        if (schema.format) {
+            switch (schema.format) {
+                case "email":
+                    stringSchema = stringSchema.email();
+                    break;
+                case "uuid":
+                    stringSchema = stringSchema.uuid();
+                    break;
+                case "url":
+                    stringSchema = stringSchema.url();
+                    break;
+                case "date-time":
+                    stringSchema = stringSchema.datetime();
+                    break;
+            }
+        }
+        // Apply string length constraints
+        if (typeof schema.minLength === "number") {
+            stringSchema = stringSchema.min(schema.minLength);
+        }
+        if (typeof schema.maxLength === "number") {
+            stringSchema = stringSchema.max(schema.maxLength);
+        }
+        if (schema.pattern) {
+            stringSchema = stringSchema.regex(new RegExp(schema.pattern));
+        }
+        return stringSchema;
+    }
+    // Handle number type
+    if (schema.type === "number") {
+        let numberSchema = z.number();
+        // Apply number constraints
+        if (typeof schema.minimum === "number") {
+            numberSchema = numberSchema.min(schema.minimum);
+        }
+        if (typeof schema.maximum === "number") {
+            numberSchema = numberSchema.max(schema.maximum);
+        }
+        if (typeof schema.multipleOf === "number") {
+            numberSchema = numberSchema.multipleOf(schema.multipleOf);
+        }
+        return numberSchema;
+    }
+    // Handle integer type
+    if (schema.type === "integer") {
+        let intSchema = z.number().int();
+        // Apply number constraints
+        if (typeof schema.minimum === "number") {
+            intSchema = intSchema.min(schema.minimum);
+        }
+        if (typeof schema.maximum === "number") {
+            intSchema = intSchema.max(schema.maximum);
+        }
+        if (typeof schema.multipleOf === "number") {
+            intSchema = intSchema.multipleOf(schema.multipleOf);
+        }
+        return intSchema;
+    }
+    // Handle boolean type
+    if (schema.type === "boolean") {
+        return z.boolean();
+    }
+    // Handle null type
+    if (schema.type === "null") {
+        return z.null();
+    }
+    // Handle anyOf (union types)
+    if (schema.anyOf && Array.isArray(schema.anyOf)) {
+        const schemas = schema.anyOf.map((s) => jsonSchemaToZod(s));
+        return z.union(schemas);
+    }
+    // Handle oneOf (discriminated union)
+    if (schema.oneOf && Array.isArray(schema.oneOf)) {
+        const schemas = schema.oneOf.map((s) => jsonSchemaToZod(s));
+        return z.union(schemas);
+    }
+    // Handle allOf (intersection types)
+    if (schema.allOf && Array.isArray(schema.allOf)) {
+        // Zod doesn't have native intersection for objects, so merge them
+        let merged = z.object({});
+        for (const subSchema of schema.allOf) {
+            const zodSchema = jsonSchemaToZod(subSchema);
+            merged = merged.and(zodSchema);
+        }
+        return merged;
+    }
+    // Handle enum for non-string types
+    if (schema.enum && Array.isArray(schema.enum)) {
+        if (schema.enum.length === 1) {
+            return z.literal(schema.enum[0]);
+        }
+        // Create union of literals
+        const literals = schema.enum.map((val) => z.literal(val));
+        return z.union(literals);
+    }
+    // Default to any
+    return z.any();
+}
+/**
+ * Convert native MCP tool definitions to ToolDescriptor format
+ * that createCodeTool() expects
+ */
+function convertMCPToolToDescriptor(toolDef, client, toolName, serverName) {
+    return {
+        description: toolDef.description || "",
+        inputSchema: jsonSchemaToZod(toolDef.inputSchema),
+        execute: async (args) => {
+            // Log the tool invocation
+            logDebug(`Calling tool: ${serverName}__${toolName}`, {
+                component: 'Tool Execution',
+                server: serverName,
+                tool: toolName,
+                args: JSON.stringify(args)
+            });
+            try {
+                // Execute the tool on the upstream server using the MCP client
+                const result = await client.callTool(toolName, args);
+                // Log successful execution
+                logDebug(`Tool completed: ${serverName}__${toolName}`, {
+                    component: 'Tool Execution',
+                    server: serverName,
+                    tool: toolName,
+                    resultType: typeof result,
+                    resultSize: JSON.stringify(result).length
+                });
+                return result;
+            }
+            catch (error) {
+                logDebug(`Tool failed: ${serverName}__${toolName}`, {
+                    component: 'Tool Execution',
+                    server: serverName,
+                    tool: toolName,
+                    error: error instanceof Error ? error.message : String(error)
+                });
+                throw error;
+            }
+        },
+    };
+}
+export async function startCodeModeBridgeServer(serverConfigs) {
+    // Enable buffering of stderr output from stdio tools during startup
+    enableStderrBuffering();
+    const mcp = new McpServer({
+        name: "codemode-bridge",
+        version: "1.0.0",
+    });
+    // Collect all tools from upstream MCP servers using official MCP SDK
+    const allToolDescriptors = {};
+    const toolsByServer = {}; // Track tools grouped by server
+    const mcpClients = []; // Keep track of clients for cleanup
+    let totalToolCount = 0;
+    // Initialize all connections in parallel
+    const connectionPromises = serverConfigs.map(async (config) => {
+        try {
+            // Create client for this upstream MCP server using official SDK
+            const client = new MCPClient(config);
+            // Connect to the upstream server
+            await client.connect();
+            mcpClients.push(client);
+            // Get tools from this server in native MCP format (JSON Schema)
+            const serverTools = await client.listTools();
+            const toolCount = serverTools.length;
+            totalToolCount += toolCount;
+            logDebug(`Server "${config.name}" has ${toolCount} tools`, { component: 'Bridge' });
+            // Track tools for this server
+            toolsByServer[config.name] = [];
+            // Namespace tools by server name to avoid conflicts
+            // e.g., kubernetes.get_pod -> kubernetes__get_pod
+            // Convert native MCP tools (JSON Schema) to ToolDescriptor format (Zod)
+            for (const tool of serverTools) {
+                const namespacedName = `${config.name}__${tool.name}`;
+                toolsByServer[config.name].push(namespacedName);
+                // Convert the native MCP tool to ToolDescriptor format
+                const descriptor = convertMCPToolToDescriptor(tool, client, tool.name, config.name);
+                allToolDescriptors[namespacedName] = descriptor;
+            }
+            return { config: config.name, toolCount, success: true };
+        }
+        catch (error) {
+            logError(`Failed to connect to "${config.name}"`, error instanceof Error ? error : { error: String(error) });
+            // Continue with other servers instead of failing completely
+            return { config: config.name, toolCount: 0, success: false };
+        }
+    });
+    // Wait for all connections to initialize in parallel
+    const results = await Promise.all(connectionPromises);
+    // Recalculate total tool count from results (in case totalToolCount wasn't updated due to timing)
+    totalToolCount = results.reduce((sum, result) => sum + (result?.toolCount || 0), 0);
+    logInfo(`Total: ${totalToolCount} tools from ${serverConfigs.length} server(s)`, { component: 'Bridge' });
+    // Log tools grouped by server
+    for (const [serverName, tools] of Object.entries(toolsByServer)) {
+        if (tools.length > 0) {
+            logInfo(`${serverName}: ${tools.join(', ')}`, { component: 'Bridge', server: serverName });
+        }
+    }
+    // Create the executor using the codemode SDK pattern
+    const { executor, info: executorInfo } = await createExecutor(30000); // 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' });
+    const codemodeTool = createCodeTool({
+        tools: allToolDescriptors,
+        executor,
+        // Let the SDK auto-generate description from available tools
+    });
+    // Adapt the AI SDK Tool to MCP protocol format and register it
+    // The adaptAISDKToolToMCP function handles the protocol conversion
+    await adaptAISDKToolToMCP(mcp, codemodeTool);
+    // Register the status tool — returns executor mode, upstream servers, and tool counts
+    mcp.registerTool("status", {
+        description: "Get the current status of the codemode bridge: executor mode, upstream server connections, and available tools.",
+        inputSchema: z.object({}).strict(),
+    }, async () => {
+        const servers = Object.entries(toolsByServer).map(([name, tools]) => ({
+            name,
+            toolCount: tools.length,
+            tools,
+        }));
+        const status = {
+            executor: {
+                type: executorInfo.type,
+                reason: executorInfo.reason,
+                timeout: executorInfo.timeout,
+            },
+            servers,
+            totalTools: totalToolCount,
+        };
+        return {
+            content: [{ type: "text", text: JSON.stringify(status, null, 2) }],
+        };
+    });
+    // Connect downstream MCP transport (what the client connects to)
+    const transport = new StdioServerTransport();
+    await mcp.connect(transport);
+    logInfo(`Ready on stdio transport`, { component: 'Bridge' });
+    logDebug(`Registering tool request handler`, {
+        component: 'Bridge'
+    });
+    logInfo(`Exposing 'eval' and 'status' tools`, { component: 'Bridge' });
+}

package/dist/mcp/token-persistence.d.ts

@@ -0,0 +1,57 @@
+/**
+ * OAuth2 Token Storage
+ *
+ * Persists OAuth tokens and client information to disk for reuse across sessions.
+ * Stored in ~/.config/codemode-bridge/mcp-tokens.json
+ */
+import type { OAuthTokens, OAuthClientInformationMixed } from '@modelcontextprotocol/sdk/shared/auth.js';
+/**
+ * Manages OAuth token storage for MCP server connections
+ */
+export declare class TokenPersistence {
+    private configDir;
+    private tokenFile;
+    private storage;
+    constructor();
+    /**
+     * Load tokens from disk
+     */
+    private loadStorage;
+    /**
+     * Save storage to disk
+     */
+    private saveStorage;
+    /**
+     * Get stored client information for a server
+     */
+    getClientInformation(serverUrl: string): OAuthClientInformationMixed | undefined;
+    /**
+     * Save client information for a server
+     */
+    saveClientInformation(serverUrl: string, clientInfo: OAuthClientInformationMixed): void;
+    /**
+     * Get stored tokens for a server
+     */
+    getTokens(serverUrl: string): OAuthTokens | undefined;
+    /**
+     * Save tokens for a server
+     */
+    saveTokens(serverUrl: string, tokens: OAuthTokens): void;
+    /**
+     * Clear all tokens for a server (useful when revoked)
+     */
+    clearTokens(serverUrl: string): void;
+    /**
+     * Clear all information for a server
+     */
+    clearAll(serverUrl: string): void;
+    /**
+     * Check if a server has stored tokens (and whether they're expired)
+     * Returns { exists: boolean, isExpired: boolean }
+     */
+    getTokenStatus(serverUrl: string): {
+        exists: boolean;
+        isExpired: boolean;
+    };
+}
+export declare const tokenPersistence: TokenPersistence;

package/dist/mcp/token-persistence.js

@@ -0,0 +1,131 @@
+/**
+ * OAuth2 Token Storage
+ *
+ * Persists OAuth tokens and client information to disk for reuse across sessions.
+ * Stored in ~/.config/codemode-bridge/mcp-tokens.json
+ */
+import { existsSync, mkdirSync, writeFileSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+/**
+ * Manages OAuth token storage for MCP server connections
+ */
+export class TokenPersistence {
+    constructor() {
+        this.storage = {};
+        this.configDir = join(homedir(), '.config', 'codemode-bridge');
+        this.tokenFile = join(this.configDir, 'mcp-tokens.json');
+        this.loadStorage();
+    }
+    /**
+     * Load tokens from disk
+     */
+    loadStorage() {
+        try {
+            if (existsSync(this.tokenFile)) {
+                const content = readFileSync(this.tokenFile, 'utf-8');
+                this.storage = JSON.parse(content);
+            }
+        }
+        catch (error) {
+            console.warn('Failed to load token storage:', error);
+            this.storage = {};
+        }
+    }
+    /**
+     * Save storage to disk
+     */
+    saveStorage() {
+        try {
+            // Ensure directory exists
+            if (!existsSync(this.configDir)) {
+                mkdirSync(this.configDir, { recursive: true });
+            }
+            // Write tokens file
+            writeFileSync(this.tokenFile, JSON.stringify(this.storage, null, 2));
+        }
+        catch (error) {
+            console.warn('Failed to save token storage:', error);
+        }
+    }
+    /**
+     * Get stored client information for a server
+     */
+    getClientInformation(serverUrl) {
+        return this.storage[serverUrl]?.clientInformation;
+    }
+    /**
+     * Save client information for a server
+     */
+    saveClientInformation(serverUrl, clientInfo) {
+        if (!this.storage[serverUrl]) {
+            this.storage[serverUrl] = { lastUpdated: Date.now() };
+        }
+        this.storage[serverUrl].clientInformation = clientInfo;
+        this.storage[serverUrl].lastUpdated = Date.now();
+        this.saveStorage();
+    }
+    /**
+     * Get stored tokens for a server
+     */
+    getTokens(serverUrl) {
+        const info = this.storage[serverUrl];
+        if (!info?.tokens) {
+            return undefined;
+        }
+        // Check if tokens have expired
+        const tokens = info.tokens;
+        const expiresAt = info.lastUpdated + ((tokens.expires_in || 3600) * 1000);
+        if (expiresAt < Date.now()) {
+            // Tokens expired - don't return them
+            // The OAuth provider will request new ones
+            delete info.tokens;
+            this.saveStorage();
+            return undefined;
+        }
+        return tokens;
+    }
+    /**
+     * Save tokens for a server
+     */
+    saveTokens(serverUrl, tokens) {
+        if (!this.storage[serverUrl]) {
+            this.storage[serverUrl] = { lastUpdated: Date.now() };
+        }
+        this.storage[serverUrl].tokens = tokens;
+        this.storage[serverUrl].lastUpdated = Date.now();
+        this.saveStorage();
+    }
+    /**
+     * Clear all tokens for a server (useful when revoked)
+     */
+    clearTokens(serverUrl) {
+        if (this.storage[serverUrl]) {
+            delete this.storage[serverUrl].tokens;
+            this.saveStorage();
+        }
+    }
+    /**
+     * Clear all information for a server
+     */
+    clearAll(serverUrl) {
+        delete this.storage[serverUrl];
+        this.saveStorage();
+    }
+    /**
+     * Check if a server has stored tokens (and whether they're expired)
+     * Returns { exists: boolean, isExpired: boolean }
+     */
+    getTokenStatus(serverUrl) {
+        const info = this.storage[serverUrl];
+        if (!info?.tokens) {
+            return { exists: false, isExpired: false };
+        }
+        const tokens = info.tokens;
+        const expiresAt = info.lastUpdated + ((tokens.expires_in || 3600) * 1000);
+        const isExpired = expiresAt < Date.now();
+        return { exists: true, isExpired };
+    }
+}
+// Singleton instance
+export const tokenPersistence = new TokenPersistence();

package/dist/utils/logger.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Logger utility using Winston
+ *
+ * Provides structured logging with debug mode support
+ * All logs go to stderr to avoid interfering with JSON-RPC protocol on stdout
+ */
+import winston from 'winston';
+/**
+ * Initialize the logger
+ */
+export declare function initializeLogger(debug?: boolean): void;
+/**
+ * Get the logger instance
+ */
+export declare function getLogger(): winston.Logger;
+/**
+ * Check if debug mode is enabled
+ */
+export declare function isDebugEnabled(): boolean;
+/**
+ * Enable buffering of stderr output from stdio tools
+ * Useful for deferring tool output until after startup is complete
+ */
+export declare function enableStderrBuffering(): void;
+/**
+ * Disable buffering and flush all buffered stderr messages
+ */
+export declare function flushStderrBuffer(): void;
+/**
+ * Log an info message
+ */
+export declare function logInfo(message: string, meta?: Record<string, any>): void;
+/**
+ * Log a debug message
+ */
+export declare function logDebug(message: string, meta?: Record<string, any>): void;
+/**
+ * Log a warning message
+ */
+export declare function logWarn(message: string, meta?: Record<string, any>): void;
+/**
+ * Log an error message
+ */
+export declare function logError(message: string, error?: Error | Record<string, any>): void;

package/dist/utils/logger.js

@@ -0,0 +1,123 @@
+/**
+ * Logger utility using Winston
+ *
+ * Provides structured logging with debug mode support
+ * All logs go to stderr to avoid interfering with JSON-RPC protocol on stdout
+ */
+import winston from 'winston';
+import chalk from 'chalk';
+let logger;
+let debugMode = false;
+let stderrBufferingEnabled = false;
+let stderrBuffer = [];
+/**
+ * Initialize the logger
+ */
+export function initializeLogger(debug = false) {
+    debugMode = debug;
+    const level = debug ? 'debug' : 'info';
+    logger = winston.createLogger({
+        level,
+        format: winston.format.combine(winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }), winston.format.errors({ stack: true }), winston.format.printf(({ level, message, timestamp, component, suppressEarly, ...meta }) => {
+            // Color the level based on severity
+            let coloredLevel;
+            switch (level.toUpperCase()) {
+                case 'ERROR':
+                    coloredLevel = chalk.red(`[${level.toUpperCase()}]`);
+                    break;
+                case 'WARN':
+                    coloredLevel = chalk.yellow(`[${level.toUpperCase()}]`);
+                    break;
+                case 'INFO':
+                    coloredLevel = chalk.green(`[${level.toUpperCase()}]`);
+                    break;
+                case 'DEBUG':
+                    coloredLevel = chalk.blue(`[${level.toUpperCase()}]`);
+                    break;
+                default:
+                    coloredLevel = `[${level.toUpperCase()}]`;
+            }
+            // Build the prefix with timestamp (debug only)
+            const timestampStr = debug ? `[${timestamp}] ` : '';
+            // Add component prefix if provided (colored in cyan)
+            const componentStr = component ? ` ${chalk.cyan(`[${component}]`)}` : '';
+            // Include remaining metadata if present (excluding suppressEarly which is internal)
+            const metaStr = Object.keys(meta).length > 0 ? ` ${JSON.stringify(meta)}` : '';
+            return `${timestampStr}${coloredLevel}${componentStr} ${message}${metaStr}`.trim();
+        })),
+        transports: [
+            // Always write to stderr to avoid interfering with stdout (used for JSON-RPC protocol)
+            new winston.transports.Stream({ stream: process.stderr }),
+        ],
+    });
+}
+/**
+ * Get the logger instance
+ */
+export function getLogger() {
+    if (!logger) {
+        initializeLogger();
+    }
+    return logger;
+}
+/**
+ * Check if debug mode is enabled
+ */
+export function isDebugEnabled() {
+    return debugMode;
+}
+/**
+ * Enable buffering of stderr output from stdio tools
+ * Useful for deferring tool output until after startup is complete
+ */
+export function enableStderrBuffering() {
+    stderrBufferingEnabled = true;
+    stderrBuffer = [];
+}
+/**
+ * Disable buffering and flush all buffered stderr messages
+ */
+export function flushStderrBuffer() {
+    stderrBufferingEnabled = false;
+    const buffered = stderrBuffer;
+    stderrBuffer = [];
+    // Log all buffered messages directly without going through logInfo to avoid recursion
+    for (const { message, meta } of buffered) {
+        getLogger().info(message, meta);
+    }
+}
+/**
+ * Log an info message
+ */
+export function logInfo(message, meta) {
+    // Buffer logs marked with suppressEarly during startup if buffering is enabled
+    if (stderrBufferingEnabled && meta?.suppressEarly) {
+        stderrBuffer.push({ message, meta });
+    }
+    else {
+        getLogger().info(message, meta);
+    }
+}
+/**
+ * Log a debug message
+ */
+export function logDebug(message, meta) {
+    getLogger().debug(message, meta);
+}
+/**
+ * Log a warning message
+ */
+export function logWarn(message, meta) {
+    getLogger().warn(message, meta);
+}
+/**
+ * Log an error message
+ */
+export function logError(message, error) {
+    if (error instanceof Error) {
+        getLogger().error(message, { error: error.message, stack: error.stack });
+    }
+    else {
+        getLogger().error(message, error);
+    }
+}