@ruifung/codemode-bridge 1.0.3-1

package/dist/cli/commands.js

@@ -0,0 +1,436 @@
+/**
+ * CLI Commands for Code Mode Bridge
+ *
+ * Implements subcommands for managing and running the bridge
+ */
+import chalk from "chalk";
+import * as fs from "fs";
+import * as path from "path";
+import { loadConfig, saveConfig, addServer, removeServer, updateServer, getServer, listServers, validateServer, getConfigFilePath, } from "./config-manager.js";
+import { startCodeModeBridgeServer } from "../mcp/server.js";
+import { getServerConfig } from "../mcp/config.js";
+import { initializeLogger, logInfo, logError, flushStderrBuffer } from "../utils/logger.js";
+import { tokenPersistence } from "../mcp/token-persistence.js";
+import { MCPClient } from "../mcp/mcp-client.js";
+/**
+ * Run the bridge server
+ */
+export async function runServer(configPath, servers, debug) {
+    try {
+        // Initialize logger with debug mode if requested
+        initializeLogger(debug);
+        console.error(chalk.cyan("\n🚀 Code Mode Bridge"));
+        console.error(chalk.cyan("====================\n"));
+        // Load the bridge configuration
+        const bridgeConfig = loadConfig(configPath);
+        logInfo(`Loaded config from: ${getConfigFilePath(configPath)}`, { component: 'CLI' });
+        logInfo(`Found ${Object.keys(bridgeConfig.servers).length} configured servers`, { component: 'CLI' });
+        // Determine which servers to connect to
+        let serverNames = [];
+        if (servers && servers.length > 0) {
+            serverNames = servers;
+            logInfo(`Loading servers: ${serverNames.join(", ")}`, { component: 'CLI' });
+        }
+        else if (Object.keys(bridgeConfig.servers).length > 0) {
+            serverNames = Object.keys(bridgeConfig.servers);
+            logInfo(`No servers specified, loading all configured servers: ${serverNames.join(", ")}`, { component: 'CLI' });
+        }
+        else {
+            console.error(chalk.yellow("ℹ") + " No servers configured\n");
+        }
+        // Load server configurations
+        const serverConfigs = [];
+        for (const serverName of serverNames) {
+            try {
+                const serverConfig = getServerConfig(bridgeConfig, serverName);
+                serverConfigs.push(serverConfig);
+                logInfo(`Loaded ${serverName}`, { component: 'CLI' });
+            }
+            catch (err) {
+                logError(`Failed to load ${serverName}`, err instanceof Error ? err : { error: String(err) });
+                process.exit(1);
+            }
+        }
+        logInfo(`Starting bridge with ${serverConfigs.length} server(s)`, { component: 'CLI' });
+        // Start the MCP bridge server
+        await startCodeModeBridgeServer(serverConfigs);
+        // Flush buffered stderr output from stdio tools now that Bridge is fully running
+        flushStderrBuffer();
+        logInfo("Bridge is running!", { component: 'CLI' });
+    }
+    catch (error) {
+        logError("Error", error instanceof Error ? error : { error: String(error) });
+        process.exit(1);
+    }
+}
+/**
+ * List all configured servers
+ */
+export function listServersCommand(configPath) {
+    try {
+        const config = loadConfig(configPath);
+        const servers = listServers(config);
+        if (servers.length === 0) {
+            console.log(chalk.yellow("No servers configured.\n"));
+            console.log(`To add a server, use:\n`);
+            console.log(`  ${chalk.cyan("codemode-bridge config add <name> --type stdio --command <command>")}`);
+            return;
+        }
+        console.log(chalk.cyan("\nConfigured Servers:") + "\n");
+        for (const { name, entry } of servers) {
+            console.log(chalk.bold(name));
+            if (entry.type === "stdio") {
+                console.log(`  Type:    ${chalk.blue(entry.type)}`);
+                console.log(`  Command: ${entry.command}`);
+                if (entry.args && entry.args.length > 0) {
+                    console.log(`  Args:    ${entry.args.join(" ")}`);
+                }
+            }
+            else if (entry.type === "http") {
+                console.log(`  Type:    ${chalk.blue(entry.type)}`);
+                console.log(`  URL:     ${entry.url}`);
+            }
+            if (entry.env && Object.keys(entry.env).length > 0) {
+                console.log(`  Env:     ${JSON.stringify(entry.env)}`);
+            }
+            console.log();
+        }
+        console.log(`Config file: ${chalk.gray(getConfigFilePath(configPath))}\n`);
+    }
+    catch (error) {
+        console.error(chalk.red("✗") +
+            " Error: " +
+            (error instanceof Error ? error.message : String(error)));
+        process.exit(1);
+    }
+}
+/**
+ * Show a specific server configuration
+ */
+export function showServerCommand(name, configPath) {
+    try {
+        const config = loadConfig(configPath);
+        const entry = getServer(config, name);
+        if (!entry) {
+            console.error(chalk.red("✗") + ` Server "${name}" not found`);
+            process.exit(1);
+        }
+        console.log(chalk.cyan(`\nServer: ${name}\n`));
+        console.log(JSON.stringify(entry, null, 2));
+        console.log();
+    }
+    catch (error) {
+        console.error(chalk.red("✗") +
+            " Error: " +
+            (error instanceof Error ? error.message : String(error)));
+        process.exit(1);
+    }
+}
+/**
+ * Add a new server configuration
+ */
+export function addServerCommand(name, options, configPath) {
+    try {
+        const entry = {
+            type: options.type,
+        };
+        if (options.type === "stdio") {
+            if (!options.command) {
+                console.error(chalk.red("✗") + ' Missing --command for stdio server');
+                process.exit(1);
+            }
+            entry.command = options.command;
+            if (options.args) {
+                entry.args = options.args;
+            }
+        }
+        else if (options.type === "http") {
+            if (!options.url) {
+                console.error(chalk.red("✗") + ' Missing --url for http server');
+                process.exit(1);
+            }
+            entry.url = options.url;
+        }
+        else {
+            console.error(chalk.red("✗") + ` Invalid type: "${options.type}"`);
+            process.exit(1);
+        }
+        if (options.env) {
+            entry.env = options.env;
+        }
+        // Validate
+        const validation = validateServer(entry);
+        if (!validation.valid) {
+            console.error(chalk.red("✗") + " Validation failed:");
+            for (const error of validation.errors) {
+                console.error("  " + error);
+            }
+            process.exit(1);
+        }
+        // Load, add, and save
+        const config = loadConfig(configPath);
+        addServer(config, name, entry);
+        saveConfig(config, configPath);
+        console.log(chalk.green("✓") + ` Added server "${name}"\n`);
+        showServerCommand(name, configPath);
+    }
+    catch (error) {
+        console.error(chalk.red("✗") +
+            " Error: " +
+            (error instanceof Error ? error.message : String(error)));
+        process.exit(1);
+    }
+}
+/**
+ * Remove a server configuration
+ */
+export function removeServerCommand(name, configPath) {
+    try {
+        const config = loadConfig(configPath);
+        removeServer(config, name);
+        saveConfig(config, configPath);
+        console.log(chalk.green("✓") + ` Removed server "${name}"\n`);
+    }
+    catch (error) {
+        console.error(chalk.red("✗") +
+            " Error: " +
+            (error instanceof Error ? error.message : String(error)));
+        process.exit(1);
+    }
+}
+/**
+ * Edit a server configuration
+ */
+export function editServerCommand(name, options, configPath) {
+    try {
+        const config = loadConfig(configPath);
+        const entry = getServer(config, name);
+        if (!entry) {
+            console.error(chalk.red("✗") + ` Server "${name}" not found`);
+            process.exit(1);
+        }
+        // Update fields
+        if (options.type)
+            entry.type = options.type;
+        if (options.command)
+            entry.command = options.command;
+        if (options.args)
+            entry.args = options.args;
+        if (options.url)
+            entry.url = options.url;
+        if (options.env)
+            entry.env = options.env;
+        // Validate
+        const validation = validateServer(entry);
+        if (!validation.valid) {
+            console.error(chalk.red("✗") + " Validation failed:");
+            for (const error of validation.errors) {
+                console.error("  " + error);
+            }
+            process.exit(1);
+        }
+        // Save
+        updateServer(config, name, entry);
+        saveConfig(config, configPath);
+        console.log(chalk.green("✓") + ` Updated server "${name}"\n`);
+        showServerCommand(name, configPath);
+    }
+    catch (error) {
+        console.error(chalk.red("✗") +
+            " Error: " +
+            (error instanceof Error ? error.message : String(error)));
+        process.exit(1);
+    }
+}
+/**
+ * Show config file information
+ */
+export function configInfoCommand(configPath) {
+    const filePath = getConfigFilePath(configPath);
+    const dir = path.dirname(filePath);
+    const exists = fs.existsSync(filePath);
+    console.log(chalk.cyan("\nConfiguration Information\n"));
+    console.log(`Config file:     ${chalk.bold(filePath)}`);
+    console.log(`Directory:       ${chalk.bold(dir)}`);
+    console.log(`Status:          ${exists ? chalk.green("exists") : chalk.yellow("will be created")}`);
+    if (configPath) {
+        console.log(`\n${chalk.yellow("ℹ")} Using custom config path`);
+    }
+    else {
+        console.log(`\n${chalk.yellow("ℹ")} Using default config path`);
+    }
+    console.log();
+}
+/**
+ * Login command for OAuth servers
+ *
+ * Usage: codemode-bridge auth login <server-name>
+ *
+ * Starts the bridge connected only to the specified OAuth server.
+ * This allows the OAuth flow to complete naturally during connection.
+ */
+export async function authLoginCommand(serverName, configPath) {
+    try {
+        // Initialize logger
+        initializeLogger(false);
+        // Load config and validate server
+        const config = loadConfig(configPath);
+        const serverEntry = getServer(config, serverName);
+        if (!serverEntry) {
+            console.error(chalk.red("✗") + ` Server "${serverName}" not found`);
+            process.exit(1);
+        }
+        // Check if server has OAuth configured
+        if (!serverEntry.oauth) {
+            console.error(chalk.red("✗") + ` Server "${serverName}" does not have OAuth configured`);
+            process.exit(1);
+        }
+        // Only HTTP servers support OAuth
+        if (serverEntry.type !== "http") {
+            console.error(chalk.red("✗") + ` OAuth is only supported for HTTP servers (${serverName} is ${serverEntry.type})`);
+            process.exit(1);
+        }
+        if (!serverEntry.url) {
+            console.error(chalk.red("✗") + ` Server "${serverName}" is missing URL configuration`);
+            process.exit(1);
+        }
+        console.log(chalk.cyan(`\nAuthenticating with ${chalk.bold(serverName)}...\n`));
+        // Create an MCP client for OAuth authentication
+        // This will handle the OAuth flow without fully connecting the client
+        const mcpConfig = {
+            name: serverName,
+            type: serverEntry.type,
+            url: serverEntry.url,
+            oauth: serverEntry.oauth,
+        };
+        const client = new MCPClient(mcpConfig);
+        // Authenticate via OAuth - this triggers browser authorization and token exchange
+        logInfo(`Starting OAuth authentication for ${serverName}`, { component: 'CLI' });
+        await client.authenticateOAuth();
+        // OAuth flow is complete and tokens are saved
+        console.log(chalk.green('\n✓ Authentication successful. Tokens have been saved.\n'));
+        process.exit(0);
+    }
+    catch (error) {
+        logError(`Failed to complete OAuth authentication for ${serverName}`, error instanceof Error ? error : { error: String(error) });
+        console.error(chalk.red("\n✗ Authentication failed"));
+        if (error instanceof Error) {
+            console.error(chalk.red(error.message));
+        }
+        process.exit(1);
+    }
+}
+/**
+ * Logout command for OAuth servers
+ *
+ * Usage: codemode-bridge auth logout <server-name>
+ *
+ * Clears all stored authentication data (tokens and client info) for the server.
+ */
+export function authLogoutCommand(serverName, configPath) {
+    try {
+        // Load config and get server
+        const config = loadConfig(configPath);
+        const serverEntry = getServer(config, serverName);
+        if (!serverEntry) {
+            console.error(chalk.red("✗") + ` Server "${serverName}" not found`);
+            process.exit(1);
+        }
+        // Check if server has OAuth configured
+        if (!serverEntry.oauth) {
+            console.error(chalk.red("✗") + ` Server "${serverName}" does not have OAuth configured`);
+            process.exit(1);
+        }
+        // Get the server URL for token persistence
+        let serverUrl;
+        if (serverEntry.type === "http" && serverEntry.url) {
+            serverUrl = serverEntry.url;
+        }
+        else {
+            // For stdio servers, use server name as key
+            serverUrl = serverName;
+        }
+        // Clear all auth data including client information
+        tokenPersistence.clearAll(serverUrl);
+        logInfo(`Cleared all authentication data for ${serverName}`, { component: 'CLI' });
+        console.log(chalk.green(`✓ Logged out from ${serverName}`));
+        console.log(chalk.cyan(`\nAll tokens and client information have been cleared.`));
+    }
+    catch (error) {
+        logError(`Failed to logout from ${serverName}`, error instanceof Error ? error : { error: String(error) });
+        process.exit(1);
+    }
+}
+/**
+ * List command for OAuth servers
+ *
+ * Usage: codemode-bridge auth list
+ *
+ * Shows all OAuth-enabled servers and their authentication status.
+ */
+export function authListCommand(configPath) {
+    try {
+        // Load config
+        const config = loadConfig(configPath);
+        // Find all OAuth-enabled servers
+        const oauthServers = [];
+        for (const [name, entry] of Object.entries(config.servers || {})) {
+            if (entry.oauth) {
+                // Determine server URL for token lookup
+                let serverUrl;
+                if (entry.type === "http" && entry.url) {
+                    serverUrl = entry.url;
+                }
+                else {
+                    serverUrl = name;
+                }
+                // Get token status
+                const tokenStatus = tokenPersistence.getTokenStatus(serverUrl);
+                let status;
+                if (tokenStatus.exists && !tokenStatus.isExpired) {
+                    status = 'authenticated';
+                }
+                else if (tokenStatus.exists && tokenStatus.isExpired) {
+                    status = 'expired';
+                }
+                else {
+                    status = 'needs login';
+                }
+                oauthServers.push({
+                    name,
+                    entry,
+                    serverUrl,
+                    status,
+                });
+            }
+        }
+        // Display results
+        if (oauthServers.length === 0) {
+            console.log(chalk.yellow("No OAuth-enabled servers configured.\n"));
+            return;
+        }
+        console.log(chalk.cyan("\nOAuth Servers:\n"));
+        for (const server of oauthServers) {
+            const name = chalk.bold(server.name);
+            let statusColor;
+            switch (server.status) {
+                case 'authenticated':
+                    statusColor = chalk.green;
+                    break;
+                case 'expired':
+                    statusColor = chalk.yellow;
+                    break;
+                default:
+                    statusColor = chalk.gray;
+            }
+            console.log(`${name} (${server.entry.type})${chalk.dim(` - ${statusColor(server.status)}`)}`);
+        }
+        console.log();
+    }
+    catch (error) {
+        console.error(chalk.red("✗") +
+            " Error: " +
+            (error instanceof Error ? error.message : String(error)));
+        process.exit(1);
+    }
+}

package/dist/cli/config-manager.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Configuration Manager for Code Mode Bridge
+ *
+ * Manages the bridge configuration stored in .config/codemode-bridge/mcp.json
+ * Provides utilities to load, save, and manipulate the configuration
+ */
+import type { MCPJsonConfig, MCPServerConfigEntry } from "../mcp/config.js";
+/**
+ * Get the default config directory for the current platform
+ */
+export declare function getDefaultConfigDir(): string;
+/**
+ * Get the full path to the mcp.json config file
+ */
+export declare function getConfigFilePath(overridePath?: string): string;
+/**
+ * Load the configuration file, creating it if it doesn't exist
+ */
+export declare function loadConfig(configPath?: string): MCPJsonConfig;
+/**
+ * Save the configuration file
+ */
+export declare function saveConfig(config: MCPJsonConfig, configPath?: string): void;
+/**
+ * Add a server to the configuration
+ */
+export declare function addServer(config: MCPJsonConfig, name: string, entry: MCPServerConfigEntry): MCPJsonConfig;
+/**
+ * Remove a server from the configuration
+ */
+export declare function removeServer(config: MCPJsonConfig, name: string): MCPJsonConfig;
+/**
+ * Update a server in the configuration
+ */
+export declare function updateServer(config: MCPJsonConfig, name: string, entry: MCPServerConfigEntry): MCPJsonConfig;
+/**
+ * Get a server from the configuration
+ */
+export declare function getServer(config: MCPJsonConfig, name: string): MCPServerConfigEntry | null;
+/**
+ * List all servers in the configuration
+ */
+export declare function listServers(config: MCPJsonConfig): {
+    name: string;
+    entry: MCPServerConfigEntry;
+}[];
+/**
+ * Validate a server configuration entry
+ */
+export declare function validateServer(entry: MCPServerConfigEntry): {
+    valid: boolean;
+    errors: string[];
+};

package/dist/cli/config-manager.js

@@ -0,0 +1,142 @@
+/**
+ * Configuration Manager for Code Mode Bridge
+ *
+ * Manages the bridge configuration stored in .config/codemode-bridge/mcp.json
+ * Provides utilities to load, save, and manipulate the configuration
+ */
+import * as fs from "fs";
+import * as path from "path";
+/**
+ * Get the default config directory for the current platform
+ */
+export function getDefaultConfigDir() {
+    const homeDir = process.env.HOME || process.env.USERPROFILE || process.cwd();
+    if (process.platform === "win32") {
+        return path.join(homeDir, ".config", "codemode-bridge");
+    }
+    else if (process.platform === "darwin") {
+        return path.join(homeDir, ".config", "codemode-bridge");
+    }
+    else {
+        // Linux
+        return path.join(homeDir, ".config", "codemode-bridge");
+    }
+}
+/**
+ * Get the full path to the mcp.json config file
+ */
+export function getConfigFilePath(overridePath) {
+    if (overridePath) {
+        return path.resolve(overridePath);
+    }
+    return path.join(getDefaultConfigDir(), "mcp.json");
+}
+/**
+ * Load the configuration file, creating it if it doesn't exist
+ */
+export function loadConfig(configPath) {
+    const filePath = getConfigFilePath(configPath);
+    if (!fs.existsSync(filePath)) {
+        // Create default config
+        const defaultConfig = {
+            servers: {},
+        };
+        saveConfig(defaultConfig, configPath);
+        return defaultConfig;
+    }
+    try {
+        const content = fs.readFileSync(filePath, "utf-8");
+        return JSON.parse(content);
+    }
+    catch (error) {
+        throw new Error(`Failed to parse config file at ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Save the configuration file
+ */
+export function saveConfig(config, configPath) {
+    const filePath = getConfigFilePath(configPath);
+    const dir = path.dirname(filePath);
+    // Create directory if it doesn't exist
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    try {
+        fs.writeFileSync(filePath, JSON.stringify(config, null, 2), "utf-8");
+    }
+    catch (error) {
+        throw new Error(`Failed to save config file at ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Add a server to the configuration
+ */
+export function addServer(config, name, entry) {
+    if (config.servers[name]) {
+        throw new Error(`Server "${name}" already exists`);
+    }
+    config.servers[name] = entry;
+    return config;
+}
+/**
+ * Remove a server from the configuration
+ */
+export function removeServer(config, name) {
+    if (!config.servers[name]) {
+        throw new Error(`Server "${name}" not found`);
+    }
+    delete config.servers[name];
+    return config;
+}
+/**
+ * Update a server in the configuration
+ */
+export function updateServer(config, name, entry) {
+    if (!config.servers[name]) {
+        throw new Error(`Server "${name}" not found`);
+    }
+    config.servers[name] = entry;
+    return config;
+}
+/**
+ * Get a server from the configuration
+ */
+export function getServer(config, name) {
+    return config.servers[name] || null;
+}
+/**
+ * List all servers in the configuration
+ */
+export function listServers(config) {
+    return Object.entries(config.servers).map(([name, entry]) => ({
+        name,
+        entry,
+    }));
+}
+/**
+ * Validate a server configuration entry
+ */
+export function validateServer(entry) {
+    const errors = [];
+    if (!entry.type) {
+        errors.push("Missing 'type' field (must be 'stdio' or 'http')");
+    }
+    else if (entry.type !== "stdio" && entry.type !== "http") {
+        errors.push(`Invalid type: "${entry.type}" (must be 'stdio' or 'http')`);
+    }
+    if (entry.type === "stdio") {
+        if (!entry.command) {
+            errors.push("Missing 'command' field for stdio server");
+        }
+    }
+    else if (entry.type === "http") {
+        if (!entry.url) {
+            errors.push("Missing 'url' field for http server");
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+    };
+}

package/dist/cli/index.d.ts

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+/**
+ * Code Mode Bridge CLI
+ *
+ * Main entry point for the command-line interface
+ *
+ * Usage:
+ *   codemode-bridge run [options]            - Start the bridge server
+ *   codemode-bridge config list [options]    - List configured servers
+ *   codemode-bridge config show <name>       - Show a server configuration
+ *   codemode-bridge config add <name>        - Add a new server
+ *   codemode-bridge config remove <name>     - Remove a server
+ *   codemode-bridge config edit <name>       - Edit a server
+ *   codemode-bridge config info              - Show config file information
+ *   codemode-bridge auth list [options]      - List OAuth-enabled servers and status
+ *   codemode-bridge auth login <name>        - Prepare to login to an OAuth server
+ *   codemode-bridge auth logout <name>       - Logout from an OAuth server
+ */
+export {};