@andorra-labs/code 0.0.0-stage → 0.1.5

package/dist/vendor/engine/runtime/coding-agent/modes/interactive/model-catalog-refresh.d.ts

@@ -0,0 +1,6 @@
+import type { ModelsRefreshResult } from "../../../ai/index.js";
+import type { AndorraModelRuntime } from "../../core/model-runtime.js";
+type ModelCatalogRuntime = Pick<AndorraModelRuntime, "refresh">;
+/** Share concurrent interactive all-catalog refreshes while keeping each caller's cancellation independent. */
+export declare function andorraRefreshModelCatalogs(modelRuntime: ModelCatalogRuntime, signal: AbortSignal): Promise<ModelsRefreshResult>;
+export {};

package/dist/vendor/engine/runtime/coding-agent/modes/interactive/model-catalog-refresh.js

@@ -0,0 +1,33 @@
+import { andorraRaceWithAbortSignal } from "../../utils/abort.js";
+class AndorraModelCatalogRefreshCoordinator {
+    activeByRuntime = new WeakMap();
+    refresh(modelRuntime, signal) {
+        signal.throwIfAborted();
+        let active = this.activeByRuntime.get(modelRuntime);
+        if (!active) {
+            const controller = new AbortController();
+            let created;
+            const operation = modelRuntime.refresh({ signal: controller.signal });
+            const promise = andorraRaceWithAbortSignal(operation, controller.signal).finally(() => {
+                if (this.activeByRuntime.get(modelRuntime) === created) {
+                    this.activeByRuntime.delete(modelRuntime);
+                }
+            });
+            created = { controller, promise, waiters: 0 };
+            active = created;
+            this.activeByRuntime.set(modelRuntime, active);
+        }
+        active.waiters++;
+        return andorraRaceWithAbortSignal(active.promise, signal).finally(() => {
+            active.waiters--;
+            if (active.waiters === 0 && this.activeByRuntime.get(modelRuntime) === active) {
+                active.controller.abort();
+            }
+        });
+    }
+}
+const modelCatalogRefreshCoordinator = new AndorraModelCatalogRefreshCoordinator();
+/** Share concurrent interactive all-catalog refreshes while keeping each caller's cancellation independent. */
+export function andorraRefreshModelCatalogs(modelRuntime, signal) {
+    return modelCatalogRefreshCoordinator.refresh(modelRuntime, signal);
+}

package/dist/vendor/engine/runtime/coding-agent/modes/interactive/model-search.d.ts

@@ -0,0 +1,11 @@
+export interface ModelSearchItem {
+    id: string;
+    provider: string;
+    name?: string;
+}
+export declare function andorraGetModelSearchText(item: ModelSearchItem): string;
+/**
+ * The /model selector search should rank exact provider-prefixed queries before proxy-provider IDs
+ * like openrouter/openai/gpt-5, so keep the bare model ID out of the leading position.
+ */
+export declare function andorraGetModelSelectorSearchText(item: ModelSearchItem): string;

package/dist/vendor/engine/runtime/coding-agent/modes/interactive/model-search.js

@@ -0,0 +1,14 @@
+export function andorraGetModelSearchText(item) {
+    const { id, provider } = item;
+    const name = item.name ? ` ${item.name}` : "";
+    return `${id} ${provider} ${provider}/${id} ${provider} ${id}${name}`;
+}
+/**
+ * The /model selector search should rank exact provider-prefixed queries before proxy-provider IDs
+ * like openrouter/openai/gpt-5, so keep the bare model ID out of the leading position.
+ */
+export function andorraGetModelSelectorSearchText(item) {
+    const { id, provider } = item;
+    const name = item.name ? ` ${item.name}` : "";
+    return `${provider} ${provider}/${id} ${provider} ${id}${name}`;
+}

package/dist/vendor/engine/runtime/coding-agent/modes/interactive/session-share.d.ts

@@ -0,0 +1,17 @@
+import { type AndorraContainer, type EditorComponent, type TUI } from "../../../tui/index.js";
+import type { AndorraAgentSession } from "../../core/agent-session.js";
+interface SessionShareContext {
+    session: AndorraAgentSession;
+    ui: TUI;
+    editorContainer: AndorraContainer;
+    editor: EditorComponent;
+    showStatus: (message: string) => void;
+    showError: (message: string) => void;
+}
+/** Trailing `pi.share` entry carrying the system prompt and tool schemas for the session viewer. */
+export declare function andorraCreateShareTrailingEntries(session: AndorraAgentSession, parentId: string | null, timestamp: string): object[];
+/** Export the current branch with presentation metadata for Radius. */
+export declare function andorraExportSessionForShare(filePath: string, session: AndorraAgentSession): void;
+/** Share the current session through Radius, falling back to a private gist. */
+export declare function andorraShareSession(context: SessionShareContext): Promise<void>;
+export {};

package/dist/vendor/engine/runtime/coding-agent/modes/interactive/session-share.js

@@ -0,0 +1,187 @@
+import { spawn, spawnSync } from "node:child_process";
+import * as crypto from "node:crypto";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { DEFAULT_RADIUS_GATEWAY } from "../../../ai/providers/radius-config.js";
+import { andorraHyperlink } from "../../../tui/index.js";
+import { andorraGetAuthCredential } from "../../cli/auth-command.js";
+import { andorraGetShareViewerUrl } from "../../config.js";
+import { andorraExportSessionToJsonl } from "../../core/session-export.js";
+import { AndorraBorderedLoader } from "./components/bordered-loader.js";
+import { theme } from "./theme/theme.js";
+/** Trailing `pi.share` entry carrying the system prompt and tool schemas for the session viewer. */
+export function andorraCreateShareTrailingEntries(session, parentId, timestamp) {
+    return [
+        {
+            type: "custom",
+            customType: "pi.share",
+            id: crypto.randomUUID().slice(0, 8),
+            parentId,
+            timestamp,
+            data: {
+                systemPrompt: session.state.systemPrompt,
+                tools: session.state.tools.map((tool) => ({
+                    name: tool.name,
+                    description: tool.description,
+                    parameters: tool.parameters,
+                })),
+            },
+        },
+    ];
+}
+/** Export the current branch with presentation metadata for Radius. */
+export function andorraExportSessionForShare(filePath, session) {
+    andorraExportSessionToJsonl(session.sessionManager, filePath, (parentId, timestamp) => andorraCreateShareTrailingEntries(session, parentId, timestamp));
+}
+/** Share the current session through Radius, falling back to a private gist. */
+export async function andorraShareSession(context) {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-share-"));
+    const jsonlFile = path.join(tempDir, "session.jsonl");
+    const htmlFile = path.join(tempDir, "session.html");
+    try {
+        try {
+            andorraExportSessionForShare(jsonlFile, context.session);
+        }
+        catch (error) {
+            context.showError(`Failed to export session: ${error instanceof Error ? error.message : "Unknown error"}`);
+            return;
+        }
+        if (await andorraTryShareViaRadius(jsonlFile, context))
+            return;
+        try {
+            const authResult = spawnSync("gh", ["auth", "status"], { encoding: "utf-8" });
+            if (authResult.status !== 0) {
+                context.showError("GitHub CLI is not logged in. Run 'gh auth login' first.");
+                return;
+            }
+        }
+        catch {
+            context.showError("GitHub CLI (gh) is not installed. Install it from https://cli.github.com/");
+            return;
+        }
+        try {
+            await context.session.exportToHtml(htmlFile, { themeName: theme.name });
+        }
+        catch (error) {
+            context.showError(`Failed to export session: ${error instanceof Error ? error.message : "Unknown error"}`);
+            return;
+        }
+        await andorraShareViaGist(htmlFile, context);
+    }
+    finally {
+        try {
+            fs.rmSync(tempDir, { recursive: true, force: true });
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+    }
+}
+async function andorraTryShareViaRadius(tmpFile, context) {
+    const provider = context.session.modelRuntime.getProvider("radius");
+    if (!provider)
+        return false;
+    const token = andorraGetAuthCredential(await context.session.modelRuntime.getAuth("radius", { minOAuthValidityMs: 5 * 60_000 }));
+    if (!token)
+        return false;
+    const loader = new AndorraBorderedLoader(context.ui, theme, "Uploading to Radius...");
+    context.editorContainer.clear();
+    context.editorContainer.addChild(loader);
+    context.ui.setFocus(loader);
+    context.ui.requestRender();
+    loader.onAbort = () => {
+        andorraRestoreEditor(loader, context);
+        context.showStatus("Share cancelled");
+    };
+    try {
+        const body = fs.readFileSync(tmpFile);
+        const url = new URL("/v1/artifacts", DEFAULT_RADIUS_GATEWAY);
+        url.searchParams.set("visibility", "organization");
+        url.searchParams.set("title", "Pi session");
+        const response = await fetch(url, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${token}`,
+                "Content-Type": "application/x-ndjson",
+                "Content-Length": String(body.byteLength),
+            },
+            body,
+            signal: loader.signal,
+        });
+        if (loader.signal.aborted)
+            return true;
+        const json = (await response.json().catch(() => null));
+        if (loader.signal.aborted)
+            return true;
+        andorraRestoreEditor(loader, context);
+        if (!response.ok || !json?.artifact) {
+            context.showError(`Failed to upload Radius artifact: ${json?.error || response.statusText || response.status}`);
+            return true;
+        }
+        const shareUrl = json.artifact.canonical_url;
+        context.showStatus(`Share URL: ${andorraHyperlink(shareUrl, shareUrl)}`);
+        return true;
+    }
+    catch (error) {
+        if (!loader.signal.aborted) {
+            andorraRestoreEditor(loader, context);
+            context.showError(`Failed to upload Radius artifact: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+        return true;
+    }
+}
+async function andorraShareViaGist(tmpFile, context) {
+    const loader = new AndorraBorderedLoader(context.ui, theme, "Creating gist...");
+    context.editorContainer.clear();
+    context.editorContainer.addChild(loader);
+    context.ui.setFocus(loader);
+    context.ui.requestRender();
+    let proc = null;
+    loader.onAbort = () => {
+        proc?.kill();
+        andorraRestoreEditor(loader, context);
+        context.showStatus("Share cancelled");
+    };
+    try {
+        const result = await new Promise((resolve) => {
+            proc = spawn("gh", ["gist", "create", "--public=false", tmpFile]);
+            let stdout = "";
+            let stderr = "";
+            proc.stdout?.on("data", (data) => {
+                stdout += data.toString();
+            });
+            proc.stderr?.on("data", (data) => {
+                stderr += data.toString();
+            });
+            proc.on("close", (code) => resolve({ stdout, stderr, code }));
+        });
+        if (loader.signal.aborted)
+            return;
+        andorraRestoreEditor(loader, context);
+        if (result.code !== 0) {
+            context.showError(`Failed to create gist: ${result.stderr?.trim() || "Unknown error"}`);
+            return;
+        }
+        const gistUrl = result.stdout?.trim();
+        const gistId = gistUrl?.split("/").pop();
+        if (!gistId) {
+            context.showError("Failed to parse gist ID from gh output");
+            return;
+        }
+        const previewUrl = andorraGetShareViewerUrl(gistId);
+        context.showStatus(`Share URL: ${andorraHyperlink(previewUrl, previewUrl)}\nGist: ${andorraHyperlink(gistUrl, gistUrl)}`);
+    }
+    catch (error) {
+        if (!loader.signal.aborted) {
+            andorraRestoreEditor(loader, context);
+            context.showError(`Failed to create gist: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+    }
+}
+function andorraRestoreEditor(loader, context) {
+    loader.dispose();
+    context.editorContainer.clear();
+    context.editorContainer.addChild(context.editor);
+    context.ui.setFocus(context.editor);
+}

package/dist/vendor/engine/runtime/coding-agent/modes/interactive/theme/dark.json

@@ -0,0 +1,91 @@
+{
+	"$schema": "https://raw.githubusercontent.com/earendil-works/pi/main/packages/coding-agent/src/modes/interactive/theme/theme-schema.json",
+	"name": "dark",
+	"vars": {
+		"cyan": "#00d7ff",
+		"blue": "#5f87ff",
+		"green": "#b5bd68",
+		"red": "#cc6666",
+		"yellow": "#ffff00",
+		"text": "#d4d4d4",
+		"gray": "#808080",
+		"dimGray": "#666666",
+		"darkGray": "#505050",
+		"accent": "#8abeb7",
+		"selectedBg": "#3a3a4a",
+		"userMsgBg": "#343541",
+		"toolPendingBg": "#282832",
+		"toolSuccessBg": "#283228",
+		"toolErrorBg": "#3c2828",
+		"customMsgBg": "#2d2838"
+	},
+	"colors": {
+		"accent": "accent",
+		"border": "blue",
+		"borderAccent": "cyan",
+		"borderMuted": "darkGray",
+		"success": "green",
+		"error": "red",
+		"warning": "yellow",
+		"muted": "gray",
+		"dim": "dimGray",
+		"text": "text",
+		"thinkingText": "gray",
+
+		"selectedBg": "selectedBg",
+		"scrollbarTrack": "darkGray",
+		"scrollbarThumb": "text",
+		"searchMatchBg": "selectedBg",
+		"searchMatchText": "text",
+		"userMessageBg": "userMsgBg",
+		"userMessageText": "text",
+		"customMessageBg": "customMsgBg",
+		"customMessageText": "text",
+		"customMessageLabel": "#9575cd",
+		"toolPendingBg": "toolPendingBg",
+		"toolSuccessBg": "toolSuccessBg",
+		"toolErrorBg": "toolErrorBg",
+		"toolTitle": "text",
+		"toolOutput": "gray",
+
+		"mdHeading": "#f0c674",
+		"mdLink": "#81a2be",
+		"mdLinkUrl": "dimGray",
+		"mdCode": "accent",
+		"mdCodeBlock": "green",
+		"mdCodeBlockBorder": "gray",
+		"mdQuote": "gray",
+		"mdQuoteBorder": "gray",
+		"mdHr": "gray",
+		"mdListBullet": "accent",
+
+		"toolDiffAdded": "green",
+		"toolDiffRemoved": "red",
+		"toolDiffContext": "gray",
+
+		"syntaxComment": "#6A9955",
+		"syntaxKeyword": "#569CD6",
+		"syntaxFunction": "#DCDCAA",
+		"syntaxVariable": "#9CDCFE",
+		"syntaxString": "#CE9178",
+		"syntaxNumber": "#B5CEA8",
+		"syntaxType": "#4EC9B0",
+		"syntaxOperator": "#D4D4D4",
+		"syntaxPunctuation": "#D4D4D4",
+
+		"thinkingOff": "darkGray",
+		"thinkingMinimal": "#6e6e6e",
+		"thinkingLow": "#5f87af",
+		"thinkingMedium": "#81a2be",
+		"thinkingHigh": "#b294bb",
+		"thinkingXhigh": "#d183e8",
+		"thinkingMax": "#ff5fff",
+
+		"bashMode": "green"
+	},
+	"export": {
+		"pageBg": "#18181e",
+		"cardBg": "#1e1e24",
+		"infoBg": "#3c3728"
+	}
+}

package/dist/vendor/engine/runtime/coding-agent/modes/interactive/theme/light.json

@@ -0,0 +1,90 @@
+{
+	"$schema": "https://raw.githubusercontent.com/earendil-works/pi/main/packages/coding-agent/src/modes/interactive/theme/theme-schema.json",
+	"name": "light",
+	"vars": {
+		"teal": "#5a8080",
+		"blue": "#547da7",
+		"green": "#588458",
+		"red": "#aa5555",
+		"yellow": "#9a7326",
+		"text": "#1f2328",
+		"mediumGray": "#6c6c6c",
+		"dimGray": "#767676",
+		"lightGray": "#b0b0b0",
+		"selectedBg": "#d0d0e0",
+		"userMsgBg": "#e8e8e8",
+		"toolPendingBg": "#e8e8f0",
+		"toolSuccessBg": "#e8f0e8",
+		"toolErrorBg": "#f0e8e8",
+		"customMsgBg": "#ede7f6"
+	},
+	"colors": {
+		"accent": "teal",
+		"border": "blue",
+		"borderAccent": "teal",
+		"borderMuted": "lightGray",
+		"success": "green",
+		"error": "red",
+		"warning": "yellow",
+		"muted": "mediumGray",
+		"dim": "dimGray",
+		"text": "text",
+		"thinkingText": "mediumGray",
+
+		"selectedBg": "selectedBg",
+		"scrollbarTrack": "lightGray",
+		"scrollbarThumb": "text",
+		"searchMatchBg": "selectedBg",
+		"searchMatchText": "text",
+		"userMessageBg": "userMsgBg",
+		"userMessageText": "text",
+		"customMessageBg": "customMsgBg",
+		"customMessageText": "text",
+		"customMessageLabel": "#7e57c2",
+		"toolPendingBg": "toolPendingBg",
+		"toolSuccessBg": "toolSuccessBg",
+		"toolErrorBg": "toolErrorBg",
+		"toolTitle": "text",
+		"toolOutput": "mediumGray",
+
+		"mdHeading": "yellow",
+		"mdLink": "blue",
+		"mdLinkUrl": "dimGray",
+		"mdCode": "teal",
+		"mdCodeBlock": "green",
+		"mdCodeBlockBorder": "mediumGray",
+		"mdQuote": "mediumGray",
+		"mdQuoteBorder": "mediumGray",
+		"mdHr": "mediumGray",
+		"mdListBullet": "green",
+
+		"toolDiffAdded": "green",
+		"toolDiffRemoved": "red",
+		"toolDiffContext": "mediumGray",
+
+		"syntaxComment": "#008000",
+		"syntaxKeyword": "#0000FF",
+		"syntaxFunction": "#795E26",
+		"syntaxVariable": "#001080",
+		"syntaxString": "#A31515",
+		"syntaxNumber": "#098658",
+		"syntaxType": "#267F99",
+		"syntaxOperator": "#000000",
+		"syntaxPunctuation": "#000000",
+
+		"thinkingOff": "lightGray",
+		"thinkingMinimal": "#767676",
+		"thinkingLow": "blue",
+		"thinkingMedium": "teal",
+		"thinkingHigh": "#875f87",
+		"thinkingXhigh": "#8b008b",
+		"thinkingMax": "#af005f",
+
+		"bashMode": "green"
+	},
+	"export": {
+		"pageBg": "#f8f8f8",
+		"cardBg": "#ffffff",
+		"infoBg": "#fffae6"
+	}
+}

package/dist/vendor/engine/runtime/coding-agent/modes/interactive/theme/theme-controller.d.ts

@@ -0,0 +1,40 @@
+import type { TUI } from "../../../../tui/index.js";
+import type { AndorraSettingsManager } from "../../../core/settings-manager.js";
+import { type TerminalTheme, type AndorraTheme } from "./theme.js";
+type ThemeResult = {
+    success: boolean;
+    error?: string;
+};
+export declare class AndorraInteractiveThemeController {
+    private readonly ui;
+    private readonly getSettingsManager;
+    private readonly showError;
+    private readonly onChanged;
+    private currentThemeSetting;
+    private terminalTheme;
+    private activeThemeName;
+    private autoSyncEnabled;
+    private terminalColorSchemeUnsubscribe;
+    constructor(ui: TUI, options: {
+        getSettingsManager: () => AndorraSettingsManager;
+        showError: (message: string) => void;
+        onChanged: () => void;
+        initialThemeSetting?: string;
+    });
+    rebindTui(): void;
+    applyFromSettings(): Promise<void>;
+    getThemeSelection(): string | undefined;
+    setThemeName(themeName: string, showError?: boolean): ThemeResult;
+    setThemeSetting(themeSetting: string): Promise<void>;
+    setThemeInstance(themeInstance: AndorraTheme): ThemeResult;
+    preview(themeSettingOrName: string): void;
+    disableAutoSync(): void;
+    dispose(): void;
+    getTerminalTheme(): TerminalTheme;
+    private applyThemeName;
+    private notifyChanged;
+    private setAutoSync;
+    private bindTerminalColorSchemeListener;
+    private applyTerminalTheme;
+}
+export {};

package/dist/vendor/engine/runtime/coding-agent/modes/interactive/theme/theme-controller.js

@@ -0,0 +1,129 @@
+import { andorraDetectTerminalBackgroundFromEnv, andorraDetectTerminalBackgroundTheme, andorraDetectTerminalThemeForAuto, andorraInitTheme, andorraParseAutoThemeSetting, andorraResolveThemeSetting, andorraSetTheme, andorraSetThemeInstance, } from "./theme.js";
+export class AndorraInteractiveThemeController {
+    ui;
+    getSettingsManager;
+    showError;
+    onChanged;
+    currentThemeSetting;
+    terminalTheme = andorraDetectTerminalBackgroundFromEnv().theme;
+    activeThemeName;
+    autoSyncEnabled = false;
+    terminalColorSchemeUnsubscribe;
+    constructor(ui, options) {
+        this.ui = ui;
+        this.getSettingsManager = options.getSettingsManager;
+        this.showError = options.showError;
+        this.onChanged = options.onChanged;
+        this.currentThemeSetting = options.initialThemeSetting;
+        this.activeThemeName = andorraResolveThemeSetting(this.currentThemeSetting ?? this.getSettingsManager().getThemeSetting(), this.terminalTheme);
+        andorraInitTheme(this.activeThemeName, true);
+        this.bindTerminalColorSchemeListener();
+    }
+    rebindTui() {
+        this.terminalColorSchemeUnsubscribe?.();
+        this.bindTerminalColorSchemeListener();
+        this.ui.setTerminalColorSchemeNotifications(this.autoSyncEnabled);
+    }
+    async applyFromSettings() {
+        const settingsManager = this.getSettingsManager();
+        const themeSetting = this.currentThemeSetting ?? settingsManager.getThemeSetting();
+        const autoTheme = andorraParseAutoThemeSetting(themeSetting);
+        if (autoTheme) {
+            this.terminalTheme = await andorraDetectTerminalThemeForAuto({ ui: this.ui, timeoutMs: 100 });
+            this.setAutoSync(true);
+            this.applyThemeName(this.terminalTheme === "light" ? autoTheme.lightTheme : autoTheme.darkTheme, true);
+            return;
+        }
+        this.setAutoSync(false);
+        if (themeSetting !== undefined) {
+            this.applyThemeName(themeSetting, true);
+            return;
+        }
+        const detection = await andorraDetectTerminalBackgroundTheme({ ui: this.ui, timeoutMs: 100 });
+        this.terminalTheme = detection.theme;
+        if (!this.applyThemeName(detection.theme).success)
+            return;
+        if (detection.confidence === "high") {
+            settingsManager.setTheme(detection.theme);
+            await settingsManager.flush();
+        }
+    }
+    getThemeSelection() {
+        return this.currentThemeSetting ?? this.getSettingsManager().getThemeSetting() ?? this.activeThemeName;
+    }
+    setThemeName(themeName, showError = false) {
+        this.setAutoSync(false);
+        const result = this.applyThemeName(themeName, showError);
+        if (result.success) {
+            this.currentThemeSetting = themeName;
+        }
+        return result;
+    }
+    async setThemeSetting(themeSetting) {
+        this.currentThemeSetting = themeSetting;
+        await this.applyFromSettings();
+    }
+    setThemeInstance(themeInstance) {
+        this.setAutoSync(false);
+        andorraSetThemeInstance(themeInstance);
+        this.activeThemeName = "<in-memory>";
+        this.notifyChanged();
+        return { success: true };
+    }
+    preview(themeSettingOrName) {
+        const themeName = andorraResolveThemeSetting(themeSettingOrName, this.terminalTheme) ?? this.activeThemeName;
+        if (!themeName)
+            return;
+        if (andorraSetTheme(themeName, true).success) {
+            this.ui.invalidate();
+            this.ui.requestRender();
+        }
+    }
+    disableAutoSync() {
+        this.setAutoSync(false);
+    }
+    dispose() {
+        this.setAutoSync(false);
+        this.terminalColorSchemeUnsubscribe?.();
+        this.terminalColorSchemeUnsubscribe = undefined;
+    }
+    getTerminalTheme() {
+        return this.terminalTheme;
+    }
+    applyThemeName(themeName, showError = false) {
+        const result = andorraSetTheme(themeName, true);
+        this.activeThemeName = result.success ? themeName : "dark";
+        this.notifyChanged();
+        if (!result.success && showError) {
+            this.showError(`Failed to load theme "${themeName}": ${result.error}\nFell back to dark theme.`);
+        }
+        return result;
+    }
+    notifyChanged() {
+        this.ui.invalidate();
+        this.onChanged();
+    }
+    setAutoSync(enabled) {
+        if (this.autoSyncEnabled === enabled)
+            return;
+        this.autoSyncEnabled = enabled;
+        this.ui.setTerminalColorSchemeNotifications(enabled);
+    }
+    bindTerminalColorSchemeListener() {
+        this.terminalColorSchemeUnsubscribe = this.ui.onTerminalColorSchemeChange((terminalTheme) => this.applyTerminalTheme(terminalTheme));
+    }
+    applyTerminalTheme(terminalTheme) {
+        if (!this.autoSyncEnabled)
+            return;
+        this.terminalTheme = terminalTheme;
+        const autoTheme = andorraParseAutoThemeSetting(this.currentThemeSetting ?? this.getSettingsManager().getThemeSetting());
+        if (!autoTheme) {
+            this.setAutoSync(false);
+            return;
+        }
+        const themeName = terminalTheme === "light" ? autoTheme.lightTheme : autoTheme.darkTheme;
+        if (themeName !== this.activeThemeName) {
+            this.applyThemeName(themeName);
+        }
+    }
+}