@apify/mcpc 0.3.0 → 0.3.1

package/dist/cli/commands/connect.js

@@ -0,0 +1,655 @@
+import { createServer } from 'net';
+import { isValidSessionName, generateSessionName, normalizeServerUrl, validateProfileName, redactHeaders, AuthError, ClientError, isAuthenticationError, createServerAuthError, } from '../../lib/index.js';
+import { formatOutput, formatSuccess, formatWarning, formatPath, formatConnectStatusBadge, theme, } from '../output.js';
+import { withMcpClient, resolveTarget, resolveAuthProfile } from '../helpers.js';
+import { deleteSession, saveSession, updateSession, getSession, loadSessions, } from '../../lib/sessions.js';
+import { startBridge, stopBridge } from '../../lib/bridge-manager.js';
+import { storeKeychainSessionHeaders, storeKeychainProxyBearerToken, } from '../../lib/auth/keychain.js';
+import { getWallet } from '../../lib/wallets.js';
+import chalk from 'chalk';
+import ora from 'ora';
+import { createLogger } from '../../lib/logger.js';
+import { parseProxyArg } from '../parser.js';
+import { loadConfig, listServers, isStdioEntry, scanMcpConfigFiles, getStandardMcpConfigPaths, } from '../../lib/config.js';
+import { getBridgeStatus, showServerDetails, statelessField } from './sessions.js';
+const logger = createLogger('connect');
+async function checkPortAvailable(host, port) {
+    return new Promise((resolve) => {
+        const server = createServer();
+        server.once('error', () => {
+            resolve(false);
+        });
+        server.once('listening', () => {
+            server.close(() => {
+                resolve(true);
+            });
+        });
+        server.listen(port, host);
+    });
+}
+async function buildConnectResultEntry(sessionName, status, options) {
+    return await withMcpClient(sessionName, {
+        outputMode: 'json',
+        hideTarget: true,
+        ...(options.verbose && { verbose: options.verbose }),
+        ...(options.timeout !== undefined && { timeout: options.timeout }),
+    }, async (client, context) => {
+        const serverDetails = await client.getServerDetails();
+        const tools = (await client.listAllTools()).tools;
+        const server = context.serverConfig
+            ? {
+                ...context.serverConfig,
+                ...(context.serverConfig.headers && {
+                    headers: redactHeaders(context.serverConfig.headers),
+                }),
+            }
+            : undefined;
+        return {
+            _mcpc: {
+                sessionName: context.sessionName ?? sessionName,
+                ...(context.profileName && { profileName: context.profileName }),
+                ...(server && { server }),
+                ...(options.configFile && { configFile: options.configFile }),
+                ...(options.entry && { entry: options.entry }),
+                status,
+                ...statelessField(serverDetails.connectionMode),
+            },
+            ...(serverDetails.protocolVersion && { protocolVersion: serverDetails.protocolVersion }),
+            ...(serverDetails.capabilities && { capabilities: serverDetails.capabilities }),
+            ...(serverDetails.serverInfo && { serverInfo: serverDetails.serverInfo }),
+            ...(serverDetails.instructions && { instructions: serverDetails.instructions }),
+            ...(tools.length > 0 && { toolNames: tools.map((t) => t.name) }),
+        };
+    });
+}
+async function renderConnectedSession(name, status, options) {
+    if (options.outputMode === 'json') {
+        const entry = await buildConnectResultEntry(name, status, {
+            ...(options.verbose && { verbose: options.verbose }),
+            ...(options.timeout !== undefined && { timeout: options.timeout }),
+        });
+        console.log(formatOutput([entry], 'json'));
+    }
+    else {
+        await showServerDetails(name, { ...options, hideTarget: false });
+    }
+}
+export async function connectSession(target, name, options) {
+    if (!isValidSessionName(name)) {
+        throw new ClientError(`Invalid session name: ${name}\n` +
+            `Session names must start with @ and be followed by 1-64 characters, alphanumeric with hyphens or underscores only (e.g., @my-session).`);
+    }
+    if (options.profile) {
+        validateProfileName(options.profile);
+    }
+    let proxyConfig;
+    if (options.proxy) {
+        proxyConfig = parseProxyArg(options.proxy);
+        logger.debug(`Proxy config: ${proxyConfig.host}:${proxyConfig.port}`);
+        const portAvailable = await checkPortAvailable(proxyConfig.host, proxyConfig.port);
+        if (!portAvailable) {
+            throw new ClientError(`Port ${proxyConfig.port} is already in use on ${proxyConfig.host}. ` +
+                `Choose a different port with --proxy [host:]port`);
+        }
+    }
+    if (options.proxyBearerToken && !options.proxy) {
+        throw new ClientError('--proxy-bearer-token requires --proxy to be specified');
+    }
+    const existingSession = await getSession(name);
+    if (existingSession) {
+        const bridgeStatus = getBridgeStatus(existingSession);
+        if (bridgeStatus === 'live') {
+            if (options.outputMode === 'human' && !options.quiet) {
+                console.log(formatSuccess(`Session ${name} is already active`));
+            }
+            if (!options.skipDetails) {
+                await renderConnectedSession(name, 'active', options);
+            }
+            return;
+        }
+        if (options.outputMode === 'human' && !options.quiet) {
+            console.log(theme.yellow(`Session ${name} exists but bridge is ${bridgeStatus}, reconnecting...`));
+        }
+        try {
+            await stopBridge(name);
+        }
+        catch {
+        }
+    }
+    const serverConfig = await resolveTarget(target, options);
+    const hasExplicitAuthHeader = serverConfig.headers?.Authorization !== undefined;
+    const hasExplicitProfile = options.profile !== undefined;
+    if (hasExplicitAuthHeader && hasExplicitProfile) {
+        throw new ClientError(`Cannot combine --profile with --header "Authorization: ...".\n\n` +
+            `Use either:\n` +
+            `  --profile ${options.profile}  (OAuth authentication via saved profile)\n` +
+            `  --header "Authorization: Bearer <token>"  (static bearer token)`);
+    }
+    let profileName;
+    if (serverConfig.url) {
+        if (options.noProfile) {
+            logger.debug('Skipping OAuth profile: --no-profile specified');
+        }
+        else if (hasExplicitAuthHeader) {
+            logger.debug('Skipping OAuth profile auto-detection: explicit Authorization header provided via --header');
+        }
+        else if (options.x402 && !options.profile) {
+            logger.debug('Skipping OAuth profile auto-detection: --x402 specified');
+        }
+        else {
+            profileName = await resolveAuthProfile(serverConfig.url, target, options.profile, {
+                sessionName: name,
+            });
+        }
+    }
+    let headers;
+    if (serverConfig.headers && Object.keys(serverConfig.headers).length > 0) {
+        headers = { ...serverConfig.headers };
+        logger.debug(`Storing ${Object.keys(headers).length} headers for session ${name} in keychain`);
+        await storeKeychainSessionHeaders(name, headers);
+    }
+    if (options.proxyBearerToken) {
+        logger.debug(`Storing proxy bearer token for session ${name} in keychain`);
+        await storeKeychainProxyBearerToken(name, options.proxyBearerToken);
+    }
+    if (options.x402) {
+        const wallet = await getWallet();
+        if (!wallet) {
+            throw new ClientError('x402 wallet not found. Create one with: mcpc x402 init');
+        }
+        logger.debug(`Using x402 wallet: ${wallet.address}`);
+    }
+    const isReconnect = !!existingSession;
+    const { headers: _originalHeaders, ...baseTransportConfig } = serverConfig;
+    const sessionTransportConfig = {
+        ...baseTransportConfig,
+        ...(headers && { headers: redactHeaders(headers) }),
+    };
+    const sessionUpdate = {
+        server: sessionTransportConfig,
+        ...(profileName && { profileName }),
+        ...(proxyConfig && { proxy: proxyConfig }),
+        ...(options.x402 && { x402: options.x402 }),
+        ...(options.insecure && { insecure: true }),
+        ...(isReconnect && { status: 'active' }),
+    };
+    if (isReconnect) {
+        await updateSession(name, sessionUpdate);
+        logger.debug(`Session record updated for reconnect: ${name}`);
+    }
+    else {
+        await saveSession(name, {
+            server: sessionTransportConfig,
+            createdAt: new Date().toISOString(),
+            status: 'connecting',
+            lastConnectionAttemptAt: new Date().toISOString(),
+            ...sessionUpdate,
+        });
+        logger.debug(`Initial session record created for: ${name}`);
+    }
+    try {
+        const bridgeOptions = {
+            sessionName: name,
+            serverConfig,
+            verbose: options.verbose || false,
+            ...(headers && { headers }),
+            ...(profileName && { profileName }),
+            ...(proxyConfig && { proxyConfig }),
+            ...(options.x402 && { x402: options.x402 }),
+            ...(options.insecure && { insecure: true }),
+        };
+        const { pid } = await startBridge(bridgeOptions);
+        await updateSession(name, { pid, status: 'active' });
+        logger.debug(`Session ${name} updated with bridge PID: ${pid}`);
+    }
+    catch (error) {
+        logger.debug(`Bridge start failed, cleaning up session ${name}`);
+        if (!isReconnect) {
+            try {
+                await deleteSession(name);
+            }
+            catch {
+            }
+        }
+        throw error;
+    }
+    if (options.skipDetails) {
+        if (options.outputMode === 'human' && !options.quiet) {
+            console.log(formatSuccess(`Session ${name} ${isReconnect ? 'reconnected' : 'created'}`));
+        }
+        return;
+    }
+    try {
+        await renderConnectedSession(name, 'created', options);
+        if (options.outputMode === 'human') {
+            console.log(formatSuccess(`Session ${name} ${isReconnect ? 'reconnected' : 'created'}`));
+        }
+    }
+    catch (detailsError) {
+        if (detailsError instanceof AuthError) {
+            throw detailsError;
+        }
+        if (detailsError instanceof Error && isAuthenticationError(detailsError.message)) {
+            throw createServerAuthError(serverConfig.url || target, { sessionName: name });
+        }
+        const errorMsg = detailsError instanceof Error ? detailsError.message : String(detailsError);
+        if (options.outputMode === 'json') {
+            const failed = {
+                _mcpc: {
+                    sessionName: name,
+                    status: 'failed',
+                    error: errorMsg,
+                },
+            };
+            console.log(formatOutput([failed], 'json'));
+        }
+        else {
+            console.log(formatWarning(`Session ${name} created but server is not responding: ${errorMsg}\n` +
+                `  The session will auto-recover when the server becomes available.\n` +
+                `  Check status with: mcpc ${name}`));
+        }
+        logger.debug(`showServerDetails failed for new session ${name}: ${errorMsg}`);
+    }
+}
+async function findMatchingSession(parsed, options) {
+    const storage = await loadSessions();
+    const sessions = Object.values(storage.sessions);
+    if (sessions.length === 0)
+        return undefined;
+    const effectiveProfile = options.noProfile ? undefined : (options.profile ?? 'default');
+    for (const session of sessions) {
+        if (!session.server)
+            continue;
+        if (parsed.type === 'url') {
+            if (!session.server.url)
+                continue;
+            try {
+                const existingUrl = normalizeServerUrl(session.server.url);
+                const newUrl = normalizeServerUrl(parsed.url);
+                if (existingUrl !== newUrl)
+                    continue;
+            }
+            catch {
+                continue;
+            }
+        }
+        else {
+            continue;
+        }
+        const sessionProfile = session.profileName ?? 'default';
+        if (effectiveProfile !== sessionProfile)
+            continue;
+        const existingHeaderKeys = Object.keys(session.server.headers || {}).sort();
+        const newHeaderKeys = (options.headers || [])
+            .map((h) => h.split(':')[0]?.trim() || '')
+            .filter(Boolean)
+            .sort();
+        if (existingHeaderKeys.join(',') !== newHeaderKeys.join(','))
+            continue;
+        return session.name;
+    }
+    return undefined;
+}
+export async function resolveSessionName(parsed, options) {
+    const existingName = await findMatchingSession(parsed, options);
+    if (existingName) {
+        return existingName;
+    }
+    const candidateName = generateSessionName(parsed);
+    const storage = await loadSessions();
+    if (!(candidateName in storage.sessions)) {
+        if (options.outputMode === 'human') {
+            console.log(theme.cyan(`Using session name: ${candidateName}`));
+        }
+        return candidateName;
+    }
+    for (let i = 2; i <= 99; i++) {
+        const suffixed = `${candidateName}-${i}`;
+        if (isValidSessionName(suffixed) && !(suffixed in storage.sessions)) {
+            if (options.outputMode === 'human') {
+                console.log(theme.cyan(`Using session name: ${suffixed}`));
+            }
+            return suffixed;
+        }
+    }
+    throw new ClientError(`Cannot auto-generate session name: too many sessions for this server.\n` +
+        `Specify a name explicitly: mcpc connect ${parsed.type === 'url' ? parsed.url : `${parsed.file}:${parsed.entry}`} @my-session`);
+}
+function skippedConnectEntry(entry, skipReason) {
+    return {
+        _mcpc: {
+            sessionName: entry.sessionName,
+            configFile: entry.configFile,
+            entry: entry.entry,
+            status: 'skipped',
+            skipReason,
+        },
+    };
+}
+async function waitForSessionReady(sessionName, options) {
+    try {
+        await withMcpClient(sessionName, {
+            outputMode: 'json',
+            hideTarget: true,
+            ...(options.verbose && { verbose: options.verbose }),
+            ...(options.timeout !== undefined && { timeout: options.timeout }),
+        }, async (client) => {
+            await client.getServerDetails();
+        });
+        return { ready: true };
+    }
+    catch (error) {
+        return { ready: false, error: error instanceof Error ? error.message : String(error) };
+    }
+}
+async function waitForBulkConnectReady(results, options, onSettled) {
+    return Promise.all(results.map(async (r) => {
+        try {
+            if (r.status !== 'created')
+                return r;
+            const ready = await waitForSessionReady(r.sessionName, options);
+            return ready.ready ? r : { ...r, status: 'failed', error: ready.error };
+        }
+        finally {
+            onSettled?.();
+        }
+    }));
+}
+async function bulkConnectEntries(entries, options, { printBadges = true } = {}) {
+    const liveSet = new Set();
+    for (const { sessionName } of entries) {
+        const session = await getSession(sessionName);
+        if (session && getBridgeStatus(session) === 'live') {
+            liveSet.add(sessionName);
+        }
+    }
+    const settled = await Promise.allSettled(entries.map(async ({ entry, sessionName, configFile }) => connectSession(entry, sessionName, {
+        ...options,
+        config: configFile,
+        skipDetails: true,
+        quiet: true,
+    })));
+    let results = settled.map((outcome, i) => {
+        const base = entries[i];
+        if (outcome.status === 'fulfilled') {
+            return { ...base, status: liveSet.has(base.sessionName) ? 'active' : 'created' };
+        }
+        const error = outcome.reason instanceof Error ? outcome.reason.message : String(outcome.reason);
+        return { ...base, status: 'failed', error };
+    });
+    if (options.outputMode === 'human' && results.some((r) => r.status === 'created')) {
+        const total = results.length;
+        let done = 0;
+        const spinner = ora(`Connecting to ${total} server${total === 1 ? '' : 's'}...`).start();
+        results = await waitForBulkConnectReady(results, options, () => {
+            done += 1;
+            spinner.text = `Connecting to servers... (${done}/${total})`;
+        });
+        spinner.stop();
+    }
+    if (options.outputMode === 'human' && printBadges) {
+        for (const r of results) {
+            const name = theme.cyan(r.sessionName);
+            switch (r.status) {
+                case 'created':
+                    console.log(`  ${theme.green('●')} ${name} ${theme.green('live')}`);
+                    break;
+                case 'active':
+                    console.log(`  ${theme.green('●')} ${name} ${chalk.dim('already active')}`);
+                    break;
+                case 'failed':
+                    console.log(`  ${theme.red('●')} ${name} ${theme.red('failed')}${r.error ? chalk.dim(` — ${r.error}`) : ''}`);
+                    break;
+            }
+        }
+    }
+    return results;
+}
+function printBulkConnectSummary(results, options) {
+    const active = results.filter((r) => r.status === 'active').length;
+    const connected = results.filter((r) => r.status === 'created').length;
+    const failed = results.filter((r) => r.status === 'failed').length;
+    if (options.outputMode === 'human' && results.length > 1) {
+        const parts = [];
+        if (connected > 0)
+            parts.push(`${connected} connected`);
+        if (active > 0)
+            parts.push(`${active} already active`);
+        if (failed > 0)
+            parts.push(`${failed} failed`);
+        const summary = parts.join(', ');
+        if (failed === 0) {
+            console.log(formatSuccess(summary));
+        }
+        else if (active + connected > 0) {
+            console.log(formatWarning(summary));
+        }
+    }
+    return { active, connected, failed };
+}
+async function buildBulkConnectEntries(results, options) {
+    return await Promise.all(results.map(async (r) => {
+        if (r.status === 'failed') {
+            return {
+                _mcpc: {
+                    sessionName: r.sessionName,
+                    configFile: r.configFile,
+                    entry: r.entry,
+                    status: 'failed',
+                    ...(r.error && { error: r.error }),
+                },
+            };
+        }
+        try {
+            return await buildConnectResultEntry(r.sessionName, r.status, {
+                ...(options.verbose && { verbose: options.verbose }),
+                ...(options.timeout !== undefined && { timeout: options.timeout }),
+                configFile: r.configFile,
+                entry: r.entry,
+            });
+        }
+        catch (err) {
+            return {
+                _mcpc: {
+                    sessionName: r.sessionName,
+                    configFile: r.configFile,
+                    entry: r.entry,
+                    status: 'failed',
+                    error: err instanceof Error ? err.message : String(err),
+                },
+            };
+        }
+    }));
+}
+export async function connectAllFromConfig(configFile, options) {
+    const config = loadConfig(configFile);
+    const allNames = listServers(config);
+    if (allNames.length === 0) {
+        throw new ClientError(`No servers found in config file: ${configFile}`);
+    }
+    const stdioSkipped = [];
+    const serverNames = allNames.filter((name) => {
+        if (!options.stdio && isStdioEntry(config, name)) {
+            stdioSkipped.push(name);
+            return false;
+        }
+        return true;
+    });
+    const toSkippedStdioEntry = (entry) => skippedConnectEntry({
+        sessionName: generateSessionName({ type: 'config', file: configFile, entry }),
+        configFile,
+        entry,
+    }, 'stdio');
+    if (serverNames.length === 0) {
+        if (options.outputMode === 'json') {
+            console.log(formatOutput(stdioSkipped.map(toSkippedStdioEntry), 'json'));
+            return;
+        }
+        throw new ClientError(`All ${allNames.length} server${allNames.length === 1 ? '' : 's'} in ${configFile} use stdio transport.\n` +
+            `Pass --stdio to include them: mcpc connect ${configFile} --stdio`);
+    }
+    if (options.outputMode === 'human') {
+        console.log(theme.cyan(`Connecting ${serverNames.length} server${serverNames.length === 1 ? '' : 's'} from ${configFile}...`));
+        if (stdioSkipped.length > 0) {
+            console.log(chalk.dim(`  skipping ${stdioSkipped.length} stdio server${stdioSkipped.length === 1 ? '' : 's'} ` +
+                `(${stdioSkipped.join(', ')}), pass --stdio to include`));
+        }
+    }
+    const entries = serverNames.map((entry) => ({
+        configFile,
+        entry,
+        sessionName: generateSessionName({ type: 'config', file: configFile, entry }),
+    }));
+    const results = await bulkConnectEntries(entries, options);
+    if (options.outputMode === 'json') {
+        const resultEntries = await buildBulkConnectEntries(results, options);
+        console.log(formatOutput([...resultEntries, ...stdioSkipped.map(toSkippedStdioEntry)], 'json'));
+        return;
+    }
+    const { active, connected, failed } = printBulkConnectSummary(results, options);
+    if (active + connected === 0 && failed > 0) {
+        throw new ClientError(`Failed to connect any servers from ${configFile}`);
+    }
+}
+function aggregateDiscoveredEntries(discovered, options) {
+    const entries = [];
+    const skippedDuplicates = [];
+    const skippedStdio = [];
+    const seenNames = new Set();
+    for (const d of discovered) {
+        for (const entry of Object.keys(d.config.mcpServers)) {
+            const sessionName = generateSessionName({ type: 'config', file: d.path, entry });
+            if (!options.stdio && isStdioEntry(d.config, entry)) {
+                skippedStdio.push({ configFile: d.path, entry, sessionName });
+                continue;
+            }
+            if (seenNames.has(sessionName)) {
+                skippedDuplicates.push({ configFile: d.path, entry, sessionName });
+                continue;
+            }
+            seenNames.add(sessionName);
+            entries.push({
+                configFile: d.path,
+                entry,
+                sessionName,
+            });
+        }
+    }
+    return { entries, skippedDuplicates, skippedStdio };
+}
+function buildNoServersError(scan) {
+    if (scan.empty.length > 0 || scan.errors.length > 0) {
+        const lines = [];
+        if (scan.empty.length > 0) {
+            lines.push(scan.empty.length === 1
+                ? `Found a config file, but it defines no servers:`
+                : `Found config files, but they define no servers:`);
+            for (const c of scan.empty)
+                lines.push(`  ${formatPath(c.path)}`);
+        }
+        if (scan.errors.length > 0) {
+            if (lines.length > 0)
+                lines.push('');
+            lines.push(scan.errors.length === 1
+                ? `Found a config file, but it couldn't be used:`
+                : `Found config files, but they couldn't be used:`);
+            for (const c of scan.errors)
+                lines.push(`  ${formatPath(c.path)} — ${c.error}`);
+        }
+        return (`No MCP servers to connect.\n\n` +
+            `${lines.join('\n')}\n\n` +
+            `Add a server under "mcpServers" and re-run mcpc connect, or connect one now:\n` +
+            `  mcpc connect mcp.example.com @myserver`);
+    }
+    const searchPaths = getStandardMcpConfigPaths()
+        .map((c) => `  ${formatPath(c.path)}`)
+        .join('\n');
+    return (`No MCP config files found in standard locations.\n\n` +
+        `Searched:\n${searchPaths}\n\n` +
+        `Connect a specific server:    mcpc connect mcp.example.com\n` +
+        `Connect from a specific file: mcpc connect /path/to/mcp.json`);
+}
+export async function connectAllFromStandardConfigs(options) {
+    const scan = scanMcpConfigFiles();
+    const { discovered } = scan;
+    if (discovered.length === 0) {
+        if (options.outputMode === 'json') {
+            console.log(formatOutput([], 'json'));
+            return;
+        }
+        throw new ClientError(buildNoServersError(scan));
+    }
+    const { entries, skippedDuplicates, skippedStdio } = aggregateDiscoveredEntries(discovered, {
+        ...(options.stdio && { stdio: true }),
+    });
+    const results = entries.length > 0 ? await bulkConnectEntries(entries, options, { printBadges: false }) : [];
+    if (options.outputMode === 'json') {
+        const skippedJsonEntries = [
+            ...skippedStdio.map((s) => skippedConnectEntry(s, 'stdio')),
+            ...skippedDuplicates.map((s) => skippedConnectEntry(s, 'duplicate')),
+        ];
+        if (entries.length === 0) {
+            console.log(formatOutput(skippedJsonEntries, 'json'));
+            return;
+        }
+        const resultEntries = await buildBulkConnectEntries(results, options);
+        console.log(formatOutput([...resultEntries, ...skippedJsonEntries], 'json'));
+        return;
+    }
+    const totalEntries = entries.length + skippedDuplicates.length + skippedStdio.length;
+    const fileCount = discovered.length + scan.empty.length + scan.errors.length;
+    console.log(theme.cyan(`Found ${fileCount} MCP config file${fileCount === 1 ? '' : 's'} ` +
+        `with ${totalEntries} server${totalEntries === 1 ? '' : 's'}:`));
+    const statusByName = new Map(results.map((r) => [r.sessionName, r]));
+    const liveSkippedStdio = new Set();
+    for (const s of skippedStdio) {
+        const session = await getSession(s.sessionName);
+        if (session && getBridgeStatus(session) === 'live') {
+            liveSkippedStdio.add(s.sessionName);
+        }
+    }
+    const unconnectedStdio = skippedStdio.length - liveSkippedStdio.size;
+    for (const d of discovered) {
+        console.log(`  ${formatPath(d.path)} ${chalk.dim(`(${d.serverCount} server${d.serverCount === 1 ? '' : 's'})`)}`);
+        for (const entryName of Object.keys(d.config.mcpServers)) {
+            const sessionName = generateSessionName({ type: 'config', file: d.path, entry: entryName });
+            const serverCfg = d.config.mcpServers[entryName];
+            const target = serverCfg?.url ?? [serverCfg?.command, ...(serverCfg?.args ?? [])].join(' ');
+            const truncated = target && target.length > 72 ? target.slice(0, 72) + '…' : target;
+            let marker;
+            if (skippedStdio.some((s) => s.configFile === d.path && s.entry === entryName)) {
+                marker = liveSkippedStdio.has(sessionName)
+                    ? formatConnectStatusBadge('active')
+                    : theme.yellow('○ skipped (stdio)');
+            }
+            else if (skippedDuplicates.some((s) => s.configFile === d.path && s.entry === entryName)) {
+                marker = chalk.dim('○ skipped (duplicate)');
+            }
+            else {
+                const r = statusByName.get(sessionName);
+                marker = r ? formatConnectStatusBadge(r.status, r.error) : '';
+            }
+            console.log(`    ${theme.cyan(sessionName)} → ${chalk.dim(truncated ?? entryName)}${marker ? ` ${marker}` : ''}`);
+        }
+    }
+    for (const c of scan.empty) {
+        console.log(`  ${formatPath(c.path)} ${chalk.dim('(0 servers)')}`);
+    }
+    for (const c of scan.errors) {
+        console.log(`  ${formatPath(c.path)} ${chalk.dim('(invalid)')}`);
+        console.log(`    ${chalk.dim(c.error)}`);
+    }
+    if (entries.length === 0 && liveSkippedStdio.size === 0) {
+        throw new ClientError(`All servers in discovered config files use stdio transport.\n` +
+            `Pass --stdio to include them: mcpc connect --stdio`);
+    }
+    if (unconnectedStdio > 0) {
+        console.log('\nTo include stdio servers, run: mcpc connect --stdio');
+    }
+    const failed = results.filter((r) => r.status === 'failed').length;
+    const succeeded = results.filter((r) => r.status === 'active' || r.status === 'created').length;
+    if (entries.length > 0 && succeeded === 0 && failed > 0) {
+        throw new ClientError(`Failed to connect any servers from discovered config files`);
+    }
+}
+//# sourceMappingURL=connect.js.map