@andorra-labs/code 0.0.0-stage → 0.1.5

package/dist/vendor/engine/runtime/coding-agent/main.js

@@ -0,0 +1,808 @@
+/**
+ * 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 { createInterface } from "node:readline";
+import { andorraModelsAreEqual } from "../ai/index.js";
+import { andorraSetCapabilityOverrides } from "../tui/index.js";
+import chalk from "chalk";
+import { andorraNormalizeSessionName, andorraParseArgs, andorraPrintHelp } from "./cli/args.js";
+import { andorraCheckProviderAuth, andorraCreateAuthCheckModelRuntime, andorraGetProviderCredential, } from "./cli/auth-check.js";
+import { AndorraAuthCommandError, andorraGetAuthCommandName, andorraGetAuthCommandUsage, andorraIsAuthCommandHelp, andorraParseAuthCommand, andorraPrintAuthCommandHelp, andorraValidateAuthCommandArgs, } from "./cli/auth-command.js";
+import { andorraResolveCredentialForPrint } from "./cli/credential-print.js";
+import { andorraProcessFileArguments } from "./cli/file-processor.js";
+import { andorraBuildInitialMessage } from "./cli/initial-message.js";
+import { andorraListModels } from "./cli/list-models.js";
+import { andorraCreateProjectTrustContext } from "./cli/project-trust.js";
+import { andorraSelectSession } from "./cli/session-picker.js";
+import { andorraShouldRunFirstTimeSetup, andorraShowFirstTimeSetup, andorraShowStartupSelector } from "./cli/startup-ui.js";
+import { APP_NAME, ENV_SESSION_DIR, andorraExpandTildePath, andorraGetAgentDir, andorraGetPackageDir, VERSION } from "./config.js";
+import { andorraCreateAgentSessionRuntime } from "./core/agent-session-runtime.js";
+import { andorraCreateAgentSessionFromServices, andorraCreateAgentSessionServices, } from "./core/agent-session-services.js";
+import { andorraFormatNoModelsAvailableMessage } from "./core/auth-guidance.js";
+import { AndorraAuthStorage, AndorraReadOnlyAuthStorage } from "./core/auth-storage.js";
+import { andorraExportFromFile } from "./core/export-html/index.js";
+import { andorraApplyHttpProxySettings, andorraConfigureHttpDispatcher } from "./core/http-dispatcher.js";
+import { andorraResolveCliModel, andorraResolveModelScope } from "./core/model-resolver.js";
+import { AndorraModelRuntime } from "./core/model-runtime.js";
+import { andorraRestoreStdout, andorraTakeOverStdout } from "./core/output-guard.js";
+import { andorraResolveProjectTrusted } from "./core/project-trust.js";
+import { andorraFormatMissingSessionCwdPrompt, andorraGetMissingSessionCwdIssue, AndorraMissingSessionCwdError, } from "./core/session-cwd.js";
+import { andorraAssertValidSessionId, AndorraSessionManager } from "./core/session-manager.js";
+import { andorraCollectSettingsDiagnostics, andorraDeduplicateDiagnostics } from "./core/settings-diagnostics.js";
+import { AndorraSettingsManager } from "./core/settings-manager.js";
+import { andorraPrintTimings, andorraResetTimings, andorraTime } from "./core/timings.js";
+import { andorraHasTrustRequiringProjectResources, AndorraProjectTrustStore } from "./core/trust-manager.js";
+import { builtInExtensions } from "./extensions/index.js";
+import { andorraRunMigrations, andorraShowDeprecationWarnings } from "./migrations.js";
+import { AndorraInteractiveMode, andorraRunPrintMode, andorraRunRpcMode } from "./modes/index.js";
+import { andorraInitTheme, andorraSetThemeJsonValidator, andorraStopThemeWatcher } from "./modes/interactive/theme/theme.js";
+import { andorraValidateThemeJson } from "./modes/interactive/theme/theme-json.js";
+import { andorraCleanupManagedInstall, andorraHandleConfigCommand, andorraHandlePackageCommand } from "./package-manager-cli.js";
+import { andorraIsLocalPath, andorraNormalizePath, andorraResolvePath } from "./utils/paths.js";
+import { andorraCleanupWindowsSelfUpdateQuarantine } from "./utils/windows-self-update.js";
+const EXTENSION_LOAD_FAILURE_HINT = `Hint: Start without extensions using "${APP_NAME} -ne".`;
+/**
+ * Read all content from piped stdin.
+ * Returns undefined if stdin is a TTY (interactive terminal).
+ */
+async function andorraReadPipedStdin() {
+    // 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 andorraReportDiagnostics(diagnostics) {
+    for (const diagnostic of diagnostics) {
+        const color = diagnostic.type === "error" ? chalk.red : diagnostic.type === "warning" ? chalk.yellow : chalk.dim;
+        const prefix = diagnostic.type === "error" ? "Error: " : diagnostic.type === "warning" ? "Warning: " : "";
+        console.error(color(`${prefix}${diagnostic.message}`));
+    }
+}
+function andorraIsTruthyEnvFlag(value) {
+    if (!value)
+        return false;
+    return value === "1" || value.toLowerCase() === "true" || value.toLowerCase() === "yes";
+}
+function andorraResolveAppMode(parsed, stdinIsTTY, stdoutIsTTY) {
+    if (parsed.mode === "rpc") {
+        return "rpc";
+    }
+    if (parsed.mode === "json") {
+        return "json";
+    }
+    if (parsed.print || !stdinIsTTY || !stdoutIsTTY) {
+        return "print";
+    }
+    return "interactive";
+}
+function andorraToPrintOutputMode(appMode) {
+    return appMode === "json" ? "json" : "text";
+}
+function andorraIsPlainRuntimeMetadataCommand(parsed) {
+    return !parsed.print && parsed.mode === undefined && (parsed.help === true || parsed.listModels !== undefined);
+}
+async function andorraRunAuthCommand(args) {
+    if (andorraIsAuthCommandHelp(args)) {
+        andorraPrintAuthCommandHelp();
+        return true;
+    }
+    let command;
+    try {
+        command = andorraParseAuthCommand(args);
+    }
+    catch (error) {
+        const message = error instanceof AndorraAuthCommandError ? error.message : "Failed to parse auth command";
+        console.error(chalk.red(`Error: ${message}`));
+        process.exitCode = 1;
+        return true;
+    }
+    if (!command)
+        return false;
+    const parsed = andorraParseArgs(command.args);
+    if (parsed.unknownFlags.size > 0) {
+        const option = parsed.unknownFlags.keys().next().value;
+        console.error(chalk.red(`Unknown option --${option} for "${andorraGetAuthCommandName(command.kind)}".`));
+        console.error(chalk.dim(`Use "${APP_NAME} --help" or "${andorraGetAuthCommandUsage(command.kind)}".`));
+        process.exitCode = 1;
+        return true;
+    }
+    try {
+        if (parsed.diagnostics.length > 0) {
+            throw new AndorraAuthCommandError(parsed.diagnostics.map((diagnostic) => diagnostic.message).join("\n"));
+        }
+        if (command.kind !== "check") {
+            const signal = AbortSignal.timeout(15_000);
+            const modelRuntime = await AndorraModelRuntime.create({ allowModelNetwork: false, signal });
+            const credential = await andorraResolveCredentialForPrint(parsed, modelRuntime, command.kind, command.minExpiryMs, signal);
+            process.stdout.write(`${credential}\n`);
+            return true;
+        }
+        const requestedAuth = andorraValidateAuthCommandArgs(parsed, command.kind);
+        let result;
+        let credential;
+        try {
+            const credentials = command.noRefresh ? new AndorraReadOnlyAuthStorage() : AndorraAuthStorage.create();
+            const modelRuntime = await andorraCreateAuthCheckModelRuntime(credentials);
+            result = await andorraCheckProviderAuth(parsed, modelRuntime, { refresh: !command.noRefresh });
+            if (command.credentials && result.status === "ready") {
+                credential = await andorraGetProviderCredential(result.provider, modelRuntime, credentials, {
+                    refresh: !command.noRefresh,
+                });
+                if (!credential) {
+                    result = { status: "not_ready", provider: result.provider, reason: "credential_not_available" };
+                }
+            }
+        }
+        catch {
+            result = {
+                status: "invalid",
+                provider: requestedAuth.provider ?? requestedAuth.model,
+                reason: "invalid_state",
+            };
+        }
+        const output = command.json
+            ? JSON.stringify({ ...result, ...(credential ? { credentials: credential } : {}) })
+            : (credential ?? result.status);
+        process.stdout.write(`${output}\n`);
+        process.exitCode = result.status === "ready" ? 0 : result.status === "not_ready" ? 1 : 2;
+    }
+    catch (error) {
+        const message = error instanceof AndorraAuthCommandError ? error.message : "Failed to resolve credential";
+        console.error(chalk.red(`Error: ${message}`));
+        process.exitCode = command.kind === "check" ? 2 : 1;
+    }
+    return true;
+}
+async function andorraPrepareInitialMessage(parsed, stdinContent) {
+    if (parsed.fileArgs.length === 0) {
+        return andorraBuildInitialMessage({ parsed, stdinContent });
+    }
+    // AgentSession resizes these after extension hooks select the request model.
+    const { text, images } = await andorraProcessFileArguments(parsed.fileArgs, { autoResizeImages: false });
+    return andorraBuildInitialMessage({
+        parsed,
+        fileText: text,
+        fileImages: images,
+        stdinContent,
+    });
+}
+/**
+ * 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.
+ */
+function andorraFindLocalSessionByExactId(sessionId, cwd, sessionDir) {
+    const path = AndorraSessionManager.findById(cwd, sessionId, sessionDir);
+    return path ? { type: "local", path } : undefined;
+}
+async function andorraResolveSessionPath(sessionArg, cwd, sessionDir) {
+    // If it looks like a file path, resolve it before handing it to the session manager.
+    if (sessionArg.includes("/") || sessionArg.includes("\\") || sessionArg.endsWith(".jsonl")) {
+        return { type: "path", path: andorraResolvePath(sessionArg, cwd) };
+    }
+    // Exact IDs only require reading session headers. Fall back to the full
+    // metadata listing for prefix matches.
+    const exactLocalMatch = andorraFindLocalSessionByExactId(sessionArg, cwd, sessionDir);
+    if (exactLocalMatch) {
+        return exactLocalMatch;
+    }
+    const localSessions = await AndorraSessionManager.list(cwd, sessionDir);
+    const localMatch = localSessions.find((s) => s.id.startsWith(sessionArg));
+    if (localMatch) {
+        return { type: "local", path: localMatch.path };
+    }
+    // Try global search across all projects
+    const allSessions = await AndorraSessionManager.listAll(sessionDir);
+    const globalMatch = allSessions.find((s) => s.id === sessionArg) ?? allSessions.find((s) => s.id.startsWith(sessionArg));
+    if (globalMatch) {
+        return { type: "global", path: globalMatch.path, cwd: globalMatch.cwd };
+    }
+    // Not found anywhere
+    return { type: "not_found", arg: sessionArg };
+}
+/** Prompt user for yes/no confirmation */
+async function andorraPromptConfirm(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");
+        });
+    });
+}
+function andorraValidateForkFlags(parsed) {
+    if (!parsed.fork)
+        return;
+    const conflictingFlags = [
+        parsed.session ? "--session" : undefined,
+        parsed.continue ? "--continue" : undefined,
+        parsed.resume ? "--resume" : undefined,
+        parsed.noSession ? "--no-session" : undefined,
+    ].filter((flag) => flag !== undefined);
+    if (conflictingFlags.length > 0) {
+        console.error(chalk.red(`Error: --fork cannot be combined with ${conflictingFlags.join(", ")}`));
+        process.exit(1);
+    }
+}
+function andorraValidateSessionIdFlags(parsed) {
+    if (parsed.sessionId === undefined)
+        return;
+    const conflictingFlags = [
+        parsed.session ? "--session" : undefined,
+        parsed.continue ? "--continue" : undefined,
+        parsed.resume ? "--resume" : undefined,
+    ].filter((flag) => flag !== undefined);
+    if (conflictingFlags.length > 0) {
+        console.error(chalk.red(`Error: --session-id cannot be combined with ${conflictingFlags.join(", ")}`));
+        process.exit(1);
+    }
+    try {
+        andorraAssertValidSessionId(parsed.sessionId);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(chalk.red(`Error: ${message}`));
+        process.exit(1);
+    }
+}
+function andorraOpenSessionOrExit(path, sessionDir) {
+    try {
+        return AndorraSessionManager.open(path, sessionDir);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(chalk.red(`Error: ${message}`));
+        process.exit(1);
+    }
+}
+function andorraForkSessionOrExit(sourcePath, cwd, sessionDir, sessionId) {
+    try {
+        return AndorraSessionManager.forkFrom(sourcePath, cwd, sessionDir, { id: sessionId });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(chalk.red(`Error: ${message}`));
+        process.exit(1);
+    }
+}
+export async function andorraCreateSessionManager(parsed, cwd, sessionDir, settingsManager) {
+    if (parsed.noSession || parsed.help || parsed.listModels !== undefined) {
+        return AndorraSessionManager.inMemory(cwd, parsed.sessionId !== undefined ? { id: parsed.sessionId } : undefined);
+    }
+    if (parsed.fork) {
+        if (parsed.sessionId) {
+            const existingTarget = andorraFindLocalSessionByExactId(parsed.sessionId, cwd, sessionDir);
+            if (existingTarget) {
+                console.error(chalk.red(`Session already exists with id '${parsed.sessionId}'`));
+                process.exit(1);
+            }
+        }
+        const resolved = await andorraResolveSessionPath(parsed.fork, cwd, sessionDir);
+        switch (resolved.type) {
+            case "path":
+            case "local":
+            case "global":
+                return andorraForkSessionOrExit(resolved.path, cwd, sessionDir, parsed.sessionId);
+            case "not_found":
+                console.error(chalk.red(`No session found matching '${resolved.arg}'`));
+                process.exit(1);
+        }
+    }
+    if (parsed.session) {
+        const resolved = await andorraResolveSessionPath(parsed.session, cwd, sessionDir);
+        switch (resolved.type) {
+            case "path":
+            case "local":
+                return andorraOpenSessionOrExit(resolved.path, sessionDir);
+            case "global": {
+                console.log(chalk.yellow(`Session found in different project: ${resolved.cwd}`));
+                const shouldFork = await andorraPromptConfirm("Fork this session into current directory?");
+                if (!shouldFork) {
+                    console.log(chalk.dim("Aborted."));
+                    process.exit(0);
+                }
+                return andorraForkSessionOrExit(resolved.path, cwd, sessionDir);
+            }
+            case "not_found":
+                console.error(chalk.red(`No session found matching '${resolved.arg}'`));
+                process.exit(1);
+        }
+    }
+    if (parsed.resume) {
+        try {
+            const selectedPath = await andorraSelectSession((onProgress, signal) => AndorraSessionManager.list(cwd, sessionDir, onProgress, signal), (onProgress, signal) => AndorraSessionManager.listAll(sessionDir, onProgress, signal), settingsManager);
+            if (!selectedPath) {
+                console.log(chalk.dim("No session selected"));
+                process.exit(0);
+            }
+            return AndorraSessionManager.open(selectedPath, sessionDir);
+        }
+        finally {
+            andorraStopThemeWatcher();
+        }
+    }
+    if (parsed.continue) {
+        return AndorraSessionManager.continueRecent(cwd, sessionDir);
+    }
+    if (parsed.sessionId) {
+        const existingSession = andorraFindLocalSessionByExactId(parsed.sessionId, cwd, sessionDir);
+        if (existingSession) {
+            return AndorraSessionManager.open(existingSession.path, sessionDir);
+        }
+        console.error(chalk.yellow(`Warning: No project session found with id '${parsed.sessionId}'; creating a new session with that id.`));
+    }
+    return AndorraSessionManager.create(cwd, sessionDir, { id: parsed.sessionId });
+}
+function andorraBuildSessionOptions(parsed, scopedModels, hasExistingSession, modelRuntime, settingsManager) {
+    const options = {};
+    const diagnostics = [];
+    let cliThinkingFromModel = false;
+    // Model from CLI
+    // - supports --provider <name> --model <pattern>
+    // - supports --model <provider>/<pattern>
+    if (parsed.model) {
+        const resolved = andorraResolveCliModel({
+            cliProvider: parsed.provider,
+            cliModel: parsed.model,
+            cliThinking: parsed.thinking,
+            modelRuntime,
+        });
+        if (resolved.warning) {
+            diagnostics.push({ type: "warning", message: resolved.warning });
+        }
+        if (resolved.error) {
+            diagnostics.push({ type: "error", message: resolved.error });
+        }
+        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;
+            }
+        }
+    }
+    if (!options.model && scopedModels.length > 0 && !hasExistingSession) {
+        // Check if saved default is in scoped models - use it if so, otherwise first scoped model
+        const savedProvider = settingsManager.getDefaultProvider();
+        const savedModelId = settingsManager.getDefaultModel();
+        const savedModel = savedProvider && savedModelId ? modelRuntime.getModel(savedProvider, savedModelId) : undefined;
+        const savedInScope = savedModel ? scopedModels.find((sm) => andorraModelsAreEqual(sm.model, savedModel)) : undefined;
+        if (savedInScope) {
+            options.model = savedInScope.model;
+            // Use thinking level from scoped model config if explicitly set
+            if (!parsed.thinking && savedInScope.thinkingLevel) {
+                options.thinkingLevel = savedInScope.thinkingLevel;
+            }
+        }
+        else {
+            options.model = scopedModels[0].model;
+            // Use thinking level from first scoped model if explicitly set
+            if (!parsed.thinking && scopedModels[0].thinkingLevel) {
+                options.thinkingLevel = scopedModels[0].thinkingLevel;
+            }
+        }
+    }
+    // Thinking level from CLI (takes precedence over scoped model thinking levels set above)
+    if (parsed.thinking) {
+        options.thinkingLevel = parsed.thinking;
+    }
+    // Scoped models for Ctrl+P cycling
+    // Keep thinking level undefined when not explicitly set in the model pattern.
+    // Undefined means "inherit current session thinking level" during cycling.
+    if (scopedModels.length > 0) {
+        options.scopedModels = scopedModels.map((sm) => ({
+            model: sm.model,
+            thinkingLevel: sm.thinkingLevel,
+        }));
+    }
+    // API key from CLI - set as a non-persistent runtime override
+    // (handled by caller before createAgentSession)
+    // Tools
+    if (parsed.noTools) {
+        options.noTools = "all";
+    }
+    else if (parsed.noBuiltinTools) {
+        options.noTools = "builtin";
+    }
+    if (parsed.tools) {
+        options.tools = [...parsed.tools];
+    }
+    if (parsed.excludeTools) {
+        options.excludeTools = [...parsed.excludeTools];
+    }
+    return { options, cliThinkingFromModel, diagnostics };
+}
+function andorraResolveCliPaths(cwd, paths) {
+    return paths?.map((value) => (andorraIsLocalPath(value) ? andorraResolvePath(value, cwd) : value));
+}
+async function andorraPromptForMissingSessionCwd(issue, settingsManager) {
+    return andorraShowStartupSelector(settingsManager, andorraFormatMissingSessionCwdPrompt(issue), [
+        { label: "Continue", value: issue.fallbackCwd },
+        { label: "Cancel", value: undefined },
+    ]);
+}
+export async function andorraMain(args, options) {
+    andorraResetTimings();
+    const extensionFactories = [...builtInExtensions, ...(options?.extensionFactories ?? [])];
+    const offlineMode = args.includes("--offline") || andorraIsTruthyEnvFlag(process.env.ANDORRA_ENGINE_OFFLINE);
+    if (offlineMode) {
+        process.env.ANDORRA_ENGINE_OFFLINE = "1";
+        process.env.ANDORRA_ENGINE_SKIP_VERSION_CHECK = "1";
+    }
+    if (await andorraRunAuthCommand(args)) {
+        return;
+    }
+    if (process.platform === "win32") {
+        andorraCleanupWindowsSelfUpdateQuarantine(andorraGetPackageDir());
+    }
+    andorraCleanupManagedInstall();
+    const cwd = process.cwd();
+    const agentDir = andorraGetAgentDir();
+    const bootstrapSettingsManager = AndorraSettingsManager.create(cwd, agentDir, { projectTrusted: false });
+    andorraApplyHttpProxySettings(bootstrapSettingsManager.getGlobalSettings().httpProxy);
+    andorraConfigureHttpDispatcher();
+    if (await andorraHandlePackageCommand(args, { extensionFactories })) {
+        const exitCode = process.exitCode ?? 0;
+        if (process.platform === "win32" && exitCode === 0 && args[0] === "update") {
+            // We normally prefer process.exit(0) for package commands so bad extensions cannot keep
+            // one-shot commands alive. On Windows, Node can assert after fetch() if process.exit(0)
+            // runs during teardown; let successful `pi update` drain naturally instead.
+            // https://github.com/nodejs/node/issues/56645
+            return;
+        }
+        process.exit(exitCode);
+        return;
+    }
+    if (await andorraHandleConfigCommand(args, { extensionFactories })) {
+        return;
+    }
+    const parsed = andorraParseArgs(args);
+    if (parsed.diagnostics.length > 0) {
+        for (const d of parsed.diagnostics) {
+            const color = d.type === "error" ? chalk.red : chalk.yellow;
+            console.error(color(`${d.type === "error" ? "Error" : "Warning"}: ${d.message}`));
+        }
+        if (parsed.diagnostics.some((d) => d.type === "error")) {
+            process.exit(1);
+        }
+    }
+    andorraTime("parseArgs");
+    if (parsed.version) {
+        console.log(VERSION);
+        process.exit(0);
+    }
+    if (parsed.export) {
+        let result;
+        try {
+            const outputPath = parsed.messages.length > 0 ? parsed.messages[0] : undefined;
+            result = await andorraExportFromFile(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);
+    }
+    let appMode = andorraResolveAppMode(parsed, process.stdin.isTTY, process.stdout.isTTY);
+    const shouldTakeOverStdout = appMode !== "interactive" && !andorraIsPlainRuntimeMetadataCommand(parsed);
+    if (shouldTakeOverStdout) {
+        andorraTakeOverStdout();
+    }
+    if (parsed.mode === "rpc" && parsed.fileArgs.length > 0) {
+        console.error(chalk.red("Error: @file arguments are not supported in RPC mode"));
+        process.exit(1);
+    }
+    andorraValidateForkFlags(parsed);
+    andorraValidateSessionIdFlags(parsed);
+    // Run migrations (pass cwd for project-local migrations)
+    const { migratedAuthProviders: migratedProviders, deprecationWarnings } = andorraRunMigrations(cwd);
+    andorraTime("runMigrations");
+    const startupSettingsManager = AndorraSettingsManager.create(cwd, agentDir);
+    const startupSettingsDiagnostics = andorraCollectSettingsDiagnostics(startupSettingsManager);
+    // Experimental first-time setup: theme choice and analytics opt-in.
+    // Runs before any runtime services are created so the chosen settings apply everywhere.
+    if (appMode === "interactive" && !parsed.help && parsed.listModels === undefined && andorraShouldRunFirstTimeSetup()) {
+        await andorraShowFirstTimeSetup(startupSettingsManager);
+        andorraTime("firstTimeSetup");
+    }
+    if (appMode === "interactive" && parsed.useTheme !== undefined) {
+        startupSettingsManager.applyOverrides({ theme: parsed.useTheme });
+    }
+    // Decide the final runtime cwd before creating cwd-bound runtime services.
+    // --session and --resume may select a session from another project, so project-local
+    // settings, resources, provider registrations, and models must be resolved only after
+    // the target session cwd is known. The startup-cwd settings manager is used only for
+    // sessionDir lookup during session selection.
+    const envSessionDir = process.env[ENV_SESSION_DIR];
+    const sessionDir = (parsed.sessionDir ? andorraNormalizePath(parsed.sessionDir) : undefined) ??
+        (envSessionDir ? andorraExpandTildePath(envSessionDir) : undefined) ??
+        startupSettingsManager.getSessionDir();
+    let sessionManager = await andorraCreateSessionManager(parsed, cwd, sessionDir, startupSettingsManager);
+    const missingSessionCwdIssue = andorraGetMissingSessionCwdIssue(sessionManager, cwd);
+    if (missingSessionCwdIssue) {
+        if (appMode === "interactive") {
+            const selectedCwd = await andorraPromptForMissingSessionCwd(missingSessionCwdIssue, startupSettingsManager);
+            if (!selectedCwd) {
+                process.exit(0);
+            }
+            sessionManager = AndorraSessionManager.open(missingSessionCwdIssue.sessionFile, sessionDir, selectedCwd);
+        }
+        else {
+            console.error(chalk.red(new AndorraMissingSessionCwdError(missingSessionCwdIssue).message));
+            process.exit(1);
+        }
+    }
+    if (parsed.name !== undefined) {
+        const name = andorraNormalizeSessionName(parsed.name);
+        if (name === undefined) {
+            console.error(chalk.red("Error: --name requires a non-empty value"));
+            process.exit(1);
+        }
+        sessionManager.appendSessionInfo(name);
+    }
+    andorraTime("createSessionManager");
+    const trustStore = new AndorraProjectTrustStore(agentDir);
+    const sessionCwd = sessionManager.getCwd();
+    const autoTrustOnReloadCwd = parsed.projectTrustOverride === undefined && !andorraHasTrustRequiringProjectResources(sessionCwd)
+        ? sessionCwd
+        : undefined;
+    const trustPromptMode = parsed.help || parsed.listModels !== undefined ? "print" : appMode;
+    const projectTrustByCwd = new Map();
+    const resolvedExtensionPaths = andorraResolveCliPaths(cwd, parsed.extensions);
+    const resolvedSkillPaths = andorraResolveCliPaths(cwd, parsed.skills);
+    const resolvedPromptTemplatePaths = andorraResolveCliPaths(cwd, parsed.promptTemplates);
+    const resolvedThemePaths = andorraResolveCliPaths(cwd, parsed.themes);
+    const andorraCreateRuntime = async ({ cwd, agentDir, sessionManager, sessionStartEvent, projectTrustContext, }) => {
+        const isInitialRuntime = sessionStartEvent === undefined;
+        const projectTrustDiagnostics = [];
+        const cachedProjectTrust = projectTrustByCwd.get(cwd);
+        const hasTrustRequiringResources = andorraHasTrustRequiringProjectResources(cwd);
+        const shouldResolveProjectTrust = parsed.projectTrustOverride === undefined && cachedProjectTrust === undefined && hasTrustRequiringResources;
+        const projectTrusted = shouldResolveProjectTrust
+            ? false
+            : (cachedProjectTrust ??
+                parsed.projectTrustOverride ??
+                (!hasTrustRequiringResources || trustStore.get(cwd) === true));
+        const runtimeSettingsManager = AndorraSettingsManager.create(cwd, agentDir, { projectTrusted });
+        const services = await andorraCreateAgentSessionServices({
+            cwd,
+            agentDir,
+            settingsManager: runtimeSettingsManager,
+            modelRuntimeSignal: AbortSignal.timeout(15_000),
+            extensionFlagValues: parsed.unknownFlags,
+            resourceLoaderReloadOptions: shouldResolveProjectTrust
+                ? {
+                    resolveProjectTrust: async ({ extensionsResult }) => {
+                        const trusted = await andorraResolveProjectTrusted({
+                            cwd,
+                            trustStore,
+                            trustOverride: parsed.projectTrustOverride,
+                            defaultProjectTrust: startupSettingsManager.getDefaultProjectTrust(),
+                            extensionsResult,
+                            projectTrustContext: projectTrustContext ??
+                                andorraCreateProjectTrustContext({
+                                    cwd,
+                                    mode: isInitialRuntime ? trustPromptMode : appMode,
+                                    settingsManager: startupSettingsManager,
+                                    hasUI: isInitialRuntime && trustPromptMode === "interactive",
+                                }),
+                            onExtensionError: (message) => projectTrustDiagnostics.push({ type: "warning", message }),
+                        });
+                        projectTrustByCwd.set(cwd, trusted);
+                        return trusted;
+                    },
+                }
+                : undefined,
+            resourceLoaderOptions: {
+                additionalExtensionPaths: resolvedExtensionPaths,
+                additionalSkillPaths: resolvedSkillPaths,
+                additionalPromptTemplatePaths: resolvedPromptTemplatePaths,
+                additionalThemePaths: resolvedThemePaths,
+                noExtensions: parsed.noExtensions,
+                noSkills: parsed.noSkills,
+                noPromptTemplates: parsed.noPromptTemplates,
+                noThemes: parsed.noThemes,
+                noContextFiles: parsed.noContextFiles,
+                systemPrompt: parsed.systemPrompt,
+                appendSystemPrompt: parsed.appendSystemPrompt,
+                extensionFactories,
+            },
+        });
+        const { settingsManager, modelRuntime, resourceLoader } = services;
+        const diagnostics = [
+            ...projectTrustDiagnostics,
+            ...services.diagnostics,
+            ...andorraCollectSettingsDiagnostics(settingsManager),
+            ...resourceLoader.getExtensions().errors.map(({ path, error }) => ({
+                type: "error",
+                message: `Failed to load extension "${path}": ${error}`,
+            })),
+        ];
+        const modelPatterns = parsed.models ?? settingsManager.getEnabledModels();
+        const scopedModels = modelPatterns && modelPatterns.length > 0
+            ? await andorraResolveModelScope(modelPatterns, modelRuntime, { signal: AbortSignal.timeout(15_000) })
+            : [];
+        const { options: sessionOptions, cliThinkingFromModel, diagnostics: sessionOptionDiagnostics, } = andorraBuildSessionOptions(parsed, scopedModels, sessionManager.buildSessionContext().messages.length > 0, modelRuntime, settingsManager);
+        diagnostics.push(...sessionOptionDiagnostics);
+        if (parsed.apiKey) {
+            if (!sessionOptions.model) {
+                diagnostics.push({
+                    type: "error",
+                    message: "--api-key requires a model to be specified via --model, --provider/--model, or --models",
+                });
+            }
+            else {
+                await modelRuntime.setRuntimeApiKey(sessionOptions.model.provider, parsed.apiKey);
+            }
+        }
+        const created = await andorraCreateAgentSessionFromServices({
+            services,
+            sessionManager,
+            sessionStartEvent,
+            model: sessionOptions.model,
+            thinkingLevel: sessionOptions.thinkingLevel,
+            scopedModels: sessionOptions.scopedModels,
+            tools: sessionOptions.tools,
+            excludeTools: sessionOptions.excludeTools,
+            noTools: sessionOptions.noTools,
+            customTools: sessionOptions.customTools,
+        });
+        const cliThinkingOverride = parsed.thinking !== undefined || cliThinkingFromModel;
+        if (created.session.model && cliThinkingOverride) {
+            created.session.setThinkingLevel(created.session.thinkingLevel);
+        }
+        return {
+            ...created,
+            services,
+            diagnostics,
+        };
+    };
+    andorraTime("createRuntime");
+    const runtime = await andorraCreateAgentSessionRuntime(andorraCreateRuntime, {
+        cwd: sessionManager.getCwd(),
+        agentDir,
+        sessionManager,
+    });
+    andorraTime("createAgentSessionRuntime");
+    const { services, session, modelFallbackMessage } = runtime;
+    const { settingsManager, modelRuntime, resourceLoader } = services;
+    andorraSetCapabilityOverrides(settingsManager.getTerminalCapabilityOverrides());
+    andorraApplyHttpProxySettings(settingsManager.getGlobalSettings().httpProxy);
+    andorraConfigureHttpDispatcher(settingsManager.getHttpIdleTimeoutMs());
+    if (parsed.help) {
+        andorraReportDiagnostics(startupSettingsDiagnostics);
+        const extensionFlags = resourceLoader
+            .getExtensions()
+            .extensions.flatMap((extension) => Array.from(extension.flags.values()));
+        andorraPrintHelp(extensionFlags);
+        process.exit(0);
+    }
+    if (parsed.listModels !== undefined) {
+        andorraReportDiagnostics(startupSettingsDiagnostics);
+        const searchPattern = typeof parsed.listModels === "string" ? parsed.listModels : undefined;
+        await andorraListModels(modelRuntime, searchPattern, AbortSignal.timeout(15_000));
+        process.exit(0);
+    }
+    // Read piped stdin content (if any) - skip for RPC mode which uses stdin for JSON-RPC
+    let stdinContent;
+    if (appMode !== "rpc") {
+        stdinContent = await andorraReadPipedStdin();
+        if (stdinContent !== undefined && appMode === "interactive") {
+            appMode = "print";
+        }
+    }
+    andorraTime("readPipedStdin");
+    const { initialMessage, initialImages } = await andorraPrepareInitialMessage(parsed, stdinContent);
+    andorraTime("prepareInitialMessage");
+    // pi reads user-authored themes, so it opts into full validation before any theme loads.
+    andorraSetThemeJsonValidator(andorraValidateThemeJson);
+    andorraInitTheme(settingsManager.getTheme(), appMode === "interactive");
+    andorraTime("initTheme");
+    // Show deprecation warnings in interactive mode
+    if (appMode === "interactive" && deprecationWarnings.length > 0) {
+        await andorraShowDeprecationWarnings(deprecationWarnings);
+    }
+    andorraTime("resolveModelScope");
+    const startupDiagnostics = andorraDeduplicateDiagnostics([...startupSettingsDiagnostics, ...runtime.diagnostics]);
+    const hasRuntimeErrors = runtime.diagnostics.some((diagnostic) => diagnostic.type === "error");
+    if (appMode !== "interactive" || hasRuntimeErrors) {
+        andorraReportDiagnostics(startupDiagnostics);
+    }
+    if (hasRuntimeErrors) {
+        if (runtime.diagnostics.some((diagnostic) => diagnostic.message.includes("Failed to load extension"))) {
+            console.error(chalk.yellow(EXTENSION_LOAD_FAILURE_HINT));
+        }
+        process.exit(1);
+    }
+    andorraTime("createAgentSession");
+    if (appMode !== "interactive" && !session.model) {
+        console.error(chalk.red(andorraFormatNoModelsAvailableMessage()));
+        process.exit(1);
+    }
+    const startupBenchmark = andorraIsTruthyEnvFlag(process.env.ANDORRA_ENGINE_STARTUP_BENCHMARK);
+    if (startupBenchmark && appMode !== "interactive") {
+        console.error(chalk.red("Error: ANDORRA_ENGINE_STARTUP_BENCHMARK only supports interactive mode"));
+        process.exit(1);
+    }
+    // RPC refreshes catalogs here in the background; interactive mode starts its refresh after TUI initialization.
+    if (!offlineMode && appMode === "rpc") {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 15_000);
+        void modelRuntime
+            .refresh({ signal: controller.signal })
+            .catch(() => { })
+            .finally(() => clearTimeout(timeout));
+    }
+    if (appMode === "rpc") {
+        andorraPrintTimings();
+        await andorraRunRpcMode(runtime);
+    }
+    else if (appMode === "interactive") {
+        const interactiveMode = new AndorraInteractiveMode(runtime, {
+            migratedProviders,
+            startupDiagnostics,
+            modelFallbackMessage,
+            autoTrustOnReloadCwd,
+            initialMessage,
+            initialImages,
+            initialMessages: parsed.messages,
+            verbose: parsed.verbose,
+            tuiMode: parsed.tuiMode,
+            initialThemeSetting: parsed.useTheme,
+        });
+        if (startupBenchmark) {
+            await interactiveMode.init();
+            andorraTime("interactiveMode.init");
+            // Give the TUI's stdin handler a brief chance to consume terminal query replies
+            // (Kitty keyboard protocol, device attributes, cell size) before restoring the terminal.
+            await new Promise((resolve) => setTimeout(resolve, 150));
+            interactiveMode.stop();
+            andorraStopThemeWatcher();
+            andorraPrintTimings();
+            if (process.stdout.writableLength > 0) {
+                await new Promise((resolve) => process.stdout.once("drain", resolve));
+            }
+            if (process.stderr.writableLength > 0) {
+                await new Promise((resolve) => process.stderr.once("drain", resolve));
+            }
+            return;
+        }
+        andorraPrintTimings();
+        await interactiveMode.run();
+    }
+    else {
+        andorraPrintTimings();
+        const exitCode = await andorraRunPrintMode(runtime, {
+            mode: andorraToPrintOutputMode(appMode),
+            messages: parsed.messages,
+            initialMessage,
+            initialImages,
+        });
+        andorraStopThemeWatcher();
+        andorraRestoreStdout();
+        if (exitCode !== 0) {
+            process.exitCode = exitCode;
+        }
+        return;
+    }
+}