dexto 1.3.0 → 1.4.0

package/dist/cli/ink-cli/utils/textUtils.js

@@ -0,0 +1,248 @@
+/**
+ * Unicode-aware text utilities for terminal rendering
+ *
+ * These utilities work at the code-point level rather than UTF-16 code units,
+ * so that surrogate-pair emoji count as one "column".
+ */
+import stripAnsi from 'strip-ansi';
+import stringWidth from 'string-width';
+// Cache for code points to reduce GC pressure
+const codePointsCache = new Map();
+const MAX_STRING_LENGTH_TO_CACHE = 1000;
+/**
+ * Convert a string to an array of code points (handles surrogate pairs correctly)
+ */
+export function toCodePoints(str) {
+    // ASCII fast path - check if all chars are ASCII (0-127)
+    let isAscii = true;
+    for (let i = 0; i < str.length; i++) {
+        if (str.charCodeAt(i) > 127) {
+            isAscii = false;
+            break;
+        }
+    }
+    if (isAscii) {
+        return str.split('');
+    }
+    // Cache short strings
+    // We return a copy ([...cached]) to prevent callers from mutating the cache.
+    // This has O(n) overhead but n is bounded by MAX_STRING_LENGTH_TO_CACHE (1000).
+    if (str.length <= MAX_STRING_LENGTH_TO_CACHE) {
+        const cached = codePointsCache.get(str);
+        if (cached) {
+            return [...cached];
+        }
+    }
+    const result = Array.from(str);
+    // Cache result
+    if (str.length <= MAX_STRING_LENGTH_TO_CACHE) {
+        codePointsCache.set(str, result);
+    }
+    return result;
+}
+/**
+ * Get the code-point length of a string
+ */
+export function cpLen(str) {
+    return toCodePoints(str).length;
+}
+/**
+ * Slice a string by code-point indices
+ */
+export function cpSlice(str, start, end) {
+    const arr = toCodePoints(str).slice(start, end);
+    return arr.join('');
+}
+/**
+ * Strip characters that can break terminal rendering.
+ *
+ * Characters stripped:
+ * - ANSI escape sequences
+ * - C0 control chars (0x00-0x1F) except CR/LF/TAB
+ * - C1 control chars (0x80-0x9F)
+ *
+ * Characters preserved:
+ * - All printable Unicode including emojis
+ * - CR/LF (0x0D/0x0A) - needed for line breaks
+ * - TAB (0x09)
+ */
+export function stripUnsafeCharacters(str) {
+    const strippedAnsi = stripAnsi(str);
+    return toCodePoints(strippedAnsi)
+        .filter((char) => {
+        const code = char.codePointAt(0);
+        if (code === undefined)
+            return false;
+        // Preserve CR/LF/TAB for line handling
+        if (code === 0x0a || code === 0x0d || code === 0x09)
+            return true;
+        // Remove C0 control chars (except CR/LF/TAB)
+        if (code >= 0x00 && code <= 0x1f)
+            return false;
+        // Remove DEL control char
+        if (code === 0x7f)
+            return false;
+        // Remove C1 control chars (0x80-0x9f)
+        if (code >= 0x80 && code <= 0x9f)
+            return false;
+        // Preserve all other characters including Unicode/emojis
+        return true;
+    })
+        .join('');
+}
+// String width caching for performance optimization
+const stringWidthCache = new Map();
+/**
+ * Cached version of stringWidth function for better performance
+ */
+export function getCachedStringWidth(str) {
+    // ASCII printable chars have width 1
+    if (/^[\x20-\x7E]*$/.test(str)) {
+        return str.length;
+    }
+    if (stringWidthCache.has(str)) {
+        return stringWidthCache.get(str);
+    }
+    const width = stringWidth(str);
+    stringWidthCache.set(str, width);
+    return width;
+}
+/**
+ * Clear the string width cache
+ */
+export function clearStringWidthCache() {
+    stringWidthCache.clear();
+}
+// Word character detection helpers
+// These accept string | undefined to safely handle array bounds access (chars[i] may be undefined)
+export const isWordCharStrict = (char) => char !== undefined && /[\w\p{L}\p{N}]/u.test(char);
+export const isWhitespace = (char) => char !== undefined && /\s/.test(char);
+export const isCombiningMark = (char) => char !== undefined && /\p{M}/u.test(char);
+export const isWordCharWithCombining = (char) => isWordCharStrict(char) || isCombiningMark(char);
+// Get the script of a character (simplified for common scripts)
+export const getCharScript = (char) => {
+    if (!char)
+        return 'other';
+    if (/[\p{Script=Latin}]/u.test(char))
+        return 'latin';
+    if (/[\p{Script=Han}]/u.test(char))
+        return 'han';
+    if (/[\p{Script=Arabic}]/u.test(char))
+        return 'arabic';
+    if (/[\p{Script=Hiragana}]/u.test(char))
+        return 'hiragana';
+    if (/[\p{Script=Katakana}]/u.test(char))
+        return 'katakana';
+    if (/[\p{Script=Cyrillic}]/u.test(char))
+        return 'cyrillic';
+    return 'other';
+};
+export const isDifferentScript = (char1, char2) => {
+    if (!isWordCharStrict(char1) || !isWordCharStrict(char2))
+        return false;
+    return getCharScript(char1) !== getCharScript(char2);
+};
+// Initialize segmenter for word boundary detection
+const segmenter = new Intl.Segmenter(undefined, { granularity: 'word' });
+/**
+ * Find previous word boundary in a line
+ */
+export function findPrevWordBoundary(line, cursorCol) {
+    const codePoints = toCodePoints(line);
+    // Convert cursorCol (CP index) to string index
+    const prefix = codePoints.slice(0, cursorCol).join('');
+    const cursorIdx = prefix.length;
+    let targetIdx = 0;
+    for (const seg of segmenter.segment(line)) {
+        if (seg.index >= cursorIdx)
+            break;
+        if (seg.isWordLike) {
+            targetIdx = seg.index;
+        }
+    }
+    return toCodePoints(line.slice(0, targetIdx)).length;
+}
+/**
+ * Find next word boundary in a line
+ */
+export function findNextWordBoundary(line, cursorCol) {
+    const codePoints = toCodePoints(line);
+    const prefix = codePoints.slice(0, cursorCol).join('');
+    const cursorIdx = prefix.length;
+    let targetIdx = line.length;
+    for (const seg of segmenter.segment(line)) {
+        const segEnd = seg.index + seg.segment.length;
+        if (segEnd > cursorIdx) {
+            if (seg.isWordLike) {
+                targetIdx = segEnd;
+                break;
+            }
+        }
+    }
+    return toCodePoints(line.slice(0, targetIdx)).length;
+}
+/**
+ * Find next word start within a line, starting from col
+ */
+export function findNextWordStartInLine(line, col) {
+    const chars = toCodePoints(line);
+    let i = col;
+    if (i >= chars.length)
+        return null;
+    const currentChar = chars[i];
+    // Skip current word/sequence based on character type
+    if (isWordCharStrict(currentChar)) {
+        while (i < chars.length && isWordCharWithCombining(chars[i])) {
+            if (i + 1 < chars.length &&
+                isWordCharStrict(chars[i + 1]) &&
+                isDifferentScript(chars[i], chars[i + 1])) {
+                i++;
+                break;
+            }
+            i++;
+        }
+    }
+    else if (!isWhitespace(currentChar)) {
+        while (i < chars.length && !isWordCharStrict(chars[i]) && !isWhitespace(chars[i])) {
+            i++;
+        }
+    }
+    // Skip whitespace
+    while (i < chars.length && isWhitespace(chars[i])) {
+        i++;
+    }
+    return i < chars.length ? i : null;
+}
+/**
+ * Find previous word start within a line
+ */
+export function findPrevWordStartInLine(line, col) {
+    const chars = toCodePoints(line);
+    let i = col;
+    if (i <= 0)
+        return null;
+    i--;
+    // Skip whitespace moving backwards
+    while (i >= 0 && isWhitespace(chars[i])) {
+        i--;
+    }
+    if (i < 0)
+        return null;
+    if (isWordCharStrict(chars[i])) {
+        while (i >= 0 && isWordCharStrict(chars[i])) {
+            if (i - 1 >= 0 &&
+                isWordCharStrict(chars[i - 1]) &&
+                isDifferentScript(chars[i], chars[i - 1])) {
+                return i;
+            }
+            i--;
+        }
+        return i + 1;
+    }
+    else {
+        while (i >= 0 && !isWordCharStrict(chars[i]) && !isWhitespace(chars[i])) {
+            i--;
+        }
+        return i + 1;
+    }
+}

package/dist/cli/ink-cli/utils/toolUtils.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Tool utility functions for CLI
+ */
+/**
+ * Check if a tool is an edit or write file tool.
+ * Used for "accept all edits" mode which auto-approves these tools.
+ */
+export declare function isEditWriteTool(toolName: string | undefined): boolean;
+//# sourceMappingURL=toolUtils.d.ts.map

package/dist/cli/ink-cli/utils/toolUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolUtils.d.ts","sourceRoot":"","sources":["../../../../src/cli/ink-cli/utils/toolUtils.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;GAGG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAOrE"}

package/dist/cli/ink-cli/utils/toolUtils.js

@@ -0,0 +1,13 @@
+/**
+ * Tool utility functions for CLI
+ */
+/**
+ * Check if a tool is an edit or write file tool.
+ * Used for "accept all edits" mode which auto-approves these tools.
+ */
+export function isEditWriteTool(toolName) {
+    return (toolName === 'internal--edit_file' ||
+        toolName === 'internal--write_file' ||
+        toolName === 'edit_file' ||
+        toolName === 'write_file');
+}

package/dist/cli/utils/options.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../../../src/cli/utils/options.ts"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,GAAG,GAAG,IAAI,CA2FlD;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,CAoB3D"}
+{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../../../src/cli/utils/options.ts"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,GAAG,GAAG,IAAI,CAyFlD;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,CAoB3D"}

package/dist/cli/utils/options.js

@@ -32,7 +32,6 @@ export function validateCliOptions(opts) {
             .describe('Automatically approve all tool executions when true'),
         provider: z.string().optional(),
         model: z.string().optional(),
-        router: z.enum(['vercel', 'in-built']).optional(),
         interactive: z
             .boolean()
             .optional()
@@ -75,7 +74,6 @@ export function validateCliOptions(opts) {
         port: opts.port,
         provider: opts.provider,
         model: opts.model,
-        router: opts.router,
         interactive: opts.interactive,
         autoApprove: opts.autoApprove,
     });

package/dist/config/cli-overrides.d.ts

@@ -7,7 +7,7 @@ import type { AgentConfig, LLMConfig } from '@dexto/core';
  * CLI config override type for fields that can be overridden via CLI
  * Uses input type (LLMConfig) since these represent user-provided CLI arguments
  */
-export interface CLIConfigOverrides extends Partial<Pick<LLMConfig, 'provider' | 'model' | 'router' | 'apiKey'>> {
+export interface CLIConfigOverrides extends Partial<Pick<LLMConfig, 'provider' | 'model' | 'apiKey'>> {
     autoApprove?: boolean;
 }
 /**

package/dist/config/cli-overrides.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli-overrides.d.ts","sourceRoot":"","sources":["../../src/config/cli-overrides.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE1D;;;GAGG;AACH,MAAM,WAAW,kBACb,SAAQ,OAAO,CAAC,IAAI,CAAC,SAAS,EAAE,UAAU,GAAG,OAAO,GAAG,QAAQ,GAAG,QAAQ,CAAC,CAAC;IAC5E,WAAW,CAAC,EAAE,OAAO,CAAC;CACzB;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAC7B,UAAU,EAAE,WAAW,EACvB,YAAY,CAAC,EAAE,kBAAkB,GAClC,WAAW,CAuCb"}
+{"version":3,"file":"cli-overrides.d.ts","sourceRoot":"","sources":["../../src/config/cli-overrides.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE1D;;;GAGG;AACH,MAAM,WAAW,kBACb,SAAQ,OAAO,CAAC,IAAI,CAAC,SAAS,EAAE,UAAU,GAAG,OAAO,GAAG,QAAQ,CAAC,CAAC;IACjE,WAAW,CAAC,EAAE,OAAO,CAAC;CACzB;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAC7B,UAAU,EAAE,WAAW,EACvB,YAAY,CAAC,EAAE,kBAAkB,GAClC,WAAW,CA+Bb"}

package/dist/config/cli-overrides.js

@@ -18,29 +18,24 @@ export function applyCLIOverrides(baseConfig, cliOverrides) {
     }
     // Create a deep copy of the base config for modification
     const mergedConfig = JSON.parse(JSON.stringify(baseConfig));
-    // Ensure llm section exists
-    if (!mergedConfig.llm) {
-        mergedConfig.llm = {};
-    }
-    // Apply CLI overrides to LLM config
+    // Apply CLI overrides to LLM config (llm is required in AgentConfig)
     if (cliOverrides.provider) {
         mergedConfig.llm.provider = cliOverrides.provider;
     }
     if (cliOverrides.model) {
         mergedConfig.llm.model = cliOverrides.model;
     }
-    if (cliOverrides.router) {
-        mergedConfig.llm.router = cliOverrides.router;
-    }
     if (cliOverrides.apiKey) {
         mergedConfig.llm.apiKey = cliOverrides.apiKey;
     }
     if (cliOverrides.autoApprove) {
         // Ensure toolConfirmation section exists before overriding
         if (!mergedConfig.toolConfirmation) {
-            mergedConfig.toolConfirmation = {};
+            mergedConfig.toolConfirmation = { mode: 'auto-approve' };
+        }
+        else {
+            mergedConfig.toolConfirmation.mode = 'auto-approve';
         }
-        mergedConfig.toolConfirmation.mode = 'auto-approve';
     }
     // Return merged config without validation - validation happens later
     return mergedConfig;

package/dist/index.js

@@ -3,7 +3,7 @@
 import { applyLayeredEnvironmentLoading } from './utils/env.js';
 // Apply layered environment loading before any other imports
 await applyLayeredEnvironmentLoading();
-import { existsSync } from 'fs';
+import { existsSync, readFileSync } from 'fs';
 import { createRequire } from 'module';
 import path from 'path';
 import { Command } from 'commander';
@@ -15,10 +15,8 @@ import { withAnalytics, safeExit, ExitSignal } from './analytics/wrapper.js';
 const require = createRequire(import.meta.url);
 const pkg = require('../package.json');
 import { logger, getProviderFromModel, getAllSupportedModels, DextoAgent, isPath, resolveApiKeyForProvider, getPrimaryApiKeyEnvVar, } from '@dexto/core';
-import { resolveAgentPath, getAgentRegistry, loadAgentConfig, globalPreferencesExist, loadGlobalPreferences, } from '@dexto/agent-management';
+import { resolveAgentPath, loadAgentConfig, globalPreferencesExist, loadGlobalPreferences, resolveBundledScript, } from '@dexto/agent-management';
 import { startHonoApiServer } from './api/server-hono.js';
-import { startDiscordBot } from './discord/bot.js';
-import { startTelegramBot } from './telegram/bot.js';
 import { validateCliOptions, handleCliOptionsError } from './cli/utils/options.js';
 import { validateAgentConfig } from './cli/utils/config-validation.js';
 import { applyCLIOverrides } from './config/cli-overrides.js';
@@ -48,11 +46,10 @@ program
     .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')
     .option('-c, --continue', 'Continue most recent session (requires -p/prompt)')
     .option('-r, --resume <sessionId>', 'Resume specific session (requires -p/prompt)')
-    .option('--mode <mode>', 'The application in which dexto should talk to you - web | cli | server | discord | telegram | mcp', 'web')
+    .option('--mode <mode>', 'The application in which dexto should talk to you - web | cli | server | mcp', 'web')
     .option('--port <port>', 'port for the server (default: 3000 for web, 3001 for server mode)')
     .option('--no-auto-install', 'Disable automatic installation of missing agents from registry')
     .enablePositionalOptions();
@@ -239,16 +236,22 @@ async function bootstrapAgentFromGlobalOpts() {
     const resolvedPath = await resolveAgentPath(globalOpts.agent, globalOpts.autoInstall !== false, true);
     const rawConfig = await loadAgentConfig(resolvedPath);
     const mergedConfig = applyCLIOverrides(rawConfig, globalOpts);
-    const enrichedConfig = enrichAgentConfig(mergedConfig, resolvedPath);
+    const enrichedConfig = enrichAgentConfig(mergedConfig, resolvedPath, {
+        logLevel: 'info', // CLI uses info-level logging for visibility
+    });
     // Override approval config for read-only commands (never run conversations)
     // This avoids needing to set up unused approval handlers
     enrichedConfig.toolConfirmation = {
         mode: 'auto-approve',
-        timeout: enrichedConfig.toolConfirmation?.timeout ?? 120000,
+        ...(enrichedConfig.toolConfirmation?.timeout !== undefined && {
+            timeout: enrichedConfig.toolConfirmation.timeout,
+        }),
     };
     enrichedConfig.elicitation = {
         enabled: false,
-        timeout: enrichedConfig.elicitation?.timeout ?? 120000,
+        ...(enrichedConfig.elicitation?.timeout !== undefined && {
+            timeout: enrichedConfig.elicitation.timeout,
+        }),
     };
     const agent = new DextoAgent(enrichedConfig, resolvedPath);
     await agent.start();
@@ -439,7 +442,7 @@ program
         safeExit('mcp', 1, 'mcp-agg-failed');
     }
 }, { timeoutMs: 0 }));
-// 10) Main dexto CLI - Interactive/One shot (CLI/HEADLESS) or run in other modes (--mode web/discord/telegram)
+// 10) Main dexto CLI - Interactive/One shot (CLI/HEADLESS) or run in other modes (--mode web/server/mcp)
 program
     .argument('[prompt...]', 'Natural-language prompt to run once. If not passed, dexto will start as an interactive CLI')
     // Main customer facing description
@@ -469,8 +472,6 @@ program
     '  dexto --auto-approve     Auto-approve all tool executions\n\n' +
     'Advanced Modes:\n' +
     '  dexto --mode server      Run as API server\n' +
-    '  dexto --mode discord     Run as Discord bot\n' +
-    '  dexto --mode telegram    Run as Telegram bot\n' +
     '  dexto --mode mcp         Run as MCP server\n\n' +
     'See https://docs.dexto.ai for documentation and examples')
     .action(withAnalytics('main', async (prompt = []) => {
@@ -573,19 +574,29 @@ program
         else {
             // Early registry validation for named agents
             if (opts.agent) {
-                const registry = getAgentRegistry();
-                if (!registry.hasAgent(opts.agent)) {
-                    console.error(`❌ Agent '${opts.agent}' not found in registry`);
-                    // Show available agents
-                    const available = Object.keys(registry.getAvailableAgents());
-                    if (available.length > 0) {
-                        console.log(`📋 Available agents: ${available.join(', ')}`);
-                    }
-                    else {
-                        console.log('📋 No agents available in registry');
+                // Load bundled registry to check if agent exists
+                try {
+                    const bundledRegistryPath = resolveBundledScript('agents/agent-registry.json');
+                    const registryContent = readFileSync(bundledRegistryPath, 'utf-8');
+                    const bundledRegistry = JSON.parse(registryContent);
+                    // Check if agent exists in bundled registry
+                    if (!(opts.agent in bundledRegistry.agents)) {
+                        console.error(`❌ Agent '${opts.agent}' not found in registry`);
+                        // Show available agents
+                        const available = Object.keys(bundledRegistry.agents);
+                        if (available.length > 0) {
+                            console.log(`📋 Available agents: ${available.join(', ')}`);
+                        }
+                        else {
+                            console.log('📋 No agents available in registry');
+                        }
+                        safeExit('main', 1, 'agent-not-in-registry');
+                        return;
                     }
-                    safeExit('main', 1, 'agent-not-in-registry');
-                    return;
+                }
+                catch (error) {
+                    logger.warn(`Could not validate agent against registry: ${error instanceof Error ? error.message : String(error)}`);
+                    // Continue anyway - resolver will handle it
                 }
             }
             // Check setup state and auto-trigger if needed
@@ -608,7 +619,10 @@ program
         // Enrichment adds filesystem paths to storage (schema has in-memory defaults)
         // Interactive CLI mode: only log to file (console would interfere with chat UI)
         const isInteractiveCli = opts.mode === 'cli' && !headlessInput;
-        const enrichedConfig = enrichAgentConfig(mergedConfig, resolvedPath, isInteractiveCli);
+        const enrichedConfig = enrichAgentConfig(mergedConfig, resolvedPath, {
+            isInteractiveCli,
+            logLevel: 'info', // CLI uses info-level logging for visibility
+        });
         // Validate enriched config with interactive setup if needed (for API key issues)
         validatedConfig = await validateAgentConfig(enrichedConfig, opts.interactive !== false);
     }
@@ -704,6 +718,15 @@ program
                 const approvalCoordinator = new ApprovalCoordinator();
                 const handler = createManualApprovalHandler(approvalCoordinator);
                 agent.setApprovalHandler(handler);
+                // Bridge approval events between coordinator and agent event bus for Ink CLI
+                // Forward requests from coordinator to event bus (for UI to receive)
+                approvalCoordinator.on('approval:request', (request) => {
+                    agent.agentEventBus.emit('approval:request', request);
+                });
+                // Forward responses from event bus to coordinator (for handler to receive)
+                agent.agentEventBus.on('approval:response', (response) => {
+                    approvalCoordinator.emitResponse(response);
+                });
                 logger.debug('Event-based approval handler configured for Ink CLI');
             }
             // Start the agent now that approval handler is configured
@@ -799,8 +822,9 @@ program
             else {
                 // Interactive mode - session management handled via /resume command
                 // Note: -c and -r flags are validated to require a prompt (headless mode only)
-                // Defer session creation until first message is sent to prevent stale empty sessions
-                const cliSessionId = null;
+                // Create session eagerly so slash commands work immediately
+                const session = await agent.createSession();
+                const cliSessionId = session.id;
                 // Interactive mode - use Ink CLI with session support
                 // Suppress console output before starting Ink UI
                 const originalConsole = {
@@ -903,26 +927,6 @@ program
             console.log('  SSE support available for real-time events');
             break;
         }
-        case 'discord':
-            console.log('🤖 Starting Discord bot…');
-            try {
-                startDiscordBot(agent);
-            }
-            catch (err) {
-                console.error('❌ Discord startup failed:', err);
-                safeExit('main', 1, 'discord-startup-failed');
-            }
-            break;
-        case 'telegram':
-            console.log('🤖 Starting Telegram bot…');
-            try {
-                startTelegramBot(agent);
-            }
-            catch (err) {
-                console.error('❌ Telegram startup failed:', err);
-                safeExit('main', 1, 'telegram-startup-failed');
-            }
-            break;
         // TODO: Remove if server mode is stable and supports mcp
         // Starts dexto as a local mcp server
         // Use `dexto --mode mcp` to start dexto as a local mcp server
@@ -953,7 +957,21 @@ program
             break;
         }
         default:
-            console.error(`❌ Unknown mode '${opts.mode}'. Use web, cli, server, discord, telegram, or mcp.`);
+            if (opts.mode === 'discord' || opts.mode === 'telegram') {
+                console.error(`❌ Error: '${opts.mode}' mode has been moved to examples`);
+                console.error('');
+                console.error(`The ${opts.mode} bot is now a standalone example that you can customize.`);
+                console.error('');
+                console.error(`📖 See: examples/${opts.mode}-bot/README.md`);
+                console.error('');
+                console.error(`To run it:`);
+                console.error(`  cd examples/${opts.mode}-bot`);
+                console.error(`  pnpm install`);
+                console.error(`  pnpm start`);
+            }
+            else {
+                console.error(`❌ Unknown mode '${opts.mode}'. Use web, cli, server, or mcp.`);
+            }
             safeExit('main', 1, 'unknown-mode');
     }
 }, { timeoutMs: 0 }));

package/dist/utils/agent-helpers.d.ts

@@ -0,0 +1,95 @@
+import { AgentManager, type InstallOptions, type AgentMetadata } from '@dexto/agent-management';
+/**
+ * Get or create the CLI AgentManager instance
+ *
+ * This manager operates on the global agents directory (~/.dexto/agents)
+ * and uses the user registry file (~/.dexto/agents/registry.json).
+ *
+ * @returns AgentManager instance for CLI operations
+ *
+ * @example
+ * ```typescript
+ * const manager = getCLIAgentManager();
+ * await manager.loadRegistry();
+ * const agents = manager.listAgents();
+ * ```
+ */
+export declare function getCLIAgentManager(): AgentManager;
+/**
+ * Reset the CLI AgentManager singleton (primarily for testing)
+ *
+ * @example
+ * ```typescript
+ * // In tests
+ * resetCLIAgentManager();
+ * const manager = getCLIAgentManager(); // Creates fresh instance
+ * ```
+ */
+export declare function resetCLIAgentManager(): void;
+/**
+ * Install bundled agent from registry to ~/.dexto/agents
+ *
+ * @param agentId ID of the agent to install from bundled registry
+ * @param options Installation options (agentsDir defaults to ~/.dexto/agents)
+ * @returns Path to the installed agent's main config file
+ *
+ * @throws {Error} If agent not found in bundled registry or installation fails
+ *
+ * @example
+ * ```typescript
+ * await installBundledAgent('coding-agent');
+ * console.log('Agent installed to ~/.dexto/agents/coding-agent');
+ * ```
+ */
+export declare function installBundledAgent(agentId: string, options?: InstallOptions): Promise<string>;
+/**
+ * Install custom agent from local path to ~/.dexto/agents
+ *
+ * @param agentId Unique ID for the custom agent
+ * @param sourcePath Absolute path to agent YAML file or directory
+ * @param metadata Agent metadata (name, description, author, tags)
+ * @param options Installation options (agentsDir defaults to ~/.dexto/agents)
+ * @returns Path to the installed agent's main config file
+ *
+ * @throws {Error} If agent ID already exists or installation fails
+ *
+ * @example
+ * ```typescript
+ * await installCustomAgent('my-agent', '/path/to/agent.yml', {
+ *   name: 'My Agent',
+ *   description: 'Custom agent for my use case',
+ *   author: 'John Doe',
+ *   tags: ['custom']
+ * });
+ * ```
+ */
+export declare function installCustomAgent(agentId: string, sourcePath: string, metadata: Pick<AgentMetadata, 'name' | 'description' | 'author' | 'tags'>, options?: InstallOptions): Promise<string>;
+/**
+ * Uninstall agent by removing it from disk and user registry
+ *
+ * @param agentId ID of the agent to uninstall
+ * @param options Installation options (agentsDir defaults to ~/.dexto/agents)
+ *
+ * @throws {Error} If agent not found or uninstallation fails
+ *
+ * @example
+ * ```typescript
+ * await uninstallAgent('my-custom-agent');
+ * console.log('Agent uninstalled');
+ * ```
+ */
+export declare function uninstallAgent(agentId: string, options?: InstallOptions): Promise<void>;
+/**
+ * List installed agents from ~/.dexto/agents
+ *
+ * @param options Installation options (agentsDir defaults to ~/.dexto/agents)
+ * @returns Array of installed agent IDs
+ *
+ * @example
+ * ```typescript
+ * const installed = await listInstalledAgents();
+ * console.log(installed); // ['coding-agent', 'my-custom-agent']
+ * ```
+ */
+export declare function listInstalledAgents(options?: InstallOptions): Promise<string[]>;
+//# sourceMappingURL=agent-helpers.d.ts.map

package/dist/utils/agent-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-helpers.d.ts","sourceRoot":"","sources":["../../src/utils/agent-helpers.ts"],"names":[],"mappings":"AAGA,OAAO,EACH,YAAY,EAMZ,KAAK,cAAc,EACnB,KAAK,aAAa,EACrB,MAAM,yBAAyB,CAAC;AAQjC;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,kBAAkB,IAAI,YAAY,CAMjD;AAED;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,IAAI,IAAI,CAE3C;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,mBAAmB,CACrC,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,cAAc,GACzB,OAAO,CAAC,MAAM,CAAC,CAEjB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,kBAAkB,CACpC,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,IAAI,CAAC,aAAa,EAAE,MAAM,GAAG,aAAa,GAAG,QAAQ,GAAG,MAAM,CAAC,EACzE,OAAO,CAAC,EAAE,cAAc,GACzB,OAAO,CAAC,MAAM,CAAC,CAEjB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAE7F;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,mBAAmB,CAAC,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAErF"}