shortcutxl 0.2.0

package/dist/main.js

@@ -0,0 +1,613 @@
+/**
+ * Main entry point for the coding agent CLI.
+ *
+ * This file handles CLI argument parsing and translates them into
+ * createAgentSession() options. The SDK does the heavy lifting.
+ */
+import { supportsXhigh } from '@mariozechner/pi-ai';
+import chalk from 'chalk';
+import { spawn } from 'child_process';
+import { createInterface } from 'readline';
+import { parseArgs, printHelp } from './cli/args.js';
+import { selectConfig } from './cli/config-selector.js';
+import { processFileArguments } from './cli/file-processor.js';
+import { listModels } from './cli/list-models.js';
+import { handlePackageCommand } from './cli/package-commands.js';
+import { reportSettingsErrors } from './cli/report-settings-errors.js';
+import { selectSession } from './cli/session-picker.js';
+import { getAgentDir, getModelsPath, getUpdateCommand, NPM_PACKAGE_NAME, NPM_REGISTRY_URL, VERSION } from './config.js';
+import { AuthStorage } from './core/auth-storage.js';
+// SHORTCUT PATCH: removed DEFAULT_THINKING_LEVEL import (no longer needed without scoped models)
+import { DEV_MODE, isInstalled } from './config.js';
+import { exportFromFile } from './core/export-html/index.js';
+import { KeybindingsManager } from './core/keybindings.js';
+import { ModelRegistry } from './core/model-registry.js';
+import { resolveCliModel } from './core/model-resolver.js';
+import { DefaultPackageManager } from './core/package-manager.js';
+import { DefaultResourceLoader } from './core/resource-loader.js';
+import { createAgentSession } from './core/sdk.js';
+import { SessionManager } from './core/session-manager.js';
+import { SettingsManager } from './core/settings-manager.js';
+import { initTheme, stopThemeWatcher } from './core/theme.js';
+import { printTimings, time } from './core/timings.js';
+import { allTools } from './core/tools/index.js';
+import { actionAgent, installationAgent } from './custom/agents/index.js';
+import { startProactiveRefresh } from './custom/auth/refresh-timer.js';
+import { EXCEL_HTTP_URL, SHORTCUT_LLM_PROXY_URL } from './custom/constants.js';
+import { fetchWorkbookSummary, formatSummaryForLlm, parseWorkbookNames } from './custom/context/workbook-summary.js';
+import { fetchCreditBalance } from './custom/credits/shortcut-credits.js';
+import { startCronStatusPolling } from './custom/cron/status-line.js';
+import { getDevHooks } from './custom/dev/index.js';
+import { runPreflight } from './custom/preflight.js';
+import { SHORTCUT_PROVIDER_ID } from './custom/providers/provider-ids.js';
+// TODO: Re-enable when we support multiple providers
+// import { registerOpenAICodexProvider } from './custom/providers/register-openai-codex-provider.js';
+import { registerShortcutProvider } from './custom/providers/register-shortcut-provider.js';
+import { syncXll } from './custom/sync-xll.js';
+import { createCronTool } from './custom/tools/cron.js';
+import { createExcelExecTool } from './custom/tools/excel-exec.js';
+import { createLlmAnalysisTool } from './custom/tools/llm-analysis.js';
+import { createSwitchModeTool, setCurrentMode } from './custom/tools/switch-mode.js';
+import { createTaskTool } from './custom/tools/task/index.js';
+import { createTodoListTool, setTodoWidget } from './custom/tools/todo-list.js';
+import { attachSessionUpload } from './custom/tracing/session-upload.js';
+import { runMigrations, showDeprecationWarnings } from './migrations.js';
+import { InteractiveMode, runPrintMode, runRpcMode } from './modes/index.js';
+import { runSubagent } from './subagent-entry.js';
+import { CRON, EXCEL_EXEC, LLM_ANALYSIS, SWITCH_MODE, TASK, TODO_LIST } from './tool-names.js';
+/**
+ * Read all content from piped stdin.
+ * Returns undefined if stdin is a TTY (interactive terminal).
+ */
+async function readPipedStdin() {
+    // If stdin is a TTY, we're running interactively - don't read stdin
+    if (process.stdin.isTTY) {
+        return undefined;
+    }
+    return new Promise((resolve) => {
+        let data = '';
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('data', (chunk) => {
+            data += chunk;
+        });
+        process.stdin.on('end', () => {
+            resolve(data.trim() || undefined);
+        });
+        process.stdin.resume();
+    });
+}
+function isTruthyEnvFlag(value) {
+    if (!value)
+        return false;
+    return value === '1' || value.toLowerCase() === 'true' || value.toLowerCase() === 'yes';
+}
+async function prepareInitialMessage(parsed, autoResizeImages) {
+    if (parsed.fileArgs.length === 0) {
+        return {};
+    }
+    const { text, images } = await processFileArguments(parsed.fileArgs, { autoResizeImages });
+    let initialMessage;
+    if (parsed.messages.length > 0) {
+        initialMessage = text + parsed.messages[0];
+        parsed.messages.shift();
+    }
+    else {
+        initialMessage = text;
+    }
+    return {
+        initialMessage,
+        initialImages: images.length > 0 ? images : undefined
+    };
+}
+/**
+ * Resolve a session argument to a file path.
+ * If it looks like a path, use as-is. Otherwise try to match as session ID prefix.
+ */
+async function resolveSessionPath(sessionArg, cwd, sessionDir) {
+    // If it looks like a file path, use as-is
+    if (sessionArg.includes('/') || sessionArg.includes('\\') || sessionArg.endsWith('.jsonl')) {
+        return { type: 'path', path: sessionArg };
+    }
+    // Try to match as session ID in current project first
+    const localSessions = await SessionManager.list(cwd, sessionDir);
+    const localMatches = localSessions.filter((s) => s.id.startsWith(sessionArg));
+    if (localMatches.length >= 1) {
+        return { type: 'local', path: localMatches[0].path };
+    }
+    // Try global search across all projects
+    const allSessions = await SessionManager.listAll();
+    const globalMatches = allSessions.filter((s) => s.id.startsWith(sessionArg));
+    if (globalMatches.length >= 1) {
+        const match = globalMatches[0];
+        return { type: 'global', path: match.path, cwd: match.cwd };
+    }
+    // Not found anywhere
+    return { type: 'not_found', arg: sessionArg };
+}
+/** Prompt user for yes/no confirmation */
+async function promptConfirm(message) {
+    return new Promise((resolve) => {
+        const rl = createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+        rl.question(`${message} [y/N] `, (answer) => {
+            rl.close();
+            resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
+        });
+    });
+}
+async function createSessionManager(parsed, cwd) {
+    if (parsed.noSession) {
+        return SessionManager.inMemory();
+    }
+    if (parsed.session) {
+        const resolved = await resolveSessionPath(parsed.session, cwd, parsed.sessionDir);
+        switch (resolved.type) {
+            case 'path':
+            case 'local':
+                return SessionManager.open(resolved.path, parsed.sessionDir);
+            case 'global': {
+                // Session found in different project - ask user if they want to fork
+                console.log(chalk.yellow(`Session found in different project: ${resolved.cwd}`));
+                const shouldFork = await promptConfirm('Fork this session into current directory?');
+                if (!shouldFork) {
+                    console.log(chalk.dim('Aborted.'));
+                    process.exit(0);
+                }
+                return SessionManager.forkFrom(resolved.path, cwd, parsed.sessionDir);
+            }
+            case 'not_found':
+                console.error(chalk.red(`No session found matching '${resolved.arg}'`));
+                process.exit(1);
+        }
+    }
+    if (parsed.continue) {
+        return SessionManager.continueRecent(cwd, parsed.sessionDir);
+    }
+    // --resume is handled separately (needs picker UI)
+    // If --session-dir provided without --continue/--resume, create new session there
+    if (parsed.sessionDir) {
+        return SessionManager.create(cwd, parsed.sessionDir);
+    }
+    // Default case (new session) returns undefined, SDK will create one
+    return undefined;
+}
+// Lazy reference — set during main(), used by tools via closures
+let sessionRef = null;
+// SHORTCUT PATCH: simplified buildSessionOptions — removed scopedModels parameter
+function buildSessionOptions(parsed, sessionManager, modelRegistry, _settingsManager) {
+    const options = {};
+    let cliThinkingFromModel = false;
+    if (sessionManager) {
+        options.sessionManager = sessionManager;
+    }
+    // Model from CLI
+    // - supports --provider <name> --model <pattern>
+    // - supports --model <provider>/<pattern>
+    if (parsed.model) {
+        const resolved = resolveCliModel({
+            cliProvider: parsed.provider,
+            cliModel: parsed.model,
+            modelRegistry
+        });
+        if (resolved.warning) {
+            console.warn(chalk.yellow(`Warning: ${resolved.warning}`));
+        }
+        if (resolved.error) {
+            console.error(chalk.red(resolved.error));
+            process.exit(1);
+        }
+        if (resolved.model) {
+            options.model = resolved.model;
+            // Allow "--model <pattern>:<thinking>" as a shorthand.
+            // Explicit --thinking still takes precedence (applied later).
+            if (!parsed.thinking && resolved.thinkingLevel) {
+                options.thinkingLevel = resolved.thinkingLevel;
+                cliThinkingFromModel = true;
+            }
+        }
+    }
+    // Thinking level from CLI
+    if (parsed.thinking) {
+        options.thinkingLevel = parsed.thinking;
+    }
+    // API key from CLI - set in authStorage
+    // (handled by caller before createAgentSession)
+    // Tools
+    if (parsed.noTools) {
+        // --no-tools: start with no built-in tools
+        // --tools can still add specific ones back
+        if (parsed.tools && parsed.tools.length > 0) {
+            options.tools = parsed.tools.map((name) => allTools[name]);
+        }
+        else {
+            options.tools = [];
+        }
+    }
+    else if (parsed.tools) {
+        options.tools = parsed.tools.map((name) => allTools[name]);
+    }
+    // Register custom tools.
+    // --no-custom-tools: register nothing (used by subagents that need no custom tools).
+    // --custom-tools <names>: register only the named tools (comma-separated).
+    // Unset: register all (default for interactive use).
+    const availableCustomTools = [];
+    if (!parsed.noCustomTools) {
+        const customToolSet = parsed.customTools ? new Set(parsed.customTools) : null;
+        if (!customToolSet || customToolSet.has(EXCEL_EXEC)) {
+            availableCustomTools.push(createExcelExecTool(EXCEL_HTTP_URL));
+        }
+        if (!customToolSet || customToolSet.has(TASK)) {
+            availableCustomTools.push(createTaskTool());
+        }
+        if (!customToolSet || customToolSet.has(TODO_LIST)) {
+            availableCustomTools.push(createTodoListTool());
+        }
+        if (!customToolSet || customToolSet.has(CRON)) {
+            availableCustomTools.push(createCronTool());
+        }
+        if (!customToolSet || customToolSet.has(SWITCH_MODE)) {
+            availableCustomTools.push(createSwitchModeTool(() => sessionRef));
+        }
+        if (!customToolSet || customToolSet.has(LLM_ANALYSIS)) {
+            availableCustomTools.push(createLlmAnalysisTool(SHORTCUT_LLM_PROXY_URL));
+        }
+    }
+    options.customTools = [...(options.customTools ?? []), ...availableCustomTools];
+    return { options, cliThinkingFromModel };
+}
+async function handleConfigCommand(args) {
+    if (args[0] !== 'config') {
+        return false;
+    }
+    const cwd = process.cwd();
+    const agentDir = getAgentDir();
+    const settingsManager = SettingsManager.create(cwd, agentDir);
+    reportSettingsErrors(settingsManager, 'config command');
+    const packageManager = new DefaultPackageManager({ cwd, agentDir, settingsManager });
+    const resolvedPaths = await packageManager.resolve();
+    await selectConfig({
+        resolvedPaths,
+        settingsManager,
+        cwd,
+        agentDir
+    });
+    process.exit(0);
+}
+/**
+ * Check for a newer version and install it in the background.
+ * The update takes effect on the next launch — no re-exec needed.
+ */
+function backgroundAutoUpdate() {
+    if (process.env.SHORTCUT_SKIP_VERSION_CHECK || process.env.SHORTCUT_OFFLINE)
+        return;
+    const command = getUpdateCommand(NPM_PACKAGE_NAME);
+    if (!command)
+        return; // bun-binary — can't auto-update
+    fetch(NPM_REGISTRY_URL, { signal: AbortSignal.timeout(10_000) })
+        .then((res) => (res.ok ? res.json() : undefined))
+        .then((data) => {
+        const latest = data?.version;
+        if (!latest || latest === VERSION)
+            return;
+        // Install in background — fire and forget
+        const child = spawn(command, {
+            shell: true,
+            stdio: 'ignore',
+            detached: true
+        });
+        child.unref();
+    })
+        .catch(() => {
+        // Silent — network errors, timeouts, etc.
+    });
+}
+export async function main(args) {
+    // Fast path for subagent child processes — skip all heavy startup
+    if (args.includes('--subagent')) {
+        return runSubagent(args.filter((a) => a !== '--subagent'));
+    }
+    // Fast path for cron daemon — minimal startup, no TUI, no tools
+    if (args[0] === 'cron-daemon') {
+        const { runCronDaemon } = await import('./custom/cron/cron-daemon-entry.js');
+        return runCronDaemon();
+    }
+    const offlineMode = args.includes('--offline') || isTruthyEnvFlag(process.env.SHORTCUT_OFFLINE);
+    if (offlineMode) {
+        process.env.SHORTCUT_OFFLINE = '1';
+        process.env.SHORTCUT_SKIP_VERSION_CHECK = '1';
+    }
+    // Auto-update in background — takes effect on next launch
+    backgroundAutoUpdate();
+    if (await handlePackageCommand(args)) {
+        return;
+    }
+    if (await handleConfigCommand(args)) {
+        return;
+    }
+    // Run migrations (pass cwd for project-local migrations)
+    const { migratedAuthProviders: migratedProviders, deprecationWarnings } = runMigrations(process.cwd());
+    // First pass: parse args to get --extension paths
+    const firstPass = parseArgs(args);
+    // Early load extensions to discover their CLI flags
+    const cwd = process.cwd();
+    const agentDir = getAgentDir();
+    const settingsManager = SettingsManager.create(cwd, agentDir);
+    reportSettingsErrors(settingsManager, 'startup');
+    const authStorage = AuthStorage.create();
+    const modelRegistry = new ModelRegistry(authStorage, getModelsPath());
+    // Pick the initial agent based on installation state
+    const needsSetup = !isInstalled();
+    const startupWarnings = [];
+    const startupInfos = [];
+    // Sync shipped XLL binaries to the stable user-local directory.
+    // This ensures ~/.shortcut/agent/xll/ always has the latest version,
+    // regardless of where npm installed the package.
+    const { updated: xllFilesUpdated, xllReady } = syncXll();
+    if (xllFilesUpdated > 0 && DEV_MODE) {
+        startupWarnings.push(`Updated ${xllFilesUpdated} XLL file(s) in ${getAgentDir()}/xll/`);
+    }
+    if (!xllReady && needsSetup) {
+        console.error(chalk.red('Error: ShortcutXL.xll could not be synced to the stable directory.'));
+        console.error(chalk.red(`Expected at: ${getAgentDir()}/xll/ShortcutXL.xll`));
+        console.error(chalk.yellow('Check that the npm package installed correctly and try again.'));
+        process.exit(1);
+    }
+    if (!xllReady && !needsSetup) {
+        startupWarnings.push('XLL sync failed, but a previous installation exists. Continuing with existing files.');
+    }
+    // Deterministic pre-flight: auto-install Git Bash, Python, registry key,
+    // launch Excel, and run smoke test. Regardless of outcome, the installation
+    // agent always runs afterward to verify everything is set up correctly.
+    let preflightComplete = false;
+    if (needsSetup) {
+        preflightComplete = await runPreflight();
+        startupInfos.push('Setting up ShortcutXL...');
+    }
+    let systemPrompt;
+    let initialAgent;
+    if (firstPass.systemPrompt) {
+        systemPrompt = firstPass.systemPrompt;
+    }
+    else if (needsSetup) {
+        initialAgent = installationAgent();
+        systemPrompt = initialAgent.systemPrompt;
+    }
+    else {
+        initialAgent = actionAgent();
+        systemPrompt = initialAgent.systemPrompt;
+    }
+    const resourceLoader = new DefaultResourceLoader({
+        cwd,
+        agentDir,
+        settingsManager,
+        additionalExtensionPaths: firstPass.extensions,
+        additionalSkillPaths: firstPass.skills,
+        additionalPromptTemplatePaths: firstPass.promptTemplates,
+        additionalThemePaths: firstPass.themes,
+        noExtensions: firstPass.noExtensions,
+        noSkills: firstPass.noSkills,
+        noPromptTemplates: firstPass.noPromptTemplates,
+        noThemes: firstPass.noThemes,
+        systemPrompt,
+        appendSystemPrompt: firstPass.appendSystemPrompt,
+        // AGENTS.md / CLAUDE.md context files are dev-only (not useful for end users)
+        agentsFilesOverride: DEV_MODE ? undefined : () => ({ agentsFiles: [] })
+    });
+    await resourceLoader.reload();
+    time('resourceLoader.reload');
+    const extensionsResult = resourceLoader.getExtensions();
+    for (const { path, error } of extensionsResult.errors) {
+        console.error(chalk.red(`Failed to load extension "${path}": ${error}`));
+    }
+    // Apply pending provider registrations from extensions immediately
+    // so they're available for model resolution before AgentSession is created
+    for (const { name, config } of extensionsResult.runtime.pendingProviderRegistrations) {
+        modelRegistry.registerProvider(name, config);
+    }
+    extensionsResult.runtime.pendingProviderRegistrations = [];
+    // Register Shortcut as a provider with custom stream through the Python backend
+    registerShortcutProvider(modelRegistry, SHORTCUT_LLM_PROXY_URL);
+    // Keep Shortcut OAuth tokens fresh while the TUI is idle.
+    // Without this, the access token (7-min TTL on staging) expires silently
+    // and the next LLM request fails with 401.
+    startProactiveRefresh(authStorage, SHORTCUT_PROVIDER_ID);
+    // TODO: Re-enable when we support multiple providers
+    // Register OpenAI Codex provider (ChatGPT Plus/Pro OAuth, gpt-5.4)
+    // registerOpenAICodexProvider(modelRegistry);
+    const extensionFlags = new Map();
+    for (const ext of extensionsResult.extensions) {
+        for (const [name, flag] of ext.flags) {
+            extensionFlags.set(name, { type: flag.type });
+        }
+    }
+    // Second pass: parse args with extension flags
+    const parsed = parseArgs(args, extensionFlags);
+    // Pass flag values to extensions via runtime
+    for (const [name, value] of parsed.unknownFlags) {
+        extensionsResult.runtime.flagValues.set(name, value);
+    }
+    if (parsed.version) {
+        console.log(VERSION);
+        process.exit(0);
+    }
+    if (parsed.help) {
+        printHelp();
+        process.exit(0);
+    }
+    if (parsed.listModels !== undefined) {
+        const searchPattern = typeof parsed.listModels === 'string' ? parsed.listModels : undefined;
+        await listModels(modelRegistry, searchPattern);
+        process.exit(0);
+    }
+    // Read piped stdin content (if any) - skip for RPC mode which uses stdin for JSON-RPC
+    if (parsed.mode !== 'rpc') {
+        const stdinContent = await readPipedStdin();
+        if (stdinContent !== undefined) {
+            // Force print mode since interactive mode requires a TTY for keyboard input
+            parsed.print = true;
+            // Prepend stdin content to messages
+            parsed.messages.unshift(stdinContent);
+        }
+    }
+    if (parsed.export) {
+        let result;
+        try {
+            const outputPath = parsed.messages.length > 0 ? parsed.messages[0] : undefined;
+            result = await exportFromFile(parsed.export, outputPath);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Failed to export session';
+            console.error(chalk.red(`Error: ${message}`));
+            process.exit(1);
+        }
+        console.log(`Exported to: ${result}`);
+        process.exit(0);
+    }
+    if (parsed.mode === 'rpc' && parsed.fileArgs.length > 0) {
+        console.error(chalk.red('Error: @file arguments are not supported in RPC mode'));
+        process.exit(1);
+    }
+    let { initialMessage, initialImages } = await prepareInitialMessage(parsed, settingsManager.getImageAutoResize());
+    // Auto-start the installation flow so the user doesn't have to type anything
+    if (needsSetup && !initialMessage) {
+        initialMessage = 'Start the installation process.';
+    }
+    const isInteractive = !parsed.print && parsed.mode === undefined;
+    const mode = parsed.mode || 'text';
+    initTheme(settingsManager.getTheme(), isInteractive);
+    // Show deprecation warnings in interactive mode
+    if (isInteractive && deprecationWarnings.length > 0) {
+        await showDeprecationWarnings(deprecationWarnings);
+    }
+    // SHORTCUT PATCH: removed scoped models resolution — all authed models available for cycling
+    // Create session manager based on CLI flags
+    let sessionManager = await createSessionManager(parsed, cwd);
+    // Handle --resume: show session picker
+    if (parsed.resume) {
+        // Initialize keybindings so session picker respects user config
+        KeybindingsManager.create();
+        const selectedPath = await selectSession((onProgress) => SessionManager.list(cwd, parsed.sessionDir, onProgress), SessionManager.listAll);
+        if (!selectedPath) {
+            console.log(chalk.dim('No session selected'));
+            stopThemeWatcher();
+            process.exit(0);
+        }
+        sessionManager = SessionManager.open(selectedPath);
+    }
+    const { options: sessionOptions, cliThinkingFromModel } = buildSessionOptions(parsed, sessionManager, modelRegistry, settingsManager);
+    sessionOptions.authStorage = authStorage;
+    sessionOptions.modelRegistry = modelRegistry;
+    sessionOptions.resourceLoader = resourceLoader;
+    sessionOptions.prePromptContext = async () => {
+        const summary = await fetchWorkbookSummary();
+        if (!summary)
+            return null;
+        return {
+            text: formatSummaryForLlm(summary),
+            details: { workbooks: parseWorkbookNames(summary) }
+        };
+    };
+    // Handle CLI --api-key as runtime override (not persisted)
+    if (parsed.apiKey) {
+        if (!sessionOptions.model) {
+            console.error(chalk.red('--api-key requires a model to be specified via --model or --provider/--model'));
+            process.exit(1);
+        }
+        authStorage.setRuntimeApiKey(sessionOptions.model.provider, parsed.apiKey);
+    }
+    const { session, modelFallbackMessage } = await createAgentSession(sessionOptions);
+    sessionRef = session;
+    // Apply initial agent's tool set and track current mode
+    if (initialAgent) {
+        session.setActiveToolsByName([...initialAgent.tools]);
+        setCurrentMode(initialAgent.name);
+    }
+    // Trace hooks (always active for /trace command; dev hooks add extra commands)
+    const traceHooks = getDevHooks(session);
+    const devHooks = DEV_MODE ? traceHooks : undefined;
+    // Upload session traces to Shortcut backend for centralized observability.
+    // Uses the user's own OAuth token — no shared API keys.
+    attachSessionUpload(session, {
+        getAccessToken: () => {
+            const cred = authStorage.get('shortcut');
+            return cred?.type === 'oauth' ? cred.access : undefined;
+        }
+    });
+    if (!isInteractive && !session.model) {
+        console.error(chalk.red('No models available.'));
+        console.error(chalk.yellow('\nSet an API key environment variable:'));
+        console.error('  ANTHROPIC_API_KEY, OPENAI_API_KEY, GEMINI_API_KEY, etc.');
+        console.error(chalk.yellow(`\nOr create ${getModelsPath()}`));
+        process.exit(1);
+    }
+    // Clamp thinking level to model capabilities for CLI-provided thinking levels.
+    // This covers both --thinking <level> and --model <pattern>:<thinking>.
+    const cliThinkingOverride = parsed.thinking !== undefined || cliThinkingFromModel;
+    if (session.model && cliThinkingOverride) {
+        let effectiveThinking = session.thinkingLevel;
+        if (!session.model.reasoning) {
+            effectiveThinking = 'off';
+        }
+        else if (effectiveThinking === 'xhigh' && !supportsXhigh(session.model)) {
+            effectiveThinking = 'high';
+        }
+        if (effectiveThinking !== session.thinkingLevel) {
+            session.setThinkingLevel(effectiveThinking);
+        }
+    }
+    // In non-interactive modes, print startup messages to stderr since there's no TUI
+    for (const info of startupInfos) {
+        console.warn(chalk.dim(info));
+    }
+    for (const warning of startupWarnings) {
+        console.warn(chalk.yellow(warning));
+    }
+    if (mode === 'rpc') {
+        await runRpcMode(session);
+    }
+    else if (isInteractive) {
+        printTimings();
+        const mode = new InteractiveMode(session, {
+            migratedProviders,
+            modelFallbackMessage,
+            startupWarnings,
+            startupInfos,
+            initialMessage,
+            initialImages,
+            initialMessages: parsed.messages,
+            verbose: parsed.verbose,
+            fetchCreditBalance: async (apiKey) => {
+                const model = session.model;
+                if (!model || model.provider !== SHORTCUT_PROVIDER_ID)
+                    return 'not_applicable';
+                return fetchCreditBalance(apiKey);
+            },
+            // TODO: Re-enable when we support multiple providers
+            oauthProviderOrder: [SHORTCUT_PROVIDER_ID],
+            extraSlashCommands: devHooks?.slashCommands,
+            onDevCommand: traceHooks.onDevCommand,
+            onAgentEnd: traceHooks.onAgentEnd,
+            onReady: ({ setStatus, setWidget }) => {
+                startCronStatusPolling(setStatus);
+                setTodoWidget(setWidget);
+            }
+        });
+        await mode.run();
+    }
+    else {
+        await runPrintMode(session, {
+            mode,
+            messages: parsed.messages,
+            initialMessage,
+            initialImages
+        });
+        stopThemeWatcher();
+        if (process.stdout.writableLength > 0) {
+            await new Promise((resolve) => process.stdout.once('drain', resolve));
+        }
+        process.exit(0);
+    }
+}
+//# sourceMappingURL=main.js.map