dexto 1.6.8 → 1.6.9

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

@@ -0,0 +1,78 @@
+import { resolveAgentPath } from '@dexto/agent-management';
+import { withAnalytics, safeExit, ExitSignal } from '../../../analytics/wrapper.js';
+export function registerRunCommand({ program, cliVersion, bootstrapAgentFromGlobalOpts, }) {
+    program
+        .command('run [prompt]')
+        .description('Run a single prompt non-interactively (headless mode)')
+        .option('-m, --model <model>', 'Specify the LLM model to use for this run')
+        .addHelpText('after', `
+Examples:
+  $ dexto run "summarize this repository"
+  $ echo "fix lint errors" | dexto run
+  $ dexto run - < prompt.txt
+`)
+        .action(withAnalytics('run', async (promptArg, runOptions) => {
+        let agent;
+        let exitCode = 0;
+        let exitReason = 'ok';
+        try {
+            const { executeHeadlessRun, printHeadlessAssistantResponse, printHeadlessMcpStartup, printHeadlessRunSummary, resolveHeadlessPrompt, writeFinalMessageToStdout, writeHeadlessError, } = await import('./headless.js');
+            const prompt = await resolveHeadlessPrompt(promptArg);
+            if (prompt.trim().length === 0) {
+                writeHeadlessError('Prompt cannot be empty.');
+                exitCode = 1;
+                exitReason = 'empty-prompt';
+            }
+            else {
+                const bootstrapOptions = runOptions?.model
+                    ? { mode: 'headless-run', modelOverride: runOptions.model }
+                    : { mode: 'headless-run' };
+                agent = await bootstrapAgentFromGlobalOpts(bootstrapOptions);
+                const session = await agent.createSession();
+                const globalOpts = program.opts();
+                const resolvedAgentPath = await resolveAgentPath(globalOpts.agent, globalOpts.autoInstall !== false);
+                printHeadlessRunSummary({
+                    agent,
+                    sessionId: session.id,
+                    prompt,
+                    agentPath: resolvedAgentPath,
+                    cliVersion,
+                });
+                printHeadlessMcpStartup(agent);
+                const runResult = await executeHeadlessRun(agent, session.id, prompt);
+                if (runResult.finalMessage !== undefined) {
+                    printHeadlessAssistantResponse(runResult.finalMessage, runResult.totalTokens);
+                    writeFinalMessageToStdout(runResult.finalMessage);
+                }
+                else {
+                    writeHeadlessError('No final response was produced.');
+                    exitCode = 1;
+                    exitReason = 'no-final-response';
+                }
+                if (runResult.fatalError) {
+                    exitCode = 1;
+                    exitReason = 'fatal-error';
+                }
+            }
+        }
+        catch (err) {
+            if (err instanceof ExitSignal)
+                throw err;
+            const errorMessage = err instanceof Error ? err.message : String(err);
+            process.stderr.write(`dexto run failed: ${errorMessage}\n`);
+            exitCode = 1;
+            exitReason = 'error';
+        }
+        finally {
+            if (agent) {
+                try {
+                    await agent.stop();
+                }
+                catch {
+                    // Ignore shutdown errors in headless mode cleanup
+                }
+            }
+        }
+        safeExit('run', exitCode, exitReason);
+    }));
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"register.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/search/register.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,wBAAwB,CAAC;AAE5E,wBAAgB,qBAAqB,CAAC,EAClC,OAAO,EACP,4BAA4B,GAC/B,EAAE,6BAA6B,GAAG,IAAI,CA8EtC"}

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

@@ -0,0 +1,55 @@
+import { withAnalytics, safeExit, ExitSignal } from '../../../analytics/wrapper.js';
+export function registerSearchCommand({ program, bootstrapAgentFromGlobalOpts, }) {
+    program
+        .command('search')
+        .description('Search session history')
+        .argument('<query>', 'Search query')
+        .option('--session <sessionId>', 'Search in specific session')
+        .option('--role <role>', 'Filter by role (user, assistant, system, tool)')
+        .option('--limit <number>', 'Limit number of results', '10')
+        .action(withAnalytics('search', async (query, options) => {
+        let agent = null;
+        try {
+            const searchOptions = {};
+            if (options.session) {
+                searchOptions.sessionId = options.session;
+            }
+            if (options.role) {
+                const allowed = new Set(['user', 'assistant', 'system', 'tool']);
+                if (!allowed.has(options.role)) {
+                    console.error(`❌ Invalid role: ${options.role}. Use one of: user, assistant, system, tool`);
+                    safeExit('search', 1, 'invalid-role');
+                }
+                searchOptions.role = options.role;
+            }
+            if (options.limit) {
+                const rawLimit = options.limit.trim();
+                const parsed = Number(rawLimit);
+                if (!/^\d+$/.test(rawLimit) ||
+                    !Number.isInteger(parsed) ||
+                    parsed <= 0) {
+                    console.error(`❌ Invalid --limit: ${options.limit}. Use a positive integer (e.g., 10).`);
+                    safeExit('search', 1, 'invalid-limit');
+                }
+                searchOptions.limit = parsed;
+            }
+            agent = await bootstrapAgentFromGlobalOpts({
+                mode: 'non-interactive',
+            });
+            const { handleSessionSearchCommand } = await import('../session-commands.js');
+            await handleSessionSearchCommand(agent, query, searchOptions);
+            safeExit('search', 0);
+        }
+        catch (err) {
+            if (err instanceof ExitSignal)
+                throw err;
+            console.error(`❌ dexto search command failed: ${err}`);
+            safeExit('search', 1, 'error');
+        }
+        finally {
+            if (agent) {
+                await agent.stop().catch(() => { });
+            }
+        }
+    }));
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"register.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/session/register.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,wBAAwB,CAAC;AAE5E,wBAAgB,sBAAsB,CAAC,EACnC,OAAO,EACP,4BAA4B,GAC/B,EAAE,6BAA6B,GAAG,IAAI,CA4EtC"}

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

@@ -0,0 +1,75 @@
+import { withAnalytics, safeExit, ExitSignal } from '../../../analytics/wrapper.js';
+export function registerSessionCommand({ program, bootstrapAgentFromGlobalOpts, }) {
+    const sessionCommand = program.command('session').description('Manage chat sessions');
+    sessionCommand
+        .command('list')
+        .description('List all sessions')
+        .action(withAnalytics('session list', async () => {
+        let agent = null;
+        try {
+            agent = await bootstrapAgentFromGlobalOpts({ mode: 'non-interactive' });
+            const { handleSessionListCommand } = await import('../session-commands.js');
+            await handleSessionListCommand(agent);
+            safeExit('session list', 0);
+        }
+        catch (err) {
+            if (err instanceof ExitSignal)
+                throw err;
+            console.error(`❌ dexto session list command failed: ${err}`);
+            safeExit('session list', 1, 'error');
+        }
+        finally {
+            if (agent) {
+                await agent.stop().catch(() => { });
+            }
+        }
+    }));
+    sessionCommand
+        .command('history')
+        .description('Show session history')
+        .argument('[sessionId]', 'Session ID (defaults to current session)')
+        .action(withAnalytics('session history', async (sessionId) => {
+        let agent = null;
+        try {
+            agent = await bootstrapAgentFromGlobalOpts({ mode: 'non-interactive' });
+            const { handleSessionHistoryCommand } = await import('../session-commands.js');
+            await handleSessionHistoryCommand(agent, sessionId);
+            safeExit('session history', 0);
+        }
+        catch (err) {
+            if (err instanceof ExitSignal)
+                throw err;
+            console.error(`❌ dexto session history command failed: ${err}`);
+            safeExit('session history', 1, 'error');
+        }
+        finally {
+            if (agent) {
+                await agent.stop().catch(() => { });
+            }
+        }
+    }));
+    sessionCommand
+        .command('delete')
+        .description('Delete a session')
+        .argument('<sessionId>', 'Session ID to delete')
+        .action(withAnalytics('session delete', async (sessionId) => {
+        let agent = null;
+        try {
+            agent = await bootstrapAgentFromGlobalOpts({ mode: 'non-interactive' });
+            const { handleSessionDeleteCommand } = await import('../session-commands.js');
+            await handleSessionDeleteCommand(agent, sessionId);
+            safeExit('session delete', 0);
+        }
+        catch (err) {
+            if (err instanceof ExitSignal)
+                throw err;
+            console.error(`❌ dexto session delete command failed: ${err}`);
+            safeExit('session delete', 1, 'error');
+        }
+        finally {
+            if (agent) {
+                await agent.stop().catch(() => { });
+            }
+        }
+    }));
+}

package/dist/cli/commands/setup.js

@@ -9,7 +9,7 @@ import { selectProvider, getProviderDisplayName, getProviderEnvVar, providerRequ
 import { setupLocalModels, setupOllamaModels, hasSelectedModel, getModelFromResult, } from '../utils/local-model-setup.js';
 import { requiresSetup } from '../utils/setup-utils.js';
 import { canUseDextoProvider } from '../utils/dexto-setup.js';
-import { handleBrowserLogin } from './auth/login.js';
+import { handleAutoLogin } from './auth/login.js';
 import { loadAuth, getDextoApiClient } from '../auth/index.js';
 import { DEXTO_CREDITS_URL } from '../auth/constants.js';
 import * as p from '@clack/prompts';
@@ -431,16 +431,16 @@ async function handleDextoProviderSetup(options = {}) {
     const hasKey = await canUseDextoProvider();
     if (!hasKey) {
         p.note(`Dexto gives you instant access to ${chalk.cyan('all AI models')} with a single account.\n\n` +
-            `We'll open your browser to sign in or create an account.`, 'Login Required');
+            `We'll guide you through device-code login.`, 'Login Required');
         const shouldLogin = await p.confirm({
-            message: 'Continue with browser login?',
+            message: 'Continue with Dexto login?',
             initialValue: true,
         });
         if (p.isCancel(shouldLogin) || !shouldLogin) {
             return abort('Setup cancelled');
         }
         try {
-            await handleBrowserLogin();
+            await handleAutoLogin();
             // Verify key was actually provisioned (provisionKeys silently catches errors)
             if (!(await canUseDextoProvider())) {
                 p.log.error('API key provisioning failed. Please try again or use `dexto setup` with a different provider.');

package/dist/cli/commands/sync-agents.d.ts

@@ -25,9 +25,9 @@ export declare function shouldPromptForSync(): Promise<boolean>;
  *
  * @example
  * ```bash
- * dexto sync-agents          # Interactive - prompt for each
- * dexto sync-agents --list   # Show what would be updated
- * dexto sync-agents --force  # Update all without prompting
+ * dexto agents sync          # Interactive - prompt for each
+ * dexto agents sync --list   # Show what would be updated
+ * dexto agents sync --force  # Update all without prompting
  * ```
  */
 export declare function handleSyncAgentsCommand(options: SyncAgentsCommandOptions): Promise<void>;

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

@@ -243,9 +243,9 @@ function formatStatus(status) {
  *
  * @example
  * ```bash
- * dexto sync-agents          # Interactive - prompt for each
- * dexto sync-agents --list   # Show what would be updated
- * dexto sync-agents --force  # Update all without prompting
+ * dexto agents sync          # Interactive - prompt for each
+ * dexto agents sync --list   # Show what would be updated
+ * dexto agents sync --force  # Update all without prompting
  * ```
  */
 export async function handleSyncAgentsCommand(options) {
@@ -363,7 +363,7 @@ export async function handleSyncAgentsCommand(options) {
         console.log('');
         // If list mode, stop here
         if (list) {
-            p.outro('Use `dexto sync-agents` to update agents');
+            p.outro('Use `dexto agents sync` to update agents');
             return;
         }
         // No updates needed

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

@@ -4,13 +4,13 @@ declare const UninstallCommandSchema: z.ZodObject<{
     all: z.ZodDefault<z.ZodBoolean>;
     force: z.ZodDefault<z.ZodBoolean>;
 }, "strict", z.ZodTypeAny, {
-    all: boolean;
     agents: string[];
     force: boolean;
+    all: boolean;
 }, {
     agents: string[];
-    all?: boolean | undefined;
     force?: boolean | undefined;
+    all?: boolean | undefined;
 }>;
 export type UninstallCommandOptions = z.output<typeof UninstallCommandSchema>;
 export declare function handleUninstallCommand(agents: string[], options: Partial<UninstallCommandOptions>): Promise<void>;

package/dist/cli/modes/cli.d.ts

@@ -0,0 +1,3 @@
+import type { MainModeContext } from './context.js';
+export declare function runCliMode(context: MainModeContext): Promise<void>;
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli/modes/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../../src/cli/modes/cli.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAsBpD,wBAAsB,UAAU,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAuLxE"}

package/dist/cli/modes/cli.js

@@ -0,0 +1,170 @@
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+import { logger } from '@dexto/core';
+import { safeExit, ExitSignal } from '../../analytics/wrapper.js';
+async function getMostRecentSessionId(agent) {
+    const sessionIds = await agent.listSessions();
+    if (sessionIds.length === 0) {
+        return null;
+    }
+    let mostRecentId = null;
+    let mostRecentActivity = 0;
+    for (const sessionId of sessionIds) {
+        const metadata = await agent.getSessionMetadata(sessionId);
+        if (metadata && metadata.lastActivity > mostRecentActivity) {
+            mostRecentActivity = metadata.lastActivity;
+            mostRecentId = sessionId;
+        }
+    }
+    return mostRecentId;
+}
+export async function runCliMode(context) {
+    const { agent, opts, validatedConfig, resolvedPath, initialPrompt, getVersionCheckResult } = context;
+    const needsHandler = validatedConfig.permissions.mode === 'manual' || validatedConfig.elicitation.enabled;
+    if (needsHandler) {
+        const { createCLIApprovalHandler } = await import('../approval/index.js');
+        const handler = createCLIApprovalHandler(agent);
+        agent.setApprovalHandler(handler);
+        logger.debug('CLI approval handler configured for Ink CLI');
+    }
+    await agent.start();
+    try {
+        const llmConfig = agent.getCurrentLLMConfig();
+        const { requiresApiKey } = await import('@dexto/core');
+        if (requiresApiKey(llmConfig.provider) && !llmConfig.apiKey?.trim()) {
+            const { interactiveApiKeySetup } = await import('../utils/api-key-setup.js');
+            console.log(chalk.yellow(`\n⚠️  API key required for provider '${llmConfig.provider}'\n`));
+            const setupResult = await interactiveApiKeySetup(llmConfig.provider, {
+                exitOnCancel: false,
+                model: llmConfig.model,
+            });
+            if (setupResult.cancelled) {
+                safeExit('main', 0, 'api-key-setup-cancelled');
+            }
+            if (setupResult.skipped) {
+                safeExit('main', 0, 'api-key-pending');
+            }
+            if (setupResult.success && setupResult.apiKey) {
+                await agent.switchLLM({
+                    provider: llmConfig.provider,
+                    model: llmConfig.model,
+                    apiKey: setupResult.apiKey,
+                });
+                logger.info('API key configured successfully, continuing...');
+            }
+        }
+        let cliSessionId;
+        if (opts.resume) {
+            const existing = await agent.getSession(opts.resume);
+            if (!existing) {
+                console.error(`❌ Session '${opts.resume}' not found`);
+                console.error('💡 Use `dexto session list` to see available sessions');
+                safeExit('main', 1, 'resume-failed');
+            }
+            cliSessionId = opts.resume;
+        }
+        else if (opts.continue) {
+            const mostRecentSessionId = await getMostRecentSessionId(agent);
+            if (mostRecentSessionId) {
+                cliSessionId = mostRecentSessionId;
+            }
+            else {
+                const session = await agent.createSession();
+                cliSessionId = session.id;
+            }
+        }
+        else {
+            const session = await agent.createSession();
+            cliSessionId = session.id;
+        }
+        const cliUpdateInfo = await getVersionCheckResult();
+        const { shouldPromptForSync, handleSyncAgentsCommand } = await import('../commands/sync-agents.js');
+        const needsSync = await shouldPromptForSync();
+        if (needsSync) {
+            const shouldSync = await p.confirm({
+                message: 'Agent config updates available. Sync now?',
+                initialValue: true,
+            });
+            if (!p.isCancel(shouldSync) && shouldSync) {
+                await handleSyncAgentsCommand({ force: true, quiet: true });
+            }
+        }
+        const originalConsole = {
+            log: console.log,
+            error: console.error,
+            warn: console.warn,
+            info: console.info,
+        };
+        const noOp = () => { };
+        console.log = noOp;
+        console.error = noOp;
+        console.warn = noOp;
+        console.info = noOp;
+        let inkError = undefined;
+        try {
+            const [{ startInkCliRefactored, setTuiRuntimeServices }, { registerGracefulShutdown }, { applyLayeredEnvironmentLoading }, { getProviderDisplayName, isValidApiKeyFormat, getProviderInstructions }, { performDeviceCodeLogin, persistOAuthLoginResult, ensureDextoApiKeyForAuthToken, loadAuth, storeAuth, removeAuth, removeDextoApiKeyFromEnv, }, { isUsingDextoCredits }, { canUseDextoProvider }, { capture },] = await Promise.all([
+                import('@dexto/tui'),
+                import('../../utils/graceful-shutdown.js'),
+                import('../../utils/env.js'),
+                import('../utils/provider-setup.js'),
+                import('../auth/index.js'),
+                import('../../config/effective-llm.js'),
+                import('../utils/dexto-setup.js'),
+                import('../../analytics/index.js'),
+            ]);
+            setTuiRuntimeServices({
+                registerGracefulShutdown,
+                capture: (event, properties) => {
+                    capture(event, properties);
+                },
+                applyLayeredEnvironmentLoading,
+                getProviderDisplayName,
+                isValidApiKeyFormat,
+                getProviderInstructions,
+                performDeviceCodeLogin,
+                persistOAuthLoginResult,
+                ensureDextoApiKeyForAuthToken,
+                loadAuth,
+                storeAuth,
+                removeAuth,
+                removeDextoApiKeyFromEnv,
+                isUsingDextoCredits,
+                canUseDextoProvider,
+            });
+            await startInkCliRefactored(agent, cliSessionId, {
+                updateInfo: cliUpdateInfo ?? undefined,
+                configFilePath: resolvedPath,
+                ...(initialPrompt && { initialPrompt }),
+                bypassPermissions: opts.bypassPermissions,
+            });
+        }
+        catch (error) {
+            inkError = error;
+        }
+        finally {
+            console.log = originalConsole.log;
+            console.error = originalConsole.error;
+            console.warn = originalConsole.warn;
+            console.info = originalConsole.info;
+        }
+        if (inkError) {
+            if (inkError instanceof ExitSignal)
+                throw inkError;
+            const errorMessage = inkError instanceof Error ? inkError.message : String(inkError);
+            console.error(`❌ Ink CLI failed: ${errorMessage}`);
+            if (inkError instanceof Error && inkError.stack) {
+                console.error(inkError.stack);
+            }
+            safeExit('main', 1, 'ink-cli-error');
+        }
+        safeExit('main', 0);
+    }
+    finally {
+        try {
+            await agent.stop();
+        }
+        catch {
+            // Ignore shutdown errors
+        }
+    }
+}

package/dist/cli/modes/context.d.ts

@@ -0,0 +1,20 @@
+import type { ValidatedAgentConfig } from '@dexto/agent-config';
+import type { DextoAgent } from '@dexto/core';
+import type { UpdateInfo } from '../utils/version-check.js';
+export interface MainModeOptions {
+    mode: string;
+    port?: string;
+    resume?: string;
+    continue?: boolean;
+    bypassPermissions?: boolean;
+}
+export interface MainModeContext {
+    agent: DextoAgent;
+    opts: MainModeOptions;
+    validatedConfig: ValidatedAgentConfig;
+    resolvedPath: string;
+    derivedAgentId: string;
+    initialPrompt: string | undefined;
+    getVersionCheckResult: () => Promise<UpdateInfo | null>;
+}
+//# sourceMappingURL=context.d.ts.map

package/dist/cli/modes/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../../src/cli/modes/context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAE5D,MAAM,WAAW,eAAe;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC/B;AAED,MAAM,WAAW,eAAe;IAC5B,KAAK,EAAE,UAAU,CAAC;IAClB,IAAI,EAAE,eAAe,CAAC;IACtB,eAAe,EAAE,oBAAoB,CAAC;IACtC,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,GAAG,SAAS,CAAC;IAClC,qBAAqB,EAAE,MAAM,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAAC;CAC3D"}

package/dist/cli/modes/context.js

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

package/dist/cli/modes/dispatch.d.ts

@@ -0,0 +1,3 @@
+import type { MainModeContext } from './context.js';
+export declare function dispatchMainMode(context: MainModeContext): Promise<void>;
+//# sourceMappingURL=dispatch.d.ts.map

package/dist/cli/modes/dispatch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispatch.d.ts","sourceRoot":"","sources":["../../../src/cli/modes/dispatch.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAEpD,wBAAsB,gBAAgB,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAqD9E"}

package/dist/cli/modes/dispatch.js

@@ -0,0 +1,52 @@
+import { safeExit, ExitSignal } from '../../analytics/wrapper.js';
+export async function dispatchMainMode(context) {
+    const mode = context.opts.mode;
+    try {
+        switch (mode) {
+            case 'cli': {
+                const { runCliMode } = await import('./cli.js');
+                await runCliMode(context);
+                return;
+            }
+            case 'web': {
+                const { runWebMode } = await import('./web.js');
+                await runWebMode(context);
+                return;
+            }
+            case 'server': {
+                const { runServerMode } = await import('./server.js');
+                await runServerMode(context);
+                return;
+            }
+            case 'mcp': {
+                const { runMcpMode } = await import('./mcp.js');
+                await runMcpMode(context);
+                return;
+            }
+            default:
+                if (mode === 'discord' || mode === 'telegram') {
+                    console.error(`❌ Error: '${mode}' mode has been moved to examples`);
+                    console.error('');
+                    console.error(`The ${mode} bot is now a standalone example that you can customize.`);
+                    console.error('');
+                    console.error(`📖 See: examples/${mode}-bot/README.md`);
+                    console.error('');
+                    console.error('To run it:');
+                    console.error(`  cd examples/${mode}-bot`);
+                    console.error('  pnpm install');
+                    console.error('  pnpm start');
+                }
+                else {
+                    console.error(`❌ Unknown mode '${mode}'. Use web, cli, server, or mcp.`);
+                }
+                safeExit('main', 1, 'unknown-mode');
+        }
+    }
+    catch (err) {
+        if (err instanceof ExitSignal)
+            throw err;
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(`❌ Failed to start '${mode}' mode: ${message}`);
+        safeExit('main', 1, 'mode-startup-failed');
+    }
+}

package/dist/cli/modes/mcp.d.ts

@@ -0,0 +1,3 @@
+import type { MainModeContext } from './context.js';
+export declare function runMcpMode(context: MainModeContext): Promise<void>;
+//# sourceMappingURL=mcp.d.ts.map

package/dist/cli/modes/mcp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp.d.ts","sourceRoot":"","sources":["../../../src/cli/modes/mcp.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAEpD,wBAAsB,UAAU,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAwBxE"}

package/dist/cli/modes/mcp.js

@@ -0,0 +1,23 @@
+import { createAgentCard } from '@dexto/core';
+import { safeExit } from '../../analytics/wrapper.js';
+export async function runMcpMode(context) {
+    const { agent } = context;
+    const agentCardConfig = agent.config.agentCard || {
+        name: 'dexto',
+        version: '1.0.0',
+    };
+    try {
+        const agentCardData = createAgentCard({
+            defaultName: agentCardConfig.name ?? 'dexto',
+            defaultVersion: agentCardConfig.version ?? '1.0.0',
+            defaultBaseUrl: 'stdio://local-dexto',
+        }, agentCardConfig);
+        const { createMcpTransport, initializeMcpServer } = await import('@dexto/server');
+        const mcpTransport = await createMcpTransport('stdio');
+        await initializeMcpServer(agent, agentCardData, mcpTransport);
+    }
+    catch (err) {
+        process.stderr.write(`MCP server startup failed: ${err}\n`);
+        safeExit('main', 1, 'mcp-startup-failed');
+    }
+}

package/dist/cli/modes/server.d.ts

@@ -0,0 +1,3 @@
+import type { MainModeContext } from './context.js';
+export declare function runServerMode(context: MainModeContext): Promise<void>;
+//# sourceMappingURL=server.d.ts.map

package/dist/cli/modes/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../../src/cli/modes/server.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAEpD,wBAAsB,aAAa,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CA0C3E"}

package/dist/cli/modes/server.js

@@ -0,0 +1,36 @@
+import { getPort } from '../../utils/port-utils.js';
+export async function runServerMode(context) {
+    const { agent, opts, derivedAgentId, resolvedPath, getVersionCheckResult } = context;
+    const { startHonoApiServer } = await import('../../api/server-hono.js');
+    const agentCard = agent.config.agentCard ?? {};
+    const defaultPort = (() => {
+        if (!opts.port) {
+            return 3001;
+        }
+        const rawPort = opts.port.trim();
+        const parsedPort = Number(rawPort);
+        if (!/^\d+$/.test(rawPort) ||
+            !Number.isInteger(parsedPort) ||
+            parsedPort <= 0 ||
+            parsedPort > 65535) {
+            throw new Error(`Invalid --port value "${opts.port}". Use a port between 1 and 65535.`);
+        }
+        return parsedPort;
+    })();
+    const apiPort = getPort(process.env.PORT, defaultPort, 'PORT');
+    const apiUrl = process.env.DEXTO_URL ?? `http://localhost:${apiPort}`;
+    console.log('🌐 Starting server (REST APIs + SSE)...');
+    await startHonoApiServer(agent, apiPort, agentCard, derivedAgentId, resolvedPath);
+    console.log(`✅ Server running at ${apiUrl}`);
+    console.log('Available endpoints:');
+    console.log('  POST /api/message - Send async message');
+    console.log('  POST /api/message-sync - Send sync message');
+    console.log('  POST /api/reset - Reset conversation');
+    console.log('  GET  /api/mcp/servers - List MCP servers');
+    console.log('  SSE support available for real-time events');
+    const serverUpdateInfo = await getVersionCheckResult();
+    if (serverUpdateInfo) {
+        const { displayUpdateNotification } = await import('../utils/version-check.js');
+        displayUpdateNotification(serverUpdateInfo);
+    }
+}