pi-ui-extend 0.1.1

package/dist/app/file-links.js

@@ -0,0 +1,117 @@
+import { existsSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { isAbsolute, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+const FILE_PATH_CANDIDATE = /(?<![\p{L}\p{N}_:])((?:file:\/\/\/|~\/|\.{1,2}\/|\/|[A-Za-z0-9_.@-]+\/)[^\s"'`<>]*)/gu;
+const TRAILING_PUNCTUATION = new Set([".", ",", ";", ")", "]", "}"]);
+export function detectFileLinks(text, cwd) {
+    const links = [];
+    if (!text.includes("/"))
+        return links;
+    for (const match of text.matchAll(FILE_PATH_CANDIDATE)) {
+        const raw = match[1];
+        if (!raw)
+            continue;
+        const start = match.index + match[0].indexOf(raw);
+        const candidate = trimTrailingPunctuation(raw);
+        if (!candidate)
+            continue;
+        const location = resolveExistingFileLocation(candidate, cwd);
+        if (!location)
+            continue;
+        links.push({
+            start,
+            end: start + candidate.length,
+            url: locationUrl(location),
+            filePath: location.filePath,
+            line: location.line,
+            column: location.column,
+        });
+    }
+    return mergeOverlappingLinks(links);
+}
+export function hyperlink(text, url) {
+    return `\x1b]8;;${url}\x07${text}\x1b]8;;\x07`;
+}
+function locationUrl(location) {
+    const url = pathToFileURL(location.filePath).href;
+    if (location.line === undefined)
+        return url;
+    return location.column === undefined ? `${url}:${location.line}` : `${url}:${location.line}:${location.column}`;
+}
+function trimTrailingPunctuation(value) {
+    let end = value.length;
+    while (end > 0 && TRAILING_PUNCTUATION.has(value[end - 1] ?? ""))
+        end -= 1;
+    return value.slice(0, end);
+}
+function resolveExistingFileLocation(candidate, cwd) {
+    for (const variant of candidatePathVariants(candidate)) {
+        const filePath = resolveLocalPath(variant.pathText, cwd);
+        if (filePath && isExistingFile(filePath))
+            return { filePath, line: variant.line, column: variant.column };
+    }
+    return undefined;
+}
+function candidatePathVariants(candidate) {
+    const variants = [{ pathText: candidate }];
+    const locationSuffix = /^(.*?):(\d+)(?::(\d+))?(?:\+\d+)?$/u.exec(candidate);
+    if (locationSuffix?.[1] && locationSuffix[1] !== candidate) {
+        variants.push({
+            pathText: locationSuffix[1],
+            line: Number(locationSuffix[2]),
+            column: locationSuffix[3] ? Number(locationSuffix[3]) : undefined,
+        });
+    }
+    const markdownAnchorSuffix = /^(.*?)#L(\d+)(?:C(\d+))?$/u.exec(candidate);
+    if (markdownAnchorSuffix?.[1] && markdownAnchorSuffix[1] !== candidate) {
+        variants.push({
+            pathText: markdownAnchorSuffix[1],
+            line: Number(markdownAnchorSuffix[2]),
+            column: markdownAnchorSuffix[3] ? Number(markdownAnchorSuffix[3]) : undefined,
+        });
+    }
+    const seen = new Set();
+    return variants.filter((variant) => {
+        const key = `${variant.pathText}\0${variant.line ?? ""}\0${variant.column ?? ""}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+function resolveLocalPath(pathText, cwd) {
+    if (pathText.startsWith("file:///")) {
+        try {
+            return fileURLToPath(pathText);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    if (pathText.startsWith("~/"))
+        return resolve(homedir(), pathText.slice(2));
+    if (isAbsolute(pathText))
+        return pathText;
+    if (!cwd)
+        return undefined;
+    return resolve(cwd, pathText);
+}
+function isExistingFile(filePath) {
+    try {
+        return existsSync(filePath) && statSync(filePath).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function mergeOverlappingLinks(links) {
+    const merged = [];
+    for (const link of links.sort((left, right) => left.start - right.start || right.end - left.end)) {
+        const previous = merged[merged.length - 1];
+        if (previous && link.start < previous.end)
+            continue;
+        merged.push(link);
+    }
+    return merged;
+}

package/dist/app/guards.d.ts

@@ -0,0 +1,3 @@
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function isStringArray(value: unknown): value is string[];
+export declare function isNumberArray(value: unknown): value is number[];

package/dist/app/guards.js

@@ -0,0 +1,9 @@
+export function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+export function isStringArray(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+export function isNumberArray(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === "number");
+}

package/dist/app/icons.d.ts

@@ -0,0 +1,37 @@
+export declare const PIX_ICON_THEME_ENV = "PIX_ICON_THEME";
+export declare const PIX_USE_FALLBACK_ICONS_ENV = "PIX_USE_FALLBACK_ICONS";
+declare const NERD_FONT_ICONS: {
+    readonly alert: "󰀦";
+    readonly autoFix: "󰁨";
+    readonly check: "󰄬";
+    readonly checkCircle: "󰗠";
+    readonly circle: "󰝥";
+    readonly circleOutline: "󰝦";
+    readonly close: "󰅖";
+    readonly closeCircle: "󰅙";
+    readonly deleted: "󰅙";
+    readonly deferred: "󰍷";
+    readonly info: "󰋼";
+    readonly microphone: "󰍬";
+    readonly plus: "󰐕";
+    readonly record: "󰑊";
+    readonly refresh: "󰑐";
+    readonly user: "󰀄";
+    readonly compactTools: "󰍜";
+    readonly thinkingExpanded: "󰌵";
+    readonly stopCircle: "󰙥";
+    readonly timerSand: "󰔟";
+    readonly down: "󰁅";
+};
+export type AppIconName = keyof typeof NERD_FONT_ICONS;
+export type AppIconMap = Record<AppIconName, string>;
+export type AppIconThemeName = "nerdFont" | "fallback";
+export declare const APP_ICON_THEMES: Record<AppIconThemeName, AppIconMap>;
+export declare const APP_ICONS: AppIconMap;
+export declare function currentAppIconTheme(): AppIconThemeName;
+export declare function parseAppIconThemeName(value: unknown): AppIconThemeName | undefined;
+export declare function appIconThemeFromFallbackFlag(value: unknown): AppIconThemeName | undefined;
+export declare function resolveAppIconThemeNameFromEnv(env?: NodeJS.ProcessEnv): AppIconThemeName;
+export declare function appIconThemeOverrideFromEnv(env?: NodeJS.ProcessEnv): AppIconThemeName | undefined;
+export declare function setAppIconTheme(themeName: AppIconThemeName): void;
+export {};

package/dist/app/icons.js

@@ -0,0 +1,97 @@
+// Centralized icon themes. The default theme uses Nerd Font / Material Design
+// private-use glyphs; the fallback theme avoids icon-font codepoints so Pix is
+// still readable when the terminal font is missing.
+//
+// Use codepoint escapes for private-use characters so editors cannot silently
+// substitute visually similar glyphs.
+export const PIX_ICON_THEME_ENV = "PIX_ICON_THEME";
+export const PIX_USE_FALLBACK_ICONS_ENV = "PIX_USE_FALLBACK_ICONS";
+const NERD_FONT_ICONS = {
+    alert: "\u{f0026}",
+    autoFix: "\u{f0068}",
+    check: "\u{f012c}",
+    checkCircle: "\u{f05e0}",
+    circle: "\u{f0765}",
+    circleOutline: "\u{f0766}",
+    close: "\u{f0156}",
+    closeCircle: "\u{f0159}",
+    deleted: "\u{f0159}",
+    deferred: "\u{f0377}",
+    info: "\u{f02fc}",
+    microphone: "\u{f036c}",
+    plus: "\u{f0415}",
+    record: "\u{f044a}",
+    refresh: "\u{f0450}",
+    user: "\u{f0004}",
+    compactTools: "\u{f035c}",
+    thinkingExpanded: "\u{f0335}",
+    stopCircle: "\u{f0665}",
+    timerSand: "\u{f051f}",
+    down: "\u{f0045}",
+};
+const FALLBACK_ICONS = {
+    alert: "!",
+    autoFix: "*",
+    check: "✓",
+    checkCircle: "✓",
+    circle: "●",
+    circleOutline: "○",
+    close: "×",
+    closeCircle: "×",
+    deleted: "×",
+    deferred: "↷",
+    info: "i",
+    microphone: "m",
+    plus: "+",
+    record: "●",
+    refresh: "↻",
+    user: "@",
+    compactTools: "≡",
+    thinkingExpanded: ">",
+    stopCircle: "■",
+    timerSand: "…",
+    down: "v",
+};
+export const APP_ICON_THEMES = {
+    nerdFont: NERD_FONT_ICONS,
+    fallback: FALLBACK_ICONS,
+};
+let currentAppIconThemeName = resolveAppIconThemeNameFromEnv();
+export const APP_ICONS = { ...APP_ICON_THEMES[currentAppIconThemeName] };
+export function currentAppIconTheme() {
+    return currentAppIconThemeName;
+}
+export function parseAppIconThemeName(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const normalized = value.trim().toLowerCase().replace(/[\s_-]+/gu, "");
+    if (normalized === "fallback" || normalized === "plain" || normalized === "ascii")
+        return "fallback";
+    if (normalized === "nerdfont" || normalized === "font" || normalized === "icons")
+        return "nerdFont";
+    return undefined;
+}
+export function appIconThemeFromFallbackFlag(value) {
+    if (typeof value === "boolean")
+        return value ? "fallback" : "nerdFont";
+    if (typeof value !== "string")
+        return undefined;
+    const normalized = value.trim().toLowerCase();
+    if (["1", "true", "yes", "on", "fallback"].includes(normalized))
+        return "fallback";
+    if (["0", "false", "no", "off", "nerdfont", "nerd-font"].includes(normalized))
+        return "nerdFont";
+    return undefined;
+}
+export function resolveAppIconThemeNameFromEnv(env = process.env) {
+    return appIconThemeOverrideFromEnv(env) ?? "nerdFont";
+}
+export function appIconThemeOverrideFromEnv(env = process.env) {
+    return appIconThemeFromFallbackFlag(env[PIX_USE_FALLBACK_ICONS_ENV])
+        ?? parseAppIconThemeName(env[PIX_ICON_THEME_ENV])
+        ?? undefined;
+}
+export function setAppIconTheme(themeName) {
+    currentAppIconThemeName = themeName;
+    Object.assign(APP_ICONS, APP_ICON_THEMES[themeName]);
+}

package/dist/app/id.d.ts

@@ -0,0 +1 @@
+export declare function createId(prefix: string): string;

package/dist/app/id.js

@@ -0,0 +1,4 @@
+import { randomUUID } from "node:crypto";
+export function createId(prefix) {
+    return `${prefix}-${randomUUID()}`;
+}

package/dist/app/image-click-targets.d.ts

@@ -0,0 +1,5 @@
+import type { ImageContent } from "../input-editor.js";
+import type { RenderedLine, StyledSegment } from "./types.js";
+type ImageLabelStyle = Omit<StyledSegment, "start" | "end">;
+export declare function attachImageClickTargets(lines: RenderedLine[], entryId: string, images: readonly ImageContent[] | undefined, style?: ImageLabelStyle): RenderedLine[];
+export {};

package/dist/app/image-click-targets.js

@@ -0,0 +1,32 @@
+const IMAGE_LABEL_PATTERN = /\[Image(?:\s+\d+)?(?::[^\]]+)?\]/g;
+export function attachImageClickTargets(lines, entryId, images, style) {
+    if (!images || images.length === 0)
+        return lines;
+    let fallbackIndex = 0;
+    for (const line of lines) {
+        const targets = [];
+        const segments = [];
+        for (const match of line.text.matchAll(IMAGE_LABEL_PATTERN)) {
+            const imageIndex = imageIndexForLabel(match[0], fallbackIndex);
+            fallbackIndex = Math.max(fallbackIndex, imageIndex + 1);
+            if (imageIndex < 0 || imageIndex >= images.length)
+                continue;
+            const start = match.index ?? 0;
+            const end = start + match[0].length;
+            targets.push({ start, end, entryId, imageIndex });
+            if (style)
+                segments.push({ start, end, ...style });
+        }
+        if (targets.length > 0)
+            line.imageTargets = [...(line.imageTargets ?? []), ...targets];
+        if (segments.length > 0)
+            line.segments = [...(line.segments ?? []), ...segments];
+    }
+    return lines;
+}
+function imageIndexForLabel(label, fallbackIndex) {
+    const numbered = /^\[Image\s+(\d+)(?::|\])/u.exec(label);
+    if (numbered?.[1])
+        return Number(numbered[1]) - 1;
+    return fallbackIndex;
+}

package/dist/app/image-opener.d.ts

@@ -0,0 +1,2 @@
+import type { ImageContent } from "../input-editor.js";
+export declare function openImageContent(image: ImageContent): boolean;

package/dist/app/image-opener.js

@@ -0,0 +1,64 @@
+import { spawn } from "node:child_process";
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+export function openImageContent(image) {
+    const filePath = writeImageTempFile(image);
+    if (!filePath)
+        return false;
+    return openPathWithSystemViewer(filePath);
+}
+function writeImageTempFile(image) {
+    try {
+        const data = Buffer.from(image.data, "base64");
+        if (data.length === 0)
+            return undefined;
+        const dir = join(tmpdir(), "pix-image-open");
+        mkdirSync(dir, { recursive: true });
+        const hash = createHash("sha256").update(image.mimeType).update("\0").update(data).digest("hex").slice(0, 24);
+        const filePath = join(dir, `${hash}${imageExtension(image.mimeType)}`);
+        if (!existsSync(filePath))
+            writeFileSync(filePath, data, { flag: "wx" });
+        return filePath;
+    }
+    catch {
+        return undefined;
+    }
+}
+function imageExtension(mimeType) {
+    switch (mimeType.toLowerCase()) {
+        case "image/jpeg":
+        case "image/jpg":
+            return ".jpg";
+        case "image/gif":
+            return ".gif";
+        case "image/webp":
+            return ".webp";
+        case "image/bmp":
+            return ".bmp";
+        case "image/svg+xml":
+            return ".svg";
+        case "image/png":
+        default:
+            return ".png";
+    }
+}
+function openPathWithSystemViewer(filePath) {
+    if (process.platform === "darwin")
+        return spawnDetached("open", [filePath]);
+    if (process.platform === "win32")
+        return spawnDetached("cmd", ["/c", "start", "", filePath]);
+    return spawnDetached("xdg-open", [filePath]);
+}
+function spawnDetached(command, args) {
+    try {
+        const child = spawn(command, args, { detached: true, stdio: "ignore" });
+        child.on("error", () => { });
+        child.unref();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/app/input-action-controller.d.ts

@@ -0,0 +1,47 @@
+import type { InputEditor } from "../input-editor.js";
+import type { AgentSessionRuntime } from "@earendil-works/pi-coding-agent";
+import type { AppPopupActionController } from "./popup-action-controller.js";
+import type { AppPopupMenuController } from "./popup-menu-controller.js";
+import type { AppQueuedMessageController } from "./queued-message-controller.js";
+import type { AppRequestHistory } from "./request-history.js";
+import { type InteractiveShellCommandResult } from "./shell-command.js";
+import type { Entry, SessionActivity } from "./types.js";
+export type AppInputActionControllerHost = {
+    runtime(): AgentSessionRuntime | undefined;
+    isRunning(): boolean;
+    isSessionSwitching(): boolean;
+    inputEditor(): InputEditor;
+    requestHistory(): AppRequestHistory;
+    clearPersistedInputDraft(): Promise<void>;
+    setStatus(status: string): void;
+    setSessionStatus(session: AgentSessionRuntime["session"] | undefined): void;
+    setSessionActivity(activity: SessionActivity): void;
+    addEntry(entry: Entry): void;
+    addSessionAbortedEntry(): void;
+    showToast(message: string, kind: "success" | "error" | "warning" | "info"): void;
+    stopVoiceInput(): Promise<void>;
+    isShellCommandRunning(): boolean;
+    runChatShellCommand(command: string): Promise<InteractiveShellCommandResult>;
+    sendShellInput(text: string): boolean;
+    interruptShellCommand(): boolean;
+    runInteractiveShellCommand(command: string): Promise<InteractiveShellCommandResult>;
+    stop(): Promise<void>;
+    render(): void;
+};
+export declare class AppInputActionController {
+    private readonly host;
+    private readonly popupMenus;
+    private readonly popupActions;
+    private readonly queuedMessages;
+    private abortInFlight;
+    constructor(host: AppInputActionControllerHost, popupMenus: AppPopupMenuController, popupActions: AppPopupActionController, queuedMessages: AppQueuedMessageController);
+    handleEnter(): void;
+    handleInterrupt(): Promise<void>;
+    handleEscape(): Promise<void>;
+    private abortStreamingSession;
+    private restoreSessionState;
+    private sessionActivity;
+    private submitInput;
+    private submitShellInput;
+    private submitShellCommand;
+}

package/dist/app/input-action-controller.js

@@ -0,0 +1,209 @@
+import { createId } from "./id.js";
+import { stringifyUnknown } from "./message-content.js";
+import { bangShellCommandFromInput, formatShellCommandEntry, } from "./shell-command.js";
+const ABORT_STATUS_RESTORE_MS = 1200;
+export class AppInputActionController {
+    host;
+    popupMenus;
+    popupActions;
+    queuedMessages;
+    abortInFlight = false;
+    constructor(host, popupMenus, popupActions, queuedMessages) {
+        this.host = host;
+        this.popupMenus = popupMenus;
+        this.popupActions = popupActions;
+        this.queuedMessages = queuedMessages;
+    }
+    handleEnter() {
+        if (this.popupMenus.syncActivePopupMenu()) {
+            void this.popupActions.submitActivePopupMenu();
+            return;
+        }
+        void this.submitInput();
+    }
+    async handleInterrupt() {
+        if (this.host.interruptShellCommand()) {
+            this.host.inputEditor().clear();
+            await this.host.clearPersistedInputDraft();
+            this.host.render();
+            return;
+        }
+        const runtime = this.host.runtime();
+        if (runtime?.session.isCompacting) {
+            this.host.setStatus("aborting compaction");
+            this.host.render();
+            runtime.session.abortCompaction();
+            return;
+        }
+        if (runtime?.session.isStreaming) {
+            await this.abortStreamingSession(runtime, { stopIfAlreadyAborting: true });
+            return;
+        }
+        await this.host.stop();
+    }
+    async handleEscape() {
+        const session = this.host.runtime()?.session;
+        if (session?.isCompacting) {
+            this.host.setStatus("aborting compaction");
+            this.host.render();
+            session.abortCompaction();
+            return;
+        }
+        if (session?.isStreaming) {
+            const runtime = this.host.runtime();
+            if (runtime)
+                await this.abortStreamingSession(runtime, { stopIfAlreadyAborting: false });
+            return;
+        }
+        if (this.popupMenus.syncActivePopupMenu())
+            this.popupMenus.cancelActivePopupMenu();
+    }
+    async abortStreamingSession(runtime, options) {
+        const session = runtime.session;
+        if (this.abortInFlight) {
+            session.agent.abort();
+            if (options.stopIfAlreadyAborting)
+                await this.host.stop();
+            else
+                this.host.render();
+            return;
+        }
+        this.abortInFlight = true;
+        this.queuedMessages.restoreQueuedMessagesToEditorForAbort();
+        this.host.setStatus("aborting");
+        this.host.addSessionAbortedEntry();
+        this.host.render();
+        let restoreTimer = setTimeout(() => {
+            if (!this.abortInFlight || this.host.runtime()?.session !== session || !this.host.isRunning())
+                return;
+            this.restoreSessionState(session);
+            this.host.render();
+        }, ABORT_STATUS_RESTORE_MS);
+        restoreTimer.unref?.();
+        try {
+            session.agent.abort();
+            await session.abort();
+        }
+        catch (error) {
+            this.host.addEntry({ id: createId("error"), kind: "error", text: stringifyUnknown(error) });
+        }
+        finally {
+            if (restoreTimer)
+                clearTimeout(restoreTimer);
+            restoreTimer = undefined;
+            this.abortInFlight = false;
+            this.restoreSessionState(this.host.runtime()?.session);
+            if (this.host.isRunning())
+                this.host.render();
+        }
+    }
+    restoreSessionState(session) {
+        this.host.setSessionStatus(session);
+        this.host.setSessionActivity(this.sessionActivity(session));
+    }
+    sessionActivity(session) {
+        return session?.isStreaming || session?.isCompacting ? "running" : "idle";
+    }
+    async submitInput() {
+        await this.host.stopVoiceInput();
+        const inputEditor = this.host.inputEditor();
+        const rawPromptText = inputEditor.promptText;
+        const rawDisplayText = inputEditor.expandedText;
+        const promptText = rawPromptText.trimEnd();
+        const displayText = rawDisplayText.trimEnd();
+        const images = [...inputEditor.images];
+        if (this.host.isShellCommandRunning()) {
+            await this.submitShellInput(rawDisplayText, images.length);
+            return;
+        }
+        if (!promptText && images.length === 0)
+            return;
+        const shellCommand = bangShellCommandFromInput(promptText);
+        if (shellCommand !== undefined) {
+            await this.submitShellCommand(shellCommand.command, displayText, images.length, shellCommand.interactive ? "interactive" : "chat");
+            return;
+        }
+        if (this.host.isSessionSwitching()) {
+            this.host.showToast("Wait for the tab to finish loading", "info");
+            this.host.render();
+            return;
+        }
+        if (promptText.startsWith("/")) {
+            await this.popupActions.submitSlashCommand(promptText);
+            return;
+        }
+        const message = this.queuedMessages.createSubmittedUserMessage(promptText, displayText, images);
+        this.host.requestHistory().add(message.displayText);
+        inputEditor.clear();
+        await this.host.clearPersistedInputDraft();
+        this.host.render();
+        try {
+            await this.queuedMessages.submitUserMessage(message);
+        }
+        catch (error) {
+            this.host.addEntry({ id: createId("error"), kind: "error", text: stringifyUnknown(error) });
+        }
+        if (this.host.isRunning())
+            this.host.render();
+    }
+    async submitShellInput(text, imageCount) {
+        if (imageCount > 0) {
+            this.host.showToast("Shell stdin cannot include pasted images", "warning");
+            this.host.render();
+            return;
+        }
+        const inputEditor = this.host.inputEditor();
+        inputEditor.clear();
+        await this.host.clearPersistedInputDraft();
+        if (!this.host.sendShellInput(text))
+            this.host.showToast("No shell command is waiting for input", "info");
+        this.host.render();
+    }
+    async submitShellCommand(command, displayText, imageCount, mode) {
+        if (!command) {
+            this.host.showToast(`Enter a shell command after ${mode === "interactive" ? "!!" : "!"}`, "info");
+            this.host.render();
+            return;
+        }
+        if (imageCount > 0) {
+            this.host.showToast("Shell commands cannot include pasted images", "warning");
+            this.host.render();
+            return;
+        }
+        if (this.host.isSessionSwitching()) {
+            this.host.showToast("Wait for the tab to finish loading", "info");
+            this.host.render();
+            return;
+        }
+        const session = this.host.runtime()?.session;
+        if (session?.isStreaming || session?.isCompacting) {
+            this.host.showToast("Wait for the current session turn to finish before running shell commands", "info");
+            this.host.render();
+            return;
+        }
+        const inputEditor = this.host.inputEditor();
+        this.host.requestHistory().add(displayText);
+        inputEditor.clear();
+        await this.host.clearPersistedInputDraft();
+        this.host.setStatus(`shell: ${command}`);
+        this.host.render();
+        try {
+            if (mode === "chat") {
+                await this.host.runChatShellCommand(command);
+            }
+            else {
+                const result = await this.host.runInteractiveShellCommand(command);
+                const entryKind = result.error ? "error" : "system";
+                this.host.addEntry({ id: createId(entryKind), kind: entryKind, text: formatShellCommandEntry(command, result, "!!") });
+            }
+        }
+        catch (error) {
+            this.host.addEntry({ id: createId("error"), kind: "error", text: `Shell command failed: ${stringifyUnknown(error)}` });
+        }
+        finally {
+            this.restoreSessionState(this.host.runtime()?.session);
+        }
+        if (this.host.isRunning())
+            this.host.render();
+    }
+}