dexto 1.13.5 → 1.14.1

package/dist/cli/commands/mcp/register.js

@@ -1,13 +1,21 @@
+import { Option } from 'commander';
+import { resolve } from 'node:path';
+import { isIP } from 'node:net';
+import { registerGracefulShutdown } from '../../../utils/graceful-shutdown.js';
 import { withAnalytics, safeExit, ExitSignal } from '../../../analytics/wrapper.js';
 export function registerMcpCommand({ program }) {
-    // For now, this mode simply aggregates and re-expose tools from configured MCP servers (no agent)
-    // dexto --mode mcp will be moved to this sub-command in the future
-    program
+    const mcp = program
         .command('mcp')
-        .description('Start Dexto as an MCP server. Use --group-servers to aggregate and re-expose tools from configured MCP servers. \
-        In the future, this command will expose the agent as an MCP server by default.')
+        .description('Configure and call MCP servers, or expose them through an aggregation gateway')
+        .option('--config <path>', 'MCP-only YAML configuration (otherwise use --agent)')
         .option('-s, --strict', 'Require all MCP server connections to succeed')
         .option('--group-servers', 'Aggregate and re-expose tools from configured MCP servers (required for now)')
+        .addOption(new Option('--transport <transport>', 'Gateway transport')
+        .choices(['stdio', 'http'])
+        .default('stdio'))
+        .option('--host <host>', 'HTTP gateway bind address', '127.0.0.1')
+        .option('--port <port>', 'HTTP gateway port', '3001')
+        .option('--no-auth', 'Allow HTTP access without a gateway key (external ingress must own authentication)')
         .option('--name <n>', 'Name for the MCP server', 'dexto-tools')
         .option('--version <version>', 'Version for the MCP server', '1.0.0')
         .action(withAnalytics('mcp', async (options) => {
@@ -19,46 +27,271 @@ export function registerMcpCommand({ program }) {
                 safeExit('mcp', 1, 'missing-group-servers');
                 return;
             }
-            const [{ logger, ServersConfigSchema }, { resolveAgentPath, loadAgentConfig },] = await Promise.all([
-                import('@dexto/core'),
-                import('@dexto/agent-management'),
-            ]);
-            // Load and resolve config
-            // Get the global agent option from the main program
-            const globalOpts = program.opts();
-            const configPath = await resolveAgentPath(globalOpts.agent, globalOpts.autoInstall !== false);
-            logger.info(`Loading Dexto config from: ${configPath}`);
-            const config = await loadAgentConfig(configPath);
-            logger.info('Validating MCP servers...');
-            // Validate that MCP servers are configured
-            if (!config.mcpServers || Object.keys(config.mcpServers).length === 0) {
-                console.error('❌ No MCP servers configured. Please configure mcpServers in your config file.');
+            const apiKey = process.env.DEXTO_SERVER_API_KEY;
+            const loopback = options.host === '127.0.0.1' || options.host === '::1';
+            const port = Number(options.port);
+            if (options.transport === 'http') {
+                if (!/^\d+$/.test(options.port) ||
+                    !Number.isInteger(port) ||
+                    port < 1 ||
+                    port > 65535) {
+                    process.stderr.write('MCP HTTP port must be an integer from 1 to 65535.\n');
+                    safeExit('mcp', 1, 'mcp-http-invalid-port');
+                    return;
+                }
+                if (options.auth && !loopback && !apiKey) {
+                    process.stderr.write('Network-facing MCP HTTP requires DEXTO_SERVER_API_KEY or explicit --no-auth for an authenticated ingress.\n');
+                    safeExit('mcp', 1, 'mcp-http-auth-required');
+                    return;
+                }
+            }
+            const { logger, ServersConfigSchema } = await import('@dexto/core');
+            let servers;
+            if (options.config) {
+                const { loadStandaloneMcpConfiguration } = await import('./standalone.js');
+                servers = (await loadStandaloneMcpConfiguration(resolve(options.config), false)).servers;
+            }
+            else {
+                const { resolveAgentPath, loadAgentConfig } = await import('@dexto/agent-management');
+                const globalOpts = program.opts();
+                const configPath = await resolveAgentPath(globalOpts.agent, globalOpts.autoInstall !== false);
+                servers = (await loadAgentConfig(configPath)).mcpServers;
+            }
+            if (!servers || Object.keys(servers).length === 0) {
+                process.stderr.write('No MCP servers configured. Add a server or choose --config.\n');
                 safeExit('mcp', 1, 'no-mcp-servers');
                 return;
             }
-            const validatedServers = ServersConfigSchema.parse(config.mcpServers);
+            const validatedServers = ServersConfigSchema.parse(servers);
             logger.info(`Validated MCP servers. Configured servers: ${Object.keys(validatedServers).join(', ')}`);
-            const [{ createMcpTransport }, { initializeMcpToolAggregationServer }] = await Promise.all([
-                import('@dexto/server'),
-                import('../../../api/mcp/tool-aggregation-handler.js'),
-            ]);
             // Logs are already redirected to file by default to prevent interference with stdio transport
             const currentLogPath = logger.getLogFilePath();
             logger.info(`MCP mode using log file: ${currentLogPath || 'default .dexto location'}`);
             logger.info(`Starting MCP tool aggregation server: ${options.name} v${options.version}`);
+            if (options.transport === 'http') {
+                const [{ startMcpHttpAggregationGateway }, { createRequiredBearerAuthorization },] = await Promise.all([
+                    import('../../../api/mcp/http-gateway.js'),
+                    import('@dexto/server/hono/auth'),
+                ]);
+                const startup = startMcpHttpAggregationGateway(validatedServers, {
+                    name: options.name,
+                    version: options.version,
+                    strict: options.strict ?? false,
+                    host: options.host,
+                    port,
+                    authorize: options.auth && apiKey
+                        ? createRequiredBearerAuthorization(apiKey)
+                        : () => ({ allowed: true }),
+                });
+                const dispose = registerGracefulShutdown(() => ({
+                    stop: async () => {
+                        try {
+                            await (await startup).close();
+                        }
+                        catch {
+                            throw new Error('MCP shutdown failed');
+                        }
+                        finally {
+                            dispose();
+                        }
+                    },
+                }));
+                try {
+                    const owner = await startup;
+                    const host = isIP(options.host) === 6 ? `[${options.host}]` : options.host;
+                    process.stderr.write(`MCP HTTP gateway listening on http://${host}:${owner.port}/mcp\n`);
+                }
+                catch (error) {
+                    dispose();
+                    throw error;
+                }
+                return;
+            }
+            const [{ createMcpTransport }, { initializeMcpToolAggregationServer }] = await Promise.all([
+                import('@dexto/server'),
+                import('../../../api/mcp/tool-aggregation-handler.js'),
+            ]);
             // Create stdio transport for MCP tool aggregation
             const mcpTransport = await createMcpTransport('stdio');
             const strictMode = options.strict ?? false;
             // Initialize tool aggregation server
-            await initializeMcpToolAggregationServer(validatedServers, mcpTransport, options.name, options.version, strictMode);
+            const owner = await initializeMcpToolAggregationServer(validatedServers, mcpTransport, options.name, options.version, strictMode);
+            const dispose = registerGracefulShutdown(() => ({
+                stop: async () => {
+                    try {
+                        await owner.close();
+                    }
+                    catch {
+                        throw new Error('MCP shutdown failed');
+                    }
+                },
+            }));
+            const closeOnEnd = () => {
+                void owner.close().catch(() => {
+                    process.stderr.write('MCP shutdown failed.\n');
+                    process.exitCode = 1;
+                });
+            };
+            process.stdin.once('end', closeOnEnd);
+            const previousClose = owner.server.onclose;
+            owner.server.onclose = () => {
+                try {
+                    previousClose?.();
+                }
+                finally {
+                    dispose();
+                    process.stdin.off('end', closeOnEnd);
+                }
+            };
             logger.info('MCP tool aggregation server started successfully');
         }
         catch (err) {
             if (err instanceof ExitSignal)
                 throw err;
             // Write to stderr to avoid interfering with MCP protocol
-            process.stderr.write(`MCP tool aggregation server startup failed: ${err}\n`);
+            process.stderr.write('MCP tool aggregation server startup failed. Check configuration, credentials and server availability.\n');
             safeExit('mcp', 1, 'mcp-agg-failed');
         }
     }, { timeoutMs: 0 }));
+    mcp.hook('preAction', (_, actionCommand) => {
+        if (actionCommand === mcp || actionCommand.getOptionValueSource('config') !== 'default')
+            return;
+        const parentConfig = mcp.opts().config;
+        if (parentConfig !== undefined)
+            actionCommand.setOptionValueWithSource('config', parentConfig, 'implied');
+    });
+    const list = mcp.command('list').description('List configured MCP servers without connecting');
+    list.option('--config <path>', 'MCP-only YAML configuration', '.dexto/mcp.yml').option('--json', 'Emit machine-readable JSON');
+    list.action(async (options) => {
+        const { runStandaloneMcp } = await import('./standalone.js');
+        const result = await runStandaloneMcp({ command: 'list' }, options);
+        printStandaloneResult(result, options.json);
+    });
+    const connect = mcp
+        .command('connect <server>')
+        .description('Probe a server connection, then close it');
+    connect
+        .option('--config <path>', 'MCP-only YAML configuration', '.dexto/mcp.yml')
+        .option('--json', 'Emit machine-readable JSON');
+    connect.action(async (server, options) => {
+        const { runStandaloneMcp } = await import('./standalone.js');
+        const result = await runStandaloneMcp({ command: 'connect', server }, options);
+        printStandaloneResult(result, options.json);
+    });
+    const call = mcp
+        .command('call <server> <tool>')
+        .description('Call an explicitly selected upstream MCP tool, then close the connection');
+    call.option('--config <path>', 'MCP-only YAML configuration', '.dexto/mcp.yml')
+        .option('--json', 'Emit machine-readable JSON')
+        .option('--arguments <json>', 'Tool arguments as a JSON object', '{}');
+    call.action(async (server, tool, options) => {
+        const { runStandaloneMcp } = await import('./standalone.js');
+        const result = await runStandaloneMcp({ command: 'call', server, tool, argumentsJson: options.arguments }, options);
+        printStandaloneResult(result, options.json);
+    });
+    const tools = mcp.command('tools <server>').description('List upstream MCP tools and schemas');
+    tools
+        .option('--config <path>', 'MCP-only YAML configuration', '.dexto/mcp.yml')
+        .option('--json', 'Emit machine-readable JSON');
+    tools.action(async (server, options) => {
+        const { runStandaloneMcp } = await import('./standalone.js');
+        const result = await runStandaloneMcp({ command: 'tools', server }, options);
+        printStandaloneResult(result, options.json);
+    });
+    const resources = mcp
+        .command('resources <server>')
+        .description('List upstream MCP resource metadata');
+    resources
+        .option('--config <path>', 'MCP-only YAML configuration', '.dexto/mcp.yml')
+        .option('--json', 'Emit machine-readable JSON');
+    resources.action(async (server, options) => {
+        const { runStandaloneMcp } = await import('./standalone.js');
+        const result = await runStandaloneMcp({ command: 'resources', server }, options);
+        printStandaloneResult(result, options.json);
+    });
+    const readResource = mcp
+        .command('read-resource <server> <uri>')
+        .description('Read an exact upstream MCP resource, then close the connection');
+    readResource
+        .option('--config <path>', 'MCP-only YAML configuration', '.dexto/mcp.yml')
+        .option('--json', 'Emit machine-readable JSON');
+    readResource.action(async (server, uri, options) => {
+        const { runStandaloneMcp } = await import('./standalone.js');
+        const result = await runStandaloneMcp({ command: 'read-resource', server, uri }, options);
+        printStandaloneResult(result, options.json);
+    });
+    const prompts = mcp
+        .command('prompts <server>')
+        .description('List upstream MCP prompt metadata');
+    prompts
+        .option('--config <path>', 'MCP-only YAML configuration', '.dexto/mcp.yml')
+        .option('--json', 'Emit machine-readable JSON');
+    prompts.action(async (server, options) => {
+        const { runStandaloneMcp } = await import('./standalone.js');
+        const result = await runStandaloneMcp({ command: 'prompts', server }, options);
+        printStandaloneResult(result, options.json);
+    });
+    const getPrompt = mcp
+        .command('get-prompt <server> <prompt>')
+        .description('Render an exact upstream MCP prompt, then close the connection');
+    getPrompt
+        .option('--config <path>', 'MCP-only YAML configuration', '.dexto/mcp.yml')
+        .option('--json', 'Emit machine-readable JSON')
+        .option('--arguments <json>', 'Prompt arguments as a JSON object of strings', '{}');
+    getPrompt.action(async (server, prompt, options) => {
+        const { runStandaloneMcp } = await import('./standalone.js');
+        const result = await runStandaloneMcp({ command: 'get-prompt', server, prompt, argumentsJson: options.arguments }, options);
+        printStandaloneResult(result, options.json);
+    });
+    const add = mcp.command('add <server>').description('Add MCP server configuration');
+    add.option('--config <path>', 'MCP-only YAML configuration', '.dexto/mcp.yml')
+        .option('--json', 'Emit machine-readable JSON')
+        .option('--server-config <json>', 'Server configuration as a JSON object')
+        .option('--transport <type>', 'stdio, http or sse (inferred from command or URL)')
+        .option('--command <executable>', 'Local stdio server executable')
+        .option('--arg <value>', 'Server argument (repeat; use --arg=--flag for option arguments)', appendOption)
+        .option('--env <NAME=VALUE>', 'Server environment assignment (repeat)', appendOption)
+        .option('--url <url>', 'Remote MCP endpoint')
+        .option('--header <NAME=VALUE>', 'Remote request header (repeat)', appendOption)
+        .option('--replace', 'Replace an existing server');
+    add.action(async (server, options) => {
+        const { runStandaloneMcp, serverConfigurationFromOptions } = await import('./standalone.js');
+        let result;
+        try {
+            result = await runStandaloneMcp({
+                command: 'add',
+                server,
+                serverConfig: serverConfigurationFromOptions(options),
+                ...(options.replace ? { replace: true } : {}),
+            }, options);
+        }
+        catch {
+            result = {
+                exitCode: 2,
+                output: {
+                    error: {
+                        code: 'invalid_setup_options',
+                        message: 'Use --command with --arg/--env, --url with --header, or --server-config by itself.',
+                    },
+                },
+            };
+        }
+        printStandaloneResult(result, options.json);
+    });
+    const remove = mcp.command('remove <server>').description('Remove configured MCP server');
+    remove
+        .option('--config <path>', 'MCP-only YAML configuration', '.dexto/mcp.yml')
+        .option('--json', 'Emit machine-readable JSON');
+    remove.action(async (server, options) => {
+        const { runStandaloneMcp } = await import('./standalone.js');
+        const result = await runStandaloneMcp({ command: 'remove', server }, options);
+        printStandaloneResult(result, options.json);
+    });
+}
+function appendOption(value, previous = []) {
+    return [...previous, value];
+}
+function printStandaloneResult(result, compact) {
+    process.stdout.write(JSON.stringify(result.output, null, compact ? undefined : 2) + '\n');
+    process.exitCode = result.exitCode;
 }

package/dist/cli/commands/mcp/standalone.d.ts

@@ -0,0 +1,98 @@
+import { parseDocument } from 'yaml';
+import { z } from 'zod';
+declare const documentSchema: z.ZodObject<{
+    mcpServers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"stdio">;
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        timeout: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+        connectionMode: z.ZodDefault<z.ZodEnum<{
+            strict: "strict";
+            lenient: "lenient";
+        }>>;
+        command: z.ZodString;
+        args: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        env: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"http">;
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        timeout: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+        connectionMode: z.ZodDefault<z.ZodEnum<{
+            strict: "strict";
+            lenient: "lenient";
+        }>>;
+        url: z.ZodString;
+        headers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"sse">;
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        timeout: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+        connectionMode: z.ZodDefault<z.ZodEnum<{
+            strict: "strict";
+            lenient: "lenient";
+        }>>;
+        url: z.ZodString;
+        headers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strict>], "type">>>;
+}, z.core.$loose>;
+type McpOperation = {
+    command: 'connect' | 'tools' | 'resources' | 'prompts';
+    server: string;
+} | {
+    command: 'call';
+    server: string;
+    tool: string;
+    argumentsJson: string;
+} | {
+    command: 'read-resource';
+    server: string;
+    uri: string;
+} | {
+    command: 'get-prompt';
+    server: string;
+    prompt: string;
+    arguments: Record<string, string>;
+};
+export type StandaloneMcpCommand = {
+    command: 'list';
+} | Exclude<McpOperation, {
+    command: 'get-prompt';
+}> | {
+    command: 'get-prompt';
+    server: string;
+    prompt: string;
+    argumentsJson: string;
+} | {
+    command: 'remove';
+    server: string;
+} | {
+    command: 'add';
+    server: string;
+    serverConfig: string;
+    replace?: boolean;
+};
+export interface StandaloneMcpOptions {
+    config?: string;
+}
+export interface StandaloneMcpResult {
+    exitCode: number;
+    output: unknown;
+}
+export declare function runStandaloneMcp(command: StandaloneMcpCommand, options: StandaloneMcpOptions): Promise<StandaloneMcpResult>;
+/** Load MCP-only YAML for direct commands or the aggregation host without agent setup. */
+export declare function loadStandaloneMcpConfiguration(path: string, allowMissing: boolean): Promise<{
+    document: ReturnType<typeof parseDocument>;
+    servers: z.output<typeof documentSchema>['mcpServers'];
+}>;
+export interface McpAddOptions {
+    serverConfig?: string;
+    transport?: string;
+    command?: string;
+    arg?: string[];
+    env?: string[];
+    url?: string;
+    header?: string[];
+}
+/** Convert CLI setup forms to literal configuration without expanding credentials. */
+export declare function serverConfigurationFromOptions(options: McpAddOptions): string;
+export {};
+//# sourceMappingURL=standalone.d.ts.map

package/dist/cli/commands/mcp/standalone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"standalone.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/mcp/standalone.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,aAAa,EAAE,MAAM,MAAM,CAAC;AACrC,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA2BxB,QAAA,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAEF,CAAC;AACnB,KAAK,YAAY,GACX;IAAE,OAAO,EAAE,SAAS,GAAG,OAAO,GAAG,WAAW,GAAG,SAAS,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAC1E;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAE,GACxE;IAAE,OAAO,EAAE,eAAe,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GACzD;IAAE,OAAO,EAAE,YAAY,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,CAAC;AACnG,MAAM,MAAM,oBAAoB,GAC1B;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,GACnB,OAAO,CAAC,YAAY,EAAE;IAAE,OAAO,EAAE,YAAY,CAAA;CAAE,CAAC,GAChD;IAAE,OAAO,EAAE,YAAY,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAE,GAChF;IAAE,OAAO,EAAE,QAAQ,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GACrC;IAAE,OAAO,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC;AAClF,MAAM,WAAW,oBAAoB;IACjC,MAAM,CAAC,EAAE,MAAM,CAAC;CACnB;AACD,MAAM,WAAW,mBAAmB;IAChC,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,OAAO,CAAC;CACnB;AAED,wBAAsB,gBAAgB,CAClC,OAAO,EAAE,oBAAoB,EAC7B,OAAO,EAAE,oBAAoB,GAC9B,OAAO,CAAC,mBAAmB,CAAC,CA4G9B;AAsJD,0FAA0F;AAC1F,wBAAsB,8BAA8B,CAChD,IAAI,EAAE,MAAM,EACZ,YAAY,EAAE,OAAO,GACtB,OAAO,CAAC;IACP,QAAQ,EAAE,UAAU,CAAC,OAAO,aAAa,CAAC,CAAC;IAC3C,OAAO,EAAE,CAAC,CAAC,MAAM,CAAC,OAAO,cAAc,CAAC,CAAC,YAAY,CAAC,CAAC;CAC1D,CAAC,CA8BD;AAsLD,MAAM,WAAW,aAAa;IAC1B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,EAAE,CAAC;IACf,GAAG,CAAC,EAAE,MAAM,EAAE,CAAC;IACf,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;CACrB;AAED,sFAAsF;AACtF,wBAAgB,8BAA8B,CAAC,OAAO,EAAE,aAAa,GAAG,MAAM,CAkC7E"}