mcp-compress-router 1.0.0

package/build/cli/login-command.js

@@ -0,0 +1,219 @@
+import { ensureConfigDir, readConfigFile } from './config-io.js';
+import { loadConfig } from '../services/config.js';
+/**
+ * Validates that a server exists in config and is eligible for OAuth login.
+ *
+ * @param configPath - Absolute path to the mcp.json file.
+ * @param name - Server name to validate.
+ * @returns The raw server entry and the typed downstream config.
+ * @throws If the server is not found or is not an HTTP type.
+ */
+async function validateServerForLogin(configPath, name) {
+    await ensureConfigDir(configPath);
+    const servers = await readConfigFile(configPath);
+    if (!(name in servers)) {
+        const available = Object.keys(servers);
+        const hint = available.length > 0
+            ? ` Available servers: ${available.join(', ')}`
+            : ' No servers configured.';
+        throw new Error(`Server "${name}" not found.${hint}`);
+    }
+    const entry = servers[name];
+    if (entry.type !== 'http' && entry.type !== 'streamable-http') {
+        throw new Error(`Server "${name}" is type "${entry.type}". OAuth is only supported for HTTP servers.`);
+    }
+    const allConfigs = await loadConfig(configPath);
+    const targetServer = allConfigs.find((s) => s.name === name);
+    if (!targetServer) {
+        throw new Error(`Server "${name}" not found in configuration.`);
+    }
+    return { entry, targetServer };
+}
+// Cached lazy imports for SDK OAuth modules.
+let _sdkAuth;
+async function _getSdkAuth() {
+    if (!_sdkAuth) {
+        _sdkAuth = await import('@modelcontextprotocol/sdk/client/auth.js');
+    }
+    return _sdkAuth;
+}
+/**
+ * Discovers OAuth metadata and registers the client if dynamic registration
+ * is needed.
+ *
+ * @param mgr - OAuth credential manager for the target server.
+ * @param targetServer - Typed downstream server configuration.
+ * @param name - Server name (for error messages).
+ * @returns The discovered OAuth metadata (non-null after validation).
+ * @throws If the server does not expose OAuth metadata or registration.
+ */
+async function setupOAuthClient(mgr, targetServer, name) {
+    const { discoverOAuthMetadata, registerClient } = await _getSdkAuth();
+    const serverUrl = new URL(targetServer.url);
+    const metadata = await discoverOAuthMetadata(serverUrl);
+    if (!metadata) {
+        throw new Error(`Server "${name}" does not expose OAuth metadata.`);
+    }
+    if (!metadata.registration_endpoint) {
+        throw new Error(`Server "${name}" does not support dynamic client registration.`);
+    }
+    if (!mgr.hasStaticClient() && !(await mgr.clientInformation())) {
+        const regResult = await registerClient(new URL(metadata.registration_endpoint), {
+            metadata,
+            clientMetadata: mgr.clientMetadata,
+        });
+        await mgr.saveClientInformation(regResult);
+    }
+    return metadata;
+}
+/**
+ * Starts a temporary HTTP server, opens the browser for authorization,
+ * and waits for the OAuth callback with a configurable timeout.
+ *
+ * @param mgr - OAuth credential manager.
+ * @param metadata - Discovered OAuth metadata.
+ * @param targetServer - Typed downstream server configuration.
+ * @returns The authorization code and the full `startAuthorization` result.
+ * @throws If the callback times out or the authorization is denied.
+ */
+async function acquireAuthorizationCode(mgr, metadata, targetServer) {
+    const { startAuthorization } = await _getSdkAuth();
+    const { openBrowser } = await import('../utils/open-browser.js');
+    const TIMEOUT_MS = _readTimeoutMs();
+    return _startCallbackServerAndWait(mgr, metadata, targetServer, startAuthorization, openBrowser, TIMEOUT_MS);
+}
+/**
+ * Creates the HTTP request listener for the temporary OAuth callback server.
+ *
+ * Uses `tempServer` captured via closure for calling `.close()` and the
+ * `resolve`/`reject` functions to settle the promise. The `timeoutHandle`
+ * wrapper allows the callback to clear the timeout when a response arrives.
+ *
+ * @param timeoutHandle - Mutable object wrapping the timeout ID.
+ * @param tempServer - The temporary HTTP server (to close on completion).
+ * @param resolve - Promise resolve function.
+ * @param reject - Promise reject function.
+ * @returns An HTTP request listener.
+ */
+function _makeCallbackHandler(timeoutHandle, tempServer, resolve, reject) {
+    return (req, res) => {
+        const url = new URL(req.url, `http://localhost`);
+        const code = url.searchParams.get('code');
+        const error = url.searchParams.get('error');
+        if (code) {
+            if (timeoutHandle.current)
+                clearTimeout(timeoutHandle.current);
+            res.writeHead(200, { 'Content-Type': 'text/html' });
+            res.end('<html><body><h1>Authorization successful!</h1><p>You can close this window.</p></body></html>');
+            tempServer.close();
+            resolve(code);
+        }
+        else if (error) {
+            if (timeoutHandle.current)
+                clearTimeout(timeoutHandle.current);
+            res.writeHead(400, { 'Content-Type': 'text/html' });
+            res.end(`<html><body><h1>Authorization failed</h1><p>${error}</p></body></html>`);
+            tempServer.close();
+            reject(new Error(`Authorization failed: ${error}`));
+        }
+        else {
+            res.writeHead(404);
+            res.end('Not found');
+        }
+    };
+}
+/** Creates a temp HTTP server, starts OAuth flow, waits for callback. */
+async function _startCallbackServerAndWait(mgr, metadata, targetServer, startAuthorization, openBrowser, TIMEOUT_MS) {
+    const http = await import('node:http');
+    const timeoutHandle = { current: undefined };
+    const authResultRef = { value: undefined };
+    const authorizationCode = await new Promise((resolve, reject) => {
+        const tempServer = http.createServer();
+        tempServer.on('request', _makeCallbackHandler(timeoutHandle, tempServer, resolve, reject));
+        tempServer.listen(0, _onServerListen(tempServer, mgr, metadata, targetServer, startAuthorization, openBrowser, TIMEOUT_MS, timeoutHandle, authResultRef, reject));
+        tempServer.on('error', (err) => {
+            if (timeoutHandle.current)
+                clearTimeout(timeoutHandle.current);
+            reject(err);
+        });
+    });
+    if (timeoutHandle.current)
+        clearTimeout(timeoutHandle.current);
+    return { authorizationCode, authResult: authResultRef.value };
+}
+/** Listen callback: sets port, starts auth, opens browser, arms timeout. */
+function _onServerListen(tempServer, mgr, metadata, targetServer, startAuthorization, openBrowser, TIMEOUT_MS, timeoutHandle, authResultRef, reject) {
+    return async () => {
+        try {
+            const address = tempServer.address();
+            if (!address || typeof address === 'string') {
+                reject(new Error('Failed to get server address'));
+                return;
+            }
+            const actualPort = address.port;
+            mgr.setActualPort(actualPort);
+            authResultRef.value = await startAuthorization(new URL(metadata.authorization_endpoint), {
+                metadata,
+                clientInformation: (await mgr.clientInformation()),
+                redirectUrl: mgr.redirectUrl,
+                scope: targetServer.oauth?.scope,
+            });
+            await mgr.saveCodeVerifier(authResultRef.value.codeVerifier);
+            void openBrowser(authResultRef.value.authorizationUrl.toString());
+            timeoutHandle.current = setTimeout(() => {
+                tempServer.close();
+                reject(new Error(`OAuth login timed out after ${TIMEOUT_MS / 1000} seconds. Please try again.`));
+            }, TIMEOUT_MS);
+        }
+        catch (err) {
+            reject(err instanceof Error ? err : new Error(String(err)));
+        }
+    };
+}
+/**
+ * Reads the OAuth login timeout from the
+ * `MCP_COMPRESS_ROUTER_LOGIN_TIMEOUT_MS` env var, defaulting to 120 seconds.
+ *
+ * @returns Timeout in milliseconds.
+ */
+function _readTimeoutMs() {
+    const env = process.env.MCP_COMPRESS_ROUTER_LOGIN_TIMEOUT_MS;
+    if (env) {
+        const parsed = parseInt(env, 10);
+        if (!isNaN(parsed) && parsed > 0)
+            return parsed;
+    }
+    return 120_000;
+}
+/**
+ * Handles the `login <name>` subcommand.
+ *
+ * Validates the server exists in config and is an HTTP type.
+ * For HTTP servers, runs the OAuth authorization-code flow
+ * using the SDK's OAuth client infrastructure. The flow opens
+ * a browser, handles the redirect callback, exchanges the
+ * authorization code for tokens, and persists them in credentials.json.
+ *
+ * @param configPath - Absolute path to the mcp.json file.
+ * @param name - Server name to authenticate.
+ * @returns Human-readable confirmation message.
+ * @throws If the server name is not found or is not an HTTP type.
+ */
+export async function handleLogin(configPath, name) {
+    const { targetServer } = await validateServerForLogin(configPath, name);
+    const { OAuthCredentialManager } = await import('../services/oauth.js');
+    const mgr = new OAuthCredentialManager(configPath, targetServer);
+    const metadata = await setupOAuthClient(mgr, targetServer, name);
+    const { authorizationCode, authResult } = await acquireAuthorizationCode(mgr, metadata, targetServer);
+    const { exchangeAuthorization } = await _getSdkAuth();
+    const realRedirectUrl = mgr.redirectUrl;
+    const tokens = await exchangeAuthorization(new URL(metadata.token_endpoint), {
+        metadata,
+        clientInformation: (await mgr.clientInformation()),
+        authorizationCode,
+        codeVerifier: authResult.codeVerifier,
+        redirectUri: realRedirectUrl,
+    });
+    await mgr.saveTokens(tokens);
+    return `Successfully authenticated server "${name}". Tokens stored in credentials.json.`;
+}

package/build/cli/logout-command.js

@@ -0,0 +1,34 @@
+import { ensureConfigDir, readConfigFile, readCredentials, removeCredentials, } from './config-io.js';
+/**
+ * Handles the `logout <name>` subcommand.
+ *
+ * Attempts to revoke tokens with the authorization server (best-effort),
+ * then removes stored credentials from credentials.json.
+ *
+ * @param configPath - Absolute path to the mcp.json file.
+ * @param name - Server name to log out from.
+ * @returns Human-readable confirmation message.
+ * @throws If the server name is not found.
+ */
+export async function handleLogout(configPath, name) {
+    await ensureConfigDir(configPath);
+    const servers = await readConfigFile(configPath);
+    if (!(name in servers)) {
+        const available = Object.keys(servers);
+        const hint = available.length > 0
+            ? ` Available servers: ${available.join(', ')}`
+            : ' No servers configured.';
+        throw new Error(`Server "${name}" not found.${hint}`);
+    }
+    const creds = await readCredentials(configPath);
+    const serverCreds = creds[name];
+    if (!serverCreds) {
+        return `No credentials stored for server "${name}".`;
+    }
+    // Best-effort revocation: if the server's metadata includes a
+    // revocation_endpoint, attempt to revoke the tokens.
+    // For now, remove credentials directly. The SDK's auth infrastructure
+    // handles revocation when available.
+    await removeCredentials(configPath, name);
+    return `Removed credentials for server "${name}".`;
+}

package/build/cli/remove-command.js

@@ -0,0 +1,26 @@
+import { ensureConfigDir, readConfigFile, writeConfigFile, removeCredentials, } from './config-io.js';
+/**
+ * Handles the `remove <name>` subcommand: deletes a server entry
+ * and cleans up any stored OAuth credentials for that server.
+ *
+ * @param configPath - Absolute path to the mcp.json file.
+ * @param name - Server name to remove.
+ * @returns Human-readable confirmation message to print to stdout.
+ * @throws If the server name is not found.
+ */
+export async function handleRemove(configPath, name) {
+    await ensureConfigDir(configPath);
+    const servers = await readConfigFile(configPath);
+    if (!(name in servers)) {
+        const available = Object.keys(servers);
+        const hint = available.length > 0
+            ? ` Available servers: ${available.join(', ')}`
+            : ' No servers configured.';
+        throw new Error(`Server "${name}" not found.${hint}`);
+    }
+    delete servers[name];
+    await writeConfigFile(configPath, servers);
+    // Clean up any stored OAuth credentials for the removed server.
+    await removeCredentials(configPath, name);
+    return `Removed server "${name}".`;
+}

package/build/config.js

@@ -0,0 +1,80 @@
+import * as path from 'node:path';
+import * as os from 'node:os';
+import * as fs from 'node:fs/promises';
+/**
+ * Resolves the configuration file path.
+ *
+ * Priority: (1) explicit path argument, (2) MCP_COMPRESS_ROUTER_HOME env var,
+ * (3) default ~/.local/share/mcp-compress-router/mcp.json.
+ *
+ * @param explicitPath - An explicit config path, or undefined.
+ * @returns The resolved absolute path to the config file.
+ */
+export function resolveConfigPath(explicitPath) {
+    if (explicitPath !== undefined) {
+        return explicitPath;
+    }
+    const home = process.env.MCP_COMPRESS_ROUTER_HOME ??
+        path.join(os.homedir(), '.local', 'share', 'mcp-compress-router');
+    return path.join(home, 'mcp.json');
+}
+/**
+ * Loads and validates the MCP configuration file.
+ *
+ * Reads a JSON file with a top-level mcpServers object, extracts stdio
+ * entries, and validates uniqueness. HTTP servers and variable expansion
+ * are deferred to later slices.
+ *
+ * @param configPath - Absolute path to the mcp.json file.
+ * @returns An array of validated DownstreamServerConfig objects.
+ * @throws If the file is missing, invalid JSON, or contains duplicate names.
+ */
+export async function loadConfig(configPath) {
+    const raw = await fs.readFile(configPath, 'utf-8');
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new Error(`Failed to parse config file: ${configPath}`);
+    }
+    if (typeof parsed !== 'object' || parsed === null) {
+        throw new Error('Config file must contain a JSON object with mcpServers');
+    }
+    const obj = parsed;
+    const mcpServers = obj.mcpServers;
+    if (typeof mcpServers !== 'object' || mcpServers === null) {
+        throw new Error('Config file must contain an mcpServers object');
+    }
+    const names = new Set();
+    const servers = [];
+    for (const [name, entry] of Object.entries(mcpServers)) {
+        if (typeof entry !== 'object' || entry === null) {
+            throw new Error(`Server "${name}" must be an object`);
+        }
+        const server = entry;
+        if (server.type !== 'stdio') {
+            throw new Error(`Server "${name}" has unsupported type "${String(server.type)}"; only "stdio" is supported`);
+        }
+        if (typeof server.command !== 'string' || server.command.length === 0) {
+            throw new Error(`Server "${name}" is missing required "command" field`);
+        }
+        if (names.has(name)) {
+            throw new Error(`Duplicate server name: "${name}"`);
+        }
+        names.add(name);
+        const args = Array.isArray(server.args) ? server.args.map(String) : undefined;
+        const env = server.env !== undefined && typeof server.env === 'object'
+            ? Object.fromEntries(Object.entries(server.env).map(([k, v]) => [k, String(v)]))
+            : undefined;
+        const description = typeof server.description === 'string' ? server.description : undefined;
+        servers.push({
+            name,
+            command: server.command,
+            args,
+            env,
+            description,
+        });
+    }
+    return servers;
+}

package/build/discovery.js

@@ -0,0 +1,39 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+/**
+ * Connects to all configured stdio servers in parallel and discovers
+ * their tools. Fails fast if any server is unreachable.
+ *
+ * @param servers - Validated downstream server configs.
+ * @returns Discovered server data for each server.
+ * @throws If any server cannot be connected or tools cannot be listed.
+ */
+export async function connectAndDiscover(servers) {
+    const results = await Promise.all(servers.map(async (server) => {
+        const client = new Client({ name: 'mcp-compress-router', version: '1.0.0' }, { capabilities: {} });
+        const transport = new StdioClientTransport({
+            command: server.command,
+            args: server.args,
+            env: server.env,
+        });
+        try {
+            await client.connect(transport);
+            const listResult = await client.listTools();
+            const tools = listResult.tools.map((t) => ({
+                name: t.name,
+                description: t.description,
+                inputSchema: t.inputSchema,
+            }));
+            return {
+                name: server.name,
+                description: server.description,
+                tools,
+            };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            throw new Error(`Failed to connect to server "${server.name}": ${message}`);
+        }
+    }));
+    return results;
+}

package/build/index.js

@@ -0,0 +1,241 @@
+#!/usr/bin/env node
+/// <reference types="node" />
+import * as path from 'node:path';
+import dotenv from 'dotenv';
+import { Command } from 'commander';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { resolveConfigDir, resolveConfigPath, loadConfig, connectAndDiscover, buildCatalog, invokeDownstreamTool, OAuthCredentialManager, persistAuthRequirements, } from './services/index.js';
+import { createGetToolSchemaHandler, buildGetToolSchemaDescription, GetToolSchemaInputSchema, createInvokeToolHandler, InvokeToolInputSchema, } from './tools/index.js';
+import { Logger } from './utils/index.js';
+import { handleAdd, handleRemove, handleGet, handleList, handleLogin, handleLogout, } from './cli/index.js';
+/**
+ * Collects repeated `--header "K: V"` flags into a headers record.
+ * @internal — Exported for tests only; not part of the public module API.
+ */
+export function collectHeaders(value, previous) {
+    const colonIdx = value.indexOf(':');
+    if (colonIdx === -1) {
+        throw new Error(`Invalid header format: "${value}". Expected "Key: Value".`);
+    }
+    const key = value.slice(0, colonIdx).trim();
+    const val = value.slice(colonIdx + 1).trim();
+    return { ...previous, [key]: val };
+}
+/**
+ * Collects repeated `-e KEY=value` flags into an env record.
+ * @internal — Exported for tests only; not part of the public module API.
+ */
+export function collectEnv(value, previous) {
+    const eqIdx = value.indexOf('=');
+    if (eqIdx === -1) {
+        throw new Error(`Invalid env format: "${value}". Expected "KEY=value".`);
+    }
+    const key = value.slice(0, eqIdx);
+    const val = value.slice(eqIdx + 1);
+    return { ...previous, [key]: val };
+}
+/**
+ * Wraps a CLI action handler with error handling.
+ * On success, writes the result to stdout. On error, writes to stderr
+ * and exits with code 1.
+ */
+function guardedAction(fn) {
+    return async (...args) => {
+        try {
+            const result = await fn(...args);
+            if (result) {
+                process.stdout.write(result + '\n');
+            }
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            process.stderr.write(`Error: ${message}\n`);
+            process.exit(1);
+        }
+    };
+}
+/**
+ * Creates OAuth credential managers for HTTP servers that have stored
+ * credentials or oauth overrides, so the transport can handle auth.
+ */
+async function buildAuthProviders(resolved, servers) {
+    const authProviders = new Map();
+    for (const server of servers) {
+        if (server.type === 'http' || server.type === 'streamable-http') {
+            const mgr = new OAuthCredentialManager(resolved, server);
+            const hasCredentials = (await mgr.tokens()) !== undefined;
+            const hasOverrides = server.oauth?.clientId !== undefined;
+            if (hasCredentials || hasOverrides) {
+                authProviders.set(server.name, mgr);
+            }
+        }
+    }
+    return authProviders;
+}
+/**
+ * Creates the MCP server, registers router tools, and starts the
+ * stdio transport.
+ */
+async function startRouterServer(catalog, clients, logger) {
+    const router = new McpServer({
+        name: 'mcp-compress-router',
+        version: '1.0.0',
+    });
+    router.registerTool('get_tool_schema', {
+        title: 'Get Tool Schema',
+        description: buildGetToolSchemaDescription(catalog),
+        inputSchema: GetToolSchemaInputSchema,
+    }, createGetToolSchemaHandler(catalog, logger));
+    const invokeFn = (server, tool, args) => invokeDownstreamTool(clients, server, tool, args, logger);
+    router.registerTool('invoke_tool', {
+        title: 'Invoke Tool',
+        description: 'Invoke a specific tool on a connected MCP server. First use get_tool_schema to retrieve the required parameters.',
+        inputSchema: InvokeToolInputSchema,
+    }, createInvokeToolHandler(catalog, invokeFn, logger));
+    const transport = new StdioServerTransport();
+    await router.connect(transport);
+    logger.info('Server started on stdio');
+}
+async function runRouter(configPath, verbose) {
+    const logger = new Logger(verbose ? 'debug' : 'info');
+    logger.info('Starting mcp-compress-router', {
+        verbose,
+        config: configPath ?? '(default)',
+    });
+    const resolved = await resolveConfigPath(configPath);
+    logger.info('Loading configuration', { path: resolved });
+    const servers = await loadConfig(resolved);
+    logger.info('Configuration loaded', { serverCount: servers.length });
+    await persistAuthRequirements(resolved, servers, logger);
+    const authProviders = await buildAuthProviders(resolved, servers);
+    const getAuthProvider = (server) => authProviders.get(server.name);
+    logger.info('Connecting to downstream servers', {
+        servers: servers.map((s) => s.name),
+    });
+    const { servers: discovered, clients } = await connectAndDiscover(servers, logger, getAuthProvider);
+    logger.info('Tools discovered', {
+        servers: discovered.map((d) => ({
+            name: d.name,
+            toolCount: d.tools.length,
+            tools: d.tools.map((t) => t.name),
+        })),
+    });
+    const catalog = buildCatalog(discovered);
+    await startRouterServer(catalog, clients, logger);
+}
+function registerAddCommand(program) {
+    program
+        .command('add <name> <commandOrUrl> [rest...]')
+        .description('Add a downstream MCP server to the configuration')
+        .option('-c, --config <path>', 'path to mcp.json configuration file')
+        .option('--transport <type>', 'transport type (stdio or http)', 'stdio')
+        .option('--header <header>', 'HTTP header (Key: Value)', collectHeaders, {})
+        .option('-e, --env <env>', 'environment variable (KEY=value)', collectEnv, {})
+        .action(guardedAction(async (name, commandOrUrl, rest, options) => {
+        const configPath = await resolveConfigPath(options.config);
+        const result = await handleAdd(configPath, {
+            name,
+            transport: options.transport,
+            commandOrUrl,
+            rest,
+            env: Object.keys(options.env).length > 0 ? options.env : undefined,
+            headers: Object.keys(options.header).length > 0 ? options.header : undefined,
+        });
+        return result;
+    }));
+}
+function registerRemoveCommand(program) {
+    program
+        .command('remove <name>')
+        .description('Remove a downstream MCP server from the configuration')
+        .option('-c, --config <path>', 'path to mcp.json configuration file')
+        .action(guardedAction(async (name, options) => {
+        const configPath = await resolveConfigPath(options.config);
+        return handleRemove(configPath, name);
+    }));
+}
+function registerGetCommand(program) {
+    program
+        .command('get <name>')
+        .description('Show details for a configured downstream MCP server')
+        .option('-c, --config <path>', 'path to mcp.json configuration file')
+        .action(guardedAction(async (name, options) => {
+        const configPath = await resolveConfigPath(options.config);
+        return handleGet(configPath, name);
+    }));
+}
+function registerListCommand(program) {
+    program
+        .command('list')
+        .description('List all configured downstream MCP servers')
+        .option('-c, --config <path>', 'path to mcp.json configuration file')
+        .action(guardedAction(async (options) => {
+        const configPath = await resolveConfigPath(options.config);
+        return handleList(configPath);
+    }));
+}
+function registerLoginCommand(program) {
+    program
+        .command('login <name>')
+        .description('Authenticate a downstream server using OAuth')
+        .option('-c, --config <path>', 'path to mcp.json configuration file')
+        .action(guardedAction(async (name, options) => {
+        const configPath = await resolveConfigPath(options.config);
+        return handleLogin(configPath, name);
+    }));
+}
+function registerLogoutCommand(program) {
+    program
+        .command('logout <name>')
+        .description('Revoke and remove OAuth credentials for a downstream server')
+        .option('-c, --config <path>', 'path to mcp.json configuration file')
+        .action(guardedAction(async (name, options) => {
+        const configPath = await resolveConfigPath(options.config);
+        return handleLogout(configPath, name);
+    }));
+}
+function registerRouterCommand(program) {
+    program
+        .option('-c, --config <path>', 'path to mcp.json configuration file')
+        .option('-v, --verbose', 'enable debug-level logging to stderr')
+        .action(async (options) => {
+        const verbose = options.verbose || process.env.MCP_COMPRESS_ROUTER_VERBOSE === 'true';
+        await runRouter(options.config, verbose);
+    });
+}
+async function main() {
+    // Load .env from the config directory before any config resolution
+    // or env var expansion. `quiet` suppresses dotenv's startup log line.
+    dotenv.config({
+        path: path.join(resolveConfigDir(), '.env'),
+        quiet: true,
+    });
+    const program = new Command();
+    program
+        .name('mcp-compress-router')
+        .description('Compress all connected MCP servers into a single router MCP');
+    registerAddCommand(program);
+    registerRemoveCommand(program);
+    registerGetCommand(program);
+    registerListCommand(program);
+    registerLoginCommand(program);
+    registerLogoutCommand(program);
+    registerRouterCommand(program);
+    await program.parseAsync();
+}
+main().catch((err) => {
+    const message = err instanceof Error ? err.message : String(err);
+    // Use a fresh error-level logger for fatal startup errors.
+    const fatalLogger = new Logger('debug');
+    if (message.includes('Failed to connect to server')) {
+        fatalLogger.error('Cannot build complete tool catalog — downstream connection failed', {
+            error: message,
+        });
+    }
+    else {
+        fatalLogger.error('Fatal startup error', { error: message });
+    }
+    process.exitCode = 1;
+    process.exit(1);
+});