dexto 1.6.8 → 1.6.9

package/dist/cli/commands/list-agents.js

@@ -151,7 +151,7 @@ export async function handleListAgentsCommand(options) {
     }
     else if (showInstalled) {
         console.log(chalk.rgb(255, 165, 0)('📦 No agents installed yet.'));
-        console.log(chalk.gray('   Use `dexto install <agent-name>` to install agents from the registry.\n'));
+        console.log(chalk.gray('   Use `dexto agents install <agent-name>` to install agents from the registry.\n'));
     }
     // Show available agents (not installed)
     if (showAvailable) {
@@ -197,9 +197,9 @@ export async function handleListAgentsCommand(options) {
     if (!validated.verbose) {
         console.log(chalk.gray(`📊 Summary: ${totalInstalled} installed, ${availableToInstall} available to install`));
         if (availableToInstall > 0) {
-            console.log(chalk.gray(`   Use \`dexto install <agent-name>\` to install more agents.`));
+            console.log(chalk.gray(`   Use \`dexto agents install <agent-name>\` to install more agents.`));
         }
-        console.log(chalk.gray(`   Use \`dexto list-agents --verbose\` for detailed information.`));
+        console.log(chalk.gray(`   Use \`dexto agents list --verbose\` for detailed information.`));
         console.log(chalk.gray(`   After installing an agent, use \`dexto -a <agent-name>\` to run it.`));
     }
     console.log();

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

@@ -0,0 +1,6 @@
+import type { Command } from 'commander';
+export interface McpCommandRegisterContext {
+    program: Command;
+}
+export declare function registerMcpCommand({ program }: McpCommandRegisterContext): void;
+//# sourceMappingURL=register.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"register.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/mcp/register.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAGzC,MAAM,WAAW,yBAAyB;IACtC,OAAO,EAAE,OAAO,CAAC;CACpB;AAED,wBAAgB,kBAAkB,CAAC,EAAE,OAAO,EAAE,EAAE,yBAAyB,GAAG,IAAI,CA+G/E"}

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

@@ -0,0 +1,64 @@
+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
+        .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.')
+        .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)')
+        .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) => {
+        try {
+            // Validate that --group-servers flag is provided (mandatory for now)
+            if (!options.groupServers) {
+                console.error('❌ The --group-servers flag is required. This command currently only supports aggregating and re-exposing tools from configured MCP servers.');
+                console.error('Usage: dexto mcp --group-servers');
+                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.');
+                safeExit('mcp', 1, 'no-mcp-servers');
+                return;
+            }
+            const validatedServers = ServersConfigSchema.parse(config.mcpServers);
+            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}`);
+            // 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);
+            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`);
+            safeExit('mcp', 1, 'mcp-agg-failed');
+        }
+    }, { timeoutMs: 0 }));
+}

package/dist/cli/commands/plugin/register.d.ts

@@ -0,0 +1,6 @@
+import type { Command } from 'commander';
+export interface PluginCommandRegisterContext {
+    program: Command;
+}
+export declare function registerPluginCommand({ program }: PluginCommandRegisterContext): void;
+//# sourceMappingURL=register.d.ts.map

package/dist/cli/commands/plugin/register.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"register.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/plugin/register.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AASzC,MAAM,WAAW,4BAA4B;IACzC,OAAO,EAAE,OAAO,CAAC;CACpB;AAED,wBAAgB,qBAAqB,CAAC,EAAE,OAAO,EAAE,EAAE,4BAA4B,GAAG,IAAI,CA4MrF"}

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

@@ -0,0 +1,183 @@
+import { withAnalytics, safeExit, ExitSignal } from '../../../analytics/wrapper.js';
+export function registerPluginCommand({ program }) {
+    // `plugin` SUB-COMMAND
+    const pluginCommand = program.command('plugin').description('Manage plugins');
+    pluginCommand
+        .command('list')
+        .description('List installed plugins')
+        .option('--verbose', 'Show detailed plugin information')
+        .action(withAnalytics('plugin list', async (options) => {
+        try {
+            const { handlePluginListCommand } = await import('../plugin.js');
+            await handlePluginListCommand(options);
+            safeExit('plugin list', 0);
+        }
+        catch (err) {
+            if (err instanceof ExitSignal)
+                throw err;
+            console.error(`❌ dexto plugin list command failed: ${err}`);
+            safeExit('plugin list', 1, 'error');
+        }
+    }));
+    pluginCommand
+        .command('install')
+        .description('Install a plugin from a local directory')
+        .requiredOption('--path <path>', 'Path to the plugin directory')
+        .option('--scope <scope>', 'Installation scope: user, project, or local', 'user')
+        .option('--force', 'Force overwrite if already installed')
+        .action(withAnalytics('plugin install', async (options) => {
+        try {
+            const { handlePluginInstallCommand } = await import('../plugin.js');
+            await handlePluginInstallCommand(options);
+            safeExit('plugin install', 0);
+        }
+        catch (err) {
+            if (err instanceof ExitSignal)
+                throw err;
+            console.error(`❌ dexto plugin install command failed: ${err}`);
+            safeExit('plugin install', 1, 'error');
+        }
+    }));
+    pluginCommand
+        .command('uninstall <name>')
+        .description('Uninstall a plugin by name')
+        .action(withAnalytics('plugin uninstall', async (name) => {
+        try {
+            const { handlePluginUninstallCommand } = await import('../plugin.js');
+            await handlePluginUninstallCommand({ name });
+            safeExit('plugin uninstall', 0);
+        }
+        catch (err) {
+            if (err instanceof ExitSignal)
+                throw err;
+            console.error(`❌ dexto plugin uninstall command failed: ${err}`);
+            safeExit('plugin uninstall', 1, 'error');
+        }
+    }));
+    pluginCommand
+        .command('validate [path]')
+        .description('Validate a plugin directory structure')
+        .action(withAnalytics('plugin validate', async (path) => {
+        try {
+            const { handlePluginValidateCommand } = await import('../plugin.js');
+            await handlePluginValidateCommand({ path: path || '.' });
+            safeExit('plugin validate', 0);
+        }
+        catch (err) {
+            if (err instanceof ExitSignal)
+                throw err;
+            console.error(`❌ dexto plugin validate command failed: ${err}`);
+            safeExit('plugin validate', 1, 'error');
+        }
+    }));
+    // `plugin marketplace` SUB-COMMANDS
+    const marketplaceCommand = pluginCommand
+        .command('marketplace')
+        .alias('market')
+        .description('Manage plugin marketplaces');
+    marketplaceCommand
+        .command('add <source>')
+        .description('Add a marketplace (GitHub: owner/repo, git URL, or local path)')
+        .option('--name <name>', 'Custom name for the marketplace')
+        .action(withAnalytics('plugin marketplace add', async (source, options) => {
+        try {
+            const { handleMarketplaceAddCommand } = await import('../plugin.js');
+            await handleMarketplaceAddCommand({ source, name: options.name });
+            safeExit('plugin marketplace add', 0);
+        }
+        catch (err) {
+            if (err instanceof ExitSignal)
+                throw err;
+            console.error(`❌ dexto plugin marketplace add command failed: ${err}`);
+            safeExit('plugin marketplace add', 1, 'error');
+        }
+    }));
+    marketplaceCommand
+        .command('list')
+        .description('List registered marketplaces')
+        .option('--verbose', 'Show detailed marketplace information')
+        .action(withAnalytics('plugin marketplace list', async (options) => {
+        try {
+            const { handleMarketplaceListCommand } = await import('../plugin.js');
+            await handleMarketplaceListCommand(options);
+            safeExit('plugin marketplace list', 0);
+        }
+        catch (err) {
+            if (err instanceof ExitSignal)
+                throw err;
+            console.error(`❌ dexto plugin marketplace list command failed: ${err}`);
+            safeExit('plugin marketplace list', 1, 'error');
+        }
+    }));
+    marketplaceCommand
+        .command('remove <name>')
+        .alias('rm')
+        .description('Remove a registered marketplace')
+        .action(withAnalytics('plugin marketplace remove', async (name) => {
+        try {
+            const { handleMarketplaceRemoveCommand } = await import('../plugin.js');
+            await handleMarketplaceRemoveCommand({ name });
+            safeExit('plugin marketplace remove', 0);
+        }
+        catch (err) {
+            if (err instanceof ExitSignal)
+                throw err;
+            console.error(`❌ dexto plugin marketplace remove command failed: ${err}`);
+            safeExit('plugin marketplace remove', 1, 'error');
+        }
+    }));
+    marketplaceCommand
+        .command('update [name]')
+        .description('Update marketplace(s) from remote (git pull)')
+        .action(withAnalytics('plugin marketplace update', async (name) => {
+        try {
+            const { handleMarketplaceUpdateCommand } = await import('../plugin.js');
+            await handleMarketplaceUpdateCommand({ name });
+            safeExit('plugin marketplace update', 0);
+        }
+        catch (err) {
+            if (err instanceof ExitSignal)
+                throw err;
+            console.error(`❌ dexto plugin marketplace update command failed: ${err}`);
+            safeExit('plugin marketplace update', 1, 'error');
+        }
+    }));
+    marketplaceCommand
+        .command('plugins [marketplace]')
+        .description('List plugins available in marketplaces')
+        .option('--verbose', 'Show plugin descriptions')
+        .action(withAnalytics('plugin marketplace plugins', async (marketplace, options) => {
+        try {
+            const { handleMarketplacePluginsCommand } = await import('../plugin.js');
+            await handleMarketplacePluginsCommand({
+                marketplace,
+                verbose: options?.verbose,
+            });
+            safeExit('plugin marketplace plugins', 0);
+        }
+        catch (err) {
+            if (err instanceof ExitSignal)
+                throw err;
+            console.error(`❌ dexto plugin marketplace plugins command failed: ${err}`);
+            safeExit('plugin marketplace plugins', 1, 'error');
+        }
+    }));
+    marketplaceCommand
+        .command('install <plugin>')
+        .description('Install a plugin from marketplace (plugin or plugin@marketplace)')
+        .option('--scope <scope>', 'Installation scope: user, project, or local', 'user')
+        .option('--force', 'Force reinstall if already exists')
+        .action(withAnalytics('plugin marketplace install', async (plugin, options) => {
+        try {
+            const { handleMarketplaceInstallCommand } = await import('../plugin.js');
+            await handleMarketplaceInstallCommand({ ...options, plugin });
+            safeExit('plugin marketplace install', 0);
+        }
+        catch (err) {
+            if (err instanceof ExitSignal)
+                throw err;
+            console.error(`❌ dexto plugin marketplace install command failed: ${err}`);
+            safeExit('plugin marketplace install', 1, 'error');
+        }
+    }));
+}

package/dist/cli/commands/plugin.d.ts

@@ -22,11 +22,11 @@ declare const PluginInstallCommandSchema: z.ZodObject<{
 }, "strict", z.ZodTypeAny, {
     path: string;
     force: boolean;
-    scope: "local" | "project" | "user";
+    scope: "local" | "user" | "project";
 }, {
     path: string;
     force?: boolean | undefined;
-    scope?: "local" | "project" | "user" | undefined;
+    scope?: "local" | "user" | "project" | undefined;
 }>;
 declare const PluginUninstallCommandSchema: z.ZodObject<{
     name: z.ZodString;
@@ -79,12 +79,12 @@ declare const MarketplaceInstallCommandSchema: z.ZodObject<{
     force: z.ZodDefault<z.ZodBoolean>;
 }, "strict", z.ZodTypeAny, {
     force: boolean;
-    scope: "local" | "project" | "user";
+    scope: "local" | "user" | "project";
     plugin: string;
 }, {
     plugin: string;
     force?: boolean | undefined;
-    scope?: "local" | "project" | "user" | undefined;
+    scope?: "local" | "user" | "project" | undefined;
 }>;
 export type PluginListCommandOptions = z.output<typeof PluginListCommandSchema>;
 export type PluginListCommandOptionsInput = z.input<typeof PluginListCommandSchema>;

package/dist/cli/commands/register-context.d.ts

@@ -0,0 +1,12 @@
+import type { Command } from 'commander';
+import type { DextoAgent } from '@dexto/core';
+export type BootstrapAgentMode = 'headless-run' | 'non-interactive';
+export interface RuntimeCommandRegisterContext {
+    program: Command;
+    cliVersion: string;
+    bootstrapAgentFromGlobalOpts: (options: {
+        mode: BootstrapAgentMode;
+        modelOverride?: string;
+    }) => Promise<DextoAgent>;
+}
+//# sourceMappingURL=register-context.d.ts.map

package/dist/cli/commands/register-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"register-context.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/register-context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C,MAAM,MAAM,kBAAkB,GAAG,cAAc,GAAG,iBAAiB,CAAC;AAEpE,MAAM,WAAW,6BAA6B;IAC1C,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,4BAA4B,EAAE,CAAC,OAAO,EAAE;QACpC,IAAI,EAAE,kBAAkB,CAAC;QACzB,aAAa,CAAC,EAAE,MAAM,CAAC;KAC1B,KAAK,OAAO,CAAC,UAAU,CAAC,CAAC;CAC7B"}

package/dist/cli/commands/register-context.js

@@ -0,0 +1 @@
+export {};

package/dist/cli/commands/run/headless.d.ts

@@ -0,0 +1,20 @@
+import { type DextoAgent } from '@dexto/core';
+export type HeadlessRunResult = {
+    finalMessage?: string;
+    totalTokens?: number;
+    fatalError?: Error;
+};
+export declare function resolveHeadlessPrompt(promptArg?: string): Promise<string>;
+export declare function printHeadlessMcpStartup(agent: DextoAgent): void;
+export declare function printHeadlessRunSummary(params: {
+    agent: DextoAgent;
+    sessionId: string;
+    prompt: string;
+    agentPath: string;
+    cliVersion: string;
+}): void;
+export declare function executeHeadlessRun(agent: DextoAgent, sessionId: string, prompt: string): Promise<HeadlessRunResult>;
+export declare function printHeadlessAssistantResponse(message: string, totalTokens?: number): void;
+export declare function writeFinalMessageToStdout(message: string): void;
+export declare function writeHeadlessError(message: string): void;
+//# sourceMappingURL=headless.d.ts.map

package/dist/cli/commands/run/headless.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"headless.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/run/headless.ts"],"names":[],"mappings":"AAAA,OAAO,EAGH,KAAK,UAAU,EAIlB,MAAM,aAAa,CAAC;AAWrB,MAAM,MAAM,iBAAiB,GAAG;IAC5B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,KAAK,CAAC;CACtB,CAAC;AA0IF,wBAAsB,qBAAqB,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAY/E;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI,CAgC/D;AAED,wBAAgB,uBAAuB,CAAC,MAAM,EAAE;IAC5C,KAAK,EAAE,UAAU,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACtB,GAAG,IAAI,CAgBP;AAED,wBAAsB,kBAAkB,CACpC,KAAK,EAAE,UAAU,EACjB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,GACf,OAAO,CAAC,iBAAiB,CAAC,CA8G5B;AAED,wBAAgB,8BAA8B,CAAC,OAAO,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAM1F;AAED,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAM/D;AAED,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAExD"}

package/dist/cli/commands/run/headless.js

@@ -0,0 +1,275 @@
+import { isTextPart, safeStringify, } from '@dexto/core';
+const HEADLESS_TOOL_OUTPUT_MAX_LINES = 20;
+const HEADLESS_SECTION_SEPARATOR = '========================================';
+function writeHeadlessLine(line = '') {
+    process.stderr.write(`${line}\n`);
+}
+function writeHeadlessSeparator() {
+    writeHeadlessLine(HEADLESS_SECTION_SEPARATOR);
+}
+function writeHeadlessTaggedLine(tag, message) {
+    writeHeadlessLine(`[${tag}] ${message}`);
+}
+function writeHeadlessTaggedBlock(tag, content) {
+    writeHeadlessLine(`[${tag}]`);
+    const lines = content.length > 0 ? content.split('\n') : [''];
+    for (const line of lines) {
+        writeHeadlessLine(`| ${line}`);
+    }
+}
+function formatHeadlessDuration(durationMs) {
+    if (durationMs < 1000) {
+        return `${Math.round(durationMs)}ms`;
+    }
+    const seconds = durationMs / 1000;
+    if (seconds < 10) {
+        return `${seconds.toFixed(2)}s`;
+    }
+    return `${seconds.toFixed(1)}s`;
+}
+function formatToolNameForHeadless(toolName) {
+    const delimiter = '--';
+    const delimiterIndex = toolName.indexOf(delimiter);
+    if (delimiterIndex > 0) {
+        return `${toolName.slice(0, delimiterIndex)}.${toolName.slice(delimiterIndex + delimiter.length)}`;
+    }
+    return toolName;
+}
+function formatToolArgsForHeadless(args) {
+    if (Object.keys(args).length === 0) {
+        return '{}';
+    }
+    return safeStringify(args);
+}
+function formatToolInvocationForHeadless(toolName, args) {
+    return `${formatToolNameForHeadless(toolName)}(${formatToolArgsForHeadless(args)})`;
+}
+function truncateOutputForHeadless(output) {
+    const lines = output.split('\n');
+    if (lines.length <= HEADLESS_TOOL_OUTPUT_MAX_LINES) {
+        return output;
+    }
+    const omittedLineCount = lines.length - HEADLESS_TOOL_OUTPUT_MAX_LINES;
+    return `${lines.slice(0, HEADLESS_TOOL_OUTPUT_MAX_LINES).join('\n')}\n... (${omittedLineCount} more lines)`;
+}
+function extractSanitizedToolText(sanitized) {
+    if (!sanitized) {
+        return undefined;
+    }
+    const display = sanitized.meta.display;
+    if (display?.type === 'shell') {
+        const shellDisplay = display;
+        const chunks = [shellDisplay.stdout, shellDisplay.stderr].filter((chunk) => Boolean(chunk && chunk.trim()));
+        if (chunks.length > 0) {
+            return chunks.join('\n');
+        }
+    }
+    if (display?.type === 'diff') {
+        return display.unified;
+    }
+    if (display?.type === 'search') {
+        return safeStringify(display.matches);
+    }
+    if (display?.type === 'file') {
+        return safeStringify(display);
+    }
+    const textParts = sanitized.content.filter(isTextPart).map((part) => part.text);
+    if (textParts.length > 0) {
+        return textParts.join('\n');
+    }
+    return safeStringify(sanitized.content);
+}
+function extractToolOutputForHeadless(event) {
+    if (!event.success && event.error) {
+        return event.error;
+    }
+    return extractSanitizedToolText(event.sanitized);
+}
+function getTotalTokensFromResponse(event) {
+    const usage = event.tokenUsage;
+    if (!usage) {
+        return undefined;
+    }
+    if (typeof usage.totalTokens === 'number') {
+        return usage.totalTokens;
+    }
+    const inputTokens = usage.inputTokens ?? 0;
+    const outputTokens = usage.outputTokens ?? 0;
+    const reasoningTokens = usage.reasoningTokens ?? 0;
+    const computedTotal = inputTokens + outputTokens + reasoningTokens;
+    return computedTotal > 0 ? computedTotal : undefined;
+}
+async function readPromptFromStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        if (typeof chunk === 'string') {
+            chunks.push(Buffer.from(chunk));
+        }
+        else {
+            chunks.push(chunk);
+        }
+    }
+    return Buffer.concat(chunks).toString('utf-8');
+}
+export async function resolveHeadlessPrompt(promptArg) {
+    if (promptArg && promptArg !== '-') {
+        return promptArg;
+    }
+    if (!promptArg && process.stdin.isTTY) {
+        throw new Error('No prompt provided. Pass a prompt argument (e.g., dexto run "your prompt") or pipe input via stdin.');
+    }
+    return await readPromptFromStdin();
+}
+export function printHeadlessMcpStartup(agent) {
+    const serverStatuses = agent.getMcpServersWithStatus().filter((server) => server.enabled);
+    if (serverStatuses.length === 0) {
+        writeHeadlessTaggedLine('MCP', 'startup: no servers');
+        return;
+    }
+    const readyServers = [];
+    const failedServers = [];
+    for (const server of serverStatuses) {
+        if (server.status === 'connected') {
+            readyServers.push(server.name);
+            writeHeadlessTaggedLine('MCP', `${server.name} ready`);
+            continue;
+        }
+        failedServers.push(server.name);
+        const reason = server.error ? `failed: ${server.error}` : `failed: ${server.status}`;
+        writeHeadlessTaggedLine('MCP', `${server.name} ${reason}`);
+    }
+    const summaryParts = [];
+    if (readyServers.length > 0) {
+        summaryParts.push(`ready: ${readyServers.join(', ')}`);
+    }
+    if (failedServers.length > 0) {
+        summaryParts.push(`failed: ${failedServers.join(', ')}`);
+    }
+    writeHeadlessTaggedLine('MCP', `startup: ${summaryParts.join('; ')}`);
+}
+export function printHeadlessRunSummary(params) {
+    const { agent, sessionId, prompt, agentPath, cliVersion } = params;
+    const llmConfig = agent.getCurrentLLMConfig(sessionId);
+    writeHeadlessSeparator();
+    writeHeadlessTaggedLine('RUN', `Dexto CLI v${cliVersion}`);
+    writeHeadlessSeparator();
+    writeHeadlessLine('[CONFIG]');
+    writeHeadlessLine(`workdir: ${process.cwd()}`);
+    writeHeadlessLine(`agent: ${agentPath}`);
+    writeHeadlessLine(`model: ${llmConfig.model}`);
+    writeHeadlessLine(`provider: ${llmConfig.provider}`);
+    writeHeadlessLine(`approval: ${agent.config.permissions.mode}`);
+    writeHeadlessLine(`session id: ${sessionId}`);
+    writeHeadlessSeparator();
+    writeHeadlessTaggedBlock('USER', prompt);
+}
+export async function executeHeadlessRun(agent, sessionId, prompt) {
+    const toolCallState = new Map();
+    let anonymousToolCallCounter = 0;
+    let finalMessage;
+    let totalTokens;
+    let fatalError;
+    for await (const event of await agent.stream(prompt, sessionId)) {
+        switch (event.name) {
+            case 'llm:tool-call': {
+                const callKey = event.callId ?? `anonymous-${++anonymousToolCallCounter}`;
+                const call = {
+                    toolName: event.toolName,
+                    args: event.args,
+                    startedAt: Date.now(),
+                };
+                toolCallState.set(callKey, call);
+                writeHeadlessTaggedLine('TOOL', formatToolInvocationForHeadless(call.toolName, call.args));
+                break;
+            }
+            case 'tool:running': {
+                const runningCall = toolCallState.get(event.toolCallId);
+                if (runningCall) {
+                    runningCall.startedAt = Date.now();
+                }
+                break;
+            }
+            case 'llm:tool-result': {
+                let matchedCallKey = event.callId;
+                let matchedCall = matchedCallKey ? toolCallState.get(matchedCallKey) : undefined;
+                if (!matchedCall) {
+                    const reverseEntries = Array.from(toolCallState.entries()).reverse();
+                    const fallback = reverseEntries.find(([, call]) => call.toolName === event.toolName);
+                    if (fallback) {
+                        matchedCallKey = fallback[0];
+                        matchedCall = fallback[1];
+                    }
+                }
+                const toolName = matchedCall?.toolName ?? event.toolName;
+                const args = matchedCall?.args ?? {};
+                const invocation = formatToolInvocationForHeadless(toolName, args);
+                const durationText = matchedCall
+                    ? ` in ${formatHeadlessDuration(Date.now() - matchedCall.startedAt)}`
+                    : '';
+                const statusTag = event.success ? 'TOOL:OK' : 'TOOL:ERR';
+                writeHeadlessTaggedLine(statusTag, `${invocation}${durationText}`);
+                const output = extractToolOutputForHeadless(event);
+                if (output && output.trim().length > 0) {
+                    writeHeadlessTaggedBlock('TOOL:OUT', truncateOutputForHeadless(output));
+                }
+                if (matchedCallKey) {
+                    toolCallState.delete(matchedCallKey);
+                }
+                break;
+            }
+            case 'llm:response': {
+                finalMessage = event.content;
+                totalTokens = getTotalTokensFromResponse(event);
+                break;
+            }
+            case 'llm:unsupported-input': {
+                writeHeadlessTaggedLine('WARNING', event.errors.join('; '));
+                break;
+            }
+            case 'llm:error': {
+                if (!event.recoverable) {
+                    fatalError = event.error;
+                    writeHeadlessTaggedLine('ERROR', event.error.message);
+                }
+                break;
+            }
+            case 'run:complete': {
+                if (event.finishReason === 'error' && event.error) {
+                    fatalError = event.error;
+                    writeHeadlessTaggedLine('ERROR', event.error.message);
+                }
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    const result = {};
+    if (finalMessage !== undefined) {
+        result.finalMessage = finalMessage;
+    }
+    if (totalTokens !== undefined) {
+        result.totalTokens = totalTokens;
+    }
+    if (fatalError !== undefined) {
+        result.fatalError = fatalError;
+    }
+    return result;
+}
+export function printHeadlessAssistantResponse(message, totalTokens) {
+    writeHeadlessSeparator();
+    writeHeadlessTaggedBlock('DEXTO', message);
+    if (typeof totalTokens === 'number') {
+        writeHeadlessTaggedLine('TOKENS', new Intl.NumberFormat('en-US').format(totalTokens));
+    }
+}
+export function writeFinalMessageToStdout(message) {
+    if (message.endsWith('\n')) {
+        process.stdout.write(message);
+        return;
+    }
+    process.stdout.write(`${message}\n`);
+}
+export function writeHeadlessError(message) {
+    writeHeadlessTaggedLine('ERROR', message);
+}

package/dist/cli/commands/run/register.d.ts

@@ -0,0 +1,3 @@
+import type { RuntimeCommandRegisterContext } from '../register-context.js';
+export declare function registerRunCommand({ program, cliVersion, bootstrapAgentFromGlobalOpts, }: RuntimeCommandRegisterContext): void;
+//# sourceMappingURL=register.d.ts.map

package/dist/cli/commands/run/register.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"register.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/run/register.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,wBAAwB,CAAC;AAE5E,wBAAgB,kBAAkB,CAAC,EAC/B,OAAO,EACP,UAAU,EACV,4BAA4B,GAC/B,EAAE,6BAA6B,GAAG,IAAI,CA+FtC"}