dexto 1.1.9 → 1.1.11

package/dist/cli/tool-confirmation/cli-confirmation-handler.js

@@ -1,10 +1,10 @@
-import { logger } from '@dexto/core';
+import { logger, ApprovalType, ApprovalStatus } from '@dexto/core';
 import * as readline from 'readline';
 import chalk from 'chalk';
 import boxen from 'boxen';
 /**
- * CLI-specific subscriber for tool confirmation events
- * Implements EventSubscriber pattern to listen to AgentEventBus for tool confirmation requests
+ * CLI-specific subscriber for approval events
+ * Implements EventSubscriber pattern to listen to AgentEventBus for approval requests
  */
 export class CLIToolConfirmationSubscriber {
     agentEventBus;
@@ -12,54 +12,334 @@ export class CLIToolConfirmationSubscriber {
         // No configuration needed - CLI always shows interactive prompts
     }
     /**
-     * Subscribe to tool confirmation events on the AgentEventBus
+     * Subscribe to approval events on the AgentEventBus
      */
     subscribe(eventBus) {
         this.agentEventBus = eventBus;
-        this.agentEventBus.on('dexto:toolConfirmationRequest', this.handleConfirmationRequest.bind(this));
+        this.agentEventBus.on('dexto:approvalRequest', this.handleApprovalRequest.bind(this));
     }
     /**
-     * Handle tool confirmation request events from the AgentEventBus
+     * Handle approval request events from the AgentEventBus
      */
-    async handleConfirmationRequest(event) {
+    async handleApprovalRequest(event) {
         try {
-            logger.info(`Handling tool confirmation request for ${event.toolName}, executionId: ${event.executionId}`);
-            // Display tool call using the logger's built-in method
-            logger.toolCall(event.toolName, event.args);
-            // Collect user input with arrow key navigation
-            const approved = await this.collectArrowKeyInput();
-            // Send response back via AgentEventBus
-            const response = {
-                executionId: event.executionId,
-                approved,
-                rememberChoice: false, // CLI won't persist choice
-                ...(event.sessionId && { sessionId: event.sessionId }),
-            };
-            this.sendConfirmationResponse(response);
-            if (!approved) {
-                logger.warn(`Tool '${event.toolName}' execution denied`);
+            if (event.type === ApprovalType.TOOL_CONFIRMATION) {
+                await this.handleToolConfirmation(event);
+            }
+            else if (event.type === ApprovalType.ELICITATION) {
+                await this.handleElicitation(event);
+            }
+            else {
+                logger.debug(`[CLI] Ignoring unsupported approval type: ${event.type}`);
             }
         }
         catch (error) {
-            logger.error(`Error handling tool confirmation request: ${error}`);
+            // Use structured logging to preserve error stack and metadata
+            logger.error(`Error handling approval request: ${error instanceof Error ? error.message : String(error)}`, error instanceof Error ? { error } : undefined);
             // Send denial response on error
-            this.sendConfirmationResponse({
-                executionId: event.executionId,
-                approved: false,
-                ...(event.sessionId && { sessionId: event.sessionId }),
-            });
+            const errorResponse = {
+                approvalId: event.approvalId,
+                status: ApprovalStatus.DENIED,
+            };
+            if (event.sessionId !== undefined) {
+                errorResponse.sessionId = event.sessionId;
+            }
+            this.sendApprovalResponse(errorResponse);
+        }
+    }
+    /**
+     * Handle tool confirmation approval
+     */
+    async handleToolConfirmation(event) {
+        const toolMetadata = event.metadata;
+        logger.info(`Handling tool confirmation request for ${toolMetadata.toolName}, approvalId: ${event.approvalId}`);
+        // Display tool call using the logger's built-in method
+        logger.toolCall(toolMetadata.toolName, toolMetadata.args);
+        // Collect user input with arrow key navigation
+        const approved = await this.collectArrowKeyInput();
+        // Send response back via AgentEventBus
+        const response = {
+            approvalId: event.approvalId,
+            status: approved ? ApprovalStatus.APPROVED : ApprovalStatus.DENIED,
+            data: {
+                rememberChoice: false, // CLI won't persist choice
+            },
+        };
+        if (event.sessionId !== undefined) {
+            response.sessionId = event.sessionId;
+        }
+        this.sendApprovalResponse(response);
+        if (!approved) {
+            logger.warn(`Tool '${toolMetadata.toolName}' execution denied`);
+        }
+    }
+    /**
+     * Handle elicitation approval (form-based input from MCP servers)
+     */
+    async handleElicitation(event) {
+        const elicitationMetadata = event.metadata;
+        logger.info(`Handling elicitation request from MCP server '${elicitationMetadata.serverName}', approvalId: ${event.approvalId}`);
+        // Display the elicitation prompt
+        console.log('\n' +
+            boxen(chalk.cyan.bold('📝 Information Request from MCP Server'), {
+                padding: 1,
+                margin: 1,
+                borderStyle: 'round',
+                borderColor: 'cyan',
+            }));
+        console.log(chalk.white(`Server: ${chalk.yellow(elicitationMetadata.serverName)}`));
+        console.log(chalk.white(`Message: ${chalk.white(elicitationMetadata.prompt)}\n`));
+        // Collect form data based on schema
+        const formData = await this.collectFormData(elicitationMetadata.schema);
+        if (formData === null) {
+            // User cancelled
+            const cancelResponse = {
+                approvalId: event.approvalId,
+                status: ApprovalStatus.CANCELLED,
+            };
+            if (event.sessionId !== undefined) {
+                cancelResponse.sessionId = event.sessionId;
+            }
+            this.sendApprovalResponse(cancelResponse);
+            logger.info('Elicitation cancelled by user');
         }
+        else {
+            // User provided data
+            const response = {
+                approvalId: event.approvalId,
+                status: ApprovalStatus.APPROVED,
+                data: { formData },
+            };
+            if (event.sessionId !== undefined) {
+                response.sessionId = event.sessionId;
+            }
+            this.sendApprovalResponse(response);
+            logger.info('Elicitation completed successfully');
+        }
+    }
+    /**
+     * Collect form data based on JSON Schema
+     * Returns null if user cancels
+     */
+    async collectFormData(schema) {
+        const formData = {};
+        if (!schema.properties || typeof schema.properties !== 'object') {
+            logger.warn('Invalid schema: no properties found');
+            return null;
+        }
+        const properties = schema.properties;
+        const required = schema.required || [];
+        for (const [fieldName, fieldSchema] of Object.entries(properties)) {
+            const field = fieldSchema;
+            const isRequired = required.includes(fieldName);
+            const fieldType = field.type || 'string';
+            // Display field prompt
+            const requiredLabel = isRequired ? chalk.red('*') : '';
+            console.log(chalk.cyan(`${fieldName}${requiredLabel}`) +
+                (field.description ? chalk.gray(` - ${field.description}`) : ''));
+            // Collect input based on field type
+            let value;
+            if (fieldType === 'boolean') {
+                value = await this.collectBooleanInput(fieldName, isRequired);
+            }
+            else if (fieldType === 'number' || fieldType === 'integer') {
+                value = await this.collectNumberInput(fieldName, fieldType === 'integer', isRequired);
+            }
+            else if (field.enum && Array.isArray(field.enum)) {
+                value = await this.collectEnumInput(fieldName, field.enum, isRequired);
+            }
+            else {
+                // Default to string input
+                value = await this.collectStringInput(fieldName, isRequired);
+            }
+            if (value === null) {
+                // User cancelled
+                return null;
+            }
+            // Only assign if value is not undefined (allows skipping optional fields)
+            if (value !== undefined) {
+                formData[fieldName] = value;
+            }
+        }
+        return formData;
+    }
+    /**
+     * Collect string input from user
+     */
+    collectStringInput(fieldName, required) {
+        return new Promise((resolve) => {
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout,
+            });
+            const prompt = required
+                ? `${fieldName}: `
+                : `${fieldName} (optional, press Enter to skip): `;
+            rl.question(prompt, (answer) => {
+                rl.close();
+                if (answer.toLowerCase() === 'cancel') {
+                    resolve(null);
+                    return;
+                }
+                if (!answer && required) {
+                    console.log(chalk.red('This field is required'));
+                    resolve(this.collectStringInput(fieldName, required));
+                    return;
+                }
+                // Return undefined for optional skipped fields, empty string for provided empty input
+                if (!answer && !required) {
+                    resolve(undefined);
+                    return;
+                }
+                resolve(answer);
+            });
+        });
+    }
+    /**
+     * Collect boolean input from user (yes/no)
+     */
+    collectBooleanInput(fieldName, required) {
+        return new Promise((resolve) => {
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout,
+            });
+            const prompt = required
+                ? `${fieldName} (yes/no): `
+                : `${fieldName} (yes/no, press Enter to skip): `;
+            rl.question(prompt, (answer) => {
+                rl.close();
+                if (answer.toLowerCase() === 'cancel') {
+                    resolve(null);
+                    return;
+                }
+                const normalized = answer.toLowerCase().trim();
+                // Allow skipping optional fields
+                if (!normalized && !required) {
+                    resolve(undefined);
+                    return;
+                }
+                if (!normalized && required) {
+                    console.log(chalk.red('This field is required'));
+                    resolve(this.collectBooleanInput(fieldName, required));
+                    return;
+                }
+                if (normalized === 'yes' || normalized === 'y' || normalized === 'true') {
+                    resolve(true);
+                }
+                else if (normalized === 'no' || normalized === 'n' || normalized === 'false') {
+                    resolve(false);
+                }
+                else {
+                    console.log(chalk.red('Please answer yes or no'));
+                    resolve(this.collectBooleanInput(fieldName, required));
+                }
+            });
+        });
+    }
+    /**
+     * Collect number input from user
+     */
+    collectNumberInput(fieldName, integer, required) {
+        return new Promise((resolve) => {
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout,
+            });
+            const type = integer ? 'integer' : 'number';
+            const prompt = required
+                ? `${fieldName} (${type}): `
+                : `${fieldName} (${type}, press Enter to skip): `;
+            rl.question(prompt, (answer) => {
+                rl.close();
+                if (answer.toLowerCase() === 'cancel') {
+                    resolve(null);
+                    return;
+                }
+                // Allow skipping optional fields
+                if (!answer.trim() && !required) {
+                    resolve(undefined);
+                    return;
+                }
+                if (!answer.trim() && required) {
+                    console.log(chalk.red('This field is required'));
+                    resolve(this.collectNumberInput(fieldName, integer, required));
+                    return;
+                }
+                const num = Number(answer);
+                if (isNaN(num)) {
+                    console.log(chalk.red(`Please enter a valid ${type}`));
+                    resolve(this.collectNumberInput(fieldName, integer, required));
+                    return;
+                }
+                if (integer && !Number.isInteger(num)) {
+                    console.log(chalk.red('Please enter an integer'));
+                    resolve(this.collectNumberInput(fieldName, integer, required));
+                    return;
+                }
+                resolve(num);
+            });
+        });
+    }
+    /**
+     * Collect enum input from user (select from list)
+     */
+    collectEnumInput(fieldName, options, required) {
+        return new Promise((resolve) => {
+            console.log(chalk.gray('Available options:'));
+            options.forEach((option, index) => {
+                console.log(chalk.gray(`  ${index + 1}. ${option}`));
+            });
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout,
+            });
+            const prompt = required
+                ? `${fieldName} (enter number or value): `
+                : `${fieldName} (enter number or value, press Enter to skip): `;
+            rl.question(prompt, (answer) => {
+                rl.close();
+                if (answer.toLowerCase() === 'cancel') {
+                    resolve(null);
+                    return;
+                }
+                // Allow skipping optional fields
+                if (!answer.trim() && !required) {
+                    resolve(undefined);
+                    return;
+                }
+                if (!answer.trim() && required) {
+                    console.log(chalk.red('This field is required'));
+                    resolve(this.collectEnumInput(fieldName, options, required));
+                    return;
+                }
+                // Try as index first
+                const index = parseInt(answer) - 1;
+                if (!isNaN(index) && index >= 0 && index < options.length) {
+                    resolve(options[index]);
+                    return;
+                }
+                // Try as direct value
+                const directMatch = options.find((opt) => String(opt) === answer);
+                if (directMatch !== undefined) {
+                    resolve(directMatch);
+                    return;
+                }
+                console.log(chalk.red('Invalid selection'));
+                resolve(this.collectEnumInput(fieldName, options, required));
+            });
+        });
     }
     /**
-     * Send confirmation response via AgentEventBus
+     * Send approval response via AgentEventBus
      */
-    sendConfirmationResponse(response) {
+    sendApprovalResponse(response) {
         if (!this.agentEventBus) {
-            logger.error('AgentEventBus not available for sending confirmation response');
+            logger.error('AgentEventBus not available for sending approval response');
             return;
         }
-        logger.debug(`CLI sending toolConfirmationResponse for executionId ${response.executionId}, approved=${response.approved}, sessionId=${response.sessionId}`);
-        this.agentEventBus.emit('dexto:toolConfirmationResponse', response);
+        logger.debug(`CLI sending approvalResponse for approvalId ${response.approvalId}, status=${response.status}, sessionId=${response.sessionId ?? 'global'}`);
+        this.agentEventBus.emit('dexto:approvalResponse', response);
     }
     /**
      * Collect user input with arrow key navigation
@@ -155,7 +435,7 @@ export class CLIToolConfirmationSubscriber {
      */
     cleanup() {
         if (this.agentEventBus) {
-            this.agentEventBus.removeAllListeners('dexto:toolConfirmationRequest');
+            this.agentEventBus.removeAllListeners('dexto:approvalRequest');
         }
     }
 }

package/dist/index.js

@@ -40,11 +40,12 @@ program
     .name('dexto')
     .description('AI-powered CLI and WebUI for interacting with MCP servers')
     .version(pkg.version, '-v, --version', 'output the current version')
-    .option('-a, --agent <name|path>', 'Agent name or path to agent config file')
+    .option('-a, --agent <id|path>', 'Agent ID or path to agent config file')
     .option('-p, --prompt <text>', 'Run prompt and exit. Alternatively provide a single quoted string as positional argument.')
     .option('-s, --strict', 'Require all server connections to succeed')
     .option('--no-verbose', 'Disable verbose output')
     .option('--no-interactive', 'Disable interactive prompts and API key setup')
+    .option('--skip-setup', 'Skip global setup validation (useful for MCP mode, automation)')
     .option('-m, --model <model>', 'Specify the LLM model to use')
     .option('--router <router>', 'Specify the LLM router to use (vercel or in-built)')
     .option('--auto-approve', 'Always approve tool executions without confirmation prompts')
@@ -155,10 +156,17 @@ program
 // 5) `install` SUB-COMMAND
 program
     .command('install [agents...]')
-    .description('Install agents from the registry')
+    .description('Install agents from registry or custom YAML files/directories')
     .option('--all', 'Install all available agents from registry')
     .option('--no-inject-preferences', 'Skip injecting global preferences into installed agents')
     .option('--force', 'Force reinstall even if agent is already installed')
+    .addHelpText('after', `
+Examples:
+  $ dexto install default-agent              Install agent from registry
+  $ dexto install agent1 agent2              Install multiple registry agents
+  $ dexto install --all                      Install all available registry agents
+  $ dexto install ./my-agent.yml             Install custom agent from YAML file
+  $ dexto install ./my-agent-dir/            Install custom agent from directory (interactive)`)
     .action(withAnalytics('install', async (agents = [], options) => {
     try {
         await handleInstallCommand(agents, options);
@@ -230,7 +238,7 @@ async function bootstrapAgentFromGlobalOpts() {
     const resolvedPath = await resolveAgentPath(globalOpts.agent, globalOpts.autoInstall !== false, true);
     const rawConfig = await loadAgentConfig(resolvedPath);
     const mergedConfig = applyCLIOverrides(rawConfig, globalOpts);
-    const agent = new DextoAgent(mergedConfig, globalOpts.agent);
+    const agent = new DextoAgent(mergedConfig, resolvedPath);
     await agent.start();
     // Register graceful shutdown
     const shutdown = async () => {
@@ -501,10 +509,11 @@ program
                 }
             }
             // Check setup state and auto-trigger if needed
-            if (await requiresSetup()) {
+            // Skip if --skip-setup flag is set (for MCP mode, automation, etc.)
+            if (!opts.skipSetup && (await requiresSetup())) {
                 if (opts.interactive === false) {
                     console.error('❌ Setup required but --no-interactive flag is set.');
-                    console.error('💡 Run `dexto setup` to configure preferences first.');
+                    console.error('💡 Run `dexto setup` first, or use --skip-setup to bypass global setup.');
                     safeExit('main', 1, 'setup-required-non-interactive');
                 }
                 await handleSetupCommand({ interactive: true });
@@ -539,51 +548,9 @@ program
             }
         }
         // DextoAgent will parse/validate again (parse-twice pattern)
-        agent = new DextoAgent(validatedConfig, opts.agent);
+        agent = new DextoAgent(validatedConfig, resolvedPath);
         // Start the agent (initialize async services)
         await agent.start();
-        // Handle session options - simplified logic
-        if (opts.resume) {
-            try {
-                // Resume specific session by ID
-                await agent.loadSessionAsDefault(opts.resume);
-                logger.info(`Resumed session: ${opts.resume}`, null, 'cyan');
-            }
-            catch (err) {
-                console.error(`❌ Failed to resume session '${opts.resume}': ${err instanceof Error ? err.message : String(err)}`);
-                console.error('💡 Use `dexto session list` to see available sessions');
-                safeExit('main', 1, 'resume-failed');
-            }
-        }
-        else if (opts.continue) {
-            try {
-                // Continue from most recent session
-                await loadMostRecentSession(agent);
-                // If no sessions existed, create a new one to honor default-new invariant
-                const sessionsAfter = await agent.listSessions();
-                if (sessionsAfter.length === 0) {
-                    const session = await agent.createSession();
-                    await agent.loadSessionAsDefault(session.id);
-                    logger.info(`Created new session: ${session.id}`, null, 'green');
-                }
-            }
-            catch (err) {
-                console.error(`❌ Failed to continue session: ${err instanceof Error ? err.message : String(err)}`);
-                safeExit('main', 1, 'continue-failed');
-            }
-        }
-        else {
-            // Default behavior: create new session
-            try {
-                const session = await agent.createSession();
-                await agent.loadSessionAsDefault(session.id);
-                logger.info(`Created new session: ${session.id}`, null, 'green');
-            }
-            catch (err) {
-                console.error(`❌ Failed to create new session: ${err instanceof Error ? err.message : String(err)}`);
-                safeExit('main', 1, 'create-session-failed');
-            }
-        }
     }
     catch (err) {
         if (err instanceof ExitSignal)
@@ -595,6 +562,48 @@ program
     // ——— Dispatch based on --mode ———
     switch (opts.mode) {
         case 'cli': {
+            // Handle session options - only for CLI mode
+            if (opts.resume) {
+                try {
+                    // Resume specific session by ID
+                    await agent.loadSessionAsDefault(opts.resume);
+                    logger.info(`Resumed session: ${opts.resume}`, null, 'cyan');
+                }
+                catch (err) {
+                    console.error(`❌ Failed to resume session '${opts.resume}': ${err instanceof Error ? err.message : String(err)}`);
+                    console.error('💡 Use `dexto session list` to see available sessions');
+                    safeExit('main', 1, 'resume-failed');
+                }
+            }
+            else if (opts.continue) {
+                try {
+                    // Continue from most recent session
+                    await loadMostRecentSession(agent);
+                    // If no sessions existed, create a new one to honor default-new invariant
+                    const sessionsAfter = await agent.listSessions();
+                    if (sessionsAfter.length === 0) {
+                        const session = await agent.createSession();
+                        await agent.loadSessionAsDefault(session.id);
+                        logger.info(`Created new session: ${session.id}`, null, 'green');
+                    }
+                }
+                catch (err) {
+                    console.error(`❌ Failed to continue session: ${err instanceof Error ? err.message : String(err)}`);
+                    safeExit('main', 1, 'continue-failed');
+                }
+            }
+            else {
+                // Default behavior: create new session for CLI mode
+                try {
+                    const session = await agent.createSession();
+                    await agent.loadSessionAsDefault(session.id);
+                    logger.info(`Created new session: ${session.id}`, null, 'green');
+                }
+                catch (err) {
+                    console.error(`❌ Failed to create new session: ${err instanceof Error ? err.message : String(err)}`);
+                    safeExit('main', 1, 'create-session-failed');
+                }
+            }
             const toolConfirmationMode = agent.getEffectiveConfig().toolConfirmation?.mode ?? 'event-based';
             if (toolConfirmationMode === 'event-based') {
                 // Set up CLI tool confirmation subscriber

package/dist/webui/.next/standalone/.next/static/VoeDi3iuGmMdZu_kx-R2X/_buildManifest.js

@@ -0,0 +1 @@
+self.__BUILD_MANIFEST=function(e,r,t,s,_){return{__rewrites:{afterFiles:[{has:t,source:"/api/:path*",destination:t}],beforeFiles:[],fallback:[]},__routerFilterStatic:{numItems:3,errorRate:1e-4,numBits:58,numHashes:14,bitArray:[1,1,e,e,0,e,e,0,r,e,r,e,r,e,e,e,r,e,e,e,r,r,e,r,r,r,r,r,e,e,e,e,e,e,r,e,e,r,e,e,r,r,e,r,e,r,r,e,e,e,r,r,r,r,e,r,r,e]},__routerFilterDynamic:{numItems:e,errorRate:1e-4,numBits:20,numHashes:14,bitArray:[r,r,r,r,e,e,e,r,e,e,r,r,r,r,e,r,r,e,e,e]},"/_error":["static/chunks/pages/_error-162d61367b59fad2.js"],sortedPages:["/_app","/_error"]}}(1,0,void 0,1e-4,14),self.__BUILD_MANIFEST_CB&&self.__BUILD_MANIFEST_CB();