@apify/mcpc 0.2.4 → 0.3.0-beta.0

package/dist/cli/commands/sessions.js

@@ -1,10 +1,10 @@
 import { createServer } from 'net';
-import { isValidSessionName, validateProfileName, isProcessAlive, getServerHost, redactHeaders, } from '../../lib/index.js';
+import { isValidSessionName, generateSessionName, normalizeServerUrl, validateProfileName, isProcessAlive, getServerHost, getLogsDir, redactHeaders, } from '../../lib/index.js';
 import { DISCONNECTED_THRESHOLD_MS } from '../../lib/types.js';
-import { formatOutput, formatSuccess, formatError, formatSessionLine, formatServerDetails, } from '../output.js';
+import { formatOutput, formatSuccess, formatWarning, formatError, formatSessionLine, formatServerDetails, theme, } from '../output.js';
 import { withMcpClient, resolveTarget, resolveAuthProfile } from '../helpers.js';
 import { listAuthProfiles } from '../../lib/auth/profiles.js';
-import { sessionExists, deleteSession, saveSession, updateSession, consolidateSessions, getSession, } from '../../lib/sessions.js';
+import { sessionExists, deleteSession, saveSession, updateSession, consolidateSessions, getSession, loadSessions, } 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';
@@ -12,6 +12,7 @@ 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';
 const logger = createLogger('sessions');
 async function checkPortAvailable(host, port) {
     return new Promise((resolve) => {
@@ -32,6 +33,104 @@ async function checkPortAvailable(host, port) {
         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` +
@@ -57,14 +156,25 @@ export async function connectSession(target, name, options) {
     if (existingSession) {
         const bridgeStatus = getBridgeStatus(existingSession);
         if (bridgeStatus === 'live') {
-            if (options.outputMode === 'human') {
+            if (options.outputMode === 'human' && !options.quiet) {
                 console.log(formatSuccess(`Session ${name} is already active`));
             }
-            await showServerDetails(name, { ...options, hideTarget: false });
+            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') {
-            console.log(chalk.yellow(`Session ${name} exists but bridge is ${bridgeStatus}, reconnecting...`));
+        if (options.outputMode === 'human' && !options.quiet) {
+            console.log(theme.yellow(`Session ${name} exists but bridge is ${bridgeStatus}, reconnecting...`));
         }
         try {
             await stopBridge(name);
@@ -184,23 +294,53 @@ export async function connectSession(target, name, options) {
         }
         throw error;
     }
-    if (options.outputMode === 'human') {
-        console.log(formatSuccess(`Session ${name} ${isReconnect ? 'reconnected' : 'created'}`));
+    if (options.skipDetails) {
+        if (options.outputMode === 'human' && !options.quiet) {
+            console.log(formatSuccess(`Session ${name} ${isReconnect ? 'reconnected' : 'created'}`));
+        }
+        return;
     }
     try {
-        await showServerDetails(name, {
-            ...options,
-            hideTarget: false,
-        });
+        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)) {
-            throw createServerAuthError(serverConfig.url || target, { sessionName: name });
+            const logPath = `${getLogsDir()}/bridge-${name}.log`;
+            throw createServerAuthError(serverConfig.url || target, { sessionName: name, logPath });
         }
-        logger.debug(`showServerDetails failed for new session ${name}: ${detailsError.message}`);
+        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 getBridgeStatus(session) {
@@ -227,19 +367,19 @@ export function getBridgeStatus(session) {
 export function formatBridgeStatus(status) {
     switch (status) {
         case 'live':
-            return { dot: chalk.green('●'), text: chalk.green('live') };
+            return { dot: theme.green('●'), text: theme.green('live') };
         case 'connecting':
-            return { dot: chalk.yellow('●'), text: chalk.yellow('connecting') };
+            return { dot: theme.yellow('●'), text: theme.yellow('connecting') };
         case 'reconnecting':
-            return { dot: chalk.yellow('●'), text: chalk.yellow('reconnecting') };
+            return { dot: theme.yellow('●'), text: theme.yellow('reconnecting') };
         case 'disconnected':
-            return { dot: chalk.yellow('●'), text: chalk.yellow('disconnected') };
+            return { dot: theme.yellow('●'), text: theme.yellow('disconnected') };
         case 'crashed':
-            return { dot: chalk.yellow('○'), text: chalk.yellow('crashed') };
+            return { dot: theme.yellow('○'), text: theme.yellow('crashed') };
         case 'unauthorized':
-            return { dot: chalk.red('○'), text: chalk.red('unauthorized') };
+            return { dot: theme.red('○'), text: theme.red('unauthorized') };
         case 'expired':
-            return { dot: chalk.red('○'), text: chalk.red('expired') };
+            return { dot: theme.red('○'), text: theme.red('expired') };
     }
 }
 export function formatTimeAgo(isoDate) {
@@ -323,7 +463,7 @@ export async function listSessionsAndAuthProfiles(options) {
             console.log(chalk.bold('Saved OAuth profiles:'));
             for (const profile of profiles) {
                 const hostStr = getServerHost(profile.serverUrl);
-                const nameStr = chalk.magenta(profile.name);
+                const nameStr = theme.magenta(profile.name);
                 const userStr = profile.userEmail || profile.userName || '';
                 const timeAgo = formatTimeAgo(profile.refreshedAt || profile.createdAt);
                 const timeLabel = profile.refreshedAt ? 'refreshed' : 'created';
@@ -396,7 +536,7 @@ export async function showServerDetails(target, options) {
                 capabilities,
                 serverInfo,
                 instructions,
-                ...(tools.length > 0 && { tools }),
+                ...(tools.length > 0 && { toolNames: tools.map((t) => t.name) }),
             }, 'json'));
         }
     });
@@ -408,7 +548,7 @@ export async function restartSession(name, options) {
             throw new ClientError(`Session not found: ${name}`);
         }
         if (options.outputMode === 'human') {
-            console.log(chalk.yellow(`Restarting session ${name}...`));
+            console.log(theme.yellow(`Restarting session ${name}...`));
         }
         try {
             await stopBridge(name);
@@ -457,6 +597,7 @@ export async function restartSession(name, options) {
         logger.debug(`Session ${name} restarted with bridge PID: ${pid}`);
         if (options.outputMode === 'human') {
             console.log(formatSuccess(`Session ${name} restarted`));
+            console.log(chalk.dim('Note: previous session state was lost (e.g. added tools, resource subscriptions, async tasks)'));
         }
         await showServerDetails(name, {
             ...options,
@@ -477,8 +618,333 @@ export async function restartSession(name, options) {
         throw error;
     }
 }
-export async function showHelp(target, options) {
-    await showServerDetails(target, options);
+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) {
     const { startShell } = await import('../shell.js');