pi-ui-extend 0.1.36 → 0.1.37

package/dist/app/app.d.ts

@@ -43,6 +43,13 @@ export declare class PiUiExtendApp {
     private readonly toastNotifier;
     private readonly extensionShutdownHandler;
     private runtime;
+    /**
+     * Maps each session runtime to the isolated extension event bus it was
+     * created with. The renderer uses this to emit signals (e.g. retry state)
+     * back to the extensions running inside a specific runtime/tab, so a signal
+     * for one tab never reaches another tab's extensions.
+     */
+    private readonly extensionEventBusByRuntime;
     private readonly inputEditor;
     private lastInputEditorContentVersion;
     private readonly requestHistory;

package/dist/app/app.js

@@ -112,6 +112,13 @@ export class PiUiExtendApp {
     };
     extensionShutdownHandler = () => { };
     runtime;
+    /**
+     * Maps each session runtime to the isolated extension event bus it was
+     * created with. The renderer uses this to emit signals (e.g. retry state)
+     * back to the extensions running inside a specific runtime/tab, so a signal
+     * for one tab never reaches another tab's extensions.
+     */
+    extensionEventBusByRuntime = new WeakMap();
     inputEditor = new InputEditor();
     lastInputEditorContentVersion = this.inputEditor.contentVersion;
     requestHistory;
@@ -166,7 +173,18 @@ export class PiUiExtendApp {
             maxProjectSessions: () => this.pixConfig.maxProjectSessions,
             blinkController: this.blinkController,
             runtime: () => this.runtime,
-            createRuntimeForNewSession: () => this.createRuntime(newTabRuntimeOptions(this.options), this.runtime === undefined ? {} : { reuseServicesFrom: this.runtime }),
+            createRuntimeForNewSession: () => this.createRuntime(
+            // Never reuse services across tabs. The SDK ties the extension
+            // runtime (resourceLoader.getExtensions().runtime) to the
+            // resourceLoader, and that runtime is shared by every session
+            // built from the same services. When any such session is
+            // disposed (tab close / session replacement / reload), the SDK
+            // invalidates that shared runtime, which makes every sibling
+            // session's captured `pi`/ctx stale — session_start handlers
+            // then throw "ctx is stale after session replacement or reload".
+            // Fresh services per session = fresh extension runtime = no
+            // cross-session invalidation.
+            newTabRuntimeOptions(this.options)),
             createRuntimeForSession: (sessionPath) => this.createRuntime({
                 ...this.options,
                 noSession: false,
@@ -373,6 +391,16 @@ export class PiUiExtendApp {
             setSessionActivity: (activity) => this.setSessionActivity(activity),
             updateQueuedMessageStatus: () => this.queuedMessages.updateQueuedMessageStatus(),
             flushAutoUserMessages: () => { void this.queuedMessages.flushAutoUserMessages(); },
+            emitExtensionEvent: (channel, data) => {
+                // Emit a signal to the extensions running inside the active
+                // runtime's event bus. Used to inform extensions (terminal-bell,
+                // todo) about session lifecycle state the SDK doesn't forward to
+                // them, such as auto-retry being in progress.
+                const runtime = this.runtime;
+                if (!runtime)
+                    return;
+                this.extensionEventBusByRuntime.get(runtime)?.emit(channel, data);
+            },
             prepareWorkspaceMutation: (toolName, args) => this.workspaceActions.prepareWorkspaceMutation(toolName, args),
             workspaceMutationFromToolExecution: (input) => this.workspaceActions.workspaceMutationFromToolExecution(input),
             recordWorkspaceMutationForUserEntry: (entryId, mutation) => this.workspaceActions.recordWorkspaceMutationForUserEntry(entryId, mutation),
@@ -522,10 +550,8 @@ export class PiUiExtendApp {
             setSessionStatus: (session) => this.setSessionStatus(session),
             showToast: (message, kind) => this.showToast(message, kind),
             render: () => this.render(),
-            resetSessionView: () => this.resetSessionView(),
             awaitCurrentSessionExtensions: (runtime) => this.awaitCurrentSessionExtensions(runtime),
-            bindCurrentSession: () => this.bindCurrentSession(),
-            loadSessionHistory: () => this.loadSessionHistory(),
+            afterSessionReplacement: (message) => this.afterSessionReplacement(message),
             scrollToConversationEntry: (entryId) => this.scrollController.scrollToConversationEntry(entryId),
             scrollToUserMessageJumpTarget: (target) => this.scrollToUserMessageJumpTarget(target),
         }, this.popupMenus, this.commandController, this.menuItems, this.queuedMessages, this.workspaceActions);
@@ -768,10 +794,16 @@ export class PiUiExtendApp {
         this.slashCommands = this.commandController.slashCommands;
     }
     createRuntime(options, runtimeOptions = {}) {
+        const eventBus = this.createExtensionEventBus();
         return createPixRuntime(options, {
-            eventBus: this.createExtensionEventBus(),
+            eventBus,
             config: this.pixConfig,
             ...runtimeOptions,
+        }).then((runtime) => {
+            // Record the bus this runtime's extensions use, so the renderer can
+            // emit signals (retry state, etc.) targeted at this runtime's extensions.
+            this.extensionEventBusByRuntime.set(runtime, eventBus);
+            return runtime;
         });
     }
     async loadStartupConfig() {
@@ -837,6 +869,9 @@ export class PiUiExtendApp {
         runtime.setRebindSession(async () => {
             await this.bindCurrentSession({ awaitExtensions: false });
         });
+        runtime.setBeforeSessionInvalidate(() => {
+            this.extensionUiController.clearWidgets(this.activeExtensionUiScope());
+        });
         await this.bindCurrentSession(options);
     }
     createExtensionEventBus() {

package/dist/app/commands/command-controller.js

@@ -49,6 +49,7 @@ export class AppCommandController {
             runReloadCommand: () => this.sessionActions.runReloadCommand(),
             runNewSessionCommand: () => this.sessionActions.runNewSessionCommand(),
             runNewTabCommand: () => this.host.openNewTab(),
+            runDeleteCommand: (argumentsText) => this.sessionActions.runDeleteCommand(argumentsText),
             runCompactCommand: (customInstructions) => this.sessionActions.runCompactCommand(customInstructions),
             runForkCommand: (argumentsText) => this.navigationActions.runForkCommand(argumentsText),
             runCloneCommand: () => this.navigationActions.runCloneCommand(),

package/dist/app/commands/command-registry.d.ts

@@ -33,6 +33,7 @@ export type CommandRegistryActions = {
     runResumeCommand(): Promise<void>;
     runNewSessionCommand(): Promise<void>;
     runNewTabCommand(): Promise<void>;
+    runDeleteCommand(argumentsText: string): Promise<void>;
     runCompactCommand(customInstructions?: string): Promise<void>;
 };
 export declare function createSlashCommands(actions: CommandRegistryActions, host: CommandControllerHost): readonly SlashCommand[];

package/dist/app/commands/command-registry.js

@@ -247,6 +247,14 @@ export function createSlashCommands(actions, host) {
             keywords: ["tab", "session", "fresh", "new"],
             run: () => actions.runNewTabCommand(),
         },
+        {
+            name: "delete",
+            description: "Delete the current (or specified) session file plus its sidecar DCP state",
+            kind: "builtin",
+            keywords: ["remove", "destroy", "purge", "session", "sidecar", "dcp"],
+            allowArguments: true,
+            run: (argumentsText) => actions.runDeleteCommand(argumentsText),
+        },
         {
             name: "compact",
             description: "Manually compact the session context",

package/dist/app/commands/command-session-actions.d.ts

@@ -14,6 +14,8 @@ export declare class SessionCommandActions {
     runUpdateCommand(argumentsText: string): Promise<void>;
     runHotkeysCommand(): Promise<void>;
     runReloadCommand(): Promise<void>;
+    runDeleteCommand(argumentsText: string): Promise<void>;
+    private removeDcpSidecarState;
     runNewSessionCommand(): Promise<void>;
     runCompactCommand(customInstructions?: string): Promise<void>;
     private piPackageRoot;

package/dist/app/commands/command-session-actions.js

@@ -1,6 +1,6 @@
 import { randomUUID } from "node:crypto";
 import { mkdir, readFile, rm } from "node:fs/promises";
-import { dirname, join, resolve } from "node:path";
+import { basename, dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { getAgentDir } from "@earendil-works/pi-coding-agent";
 import { getIdleRuntime, getRuntime, parsePathArgument } from "./command-runtime.js";
@@ -272,6 +272,79 @@ export class SessionCommandActions {
             this.host.toast.error("Reload failed");
         }
     }
+    async runDeleteCommand(argumentsText) {
+        const runtime = getIdleRuntime(this.host, "delete");
+        if (!runtime)
+            return;
+        const sessionManager = runtime.session.sessionManager;
+        const currentSessionFile = sessionManager.getSessionFile();
+        const currentSessionId = sessionManager.getSessionId();
+        const targetArgument = argumentsText.trim();
+        const isCurrent = !targetArgument;
+        const targetSessionFile = targetArgument ? resolve(runtime.cwd, targetArgument) : currentSessionFile;
+        if (!targetSessionFile) {
+            this.host.addEntry({ id: createId("system"), kind: "system", text: "Nothing to delete: this session is in-memory and not persisted." });
+            this.host.toast.info("Nothing to delete");
+            this.host.setSessionStatus(runtime.session);
+            return;
+        }
+        const targetSessionId = parseSessionIdFromFileName(targetSessionFile) ?? currentSessionId;
+        const confirm = await this.host.showMenu([
+            {
+                value: true,
+                label: `Yes, delete ${isCurrent ? "the current session" : basename(targetSessionFile)}`,
+                description: "This permanently removes the session file and any sidecar data. This cannot be undone.",
+                variant: "error",
+            },
+            { value: false, label: "Cancel" },
+        ], { title: "Delete session?", searchable: false, preserveStatus: true });
+        if (confirm !== true) {
+            this.host.addEntry({ id: createId("system"), kind: "system", text: "Delete cancelled." });
+            this.host.setSessionStatus(runtime.session);
+            return;
+        }
+        this.host.setStatus("deleting session");
+        this.host.render();
+        const sidecarRemoved = await this.removeDcpSidecarState(dirname(targetSessionFile), targetSessionId).catch(() => false);
+        await rm(targetSessionFile, { force: true }).catch(() => undefined);
+        const deleteCurrent = isCurrent || targetSessionFile === currentSessionFile;
+        if (deleteCurrent) {
+            await this.host.awaitCurrentSessionExtensions(runtime);
+            const result = await runtime.newSession();
+            if (result.cancelled) {
+                this.host.addEntry({ id: createId("system"), kind: "system", text: "Delete succeeded, but new session was cancelled." });
+                this.host.setSessionStatus(runtime.session);
+                return;
+            }
+            this.host.resetSessionView();
+            this.host.loadSessionHistory();
+            this.host.addEntry({
+                id: createId("system"),
+                kind: "system",
+                text: `Deleted session ${targetSessionId}. ${sidecarRemoved ? "Sidecar DCP state removed. " : ""}Started a new session. cwd=${runtime.cwd}`,
+            });
+            if (runtime.modelFallbackMessage)
+                this.host.addEntry({ id: createId("system"), kind: "system", text: runtime.modelFallbackMessage });
+            this.host.setSessionStatus(runtime.session);
+        }
+        else {
+            this.host.addEntry({
+                id: createId("system"),
+                kind: "system",
+                text: `Deleted session file ${targetSessionFile}${sidecarRemoved ? " and its sidecar DCP state" : ""}.`,
+            });
+            this.host.setSessionStatus(runtime.session);
+        }
+        this.host.toast.success("Session deleted");
+    }
+    async removeDcpSidecarState(sessionDir, sessionId) {
+        if (!sessionId)
+            return false;
+        const safeName = `${sessionId.replace(/[^a-zA-Z0-9._-]/g, "_")}.json`;
+        const statePath = join(sessionDir, "dcp-state", safeName);
+        await rm(statePath, { force: true });
+        return true;
+    }
     async runNewSessionCommand() {
         const runtime = getIdleRuntime(this.host, "new");
         if (!runtime)
@@ -336,3 +409,8 @@ function splitUpdateArguments(argumentsText) {
     const trimmed = argumentsText.trim();
     return trimmed ? trimmed.split(/\s+/u) : [];
 }
+function parseSessionIdFromFileName(sessionFile) {
+    const base = basename(sessionFile).replace(/\.jsonl$/iu, "");
+    const separator = base.indexOf("_");
+    return separator >= 0 ? base.slice(separator + 1) : undefined;
+}

package/dist/app/extensions/extension-actions-controller.d.ts

@@ -1,4 +1,5 @@
 import type { AgentSessionRuntime, ExtensionCommandContextActions, ExtensionError } from "@earendil-works/pi-coding-agent";
+import { type PixLogDetails, type PixLogLevel } from "../logger.js";
 import type { Entry } from "../types.js";
 export type AppExtensionActionsHost = {
     isRunning(): boolean;
@@ -14,9 +15,11 @@ export type AppExtensionActionsHost = {
     showToast(message: string, kind: "success" | "error" | "warning" | "info"): void;
     render(): void;
 };
+export type ExtensionErrorLogger = (level: PixLogLevel, event: string, details?: PixLogDetails) => void;
 export declare class AppExtensionActionsController {
     private readonly host;
-    constructor(host: AppExtensionActionsHost);
+    private readonly logExtensionError;
+    constructor(host: AppExtensionActionsHost, logExtensionError?: ExtensionErrorLogger);
     createCommandContextActions(runtime: AgentSessionRuntime): ExtensionCommandContextActions;
     waitForSessionIdle(runtime: AgentSessionRuntime): Promise<void>;
     handleExtensionError(error: ExtensionError): void;

package/dist/app/extensions/extension-actions-controller.js

@@ -1,8 +1,12 @@
+import { basename } from "node:path";
 import { createId } from "../id.js";
+import { logPixEvent } from "../logger.js";
 export class AppExtensionActionsController {
     host;
-    constructor(host) {
+    logExtensionError;
+    constructor(host, logExtensionError = logPixEvent) {
         this.host = host;
+        this.logExtensionError = logExtensionError;
     }
     createCommandContextActions(runtime) {
         return {
@@ -55,10 +59,35 @@ export class AppExtensionActionsController {
         }
     }
     handleExtensionError(error) {
+        const sourceText = formatExtensionErrorSource(error.extensionPath);
         const pathText = error.extensionPath ? ` (${error.extensionPath})` : "";
-        this.host.addEntry({ id: createId("error"), kind: "error", text: `Extension ${error.event} failed${pathText}: ${error.error}` });
+        this.logExtensionError("error", "extension:error", extensionErrorLogDetails(error));
+        this.host.addEntry({
+            id: createId("error"),
+            kind: "error",
+            text: `Extension ${error.event} failed${sourceText}${pathText}: ${error.error}`,
+        });
         this.host.showToast(`Extension ${error.event} failed`, "error");
         if (this.host.isRunning())
             this.host.render();
     }
 }
+function formatExtensionErrorSource(extensionPath) {
+    if (!extensionPath)
+        return "";
+    const extensionName = basename(extensionPath);
+    return extensionName && extensionName !== extensionPath ? ` [${extensionName}]` : "";
+}
+function extensionErrorLogDetails(error) {
+    const details = {
+        event: error.event,
+        error: error.error,
+    };
+    if (error.extensionPath) {
+        details.extensionPath = error.extensionPath;
+        details.extensionName = basename(error.extensionPath);
+    }
+    if (error.stack)
+        details.stack = error.stack;
+    return details;
+}

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

@@ -47,6 +47,7 @@ export declare class AppInputController {
     private consumeTerminalEditShortcutSequence;
     private consumeIgnoredModifiedKeySequence;
     private consumeModifiedArrowKeySequence;
+    private consumeEscapeKeySequence;
     private consumeClipboardImagePasteSequence;
     private consumeShiftEnterSequence;
     private consumeTerminalInterruptSequence;

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

@@ -1,6 +1,6 @@
 import { InputPasteHandler } from "./input-paste-handler.js";
 import { hasTerminalCommandModifier, isNativeCommandPressed, isNativeShiftPressed } from "./native-modifiers.js";
-import { parseTerminalEditShortcutSequence, parseTerminalInterruptSequence, parseTerminalModifiedKeySequence, terminalKeyArrowDirection, terminalEditShortcutForControlChar, terminalKeyIsClipboardImagePaste, terminalKeyIsShiftEnter, terminalKeyShouldIgnore, } from "./terminal-edit-shortcuts.js";
+import { parseTerminalEditShortcutSequence, parseTerminalInterruptSequence, parseTerminalModifiedKeySequence, terminalKeyArrowDirection, terminalEditShortcutForControlChar, terminalKeyIsClipboardImagePaste, terminalKeyIsEscape, terminalKeyIsShiftEnter, terminalKeyShouldIgnore, } from "./terminal-edit-shortcuts.js";
 const SHIFT_ENTER_ESCAPE_SEQUENCES = ["\x1b\r", "\x1b\n"];
 export class AppInputController {
     host;
@@ -117,6 +117,11 @@ export class AppInputController {
                 continue;
             if (modifiedArrowKeySequence === "pending")
                 return;
+            const escapeKeySequence = this.consumeEscapeKeySequence();
+            if (escapeKeySequence === "consumed")
+                continue;
+            if (escapeKeySequence === "pending")
+                return;
             const ignoredModifiedKeySequence = this.consumeIgnoredModifiedKeySequence();
             if (ignoredModifiedKeySequence === "consumed")
                 continue;
@@ -230,7 +235,10 @@ export class AppInputController {
         }
         if (/^\x1b\[(?:8|127);\d*$/.test(this.inputBuffer))
             return "pending";
-        if (this.inputBuffer.startsWith("\x1b[27;") && !this.inputBuffer.includes("~"))
+        // modifyOtherKeys backspace looks like \x1b[27;<mod>;(8|127)~ (two semicolons, no colons).
+        // Kitty key sequences also begin with \x1b[27; (e.g. the ESC release \x1b[27;1:3u), so only
+        // treat the buffer as a pending modifyOtherKeys partial when it matches that exact shape.
+        if (/^\x1b\[27;\d+;\d*$/.test(this.inputBuffer))
             return "pending";
         return "none";
     }
@@ -304,6 +312,19 @@ export class AppInputController {
             this.handleArrowLeft();
         return "consumed";
     }
+    consumeEscapeKeySequence() {
+        const result = parseTerminalModifiedKeySequence(this.inputBuffer);
+        if (result.kind === "pending")
+            return "pending";
+        if (result.kind === "none")
+            return "none";
+        if (!terminalKeyIsEscape(result.key))
+            return "none";
+        this.inputBuffer = this.inputBuffer.slice(result.key.length);
+        if (!terminalKeyShouldIgnore(result.key))
+            void this.host.handleEscape();
+        return "consumed";
+    }
     consumeClipboardImagePasteSequence() {
         const result = parseTerminalModifiedKeySequence(this.inputBuffer);
         if (result.kind === "pending")

package/dist/app/input/terminal-edit-shortcuts.d.ts

@@ -39,6 +39,7 @@ export declare function parseTerminalInterruptSequence(input: string): {
 export declare function terminalKeyIsShiftEnter(key: ParsedModifiedKey): boolean;
 export declare function terminalKeyIsClipboardImagePaste(key: ParsedModifiedKey): boolean;
 export declare function terminalKeyShouldIgnore(key: ParsedModifiedKey): boolean;
+export declare function terminalKeyIsEscape(key: ParsedModifiedKey): boolean;
 export declare function terminalKeyArrowDirection(key: ParsedModifiedKey): "up" | "down" | "right" | "left" | undefined;
 export declare function terminalEditShortcutForControlChar(char: string, shiftPressed: boolean): TerminalEditShortcut | undefined;
 export {};

package/dist/app/input/terminal-edit-shortcuts.js

@@ -4,6 +4,7 @@ const COMMAND_MODIFIER_FLAG = 8;
 const LOCK_MODIFIER_MASK = 64 + 128;
 const KEY_CODE_C = 99;
 const KEY_CODE_ENTER = 13;
+const KEY_CODE_ESCAPE = 27;
 const KEY_CODE_V = 118;
 const KEY_CODE_Y = 121;
 const KEY_CODE_Z = 122;
@@ -67,6 +68,12 @@ export function terminalKeyIsClipboardImagePaste(key) {
 export function terminalKeyShouldIgnore(key) {
     return key.eventType === 3;
 }
+export function terminalKeyIsEscape(key) {
+    const effectiveModifier = key.modifier & ~LOCK_MODIFIER_MASK;
+    if (effectiveModifier !== 0)
+        return false;
+    return key.codepoint === KEY_CODE_ESCAPE;
+}
 export function terminalKeyArrowDirection(key) {
     const effectiveModifier = key.modifier & ~LOCK_MODIFIER_MASK;
     if (effectiveModifier !== 0)

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

@@ -66,7 +66,7 @@ export class AppVoiceController {
             case "installing":
                 return `${APP_ICONS.microphone}${languageLabel} ${APP_ICONS.timerSand}`;
             case "downloading":
-                return `${APP_ICONS.down}${languageLabel}`;
+                return `${APP_ICONS.microphone}${languageLabel} ${APP_ICONS.timerSand}`;
             case "loading":
                 return `${APP_ICONS.microphone}${languageLabel} ${APP_ICONS.timerSand}`;
             case "listening":

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

@@ -16,9 +16,7 @@ export type AppPopupActionControllerHost = {
     setSessionStatus(session: AgentSession | undefined): void;
     showToast(message: string, kind: "success" | "error" | "warning" | "info"): void;
     render(): void;
-    resetSessionView(): void;
-    bindCurrentSession(): Promise<void>;
-    loadSessionHistory(): void;
+    afterSessionReplacement(message?: string): void;
     scrollToConversationEntry(entryId: string): boolean;
     scrollToUserMessageJumpTarget(target: UserMessageJumpMenuValue): Promise<boolean>;
 };

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

@@ -236,12 +236,8 @@ export class AppPopupActionController {
                 this.host.render();
                 return true;
             }
-            this.host.resetSessionView();
-            await this.host.bindCurrentSession();
-            this.host.loadSessionHistory();
             const name = runtime.session.sessionName ?? session.id.slice(0, 8);
-            this.host.addEntry({ id: createId("system"), kind: "system", text: `Resumed session "${name}"` });
-            this.host.setSessionStatus(runtime.session);
+            this.host.afterSessionReplacement(`Resumed session "${name}"`);
         }
         catch (error) {
             this.host.addEntry({ id: createId("error"), kind: "error", text: `Resume failed: ${error instanceof Error ? error.message : String(error)}` });

package/dist/app/rendering/message-content.js

@@ -1,3 +1,4 @@
+import { stripDcpControlMetadata } from "../../markdown-format.js";
 import { isRecord } from "../guards.js";
 const MAX_FORMAT_STRING_CHARS = 256 * 1024;
 const MAX_RENDERED_CONTENT_CHARS = 512 * 1024;
@@ -79,11 +80,11 @@ export function renderContent(content) {
         if (!pushPart(stringifyUnknown(item)))
             break;
     }
-    return parts.join("\n");
+    return stripDcpControlMetadata(parts.join("\n"));
 }
 export function renderUserMessageContent(content) {
     if (typeof content === "string")
-        return content;
+        return stripDcpControlMetadata(content);
     if (!Array.isArray(content))
         return stringifyUnknown(content);
     const textParts = [];
@@ -103,7 +104,7 @@ export function renderUserMessageContent(content) {
         }
         textParts.push(stringifyUnknown(item));
     }
-    const text = textParts.join("\n").replace(/\[Image \d+(?:: [^\]]+)?\]/g, "").trimEnd();
+    const text = stripDcpControlMetadata(textParts.join("\n")).replace(/\[Image \d+(?:: [^\]]+)?\]/g, "").trimEnd();
     if (imageCount === 0)
         return text;
     const imageText = userImageLabels(imageCount);