pi-ui-extend 0.1.70 → 0.1.71

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

@@ -3,6 +3,7 @@ import { mkdir, readFile, rm } from "node:fs/promises";
 import { basename, dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import { captureCommandScope, isCommandRuntimeActive, isCommandScopeActive, } from "./command-host.js";
 import { getIdleRuntime, getRuntime, parsePathArgument } from "./command-runtime.js";
 import { createId } from "../id.js";
 import { runProcess } from "../process.js";
@@ -22,6 +23,7 @@ export class SessionCommandActions {
         const runtime = getIdleRuntime(this.host, "export");
         if (!runtime)
             return;
+        const scope = captureCommandScope(this.host);
         const outputPath = parsePathArgument(argumentsText);
         const resolvedOutputPath = outputPath ? resolve(runtime.cwd, outputPath) : undefined;
         this.host.setStatus("exporting session");
@@ -29,6 +31,8 @@ export class SessionCommandActions {
         const filePath = resolvedOutputPath?.endsWith(".jsonl")
             ? runtime.session.exportToJsonl(resolvedOutputPath)
             : await runtime.session.exportToHtml(resolvedOutputPath);
+        if (!isCommandScopeActive(this.host, scope))
+            return;
         this.host.addEntry({ id: createId("system"), kind: "system", text: `Session exported to: ${filePath}` });
         this.host.setSessionStatus(runtime.session);
         this.host.toast.success("Session exported");
@@ -44,6 +48,8 @@ export class SessionCommandActions {
         this.host.setStatus("importing session");
         this.host.render();
         const result = await runtime.importFromJsonl(resolvedInputPath);
+        if (!isCommandRuntimeActive(this.host, runtime))
+            return;
         if (result.cancelled) {
             this.host.addEntry({ id: createId("system"), kind: "system", text: "Import cancelled." });
             this.host.setSessionStatus(runtime.session);
@@ -55,17 +61,26 @@ export class SessionCommandActions {
         const runtime = getIdleRuntime(this.host, "share");
         if (!runtime)
             return;
+        const scope = captureCommandScope(this.host);
         const authResult = await runProcess("gh", ["auth", "status"], { maxBufferBytes: 32 * 1024 });
+        if (!isCommandScopeActive(this.host, scope))
+            return;
         if (authResult.status !== 0)
             throw new Error("GitHub CLI is not installed or is not logged in. Run `gh auth login` first.");
         const shareDir = join(getAgentDir(), "pix");
         await mkdir(shareDir, { recursive: true });
+        if (!isCommandScopeActive(this.host, scope))
+            return;
         const tmpFile = join(shareDir, `session-share-${randomUUID()}.html`);
         try {
             this.host.setStatus("creating share gist");
             this.host.render();
             await runtime.session.exportToHtml(tmpFile);
+            if (!isCommandScopeActive(this.host, scope))
+                return;
             const gistResult = await runProcess("gh", ["gist", "create", "--public=false", tmpFile], { maxBufferBytes: 64 * 1024 });
+            if (!isCommandScopeActive(this.host, scope))
+                return;
             if (gistResult.status !== 0)
                 throw new Error(gistResult.stderr?.trim() || "Failed to create gist");
             const gistUrl = gistResult.stdout.trim();
@@ -81,10 +96,13 @@ export class SessionCommandActions {
         const runtime = getRuntime(this.host, "copy");
         if (!runtime)
             return;
+        const scope = captureCommandScope(this.host);
         const text = runtime.session.getLastAssistantText();
         if (!text)
             throw new Error("No agent messages to copy yet");
         await copyTextToClipboard(text);
+        if (!isCommandScopeActive(this.host, scope))
+            return;
         this.host.addEntry({ id: createId("system"), kind: "system", text: "Copied last agent message to clipboard." });
         this.host.setSessionStatus(runtime.session);
         this.host.toast.success("Copied last agent message");
@@ -103,6 +121,7 @@ export class SessionCommandActions {
             return;
         const name = argumentsText.trim();
         if (!name) {
+            const scope = captureCommandScope(this.host);
             const branch = runtime.session.sessionManager.getBranch();
             const firstPrompt = firstUserMessageText(branch);
             if (!firstPrompt)
@@ -117,6 +136,8 @@ export class SessionCommandActions {
                 for (const modelRef of modelRefs) {
                     for (let attempt = 0; attempt < config.generationAttempts; attempt++) {
                         generatedName = await generateSessionTitleWithRuntime(firstPrompt.slice(0, config.maxInputChars).trim(), runtime.services.modelRuntime, config, modelRef, AbortSignal.timeout(config.timeoutMs));
+                        if (!isCommandScopeActive(this.host, scope))
+                            return;
                         if (generatedName)
                             break;
                     }
@@ -142,7 +163,10 @@ export class SessionCommandActions {
         const runtime = getRuntime(this.host, "session");
         if (!runtime)
             return;
+        const scope = captureCommandScope(this.host);
         const stats = await getCompleteSessionStats(runtime.session);
+        if (!isCommandScopeActive(this.host, scope))
+            return;
         const lines = [
             createStartupInfoMessage(runtime),
             "",
@@ -173,9 +197,12 @@ export class SessionCommandActions {
         const runtime = getRuntime(this.host, "usage");
         if (!runtime)
             return;
+        const scope = captureCommandScope(this.host);
         this.host.setStatus("loading usage");
         this.host.render();
         const accountReport = await queryAccountUsageReport();
+        if (!isCommandScopeActive(this.host, scope))
+            return;
         const accountUsage = formatAccountUsageReport(accountReport);
         if (accountUsage) {
             this.host.addEntry({ id: createId("system"), kind: "system", text: accountUsage });
@@ -183,6 +210,8 @@ export class SessionCommandActions {
             return;
         }
         const stats = await getCompleteSessionStats(runtime.session);
+        if (!isCommandScopeActive(this.host, scope))
+            return;
         const contextUsage = stats.contextUsage ?? runtime.session.getContextUsage();
         const model = runtime.session.model ? this.host.modelRef(runtime.session.model) : "not selected";
         const lines = [
@@ -204,8 +233,11 @@ export class SessionCommandActions {
         this.host.setSessionStatus(runtime.session);
     }
     async runChangelogCommand() {
+        const scope = captureCommandScope(this.host);
         const changelogPath = join(this.piPackageRoot(), "CHANGELOG.md");
         const raw = await readFile(changelogPath, "utf8");
+        if (!isCommandScopeActive(this.host, scope))
+            return;
         const lines = raw.trim().split(/\r?\n/).slice(0, 140);
         this.host.addEntry({ id: createId("system"), kind: "system", text: lines.join("\n") });
         this.host.setSessionStatus(this.host.runtime()?.session);
@@ -214,6 +246,7 @@ export class SessionCommandActions {
         const runtime = getRuntime(this.host, "update");
         if (!runtime)
             return;
+        const scope = captureCommandScope(this.host);
         const options = parsePixUpdateArgs(splitUpdateArguments(argumentsText));
         if (options.help) {
             this.host.addEntry({ id: createId("system"), kind: "system", text: pixUpdateUsage() });
@@ -223,6 +256,8 @@ export class SessionCommandActions {
         this.host.setStatus("checking updates");
         this.host.render();
         const result = await checkPixUpdate();
+        if (!isCommandScopeActive(this.host, scope))
+            return;
         const globalPiResult = checkGlobalPiInstall(result.packageRoot);
         const forceHint = options.force ? "\n\n/update is check-only. To force a reinstall, run `pix update --force` in your shell and restart Pix." : "";
         this.host.addEntry({
@@ -263,16 +298,23 @@ export class SessionCommandActions {
         const runtime = getIdleRuntime(this.host, "reload");
         if (!runtime)
             return;
+        const scope = captureCommandScope(this.host);
         this.host.setStatus("reloading");
         this.host.render();
         try {
             await this.host.awaitCurrentSessionExtensions(runtime);
+            if (!isCommandScopeActive(this.host, scope))
+                return;
             await runtime.session.reload();
+            if (!isCommandScopeActive(this.host, scope))
+                return;
             this.host.setSessionStatus(runtime.session);
             this.host.addEntry({ id: createId("system"), kind: "system", text: "Reloaded keybindings, extensions, skills, prompts, themes" });
             this.host.toast.success("Reloaded resources");
         }
         catch (error) {
+            if (!isCommandScopeActive(this.host, scope))
+                return;
             this.host.setSessionStatus(runtime.session);
             this.host.addEntry({ id: createId("error"), kind: "error", text: `Reload failed: ${error instanceof Error ? error.message : String(error)}` });
             this.host.toast.error("Reload failed");
@@ -282,6 +324,7 @@ export class SessionCommandActions {
         const runtime = getIdleRuntime(this.host, "delete");
         if (!runtime)
             return;
+        const scope = captureCommandScope(this.host);
         const sessionManager = runtime.session.sessionManager;
         const currentSessionFile = sessionManager.getSessionFile();
         const currentSessionId = sessionManager.getSessionId();
@@ -304,6 +347,8 @@ export class SessionCommandActions {
             },
             { value: false, label: "Cancel" },
         ], { title: "Delete session?", searchable: false, preserveStatus: true });
+        if (!isCommandScopeActive(this.host, scope))
+            return;
         if (confirm !== true) {
             this.host.addEntry({ id: createId("system"), kind: "system", text: "Delete cancelled." });
             this.host.setSessionStatus(runtime.session);
@@ -317,6 +362,8 @@ export class SessionCommandActions {
         if (deleteCurrent) {
             await this.host.awaitCurrentSessionExtensions(runtime);
             const result = await runtime.newSession();
+            if (!isCommandRuntimeActive(this.host, runtime))
+                return;
             if (result.cancelled) {
                 this.host.addEntry({ id: createId("system"), kind: "system", text: "Delete succeeded, but new session was cancelled." });
                 this.host.setSessionStatus(runtime.session);
@@ -334,6 +381,8 @@ export class SessionCommandActions {
             this.host.setSessionStatus(runtime.session);
         }
         else {
+            if (!isCommandScopeActive(this.host, scope))
+                return;
             this.host.addEntry({
                 id: createId("system"),
                 kind: "system",
@@ -358,7 +407,11 @@ export class SessionCommandActions {
         this.host.setStatus("starting new session");
         this.host.render();
         await this.host.awaitCurrentSessionExtensions(runtime);
+        if (!isCommandRuntimeActive(this.host, runtime))
+            return;
         const result = await runtime.newSession();
+        if (!isCommandRuntimeActive(this.host, runtime))
+            return;
         if (result.cancelled) {
             this.host.addEntry({ id: createId("system"), kind: "system", text: "New session cancelled." });
             this.host.setSessionStatus(runtime.session);
@@ -378,6 +431,7 @@ export class SessionCommandActions {
         const runtime = getRuntime(this.host, "compact");
         if (!runtime)
             return;
+        const scope = captureCommandScope(this.host);
         if (runtime.session.isCompacting) {
             this.host.toast.warning("Compaction already running");
             return;
@@ -385,6 +439,8 @@ export class SessionCommandActions {
         this.host.setStatus(customInstructions ? "compacting with instructions" : "compacting");
         this.host.render();
         const result = await runtime.session.compact(customInstructions);
+        if (!isCommandScopeActive(this.host, scope))
+            return;
         this.host.addEntry({
             id: createId("system"),
             kind: "system",

package/dist/app/commands/shell-controller.d.ts

@@ -1,8 +1,12 @@
-import { type InteractiveShellCommandResult } from "./shell-command.js";
+import { type ChatShellCommandHandlers, type InteractiveShellCommandResult, type RunningChatShellCommand } from "./shell-command.js";
 import type { Entry, SessionActivity } from "../types.js";
+type AppShellControllerDeps = {
+    runChatShellCommand(command: string, cwd: string, handlers: ChatShellCommandHandlers): RunningChatShellCommand;
+};
 export type AppShellControllerHost = {
     readonly cwd: string;
     isRunning(): boolean;
+    activeScopeKey(): string | undefined;
     addEntry(entry: Entry): void;
     touchEntry(entry: Entry): void;
     setStatus(status: string): void;
@@ -13,9 +17,10 @@ export type AppShellControllerHost = {
 };
 export declare class AppShellController {
     private readonly host;
+    private readonly deps;
     private activeRun;
     private renderTimer;
-    constructor(host: AppShellControllerHost);
+    constructor(host: AppShellControllerHost, deps?: AppShellControllerDeps);
     isRunning(): boolean;
     run(command: string): Promise<InteractiveShellCommandResult>;
     sendInput(text: string): boolean;
@@ -26,4 +31,6 @@ export declare class AppShellController {
     private finishEntry;
     private touchAndScheduleRender;
     private flushRender;
+    private isScopeActive;
 }
+export {};

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

@@ -1,19 +1,23 @@
 import { createId } from "../id.js";
-import { runChatShellCommand } from "./shell-command.js";
+import { runChatShellCommand, } from "./shell-command.js";
 const SHELL_RENDER_THROTTLE_MS = 33;
+const defaultDeps = { runChatShellCommand };
 export class AppShellController {
     host;
+    deps;
     activeRun;
     renderTimer;
-    constructor(host) {
+    constructor(host, deps = defaultDeps) {
         this.host = host;
+        this.deps = deps;
     }
     isRunning() {
-        return this.activeRun !== undefined;
+        return this.activeRun !== undefined && this.isScopeActive(this.activeRun.scopeKey);
     }
     async run(command) {
         if (this.activeRun)
             throw new Error("A shell command is already running");
+        const scopeKey = this.host.activeScopeKey();
         const entry = {
             id: createId("shell"),
             kind: "shell",
@@ -26,11 +30,11 @@ export class AppShellController {
         this.host.setStatus(`shell: ${command}`);
         this.host.setSessionActivity("running");
         this.host.render();
-        const runningCommand = runChatShellCommand(command, this.host.cwd, {
-            onOutput: (chunk) => this.appendOutput(entry, chunk),
-            onSettled: (result) => this.finishEntry(entry, result),
+        const runningCommand = this.deps.runChatShellCommand(command, this.host.cwd, {
+            onOutput: (chunk) => this.appendOutput(entry, chunk, scopeKey),
+            onSettled: (result) => this.finishEntry(entry, result, scopeKey),
         });
-        this.activeRun = { entry, command: runningCommand };
+        this.activeRun = { entry, command: runningCommand, scopeKey };
         try {
             return await runningCommand.done;
         }
@@ -38,24 +42,26 @@ export class AppShellController {
             if (this.activeRun?.entry === entry)
                 this.activeRun = undefined;
             this.flushRender();
-            this.host.restoreSessionStatus();
-            if (this.host.isRunning())
-                this.host.render();
+            if (this.isScopeActive(scopeKey)) {
+                this.host.restoreSessionStatus();
+                if (this.host.isRunning())
+                    this.host.render();
+            }
         }
     }
     sendInput(text) {
         const activeRun = this.activeRun;
-        if (!activeRun)
+        if (!activeRun || !this.isScopeActive(activeRun.scopeKey))
             return false;
         const input = text.endsWith("\n") ? text : `${text}\n`;
-        this.appendInputEcho(activeRun.entry, input);
+        this.appendInputEcho(activeRun.entry, input, activeRun.scopeKey);
         return activeRun.command.writeInput(input);
     }
     interrupt() {
         const activeRun = this.activeRun;
-        if (!activeRun)
+        if (!activeRun || !this.isScopeActive(activeRun.scopeKey))
             return false;
-        this.appendOutput(activeRun.entry, "\n^C\n");
+        this.appendOutput(activeRun.entry, "\n^C\n", activeRun.scopeKey);
         return activeRun.command.interrupt();
     }
     dispose() {
@@ -66,23 +72,25 @@ export class AppShellController {
         this.activeRun = undefined;
         activeRun?.command.kill("SIGTERM");
     }
-    appendOutput(entry, chunk) {
+    appendOutput(entry, chunk, scopeKey) {
         entry.output = appendTerminalChunk(entry.output, chunk);
-        this.touchAndScheduleRender(entry);
+        this.touchAndScheduleRender(entry, scopeKey);
     }
-    appendInputEcho(entry, input) {
+    appendInputEcho(entry, input, scopeKey) {
         entry.output = appendTerminalChunk(entry.output, formatInputEcho(input));
-        this.touchAndScheduleRender(entry);
+        this.touchAndScheduleRender(entry, scopeKey);
     }
-    finishEntry(entry, result) {
+    finishEntry(entry, result, scopeKey) {
         entry.status = "done";
         entry.exitCode = result.exitCode;
         entry.signal = result.signal;
         if (result.error)
             entry.error = result.error;
-        this.touchAndScheduleRender(entry);
+        this.touchAndScheduleRender(entry, scopeKey);
     }
-    touchAndScheduleRender(entry) {
+    touchAndScheduleRender(entry, scopeKey) {
+        if (!this.isScopeActive(scopeKey))
+            return;
         this.host.touchEntry(entry);
         if (!this.host.isRunning() || this.renderTimer)
             return;
@@ -99,6 +107,9 @@ export class AppShellController {
         clearTimeout(this.renderTimer);
         this.renderTimer = undefined;
     }
+    isScopeActive(scopeKey) {
+        return this.host.activeScopeKey() === scopeKey;
+    }
 }
 function appendTerminalChunk(current, chunk) {
     let next = current;

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

@@ -3,6 +3,7 @@ import { type PixLogDetails, type PixLogLevel } from "../logger.js";
 import type { Entry } from "../types.js";
 export type AppExtensionActionsHost = {
     isRunning(): boolean;
+    runtime(): AgentSessionRuntime | undefined;
     getInput(): string;
     setInput(value: string): void;
     awaitCurrentSessionExtensions(runtime?: AgentSessionRuntime): Promise<void>;
@@ -22,5 +23,7 @@ export declare class AppExtensionActionsController {
     constructor(host: AppExtensionActionsHost, logExtensionError?: ExtensionErrorLogger);
     createCommandContextActions(runtime: AgentSessionRuntime): ExtensionCommandContextActions;
     waitForSessionIdle(runtime: AgentSessionRuntime): Promise<void>;
+    private isRuntimeActive;
+    private isSessionActive;
     handleExtensionError(error: ExtensionError): void;
 }

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

@@ -13,21 +13,26 @@ export class AppExtensionActionsController {
             waitForIdle: () => this.waitForSessionIdle(runtime),
             newSession: async (options) => {
                 await this.host.awaitCurrentSessionExtensions(runtime);
+                if (!this.isRuntimeActive(runtime))
+                    return { cancelled: true };
                 const result = await runtime.newSession(options);
-                if (!result.cancelled)
+                if (!result.cancelled && this.isRuntimeActive(runtime))
                     this.host.afterSessionReplacement("Started a new session.");
                 return result;
             },
             fork: async (entryId, options) => {
                 await this.host.awaitCurrentSessionExtensions(runtime);
+                if (!this.isRuntimeActive(runtime))
+                    return { cancelled: true };
                 const result = await runtime.fork(entryId, options);
-                if (!result.cancelled)
+                if (!result.cancelled && this.isRuntimeActive(runtime))
                     this.host.afterSessionReplacement("Forked to a new session.");
                 return result;
             },
             navigateTree: async (targetId, options) => {
-                const result = await runtime.session.navigateTree(targetId, options);
-                if (!result.cancelled && !result.aborted) {
+                const session = runtime.session;
+                const result = await session.navigateTree(targetId, options);
+                if (!result.cancelled && !result.aborted && this.isSessionActive(runtime, session)) {
                     this.host.resetSessionView();
                     this.host.loadSessionHistory();
                     if (result.editorText && !this.host.getInput().trim())
@@ -39,15 +44,22 @@ export class AppExtensionActionsController {
             },
             switchSession: async (sessionPath, options) => {
                 await this.host.awaitCurrentSessionExtensions(runtime);
+                if (!this.isRuntimeActive(runtime))
+                    return { cancelled: true };
                 const result = await runtime.switchSession(sessionPath, options);
-                if (!result.cancelled)
+                if (!result.cancelled && this.isRuntimeActive(runtime))
                     this.host.afterSessionReplacement(`Switched session: ${sessionPath}`);
                 return result;
             },
             reload: async () => {
+                const session = runtime.session;
                 await this.host.awaitCurrentSessionExtensions(runtime);
-                await runtime.session.reload();
-                this.host.setSessionStatus(runtime.session);
+                if (!this.isSessionActive(runtime, session))
+                    return;
+                await session.reload();
+                if (!this.isSessionActive(runtime, session))
+                    return;
+                this.host.setSessionStatus(session);
                 this.host.showToast("Reloaded resources", "success");
                 this.host.render();
             },
@@ -56,6 +68,12 @@ export class AppExtensionActionsController {
     async waitForSessionIdle(runtime) {
         await runtime.session.waitForIdle();
     }
+    isRuntimeActive(runtime) {
+        return this.host.isRunning() && this.host.runtime() === runtime;
+    }
+    isSessionActive(runtime, session) {
+        return this.isRuntimeActive(runtime) && runtime.session === session;
+    }
     handleExtensionError(error) {
         const sourceText = formatExtensionErrorSource(error.extensionPath);
         const pathText = error.extensionPath ? ` (${error.extensionPath})` : "";

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

@@ -8,6 +8,7 @@ export type ExtensionTerminalInputResult = {
 export type ExtensionUiControllerHost = {
     readonly theme: Theme;
     activeExtensionUiScope?(): string | undefined;
+    isExtensionUiScopeActive?(scopeKey: string): boolean;
     isRunning(): boolean;
     render(): void;
     showToast(message: string, kind?: ToastKind, options?: {
@@ -38,12 +39,13 @@ export declare class ExtensionUiController {
     clearWidgets(scopeKey?: string, options?: {
         cancelCustomUi?: boolean;
     }): void;
+    cancelCustomUi(scopeKey?: string): void;
     suppressWidget(key: string): void;
     handleTerminalInput(data: string): ExtensionTerminalInputResult;
     renderActiveCustomUi(width: number): string[] | undefined;
     activeCustomUiUsesEditor(): boolean;
     handleCustomUiMouse(event: ExtensionInputMouseEvent): boolean;
-    widgetTuiHandle(): WidgetTuiHandle;
+    widgetTuiHandle(scopeKey?: string): WidgetTuiHandle;
     createExtensionUIContext(scopeKey?: string): PixExtensionUIContext;
     private setAboveInputWidget;
     private clearAboveInputWidget;
@@ -60,6 +62,8 @@ export declare class ExtensionUiController {
     private rejectActiveCustomUi;
     private finishActiveCustomUi;
     private activeCustomUiForActiveScope;
+    private isScopeActive;
+    private scopedMenuController;
     private activeScopeKey;
     private normalizeScopeKey;
     private scopedWidgetKey;