fix(session): read ssh host partitions so stranded tabs stop round-tripping as deletions

src/main/ipc/remote-workspace-cache.test.ts

@@ -3,6 +3,7 @@ import type {
   RemoteWorkspaceSession,
   RemoteWorkspaceSnapshot
 } from '../../shared/remote-workspace-types'
+import type { DirectSshAuthority, SshProviderEpoch } from '../../shared/ssh-types'
 import {
   _getRemoteWorkspaceCacheSizesForTests,
   _resetRemoteWorkspaceCachesForTests
@@ -32,6 +33,14 @@ function snapshot(session: RemoteWorkspaceSession, revision = 7): RemoteWorkspac
   }
 }
 
+function authority(targetId: string): DirectSshAuthority {
+  return {
+    targetId,
+    providerEpoch: `epoch-${targetId}` as SshProviderEpoch,
+    connectionGeneration: 1
+  }
+}
+
 describe('remote workspace snapshot cache', () => {
   beforeEach(() => {
     _resetRemoteWorkspaceCachesForTests()
@@ -40,7 +49,7 @@ describe('remote workspace snapshot cache', () => {
   it('LRU-evicts old target snapshots', () => {
     for (let i = 0; i <= REMOTE_WORKSPACE_SNAPSHOT_CACHE_MAX_ENTRIES; i++) {
       _rememberRemoteWorkspaceSnapshotForTests(
-        `target-${i}`,
+        authority(`target-${i}`),
         snapshot({
           activeWorktreePath: `/repo-${i}`,
           activeTabId: null,
@@ -53,24 +62,39 @@ describe('remote workspace snapshot cache', () => {
     expect(_getRemoteWorkspaceCacheSizesForTests().snapshots).toBe(
       REMOTE_WORKSPACE_SNAPSHOT_CACHE_MAX_ENTRIES
     )
-    expect(_getRemoteWorkspaceSnapshotForTests('target-0')).toBeUndefined()
-    expect(_getRemoteWorkspaceSnapshotForTests('target-1')?.session.activeWorktreePath).toBe(
-      '/repo-1'
-    )
+    expect(_getRemoteWorkspaceSnapshotForTests(authority('target-0'))).toBeUndefined()
+    expect(
+      _getRemoteWorkspaceSnapshotForTests(authority('target-1'))?.session.activeWorktreePath
+    ).toBe('/repo-1')
   })
 
   it('refreshes snapshot recency on cache reads', () => {
     for (let i = 0; i < REMOTE_WORKSPACE_SNAPSHOT_CACHE_MAX_ENTRIES; i++) {
       _rememberRemoteWorkspaceSnapshotForTests(
-        `target-${i}`,
+        authority(`target-${i}`),
         snapshot(emptyRemoteWorkspaceSession())
       )
     }
 
-    expect(_getRemoteWorkspaceSnapshotForTests('target-0')).toBeDefined()
-    _rememberRemoteWorkspaceSnapshotForTests('target-new', snapshot(emptyRemoteWorkspaceSession()))
+    expect(_getRemoteWorkspaceSnapshotForTests(authority('target-0'))).toBeDefined()
+    _rememberRemoteWorkspaceSnapshotForTests(
+      authority('target-new'),
+      snapshot(emptyRemoteWorkspaceSession())
+    )
+
+    expect(_getRemoteWorkspaceSnapshotForTests(authority('target-0'))).toBeDefined()
+    expect(_getRemoteWorkspaceSnapshotForTests(authority('target-1'))).toBeUndefined()
+  })
+
+  it('does not return a snapshot across provider authority rotation', () => {
+    const original = authority('target-1')
+    const replacement = {
+      ...original,
+      providerEpoch: 'epoch-replacement' as SshProviderEpoch,
+      connectionGeneration: 2
+    }
+    _rememberRemoteWorkspaceSnapshotForTests(original, snapshot(emptyRemoteWorkspaceSession(), 99))
 
-    expect(_getRemoteWorkspaceSnapshotForTests('target-0')).toBeDefined()
-    expect(_getRemoteWorkspaceSnapshotForTests('target-1')).toBeUndefined()
+    expect(_getRemoteWorkspaceSnapshotForTests(replacement)).toBeUndefined()
   })
 })

src/main/ipc/remote-workspace-events.ts

@@ -1,7 +1,10 @@
+import type { DirectSshAuthority } from '../../shared/ssh-types'
+
 type RemoteWorkspaceNotificationHandler = (
   targetId: string,
   method: string,
-  params: Record<string, unknown>
+  params: Record<string, unknown>,
+  authority: DirectSshAuthority
 ) => void
 
 const handlers = new Set<RemoteWorkspaceNotificationHandler>()
@@ -16,9 +19,10 @@ export function registerRemoteWorkspaceNotificationHandler(
 export function notifyRemoteWorkspaceHandlers(
   targetId: string,
   method: string,
-  params: Record<string, unknown>
+  params: Record<string, unknown>,
+  authority: DirectSshAuthority
 ): void {
   for (const handler of handlers) {
-    handler(targetId, method, params)
+    handler(targetId, method, params, authority)
   }
 }

src/main/ipc/remote-workspace-explicit-session-authority.ts

@@ -0,0 +1,103 @@
+import { isDeepStrictEqual } from 'node:util'
+import type { Store } from '../persistence'
+import { toSshExecutionHostId } from '../../shared/execution-host'
+import { exportRemoteWorkspaceSession } from '../../shared/remote-workspace-session-projection'
+import type { RemoteWorkspaceSession } from '../../shared/remote-workspace-types'
+import { parseAppSshPtyId } from '../../shared/ssh-pty-id'
+import type { DirectSshAuthority } from '../../shared/ssh-types'
+import type { WorkspaceSessionState } from '../../shared/workspace-session-state-types'
+import { getRepoIdFromWorktreeId } from '../../shared/worktree/id'
+
+type SessionAuthorityStore = Pick<Store, 'getRepo' | 'getWorkspaceSession'>
+
+function targetForWorktree(
+  store: SessionAuthorityStore,
+  worktreeId: string,
+  targetId: string
+): string | null {
+  const repoId = getRepoIdFromWorktreeId(worktreeId)
+  return store.getRepo(repoId, toSshExecutionHostId(targetId))?.connectionId ?? null
+}
+
+export function exportSessionForTarget(
+  store: SessionAuthorityStore,
+  authority: DirectSshAuthority,
+  session: WorkspaceSessionState
+): RemoteWorkspaceSession | null {
+  const isTargetWorktree = (worktreeId: string): boolean =>
+    targetForWorktree(store, worktreeId, authority.targetId) === authority.targetId
+  const ownerByTabId = new Map<string, string>()
+  for (const [worktreeId, tabs] of Object.entries(session.tabsByWorktree)) {
+    for (const tab of tabs) {
+      const owner = ownerByTabId.get(tab.id)
+      if (
+        owner &&
+        owner !== worktreeId &&
+        (isTargetWorktree(owner) || isTargetWorktree(worktreeId))
+      ) {
+        return null
+      }
+      ownerByTabId.set(tab.id, worktreeId)
+    }
+  }
+  const ownsPty = (ptyId: string): boolean =>
+    parseAppSshPtyId(ptyId)?.connectionId === authority.targetId
+  for (const [worktreeId, tabs] of Object.entries(session.tabsByWorktree)) {
+    if (!isTargetWorktree(worktreeId)) {
+      continue
+    }
+    for (const tab of tabs) {
+      if (tab.worktreeId !== worktreeId || (tab.ptyId && !ownsPty(tab.ptyId))) {
+        return null
+      }
+      const layout = session.terminalLayoutsByTabId[tab.id]
+      if (Object.values(layout?.ptyIdsByLeafId ?? {}).some((ptyId) => !ownsPty(ptyId))) {
+        return null
+      }
+      const remoteSessionId = session.remoteSessionIdsByTabId?.[tab.id]
+      if (remoteSessionId && !ownsPty(remoteSessionId)) {
+        return null
+      }
+    }
+  }
+  return exportRemoteWorkspaceSession(session, { isTargetWorktree })
+}
+
+function hasWorkspaceTabs(session: WorkspaceSessionState): boolean {
+  return Object.values(session.tabsByWorktree).some((tabs) => tabs.length > 0)
+}
+
+function hasRemoteWorkspaceTabs(session: RemoteWorkspaceSession): boolean {
+  return Object.values(session.tabsByWorktreePath).some((tabs) => tabs.length > 0)
+}
+
+export function exportExplicitSessionForTarget(
+  store: SessionAuthorityStore,
+  authority: DirectSshAuthority,
+  session: WorkspaceSessionState
+): RemoteWorkspaceSession | null {
+  const projected = exportSessionForTarget(store, authority, session)
+  if (!projected) {
+    return null
+  }
+  if (hasWorkspaceTabs(session) && !hasRemoteWorkspaceTabs(projected)) {
+    return null
+  }
+  const durableSessions = [
+    store.getWorkspaceSession(),
+    store.getWorkspaceSession(toSshExecutionHostId(authority.targetId))
+  ]
+  for (const durableSession of durableSessions) {
+    const durableProjection = exportSessionForTarget(store, authority, durableSession)
+    if (!durableProjection) {
+      return null
+    }
+    if (
+      hasRemoteWorkspaceTabs(durableProjection) &&
+      !isDeepStrictEqual(durableProjection, projected)
+    ) {
+      return null
+    }
+  }
+  return projected
+}