diff --git a/src/main/runtime/terminal/recovery/closed-tab-pane-resolution.test.ts b/src/main/runtime/terminal/recovery/closed-tab-pane-resolution.test.ts new file mode 100644 index 00000000000..e797537f36b --- /dev/null +++ b/src/main/runtime/terminal/recovery/closed-tab-pane-resolution.test.ts @@ -0,0 +1,45 @@ +import { describe, expect, it } from 'vitest' +import { makePaneKey } from '../../../../shared/workspace-layout/stable-pane-id' +import { + LEAF_ID, + PTY_ID, + TAB_ID, + WORKTREE_ID +} from '../../__fixtures__/orca-runtime-terminal-close-continuity-state-fixture' +import { createHarness } from '../../__fixtures__/orca-runtime-terminal-close-continuity-fixtures' + +// #9194: a paired client asks for a pane by key; a tab the host closed after its agent exited must +// read as gone, or the client keeps the closed tab forever. +async function exitedPaneWithoutTab() { + const harness = createHarness({ publishMobileSurface: true, registerPtyBacked: true }) + harness.runtime.setNotifier(null) + harness.syncEmptyGraph() + harness.removeVictimFromInventory() + const before = harness.getSession() + // With no desktop window, the exit itself closes the tab's last pane and so the tab. + await harness.runtime.onPtyExit(PTY_ID, 0) + expect(harness.getSession().tabsByWorktree[WORKTREE_ID]).toEqual([]) + return { harness, before } +} + +const resolve = (harness: Awaited>['harness']) => + harness.runtime.resolveTerminalPane(makePaneKey(TAB_ID, LEAF_ID), WORKTREE_ID) + +describe('resolving a pane of a tab the host closed', () => { + it('answers terminal_not_found once the exited pane has no tab', async () => { + const { harness } = await exitedPaneWithoutTab() + expect(() => resolve(harness)).toThrow('terminal_not_found') + }) + + it('still resolves an exited pane whose tab the host keeps', async () => { + const { harness, before } = await exitedPaneWithoutTab() + harness.editSession(() => before) + expect(resolve(harness)).toMatchObject({ connected: false }) + }) + + it('still resolves the pane while the host session is unreadable', async () => { + const { harness } = await exitedPaneWithoutTab() + harness.makeSessionUnavailable() + expect(resolve(harness)).toMatchObject({ connected: false }) + }) +}) diff --git a/src/main/runtime/terminal/recovery/resolve-terminal-pane.ts b/src/main/runtime/terminal/recovery/resolve-terminal-pane.ts index 9b6dabc6b2d..14e92443c81 100644 --- a/src/main/runtime/terminal/recovery/resolve-terminal-pane.ts +++ b/src/main/runtime/terminal/recovery/resolve-terminal-pane.ts @@ -24,6 +24,7 @@ import { import { getTerminalState } from '../wait/terminal-wait-results' import { readStructuredWorkerTerminal } from '../../orchestration/terminal-authority/structured-sessions/structured-worker-terminal-read' import { ORCA_LAYOUT_OWNER_IS_MAIN } from '../../../../shared/layout-owner-switch' +import { workspaceSessionListsTerminalTab } from '../../../../shared/workspace-session/workspace-session-terminal-tab-close' export abstract class OrcaRuntimeWithResolveTerminalPane extends OrcaRuntimeWithRestoredHandlePaneStart { protected abstract assertLiveTerminalHandleTargetsPty(handle: string, expectedPtyId: string): void @@ -79,6 +80,17 @@ export abstract class OrcaRuntimeWithResolveTerminalPane extends OrcaRuntimeWith // Why: pane coordinates restored by a paired client must not cross workspace ownership. throw new Error('terminal_not_found') } + if (parsed && !leaf && pty && !pty.connected && worktreeId) { + // An exited PTY outlives its tab; once the host closed that tab the pane is gone, and a client + // must not read the leftover record as a pane the host still owns (#9194). + const session = this.getWorkspaceSessionForWorktree(worktreeId) + if ( + session?.tabsByWorktree[worktreeId] && + !workspaceSessionListsTerminalTab(session, worktreeId, parsed.tabId) + ) { + throw new Error('terminal_not_found') + } + } return { handle, tabId: parsed?.tabId ?? record?.tabId ?? '', diff --git a/src/renderer/src/runtime/hosted-terminals/recovery/evidence/web-session-terminal-orphan-recovery-cache.ts b/src/renderer/src/runtime/hosted-terminals/recovery/evidence/web-session-terminal-orphan-recovery-cache.ts index d018fb48854..f3c9222c025 100644 --- a/src/renderer/src/runtime/hosted-terminals/recovery/evidence/web-session-terminal-orphan-recovery-cache.ts +++ b/src/renderer/src/runtime/hosted-terminals/recovery/evidence/web-session-terminal-orphan-recovery-cache.ts @@ -131,7 +131,7 @@ function buildPaneResolutionFingerprint( function inventoryAbsenceCoordinates(args: { environmentId: string snapshot: RuntimeMobileSessionTabsResult - surface: RecoverySurface + surface: RecoverySurface | UnresolvedRecoverySurface expectedEnvironmentPairingRevision?: number }): { key: string; fingerprint: string } { return { @@ -142,15 +142,15 @@ function inventoryAbsenceCoordinates(args: { expectedEnvironmentPairingRevision: args.expectedEnvironmentPairingRevision }), // Absence fingerprints identify surfaces, not publicationEpoch: including epoch resets evidence on republication and prevents two independent inventories confirming absence. - fingerprint: [args.surface.handle, args.surface.expectedPtyId ?? ''].join('\0') + fingerprint: [args.surface.handle ?? '', args.surface.expectedPtyId ?? ''].join('\0') } } -/** Returns true after two authoritative inventories omit the same surface identity. */ +/** Returns true after two authoritative inventories (terminal listings, or pane resolutions for unbound panes) omit the same surface identity. */ export function confirmSurfaceInventoryAbsence(args: { environmentId: string snapshot: RuntimeMobileSessionTabsResult - surface: RecoverySurface + surface: RecoverySurface | UnresolvedRecoverySurface expectedEnvironmentPairingRevision?: number }): boolean { const { key, fingerprint } = inventoryAbsenceCoordinates(args) @@ -174,7 +174,7 @@ export function confirmSurfaceInventoryAbsence(args: { export function clearSurfaceInventoryAbsence(args: { environmentId: string snapshot: RuntimeMobileSessionTabsResult - surface: RecoverySurface + surface: RecoverySurface | UnresolvedRecoverySurface expectedEnvironmentPairingRevision?: number }): void { surfaceInventoryAbsences.delete(inventoryAbsenceCoordinates(args).key) diff --git a/src/renderer/src/runtime/hosted-terminals/recovery/panes/web-session-terminal-orphan-recovery-pane.ts b/src/renderer/src/runtime/hosted-terminals/recovery/panes/web-session-terminal-orphan-recovery-pane.ts index 8fe2496fc7b..ba19199c1c1 100644 --- a/src/renderer/src/runtime/hosted-terminals/recovery/panes/web-session-terminal-orphan-recovery-pane.ts +++ b/src/renderer/src/runtime/hosted-terminals/recovery/panes/web-session-terminal-orphan-recovery-pane.ts @@ -5,8 +5,12 @@ import { makePaneKey } from '../../../../../../shared/workspace-layout/stable-pa import { runInTerminalRecoveryRpcLane } from '../scheduling/web-session-terminal-orphan-recovery-rpc-lane' import { cacheStablePaneResolutionFailure, + clearSurfaceInventoryAbsence, + confirmSurfaceInventoryAbsence, readStablePaneResolutionFailure } from '../evidence/web-session-terminal-orphan-recovery-cache' +import { latestTerminalRetirementProof } from '../surfaces/web-session-terminal-orphan-recovery-surface-index' +import { hostSnapshotAffirmsWorktreeContents } from '../../../web-session-tabs-sync/hydration/host-session-snapshot-authority' import type { RecoverySurface, UnresolvedRecoverySurface @@ -25,6 +29,9 @@ type PaneResolution = { unresolved: UnresolvedRecoverySurface[] } +/** `absent`: the host has no terminal for the pane; `owned`: it has one, just not attachable yet. */ +type PaneOutcome = RecoverySurface | 'absent' | 'owned' | null + type ResolvedPaneResponse = | { kind: 'connected'; terminal: RuntimeTerminalResolvePane } | { kind: 'disconnected' } @@ -96,7 +103,7 @@ async function resolveOne(args: { call: RuntimeCall expectedEnvironmentPairingRevision?: number isCurrent: () => boolean -}): Promise { +}): Promise { const { surface, snapshot, environmentId, call, expectedEnvironmentPairingRevision, isCurrent } = args if (!isCurrent()) { @@ -147,6 +154,11 @@ async function resolveOne(args: { if (response?.error.code === 'method_not_found') { cacheFailure() } + // The host also answers this for a live leaf between PTYs, so it is an absence only when the + // frame omits the pane too; a pending row means the host still owns it. + if (response?.error.code === 'terminal_not_found' && surface.incoming === undefined) { + return 'absent' + } return null } const resolution = readResolvedPane(response.result) @@ -155,11 +167,13 @@ async function resolveOne(args: { return null } if (resolution.kind === 'disconnected') { - return null + // Older hosts keep resolving a closed tab's exited pane as disconnected; only the frame can + // tell that apart from a live tab between PTYs. + return surface.incoming === undefined ? 'absent' : 'owned' } const { terminal } = resolution if (!matchesSurface(terminal, surface, snapshot.worktree)) { - return null + return 'owned' } return resolvedSurface(surface, terminal) } catch { @@ -167,6 +181,9 @@ async function resolveOne(args: { } } +/** Unbound panes have no handle to list, so they are retired by pane: the host's close record for + * the pane, or the same two consecutive authoritative absences that retire listed handles. Any + * sign the host still owns the pane restarts the count. Retired panes are in neither result list. */ export async function resolvePersistedTerminalSurfaces(args: { surfaces: readonly UnresolvedRecoverySurface[] snapshot: RuntimeMobileSessionTabsResult @@ -175,7 +192,11 @@ export async function resolvePersistedTerminalSurfaces(args: { expectedEnvironmentPairingRevision?: number isCurrent: () => boolean }): Promise { - const { surfaces, isCurrent } = args + const { snapshot, isCurrent } = args + const surfaces = args.surfaces.filter( + (surface) => + surface.incoming !== undefined || latestTerminalRetirementProof(snapshot, surface) === null + ) if (surfaces.length === 0) { return { resolved: [], unresolved: [] } } @@ -191,8 +212,26 @@ export async function resolvePersistedTerminalSurfaces(args: { if (!isCurrent()) { return null } - return { - resolved: outcomes.flatMap(({ resolved }) => (resolved ? [resolved] : [])), - unresolved: outcomes.flatMap(({ surface, resolved }) => (resolved ? [] : [surface])) + const resolved: RecoverySurface[] = [] + const unresolved: UnresolvedRecoverySurface[] = [] + for (const { surface, resolved: outcome } of outcomes) { + const evidence = { ...args, surface } + if (outcome !== 'absent') { + if (outcome !== null || surface.incoming !== undefined) { + clearSurfaceInventoryAbsence(evidence) + } + if (outcome !== null && outcome !== 'owned') { + resolved.push(outcome) + } else { + unresolved.push(surface) + } + } else if ( + // A frame the host did not publish affirms nothing, so it is never an absence. + !hostSnapshotAffirmsWorktreeContents(snapshot) || + !confirmSurfaceInventoryAbsence(evidence) + ) { + unresolved.push(surface) + } } + return { resolved, unresolved } } diff --git a/src/renderer/src/runtime/hosted-terminals/recovery/panes/web-session-terminal-pending-handle-recovery.test.ts b/src/renderer/src/runtime/hosted-terminals/recovery/panes/web-session-terminal-pending-handle-recovery.test.ts index 83ec08c96a1..14d365caea7 100644 --- a/src/renderer/src/runtime/hosted-terminals/recovery/panes/web-session-terminal-pending-handle-recovery.test.ts +++ b/src/renderer/src/runtime/hosted-terminals/recovery/panes/web-session-terminal-pending-handle-recovery.test.ts @@ -5,6 +5,8 @@ import { recoverWebSessionTerminalOrphansBeforeApply } from '../web-session-terminal-orphan-recovery' import type { TerminalOrphanRecoveryState } from '../surfaces/web-session-terminal-orphan-recovery-surface' +import type { TerminalOrphanRecoveryCall } from '../adoption/web-session-terminal-orphan-recovery-adoption' +import type { RuntimeMobileSessionTabsResult } from '../../../../../../shared/runtime-session-contracts' import '../../../rpc/testing/runtime-environment-bridge-fixture' const ENVIRONMENT_ID = 'remote-runtime' @@ -254,4 +256,96 @@ describe('web session pending terminal handle recovery', () => { ] }) }) + + describe('an unbound pane whose host tab was closed (#9194)', () => { + const closedPaneCall = vi.fn() + beforeEach(() => { + closedPaneCall.mockReset() + closedPaneCall.mockImplementation(async ({ method }) => + method === 'terminal.resolvePane' + ? { + id: 'resolve', + ok: false, + error: { code: 'terminal_not_found', message: 'terminal_not_found' } + } + : { id: method, ok: false, error: { code: 'unexpected_method', message: method } } + ) + }) + function closedTabFrame(snapshotVersion: number): RuntimeMobileSessionTabsResult { + return { ...pendingSnapshot(), activeTabId: null, snapshotVersion, tabs: [] } + } + function recover(frame: RuntimeMobileSessionTabsResult) { + return recoverWebSessionTerminalOrphansBeforeApply( + stateWithEmptyBinding(), + frame, + ENVIRONMENT_ID, + { call: closedPaneCall } + ) + } + const keepsPane = { tabs: [expect.objectContaining({ parentTabId: HOST_TAB_ID })] } + + it('retires the pane after two authoritative absences', async () => { + await expect(recover(closedTabFrame(3))).resolves.toMatchObject(keepsPane) + await expect(recover(closedTabFrame(4))).resolves.toMatchObject({ tabs: [] }) + }) + + it('retires the pane at once when the frame carries its close record', async () => { + const frame = { + ...closedTabFrame(3), + retiredTerminalSurfaces: [ + { + parentTabId: HOST_TAB_ID, + leafId: LEAF_ID, + terminal: TERMINAL_HANDLE, + ptyId: 'pty-live' + } + ] + } + await expect(recover(frame)).resolves.toMatchObject({ tabs: [] }) + expect(closedPaneCall).not.toHaveBeenCalled() + }) + + it('restarts the count when the host publishes the pane again', async () => { + await recover(closedTabFrame(3)) + await recover({ ...pendingSnapshot(), snapshotVersion: 4 }) + await expect(recover(closedTabFrame(5))).resolves.toMatchObject(keepsPane) + }) + + it('retires a closed tab whose exited pane an older host still resolves as disconnected', async () => { + closedPaneCall.mockImplementation(async ({ method }) => + method === 'terminal.resolvePane' + ? { + id: 'resolve', + ok: true, + _meta: { runtimeId: 'runtime-1' }, + result: { + terminal: { + handle: TERMINAL_HANDLE, + tabId: HOST_TAB_ID, + leafId: LEAF_ID, + ptyId: 'pty-live', + connected: false, + worktreeId: WORKTREE_ID + } + } + } + : { id: method, ok: false, error: { code: 'unexpected_method', message: method } } + ) + await expect(recover(closedTabFrame(3))).resolves.toMatchObject(keepsPane) + await expect(recover(closedTabFrame(4))).resolves.toMatchObject({ tabs: [] }) + }) + + it('keeps a pane the host still publishes, whatever the pane lookup says', async () => { + for (const snapshotVersion of [3, 4, 5]) { + await expect(recover({ ...pendingSnapshot(), snapshotVersion })).resolves.toMatchObject( + keepsPane + ) + } + }) + + it('never counts a frame the host did not publish', async () => { + await recover({ ...closedTabFrame(3), publicationEpoch: 'none' }) + await expect(recover(closedTabFrame(4))).resolves.toMatchObject(keepsPane) + }) + }) })