@timurproko/a1 0.1.8-dev.ece8cef → 0.2.0

package/dist/integrations/pi/components/shell-presenters-transcript.js

@@ -0,0 +1,435 @@
+import { AssistantMessageComponent, BashExecutionComponent, CompactionSummaryMessageComponent, CustomMessageComponent, DynamicBorder, getMarkdownTheme, parseSkillBlock, UserMessageComponent, } from "../startup-public.js";
+import { ToolExecutionComponent } from "./upstream/components/tool-execution.js";
+import { SkillInvocationMessageComponent } from "./upstream/components/skill-invocation-message.js";
+import { piToolArguments as toolArguments, updatePiToolResult as updateToolResult } from "./tool-result-adapter.js";
+import { createTranscriptImageResolver } from "./transcript-image-resolver.js";
+import { createMermaidMarkdownTransformer } from "./upstream/components/mermaid.js";
+import { Container, Image, Spacer, Text, } from "@earendil-works/pi-tui";
+import { PRODUCT_TEXT } from "../../../product-identity.js";
+import { createPiSubmittedPromptComponent, isPiPromptStyleCompaction, } from "./submitted-prompt-adapter.js";
+export { isPiPromptStyleCompaction, paintPiSubmittedPromptTimestamp } from "./submitted-prompt-adapter.js";
+import { PINNED_PI_LAYOUT, piTheme, } from "./theme.js";
+import { componentPort, createTuiFacade, ensureTheme, isRecord, } from "./shell-shared-facade.js";
+export function createPiShellTranscriptComponent(initial, cwd, extensions, submittedPrompt, initialOutputPad = PINNED_PI_LAYOUT.outputPad, initialHideThinkingBlock = false, initialMermaidRenderingMode = "off", initialShowImages = true, initialImageWidthCells = 80, imageAssets, presentation) {
+    ensureTheme();
+    let block = initial;
+    const retainedImages = createTranscriptImageResolver(imageAssets, initial);
+    let expanded = false;
+    let outputPad = initialOutputPad;
+    let hideThinkingBlock = initialHideThinkingBlock;
+    let mermaidRenderingMode = initialMermaidRenderingMode;
+    let showImages = initialShowImages;
+    let imageWidthCells = initialImageWidthCells;
+    let disposed = false;
+    let mount = 0;
+    let updating = false;
+    let dirty = false;
+    let presentationRevision = 0;
+    let mountedTool;
+    const mutate = (action) => {
+        const previous = updating;
+        updating = true;
+        try {
+            return action();
+        }
+        finally {
+            updating = previous;
+        }
+    };
+    const rebuild = () => {
+        mountedTool?.dispose();
+        const token = ++mount;
+        const requestRender = () => {
+            if (disposed || updating || token !== mount || dirty)
+                return;
+            dirty = true;
+            presentationRevision++;
+            presentation?.changed();
+        };
+        return mutate(() => {
+            const next = transcriptComponent(block, cwd, expanded, extensions, submittedPrompt, outputPad, hideThinkingBlock, mermaidRenderingMode, showImages, imageWidthCells, retainedImages, createTuiFacade({ getColumns: presentation?.getColumns ?? (() => 80),
+                getRows: presentation?.getRows ?? (() => 24), requestRender }));
+            mountedTool = next instanceof ToolExecutionComponent ? next : undefined;
+            return withTranscriptImages(next, block, retainedImages, showImages, imageWidthCells);
+        });
+    };
+    let component = rebuild();
+    return {
+        get id() { return block.id; },
+        get revision() { return block.revision; },
+        get presentationRevision() { return presentationRevision; },
+        render: width => {
+            dirty = false;
+            const rows = mutate(() => renderWithOutputPad(component, block.kind, width, outputPad));
+            const warning = block.toolRendering?.unavailable;
+            return warning === undefined ? rows : [...rows, ...new Text(piTheme().fg("warning", warning), outputPad, 0).render(width)];
+        },
+        invalidate: () => mutate(() => component.invalidate()),
+        dispose: () => { disposed = true; mount++; mountedTool?.dispose(); retainedImages.dispose(); },
+        update(next) {
+            if (next.id !== block.id)
+                throw new TypeError("Pi transcript component identity cannot change");
+            const previous = block;
+            block = next;
+            retainedImages.update(next);
+            if (!mutate(() => updateTranscriptComponent(component, previous, next, expanded, retainedImages)))
+                component = rebuild();
+        },
+        setExpanded(next) {
+            if (expanded === next)
+                return;
+            expanded = next;
+            if (submittedPrompt !== undefined && isPiPromptStyleCompaction(block))
+                return;
+            if ("setExpanded" in component && typeof component.setExpanded === "function")
+                mutate(() => {
+                    if ("setExpanded" in component && typeof component.setExpanded === "function")
+                        component.setExpanded(expanded);
+                });
+            else
+                component = rebuild();
+        },
+        setOutputPad(padding) {
+            if (outputPad === padding)
+                return;
+            outputPad = padding;
+            component = rebuild();
+        },
+        setHideThinkingBlock(hidden) {
+            if (hideThinkingBlock === hidden)
+                return;
+            hideThinkingBlock = hidden;
+            component = rebuild();
+        },
+        setMermaidRenderingMode(mode) {
+            if (mermaidRenderingMode === mode)
+                return;
+            mermaidRenderingMode = mode;
+            component = rebuild();
+        },
+        setImagePresentation(show, width) {
+            showImages = show;
+            imageWidthCells = width;
+            if (component instanceof ToolExecutionComponent) {
+                const tool = component;
+                mutate(() => { tool.setShowImages(show); tool.setImageWidthCells(width); });
+            }
+            else
+                component = rebuild();
+        },
+    };
+}
+function withTranscriptImages(component, block, assets, showImages, imageWidthCells) {
+    // Compatibility: Pi owns tool images and renderer state, including references introduced after the call header.
+    if (component instanceof ToolExecutionComponent)
+        return component;
+    const references = block.imageReferences ?? [];
+    if (references.length === 0)
+        return component;
+    const container = new Container();
+    container.addChild(component);
+    for (const reference of references) {
+        container.addChild(new Spacer(1));
+        const asset = assets?.resolve(reference.assetId) ?? null;
+        if (!showImages) {
+            container.addChild(new Text(piTheme().fg("muted", `[Image hidden: ${reference.mimeType}, ${reference.byteLength} bytes]`), 1, 0));
+        }
+        else if (asset === null) {
+            container.addChild(new Text(piTheme().fg("warning", `[Image unavailable: ${reference.mimeType}]`), 1, 0));
+        }
+        else {
+            container.addChild(new Image(asset.data, asset.mimeType, {
+                fallbackColor: text => piTheme().fg("muted", text),
+            }, { maxWidthCells: imageWidthCells, filename: reference.assetId }));
+        }
+    }
+    return container;
+}
+function renderWithOutputPad(component, kind, width, outputPad) {
+    const rows = component.render(width);
+    if (outputPad !== 0 || (kind !== "tool-call" && kind !== "tool-result" && kind !== "bash"))
+        return rows;
+    return rows.map(row => row.startsWith(" ") ? row.slice(1) : row);
+}
+export function renderPiShellTranscriptBlock(block, width, cwd) {
+    ensureTheme();
+    return transcriptComponent(block, cwd, true, undefined, undefined, PINNED_PI_LAYOUT.outputPad, false, "off", true, 80).render(width);
+}
+/**
+ * Pinned Pi's CLI prints startup diagnostics with `reportDiagnostics` before
+ * the banner: the whole line, prefix included, in chalk's basic ANSI severity
+ * colour — not the theme's tokens — with info lines dim and unprefixed.
+ */
+export function renderPiShellStartupDiagnostic(diagnostic, width) {
+    ensureTheme();
+    const escape = String.fromCharCode(27);
+    const chalk = diagnostic.severity === "error"
+        ? { open: `${escape}[31m`, close: `${escape}[39m`, prefix: "Error: " }
+        : diagnostic.severity === "warning"
+            ? { open: `${escape}[33m`, close: `${escape}[39m`, prefix: "Warning: " }
+            : { open: `${escape}[2m`, close: `${escape}[22m`, prefix: "" };
+    return new Text(`${chalk.open}${chalk.prefix}${diagnostic.message}${chalk.close}`, 0, 0).render(width);
+}
+/**
+ * Pinned Pi's `showPackageUpdateNotification` banner: warning-coloured dynamic
+ * borders around a bold warning title, the muted update instruction with the
+ * accent command, and the package list.
+ */
+export function renderPiShellPackageUpdateNotice(packages, width) {
+    ensureTheme();
+    const theme = piTheme();
+    const container = new Container();
+    container.addChild(new Spacer(1));
+    container.addChild(new DynamicBorder(text => theme.fg("warning", text)));
+    container.addChild(new Text(`${theme.bold(theme.fg("warning", "Package Updates Available"))}\n`
+        + `${theme.fg("muted", "Package updates are available. Run ")}${theme.fg("accent", `${PRODUCT_TEXT.commandName} pi update --extensions`)}\n`
+        + `${theme.fg("muted", "Packages:")}\n`
+        + packages.map(name => `- ${name}`).join("\n"), 1, 0));
+    container.addChild(new DynamicBorder(text => theme.fg("warning", text)));
+    return container.render(width);
+}
+function transcriptComponent(block, cwd, expanded, extensions, submittedPrompt, outputPad, hideThinkingBlock, mermaidRenderingMode, showImages, imageWidthCells, imageAssets, tui) {
+    switch (block.kind) {
+        case "user": {
+            const visibleBlock = submittedPrompt === undefined || block.userPresentation === undefined ? block
+                : { ...block, text: block.userPresentation.visibleText };
+            const skill = parseSkillBlock(visibleBlock.text);
+            if (!skill)
+                return submittedPrompt ? createPiSubmittedPromptComponent(visibleBlock, submittedPrompt) : new UserMessageComponent(visibleBlock.text);
+            const invocation = new SkillInvocationMessageComponent(skill, getMarkdownTheme());
+            invocation.setExpanded(expanded);
+            if (!skill.userMessage)
+                return invocation;
+            const container = new Container();
+            container.addChild(invocation);
+            container.addChild(new Spacer(1));
+            container.addChild(new UserMessageComponent(skill.userMessage));
+            return container;
+        }
+        case "assistant":
+        case "thinking":
+            return assistantComponent(block, outputPad, hideThinkingBlock, mermaidRenderingMode);
+        case "tool-call":
+        case "tool-result": {
+            const component = toolComponent(block, cwd, extensions, showImages, imageWidthCells, imageAssets, tui);
+            component.setExpanded(expanded);
+            return component;
+        }
+        case "compaction": {
+            if (submittedPrompt !== undefined && isPiPromptStyleCompaction(block)) {
+                const tokens = numericPayload(block, "tokensBefore").toLocaleString("en-US");
+                return createPiSubmittedPromptComponent(block, submittedPrompt, `Compacted from ${tokens} tokens`);
+            }
+            const component = new CompactionSummaryMessageComponent({
+                role: "compactionSummary",
+                summary: block.text,
+                tokensBefore: numericPayload(block, "tokensBefore"),
+                timestamp: numericPayload(block, "timestamp") || 0,
+            }, getMarkdownTheme());
+            component.setExpanded(expanded);
+            return component;
+        }
+        case "retry":
+            return new Text(piTheme().fg("warning", `Retry: ${block.text}`), outputPad, 0);
+        case "error":
+            return new Text(piTheme().fg("error", `Error: ${block.text}`), outputPad, 0);
+        case "system":
+            return new Text(piTheme().fg("dim", block.text), outputPad, 0);
+        case "custom":
+            return customMessageComponent(block, expanded, extensions, outputPad);
+        case "bash":
+            return bashExecutionComponent(block, cwd, expanded, tui);
+    }
+}
+function updateTranscriptComponent(component, previous, next, expanded, imageAssets) {
+    if (component instanceof AssistantMessageComponent && next.kind === previous.kind
+        && (next.kind === "assistant" || next.kind === "thinking")) {
+        component.updateContent(validatedAssistantMessage(next), next.status === "live");
+        return true;
+    }
+    if (component instanceof ToolExecutionComponent
+        && (next.kind === "tool-call" || next.kind === "tool-result")
+        && (previous.kind === "tool-call" || previous.kind === "tool-result")) {
+        if (toolArguments(previous) !== toolArguments(next))
+            component.updateArgs(toolArguments(next));
+        applyToolState(component, next, previous);
+        updateToolResult(component, next, imageAssets);
+        return true;
+    }
+    if (component instanceof BashExecutionComponent && next.kind === "bash" && previous.kind === "bash") {
+        if (next.text.startsWith(previous.text))
+            component.appendOutput(next.text.slice(previous.text.length));
+        else
+            return false;
+        if (next.status === "finalized")
+            completeBashComponent(component, next);
+        component.setExpanded(expanded);
+        return true;
+    }
+    if (component instanceof Text && next.kind === previous.kind
+        && (next.kind === "retry" || next.kind === "error" || next.kind === "system")) {
+        component.setText(transcriptText(next));
+        return true;
+    }
+    return false;
+}
+function assistantComponent(block, outputPad, hideThinkingBlock, mermaidRenderingMode) {
+    const transformer = createMermaidMarkdownTransformer({ getMode: () => mermaidRenderingMode, theme: piTheme() });
+    const component = new AssistantMessageComponent(undefined, hideThinkingBlock, getMarkdownTheme(), undefined, outputPad, [transformer]);
+    component.updateContent(validatedAssistantMessage(block), block.status === "live");
+    return component;
+}
+export function validatedAssistantMessage(block) {
+    const payload = blockPayload(block);
+    const content = assistantPayloadContent(payload.content)
+        ?? (block.kind === "thinking"
+            ? [{ type: "thinking", thinking: block.text }]
+            : [{ type: "text", text: block.text }]);
+    const message = {
+        role: "assistant",
+        content,
+        api: stringPayload(payload, "api") ?? "openai-responses",
+        provider: stringPayload(payload, "provider") ?? "openai",
+        model: stringPayload(payload, "model") ?? "gpt-5",
+        usage: isRecord(payload.usage) ? payload.usage : emptyUsage(),
+        stopReason: stringPayload(payload, "stopReason") ?? (block.status === "live" ? "pending" : "stop"),
+        ...(stringPayload(payload, "errorMessage") === undefined ? {} : { errorMessage: stringPayload(payload, "errorMessage") }),
+        timestamp: numericPayload(block, "timestamp") || 0,
+    };
+    if (!isPiAssistantMessage(message))
+        throw new TypeError("Pi assistant message façade rejected malformed content");
+    return message;
+}
+function isPiAssistantMessage(value) {
+    return isRecord(value) && value.role === "assistant" && Array.isArray(value.content)
+        && typeof value.api === "string" && typeof value.provider === "string" && typeof value.model === "string"
+        && isRecord(value.usage) && typeof value.stopReason === "string" && typeof value.timestamp === "number";
+}
+function assistantPayloadContent(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const content = [];
+    for (const item of value) {
+        if (!isRecord(item))
+            continue;
+        if (item.type === "text" && typeof item.text === "string")
+            content.push({ type: "text", text: item.text });
+        else if (item.type === "thinking" && typeof item.thinking === "string") {
+            content.push({ type: "thinking", thinking: item.thinking, ...(item.redacted === true ? { redacted: true } : {}) });
+        }
+        else if (item.type === "toolCall" && typeof item.id === "string" && typeof item.name === "string") {
+            content.push({ type: "toolCall", id: item.id, name: item.name, arguments: item.arguments ?? {} });
+        }
+    }
+    return content.length === 0 && value.length > 0 ? undefined : content;
+}
+function validatedToolDefinition(value) {
+    if (value === undefined)
+        return undefined;
+    if (!isPiToolDefinition(value))
+        throw new TypeError("Pi tool-definition façade rejected malformed metadata");
+    return value;
+}
+function isPiToolDefinition(value) {
+    return isRecord(value) && typeof value.name === "string";
+}
+function validatedMessageRenderer(value) {
+    if (value === undefined)
+        return undefined;
+    if (!isPiMessageRenderer(value))
+        throw new TypeError("Pi message-renderer façade rejected a non-function renderer");
+    return value;
+}
+function isPiMessageRenderer(value) {
+    return typeof value === "function";
+}
+function toolComponent(block, cwd, extensions, showImages, imageWidthCells, imageAssets, tui) {
+    const payload = blockPayload(block);
+    const toolCallId = stringPayload(payload, "toolCallId") ?? block.id;
+    const toolName = stringPayload(payload, "toolName") ?? block.title ?? "tool";
+    const argumentsPayload = toolArguments(block);
+    const component = new ToolExecutionComponent(toolName, toolCallId, argumentsPayload, { showImages, imageWidthCells }, validatedToolDefinition(extensions?.getToolDefinition(toolName)), tui ?? createTuiFacade({ getColumns: () => 80, getRows: () => 24, requestRender() { } }), cwd);
+    applyToolState(component, block);
+    updateToolResult(component, block, imageAssets);
+    return component;
+}
+/** The public renderer's argument-complete and execution-started flags are independent. */
+function applyToolState(component, block, previous) {
+    const started = (value) => value.toolState?.execution === "running"
+        || value.toolState === undefined && value.status === "live";
+    const complete = (value) => value.toolState?.argsComplete
+        ?? (value.status === "finalized" || blockPayload(value).argsComplete === true);
+    if (started(block) && (previous === undefined || !started(previous)))
+        component.markExecutionStarted();
+    if (complete(block) && (previous === undefined || !complete(previous)))
+        component.setArgsComplete();
+}
+function customMessageComponent(block, expanded, extensions, outputPad) {
+    const payload = blockPayload(block);
+    const message = {
+        role: "custom",
+        customType: stringPayload(payload, "customType") ?? block.title ?? "custom",
+        content: block.text,
+        display: payload.display !== false,
+        details: payload.details,
+        timestamp: numericPayload(block, "timestamp") || 0,
+    };
+    const renderer = validatedMessageRenderer(extensions?.getMessageRenderer(message.customType));
+    const component = new CustomMessageComponent(message, renderer, getMarkdownTheme(), outputPad);
+    component.setExpanded(expanded);
+    return component;
+}
+function bashExecutionComponent(block, cwd, expanded, tui) {
+    const payload = blockPayload(block);
+    const component = new BashExecutionComponent(stringPayload(payload, "command") ?? block.title ?? "", tui ?? createTuiFacade({ getColumns: () => 80, getRows: () => 24, requestRender() { } }), payload.excludeFromContext === true);
+    if (block.text)
+        component.appendOutput(block.text);
+    if (block.status === "finalized")
+        completeBashComponent(component, block);
+    component.setExpanded(expanded);
+    return component;
+}
+function completeBashComponent(component, block) {
+    const payload = blockPayload(block);
+    component.setComplete(typeof payload.exitCode === "number" ? payload.exitCode : undefined, payload.cancelled === true, payload.truncated === true ? {
+        content: block.text,
+        truncated: true,
+        truncatedBy: "bytes",
+        totalLines: block.text.split("\n").length,
+        totalBytes: Buffer.byteLength(block.text),
+        outputLines: block.text.split("\n").length,
+        outputBytes: Buffer.byteLength(block.text),
+        lastLinePartial: false,
+        firstLineExceedsLimit: false,
+        maxLines: 2000,
+        maxBytes: 50 * 1024,
+    } : undefined, stringPayload(payload, "fullOutputPath"));
+}
+function transcriptText(block) {
+    if (block.kind === "retry")
+        return piTheme().fg("warning", `Retry: ${block.text}`);
+    if (block.kind === "error")
+        return piTheme().fg("error", `Error: ${block.text}`);
+    return piTheme().fg("dim", block.text);
+}
+function blockPayload(block) {
+    return isRecord(block.payload) ? block.payload : {};
+}
+function stringPayload(payload, key) {
+    const value = payload[key];
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function numericPayload(block, key) {
+    const value = blockPayload(block)[key];
+    return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function emptyUsage() {
+    return {
+        input: 0,
+        output: 0,
+        cacheRead: 0,
+        cacheWrite: 0,
+        totalTokens: 0,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+    };
+}

package/dist/integrations/pi/components/shell-selectors-dialogs.d.ts

@@ -0,0 +1,134 @@
+import { ModelSelectorComponent, type SessionInfo, type SettingsCallbacks, type SettingsConfig } from "../startup-public.js";
+import type { OwnedUiDialog } from "../../../contracts/owned-ui/index.js";
+import { type ModelsDialogCallbacks, type ModelsDialogConfig } from "./models-dialog.js";
+import { type TrustDecision, type TrustOption, type TrustUpdate } from "./upstream/components/trust-selector.js";
+import { type PiShellComponentPort, type PiShellEditorOptions, type PiShellSelectorOption, type PiShellSelectorOptions } from "./shell-shared-facade.js";
+export { createPiShellSkillsSelector, type PiShellSkillsSelectorOptions } from "./skills-dialog.js";
+export declare function createPiShellSelector(options: PiShellSelectorOptions): PiShellComponentPort;
+export interface PiShellSettingsSelectorOptions {
+    readonly config: SettingsConfig;
+    readonly onChange: (callback: keyof SettingsCallbacks, value: unknown) => void;
+    readonly onCancel: () => void;
+}
+export declare function createPiShellSettingsSelector(options: PiShellSettingsSelectorOptions): PiShellComponentPort;
+type PiModelSelectorArguments = ConstructorParameters<typeof ModelSelectorComponent>;
+export interface PiShellModelSelectorOptions {
+    readonly currentModel: unknown;
+    readonly modelRuntime: unknown;
+    readonly scopedModels: readonly unknown[];
+    /** The persisted default model, when one is set. */
+    readonly defaultModel?: {
+        readonly provider: string;
+        readonly id: string;
+    };
+    readonly initialSearchInput?: string;
+    readonly runtime: Pick<PiShellEditorOptions, "getColumns" | "getRows" | "requestRender">;
+    readonly onSelect: PiModelSelectorArguments[4];
+    /** The pinned selector's "select as default" action: the model is chosen and persisted. */
+    readonly onSelectAsDefault: PiModelSelectorArguments[4];
+    readonly onCancel: () => void;
+}
+export declare function createPiShellModelSelector(options: PiShellModelSelectorOptions): PiShellComponentPort;
+export interface PiShellScopedModelDescriptor {
+    readonly provider: string;
+    readonly id: string;
+    readonly name: string;
+}
+export interface PiShellScopedModelsSelectorOptions {
+    readonly models: readonly PiShellScopedModelDescriptor[];
+    readonly enabledModelIds: readonly string[] | null;
+    readonly refreshStatus?: string;
+    readonly onChange: (enabledModelIds: readonly string[] | null) => void | Promise<void>;
+    readonly onPersist: (enabledModelIds: readonly string[] | null) => void | Promise<void>;
+    readonly onCancel: () => void;
+}
+export interface PiShellScopedModelsSelectorPort extends PiShellComponentPort {
+    updateModels(models: readonly PiShellScopedModelDescriptor[], enabledModelIds?: readonly string[] | null): void;
+    setRefreshStatus(message: string, kind: "muted" | "success" | "warning"): void;
+}
+export declare function createPiShellScopedModelsSelector(options: PiShellScopedModelsSelectorOptions): PiShellScopedModelsSelectorPort;
+export interface PiShellModelsDialogOptions extends ModelsDialogConfig, ModelsDialogCallbacks {
+}
+export interface PiShellModelsDialogPort extends PiShellComponentPort {
+    updateModels(models: readonly PiShellScopedModelDescriptor[]): void;
+    setRefreshStatus(message: string, kind: "muted" | "success" | "warning"): void;
+    readonly dirty: () => boolean;
+}
+/** The bare-A1 unified Models dialog behind the owned component boundary; the pinned selectors above stay for `a1 pi`. */
+export declare function createPiShellModelsDialog(options: PiShellModelsDialogOptions): PiShellModelsDialogPort;
+export declare function createPiShellTrustSelector(options: {
+    readonly cwd: string;
+    readonly savedDecision: TrustDecision | null;
+    readonly projectTrusted: boolean;
+    readonly trustOptions: readonly TrustOption[];
+    readonly onSelect: (selection: {
+        readonly trusted: boolean;
+        readonly updates: readonly TrustUpdate[];
+    }) => void;
+    readonly onCancel: () => void;
+}): PiShellComponentPort;
+/** Mirrors the pinned session manager's progress callback, including its partial results. */
+type SessionListProgress = (loaded: number, total: number, partialSessions?: readonly SessionInfo[]) => void;
+export declare function createPiShellSessionSelector(options: {
+    readonly currentSessionsLoader: (onProgress?: SessionListProgress) => Promise<SessionInfo[]>;
+    readonly allSessionsLoader: (onProgress?: SessionListProgress) => Promise<SessionInfo[]>;
+    readonly onSelect: (path: string) => void;
+    readonly onCancel: () => void;
+    readonly onExit: () => void;
+    readonly requestRender: () => void;
+    readonly renameSession: (sessionFilePath: string, nextName: string | undefined) => Promise<void>;
+    readonly currentSessionFilePath: string | undefined;
+}): Promise<PiShellComponentPort>;
+export declare function createPiShellTreeSelector(options: {
+    readonly tree: readonly unknown[];
+    readonly currentLeafId: string | null;
+    readonly terminalHeight: number;
+    readonly onSelect: (id: string) => void;
+    readonly onCancel: () => void;
+    readonly onLabelChange: (entryId: string, label: string | undefined) => void;
+    readonly onCopy?: (text: string | undefined) => void;
+    readonly initialSelectedId?: string;
+    readonly initialFilterMode?: "default" | "no-tools" | "user-only" | "labeled-only" | "all";
+}): Promise<PiShellComponentPort>;
+export declare function createPiShellUserMessageSelector(messages: readonly PiShellSelectorOption[], onSelect: (id: string) => void, onCancel: () => void, initialSelectedId?: string): PiShellComponentPort;
+export interface PiShellLoginDialogPort extends PiShellComponentPort {
+    showAuth(url: string, instructions?: string): void;
+    showDeviceCode(info: {
+        readonly verificationUri: string;
+        readonly userCode: string;
+    }): void;
+    showManualInput(message: string): Promise<string>;
+    showPrompt(message: string, placeholder?: string): Promise<string>;
+    showDetails(lines: readonly string[]): void;
+    showInfo(message: string, links?: readonly {
+        readonly label?: string;
+        readonly url: string;
+    }[], showCloseHint?: boolean): void;
+    showWaiting(message: string): void;
+    showProgress(message: string): void;
+}
+export declare function createPiShellLoginDialog(runtime: Pick<PiShellEditorOptions, "getColumns" | "getRows" | "requestRender">, providerId: string, onComplete: (success: boolean, message?: string) => void, providerName?: string, title?: string): PiShellLoginDialogPort;
+export declare function createPiShellArmin(runtime: Pick<PiShellEditorOptions, "getColumns" | "getRows" | "requestRender">): PiShellComponentPort;
+export declare function createPiShellDaxnuts(runtime: Pick<PiShellEditorOptions, "getColumns" | "getRows" | "requestRender">): PiShellComponentPort;
+export declare function createPiShellEarendilAnnouncement(): PiShellComponentPort;
+export interface PiShellOperationLoaderPort extends PiShellComponentPort {
+    readonly signal: AbortSignal;
+}
+export declare function createPiShellOperationLoader(runtime: Pick<PiShellEditorOptions, "getColumns" | "getRows" | "requestRender">, message: string): PiShellOperationLoaderPort;
+export declare function createPiShellReloadBox(): PiShellComponentPort;
+export interface PiShellAuthProviderOption extends PiShellSelectorOption {
+    readonly providerId: string;
+    readonly authType: "oauth" | "api_key";
+    readonly status?: {
+        readonly type: "oauth" | "api_key";
+        readonly source?: string;
+    };
+}
+export declare function createPiShellAuthProviderSelector(mode: "login" | "logout", providers: readonly PiShellAuthProviderOption[], onSelect: (id: string) => void, onCancel: () => void, initialSearchInput?: string): PiShellComponentPort;
+export declare function createPiShellExtensionSelector(title: string, options: readonly string[], onSelect: (value: string) => void, onCancel: () => void): PiShellComponentPort;
+export declare function createPiShellThemeSelector(currentTheme: string, onSelect: (theme: string) => void, onCancel: () => void, onPreview: (theme: string) => void): PiShellComponentPort;
+export declare function createPiShellShowImagesSelector(currentValue: boolean, onSelect: (show: boolean) => void, onCancel: () => void): PiShellComponentPort;
+export declare function createPiShellDialog(dialog: OwnedUiDialog, handlers?: {
+    readonly onSelect?: (id: string) => void;
+    readonly onCancel?: () => void;
+}): PiShellComponentPort;