@andorra-labs/code 0.0.0-stage → 0.1.4

package/dist/vendor/engine/runtime/coding-agent/cli/config-selector.js

@@ -0,0 +1,31 @@
+/**
+ * TUI config selector for `pi config` command
+ */
+import { AndorraProcessTerminal, AndorraTuiMainScreen } from "../../tui/index.js";
+import { AndorraConfigSelectorComponent } from "../modes/interactive/components/config-selector.js";
+import { andorraInitTheme, andorraStopThemeWatcher } from "../modes/interactive/theme/theme.js";
+/** Show TUI config selector and return when closed */
+export async function andorraSelectConfig(options) {
+    // Initialize theme before showing TUI
+    andorraInitTheme(options.settingsManager.getTheme(), true);
+    return new Promise((resolve) => {
+        const ui = new AndorraTuiMainScreen(new AndorraProcessTerminal(), options.settingsManager.getShowHardwareCursor(), options.agentDir);
+        ui.setClearOnShrink(options.settingsManager.getClearOnShrink());
+        let resolved = false;
+        const selector = new AndorraConfigSelectorComponent(options.resolvedPaths, options.settingsManager, options.cwd, options.agentDir, () => {
+            if (!resolved) {
+                resolved = true;
+                ui.stop();
+                andorraStopThemeWatcher();
+                resolve();
+            }
+        }, () => {
+            ui.stop();
+            andorraStopThemeWatcher();
+            process.exit(0);
+        }, () => ui.requestRender(), ui.terminal.rows, options.writeScope, options.projectModeAvailable);
+        ui.addChild(selector);
+        ui.setFocus(selector.getResourceList());
+        ui.start();
+    });
+}

package/dist/vendor/engine/runtime/coding-agent/cli/credential-print.d.ts

@@ -0,0 +1,12 @@
+import type { AndorraModelRuntime } from "../core/model-runtime.js";
+import type { Args } from "./args.js";
+import { type AuthCommandKind } from "./auth-command.js";
+type CredentialPrintKind = Exclude<AuthCommandKind, "check">;
+/**
+ * Resolve one configured provider credential.
+ *
+ * This intentionally calls ModelRuntime.getAuth(), which refreshes and persists
+ * OAuth credentials with less than five minutes remaining through the normal request-auth path.
+ */
+export declare function andorraResolveCredentialForPrint(args: Args, modelRuntime: AndorraModelRuntime, kind: CredentialPrintKind, minExpiryMs?: number, signal?: AbortSignal): Promise<string>;
+export {};

package/dist/vendor/engine/runtime/coding-agent/cli/credential-print.js

@@ -0,0 +1,75 @@
+import { andorraResolveCliModel } from "../core/model-resolver.js";
+import { AndorraAuthCommandError, andorraGetAuthCredential, andorraValidateAuthCommandArgs } from "./auth-command.js";
+const DEFAULT_BEARER_TOKEN_MIN_EXPIRY_MS = 30 * 60_000;
+/**
+ * Resolve one configured provider credential.
+ *
+ * This intentionally calls ModelRuntime.getAuth(), which refreshes and persists
+ * OAuth credentials with less than five minutes remaining through the normal request-auth path.
+ */
+export async function andorraResolveCredentialForPrint(args, modelRuntime, kind, minExpiryMs, signal) {
+    const { provider: cliProvider, model: cliModel } = andorraValidateAuthCommandArgs(args, kind);
+    const credentialTypes = new Map((await modelRuntime.listCredentials({ signal })).map((credential) => [credential.providerId, credential.type]));
+    const providers = [];
+    if (cliProvider) {
+        const provider = modelRuntime.getProvider(cliProvider);
+        if (!provider) {
+            throw new AndorraAuthCommandError(`Unknown provider "${cliProvider}". Use --list-models to see available providers.`);
+        }
+        if (cliModel) {
+            const resolved = andorraResolveCliModel({ cliProvider: provider.id, cliModel, modelRuntime });
+            if (resolved.error || !resolved.model) {
+                throw new AndorraAuthCommandError(resolved.error ?? "Unable to resolve the requested provider/model");
+            }
+            providers.push({ id: provider.id, model: resolved.model });
+        }
+        else {
+            providers.push({ id: provider.id });
+        }
+    }
+    else {
+        for (const provider of modelRuntime.getProviders()) {
+            if (!credentialTypes.has(provider.id))
+                continue;
+            const resolved = andorraResolveCliModel({ cliProvider: provider.id, cliModel: cliModel, modelRuntime });
+            if (resolved.model && !resolved.error && !resolved.warning?.includes("Using custom model id")) {
+                providers.push({ id: provider.id, model: resolved.model });
+            }
+        }
+        if (providers.length === 0) {
+            throw new AndorraAuthCommandError(`Model "${cliModel}" not found. Use --list-models to see available models.`);
+        }
+    }
+    const credentials = [];
+    for (const provider of providers) {
+        const type = credentialTypes.get(provider.id);
+        if (kind === "api_key" && type === "oauth")
+            continue;
+        if (kind === "bearer_token" && type !== "oauth")
+            continue;
+        const authOptions = {
+            ...(kind === "bearer_token" ? { minOAuthValidityMs: minExpiryMs ?? DEFAULT_BEARER_TOKEN_MIN_EXPIRY_MS } : {}),
+            signal,
+        };
+        const auth = provider.model
+            ? await modelRuntime.getAuth(provider.model, authOptions)
+            : await modelRuntime.getAuth(provider.id, authOptions);
+        const value = andorraGetAuthCredential(auth);
+        if (value)
+            credentials.push({ providerId: provider.id, value });
+    }
+    if (credentials.length === 1)
+        return credentials[0].value;
+    if (credentials.length === 0) {
+        const providerId = providers[0]?.id;
+        const type = providerId ? credentialTypes.get(providerId) : undefined;
+        if (cliProvider && kind === "api_key" && type === "oauth") {
+            throw new AndorraAuthCommandError(`Provider "${providerId}" is configured with OAuth, not an API key`);
+        }
+        if (cliProvider && kind === "bearer_token" && type !== "oauth") {
+            throw new AndorraAuthCommandError(`Provider "${providerId}" is not configured with an OAuth bearer token`);
+        }
+        throw new AndorraAuthCommandError(`No usable ${kind === "api_key" ? "API key" : "OAuth bearer token"} is configured`);
+    }
+    throw new AndorraAuthCommandError(`Multiple configured providers matched (${credentials.map(({ providerId }) => providerId).join(", ")}). Specify --provider.`);
+}

package/dist/vendor/engine/runtime/coding-agent/cli/file-processor.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Process @file CLI arguments into text content and image attachments
+ */
+import type { ImageContent } from "../../ai/index.js";
+export interface ProcessedFiles {
+    text: string;
+    images: ImageContent[];
+}
+export interface ProcessFileOptions {
+    /** Whether to auto-resize images. Default: true */
+    autoResizeImages?: boolean;
+}
+/** Process @file arguments into text content and image attachments */
+export declare function andorraProcessFileArguments(fileArgs: string[], options?: ProcessFileOptions): Promise<ProcessedFiles>;

package/dist/vendor/engine/runtime/coding-agent/cli/file-processor.js

@@ -0,0 +1,70 @@
+/**
+ * Process @file CLI arguments into text content and image attachments
+ */
+import { access, readFile, stat } from "node:fs/promises";
+import chalk from "chalk";
+import { resolve } from "path";
+import { andorraResolveReadPath } from "../core/tools/path-utils.js";
+import { andorraProcessImage } from "../utils/image-process.js";
+import { andorraDetectSupportedImageMimeTypeFromFile } from "../utils/mime.js";
+import { andorraStripBom } from "../utils/text.js";
+/** Process @file arguments into text content and image attachments */
+export async function andorraProcessFileArguments(fileArgs, options) {
+    const autoResizeImages = options?.autoResizeImages ?? true;
+    let text = "";
+    const images = [];
+    for (const fileArg of fileArgs) {
+        // Expand and resolve path (handles ~ expansion and macOS screenshot Unicode spaces)
+        const absolutePath = resolve(andorraResolveReadPath(fileArg, process.cwd()));
+        // Check if file exists
+        try {
+            await access(absolutePath);
+        }
+        catch {
+            console.error(chalk.red(`Error: File not found: ${absolutePath}`));
+            process.exit(1);
+        }
+        // Check if file is empty
+        const stats = await stat(absolutePath);
+        if (stats.size === 0) {
+            // Skip empty files
+            continue;
+        }
+        const mimeType = await andorraDetectSupportedImageMimeTypeFromFile(absolutePath);
+        if (mimeType) {
+            // Handle image file
+            const content = await readFile(absolutePath);
+            const processed = await andorraProcessImage(content, mimeType, { autoResizeImages });
+            if (!processed.ok) {
+                text += `<file name="${absolutePath}">${processed.message}</file>\n`;
+                continue;
+            }
+            const attachment = {
+                type: "image",
+                mimeType: processed.mimeType,
+                data: processed.data,
+            };
+            images.push(attachment);
+            // Add text reference to image with optional processing hints
+            if (processed.hints.length > 0) {
+                text += `<file name="${absolutePath}">${processed.hints.join("\n")}</file>\n`;
+            }
+            else {
+                text += `<file name="${absolutePath}"></file>\n`;
+            }
+        }
+        else {
+            // Handle text file
+            try {
+                const content = andorraStripBom(await readFile(absolutePath, "utf-8"));
+                text += `<file name="${absolutePath}">\n${content}\n</file>\n`;
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                console.error(chalk.red(`Error: Could not read file ${absolutePath}: ${message}`));
+                process.exit(1);
+            }
+        }
+    }
+    return { text, images };
+}

package/dist/vendor/engine/runtime/coding-agent/cli/initial-message.d.ts

@@ -0,0 +1,17 @@
+import type { ImageContent } from "../../ai/index.js";
+import type { Args } from "./args.js";
+export interface InitialMessageInput {
+    parsed: Args;
+    fileText?: string;
+    fileImages?: ImageContent[];
+    stdinContent?: string;
+}
+export interface InitialMessageResult {
+    initialMessage?: string;
+    initialImages?: ImageContent[];
+}
+/**
+ * Combine stdin content, @file text, and the first CLI message into a single
+ * initial prompt for non-interactive mode.
+ */
+export declare function andorraBuildInitialMessage({ parsed, fileText, fileImages, stdinContent, }: InitialMessageInput): InitialMessageResult;

package/dist/vendor/engine/runtime/coding-agent/cli/initial-message.js

@@ -0,0 +1,21 @@
+/**
+ * Combine stdin content, @file text, and the first CLI message into a single
+ * initial prompt for non-interactive mode.
+ */
+export function andorraBuildInitialMessage({ parsed, fileText, fileImages, stdinContent, }) {
+    const parts = [];
+    if (stdinContent !== undefined) {
+        parts.push(stdinContent);
+    }
+    if (fileText) {
+        parts.push(fileText);
+    }
+    if (parsed.messages.length > 0) {
+        parts.push(parsed.messages[0]);
+        parsed.messages.shift();
+    }
+    return {
+        initialMessage: parts.length > 0 ? parts.join("") : undefined,
+        initialImages: fileImages && fileImages.length > 0 ? fileImages : undefined,
+    };
+}

package/dist/vendor/engine/runtime/coding-agent/cli/list-models.d.ts

@@ -0,0 +1,8 @@
+/**
+ * List available models with optional fuzzy search
+ */
+import type { AndorraModelRuntime } from "../core/model-runtime.js";
+/**
+ * List available models, optionally filtered by search pattern
+ */
+export declare function andorraListModels(modelRuntime: AndorraModelRuntime, searchPattern?: string, signal?: AbortSignal): Promise<void>;

package/dist/vendor/engine/runtime/coding-agent/cli/list-models.js

@@ -0,0 +1,97 @@
+/**
+ * List available models with optional fuzzy search
+ */
+import { andorraFuzzyFilter } from "../../tui/index.js";
+import chalk from "chalk";
+import { andorraFormatNoModelsAvailableMessage } from "../core/auth-guidance.js";
+/**
+ * Format a number as human-readable (e.g., 200000 -> "200K", 1000000 -> "1M")
+ */
+function andorraFormatTokenCount(count) {
+    if (count >= 1_000_000) {
+        const millions = count / 1_000_000;
+        return millions % 1 === 0 ? `${millions}M` : `${millions.toFixed(1)}M`;
+    }
+    if (count >= 1_000) {
+        const thousands = count / 1_000;
+        return thousands % 1 === 0 ? `${thousands}K` : `${thousands.toFixed(1)}K`;
+    }
+    return count.toString();
+}
+/**
+ * List available models, optionally filtered by search pattern
+ */
+export async function andorraListModels(modelRuntime, searchPattern, signal) {
+    const loadError = modelRuntime.getError();
+    if (loadError) {
+        console.error(chalk.yellow(`Warning: errors loading models.json:\n${loadError}`));
+    }
+    const models = [...(await modelRuntime.getAvailable(undefined, { signal }))];
+    if (models.length === 0) {
+        console.log(andorraFormatNoModelsAvailableMessage());
+        return;
+    }
+    // Apply fuzzy filter if search pattern provided
+    let filteredModels = models;
+    if (searchPattern) {
+        filteredModels = andorraFuzzyFilter(models, searchPattern, (m) => `${m.provider} ${m.id}`);
+    }
+    if (filteredModels.length === 0) {
+        console.log(`No models matching "${searchPattern}"`);
+        return;
+    }
+    // Sort by provider, then by model id
+    filteredModels.sort((a, b) => {
+        const providerCmp = a.provider.localeCompare(b.provider);
+        if (providerCmp !== 0)
+            return providerCmp;
+        return a.id.localeCompare(b.id);
+    });
+    // Calculate column widths
+    const rows = filteredModels.map((m) => ({
+        provider: m.provider,
+        model: m.id,
+        context: andorraFormatTokenCount(m.contextWindow),
+        maxOut: andorraFormatTokenCount(m.maxTokens),
+        thinking: m.reasoning ? "yes" : "no",
+        images: m.input.includes("image") ? "yes" : "no",
+    }));
+    const headers = {
+        provider: "provider",
+        model: "model",
+        context: "context",
+        maxOut: "max-out",
+        thinking: "thinking",
+        images: "images",
+    };
+    const widths = {
+        provider: Math.max(headers.provider.length, ...rows.map((r) => r.provider.length)),
+        model: Math.max(headers.model.length, ...rows.map((r) => r.model.length)),
+        context: Math.max(headers.context.length, ...rows.map((r) => r.context.length)),
+        maxOut: Math.max(headers.maxOut.length, ...rows.map((r) => r.maxOut.length)),
+        thinking: Math.max(headers.thinking.length, ...rows.map((r) => r.thinking.length)),
+        images: Math.max(headers.images.length, ...rows.map((r) => r.images.length)),
+    };
+    // Print header
+    const headerLine = [
+        headers.provider.padEnd(widths.provider),
+        headers.model.padEnd(widths.model),
+        headers.context.padEnd(widths.context),
+        headers.maxOut.padEnd(widths.maxOut),
+        headers.thinking.padEnd(widths.thinking),
+        headers.images.padEnd(widths.images),
+    ].join("  ");
+    console.log(headerLine);
+    // Print rows
+    for (const row of rows) {
+        const line = [
+            row.provider.padEnd(widths.provider),
+            row.model.padEnd(widths.model),
+            row.context.padEnd(widths.context),
+            row.maxOut.padEnd(widths.maxOut),
+            row.thinking.padEnd(widths.thinking),
+            row.images.padEnd(widths.images),
+        ].join("  ");
+        console.log(line);
+    }
+}

package/dist/vendor/engine/runtime/coding-agent/cli/project-trust.d.ts

@@ -0,0 +1,9 @@
+import type { ProjectTrustContext } from "../core/extensions/types.js";
+import type { AppMode } from "../core/project-trust.js";
+import type { AndorraSettingsManager } from "../core/settings-manager.js";
+export declare function andorraCreateProjectTrustContext(options: {
+    cwd: string;
+    mode: AppMode;
+    settingsManager: AndorraSettingsManager;
+    hasUI: boolean;
+}): ProjectTrustContext;

package/dist/vendor/engine/runtime/coding-agent/cli/project-trust.js

@@ -0,0 +1,47 @@
+import chalk from "chalk";
+import { andorraShowStartupInput, andorraShowStartupSelector } from "./startup-ui.js";
+export function andorraCreateProjectTrustContext(options) {
+    return {
+        cwd: options.cwd,
+        mode: options.mode === "interactive" ? "tui" : options.mode,
+        hasUI: options.hasUI,
+        ui: {
+            select: async (title, selectOptions) => {
+                if (!options.hasUI) {
+                    return undefined;
+                }
+                if (options.mode !== "interactive") {
+                    return undefined;
+                }
+                return andorraShowStartupSelector(options.settingsManager, title, selectOptions.map((option) => ({ label: option, value: option })));
+            },
+            confirm: async (title, message) => {
+                if (!options.hasUI) {
+                    return false;
+                }
+                if (options.mode !== "interactive") {
+                    return false;
+                }
+                return ((await andorraShowStartupSelector(options.settingsManager, `${title}\n${message}`, [
+                    { label: "Yes", value: true },
+                    { label: "No", value: false },
+                ])) ?? false);
+            },
+            input: async (title, placeholder) => {
+                if (!options.hasUI) {
+                    return undefined;
+                }
+                if (options.mode !== "interactive") {
+                    return undefined;
+                }
+                return andorraShowStartupInput(options.settingsManager, title, placeholder);
+            },
+            notify: (message, type = "info") => {
+                if (options.mode !== "interactive") {
+                    const color = type === "error" ? chalk.red : type === "warning" ? chalk.yellow : chalk.cyan;
+                    console.error(color(message));
+                }
+            },
+        },
+    };
+}

package/dist/vendor/engine/runtime/coding-agent/cli/session-picker.d.ts

@@ -0,0 +1,9 @@
+/**
+ * TUI session selector for --resume flag
+ */
+import type { SessionInfo, SessionListProgress } from "../core/session-manager.js";
+import type { AndorraSettingsManager } from "../core/settings-manager.js";
+type SessionsLoader = (onProgress?: SessionListProgress, signal?: AbortSignal) => Promise<SessionInfo[]>;
+/** Show TUI session selector and return selected session path or null if cancelled */
+export declare function andorraSelectSession(currentSessionsLoader: SessionsLoader, allSessionsLoader: SessionsLoader, settingsManager: AndorraSettingsManager): Promise<string | null>;
+export {};

package/dist/vendor/engine/runtime/coding-agent/cli/session-picker.js

@@ -0,0 +1,35 @@
+/**
+ * TUI session selector for --resume flag
+ */
+import { andorraSetKeybindings } from "../../tui/index.js";
+import { AndorraKeybindingsManager } from "../core/keybindings.js";
+import { AndorraSessionSelectorComponent } from "../modes/interactive/components/session-selector.js";
+import { andorraCreateStartupTui, andorraStartStartupTui } from "./startup-ui.js";
+/** Show TUI session selector and return selected session path or null if cancelled */
+export async function andorraSelectSession(currentSessionsLoader, allSessionsLoader, settingsManager) {
+    const ui = await andorraCreateStartupTui(settingsManager);
+    return new Promise((resolve) => {
+        const keybindings = AndorraKeybindingsManager.create();
+        andorraSetKeybindings(keybindings);
+        let resolved = false;
+        const selector = new AndorraSessionSelectorComponent(currentSessionsLoader, allSessionsLoader, (path) => {
+            if (!resolved) {
+                resolved = true;
+                ui.stop();
+                resolve(path);
+            }
+        }, () => {
+            if (!resolved) {
+                resolved = true;
+                ui.stop();
+                resolve(null);
+            }
+        }, () => {
+            ui.stop();
+            process.exit(0);
+        }, () => ui.requestRender(), { showRenameHint: false, keybindings });
+        ui.addChild(selector);
+        ui.setFocus(selector.getSessionList());
+        andorraStartStartupTui(ui, settingsManager);
+    });
+}

package/dist/vendor/engine/runtime/coding-agent/cli/startup-ui.d.ts

@@ -0,0 +1,19 @@
+import { type TUI } from "../../tui/index.js";
+import { AndorraSettingsManager } from "../core/settings-manager.js";
+export declare function andorraCreateStartupTui(settingsManager: AndorraSettingsManager): Promise<TUI>;
+export declare function andorraStartStartupTui(ui: TUI, settingsManager: AndorraSettingsManager): void;
+/**
+ * First-time setup runs when all of these hold:
+ * - this is the official Pi distribution (not a fork/rebrand)
+ * - experimental features are enabled (ANDORRA_ENGINE_EXPERIMENTAL=1)
+ * - the default agent directory is used (no custom agent dir override)
+ * - setup was not completed before (settings.json does not exist)
+ */
+export declare function andorraShouldRunFirstTimeSetup(settingsPath?: string): boolean;
+export declare function andorraShowStartupSelector<T>(settingsManager: AndorraSettingsManager, title: string, options: Array<{
+    label: string;
+    value: T;
+}>): Promise<T | undefined>;
+/** Show the first-time setup dialog and persist the result */
+export declare function andorraShowFirstTimeSetup(settingsManager: AndorraSettingsManager): Promise<void>;
+export declare function andorraShowStartupInput(settingsManager: AndorraSettingsManager, title: string, placeholder?: string): Promise<string | undefined>;

package/dist/vendor/engine/runtime/coding-agent/cli/startup-ui.js

@@ -0,0 +1,184 @@
+import { AndorraProcessTerminal, andorraSetCapabilityOverrides, andorraSetKeybindings, AndorraTuiMainScreen, } from "../../tui/index.js";
+import { existsSync } from "fs";
+import { APP_NAME, CONFIG_DIR_NAME, ENV_AGENT_DIR, andorraGetAgentDir, andorraGetSettingsPath, PACKAGE_NAME } from "../config.js";
+import { andorraAreExperimentalFeaturesEnabled } from "../core/experimental.js";
+import { AndorraKeybindingsManager } from "../core/keybindings.js";
+import { AndorraDefaultPackageManager } from "../core/package-manager.js";
+import { AndorraSettingsManager } from "../core/settings-manager.js";
+import { AndorraExtensionInputComponent } from "../modes/interactive/components/extension-input.js";
+import { AndorraExtensionSelectorComponent } from "../modes/interactive/components/extension-selector.js";
+import { AndorraFirstTimeSetupComponent, } from "../modes/interactive/components/first-time-setup.js";
+import { andorraDetectTerminalBackgroundFromEnv, andorraDetectTerminalThemeForAuto, andorraInitTheme, andorraLoadThemeFromPath, andorraParseAutoThemeSetting, andorraResolveThemeSetting, andorraSetRegisteredThemes, andorraSetTheme, } from "../modes/interactive/theme/theme.js";
+const OFFICIAL_PACKAGE_NAME = "@andorra-labs/code";
+const OFFICIAL_APP_NAME = "andorra";
+const OFFICIAL_CONFIG_DIR_NAME = ".andorracode";
+function andorraIsOfficialDistribution({ packageName, appName, configDirName }) {
+    return (packageName === OFFICIAL_PACKAGE_NAME &&
+        appName === OFFICIAL_APP_NAME &&
+        configDirName === OFFICIAL_CONFIG_DIR_NAME);
+}
+function andorraLoadThemes(resources) {
+    const themes = [];
+    const seen = new Set();
+    for (const resource of resources) {
+        if (!resource.enabled)
+            continue;
+        try {
+            const loadedTheme = andorraLoadThemeFromPath(resource.path);
+            if (loadedTheme.name) {
+                if (seen.has(loadedTheme.name))
+                    continue;
+                seen.add(loadedTheme.name);
+            }
+            themes.push(loadedTheme);
+        }
+        catch {
+            // Startup prompts should not fail because a theme is broken. The normal
+            // resource loader reports theme diagnostics later in startup.
+        }
+    }
+    return themes;
+}
+async function andorraLoadStartupThemes(settingsManager) {
+    const globalSettingsManager = AndorraSettingsManager.inMemory(settingsManager.getGlobalSettings(), {
+        projectTrusted: false,
+    });
+    const packageManager = new AndorraDefaultPackageManager({
+        cwd: process.cwd(),
+        agentDir: andorraGetAgentDir(),
+        settingsManager: globalSettingsManager,
+    });
+    const resolvedPaths = await packageManager.resolve(async () => "skip");
+    return andorraLoadThemes(resolvedPaths.themes);
+}
+export async function andorraCreateStartupTui(settingsManager) {
+    andorraSetCapabilityOverrides(settingsManager.getTerminalCapabilityOverrides());
+    andorraSetRegisteredThemes(await andorraLoadStartupThemes(settingsManager));
+    const terminalTheme = andorraDetectTerminalBackgroundFromEnv().theme;
+    andorraInitTheme(andorraResolveThemeSetting(settingsManager.getThemeSetting(), terminalTheme) ?? terminalTheme);
+    andorraSetKeybindings(AndorraKeybindingsManager.create());
+    const ui = new AndorraTuiMainScreen(new AndorraProcessTerminal(), settingsManager.getShowHardwareCursor(), andorraGetAgentDir());
+    ui.setClearOnShrink(settingsManager.getClearOnShrink());
+    return ui;
+}
+export function andorraStartStartupTui(ui, settingsManager) {
+    ui.start();
+    void andorraApplyDetectedStartupTheme(ui, settingsManager);
+}
+async function andorraApplyDetectedStartupTheme(ui, settingsManager) {
+    const themeSetting = settingsManager.getThemeSetting();
+    if (themeSetting && !andorraParseAutoThemeSetting(themeSetting))
+        return;
+    const terminalTheme = await andorraDetectTerminalThemeForAuto({ ui, timeoutMs: 100 });
+    andorraSetTheme(andorraResolveThemeSetting(themeSetting, terminalTheme) ?? terminalTheme);
+    ui.invalidate();
+    ui.requestRender();
+}
+async function andorraClearStartupTui(ui) {
+    ui.clear();
+    ui.requestRender();
+    await new Promise((resolve) => setTimeout(resolve, 25));
+}
+/**
+ * First-time setup runs when all of these hold:
+ * - this is the official Pi distribution (not a fork/rebrand)
+ * - experimental features are enabled (ANDORRA_ENGINE_EXPERIMENTAL=1)
+ * - the default agent directory is used (no custom agent dir override)
+ * - setup was not completed before (settings.json does not exist)
+ */
+export function andorraShouldRunFirstTimeSetup(settingsPath = andorraGetSettingsPath()) {
+    if (!andorraIsOfficialDistribution({
+        packageName: PACKAGE_NAME,
+        appName: APP_NAME,
+        configDirName: CONFIG_DIR_NAME,
+    })) {
+        return false;
+    }
+    if (!andorraAreExperimentalFeaturesEnabled()) {
+        return false;
+    }
+    if (process.env[ENV_AGENT_DIR]) {
+        return false;
+    }
+    return !existsSync(settingsPath);
+}
+export async function andorraShowStartupSelector(settingsManager, title, options) {
+    const ui = await andorraCreateStartupTui(settingsManager);
+    return new Promise((resolve) => {
+        let settled = false;
+        const andorraFinish = async (result) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            await andorraClearStartupTui(ui);
+            ui.stop();
+            resolve(result);
+        };
+        const selector = new AndorraExtensionSelectorComponent(title, options.map((option) => option.label), (option) => void andorraFinish(options.find((entry) => entry.label === option)?.value), () => void andorraFinish(undefined), { tui: ui });
+        ui.addChild(selector);
+        ui.setFocus(selector);
+        andorraStartStartupTui(ui, settingsManager);
+    });
+}
+/** Show the first-time setup dialog and persist the result */
+export async function andorraShowFirstTimeSetup(settingsManager) {
+    const ui = await andorraCreateStartupTui(settingsManager);
+    return new Promise((resolve) => {
+        let settled = false;
+        const andorraFinish = async (result) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            if (result) {
+                settingsManager.setTheme(result.theme);
+                settingsManager.setEnableAnalytics(result.shareAnalytics);
+                await settingsManager.flush();
+            }
+            await andorraClearStartupTui(ui);
+            ui.stop();
+            resolve();
+        };
+        const andorraShowSetup = async () => {
+            ui.start();
+            const detectedTheme = await andorraDetectTerminalThemeForAuto({ ui, timeoutMs: 100 });
+            andorraSetTheme(detectedTheme);
+            const component = new AndorraFirstTimeSetupComponent({
+                detectedTheme,
+                onThemePreview: (themeName) => {
+                    andorraSetTheme(themeName);
+                    ui.requestRender();
+                },
+                onSubmit: (result) => void andorraFinish(result),
+                onCancel: () => void andorraFinish(undefined),
+            });
+            ui.addChild(component);
+            ui.setFocus(component);
+            ui.requestRender();
+        };
+        void andorraShowSetup();
+    });
+}
+export async function andorraShowStartupInput(settingsManager, title, placeholder) {
+    const ui = await andorraCreateStartupTui(settingsManager);
+    return new Promise((resolve) => {
+        let settled = false;
+        const andorraFinish = async (result) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            input.dispose();
+            await andorraClearStartupTui(ui);
+            ui.stop();
+            resolve(result);
+        };
+        const input = new AndorraExtensionInputComponent(title, placeholder, (value) => void andorraFinish(value), () => void andorraFinish(undefined), {
+            tui: ui,
+        });
+        ui.addChild(input);
+        ui.setFocus(input);
+        andorraStartStartupTui(ui, settingsManager);
+    });
+}