@apify/mcpc 0.1.11 → 0.2.0-beta.1

package/dist/cli/index.js

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
-import { EnvHttpProxyAgent, setGlobalDispatcher } from 'undici';
+import { initProxy } from '../lib/proxy.js';
 import { Command } from 'commander';
 import { setVerbose, setJsonMode, closeFileLogger } from '../lib/index.js';
-import { isMcpError, formatHumanError, NetworkError } from '../lib/index.js';
+import { isMcpError, formatHumanError, ClientError } from '../lib/index.js';
+import chalk from 'chalk';
 import { formatJson, formatJsonError, rainbow } from './output.js';
 import * as tools from './commands/tools.js';
 import * as resources from './commands/resources.js';
@@ -11,12 +12,16 @@ import * as sessions from './commands/sessions.js';
 import * as logging from './commands/logging.js';
 import * as utilities from './commands/utilities.js';
 import * as auth from './commands/auth.js';
+import * as tasks from './commands/tasks.js';
 import { handleX402Command } from './commands/x402.js';
 import { clean } from './commands/clean.js';
-import { findTarget, extractOptions, hasCommandAfterTarget, getVerboseFromEnv, getJsonFromEnv, validateOptions, validateCleanTypes, validateArgValues, KNOWN_COMMANDS, } from './parser.js';
+import { extractOptions, getVerboseFromEnv, getJsonFromEnv, validateOptions, validateArgValues, parseServerArg, hasSubcommand, optionTakesValue, KNOWN_COMMANDS, KNOWN_SESSION_COMMANDS, } from './parser.js';
 import { createRequire } from 'module';
 const { version: mcpcVersion } = createRequire(import.meta.url)('../../package.json');
-setGlobalDispatcher(new EnvHttpProxyAgent());
+{
+    const insecure = process.argv.includes('--insecure');
+    initProxy({ insecure });
+}
 function getOptionsFromCommand(command) {
     const opts = command.optsWithGlobals ? command.optsWithGlobals() : command.opts();
     const verbose = opts.verbose || getVerboseFromEnv();
@@ -28,25 +33,31 @@ function getOptionsFromCommand(command) {
     const options = {
         outputMode: (json ? 'json' : 'human'),
     };
-    if (opts.config)
-        options.config = opts.config;
-    if (opts.header) {
-        options.headers = Array.isArray(opts.header) ? opts.header : [opts.header];
+    if (opts.timeout) {
+        const timeout = parseInt(opts.timeout, 10);
+        if (isNaN(timeout) || timeout <= 0) {
+            throw new Error(`Invalid --timeout value: "${opts.timeout}". Must be a positive number (seconds).`);
+        }
+        options.timeout = timeout;
+    }
+    if (opts.profile === false) {
+        options.noProfile = true;
     }
-    if (opts.timeout)
-        options.timeout = parseInt(opts.timeout, 10);
-    if (opts.profile)
+    else if (opts.profile) {
         options.profile = opts.profile;
+    }
     if (verbose)
         options.verbose = verbose;
     if (opts.x402)
         options.x402 = true;
+    if (opts.insecure)
+        options.insecure = true;
     if (opts.schema)
         options.schema = opts.schema;
     if (opts.schemaMode) {
         const mode = opts.schemaMode;
         if (mode !== 'strict' && mode !== 'compatible' && mode !== 'ignore') {
-            throw new Error(`Invalid schema mode: ${mode}. Must be 'strict', 'compatible', or 'ignore'.`);
+            throw new Error(`Invalid --schema-mode value: "${mode}". Valid modes are: strict, compatible, ignore`);
         }
         options.schemaMode = mode;
     }
@@ -78,7 +89,14 @@ async function main() {
         return;
     }
     if (args.includes('--help') || args.includes('-h')) {
-        const program = createProgram();
+        if (args.includes('x402')) {
+            const x402Index = args.indexOf('x402');
+            const x402Args = args.slice(x402Index + 1);
+            await handleX402Command(x402Args);
+            await closeFileLogger();
+            return;
+        }
+        const program = createTopLevelProgram();
         await program.parseAsync(process.argv);
         return;
     }
@@ -87,37 +105,26 @@ async function main() {
         validateArgValues(args);
     }
     catch (error) {
-        console.error(formatHumanError(error, false));
+        console.error(chalk.red(formatHumanError(error, false)));
         process.exit(1);
     }
-    const cleanArg = args.find((arg) => arg === '--clean' || arg.startsWith('--clean='));
-    if (cleanArg) {
-        const options = extractOptions(args);
-        if (options.verbose)
-            setVerbose(true);
-        if (options.json)
-            setJsonMode(true);
-        const cleanValue = cleanArg.includes('=') ? cleanArg.split('=')[1] : '';
-        const cleanTypes = cleanValue ? cleanValue.split(',').map((s) => s.trim()) : [];
-        try {
-            validateCleanTypes(cleanTypes);
-        }
-        catch (error) {
-            console.error(formatHumanError(error, false));
-            process.exit(1);
+    let firstNonOption;
+    let firstNonOptionIndex = -1;
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (!arg)
+            continue;
+        if (arg.startsWith('-')) {
+            if (optionTakesValue(arg) && !arg.includes('=') && i + 1 < args.length) {
+                i++;
+            }
+            continue;
         }
-        await clean({
-            outputMode: options.json ? 'json' : 'human',
-            sessions: cleanTypes.includes('sessions'),
-            profiles: cleanTypes.includes('profiles'),
-            logs: cleanTypes.includes('logs'),
-            all: cleanTypes.includes('all'),
-        });
-        await closeFileLogger();
-        return;
+        firstNonOption = arg;
+        firstNonOptionIndex = i;
+        break;
     }
-    const targetInfo = findTarget(args);
-    if (!targetInfo) {
+    if (!firstNonOption) {
         const { json } = extractOptions(args);
         if (json)
             setJsonMode(true);
@@ -128,240 +135,420 @@ async function main() {
         await closeFileLogger();
         return;
     }
-    const { target, targetIndex } = targetInfo;
-    const modifiedArgs = [
-        ...process.argv.slice(0, 2),
-        ...args.slice(0, targetIndex),
-        ...args.slice(targetIndex + 1),
-    ];
-    if (target === 'x402') {
-        const x402Args = args.slice(targetIndex + 1);
-        await handleX402Command(x402Args);
-        await closeFileLogger();
-        return;
-    }
-    try {
-        await handleCommands(target, modifiedArgs);
-    }
-    catch (error) {
-        if (isMcpError(error)) {
-            const opts = extractOptions(args);
-            const outputMode = opts.json ? 'json' : 'human';
-            if (outputMode === 'json') {
-                console.error(formatJsonError(error, error.code));
+    if (firstNonOption.startsWith('@')) {
+        const session = firstNonOption;
+        const modifiedArgs = [
+            ...process.argv.slice(0, 2),
+            ...args.slice(0, firstNonOptionIndex),
+            ...args.slice(firstNonOptionIndex + 1),
+        ];
+        try {
+            await handleSessionCommands(session, modifiedArgs);
+        }
+        catch (error) {
+            if (isMcpError(error)) {
+                const opts = extractOptions(args);
+                const outputMode = opts.json ? 'json' : 'human';
+                if (outputMode === 'json') {
+                    console.error(formatJsonError(error, error.code));
+                }
+                else {
+                    console.error(chalk.red(formatHumanError(error, opts.verbose)));
+                }
+                process.exit(error.code);
             }
-            else {
-                console.error(formatHumanError(error, opts.verbose));
-                if (error instanceof NetworkError && KNOWN_COMMANDS.includes(target)) {
-                    console.error(`\nDid you mean "mcpc <target> ${target}" ?`);
-                    console.error(`Run "mcpc --help" for usage information.\n`);
-                    process.exit(error.code);
+            throw error;
+        }
+        finally {
+            await closeFileLogger();
+        }
+        await flushStdout();
+        process.exit(0);
+    }
+    if (KNOWN_COMMANDS.includes(firstNonOption)) {
+        if (firstNonOption === 'x402') {
+            const x402Args = args.slice(firstNonOptionIndex + 1);
+            await handleX402Command(x402Args);
+            await closeFileLogger();
+            return;
+        }
+        try {
+            const program = createTopLevelProgram();
+            await program.parseAsync(process.argv);
+        }
+        catch (error) {
+            if (isMcpError(error)) {
+                const opts = extractOptions(args);
+                const outputMode = opts.json ? 'json' : 'human';
+                if (outputMode === 'json') {
+                    console.error(formatJsonError(error, error.code));
+                }
+                else {
+                    console.error(chalk.red(formatHumanError(error, opts.verbose)));
                 }
+                process.exit(error.code);
             }
-            process.exit(error.code);
+            throw error;
+        }
+        finally {
+            await closeFileLogger();
         }
-        throw error;
+        return;
     }
-    finally {
-        await closeFileLogger();
+    const opts = extractOptions(args);
+    const outputMode = opts.json ? 'json' : 'human';
+    const allCommands = [...KNOWN_COMMANDS, ...KNOWN_SESSION_COMMANDS];
+    if (allCommands.includes(firstNonOption)) {
+        if (outputMode === 'json') {
+            console.error(formatJsonError(new Error(`Missing session target for command: ${firstNonOption}`), 1));
+        }
+        else {
+            console.error(`Error: Missing session target for command: ${firstNonOption}`);
+            console.error(`\nDid you mean: mcpc <@session> ${firstNonOption}`);
+            console.error(`Run "mcpc --help" for usage information.\n`);
+        }
     }
-    await new Promise((resolve) => {
-        if (process.stdout.writableFinished) {
-            resolve();
+    else {
+        if (outputMode === 'json') {
+            console.error(formatJsonError(new Error(`Unknown command: ${firstNonOption}`), 1));
         }
         else {
-            process.stdout.once('finish', resolve);
-            process.stdout.end();
+            console.error(`Error: Unknown command: ${firstNonOption}`);
+            console.error(`Run "mcpc --help" for usage information.\n`);
         }
-    });
-    process.exit(0);
+    }
+    await closeFileLogger();
+    process.exit(1);
 }
-function createProgram() {
+function createTopLevelProgram() {
     const program = new Command();
     program.configureOutput({
         outputError: (str, write) => write(str),
         getOutHelpWidth: () => 100,
         getErrHelpWidth: () => 100,
     });
+    program.configureHelp({
+        subcommandTerm: (cmd) => `${cmd.name()} ${cmd.usage()}`.replace(/^\[options\]\s*|\s*\[options\]/g, '').trim(),
+        styleTitle: (str) => chalk.bold(str),
+        styleSubcommandText: (str) => chalk.cyan(str),
+    });
+    const docsUrl = process.stdout.isTTY
+        ? `https://github.com/apify/mcpc/tree/v${mcpcVersion}`
+        : `https://raw.githubusercontent.com/apify/mcpc/v${mcpcVersion}/README.md`;
     program
         .name('mcpc')
         .description(`${rainbow('Universal')} command-line client for the Model Context Protocol (MCP).`)
-        .usage('[options] <target> [command]')
-        .helpOption('-h, --help', 'Display general help')
+        .usage('[options] [<@session>] [<command>]')
         .option('-j, --json', 'Output in JSON format for scripting')
-        .option('-c, --config <file>', 'Path to MCP config JSON file (e.g. ".vscode/mcp.json")')
-        .option('-H, --header <header>', 'HTTP header for remote MCP server (can be repeated)')
-        .version(mcpcVersion, '-v, --version', 'Output the version number')
         .option('--verbose', 'Enable debug logging')
         .option('--profile <name>', 'OAuth profile for the server ("default" if not provided)')
         .option('--schema <file>', 'Validate tool/prompt schema against expected schema')
         .option('--schema-mode <mode>', 'Schema validation mode: strict, compatible (default), ignore')
         .option('--timeout <seconds>', 'Request timeout in seconds (default: 300)')
-        .option('--proxy <[host:]port>', 'Start proxy MCP server for session (with "connect" command)')
-        .option('--proxy-bearer-token <token>', 'Require authentication for access to proxy server')
-        .option('--x402', 'Enable x402 auto-payment using the configured wallet')
-        .option('--clean[=types]', 'Clean up mcpc data (types: sessions, logs, profiles, all)');
-    const docsUrl = process.stdout.isTTY
-        ? `https://github.com/apify/mcpc/tree/v${mcpcVersion}`
-        : `https://raw.githubusercontent.com/apify/mcpc/v${mcpcVersion}/README.md`;
+        .option('--insecure', 'Skip TLS certificate verification (for self-signed certs)')
+        .version(mcpcVersion, '-v, --version', 'Output the version number')
+        .helpOption('-h, --help', 'Display help');
     program.addHelpText('after', `
-Targets:
-  @<session>                    Named persistent session (e.g. "@apify")
-  <config-entry>                Entry in MCP config file specified by --config (e.g. "fs")
-  <server-url>                  Remote MCP server URL (e.g. "mcp.apify.com")
+${chalk.bold('MCP session commands (after connecting):')}
+  <@session>                   Show MCP server info and capabilities
+  <@session> ${chalk.cyan('tools-list')}        List MCP tools
+  <@session> ${chalk.cyan('tools-get')} <name>
+  <@session> ${chalk.cyan('tools-call')} <name> [arg:=val ... | <json> | <stdin]
+  <@session> ${chalk.cyan('prompts-list')}
+  <@session> ${chalk.cyan('prompts-get')} <name> [arg:=val ... | <json> | <stdin]
+  <@session> ${chalk.cyan('resources-list')}
+  <@session> ${chalk.cyan('resources-read')} <uri>
+  <@session> ${chalk.cyan('resources-subscribe')} <uri>
+  <@session> ${chalk.cyan('resources-unsubscribe')} <uri>
+  <@session> ${chalk.cyan('resources-templates-list')}
+  <@session> ${chalk.cyan('tasks-list')}
+  <@session> ${chalk.cyan('tasks-get')} <taskId>
+  <@session> ${chalk.cyan('tasks-cancel')} <taskId>
+  <@session> ${chalk.cyan('logging-set-level')} <level>
+  <@session> ${chalk.cyan('ping')}
 
-Management commands:
-  login                         Create OAuth profile with credentials for remote server
-  logout                        Remove OAuth profile for remote server
-  connect @<session>            Connect to server and create named persistent session
-  restart                       Kill and restart a session
-  close                         Close a session
-
-MCP server commands:
-  help                          Show server info ("help" can be omitted)
-  shell                         Open interactive shell
-  tools-list [--full]           Send "tools/list" MCP request...
-  tools-get <tool-name>
-  tools-call <tool-name> [arg1:=val1 arg2:=val2 ... | <args-json> | <stdin]
-  prompts-list
-  prompts-get <prompt-name> [arg1:=val1 arg2:=val2 ... | <args-json> | <stdin]
-  resources
-  resources-list
-  resources-read <uri>
-  resources-subscribe <uri>
-  resources-unsubscribe <uri>
-  resources-templates-list
-  logging-set-level <level>
-  ping
-
-x402 payment commands (no target needed):
-  x402 init                     Create a new x402 wallet
-  x402 import <key>             Import wallet from private key
-  x402 info                     Show wallet info
-  x402 sign -r <base64>         Sign payment from PAYMENT-REQUIRED header
-  x402 remove                   Remove the wallet
-  
-Run "mcpc" without <target> to show available sessions and profiles.
+Run "mcpc" without arguments to show active sessions and OAuth profiles.
 
 Full docs: ${docsUrl}`);
+    program
+        .command('connect [server] [@session]')
+        .usage('<server> <@session>')
+        .description('Connect to an MCP server and start a new named @session')
+        .option('-H, --header <header>', 'HTTP header (can be repeated)')
+        .option('--profile <name>', 'OAuth profile to use ("default" if skipped)')
+        .option('--no-profile', 'Skip OAuth profile (connect anonymously)')
+        .option('--proxy <[host:]port>', 'Start proxy MCP server for session')
+        .option('--proxy-bearer-token <token>', 'Require authentication for access to proxy server')
+        .option('--x402', 'Enable x402 auto-payment using the configured wallet')
+        .addHelpText('after', `
+${chalk.bold('Server formats:')}
+  mcp.apify.com                 Remote HTTP server (https:// added automatically)
+  ~/.vscode/mcp.json:puppeteer  Config file entry (file:entry)
+`)
+        .action(async (server, sessionName, opts, command) => {
+        if (!server) {
+            throw new ClientError('Missing required argument: server\n\nExample: mcpc connect mcp.apify.com @myapp');
+        }
+        if (!sessionName) {
+            throw new ClientError('Missing required argument: @session\n\nExample: mcpc connect mcp.apify.com @myapp');
+        }
+        const globalOpts = getOptionsFromCommand(command);
+        const parsed = parseServerArg(server);
+        const headers = opts.header
+            ? Array.isArray(opts.header)
+                ? opts.header
+                : [opts.header]
+            : undefined;
+        if (!parsed) {
+            throw new ClientError(`Invalid server: "${server}"\n\n` +
+                `Expected a URL (e.g. mcp.apify.com) or a config file entry (e.g. ~/.vscode/mcp.json:filesystem)`);
+        }
+        if (parsed.type === 'config') {
+            await sessions.connectSession(parsed.entry, sessionName, {
+                ...globalOpts,
+                ...(headers && { headers }),
+                config: parsed.file,
+                proxy: opts.proxy,
+                proxyBearerToken: opts.proxyBearerToken,
+                x402: opts.x402,
+                ...(globalOpts.insecure && { insecure: true }),
+            });
+        }
+        else {
+            await sessions.connectSession(server, sessionName, {
+                ...globalOpts,
+                ...(headers && { headers }),
+                proxy: opts.proxy,
+                proxyBearerToken: opts.proxyBearerToken,
+                x402: opts.x402,
+                ...(globalOpts.insecure && { insecure: true }),
+            });
+        }
+    });
+    program
+        .command('close [@session]')
+        .usage('<@session>')
+        .description('Close a session')
+        .action(async (sessionName, _opts, command) => {
+        if (!sessionName) {
+            throw new ClientError('Missing required argument: @session\n\nExample: mcpc close @myapp');
+        }
+        await sessions.closeSession(sessionName, getOptionsFromCommand(command));
+    });
+    program
+        .command('restart [@session]')
+        .usage('<@session>')
+        .description('Restart a session (losing all state)')
+        .action(async (sessionName, _opts, command) => {
+        if (!sessionName) {
+            throw new ClientError('Missing required argument: @session\n\nExample: mcpc restart @myapp');
+        }
+        await sessions.restartSession(sessionName, getOptionsFromCommand(command));
+    });
+    program
+        .command('shell [@session]')
+        .usage('<@session>')
+        .description('Open interactive shell for a session')
+        .action(async (sessionName) => {
+        if (!sessionName) {
+            throw new ClientError('Missing required argument: @session\n\nExample: mcpc shell @myapp');
+        }
+        await sessions.openShell(sessionName);
+    });
+    program
+        .command('login [server]')
+        .usage('<server>')
+        .description('Interactively login to a server using OAuth and save profile')
+        .option('--profile <name>', 'Profile name (default: "default")')
+        .option('--scope <scopes>', 'OAuth scopes to request, quoted and space-separated (e.g. --scope "read write")')
+        .option('--client-id <id>', 'OAuth client ID (for servers without dynamic client registration)')
+        .option('--client-secret <secret>', 'OAuth client secret (for servers without dynamic client registration)')
+        .action(async (server, opts, command) => {
+        if (!server) {
+            throw new ClientError('Missing required argument: server\n\nExample: mcpc login mcp.apify.com');
+        }
+        await auth.login(server, {
+            profile: opts.profile,
+            scope: opts.scope,
+            clientId: opts.clientId,
+            clientSecret: opts.clientSecret,
+            ...getOptionsFromCommand(command),
+        });
+    });
+    program
+        .command('logout [server]')
+        .usage('<server>')
+        .description('Delete an authentication profile for a server')
+        .option('--profile <name>', 'Profile name (default: "default")')
+        .action(async (server, opts, command) => {
+        if (!server) {
+            throw new ClientError('Missing required argument: server\n\nExample: mcpc logout mcp.apify.com');
+        }
+        await auth.logout(server, {
+            profile: opts.profile,
+            ...getOptionsFromCommand(command),
+        });
+    });
+    program
+        .command('clean [resources...]')
+        .description('Clean up mcpc data (sessions, profiles, logs, all)')
+        .addHelpText('after', `
+${chalk.bold('Resources:')}
+  sessions    Remove stale/crashed session records
+  profiles    Remove authentication profiles
+  logs        Remove bridge log files
+  all         Remove all of the above
+
+Without arguments, performs safe cleanup of stale data only.
+`)
+        .action(async (resources, _opts, command) => {
+        const globalOpts = getOptionsFromCommand(command);
+        const VALID_CLEAN_TYPES = ['sessions', 'profiles', 'logs', 'all'];
+        for (const r of resources) {
+            if (!VALID_CLEAN_TYPES.includes(r)) {
+                throw new ClientError(`Invalid clean resource: "${r}". Valid resources are: ${VALID_CLEAN_TYPES.join(', ')}`);
+            }
+        }
+        await clean({
+            outputMode: globalOpts.outputMode,
+            sessions: resources.includes('sessions'),
+            profiles: resources.includes('profiles'),
+            logs: resources.includes('logs'),
+            all: resources.includes('all'),
+        });
+    });
+    program
+        .command('x402 [subcommand] [args...]')
+        .description('Configure an x402 payment wallet (EXPERIMENTAL)')
+        .action(() => { });
+    program
+        .command('help [command] [subcommand]')
+        .description('Show help for a specific command')
+        .action(async (cmdName, subcommand) => {
+        if (!cmdName) {
+            program.outputHelp();
+            return;
+        }
+        if (cmdName === 'x402') {
+            const helpArgs = subcommand ? [subcommand, '--help'] : ['--help'];
+            await handleX402Command(helpArgs);
+            return;
+        }
+        const topLevelCmd = program.commands.find((c) => c.name() === cmdName || c.aliases().includes(cmdName));
+        if (topLevelCmd) {
+            topLevelCmd.outputHelp();
+            return;
+        }
+        const dummyProgram = new Command();
+        registerSessionCommands(dummyProgram, '@dummy');
+        const sessionCmd = dummyProgram.commands.find((c) => c.name() === cmdName || c.aliases().includes(cmdName));
+        if (sessionCmd) {
+            sessionCmd.outputHelp();
+            return;
+        }
+        console.error(`Unknown command: ${cmdName}`);
+        console.error(`Run "mcpc --help" for usage information.`);
+        process.exit(1);
+    });
+    program.action(async () => {
+        const opts = program.opts();
+        const json = opts.json || getJsonFromEnv();
+        if (json)
+            setJsonMode(true);
+        await sessions.listSessionsAndAuthProfiles({ outputMode: json ? 'json' : 'human' });
+        if (!json) {
+            console.log('\nRun "mcpc --help" for usage information.\n');
+        }
+    });
     return program;
 }
-async function handleCommands(target, args) {
-    const program = createProgram();
-    program.argument('<target>', 'Target (session @name, MCP config entry, or server URL)');
-    if (!hasCommandAfterTarget(args)) {
-        const options = extractOptions(args);
-        if (options.verbose)
-            setVerbose(true);
-        if (options.json)
-            setJsonMode(true);
-        await sessions.showServerDetails(target, {
-            outputMode: options.json ? 'json' : 'human',
-            ...(options.verbose && { verbose: true }),
-            ...(options.config && { config: options.config }),
-            ...(options.headers && { headers: options.headers }),
-            ...(options.timeout !== undefined && { timeout: options.timeout }),
-        });
-        return;
-    }
+function registerSessionCommands(program, session) {
     program
         .command('help')
         .description('Show server instructions and available capabilities')
         .action(async (_options, command) => {
-        await sessions.showHelp(target, getOptionsFromCommand(command));
+        await sessions.showHelp(session, getOptionsFromCommand(command));
     });
     program
         .command('shell')
-        .description('Interactive shell for the target')
+        .description('Interactive shell for the session')
         .action(async () => {
-        await sessions.openShell(target);
+        await sessions.openShell(session);
     });
     program
-        .command('close')
+        .command('close', { hidden: true })
         .description('Close the session')
         .action(async (_options, command) => {
-        await sessions.closeSession(target, getOptionsFromCommand(command));
+        await sessions.closeSession(session, getOptionsFromCommand(command));
     });
     program
         .command('restart')
         .description('Restart the session (stop and start the bridge)')
         .action(async (_options, command) => {
-        await sessions.restartSession(target, getOptionsFromCommand(command));
-    });
-    program
-        .command('connect <name>')
-        .description('Create or reconnect a named session to an MCP server')
-        .action(async (name, _options, command) => {
-        const opts = command.optsWithGlobals();
-        await sessions.connectSession(name, target, {
-            ...getOptionsFromCommand(command),
-            proxy: opts.proxy,
-            proxyBearerToken: opts.proxyBearerToken,
-            x402: opts.x402,
-        });
-    });
-    program
-        .command('login')
-        .description('Login to a server using OAuth and save authentication profile')
-        .option('--profile <name>', 'Profile name (default: default)')
-        .option('--scope <scope>', 'OAuth scope(s) to request')
-        .action(async (options, command) => {
-        await auth.login(target, {
-            profile: options.profile,
-            scope: options.scope,
-            ...getOptionsFromCommand(command),
-        });
-    });
-    program
-        .command('logout')
-        .description('Delete an authentication profile')
-        .option('--profile <name>', 'Profile name (default: default)')
-        .action(async (options, command) => {
-        await auth.logout(target, {
-            profile: options.profile,
-            ...getOptionsFromCommand(command),
-        });
+        await sessions.restartSession(session, getOptionsFromCommand(command));
     });
     program
         .command('tools')
         .description('List available tools (shorthand for tools-list)')
         .option('--full', 'Show full tool details including complete input schema')
         .action(async (_options, command) => {
-        await tools.listTools(target, getOptionsFromCommand(command));
+        await tools.listTools(session, getOptionsFromCommand(command));
     });
     program
         .command('tools-list')
         .description('List available tools')
         .option('--full', 'Show full tool details including complete input schema')
         .action(async (_options, command) => {
-        await tools.listTools(target, getOptionsFromCommand(command));
+        await tools.listTools(session, getOptionsFromCommand(command));
     });
     program
         .command('tools-get <name>')
         .description('Get information about a specific tool')
         .action(async (name, _options, command) => {
-        await tools.getTool(target, name, getOptionsFromCommand(command));
+        await tools.getTool(session, name, getOptionsFromCommand(command));
     });
     program
         .command('tools-call <name> [args...]')
         .description('Call a tool with arguments (key:=value pairs or JSON)')
-        .action(async (name, args, _options, command) => {
-        await tools.callTool(target, name, {
+        .option('--task', 'Use task execution (experimental)')
+        .option('--detach', 'Start task and return immediately with task ID (implies --task)')
+        .action(async (name, args, options, command) => {
+        await tools.callTool(session, name, {
             args,
+            task: options.task,
+            detach: options.detach,
             ...getOptionsFromCommand(command),
         });
     });
+    program
+        .command('tasks-list')
+        .description('List active tasks')
+        .action(async (_options, command) => {
+        await tasks.listTasks(session, getOptionsFromCommand(command));
+    });
+    program
+        .command('tasks-get <taskId>')
+        .description('Get status of a specific task')
+        .action(async (taskId, _options, command) => {
+        await tasks.getTask(session, taskId, getOptionsFromCommand(command));
+    });
+    program
+        .command('tasks-cancel <taskId>')
+        .description('Cancel a running task')
+        .action(async (taskId, _options, command) => {
+        await tasks.cancelTask(session, taskId, getOptionsFromCommand(command));
+    });
     program
         .command('resources')
         .description('List available resources (shorthand for resources-list)')
         .action(async (_options, command) => {
-        await resources.listResources(target, getOptionsFromCommand(command));
+        await resources.listResources(session, getOptionsFromCommand(command));
     });
     program
         .command('resources-list')
         .description('List available resources')
         .action(async (_options, command) => {
-        await resources.listResources(target, getOptionsFromCommand(command));
+        await resources.listResources(session, getOptionsFromCommand(command));
     });
     program
         .command('resources-read <uri>')
@@ -369,9 +556,8 @@ async function handleCommands(target, args) {
         .option('-o, --output <file>', 'Write resource to file')
         .option('--max-size <bytes>', 'Maximum resource size in bytes')
         .action(async (uri, options, command) => {
-        await resources.getResource(target, uri, {
+        await resources.getResource(session, uri, {
             output: options.output,
-            raw: options.raw,
             maxSize: options.maxSize,
             ...getOptionsFromCommand(command),
         });
@@ -380,37 +566,37 @@ async function handleCommands(target, args) {
         .command('resources-subscribe <uri>')
         .description('Subscribe to resource updates')
         .action(async (uri, _options, command) => {
-        await resources.subscribeResource(target, uri, getOptionsFromCommand(command));
+        await resources.subscribeResource(session, uri, getOptionsFromCommand(command));
     });
     program
         .command('resources-unsubscribe <uri>')
         .description('Unsubscribe from resource updates')
         .action(async (uri, _options, command) => {
-        await resources.unsubscribeResource(target, uri, getOptionsFromCommand(command));
+        await resources.unsubscribeResource(session, uri, getOptionsFromCommand(command));
     });
     program
         .command('resources-templates-list')
         .description('List available resource templates')
         .action(async (_options, command) => {
-        await resources.listResourceTemplates(target, getOptionsFromCommand(command));
+        await resources.listResourceTemplates(session, getOptionsFromCommand(command));
     });
     program
         .command('prompts')
         .description('List available prompts (shorthand for prompts-list)')
         .action(async (_options, command) => {
-        await prompts.listPrompts(target, getOptionsFromCommand(command));
+        await prompts.listPrompts(session, getOptionsFromCommand(command));
     });
     program
         .command('prompts-list')
         .description('List available prompts')
         .action(async (_options, command) => {
-        await prompts.listPrompts(target, getOptionsFromCommand(command));
+        await prompts.listPrompts(session, getOptionsFromCommand(command));
     });
     program
         .command('prompts-get <name> [args...]')
         .description('Get a prompt by name with arguments (key:=value pairs or JSON)')
         .action(async (name, args, _options, command) => {
-        await prompts.getPrompt(target, name, {
+        await prompts.getPrompt(session, name, {
             args,
             ...getOptionsFromCommand(command),
         });
@@ -419,14 +605,50 @@ async function handleCommands(target, args) {
         .command('logging-set-level <level>')
         .description('Set server logging level (debug, info, notice, warning, error, critical, alert, emergency)')
         .action(async (level, _options, command) => {
-        await logging.setLogLevel(target, level, getOptionsFromCommand(command));
+        await logging.setLogLevel(session, level, getOptionsFromCommand(command));
     });
     program
         .command('ping')
         .description('Ping the MCP server to check if it is alive')
         .action(async (_options, command) => {
-        await utilities.ping(target, getOptionsFromCommand(command));
+        await utilities.ping(session, getOptionsFromCommand(command));
     });
+}
+function createSessionProgram() {
+    const program = new Command();
+    program.configureOutput({
+        outputError: (str, write) => write(str),
+        getOutHelpWidth: () => 100,
+        getErrHelpWidth: () => 100,
+    });
+    program
+        .name('mcpc <@session>')
+        .helpOption('-h, --help', 'Display help')
+        .option('-j, --json', 'Output in JSON format for scripting and code mode')
+        .option('--verbose', 'Enable debug logging')
+        .option('--profile <name>', 'OAuth profile override')
+        .option('--schema <file>', 'Validate tool/prompt schema against expected schema')
+        .option('--schema-mode <mode>', 'Schema validation mode: strict, compatible (default), ignore')
+        .option('--timeout <seconds>', 'Request timeout in seconds (default: 300)')
+        .option('--insecure', 'Skip TLS certificate verification (for self-signed certs)');
+    return program;
+}
+async function handleSessionCommands(session, args) {
+    if (!hasSubcommand(args)) {
+        const options = extractOptions(args);
+        if (options.verbose)
+            setVerbose(true);
+        if (options.json)
+            setJsonMode(true);
+        await sessions.showServerDetails(session, {
+            outputMode: options.json ? 'json' : 'human',
+            ...(options.verbose && { verbose: true }),
+            ...(options.timeout !== undefined && { timeout: options.timeout }),
+        });
+        return;
+    }
+    const program = createSessionProgram();
+    registerSessionCommands(program, session);
     try {
         await program.parseAsync(args);
     }
@@ -438,16 +660,27 @@ async function handleCommands(target, args) {
                 console.error(formatJsonError(error, error.code));
             }
             else {
-                console.error(formatHumanError(error, opts.verbose));
+                console.error(chalk.red(formatHumanError(error, opts.verbose)));
             }
             process.exit(error.code);
         }
         console.error(outputMode === 'json'
             ? formatJsonError(error, 1)
-            : formatHumanError(error, opts.verbose));
+            : chalk.red(formatHumanError(error, opts.verbose)));
         process.exit(1);
     }
 }
+async function flushStdout() {
+    await new Promise((resolve) => {
+        if (process.stdout.writableFinished) {
+            resolve();
+        }
+        else {
+            process.stdout.once('finish', resolve);
+            process.stdout.end();
+        }
+    });
+}
 main().catch(async (error) => {
     console.error('Fatal error:', error);
     await closeFileLogger();