@apify/mcpc 0.3.0 → 0.3.1

package/dist/cli/commands/sessions.js

@@ -1,347 +1,20 @@
-import { createServer } from 'net';
-import { isValidSessionName, generateSessionName, normalizeServerUrl, validateProfileName, isProcessAlive, getServerHost, getLogsDir, redactHeaders, } from '../../lib/index.js';
+import { isProcessAlive, getServerHost, redactHeaders, ClientError, } from '../../lib/index.js';
 import { DISCONNECTED_THRESHOLD_MS } from '../../lib/types.js';
 import { formatOutput, formatSuccess, formatWarning, formatError, formatSessionLine, formatServerDetails, theme, } from '../output.js';
-import { withMcpClient, resolveTarget, resolveAuthProfile } from '../helpers.js';
+import { withMcpClient, resolveAuthProfile } from '../helpers.js';
 import { listAuthProfiles } from '../../lib/auth/profiles.js';
-import { sessionExists, deleteSession, saveSession, updateSession, consolidateSessions, getSession, loadSessions, } from '../../lib/sessions.js';
+import { sessionExists, deleteSession, updateSession, consolidateSessions, getSession, } from '../../lib/sessions.js';
 import { startBridge, stopBridge, reconnectCrashedSessions, } from '../../lib/bridge-manager.js';
-import { storeKeychainSessionHeaders, storeKeychainProxyBearerToken, } from '../../lib/auth/keychain.js';
-import { AuthError, ClientError, isAuthenticationError, createServerAuthError, } from '../../lib/index.js';
-import { getWallet } from '../../lib/wallets.js';
 import chalk from 'chalk';
 import { createLogger } from '../../lib/logger.js';
-import { parseProxyArg } from '../parser.js';
-import { loadConfig, listServers, isStdioEntry, discoverMcpConfigFiles, getStandardMcpConfigPaths, } from '../../lib/config.js';
+import { getBridgeLogPath } from '../../lib/log-reader.js';
 const logger = createLogger('sessions');
-async function checkPortAvailable(host, port) {
-    return new Promise((resolve) => {
-        const server = createServer();
-        server.once('error', (err) => {
-            if (err.code === 'EADDRINUSE') {
-                resolve(false);
-            }
-            else {
-                resolve(false);
-            }
-        });
-        server.once('listening', () => {
-            server.close(() => {
-                resolve(true);
-            });
-        });
-        server.listen(port, host);
-    });
-}
-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`);
-}
-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,
-            },
-            ...(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) }),
-        };
-    });
-}
-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) {
-                if (options.outputMode === 'json') {
-                    const entry = await buildConnectResultEntry(name, 'active', {
-                        ...(options.verbose && { verbose: options.verbose }),
-                        ...(options.timeout !== undefined && { timeout: options.timeout }),
-                    });
-                    console.log(formatOutput([entry], 'json'));
-                }
-                else {
-                    await showServerDetails(name, { ...options, hideTarget: false });
-                }
-            }
-            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 (Object.keys(serverConfig.headers || {}).length > 0) {
-        headers = { ...serverConfig.headers };
-        if (Object.keys(headers).length > 0) {
-            logger.debug(`Storing ${Object.keys(headers).length} headers for session ${name} in keychain`);
-            await storeKeychainSessionHeaders(name, headers);
-        }
-        else {
-            headers = undefined;
-        }
-    }
-    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: true }),
-        ...(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: serverConfig,
-            verbose: options.verbose || false,
-        };
-        if (headers) {
-            bridgeOptions.headers = headers;
-        }
-        if (profileName) {
-            bridgeOptions.profileName = profileName;
-        }
-        if (proxyConfig) {
-            bridgeOptions.proxyConfig = proxyConfig;
-        }
-        if (options.x402) {
-            bridgeOptions.x402 = true;
-        }
-        if (options.insecure) {
-            bridgeOptions.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 {
-        if (options.outputMode === 'json') {
-            const entry = await buildConnectResultEntry(name, 'created', {
-                ...(options.verbose && { verbose: options.verbose }),
-                ...(options.timeout !== undefined && { timeout: options.timeout }),
-            });
-            console.log(formatOutput([entry], 'json'));
-        }
-        else {
-            await showServerDetails(name, {
-                ...options,
-                hideTarget: false,
-            });
-            console.log(formatSuccess(`Session ${name} ${isReconnect ? 'reconnected' : 'created'}`));
-        }
-    }
-    catch (detailsError) {
-        if (detailsError instanceof AuthError) {
-            throw detailsError;
-        }
-        if (detailsError instanceof Error && isAuthenticationError(detailsError.message)) {
-            const logPath = `${getLogsDir()}/bridge-${name}.log`;
-            throw createServerAuthError(serverConfig.url || target, { sessionName: name, logPath });
-        }
-        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}`);
-    }
+export function statelessField(connectionMode) {
+    if (connectionMode === 'stateless')
+        return { stateless: true };
+    if (connectionMode === 'stateful')
+        return { stateless: false };
+    return { stateless: null };
 }
 export function getBridgeStatus(session) {
     if (session.status === 'unauthorized') {
@@ -402,9 +75,12 @@ export function formatTimeAgo(isoDate) {
         return 'yesterday';
     if (diffDays < 7)
         return `${diffDays} days ago`;
-    if (diffDays < 30)
-        return `${Math.floor(diffDays / 7)} weeks ago`;
-    return `${Math.floor(diffDays / 30)} months ago`;
+    if (diffDays < 30) {
+        const weeks = Math.floor(diffDays / 7);
+        return `${weeks} ${weeks === 1 ? 'week' : 'weeks'} ago`;
+    }
+    const months = Math.floor(diffDays / 30);
+    return `${months} ${months === 1 ? 'month' : 'months'} ago`;
 }
 export async function listSessionsAndAuthProfiles(options) {
     const consolidateResult = await consolidateSessions(false);
@@ -412,9 +88,10 @@ export async function listSessionsAndAuthProfiles(options) {
     reconnectCrashedSessions(consolidateResult.sessionsToRestart);
     const profiles = await listAuthProfiles();
     if (options.outputMode === 'json') {
-        const sessionsWithStatus = sessions.map((session) => ({
+        const sessionsWithStatus = sessions.map(({ connectionMode, ...session }) => ({
             ...session,
             status: getBridgeStatus(session),
+            ...statelessField(connectionMode),
         }));
         console.log(formatOutput({
             sessions: sessionsWithStatus,
@@ -478,6 +155,7 @@ export async function listSessionsAndAuthProfiles(options) {
             }
         }
     }
+    return { hasSessions: sessions.length > 0 };
 }
 export async function closeSession(name, options) {
     try {
@@ -513,7 +191,7 @@ export async function closeSession(name, options) {
 export async function showServerDetails(target, options) {
     await withMcpClient(target, options, async (client, context) => {
         const serverDetails = await client.getServerDetails();
-        const { serverInfo, capabilities, instructions, protocolVersion } = serverDetails;
+        const { serverInfo, capabilities, instructions, protocolVersion, connectionMode } = serverDetails;
         const cachedToolsResult = await client.listAllTools();
         const tools = cachedToolsResult.tools;
         if (options.outputMode === 'human') {
@@ -526,11 +204,17 @@ export async function showServerDetails(target, options) {
                     headers: redactHeaders(context.serverConfig.headers),
                 }),
             };
+            let logPath;
+            if (target.startsWith('@')) {
+                logPath = getBridgeLogPath(target);
+            }
             console.log(formatOutput({
                 _mcpc: {
                     sessionName: context.sessionName,
                     profileName: context.profileName,
                     server,
+                    ...statelessField(connectionMode),
+                    ...(logPath && { logPath }),
                 },
                 protocolVersion,
                 capabilities,
@@ -561,14 +245,6 @@ export async function restartSession(name, options) {
         }
         const { readKeychainSessionHeaders } = await import('../../lib/auth/keychain.js');
         const headers = await readKeychainSessionHeaders(name);
-        const bridgeOptions = {
-            sessionName: name,
-            serverConfig: { ...serverConfig, ...(headers && { headers }) },
-            verbose: options.verbose || false,
-        };
-        if (headers) {
-            bridgeOptions.headers = headers;
-        }
         const hasExplicitAuthHeader = headers?.Authorization !== undefined;
         let profileName = session.profileName;
         if (!profileName && serverConfig.url && !hasExplicitAuthHeader && !session.x402) {
@@ -580,18 +256,16 @@ export async function restartSession(name, options) {
                 await updateSession(name, { profileName });
             }
         }
-        if (profileName) {
-            bridgeOptions.profileName = profileName;
-        }
-        if (session.proxy) {
-            bridgeOptions.proxyConfig = session.proxy;
-        }
-        if (session.x402) {
-            bridgeOptions.x402 = session.x402;
-        }
-        if (session.insecure) {
-            bridgeOptions.insecure = session.insecure;
-        }
+        const bridgeOptions = {
+            sessionName: name,
+            serverConfig: { ...serverConfig, ...(headers && { headers }) },
+            verbose: options.verbose || false,
+            ...(headers && { headers }),
+            ...(profileName && { profileName }),
+            ...(session.proxy && { proxyConfig: session.proxy }),
+            ...(session.x402 && { x402: session.x402 }),
+            ...(session.insecure && { insecure: session.insecure }),
+        };
         const { pid } = await startBridge(bridgeOptions);
         await updateSession(name, { pid, status: 'active' });
         logger.debug(`Session ${name} restarted with bridge PID: ${pid}`);
@@ -618,335 +292,8 @@ export async function restartSession(name, options) {
         throw error;
     }
 }
-async function bulkConnectEntries(entries, options) {
-    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,
-    })));
-    const 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') {
-        for (const r of results) {
-            const name = theme.cyan(r.sessionName);
-            switch (r.status) {
-                case 'created':
-                    console.log(`  ${theme.yellow('●')} ${name} ${theme.yellow('connecting')}`);
-                    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 connecting = 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 (active > 0)
-            parts.push(`${active} already active`);
-        if (connecting > 0)
-            parts.push(`${connecting} connecting`);
-        if (failed > 0)
-            parts.push(`${failed} failed`);
-        const summary = parts.join(', ');
-        if (failed === 0) {
-            console.log(formatSuccess(summary));
-        }
-        else if (active + connecting > 0) {
-            console.log(formatWarning(summary));
-        }
-    }
-    return { active, connecting, failed };
-}
-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;
-    });
-    if (serverNames.length === 0) {
-        if (options.outputMode === 'json') {
-            const skippedEntries = stdioSkipped.map((entry) => ({
-                _mcpc: {
-                    sessionName: generateSessionName({ type: 'config', file: configFile, entry }),
-                    configFile,
-                    entry,
-                    status: 'skipped',
-                    skipReason: 'stdio',
-                },
-            }));
-            console.log(formatOutput(skippedEntries, '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);
-        const skippedEntries = stdioSkipped.map((entry) => ({
-            _mcpc: {
-                sessionName: generateSessionName({ type: 'config', file: configFile, entry }),
-                configFile,
-                entry,
-                status: 'skipped',
-                skipReason: 'stdio',
-            },
-        }));
-        console.log(formatOutput([...resultEntries, ...skippedEntries], 'json'));
-        return;
-    }
-    const { active, connecting, failed } = printBulkConnectSummary(results, options);
-    if (active + connecting === 0 && failed > 0) {
-        throw new ClientError(`Failed to connect any servers from ${configFile}`);
-    }
-}
-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),
-                },
-            };
-        }
-    }));
-}
-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 };
-}
-export async function connectAllFromStandardConfigs(options) {
-    const discovered = discoverMcpConfigFiles();
-    const hasApifyToken = !!process.env.APIFY_API_TOKEN;
-    if (discovered.length === 0 && !hasApifyToken) {
-        if (options.outputMode === 'json') {
-            console.log(formatOutput([], 'json'));
-            return;
-        }
-        const searchPaths = getStandardMcpConfigPaths()
-            .map((c) => `  ${c.path}`)
-            .join('\n');
-        throw new ClientError(`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`);
-    }
-    if (discovered.length === 0) {
-        await maybeConnectApify([], [], options);
-        return;
-    }
-    const { entries, skippedDuplicates, skippedStdio } = aggregateDiscoveredEntries(discovered, {
-        ...(options.stdio && { stdio: true }),
-    });
-    if (options.outputMode === 'human') {
-        const totalEntries = entries.length + skippedDuplicates.length + skippedStdio.length;
-        console.log(theme.cyan(`Found ${discovered.length} MCP config file${discovered.length === 1 ? '' : 's'} ` +
-            `with ${totalEntries} server${totalEntries === 1 ? '' : 's'}:`));
-        for (const d of discovered) {
-            console.log(`  ${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;
-                const isStdio = skippedStdio.some((s) => s.configFile === d.path && s.entry === entryName);
-                const isDuplicate = skippedDuplicates.some((s) => s.configFile === d.path && s.entry === entryName);
-                if (isStdio) {
-                    console.log(`    ${theme.cyan(sessionName)} → ${chalk.dim(truncated ?? entryName)} ${theme.yellow('○ skipped (stdio)')}`);
-                }
-                else if (isDuplicate) {
-                    console.log(`    ${theme.cyan(sessionName)} → ${chalk.dim(truncated ?? entryName)} ${chalk.dim('○ skipped (duplicate)')}`);
-                }
-                else {
-                    console.log(`    ${theme.cyan(sessionName)} → ${chalk.dim(truncated ?? entryName)}`);
-                }
-            }
-        }
-        if (entries.length === 0 && !hasApifyToken) {
-            throw new ClientError(`All servers in discovered config files use stdio transport.\n` +
-                `Pass --stdio to include them: mcpc connect --stdio`);
-        }
-        const parts = [];
-        if (entries.length > 0) {
-            parts.push(`Connecting ${entries.length} server${entries.length === 1 ? '' : 's'}`);
-        }
-        if (skippedStdio.length > 0) {
-            parts.push(`skipped ${skippedStdio.length} stdio server${skippedStdio.length === 1 ? '' : 's'}, pass --stdio to include`);
-        }
-        if (parts.length > 0) {
-            console.log(theme.cyan(`\n${parts.join('. ')}.`));
-        }
-    }
-    const skippedJsonEntries = [
-        ...skippedStdio.map((s) => ({
-            _mcpc: {
-                sessionName: s.sessionName,
-                configFile: s.configFile,
-                entry: s.entry,
-                status: 'skipped',
-                skipReason: 'stdio',
-            },
-        })),
-        ...skippedDuplicates.map((s) => ({
-            _mcpc: {
-                sessionName: s.sessionName,
-                configFile: s.configFile,
-                entry: s.entry,
-                status: 'skipped',
-                skipReason: 'duplicate',
-            },
-        })),
-    ];
-    if (entries.length === 0) {
-        if (!hasApifyToken && options.outputMode === 'json') {
-            console.log(formatOutput(skippedJsonEntries, 'json'));
-            return;
-        }
-        await maybeConnectApify([], [], options);
-        return;
-    }
-    const results = await bulkConnectEntries(entries, options);
-    if (options.outputMode === 'json') {
-        const resultEntries = await buildBulkConnectEntries(results, options);
-        console.log(formatOutput([...resultEntries, ...skippedJsonEntries], 'json'));
-        return;
-    }
-    const { active, connecting, failed } = printBulkConnectSummary(results, options);
-    await maybeConnectApify(entries, results, options);
-    if (active + connecting === 0 && failed > 0) {
-        throw new ClientError(`Failed to connect any servers from discovered config files`);
-    }
-}
-const APIFY_MCP_URL = 'https://mcp.apify.com';
-const APIFY_SESSION_NAME = '@apify';
-async function maybeConnectApify(configEntries, configResults, options) {
-    const token = process.env.APIFY_API_TOKEN;
-    if (!token)
-        return;
-    if (configEntries.some((e) => e.sessionName === APIFY_SESSION_NAME))
-        return;
-    if (configResults.some((r) => r.sessionName === APIFY_SESSION_NAME))
-        return;
-    const existing = await getSession(APIFY_SESSION_NAME);
-    const isLive = existing && getBridgeStatus(existing) === 'live';
-    if (options.outputMode === 'human') {
-        console.log(theme.cyan(`\nAPIFY_API_TOKEN detected, connecting to ${APIFY_MCP_URL}...`));
-    }
-    if (isLive) {
-        if (options.outputMode === 'human') {
-            console.log(`  ${theme.green('●')} ${theme.cyan(APIFY_SESSION_NAME)} ${chalk.dim('already active')}`);
-        }
-        return;
-    }
-    try {
-        await connectSession(APIFY_MCP_URL, APIFY_SESSION_NAME, {
-            outputMode: options.outputMode,
-            ...(options.verbose && { verbose: true }),
-            headers: [`Authorization: Bearer ${token}`],
-            skipDetails: true,
-            quiet: true,
-            noProfile: true,
-        });
-        if (options.outputMode === 'human') {
-            console.log(`  ${theme.yellow('●')} ${theme.cyan(APIFY_SESSION_NAME)} ${theme.yellow('connecting')}`);
-        }
-    }
-    catch (error) {
-        const msg = error instanceof Error ? error.message : String(error);
-        if (options.outputMode === 'human') {
-            console.log(`  ${theme.red('●')} ${theme.cyan(APIFY_SESSION_NAME)} ${theme.red('failed')}${chalk.dim(` — ${msg}`)}`);
-        }
-    }
-}
 export async function openShell(target) {
+    console.error(formatWarning('The "shell" command is deprecated and will be removed in a future release.'));
     const { startShell } = await import('../shell.js');
     await startShell(target);
 }