pi-ui-extend 0.1.70 → 0.1.72

package/dist/app/session/session-lifecycle-controller.js

@@ -4,9 +4,15 @@ import { collectStartupAvailabilityIssues } from "../cli/startup-checks.js";
 export class AppSessionLifecycleController {
     host;
     unsubscribe;
+    ownershipRuntime;
+    ownershipSession;
+    ownershipGeneration = 0;
+    subscriptionGeneration = 0;
+    replacementHistoryGeneration = 0;
     extensionBindPromise;
     extensionBindRuntime;
     extensionBindSession;
+    extensionBindOwnershipGeneration;
     constructor(host) {
         this.host = host;
     }
@@ -33,6 +39,8 @@ export class AppSessionLifecycleController {
             }
             this.host.setRuntime(runtime);
             runtime.setRebindSession(async () => {
+                if (!this.host.isRunning() || this.host.runtime() !== runtime)
+                    return;
                 await this.bindCurrentSession({ awaitExtensions: false });
             });
             await this.bindCurrentSession({ awaitExtensions: false });
@@ -65,17 +73,27 @@ export class AppSessionLifecycleController {
     async bindCurrentSession(options = {}) {
         const runtime = this.requireRuntime();
         const session = runtime.session;
+        const ownershipGeneration = this.advanceOwnership(runtime, session);
+        const subscriptionGeneration = ++this.subscriptionGeneration;
+        this.replacementHistoryGeneration += 1;
         this.unsubscribe?.();
         this.unsubscribe = session.subscribe((event) => {
+            if (!this.isCurrentRuntimeSession(runtime, session, ownershipGeneration)
+                || subscriptionGeneration !== this.subscriptionGeneration)
+                return;
             this.host.handleSessionEvent(event);
         });
         this.host.closeSdkMenuForBind();
         const extensionUiScope = this.extensionUiScope(session);
         this.host.clearExtensionWidgets(extensionUiScope, { cancelCustomUi: false });
-        const bindPromise = this.bindSessionExtensions(runtime, session, extensionUiScope);
+        const bindPromise = this.bindSessionExtensions(runtime, session, extensionUiScope, {
+            deferStart: options.awaitExtensions === false,
+            ownershipGeneration,
+        });
         if (options.awaitExtensions === false) {
             void bindPromise.catch((error) => {
-                if (!this.isCurrentRuntimeSession(runtime, session))
+                if (!this.isCurrentRuntimeSession(runtime, session, ownershipGeneration)
+                    || subscriptionGeneration !== this.subscriptionGeneration)
                     return;
                 this.host.addEntry({ id: createId("error"), kind: "error", text: `Extension bind failed: ${stringifyUnknown(error)}` });
                 this.host.showToast("Extension initialization failed", "error");
@@ -90,28 +108,53 @@ export class AppSessionLifecycleController {
             return;
         if (this.extensionBindRuntime !== runtime || this.extensionBindSession !== runtime.session)
             return;
+        if (this.extensionBindOwnershipGeneration !== this.ownershipGeneration)
+            return;
         await this.extensionBindPromise;
     }
     unsubscribeSession() {
         this.unsubscribe?.();
+        this.unsubscribe = undefined;
+        this.ownershipRuntime = undefined;
+        this.ownershipSession = undefined;
+        this.ownershipGeneration += 1;
+        this.subscriptionGeneration += 1;
+        this.replacementHistoryGeneration += 1;
     }
     afterSessionReplacement(message) {
+        const runtime = this.host.runtime();
+        if (!runtime) {
+            this.resetSessionView();
+            this.host.render();
+            return;
+        }
+        const session = runtime.session;
+        const ownershipGeneration = this.advanceOwnership(runtime, session);
+        const historyGeneration = ++this.replacementHistoryGeneration;
         this.resetSessionView();
-        void this.loadReplacementHistory(message);
+        void this.loadReplacementHistory(runtime, session, ownershipGeneration, historyGeneration, message);
         this.host.render();
     }
-    async loadReplacementHistory(message) {
-        await this.host.loadSessionHistoryEntriesAsync({
-            isCancelled: () => !this.host.isRunning(),
-            render: () => this.host.render(),
+    async loadReplacementHistory(runtime, session, ownershipGeneration, historyGeneration, message) {
+        const isCancelled = () => historyGeneration !== this.replacementHistoryGeneration
+            || !this.isCurrentRuntimeSession(runtime, session, ownershipGeneration);
+        const completed = await this.host.loadSessionHistoryEntriesAsync({
+            isCancelled,
+            render: () => {
+                if (!isCancelled())
+                    this.host.render();
+            },
             lazyOlderHistory: true,
         });
+        if (!completed || isCancelled())
+            return;
         this.host.syncUserSessionEntryMetadata();
+        if (isCancelled())
+            return;
         if (message)
             this.host.addEntry({ id: createId("system"), kind: "system", text: message });
-        const session = this.host.runtime()?.session;
         this.host.setSessionStatus(session);
-        this.host.setSessionActivity(session?.isStreaming ? "running" : "idle");
+        this.host.setSessionActivity(session.isStreaming ? "running" : "idle");
         this.host.render();
     }
     resetSessionView() {
@@ -135,25 +178,41 @@ export class AppSessionLifecycleController {
             throw new Error("Runtime is not initialized");
         return runtime;
     }
-    bindSessionExtensions(runtime, session, scopeKey) {
-        if (this.extensionBindPromise && this.extensionBindRuntime === runtime && this.extensionBindSession === session) {
+    bindSessionExtensions(runtime, session, scopeKey, options) {
+        if (this.extensionBindPromise
+            && this.extensionBindRuntime === runtime
+            && this.extensionBindSession === session
+            && this.extensionBindOwnershipGeneration === options.ownershipGeneration) {
             return this.extensionBindPromise;
         }
-        const promise = session.bindExtensions({
-            uiContext: this.host.createExtensionUIContext(scopeKey),
-            commandContextActions: this.host.createExtensionCommandContextActions(runtime),
-            shutdownHandler: this.host.extensionShutdownHandler(),
-            onError: (error) => this.host.handleExtensionError(error),
-        }).finally(() => {
+        const startBind = () => {
+            if (!this.isCurrentRuntimeSession(runtime, session, options.ownershipGeneration))
+                return Promise.resolve();
+            return session.bindExtensions({
+                uiContext: this.host.createExtensionUIContext(scopeKey),
+                commandContextActions: this.host.createExtensionCommandContextActions(runtime),
+                shutdownHandler: this.host.extensionShutdownHandler(),
+                onError: (error) => {
+                    if (this.isCurrentRuntimeSession(runtime, session, options.ownershipGeneration))
+                        this.host.handleExtensionError(error);
+                },
+            });
+        };
+        const bindPromise = options.deferStart
+            ? new Promise((resolve) => setTimeout(resolve, 0)).then(startBind)
+            : startBind();
+        const promise = bindPromise.finally(() => {
             if (this.extensionBindPromise !== promise)
                 return;
             this.extensionBindPromise = undefined;
             this.extensionBindRuntime = undefined;
             this.extensionBindSession = undefined;
+            this.extensionBindOwnershipGeneration = undefined;
         });
         this.extensionBindPromise = promise;
         this.extensionBindRuntime = runtime;
         this.extensionBindSession = session;
+        this.extensionBindOwnershipGeneration = options.ownershipGeneration;
         return promise;
     }
     async collectAvailabilityIssues(runtime) {
@@ -184,8 +243,21 @@ export class AppSessionLifecycleController {
             this.host.render();
         }
     }
-    isCurrentRuntimeSession(runtime, session) {
-        return this.host.isRunning() && this.host.runtime() === runtime && runtime.session === session;
+    advanceOwnership(runtime, session) {
+        if (this.ownershipRuntime !== runtime || this.ownershipSession !== session) {
+            this.ownershipRuntime = runtime;
+            this.ownershipSession = session;
+            this.ownershipGeneration += 1;
+        }
+        return this.ownershipGeneration;
+    }
+    isCurrentRuntimeSession(runtime, session, ownershipGeneration) {
+        return this.host.isRunning()
+            && this.host.runtime() === runtime
+            && runtime.session === session
+            && this.ownershipRuntime === runtime
+            && this.ownershipSession === session
+            && this.ownershipGeneration === ownershipGeneration;
     }
     extensionUiScope(session) {
         return session.sessionFile ?? session.sessionId;

package/dist/app/session/tabs-controller.d.ts

@@ -61,15 +61,27 @@ export declare class AppTabsController {
     private readonly sessionViewsByTabId;
     private readonly scrollStatesByTabId;
     private readonly tabIdsNeedingHistoryReload;
+    private readonly historyInvalidationGenerationByTabId;
+    private readonly runtimeOwnershipGenerationByTabId;
+    private readonly orphanRuntimeDisposals;
+    private readonly lifecycleMutationQueue;
     private activeTabId;
     private pendingActiveTabId;
     private historyLoadGeneration;
+    private historyInvalidationGeneration;
+    private runtimeOwnershipGeneration;
+    private lifecycleGeneration;
+    private lifecycleMutationRunning;
+    private saveTabsWriteTail;
     private restored;
     private retentionCleanupRunning;
     private retentionCleanupScheduled;
     private prewarmScheduled;
     private prewarmRunning;
     constructor(host: AppTabsControllerHost);
+    private runLifecycleMutation;
+    private isLifecycleOwner;
+    cancelPendingLifecycleWork(): void;
     tabs(): readonly SessionTab[];
     isSwitching(): boolean;
     markTerminalBellAttention(sessionPath: string | undefined): void;
@@ -80,16 +92,24 @@ export declare class AppTabsController {
     disposeInactiveRuntimes(disposeRuntime?: (runtime: AgentSessionRuntime) => Promise<void>): Promise<void>;
     saveInputStateForQuit(): Promise<void>;
     persistActiveDeferredUserMessages(): void;
+    requeueAutoUserMessageForSession(session: AgentSession, message: SubmittedUserMessage): void;
+    inputTabOwnedByRuntime(tabId: string | undefined, runtime: AgentSessionRuntime, session: AgentSession): boolean;
     syncActiveTabFromRuntime(options?: {
         save?: boolean;
         force?: boolean;
     }): void;
     restoreAfterStartup(): Promise<void>;
+    private restoreAfterStartupMutation;
     openNewTab(): Promise<void>;
+    private openNewTabMutation;
     openSessionInNewTab(sessionPath: string): Promise<boolean>;
+    private openSessionInNewTabMutation;
     forkSessionEntryInNewTab(entryId: string): Promise<boolean>;
+    private forkSessionEntryInNewTabMutation;
     switchToTab(tabId: string): Promise<void>;
+    private switchToTabMutation;
     closeTab(tabId: string): Promise<void>;
+    private closeTabMutation;
     private replaceLastTabWithNewSession;
     private loadActiveSessionHistory;
     private cancelHistoryLoad;
@@ -103,8 +123,13 @@ export declare class AppTabsController {
     private restoreStoredScrollState;
     private setRuntimeForTab;
     private deleteRuntimeForTab;
+    private releaseRuntimeOwnership;
     private clearRuntimeSubscriptions;
     private observeRuntimeForTab;
+    private isRuntimeOwnedByTab;
+    private queueOrphanRuntimeDisposal;
+    private disposeRuntimeIfOrphan;
+    private adoptCurrentRuntimeAfterFailedRollback;
     private shouldSyncTabFromRuntimeEvent;
     private shouldScheduleDelayedSyncForRuntimeEvent;
     private shouldInvalidateCachedViewForRuntimeEvent;
@@ -151,6 +176,7 @@ export declare class AppTabsController {
     private parsePersistedScrollState;
     private parsePersistedSubmittedUserMessages;
     private saveTabs;
+    private writeTabsSnapshot;
     private filePath;
     private sessionDir;
     private scheduleProjectSessionRetention;