Files
orca/src/main/ipc/ssh.test.ts
T
Jinjing 25fefa4072 fix(P1-A): async SSH consumer-recovery persistence and detach on failed connect (#12026)
* fix(P1-A): persist SSH consumer recovery without a sync store flush

rememberPtyConsumerRecovery ran on the live establish/reconnect path and
called flushOrThrow -> writeToDiskSync, parking the Electron main thread on
the profile-directory write. On a stalled or slow profile mount that freezes
the whole app during SSH recovery and reconnect.

Add Store.flushAsync(): same debounce-cancel and write serialization as
flushOrThrow, but awaits writeToDiskAsync instead of blocking. The consumer
recovery upsert/remove pair is now async and awaits it, and the SSH callers
await through to establish()/reconnect() so ownership is still durable before
relay setup continues. In-memory state still mutates synchronously (before the
first await), so no caller can observe a torn record and dispose() stays
synchronous.

* fix(P1-A): detach the SSH session when a connect attempt fails

Both failure exits in doConnect dropped the session from activeSessions
without calling detach(). claimSshPtyConsumerRecovery only reuses an existing
in-memory entry when detached === true, so the next connect attempt fell
through to minting a fresh clientInstanceId, discarding the remembered owner
lease and its resume identity.

Route both exits through abandonFailedSshSession(), which detaches (keeping
PTY ownership, unlike dispose()) before removing the session, and tolerates a
teardown throw so it can't mask the connect error being rethrown.

* fix(P1-A): await async lease persistence in SSH relay teardown

Failed connect attempts now wait for 'detached' leases to persist before
throwing, preventing reconnects from claiming them before cleanup completes.
Detach and dispose operations are now async and await store durability.

* fix(ssh): make session detach lease writes retryable on failure

Separate in-memory detach (identity recovery, provider cleanup) from lease
write persistence so rejected writes can be re-issued without re-running
provider teardown or re-minting the session identity. Introduce
flushDurableStateOrThrowAsync to flush only SSH-recovery state on the
live establish/reconnect path, avoiding snapshot writes of sidecars that
belong to quit/startup. Use Promise.allSettled in test reset to prevent
one rejected disposal from leaking state into the next test.

* fix(ssh): dispose mux on failed establish and propagate sync errors

- Dispose mux when session is disposed during establish to prevent resource leak
- Propagate synchronous errors in teardown via the completion promise instead of leaving completion undefined
- Add test coverage for terminated PTYs that exit mid-reattach and must stay dead
2026-08-01 23:16:24 -07:00

2868 lines
101 KiB
TypeScript

/* eslint-disable max-lines -- Why: SSH IPC session lifecycle tests share a
single mocked Electron/connection harness; splitting them would obscure active
session state that the terminate/disconnect assertions depend on. */
import { describe, expect, it, vi, beforeEach } from 'vitest'
const {
handleMock,
powerMonitorOffMock,
powerMonitorOnMock,
mockSshStore,
mockConnectionManager,
mockDeployAndLaunchRelay,
mockForceStopRelayForTarget,
mockAcceptSshPtyOutputData,
mockAcceptSshPtyOutputExit,
mockMux,
mockPtyProvider,
mockFsProvider,
mockGitProvider,
mockRegisterSshGitProvider,
mockPortForwardManager,
mockPortScannerCallbacks,
mockNextConnectionManagers,
mockNextPortForwardManagers
} = vi.hoisted(() => ({
handleMock: vi.fn(),
powerMonitorOffMock: vi.fn(),
powerMonitorOnMock: vi.fn(),
mockSshStore: {
listTargets: vi.fn().mockReturnValue([]),
getTarget: vi.fn(),
addTarget: vi.fn(),
updateTarget: vi.fn(),
removeTarget: vi.fn(),
importFromSshConfig: vi.fn().mockReturnValue([]),
lastRepoReadoptions: [] as {
oldTargetId: string
newTargetId: string
repoIds: string[]
}[]
},
mockConnectionManager: {
connect: vi.fn(),
disconnect: vi.fn(),
reconnect: vi.fn(),
getConnection: vi.fn(),
getState: vi.fn(),
disconnectAll: vi.fn(),
setCallbacks: vi.fn(),
callbacksRef: { current: null as unknown }
},
mockDeployAndLaunchRelay: vi.fn(),
mockForceStopRelayForTarget: vi.fn(),
mockAcceptSshPtyOutputData: vi.fn().mockResolvedValue({}),
mockAcceptSshPtyOutputExit: vi.fn().mockResolvedValue(undefined),
mockMux: {
dispose: vi.fn(),
isDisposed: vi.fn().mockReturnValue(false),
onNotification: vi.fn(),
onNotificationByMethod: vi.fn().mockReturnValue(() => {}),
onRequest: vi.fn().mockReturnValue(() => {}),
onDispose: vi.fn().mockReturnValue(() => {}),
request: vi.fn().mockResolvedValue({}),
notify: vi.fn(),
probeLiveness: vi.fn().mockResolvedValue(false)
},
mockPtyProvider: {
onData: vi.fn(),
onExit: vi.fn(),
onReplay: vi.fn(),
attach: vi.fn(),
attachForReconnect: vi.fn().mockResolvedValue({}),
shutdown: vi.fn(),
providerGeneration: 0
},
mockFsProvider: {},
mockGitProvider: {},
mockRegisterSshGitProvider: vi.fn(),
mockPortForwardManager: {
addForward: vi.fn(),
updateForward: vi.fn(),
removeForward: vi.fn(),
removeForwardAndWait: vi.fn(),
listForwards: vi.fn().mockReturnValue([]),
removeAllForwards: vi.fn(),
dispose: vi.fn(),
setCallbacks: vi.fn(),
callbacksRef: { current: null as unknown }
},
mockPortScannerCallbacks: new Map<string, unknown>(),
mockNextConnectionManagers: [] as unknown[],
mockNextPortForwardManagers: [] as unknown[]
}))
vi.mock('electron', () => ({
ipcMain: {
handle: handleMock,
on: vi.fn(),
once: vi.fn(),
removeHandler: vi.fn(),
removeAllListeners: vi.fn()
},
powerMonitor: {
on: powerMonitorOnMock,
off: powerMonitorOffMock
}
}))
vi.mock('./ssh-pty-output-intake-registry', () => ({
acceptSshPtyOutputData: mockAcceptSshPtyOutputData,
acceptSshPtyOutputExit: mockAcceptSshPtyOutputExit,
allocateSshPtyProviderGeneration: (() => {
let generation = 0
return () => ++generation
})(),
beginSshPtyOutputGenerationMigration: vi.fn(() => ({
byPty: new Map(),
completion: Promise.resolve()
})),
applySshPtySourceCancellationProof: vi.fn().mockReturnValue(false),
applySshPtySourceRecoveryCancellationProof: vi.fn().mockReturnValue(false),
closeSshPtyOutputGeneration: vi.fn(),
getSshPtyAcceptedSourceCheckpoints: vi.fn().mockReturnValue([]),
installSshPtySourceAckPublisher: vi.fn().mockReturnValue(() => {}),
installSshPtySourceCancellationPublisher: vi.fn().mockReturnValue(() => {})
}))
vi.mock('../ssh/ssh-connection-store', () => ({
SshConnectionStore: class MockSshConnectionStore {
constructor() {
return mockSshStore
}
}
}))
vi.mock('../ssh/ssh-connection-manager', () => ({
SshConnectionManager: class MockSshConnectionManager {
constructor(callbacks: unknown) {
const manager = (mockNextConnectionManagers.shift() ??
mockConnectionManager) as typeof mockConnectionManager
manager.callbacksRef.current = callbacks
manager.setCallbacks.mockImplementation((nextCallbacks: unknown) => {
manager.callbacksRef.current = nextCallbacks
})
return manager
}
}
}))
vi.mock('../ssh/ssh-relay-deploy', () => ({
deployAndLaunchRelay: mockDeployAndLaunchRelay
}))
vi.mock('../ssh/ssh-relay-reset', () => ({
forceStopRelayForTarget: mockForceStopRelayForTarget
}))
vi.mock('../ssh/ssh-channel-multiplexer', () => ({
SshChannelMultiplexer: class MockSshChannelMultiplexer {
constructor() {
return mockMux
}
}
}))
vi.mock('../providers/ssh-pty-provider', () => ({
isSshPtyNotFoundError: (err: unknown) =>
(err instanceof Error ? err.message : String(err)).includes('not found'),
SshPtyProvider: class MockSshPtyProvider {
constructor(_targetId: unknown, _mux: unknown, _env: unknown, providerGeneration: number) {
mockPtyProvider.providerGeneration = providerGeneration
return mockPtyProvider
}
}
}))
vi.mock('../providers/ssh-filesystem-provider', () => ({
SshFilesystemProvider: class MockSshFilesystemProvider {
constructor() {
return mockFsProvider
}
}
}))
vi.mock('./pty', () => ({
registerSshPtyProvider: vi.fn(),
unregisterSshPtyProvider: vi.fn(),
clearPtyOwnershipForConnection: vi.fn(),
clearProviderPtyState: vi.fn(),
deletePtyOwnership: vi.fn(),
setPtyOwnership: vi.fn(),
getSshPtyProvider: vi.fn(),
getPtyIdsForConnection: vi.fn().mockReturnValue([]),
isCurrentPtyExit: vi.fn().mockReturnValue(true),
isRendererPtyOutputPaused: vi.fn().mockReturnValue(false)
}))
vi.mock('../providers/ssh-filesystem-dispatch', () => ({
registerSshFilesystemProvider: vi.fn(),
unregisterSshFilesystemProvider: vi.fn(),
getSshFilesystemProvider: vi.fn()
}))
vi.mock('../providers/ssh-git-provider', () => ({
SshGitProvider: class MockSshGitProvider {
constructor() {
return mockGitProvider
}
}
}))
vi.mock('../providers/ssh-git-dispatch', () => ({
registerSshGitProvider: mockRegisterSshGitProvider,
unregisterSshGitProvider: vi.fn()
}))
vi.mock('../ssh/ssh-port-forward', () => ({
SshPortForwardManager: class MockPortForwardManager {
constructor() {
const manager = (mockNextPortForwardManagers.shift() ??
mockPortForwardManager) as typeof mockPortForwardManager
manager.setCallbacks.mockImplementation((callbacks: unknown) => {
manager.callbacksRef.current = callbacks
})
return manager
}
}
}))
vi.mock('../ssh/ssh-port-scanner', () => ({
PortScanner: class MockPortScanner {
startScanning(targetId: string, _mux: unknown, onChanged: unknown) {
mockPortScannerCallbacks.set(targetId, onChanged)
}
getDetectedPorts() {
return []
}
stopScanning(targetId: string) {
mockPortScannerCallbacks.delete(targetId)
}
}
}))
import { getSshConnectionManager, registerSshHandlers, resetSshHandlerStateForTests } from './ssh'
import { RelayVersionMismatchError } from '../ssh/ssh-relay-version-mismatch-error'
import {
SSH_RELAY_CONFIGURE_GRACE_TIME_METHOD,
type SshConnectionState,
type SshConnectionStatus,
type SshTarget
} from '../../shared/ssh-types'
import { PTY_CONSUMER_SESSION_PROTOCOL_VERSION } from '../../shared/pty-consumer-session'
import { DEFAULT_PTY_SOURCE_WINDOW_SU } from '../../shared/pty-source-credit-contract'
import type { SshPtyDataCallback } from '../providers/ssh-pty-provider-contract'
import {
clearProviderPtyState,
deletePtyOwnership,
getSshPtyProvider,
getPtyIdsForConnection
} from './pty'
import { assertSshMutationExpectation } from '../ssh/ssh-connection-generation'
import { getSshPtyConsumerRecovery } from '../ssh/ssh-pty-consumer-recovery'
describe('SSH IPC handlers', () => {
const relayBuildId = '0.1.0+ipc-test'
const ipcTestSource = {
relayPtyId: 'remote-pty',
spanId: 'ipc-test-delivery:0:5',
clientGeneration: 1,
ownerGeneration: 1,
deliveryToken: 'ipc-test-delivery',
sourceStartSu: 0,
sourceEndSu: 5
} as const
const handlers = new Map<string, (_event: unknown, args: unknown) => unknown>()
const mockStore = {
getRepos: () => [],
getSshPtyConsumerRecovery: vi.fn().mockReturnValue(null),
upsertSshPtyConsumerRecovery: vi.fn(),
removeSshPtyConsumerRecovery: vi.fn(),
getSshRemotePtyLeases: vi.fn().mockReturnValue([]),
markSshRemotePtyLease: vi.fn(),
markSshRemotePtyLeases: vi.fn(),
markSshRemotePtyLeasesAsync: vi.fn(),
markSshRemotePtyLeasesAttachedAsync: vi.fn(),
removeSshRemotePtyLeases: vi.fn()
}
const mockWindow = {
isDestroyed: () => false,
webContents: { send: vi.fn() }
}
const createMockWindow = () => ({
isDestroyed: () => false,
webContents: { send: vi.fn() }
})
const createConnectionManagerMock = () => ({
connect: vi.fn(),
disconnect: vi.fn(),
reconnect: vi.fn(),
getConnection: vi.fn(),
getState: vi.fn(),
disconnectAll: vi.fn(),
setCallbacks: vi.fn(),
callbacksRef: { current: null as unknown }
})
const createPortForwardManagerMock = () => ({
addForward: vi.fn(),
updateForward: vi.fn(),
removeForward: vi.fn(),
listForwards: vi.fn().mockReturnValue([]),
removeAllForwards: vi.fn(),
dispose: vi.fn(),
setCallbacks: vi.fn(),
callbacksRef: { current: null as unknown }
})
type RelayDisposeCallback = (reason: 'shutdown' | 'connection_lost') => void
const relayReconnectDelaysMs = [500, 1000, 2000, 4000, 8000, 15_000] as const
const relayLostStabilizedMs = 5_000
const createRelayLaunchResult = () => ({
transport: { write: vi.fn(), onData: vi.fn(), onClose: vi.fn() },
platform: 'linux-x64',
serverBuildId: relayBuildId
})
const getLatestRelayDisposeCallback = (): RelayDisposeCallback => {
const calls = mockMux.onDispose.mock.calls
const callback = calls.at(-1)?.[0] as RelayDisposeCallback | undefined
expect(callback).toBeDefined()
return callback!
}
const useSlowRelayLaunchOnce = (delayMs: number): void => {
mockDeployAndLaunchRelay.mockImplementationOnce(
() =>
new Promise((resolve) => {
setTimeout(() => resolve(createRelayLaunchResult()), delayMs)
})
)
}
beforeEach(async () => {
await resetSshHandlerStateForTests()
handlers.clear()
mockNextConnectionManagers.length = 0
mockNextPortForwardManagers.length = 0
mockPortScannerCallbacks.clear()
handleMock.mockReset()
handleMock.mockImplementation((channel: string, handler: (...a: unknown[]) => unknown) => {
handlers.set(channel, handler)
})
mockSshStore.listTargets.mockReset().mockReturnValue([])
mockSshStore.getTarget.mockReset()
mockSshStore.addTarget.mockReset()
mockSshStore.updateTarget.mockReset()
mockSshStore.removeTarget.mockReset()
mockSshStore.importFromSshConfig.mockReset().mockReturnValue([])
mockSshStore.lastRepoReadoptions = []
mockWindow.webContents.send.mockReset()
mockStore.getSshRemotePtyLeases.mockReset().mockReturnValue([])
mockStore.markSshRemotePtyLease.mockReset()
mockStore.markSshRemotePtyLeases.mockReset()
mockStore.markSshRemotePtyLeasesAsync.mockReset()
mockStore.markSshRemotePtyLeasesAttachedAsync.mockReset()
mockStore.removeSshRemotePtyLeases.mockReset()
mockStore.upsertSshPtyConsumerRecovery.mockReset()
mockConnectionManager.connect.mockReset()
mockConnectionManager.disconnect.mockReset()
mockConnectionManager.reconnect.mockReset()
mockConnectionManager.getConnection.mockReset()
mockConnectionManager.getState.mockReset()
mockConnectionManager.disconnectAll.mockReset()
mockConnectionManager.setCallbacks.mockReset()
mockConnectionManager.callbacksRef.current = null
mockForceStopRelayForTarget.mockReset().mockResolvedValue(undefined)
mockAcceptSshPtyOutputData.mockReset().mockResolvedValue({})
mockAcceptSshPtyOutputExit.mockReset().mockResolvedValue(undefined)
mockDeployAndLaunchRelay.mockReset().mockResolvedValue({
transport: { write: vi.fn(), onData: vi.fn(), onClose: vi.fn() },
platform: 'linux-x64',
serverBuildId: relayBuildId
})
mockMux.dispose.mockReset()
mockMux.isDisposed.mockReset().mockReturnValue(false)
mockMux.onNotification.mockReset()
mockMux.onNotificationByMethod.mockReset().mockReturnValue(() => {})
mockMux.onDispose.mockReset().mockReturnValue(() => {})
mockMux.request.mockReset().mockImplementation((method: string) =>
Promise.resolve(
method === 'pty.openClient'
? {
protocolVersion: PTY_CONSUMER_SESSION_PROTOCOL_VERSION,
serverBuildId: relayBuildId,
clientGeneration: 1,
role: 'session-owner',
ownerGeneration: 1,
ownerLease: 'ipc-test-owner',
capabilities: {
outputFlowControl: { version: 1, windowSu: DEFAULT_PTY_SOURCE_WINDOW_SU }
}
}
: {}
)
)
mockMux.probeLiveness.mockReset().mockResolvedValue(false)
mockPtyProvider.onData.mockReset()
mockPtyProvider.onExit.mockReset()
mockPtyProvider.onReplay.mockReset()
mockPtyProvider.attachForReconnect.mockReset().mockResolvedValue({})
mockPtyProvider.shutdown.mockReset()
mockPtyProvider.providerGeneration = 0
mockRegisterSshGitProvider.mockReset()
mockPortForwardManager.addForward.mockReset()
mockPortForwardManager.updateForward.mockReset()
mockPortForwardManager.removeForward.mockReset()
mockPortForwardManager.removeForwardAndWait.mockReset()
mockPortForwardManager.listForwards.mockReset().mockReturnValue([])
mockPortForwardManager.removeAllForwards.mockReset()
mockPortForwardManager.dispose.mockReset()
mockPortForwardManager.setCallbacks.mockReset()
mockPortForwardManager.callbacksRef.current = null
powerMonitorOnMock.mockReset()
powerMonitorOffMock.mockReset()
vi.mocked(getSshPtyProvider).mockReset()
vi.mocked(getPtyIdsForConnection).mockReset().mockReturnValue([])
vi.mocked(clearProviderPtyState).mockReset()
vi.mocked(deletePtyOwnership).mockReset()
registerSshHandlers(mockStore as never, () => mockWindow as never)
})
it('registers all expected IPC channels', () => {
const channels = Array.from(handlers.keys())
expect(channels).toContain('ssh:listTargets')
expect(channels).toContain('ssh:addTarget')
expect(channels).toContain('ssh:updateTarget')
expect(channels).toContain('ssh:removeTarget')
expect(channels).toContain('ssh:importConfig')
expect(channels).toContain('ssh:connect')
expect(channels).toContain('ssh:disconnect')
expect(channels).toContain('ssh:terminateSessions')
expect(channels).toContain('ssh:resetRelay')
expect(channels).toContain('ssh:getState')
expect(channels).toContain('ssh:testConnection')
})
it('ssh:listTargets returns targets from store', async () => {
const mockTargets: SshTarget[] = [
{ id: 'ssh-1', label: 'Server 1', host: 'srv1.com', port: 22, username: 'admin' }
]
mockSshStore.listTargets.mockReturnValue(mockTargets)
const result = await handlers.get('ssh:listTargets')!(null, {})
expect(result).toEqual(mockTargets)
})
it('ssh:addTarget calls store.addTarget', async () => {
const newTarget = {
label: 'New Server',
host: 'new.example.com',
port: 22,
username: 'deploy'
}
const withId = { ...newTarget, id: 'ssh-new' }
mockSshStore.addTarget.mockReturnValue(withId)
const result = await handlers.get('ssh:addTarget')!(null, { target: newTarget })
expect(mockSshStore.addTarget).toHaveBeenCalledWith(newTarget)
expect(result).toEqual({ target: withId, repoReadoptions: [] })
})
it('ssh:addTarget returns exact re-adoption evidence and refreshes repos', async () => {
const target = {
id: 'ssh-new',
label: 'Server',
host: 'server.example.com',
port: 22,
username: 'deploy'
}
const repoReadoptions = [
{ oldTargetId: 'ssh-old', newTargetId: 'ssh-new', repoIds: ['repo-1'] }
]
mockSshStore.addTarget.mockReturnValue(target)
mockSshStore.lastRepoReadoptions = repoReadoptions
const result = await handlers.get('ssh:addTarget')!(null, { target })
expect(result).toEqual({ target, repoReadoptions })
expect(mockWindow.webContents.send).toHaveBeenCalledWith('repos:changed')
expect(mockSshStore.lastRepoReadoptions).toEqual([])
})
it('ssh:removeTarget calls store.removeTarget', async () => {
await handlers.get('ssh:removeTarget')!(null, { id: 'ssh-1' })
expect(mockSshStore.removeTarget).toHaveBeenCalledWith('ssh-1')
})
it('ssh:removeTarget removes metadata when disconnect fails', async () => {
const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => undefined)
mockConnectionManager.disconnect.mockRejectedValueOnce(new Error('host unreachable'))
try {
await handlers.get('ssh:removeTarget')!(null, { id: 'ssh-1' })
expect(mockConnectionManager.disconnect).toHaveBeenCalledWith('ssh-1')
expect(mockStore.removeSshRemotePtyLeases).toHaveBeenCalledWith('ssh-1')
expect(mockSshStore.removeTarget).toHaveBeenCalledWith('ssh-1')
} finally {
warnSpy.mockRestore()
}
})
it('ssh:removeTarget tears down an active relay before deleting the target', async () => {
const target: SshTarget = {
id: 'ssh-1',
label: 'Server',
host: 'example.com',
port: 22,
username: 'deploy'
}
mockSshStore.getTarget.mockReturnValue(target)
mockConnectionManager.connect.mockResolvedValue({})
mockConnectionManager.getState.mockReturnValue({
targetId: 'ssh-1',
status: 'connected',
error: null,
reconnectAttempt: 0
})
await handlers.get('ssh:connect')!(null, { targetId: 'ssh-1' })
mockPortForwardManager.removeAllForwards.mockClear()
mockConnectionManager.disconnect.mockClear().mockResolvedValue(undefined)
await handlers.get('ssh:removeTarget')!(null, { id: 'ssh-1' })
expect(mockPortForwardManager.removeAllForwards).toHaveBeenCalledWith('ssh-1')
expect(mockMux.dispose).toHaveBeenCalledWith('shutdown')
expect(mockStore.markSshRemotePtyLeasesAsync).toHaveBeenCalledWith('ssh-1', 'terminated')
expect(mockConnectionManager.disconnect).toHaveBeenCalledWith('ssh-1')
expect(mockStore.removeSshRemotePtyLeases).toHaveBeenCalledWith('ssh-1')
expect(mockSshStore.removeTarget).toHaveBeenCalledWith('ssh-1')
})
it('ssh:importConfig returns imported targets', async () => {
const imported: SshTarget[] = [
{ id: 'ssh-imp', label: 'staging', host: 'staging.com', port: 22, username: '' }
]
mockSshStore.importFromSshConfig.mockReturnValue(imported)
const result = await handlers.get('ssh:importConfig')!(null, {})
expect(result).toEqual({ targets: imported, repoReadoptions: [] })
})
it('ssh:connect throws for unknown targetId', async () => {
mockSshStore.getTarget.mockReturnValue(undefined)
await expect(handlers.get('ssh:connect')!(null, { targetId: 'unknown' })).rejects.toThrow(
'SSH target "unknown" not found'
)
})
it('ssh:connect calls connection manager', async () => {
const target: SshTarget = {
id: 'ssh-1',
label: 'Server',
host: 'example.com',
port: 22,
username: 'deploy'
}
mockSshStore.getTarget.mockReturnValue(target)
mockConnectionManager.connect.mockResolvedValue({})
mockConnectionManager.getState.mockReturnValue({
targetId: 'ssh-1',
status: 'connected',
error: null,
reconnectAttempt: 0
})
await handlers.get('ssh:connect')!(null, { targetId: 'ssh-1' })
expect(mockConnectionManager.connect).toHaveBeenCalledWith(target)
})
it('registers the provider before broadcasting connected authority', async () => {
const target: SshTarget = {
id: 'ssh-1',
label: 'Server',
host: 'example.com',
port: 22,
username: 'deploy'
}
mockSshStore.getTarget.mockReturnValue(target)
mockConnectionManager.connect.mockResolvedValue({})
mockConnectionManager.getState.mockReturnValue({
targetId: 'ssh-1',
status: 'connected',
error: null,
reconnectAttempt: 0
})
await handlers.get('ssh:connect')!(null, { targetId: 'ssh-1' })
const connectedIndex = mockWindow.webContents.send.mock.calls.findIndex(
([channel, payload]) =>
channel === 'ssh:state-changed' &&
(payload as { state: SshConnectionState }).state.status === 'connected'
)
expect(connectedIndex).toBeGreaterThanOrEqual(0)
expect(mockRegisterSshGitProvider.mock.invocationCallOrder[0]).toBeLessThan(
mockWindow.webContents.send.mock.invocationCallOrder[connectedIndex]
)
expect(mockWindow.webContents.send.mock.calls[connectedIndex]?.[1]).toEqual({
targetId: 'ssh-1',
state: expect.objectContaining({
targetId: 'ssh-1',
status: 'connected',
providerEpoch: expect.any(String),
connectionGeneration: 1
})
})
})
it('ssh:connect exposes the detected remote platform in public state', async () => {
const target: SshTarget = {
id: 'ssh-1',
label: 'Windows Server',
host: 'windows.example.com',
port: 22,
username: 'deploy'
}
const hostPlatform = {
relayPlatform: 'win32-x64',
os: 'win32',
arch: 'x64',
pathFlavor: 'windows',
commandDialect: 'powershell',
pathSeparator: '\\',
pathDelimiter: ';'
}
mockDeployAndLaunchRelay.mockResolvedValueOnce({
transport: { write: vi.fn(), onData: vi.fn(), onClose: vi.fn() },
serverBuildId: relayBuildId,
hostPlatform
})
mockSshStore.getTarget.mockReturnValue(target)
mockConnectionManager.connect.mockResolvedValue({})
mockConnectionManager.getState.mockReturnValue({
targetId: 'ssh-1',
status: 'connected',
error: null,
reconnectAttempt: 0
})
await expect(handlers.get('ssh:connect')!(null, { targetId: 'ssh-1' })).resolves.toEqual({
targetId: 'ssh-1',
status: 'connected',
error: null,
reconnectAttempt: 0,
providerEpoch: expect.any(String),
connectionGeneration: 1,
remotePlatform: 'win32'
})
expect(mockWindow.webContents.send).toHaveBeenCalledWith('ssh:state-changed', {
targetId: 'ssh-1',
state: {
targetId: 'ssh-1',
status: 'connected',
error: null,
reconnectAttempt: 0,
providerEpoch: expect.any(String),
connectionGeneration: 1,
supportsFolderDownload: true,
remotePlatform: 'win32'
}
})
})
it('surfaces relay channel loss while the SSH connection remains alive', async () => {
vi.useFakeTimers()
const target: SshTarget = {
id: 'ssh-1',
label: 'Server',
host: 'example.com',
port: 22,
username: 'deploy'
}
const conn = {}
mockSshStore.getTarget.mockReturnValue(target)
mockConnectionManager.connect.mockResolvedValue(conn)
mockConnectionManager.getConnection.mockReturnValue(conn)
mockConnectionManager.getState.mockReturnValue({
targetId: 'ssh-1',
status: 'connected',
error: null,
reconnectAttempt: 0
})
try {
await handlers.get('ssh:connect')!(null, { targetId: 'ssh-1' })
const onDispose = mockMux.onDispose.mock.calls[0]?.[0] as
| ((reason: 'shutdown' | 'connection_lost') => void)
| undefined
onDispose?.('connection_lost')
const reconnectingState = handlers.get('ssh:getState')!(null, {
targetId: 'ssh-1'
}) as SshConnectionState
expect(reconnectingState).toEqual({
targetId: 'ssh-1',
status: 'reconnecting',
error: 'Relay channel lost. Reconnecting...',
reconnectAttempt: 1,
providerEpoch: expect.any(String),
connectionGeneration: 2
})
expect(mockWindow.webContents.send).toHaveBeenCalledWith('ssh:state-changed', {
targetId: 'ssh-1',
state: reconnectingState
})
await vi.advanceTimersByTimeAsync(500)
const connectedState = handlers.get('ssh:getState')!(null, {
targetId: 'ssh-1'
}) as SshConnectionState
expect(connectedState).toEqual({
targetId: 'ssh-1',
status: 'connected',
error: null,
reconnectAttempt: 0,
providerEpoch: reconnectingState.providerEpoch,
connectionGeneration: reconnectingState.connectionGeneration
})
expect(mockWindow.webContents.send).toHaveBeenCalledWith('ssh:state-changed', {
targetId: 'ssh-1',
state: {
...connectedState,
supportsFolderDownload: true
}
})
expect(() => assertSshMutationExpectation('ssh-1', 'ssh-1', 1)).toThrow(
'SSH connection changed; refresh and try again'
)
expect(() => assertSshMutationExpectation('ssh-1', 'ssh-1', 2)).not.toThrow()
} finally {
vi.useRealTimers()
}
})
it('rejects a staged mutation after the underlying SSH transport reconnects', async () => {
const target: SshTarget = {
id: 'ssh-1',
label: 'Server',
host: 'example.com',
port: 22,
username: 'deploy'
}
const conn = {}
mockSshStore.getTarget.mockReturnValue(target)
mockConnectionManager.connect.mockResolvedValue(conn)
mockConnectionManager.getConnection.mockReturnValue(conn)
mockConnectionManager.getState.mockReturnValue({
targetId: 'ssh-1',
status: 'connected',
error: null,
reconnectAttempt: 0
})
await handlers.get('ssh:connect')!(null, { targetId: 'ssh-1' })
const stagedGeneration = 1
const callbacks = mockConnectionManager.callbacksRef.current as {
onStateChange: (targetId: string, state: SshConnectionState) => void
}
callbacks.onStateChange('ssh-1', {
targetId: 'ssh-1',
status: 'reconnecting',
error: null,
reconnectAttempt: 1
})
callbacks.onStateChange('ssh-1', {
targetId: 'ssh-1',
status: 'connected',
error: null,
reconnectAttempt: 0
})
callbacks.onStateChange('ssh-1', {
targetId: 'ssh-1',
status: 'connected',
error: null,
reconnectAttempt: 0
})
expect(handlers.get('ssh:getState')!(null, { targetId: 'ssh-1' })).toEqual({
targetId: 'ssh-1',
status: 'reconnecting',
error: 'Relay channel reconnecting...',
reconnectAttempt: 0,
providerEpoch: expect.any(String),
connectionGeneration: 2
})
expect(() => assertSshMutationExpectation('ssh-1', 'ssh-1', stagedGeneration)).toThrow(
'SSH connection changed; refresh and try again'
)
expect(() => assertSshMutationExpectation('ssh-1', 'ssh-1', 2)).not.toThrow()
})
// Why: reproduces the "Infinite reconnect bug" — when the raw SSH transport
// connects but relay deploy fails permanently (dev build missing the platform
// relay package), doConnect must not leak the transport's premature 'connected'
// to the renderer. The renderer treats 'connected' as "session fully up" and
// remounts SSH panes (-> window.api.ssh.connect); a premature 'connected' on
// every failing attempt drives an unbounded reconnect loop.
it('does not broadcast a premature connected when relay deploy fails', async () => {
const target: SshTarget = {
id: 'ssh-1',
label: 'Server',
host: 'example.com',
port: 22,
username: 'deploy'
}
const conn = {}
mockSshStore.getTarget.mockReturnValue(target)
// Why: mirror the real SshConnection — connect() drives the raw transport to
// 'connected' via onStateChange BEFORE the relay session establishes. The await
// yields a microtask so this lands after connectTarget records connectInFlight,
// matching the real ssh2 'ready' event (which fires async, post connect() call).
mockConnectionManager.connect.mockImplementation(async () => {
await Promise.resolve()
const callbacks = mockConnectionManager.callbacksRef.current as {
onStateChange: (targetId: string, state: SshConnectionState) => void
}
callbacks.onStateChange('ssh-1', {
targetId: 'ssh-1',
status: 'connecting',
error: null,
reconnectAttempt: 0
})
callbacks.onStateChange('ssh-1', {
targetId: 'ssh-1',
status: 'connected',
error: null,
reconnectAttempt: 0,
supportsFolderDownload: true
})
return conn
})
mockConnectionManager.getConnection.mockReturnValue(conn)
mockConnectionManager.disconnect.mockResolvedValue(undefined)
mockDeployAndLaunchRelay
.mockReset()
.mockRejectedValue(
new Error(
'Relay package for linux-x64 not found locally. ' +
'This may be a packaging issue — try reinstalling Orca.'
)
)
await expect(handlers.get('ssh:connect')!(null, { targetId: 'ssh-1' })).rejects.toThrow(
'not found locally'
)
// Main performs exactly one connect + one disconnect per IPC (no main-side loop).
expect(mockConnectionManager.connect).toHaveBeenCalledTimes(1)
expect(mockConnectionManager.disconnect).toHaveBeenCalledWith('ssh-1')
// The renderer must never see 'connected' for a connect whose relay never
// became ready — doConnect broadcasts the authoritative 'connected' only after
// establish() succeeds, which it does not here.
const connectedBroadcasts = mockWindow.webContents.send.mock.calls.filter(
([channel, payload]) =>
channel === 'ssh:state-changed' &&
(payload as { state?: SshConnectionState }).state?.status === 'connected'
)
expect(connectedBroadcasts).toEqual([])
})
// Why: guards the fix's scope. A relay version mismatch during a relay reconnect
// strands the session 'idle' in activeSessions (only doConnect deletes it). A later
// transport blip then delivers a raw 'connected' with NO connect in flight — the
// 'deploying-relay' hold must NOT fire there (it would wedge the UI on an eternal
// spinner with every reconnect/reset control disabled). The hold is gated to live
// connects via connectInFlight.
it('does not hold a stray connected as deploying-relay when no connect is in flight', async () => {
vi.useFakeTimers()
vi.setSystemTime(0)
const target: SshTarget = {
id: 'ssh-1',
label: 'Server',
host: 'example.com',
port: 22,
username: 'deploy'
}
const conn = {}
mockSshStore.getTarget.mockReturnValue(target)
mockConnectionManager.connect.mockResolvedValue(conn)
mockConnectionManager.getConnection.mockReturnValue(conn)
mockConnectionManager.getState.mockReturnValue({
targetId: 'ssh-1',
status: 'connected',
error: null,
reconnectAttempt: 0
})
try {
// Establish a ready relay session, then lose the relay and fail the reconnect with
// a version mismatch so the session is left stranded 'idle' in activeSessions.
await handlers.get('ssh:connect')!(null, { targetId: 'ssh-1' })
mockDeployAndLaunchRelay
.mockReset()
.mockRejectedValue(new RelayVersionMismatchError('2.0.0', '1.0.0'))
getLatestRelayDisposeCallback()('connection_lost')
await vi.advanceTimersByTimeAsync(relayReconnectDelaysMs[0])
// The terminal relay error is surfaced; the session is now stranded 'idle'.
expect(
(handlers.get('ssh:getState')!(null, { targetId: 'ssh-1' }) as SshConnectionState).status
).toBe('error')
const callbacks = mockConnectionManager.callbacksRef.current as {
onStateChange: (targetId: string, state: SshConnectionState) => void
}
mockWindow.webContents.send.mockClear()
// A transport blip on the still-live SSH socket auto-recovers to 'connected' with
// no ssh:connect in flight (connectInFlight is empty).
callbacks.onStateChange('ssh-1', {
targetId: 'ssh-1',
status: 'reconnecting',
error: null,
reconnectAttempt: 0
})
callbacks.onStateChange('ssh-1', {
targetId: 'ssh-1',
status: 'connected',
error: null,
reconnectAttempt: 0
})
// The stray 'connected' is forwarded as-is — never wedged at 'deploying-relay'.
const stateChanges = mockWindow.webContents.send.mock.calls.filter(
([channel]) => channel === 'ssh:state-changed'
)
const lastStateChange = stateChanges.at(-1)
expect(lastStateChange).toBeDefined()
expect((lastStateChange![1] as { state: SshConnectionState }).state.status).toBe('connected')
const heldAsDeploying = stateChanges.some(
([, payload]) =>
(payload as { state?: SshConnectionState }).state?.status === 'deploying-relay'
)
expect(heldAsDeploying).toBe(false)
} finally {
vi.useRealTimers()
}
})
it('rebuilds instead of reusing a ready session while relay loss is pending', async () => {
vi.useFakeTimers()
const target: SshTarget = {
id: 'ssh-1',
label: 'Server',
host: 'example.com',
port: 22,
username: 'deploy'
}
const conn = {}
mockSshStore.getTarget.mockReturnValue(target)
mockConnectionManager.connect.mockResolvedValue(conn)
mockConnectionManager.getConnection.mockReturnValue(conn)
mockConnectionManager.getState.mockReturnValue({
targetId: 'ssh-1',
status: 'connected',
error: null,
reconnectAttempt: 0
})
try {
await handlers.get('ssh:connect')!(null, { targetId: 'ssh-1' })
const onDispose = mockMux.onDispose.mock.calls[0]?.[0] as
| ((reason: 'shutdown' | 'connection_lost') => void)
| undefined
onDispose?.('connection_lost')
expect(handlers.get('ssh:getState')!(null, { targetId: 'ssh-1' })).toEqual({
targetId: 'ssh-1',
status: 'reconnecting',
error: 'Relay channel lost. Reconnecting...',
reconnectAttempt: 1,
providerEpoch: expect.any(String),
connectionGeneration: 2
})
mockDeployAndLaunchRelay.mockClear()
mockPortForwardManager.removeAllForwards.mockClear()
await expect(handlers.get('ssh:connect')!(null, { targetId: 'ssh-1' })).resolves.toEqual({
targetId: 'ssh-1',
status: 'connected',
error: null,
reconnectAttempt: 0,
providerEpoch: expect.any(String),
connectionGeneration: 3
})
expect(mockPortForwardManager.removeAllForwards).toHaveBeenCalledWith('ssh-1')
expect(mockDeployAndLaunchRelay).toHaveBeenCalled()
expect(handlers.get('ssh:getState')!(null, { targetId: 'ssh-1' })).toEqual({
targetId: 'ssh-1',
status: 'connected',
error: null,
reconnectAttempt: 0,
providerEpoch: expect.any(String),
connectionGeneration: 3
})
} finally {
vi.useRealTimers()
}
})
it('keeps counting slow unstable relay reconnects until manual reconnect is required', async () => {
vi.useFakeTimers()
vi.setSystemTime(0)
const target: SshTarget = {
id: 'ssh-1',
label: 'Server',
host: 'example.com',
port: 22,
username: 'deploy'
}
const conn = {}
mockSshStore.getTarget.mockReturnValue(target)
mockConnectionManager.connect.mockResolvedValue(conn)
mockConnectionManager.getConnection.mockReturnValue(conn)
mockConnectionManager.getState.mockReturnValue({
targetId: 'ssh-1',
status: 'connected',
error: null,
reconnectAttempt: 0
})
try {
await handlers.get('ssh:connect')!(null, { targetId: 'ssh-1' })
for (const [index, delayMs] of relayReconnectDelaysMs.entries()) {
useSlowRelayLaunchOnce(relayLostStabilizedMs + 1)
getLatestRelayDisposeCallback()('connection_lost')
await vi.advanceTimersByTimeAsync(delayMs + relayLostStabilizedMs + 1)
expect(handlers.get('ssh:getState')!(null, { targetId: 'ssh-1' })).toEqual({
targetId: 'ssh-1',
status: 'connected',
error: null,
reconnectAttempt: 0,
providerEpoch: expect.any(String),
connectionGeneration: index + 2
})
}
getLatestRelayDisposeCallback()('connection_lost')
expect(handlers.get('ssh:getState')!(null, { targetId: 'ssh-1' })).toEqual({
targetId: 'ssh-1',
status: 'error',
error: 'Relay channel kept dropping. Click Reconnect on the SSH target before retrying.',
reconnectAttempt: 0,
providerEpoch: expect.any(String),
connectionGeneration: relayReconnectDelaysMs.length + 2
})
} finally {
vi.useRealTimers()
}
})
describe('relay loss while the SSH transport is down', () => {
const relayLostTarget: SshTarget = {
id: 'ssh-1',
label: 'Server',
host: 'example.com',
port: 22,
username: 'deploy'
}
const transportState = (status: SshConnectionStatus): SshConnectionState => ({
targetId: 'ssh-1',
status,
error: null,
reconnectAttempt: 0
})
const setTransportStatus = (status: SshConnectionStatus): void => {
mockConnectionManager.getState.mockReturnValue(transportState(status))
}
const maxRelayDelayMs = relayReconnectDelaysMs.at(-1)!
const connectWithLiveTransport = async (): Promise<void> => {
mockSshStore.getTarget.mockReturnValue(relayLostTarget)
mockConnectionManager.connect.mockResolvedValue({})
mockConnectionManager.getConnection.mockReturnValue({})
setTransportStatus('connected')
await handlers.get('ssh:connect')!(null, { targetId: 'ssh-1' })
mockDeployAndLaunchRelay.mockClear()
}
it('does not consume attempts or publish the manual-reconnect banner', async () => {
vi.useFakeTimers()
vi.setSystemTime(0)
try {
await connectWithLiveTransport()
setTransportStatus('reconnecting')
getLatestRelayDisposeCallback()('connection_lost')
// Well past the whole 6-step ladder: a redeploy cannot ride a dead transport, so nothing is spent.
const fullLadderMs = relayReconnectDelaysMs.reduce((sum, delay) => sum + delay, 0)
await vi.advanceTimersByTimeAsync(fullLadderMs + relayLostStabilizedMs)
expect(mockDeployAndLaunchRelay).not.toHaveBeenCalled()
expect(handlers.get('ssh:getState')!(null, { targetId: 'ssh-1' })).toEqual({
targetId: 'ssh-1',
status: 'reconnecting',
error: 'Relay channel lost. Reconnecting...',
reconnectAttempt: 0,
providerEpoch: expect.any(String),
connectionGeneration: 2
})
setTransportStatus('connected')
await vi.advanceTimersByTimeAsync(maxRelayDelayMs)
expect(mockDeployAndLaunchRelay).toHaveBeenCalledTimes(1)
expect(
(handlers.get('ssh:getState')!(null, { targetId: 'ssh-1' }) as SshConnectionState).status
).toBe('connected')
} finally {
vi.useRealTimers()
}
})
it('stops retrying once the transport reaches a terminal state', async () => {
vi.useFakeTimers()
vi.setSystemTime(0)
try {
await connectWithLiveTransport()
setTransportStatus('reconnecting')
getLatestRelayDisposeCallback()('connection_lost')
await vi.advanceTimersByTimeAsync(maxRelayDelayMs)
setTransportStatus('reconnection-failed')
await vi.advanceTimersByTimeAsync(maxRelayDelayMs)
// The wait loop is gone: only onStateChange's redeploy may revive the relay after this.
setTransportStatus('connected')
await vi.advanceTimersByTimeAsync(maxRelayDelayMs * 4)
expect(mockDeployAndLaunchRelay).not.toHaveBeenCalled()
} finally {
vi.useRealTimers()
}
})
it('resets the relay budget when the connection disappears before retry', async () => {
vi.useFakeTimers()
vi.setSystemTime(0)
try {
await connectWithLiveTransport()
getLatestRelayDisposeCallback()('connection_lost')
mockConnectionManager.getConnection.mockReturnValue(undefined)
await vi.advanceTimersByTimeAsync(relayReconnectDelaysMs[0])
mockConnectionManager.getConnection.mockReturnValue({})
getLatestRelayDisposeCallback()('connection_lost')
expect(handlers.get('ssh:getState')!(null, { targetId: 'ssh-1' })).toEqual(
expect.objectContaining({ reconnectAttempt: 1 })
)
} finally {
vi.useRealTimers()
}
})
it('still reaches the manual-reconnect banner when the transport is healthy', async () => {
vi.useFakeTimers()
vi.setSystemTime(0)
try {
await connectWithLiveTransport()
mockDeployAndLaunchRelay.mockRejectedValue(new Error('relay refused'))
getLatestRelayDisposeCallback()('connection_lost')
for (const delayMs of relayReconnectDelaysMs) {
await vi.advanceTimersByTimeAsync(delayMs)
}
expect(
(handlers.get('ssh:getState')!(null, { targetId: 'ssh-1' }) as SshConnectionState).error
).toBe('Relay channel kept dropping. Click Reconnect on the SSH target before retrying.')
} finally {
vi.useRealTimers()
}
})
it('restores the full relay budget once the transport reconnects', async () => {
vi.useFakeTimers()
vi.setSystemTime(0)
try {
await connectWithLiveTransport()
mockDeployAndLaunchRelay.mockRejectedValue(new Error('relay refused'))
getLatestRelayDisposeCallback()('connection_lost')
await vi.advanceTimersByTimeAsync(relayReconnectDelaysMs[0])
const callbacks = mockConnectionManager.callbacksRef.current as {
onStateChange: (targetId: string, state: SshConnectionState) => void
}
callbacks.onStateChange('ssh-1', transportState('reconnecting'))
callbacks.onStateChange('ssh-1', transportState('connected'))
await vi.advanceTimersByTimeAsync(0)
// Budget reset: the next loss waits the base delay again instead of the third ladder step.
mockDeployAndLaunchRelay.mockClear()
await vi.advanceTimersByTimeAsync(relayReconnectDelaysMs[0])
expect(mockDeployAndLaunchRelay).toHaveBeenCalledTimes(1)
} finally {
vi.useRealTimers()
}
})
})
it('reuses a fast relay reconnect after the post-ready stabilization window', async () => {
vi.useFakeTimers()
vi.setSystemTime(0)
const target: SshTarget = {
id: 'ssh-1',
label: 'Server',
host: 'example.com',
port: 22,
username: 'deploy'
}
const conn = {}
mockSshStore.getTarget.mockReturnValue(target)
mockConnectionManager.connect.mockResolvedValue(conn)
mockConnectionManager.getConnection.mockReturnValue(conn)
mockConnectionManager.getState.mockReturnValue({
targetId: 'ssh-1',
status: 'connected',
error: null,
reconnectAttempt: 0
})
try {
await handlers.get('ssh:connect')!(null, { targetId: 'ssh-1' })
getLatestRelayDisposeCallback()('connection_lost')
await vi.advanceTimersByTimeAsync(relayReconnectDelaysMs[0])
expect(handlers.get('ssh:getState')!(null, { targetId: 'ssh-1' })).toEqual({
targetId: 'ssh-1',
status: 'connected',
error: null,
reconnectAttempt: 0,
providerEpoch: expect.any(String),
connectionGeneration: 2
})
await vi.advanceTimersByTimeAsync(relayLostStabilizedMs + 1)
mockDeployAndLaunchRelay.mockClear()
mockPortForwardManager.removeAllForwards.mockClear()
await expect(handlers.get('ssh:connect')!(null, { targetId: 'ssh-1' })).resolves.toEqual({
targetId: 'ssh-1',
status: 'connected',
error: null,
reconnectAttempt: 0,
providerEpoch: expect.any(String),
connectionGeneration: 2
})
expect(mockPortForwardManager.removeAllForwards).not.toHaveBeenCalled()
expect(mockDeployAndLaunchRelay).not.toHaveBeenCalled()
} finally {
vi.useRealTimers()
}
})
it('forwards remote PTY events through the output intake authority', async () => {
const runtime = {
onPtyData: vi.fn(),
onPtyExit: vi.fn()
}
registerSshHandlers(mockStore as never, () => mockWindow as never, runtime as never)
const target: SshTarget = {
id: 'ssh-1',
label: 'Server',
host: 'example.com',
port: 22,
username: 'deploy'
}
mockSshStore.getTarget.mockReturnValue(target)
mockConnectionManager.connect.mockResolvedValue({})
mockConnectionManager.getState.mockReturnValue({
targetId: 'ssh-1',
status: 'connected',
error: null,
reconnectAttempt: 0
})
await handlers.get('ssh:connect')!(null, { targetId: 'ssh-1' })
const onData = mockPtyProvider.onData.mock.calls[0]?.[0] as SshPtyDataCallback | undefined
const onExit = mockPtyProvider.onExit.mock.calls[0]?.[0] as
| ((payload: {
id: string
code: number
providerGeneration: number
ptyIncarnation: string
}) => void)
| undefined
onData?.({
id: 'remote-pty',
data: 'hello',
providerGeneration: mockPtyProvider.providerGeneration,
ptyIncarnation: 'ipc-test-pty',
source: ipcTestSource
})
onExit?.({
id: 'remote-pty',
code: 7,
providerGeneration: mockPtyProvider.providerGeneration,
ptyIncarnation: 'ipc-test-pty'
})
expect(mockAcceptSshPtyOutputData).toHaveBeenCalledWith({
id: 'remote-pty',
data: 'hello',
providerGeneration: mockPtyProvider.providerGeneration,
ptyIncarnation: 'ipc-test-pty',
rawLength: 'hello'.length,
transformed: false,
source: ipcTestSource
})
expect(mockAcceptSshPtyOutputExit).toHaveBeenCalledWith({
id: 'remote-pty',
code: 7,
providerGeneration: mockPtyProvider.providerGeneration,
ptyIncarnation: 'ipc-test-pty'
})
expect(runtime.onPtyData).not.toHaveBeenCalled()
expect(runtime.onPtyExit).not.toHaveBeenCalled()
})
it('mirrors SSH state broadcasts onto the runtime client-event stream', async () => {
const runtime = {
onPtyData: vi.fn(),
onPtyExit: vi.fn(),
notifySshStateChanged: vi.fn(),
notifySshRelayReady: vi.fn()
}
registerSshHandlers(mockStore as never, () => mockWindow as never, runtime as never)
const target: SshTarget = {
id: 'ssh-1',
label: 'Server',
host: 'example.com',
port: 22,
username: 'deploy'
}
mockSshStore.getTarget.mockReturnValue(target)
mockConnectionManager.connect.mockResolvedValue({})
mockConnectionManager.getState.mockReturnValue({
targetId: 'ssh-1',
status: 'connected',
error: null,
reconnectAttempt: 0
})
await handlers.get('ssh:connect')!(null, { targetId: 'ssh-1' })
// Why: paired remote clients only learn SSH state through this hook —
// without it their reconnect overlays never clear (STA-1468).
expect(runtime.notifySshStateChanged).toHaveBeenCalledWith(
'ssh-1',
expect.objectContaining({ targetId: 'ssh-1', status: 'connected' })
)
expect(runtime.notifySshRelayReady).toHaveBeenCalledWith('ssh-1')
})
it('keeps runtime-owned SSH state off the renderer while invalidating runtime scans', async () => {
const runtime = {
onPtyData: vi.fn(),
onPtyExit: vi.fn(),
invalidateSshWorktreeScanCache: vi.fn(),
notifySshStateChanged: vi.fn()
}
registerSshHandlers(mockStore as never, () => mockWindow as never, runtime as never)
mockSshStore.getTarget.mockReturnValue({
id: 'runtime-ssh-1',
label: 'Runtime host',
host: 'example.com',
port: 22,
username: 'deploy'
} satisfies SshTarget)
mockConnectionManager.connect.mockResolvedValue({})
mockConnectionManager.getState.mockReturnValue({
targetId: 'runtime-ssh-1',
status: 'connected',
error: null,
reconnectAttempt: 0
})
await handlers.get('ssh:connect')!(null, { targetId: 'runtime-ssh-1' })
expect(mockWindow.webContents.send).not.toHaveBeenCalledWith(
'ssh:state-changed',
expect.anything()
)
expect(runtime.invalidateSshWorktreeScanCache).toHaveBeenCalledWith('runtime-ssh-1')
expect(runtime.notifySshStateChanged).not.toHaveBeenCalled()
})
it('invalidates runtime scans from hidden SSH state broadcasts', () => {
const runtime = {
onPtyData: vi.fn(),
onPtyExit: vi.fn(),
invalidateSshWorktreeScanCache: vi.fn(),
notifySshStateChanged: vi.fn()
}
registerSshHandlers(mockStore as never, () => mockWindow as never, runtime as never)
const callbacks = mockConnectionManager.callbacksRef.current as {
onStateChange: (targetId: string, state: SshConnectionState) => void
}
callbacks.onStateChange('runtime-ssh-1', {
targetId: 'runtime-ssh-1',
status: 'disconnected',
error: null,
reconnectAttempt: 1
})
expect(runtime.invalidateSshWorktreeScanCache).toHaveBeenCalledWith('runtime-ssh-1')
expect(runtime.notifySshStateChanged).not.toHaveBeenCalled()
expect(mockWindow.webContents.send).not.toHaveBeenCalledWith(
'ssh:state-changed',
expect.anything()
)
})
it('preserves active port forwards and live connections across handler re-registration', async () => {
const target: SshTarget = {
id: 'ssh-1',
label: 'Server',
host: 'example.com',
port: 22,
username: 'deploy'
}
const conn = {}
const forward = {
id: 'pf-1',
connectionId: 'ssh-1',
localPort: 4100,
remoteHost: '127.0.0.1',
remotePort: 3000,
label: 'app'
}
const updatedForward = { ...forward, remotePort: 3001 }
const newForward = { ...forward, id: 'pf-2', localPort: 4101 }
const connectedState = {
targetId: 'ssh-1',
status: 'connected' as const,
error: null,
reconnectAttempt: 0
}
mockSshStore.getTarget.mockReturnValue(target)
mockConnectionManager.connect.mockResolvedValue(conn)
mockConnectionManager.getConnection.mockReturnValue(conn)
mockConnectionManager.getState.mockReturnValue(connectedState)
mockPortForwardManager.addForward
.mockResolvedValueOnce(forward)
.mockResolvedValueOnce(newForward)
mockPortForwardManager.updateForward.mockResolvedValue(updatedForward)
mockPortForwardManager.removeForwardAndWait.mockResolvedValue(updatedForward)
mockPortForwardManager.listForwards.mockReturnValue([forward])
await handlers.get('ssh:connect')!(null, { targetId: 'ssh-1' })
await handlers.get('ssh:addPortForward')!(null, {
targetId: 'ssh-1',
localPort: 4100,
remoteHost: '127.0.0.1',
remotePort: 3000,
label: 'app'
})
const replacementConnectionManager = createConnectionManagerMock()
const replacementPortForwardManager = createPortForwardManagerMock()
mockNextConnectionManagers.push(replacementConnectionManager)
mockNextPortForwardManagers.push(replacementPortForwardManager)
registerSshHandlers(mockStore as never, () => createMockWindow() as never)
expect(getSshConnectionManager()).toBe(mockConnectionManager)
expect(await handlers.get('ssh:listPortForwards')!(null, { targetId: 'ssh-1' })).toEqual([
forward
])
mockDeployAndLaunchRelay.mockClear()
mockPortForwardManager.removeAllForwards.mockClear()
await expect(handlers.get('ssh:connect')!(null, { targetId: 'ssh-1' })).resolves.toEqual({
...connectedState,
providerEpoch: expect.any(String),
connectionGeneration: 1
})
expect(mockDeployAndLaunchRelay).not.toHaveBeenCalled()
expect(mockPortForwardManager.removeAllForwards).not.toHaveBeenCalled()
expect(await handlers.get('ssh:listPortForwards')!(null, { targetId: 'ssh-1' })).toEqual([
forward
])
await handlers.get('ssh:updatePortForward')!(null, {
id: 'pf-1',
targetId: 'ssh-1',
localPort: 4100,
remoteHost: '127.0.0.1',
remotePort: 3001,
label: 'app'
})
expect(mockPortForwardManager.updateForward).toHaveBeenCalledWith(
'pf-1',
conn,
4100,
'127.0.0.1',
3001,
'app'
)
expect(await handlers.get('ssh:removePortForward')!(null, { id: 'pf-1' })).toEqual(
updatedForward
)
await handlers.get('ssh:addPortForward')!(null, {
targetId: 'ssh-1',
localPort: 4101,
remoteHost: '127.0.0.1',
remotePort: 3000,
label: 'app'
})
expect(mockPortForwardManager.addForward).toHaveBeenLastCalledWith(
'ssh-1',
conn,
4101,
'127.0.0.1',
3000,
'app'
)
expect(replacementConnectionManager.getConnection).not.toHaveBeenCalled()
expect(replacementPortForwardManager.listForwards).not.toHaveBeenCalled()
})
it('persists desired forwards and broadcasts when an active forward closes unexpectedly', () => {
const target: SshTarget = {
id: 'ssh-1',
label: 'Server',
host: 'example.com',
port: 22,
username: 'deploy',
portForwards: [
{
localPort: 4100,
remoteHost: '127.0.0.1',
remotePort: 3000,
label: 'app'
}
]
}
const forward = {
id: 'pf-1',
connectionId: 'ssh-1',
localPort: 4100,
remoteHost: '127.0.0.1',
remotePort: 3000,
label: 'app'
}
mockSshStore.getTarget.mockReturnValue(target)
mockPortForwardManager.listForwards.mockReturnValue([])
const callbacks = mockPortForwardManager.callbacksRef.current as {
onForwardClosed: (entry: typeof forward, reason: { kind: 'unexpected-exit' }) => void
}
callbacks.onForwardClosed(forward, { kind: 'unexpected-exit' })
expect(mockSshStore.updateTarget).toHaveBeenCalledWith('ssh-1', {
portForwards: [
{
localPort: 4100,
remoteHost: '127.0.0.1',
remotePort: 3000,
label: 'app'
}
]
})
expect(mockWindow.webContents.send).toHaveBeenCalledWith('ssh:port-forwards-changed', {
targetId: 'ssh-1',
forwards: []
})
})
it('disconnects the original session and releases original forwards after re-registration', async () => {
const target: SshTarget = {
id: 'ssh-1',
label: 'Server',
host: 'example.com',
port: 22,
username: 'deploy'
}
const conn = {}
mockSshStore.getTarget.mockReturnValue(target)
mockConnectionManager.connect.mockResolvedValue(conn)
mockConnectionManager.getConnection.mockReturnValue(conn)
mockConnectionManager.getState.mockReturnValue({
targetId: 'ssh-1',
status: 'connected',
error: null,
reconnectAttempt: 0
})
await handlers.get('ssh:connect')!(null, { targetId: 'ssh-1' })
mockPortForwardManager.removeAllForwards.mockClear()
mockConnectionManager.disconnect.mockClear().mockResolvedValue(undefined)
const replacementConnectionManager = createConnectionManagerMock()
const replacementPortForwardManager = createPortForwardManagerMock()
mockNextConnectionManagers.push(replacementConnectionManager)
mockNextPortForwardManagers.push(replacementPortForwardManager)
registerSshHandlers(mockStore as never, () => createMockWindow() as never)
await handlers.get('ssh:disconnect')!(null, { targetId: 'ssh-1' })
expect(mockPortForwardManager.removeAllForwards).toHaveBeenCalledWith('ssh-1')
expect(mockConnectionManager.disconnect).toHaveBeenCalledWith('ssh-1')
expect(replacementPortForwardManager.removeAllForwards).not.toHaveBeenCalled()
expect(replacementConnectionManager.disconnect).not.toHaveBeenCalled()
})
it('refreshes live session callbacks to the newest window and output authorities', async () => {
const firstWindow = createMockWindow()
const secondWindow = createMockWindow()
const firstRuntime = {
onPtyData: vi.fn(),
onPtyExit: vi.fn()
}
const secondRuntime = {
onPtyData: vi.fn(),
onPtyExit: vi.fn()
}
registerSshHandlers(mockStore as never, () => firstWindow as never, firstRuntime as never)
const target: SshTarget = {
id: 'ssh-1',
label: 'Server',
host: 'example.com',
port: 22,
username: 'deploy'
}
const conn = {}
mockSshStore.getTarget.mockReturnValue(target)
mockConnectionManager.connect.mockResolvedValue(conn)
mockConnectionManager.getConnection.mockReturnValue(conn)
mockConnectionManager.getState.mockReturnValue({
targetId: 'ssh-1',
status: 'connected',
error: null,
reconnectAttempt: 0
})
await handlers.get('ssh:connect')!(null, { targetId: 'ssh-1' })
const onData = mockPtyProvider.onData.mock.calls[0]?.[0] as SshPtyDataCallback | undefined
const onExit = mockPtyProvider.onExit.mock.calls[0]?.[0] as
| ((payload: {
id: string
code: number
providerGeneration: number
ptyIncarnation: string
}) => void)
| undefined
const onDetectedPorts = mockPortScannerCallbacks.get('ssh-1') as
| ((targetId: string, ports: unknown[], platform: string) => void)
| undefined
firstWindow.webContents.send.mockClear()
secondWindow.webContents.send.mockClear()
registerSshHandlers(mockStore as never, () => secondWindow as never, secondRuntime as never)
const callbacks = mockConnectionManager.callbacksRef.current as {
onStateChange: (targetId: string, state: unknown) => void
}
callbacks.onStateChange('ssh-1', {
targetId: 'ssh-1',
status: 'error',
error: 'network down',
reconnectAttempt: 0
})
onData?.({
id: 'remote-pty',
data: 'hello',
providerGeneration: mockPtyProvider.providerGeneration,
ptyIncarnation: 'ipc-test-pty',
source: ipcTestSource
})
onExit?.({
id: 'remote-pty',
code: 9,
providerGeneration: mockPtyProvider.providerGeneration,
ptyIncarnation: 'ipc-test-pty'
})
onDetectedPorts?.(
'ssh-1',
[{ host: '127.0.0.1', port: 3000, pid: 12, processName: 'node' }],
'linux-x64'
)
expect(firstWindow.webContents.send).not.toHaveBeenCalled()
expect(secondWindow.webContents.send).toHaveBeenCalledWith('ssh:state-changed', {
targetId: 'ssh-1',
state: {
targetId: 'ssh-1',
status: 'error',
error: 'network down',
reconnectAttempt: 0,
providerEpoch: expect.any(String),
connectionGeneration: 1
}
})
expect(mockAcceptSshPtyOutputData).toHaveBeenCalledWith(
expect.objectContaining({ id: 'remote-pty', data: 'hello' })
)
expect(mockAcceptSshPtyOutputExit).toHaveBeenCalledWith(
expect.objectContaining({ id: 'remote-pty', code: 9 })
)
expect(secondWindow.webContents.send).toHaveBeenCalledWith('ssh:detected-ports-changed', {
targetId: 'ssh-1',
ports: expect.arrayContaining([expect.objectContaining({ port: 3000 })])
})
expect(secondRuntime.onPtyData).not.toHaveBeenCalled()
expect(secondRuntime.onPtyExit).not.toHaveBeenCalled()
expect(firstRuntime.onPtyData).not.toHaveBeenCalled()
expect(firstRuntime.onPtyExit).not.toHaveBeenCalled()
})
it('re-registers without replacing managers when no targets are connected', () => {
const replacementConnectionManager = createConnectionManagerMock()
const replacementPortForwardManager = createPortForwardManagerMock()
mockNextConnectionManagers.push(replacementConnectionManager)
mockNextPortForwardManagers.push(replacementPortForwardManager)
const result = registerSshHandlers(mockStore as never, () => createMockWindow() as never)
expect(result.connectionManager).toBe(mockConnectionManager)
expect(replacementConnectionManager.setCallbacks).not.toHaveBeenCalled()
expect(replacementPortForwardManager.dispose).not.toHaveBeenCalled()
expect(mockNextConnectionManagers).toHaveLength(1)
expect(mockNextPortForwardManagers).toHaveLength(1)
})
it('ssh:disconnect calls connection manager', async () => {
mockConnectionManager.disconnect.mockResolvedValue(undefined)
await handlers.get('ssh:disconnect')!(null, { targetId: 'ssh-1' })
expect(mockConnectionManager.disconnect).toHaveBeenCalledWith('ssh-1')
})
it('lets a same-turn disconnect invalidate connect before transport admission', async () => {
const target: SshTarget = {
id: 'ssh-1',
label: 'Server',
host: 'example.com',
port: 22,
username: 'deploy'
}
mockSshStore.getTarget.mockReturnValue(target)
mockConnectionManager.connect.mockResolvedValue({})
mockConnectionManager.disconnect.mockResolvedValue(undefined)
const connect = handlers.get('ssh:connect')!(null, {
targetId: 'ssh-1'
}) as Promise<SshConnectionState>
const disconnect = handlers.get('ssh:disconnect')!(null, {
targetId: 'ssh-1'
}) as Promise<void>
await disconnect
await expect(connect).rejects.toThrow('SSH connection attempt was cancelled')
expect(mockConnectionManager.connect).not.toHaveBeenCalled()
})
it('invalidates a pending connect when disconnect wins and allows a fresh connect', async () => {
const target: SshTarget = {
id: 'ssh-1',
label: 'Server',
host: 'example.com',
port: 22,
username: 'deploy'
}
const staleConn = {}
const freshConn = {}
let resolveStaleConnect!: (connection: unknown) => void
let resolveForwardRemoval!: () => void
let transportConnectPending = false
mockSshStore.getTarget.mockReturnValue(target)
mockConnectionManager.connect
.mockReturnValueOnce(
new Promise((resolve) => {
transportConnectPending = true
resolveStaleConnect = resolve
})
)
.mockImplementationOnce(async () => {
if (transportConnectPending) {
throw new Error('Connection to Server is already in progress')
}
return freshConn
})
mockConnectionManager.disconnect.mockImplementationOnce(async () => {
transportConnectPending = false
})
mockPortForwardManager.removeAllForwards.mockImplementationOnce(
() =>
new Promise<void>((resolve) => {
resolveForwardRemoval = resolve
})
)
mockConnectionManager.getState.mockReturnValue({
targetId: 'ssh-1',
status: 'connected',
error: null,
reconnectAttempt: 0
})
const staleConnect = handlers.get('ssh:connect')!(null, {
targetId: 'ssh-1'
}) as Promise<SshConnectionState>
await vi.waitFor(() => expect(mockConnectionManager.connect).toHaveBeenCalledTimes(1))
const disconnect = handlers.get('ssh:disconnect')!(null, {
targetId: 'ssh-1'
}) as Promise<void>
await vi.waitFor(() => expect(mockConnectionManager.disconnect).toHaveBeenCalledWith('ssh-1'))
const freshConnect = handlers.get('ssh:connect')!(null, {
targetId: 'ssh-1'
}) as Promise<SshConnectionState>
resolveStaleConnect(staleConn)
await expect(staleConnect).rejects.toThrow('SSH connection attempt was cancelled')
expect(mockConnectionManager.connect).toHaveBeenCalledTimes(1)
resolveForwardRemoval()
await disconnect
await vi.waitFor(() => expect(mockConnectionManager.connect).toHaveBeenCalledTimes(2))
await expect(freshConnect).resolves.toMatchObject({ targetId: 'ssh-1', status: 'connected' })
expect(mockDeployAndLaunchRelay).toHaveBeenCalledTimes(1)
})
it('keeps reconnect behind transport disconnect when forward teardown fails', async () => {
const target: SshTarget = {
id: 'ssh-1',
label: 'Server',
host: 'example.com',
port: 22,
username: 'deploy'
}
let resolveTransportDisconnect!: () => void
let transportDisconnectPending = false
mockSshStore.getTarget.mockReturnValue(target)
mockConnectionManager.connect.mockResolvedValueOnce({}).mockImplementationOnce(async () => {
if (transportDisconnectPending) {
throw new Error('Connection to Server is already in progress')
}
return {}
})
mockConnectionManager.disconnect.mockImplementationOnce(
() =>
new Promise<void>((resolve) => {
transportDisconnectPending = true
resolveTransportDisconnect = () => {
transportDisconnectPending = false
resolve()
}
})
)
mockConnectionManager.getState.mockReturnValue({
targetId: 'ssh-1',
status: 'connected',
error: null,
reconnectAttempt: 0
})
await handlers.get('ssh:connect')!(null, { targetId: 'ssh-1' })
mockPortForwardManager.removeAllForwards.mockRejectedValueOnce(
new Error('forward teardown failed')
)
const disconnect = handlers.get('ssh:disconnect')!(null, {
targetId: 'ssh-1'
}) as Promise<void>
const disconnectSettled = vi.fn()
void disconnect.then(disconnectSettled, disconnectSettled)
await vi.waitFor(() =>
expect(mockPortForwardManager.removeAllForwards).toHaveBeenCalledWith('ssh-1')
)
const reconnect = handlers.get('ssh:connect')!(null, {
targetId: 'ssh-1'
}) as Promise<SshConnectionState>
const reconnectResult = reconnect.then(
(state) => ({ ok: true as const, state }),
(error: unknown) => ({ ok: false as const, error })
)
await Promise.resolve()
expect(disconnectSettled).not.toHaveBeenCalled()
expect(mockConnectionManager.connect).toHaveBeenCalledTimes(1)
resolveTransportDisconnect()
await expect(disconnect).rejects.toThrow('forward teardown failed')
await expect(reconnectResult).resolves.toMatchObject({
ok: true,
state: { targetId: 'ssh-1', status: 'connected' }
})
expect(mockConnectionManager.connect).toHaveBeenCalledTimes(2)
expect(mockMux.dispose).toHaveBeenCalledWith('connection_lost')
})
it('retires a removed target session after forward teardown fails', async () => {
const target: SshTarget = {
id: 'ssh-1',
label: 'Server',
host: 'example.com',
port: 22,
username: 'deploy'
}
let resolveTransportDisconnect!: () => void
mockSshStore.getTarget.mockReturnValue(target)
mockConnectionManager.connect.mockResolvedValue({})
mockConnectionManager.disconnect.mockImplementationOnce(
() =>
new Promise<void>((resolve) => {
resolveTransportDisconnect = resolve
})
)
mockConnectionManager.getState.mockReturnValue({
targetId: 'ssh-1',
status: 'connected',
error: null,
reconnectAttempt: 0
})
await handlers.get('ssh:connect')!(null, { targetId: 'ssh-1' })
mockPortForwardManager.removeAllForwards.mockRejectedValueOnce(
new Error('forward teardown failed')
)
const removal = handlers.get('ssh:removeTarget')!(null, {
id: 'ssh-1'
}) as Promise<void>
await vi.waitFor(() =>
expect(mockPortForwardManager.removeAllForwards).toHaveBeenCalledWith('ssh-1')
)
await Promise.resolve()
expect(mockSshStore.removeTarget).not.toHaveBeenCalled()
resolveTransportDisconnect()
await removal
expect(mockMux.dispose).toHaveBeenCalledWith('shutdown')
expect(mockStore.removeSshRemotePtyLeases).toHaveBeenCalledWith('ssh-1')
expect(mockSshStore.removeTarget).toHaveBeenCalledWith('ssh-1')
})
it('replaces a stale shared connect after authority rotates without disconnect', async () => {
const target: SshTarget = {
id: 'ssh-1',
label: 'Server',
host: 'example.com',
port: 22,
username: 'deploy'
}
let resolveStaleConnect!: (connection: unknown) => void
let resolveForwardRemoval!: () => void
let resolveTransportDisconnect!: () => void
let transportConnectPending = false
mockSshStore.getTarget.mockReturnValue(target)
mockSshStore.addTarget.mockReturnValue(target)
mockConnectionManager.connect
.mockReturnValueOnce(
new Promise((resolve) => {
transportConnectPending = true
resolveStaleConnect = resolve
})
)
.mockImplementationOnce(async () => {
if (transportConnectPending) {
throw new Error('Connection to Server is already in progress')
}
return {}
})
mockConnectionManager.disconnect.mockImplementationOnce(
() =>
new Promise<void>((resolve) => {
resolveTransportDisconnect = () => {
transportConnectPending = false
resolve()
}
})
)
mockPortForwardManager.removeAllForwards.mockImplementationOnce(
() =>
new Promise<void>((resolve) => {
resolveForwardRemoval = resolve
})
)
mockConnectionManager.getState.mockReturnValue({
targetId: 'ssh-1',
status: 'connected',
error: null,
reconnectAttempt: 0
})
const staleConnect = handlers.get('ssh:connect')!(null, {
targetId: 'ssh-1'
}) as Promise<SshConnectionState>
const sharedStaleConnect = handlers.get('ssh:connect')!(null, {
targetId: 'ssh-1'
}) as Promise<SshConnectionState>
await vi.waitFor(() => expect(mockConnectionManager.connect).toHaveBeenCalledTimes(1))
mockSshStore.lastRepoReadoptions = [
{ oldTargetId: 'ssh-1', newTargetId: 'ssh-new', repoIds: ['repo-1'] }
]
await handlers.get('ssh:addTarget')!(null, { target })
const freshConnect = handlers.get('ssh:connect')!(null, {
targetId: 'ssh-1'
}) as Promise<SshConnectionState>
await vi.waitFor(() =>
expect(mockPortForwardManager.removeAllForwards).toHaveBeenCalledWith('ssh-1')
)
await vi.waitFor(() => expect(mockConnectionManager.disconnect).toHaveBeenCalledWith('ssh-1'))
const sharedFreshConnect = handlers.get('ssh:connect')!(null, {
targetId: 'ssh-1'
}) as Promise<SshConnectionState>
expect(mockConnectionManager.connect).toHaveBeenCalledTimes(1)
resolveForwardRemoval()
resolveTransportDisconnect()
await vi.waitFor(() => expect(mockConnectionManager.connect).toHaveBeenCalledTimes(2))
resolveStaleConnect({})
await expect(staleConnect).rejects.toThrow('SSH connection attempt was cancelled')
await expect(sharedStaleConnect).rejects.toThrow('SSH connection attempt was cancelled')
await expect(freshConnect).resolves.toMatchObject({ targetId: 'ssh-1', status: 'connected' })
await expect(sharedFreshConnect).resolves.toMatchObject({
targetId: 'ssh-1',
status: 'connected'
})
expect(mockDeployAndLaunchRelay).toHaveBeenCalledTimes(1)
})
it('ssh:terminateSessions preserves tracking when relay shutdown fails', async () => {
const target: SshTarget = {
id: 'ssh-1',
label: 'Server',
host: 'example.com',
port: 22,
username: 'deploy'
}
mockSshStore.getTarget.mockReturnValue(target)
mockConnectionManager.connect.mockResolvedValue({})
mockConnectionManager.getState.mockReturnValue({
targetId: 'ssh-1',
status: 'connected',
error: null,
reconnectAttempt: 0
})
mockStore.getSshRemotePtyLeases.mockReturnValue([
{ targetId: 'ssh-1', ptyId: 'pty-1', state: 'detached' }
])
vi.mocked(getSshPtyProvider).mockReturnValue(mockPtyProvider as never)
vi.mocked(getPtyIdsForConnection).mockReturnValue(['pty-1'])
mockPtyProvider.shutdown.mockRejectedValue(new Error('mux down'))
await handlers.get('ssh:connect')!(null, { targetId: 'ssh-1' })
await expect(
handlers.get('ssh:terminateSessions')!(null, { targetId: 'ssh-1' })
).rejects.toThrow('Failed to terminate SSH host sessions')
expect(mockStore.markSshRemotePtyLease).not.toHaveBeenCalledWith('ssh-1', 'pty-1', 'terminated')
expect(mockConnectionManager.disconnect).not.toHaveBeenCalledWith('ssh-1')
})
it('ssh:terminateSessions cleans scoped live PTYs while tombstoning raw leases', async () => {
const target: SshTarget = {
id: 'ssh-1',
label: 'Server',
host: 'example.com',
port: 22,
username: 'deploy'
}
mockSshStore.getTarget.mockReturnValue(target)
mockConnectionManager.connect.mockResolvedValue({})
mockConnectionManager.getState.mockReturnValue({
targetId: 'ssh-1',
status: 'connected',
error: null,
reconnectAttempt: 0
})
mockStore.getSshRemotePtyLeases.mockReturnValue([
{ targetId: 'ssh-1', ptyId: 'pty-lease', state: 'detached' }
])
vi.mocked(getSshPtyProvider).mockReturnValue(mockPtyProvider as never)
vi.mocked(getPtyIdsForConnection).mockReturnValue(['ssh:ssh-1@@pty-live'])
mockPtyProvider.shutdown.mockResolvedValue(undefined)
await handlers.get('ssh:connect')!(null, { targetId: 'ssh-1' })
await handlers.get('ssh:terminateSessions')!(null, { targetId: 'ssh-1' })
expect(mockPtyProvider.shutdown).toHaveBeenCalledWith('ssh:ssh-1@@pty-live', {
immediate: true,
keepHistory: false
})
expect(mockPtyProvider.shutdown).toHaveBeenCalledWith('ssh:ssh-1@@pty-lease', {
immediate: true,
keepHistory: false
})
expect(clearProviderPtyState).toHaveBeenCalledWith('ssh:ssh-1@@pty-live')
expect(clearProviderPtyState).toHaveBeenCalledWith('ssh:ssh-1@@pty-lease')
expect(deletePtyOwnership).toHaveBeenCalledWith('ssh:ssh-1@@pty-live')
expect(deletePtyOwnership).toHaveBeenCalledWith('ssh:ssh-1@@pty-lease')
expect(mockStore.markSshRemotePtyLease).toHaveBeenCalledWith('ssh-1', 'pty-live', 'terminated')
expect(mockStore.markSshRemotePtyLease).toHaveBeenCalledWith('ssh-1', 'pty-lease', 'terminated')
})
it('keeps reconnect behind the complete terminate-sessions lifecycle', async () => {
const target: SshTarget = {
id: 'ssh-1',
label: 'Server',
host: 'example.com',
port: 22,
username: 'deploy'
}
let resolveShutdown!: () => void
let resolveForwardRemoval!: () => void
mockSshStore.getTarget.mockReturnValue(target)
mockConnectionManager.connect.mockResolvedValue({})
mockConnectionManager.getState.mockReturnValue({
targetId: 'ssh-1',
status: 'connected',
error: null,
reconnectAttempt: 0
})
mockStore.getSshRemotePtyLeases.mockReturnValue([
{ targetId: 'ssh-1', ptyId: 'pty-1', state: 'detached' }
])
vi.mocked(getSshPtyProvider).mockReturnValue(mockPtyProvider as never)
vi.mocked(getPtyIdsForConnection).mockReturnValue([])
mockPtyProvider.shutdown.mockReturnValueOnce(
new Promise<void>((resolve) => {
resolveShutdown = resolve
})
)
mockPortForwardManager.removeAllForwards.mockImplementationOnce(
() =>
new Promise<void>((resolve) => {
resolveForwardRemoval = resolve
})
)
await handlers.get('ssh:connect')!(null, { targetId: 'ssh-1' })
const terminate = handlers.get('ssh:terminateSessions')!(null, {
targetId: 'ssh-1'
}) as Promise<void>
await vi.waitFor(() => expect(mockPtyProvider.shutdown).toHaveBeenCalledOnce())
const reconnect = handlers.get('ssh:connect')!(null, {
targetId: 'ssh-1'
}) as Promise<SshConnectionState>
expect(mockConnectionManager.connect).toHaveBeenCalledTimes(1)
resolveShutdown()
await vi.waitFor(() => expect(mockConnectionManager.disconnect).toHaveBeenCalledWith('ssh-1'))
expect(mockConnectionManager.connect).toHaveBeenCalledTimes(1)
resolveForwardRemoval()
await terminate
await vi.waitFor(() => expect(mockConnectionManager.connect).toHaveBeenCalledTimes(2))
await expect(reconnect).resolves.toMatchObject({ targetId: 'ssh-1', status: 'connected' })
})
it('ssh:terminateSessions ignores expired leases when disconnected', async () => {
mockStore.getSshRemotePtyLeases.mockReturnValue([
{ targetId: 'ssh-1', ptyId: 'pty-expired', state: 'expired' }
])
vi.mocked(getSshPtyProvider).mockReturnValue(undefined)
vi.mocked(getPtyIdsForConnection).mockReturnValue([])
await expect(
handlers.get('ssh:terminateSessions')!(null, { targetId: 'ssh-1' })
).resolves.toBeUndefined()
expect(mockPtyProvider.shutdown).not.toHaveBeenCalled()
expect(mockConnectionManager.disconnect).toHaveBeenCalledWith('ssh-1')
})
it('ssh:resetRelay force-stops the remote relay and expires tracked leases', async () => {
const target: SshTarget = {
id: 'ssh-1',
label: 'Server',
host: 'example.com',
port: 22,
username: 'deploy'
}
const conn = {}
mockSshStore.getTarget.mockReturnValue(target)
mockConnectionManager.connect.mockResolvedValue(conn)
mockConnectionManager.getConnection.mockReturnValue(undefined)
mockStore.getSshRemotePtyLeases.mockReturnValue([
{ targetId: 'ssh-1', ptyId: 'pty-1', state: 'detached' },
{ targetId: 'ssh-1', ptyId: 'pty-expired', state: 'expired' }
])
vi.mocked(getPtyIdsForConnection).mockReturnValue(['pty-2'])
await handlers.get('ssh:resetRelay')!(null, { targetId: 'ssh-1' })
expect(mockConnectionManager.connect).toHaveBeenCalledWith(target)
expect(mockForceStopRelayForTarget).toHaveBeenCalledWith(conn, 'ssh-1')
expect(mockStore.markSshRemotePtyLease).toHaveBeenCalledWith('ssh-1', 'pty-1', 'expired')
expect(mockStore.markSshRemotePtyLease).not.toHaveBeenCalledWith(
'ssh-1',
'pty-expired',
'expired'
)
expect(mockConnectionManager.disconnect).toHaveBeenCalledWith('ssh-1')
})
it('ssh:resetRelay clears scoped live PTYs while expiring raw leases', async () => {
const target: SshTarget = {
id: 'ssh-1',
label: 'Server',
host: 'example.com',
port: 22,
username: 'deploy'
}
const conn = {}
mockSshStore.getTarget.mockReturnValue(target)
mockConnectionManager.connect.mockResolvedValue(conn)
mockConnectionManager.getConnection.mockReturnValue(undefined)
mockStore.getSshRemotePtyLeases.mockReturnValue([
{ targetId: 'ssh-1', ptyId: 'pty-lease', state: 'detached' }
])
vi.mocked(getPtyIdsForConnection).mockReturnValue(['ssh:ssh-1@@pty-live'])
await handlers.get('ssh:resetRelay')!(null, { targetId: 'ssh-1' })
expect(mockStore.markSshRemotePtyLease).toHaveBeenCalledWith('ssh-1', 'pty-lease', 'expired')
expect(clearProviderPtyState).toHaveBeenCalledWith('ssh:ssh-1@@pty-live')
expect(clearProviderPtyState).toHaveBeenCalledWith('ssh:ssh-1@@pty-lease')
expect(deletePtyOwnership).toHaveBeenCalledWith('ssh:ssh-1@@pty-live')
expect(deletePtyOwnership).toHaveBeenCalledWith('ssh:ssh-1@@pty-lease')
expect(mockConnectionManager.disconnect).toHaveBeenCalledWith('ssh-1')
})
it('retires the captured session when reset forward teardown fails', async () => {
const target: SshTarget = {
id: 'ssh-1',
label: 'Server',
host: 'example.com',
port: 22,
username: 'deploy'
}
const conn = {}
mockSshStore.getTarget.mockReturnValue(target)
mockConnectionManager.connect.mockResolvedValue(conn)
mockConnectionManager.getConnection.mockReturnValue(conn)
mockConnectionManager.getState.mockReturnValue({
targetId: 'ssh-1',
status: 'connected',
error: null,
reconnectAttempt: 0
})
await handlers.get('ssh:connect')!(null, { targetId: 'ssh-1' })
mockPortForwardManager.removeAllForwards.mockRejectedValueOnce(
new Error('forward teardown failed')
)
await expect(handlers.get('ssh:resetRelay')!(null, { targetId: 'ssh-1' })).rejects.toThrow(
'forward teardown failed'
)
expect(mockMux.dispose).toHaveBeenCalledWith('connection_lost')
expect(mockForceStopRelayForTarget).not.toHaveBeenCalled()
await handlers.get('ssh:resetRelay')!(null, { targetId: 'ssh-1' })
expect(mockPortForwardManager.removeAllForwards).toHaveBeenCalledTimes(1)
expect(mockForceStopRelayForTarget).toHaveBeenCalledWith(conn, 'ssh-1')
expect(mockConnectionManager.disconnect).toHaveBeenCalledWith('ssh-1')
})
it('ssh:resetRelay waits for an in-flight connect before tearing down the session', async () => {
const target: SshTarget = {
id: 'ssh-1',
label: 'Server',
host: 'example.com',
port: 22,
username: 'deploy'
}
const conn = {}
let resolveConnect!: (value: unknown) => void
const connectResult = new Promise((resolve) => {
resolveConnect = resolve
})
mockSshStore.getTarget.mockReturnValue(target)
mockConnectionManager.connect.mockReturnValue(connectResult)
mockConnectionManager.getConnection.mockReturnValue(conn)
mockConnectionManager.getState.mockReturnValue({
targetId: 'ssh-1',
status: 'connected',
error: null,
reconnectAttempt: 0
})
const connectPromise = handlers.get('ssh:connect')!(null, {
targetId: 'ssh-1'
}) as Promise<unknown>
await vi.waitFor(() => expect(mockConnectionManager.connect).toHaveBeenCalledTimes(1))
const resetPromise = handlers.get('ssh:resetRelay')!(null, {
targetId: 'ssh-1'
}) as Promise<void>
await Promise.resolve()
expect(mockPortForwardManager.removeAllForwards).not.toHaveBeenCalled()
expect(mockForceStopRelayForTarget).not.toHaveBeenCalled()
resolveConnect(conn)
await connectPromise
await resetPromise
expect(mockConnectionManager.connect).toHaveBeenCalledTimes(1)
expect(mockPortForwardManager.removeAllForwards).toHaveBeenCalledWith('ssh-1')
expect(mockForceStopRelayForTarget).toHaveBeenCalledWith(conn, 'ssh-1')
expect(mockConnectionManager.disconnect).toHaveBeenCalledWith('ssh-1')
})
it('ssh:connect waits for an in-flight reset before starting a new connection', async () => {
const target: SshTarget = {
id: 'ssh-1',
label: 'Server',
host: 'example.com',
port: 22,
username: 'deploy'
}
const resetConn = {}
const connectConn = {}
let resolveForceStop!: () => void
const forceStopResult = new Promise<void>((resolve) => {
resolveForceStop = resolve
})
mockSshStore.getTarget.mockReturnValue(target)
mockConnectionManager.getConnection.mockReturnValue(resetConn)
mockConnectionManager.connect.mockResolvedValue(connectConn)
mockConnectionManager.getState.mockReturnValue({
targetId: 'ssh-1',
status: 'connected',
error: null,
reconnectAttempt: 0
})
mockForceStopRelayForTarget.mockReturnValue(forceStopResult)
const resetPromise = handlers.get('ssh:resetRelay')!(null, {
targetId: 'ssh-1'
}) as Promise<void>
const connectPromise = handlers.get('ssh:connect')!(null, {
targetId: 'ssh-1'
}) as Promise<unknown>
await vi.waitFor(() => expect(mockForceStopRelayForTarget).toHaveBeenCalledTimes(1))
await Promise.resolve()
expect(mockConnectionManager.connect).not.toHaveBeenCalled()
resolveForceStop()
await resetPromise
await connectPromise
expect(mockConnectionManager.disconnect).toHaveBeenCalledWith('ssh-1')
expect(mockConnectionManager.connect).toHaveBeenCalledTimes(1)
expect(mockConnectionManager.connect).toHaveBeenCalledWith(target)
})
it('ssh:resetRelay reuses duplicate in-flight resets for the same target', async () => {
const target: SshTarget = {
id: 'ssh-1',
label: 'Server',
host: 'example.com',
port: 22,
username: 'deploy'
}
const conn = {}
let resolveForceStop!: () => void
let activeForceStops = 0
let maxConcurrentForceStops = 0
const forceStopResult = new Promise<void>((resolve) => {
resolveForceStop = resolve
})
mockSshStore.getTarget.mockReturnValue(target)
mockConnectionManager.getConnection.mockReturnValue(conn)
mockForceStopRelayForTarget.mockImplementation(async () => {
activeForceStops += 1
maxConcurrentForceStops = Math.max(maxConcurrentForceStops, activeForceStops)
await forceStopResult
activeForceStops -= 1
})
const firstReset = handlers.get('ssh:resetRelay')!(null, {
targetId: 'ssh-1'
}) as Promise<void>
const secondReset = handlers.get('ssh:resetRelay')!(null, {
targetId: 'ssh-1'
}) as Promise<void>
expect(secondReset).toBe(firstReset)
await vi.waitFor(() => expect(mockForceStopRelayForTarget).toHaveBeenCalledTimes(1))
resolveForceStop()
await Promise.all([firstReset, secondReset])
expect(mockForceStopRelayForTarget).toHaveBeenCalledTimes(1)
expect(maxConcurrentForceStops).toBe(1)
expect(mockConnectionManager.disconnect).toHaveBeenCalledTimes(1)
expect(mockConnectionManager.disconnect).toHaveBeenCalledWith('ssh-1')
})
it('keeps removal behind an in-flight relay reset', async () => {
const target: SshTarget = {
id: 'ssh-1',
label: 'Server',
host: 'example.com',
port: 22,
username: 'deploy'
}
let resolveForceStop!: () => void
mockSshStore.getTarget.mockReturnValue(target)
mockConnectionManager.getConnection.mockReturnValue({})
mockConnectionManager.disconnect.mockResolvedValue(undefined)
mockForceStopRelayForTarget.mockReturnValueOnce(
new Promise<void>((resolve) => {
resolveForceStop = resolve
})
)
const reset = handlers.get('ssh:resetRelay')!(null, {
targetId: 'ssh-1'
}) as Promise<void>
await vi.waitFor(() => expect(mockForceStopRelayForTarget).toHaveBeenCalledOnce())
const removal = handlers.get('ssh:removeTarget')!(null, {
id: 'ssh-1'
}) as Promise<void>
await Promise.resolve()
expect(mockSshStore.removeTarget).not.toHaveBeenCalled()
resolveForceStop()
await reset
await removal
expect(mockConnectionManager.disconnect).toHaveBeenCalledTimes(2)
expect(mockSshStore.removeTarget).toHaveBeenCalledWith('ssh-1')
})
it('reconnects on system resume when the relay liveness probe fails', async () => {
const target: SshTarget = {
id: 'ssh-1',
label: 'Server',
host: 'example.com',
port: 22,
username: 'deploy'
}
const conn = {}
mockSshStore.getTarget.mockReturnValue(target)
mockConnectionManager.connect.mockResolvedValue(conn)
mockConnectionManager.getConnection.mockReturnValue(conn)
mockConnectionManager.getState.mockReturnValue({
targetId: 'ssh-1',
status: 'connected',
error: null,
reconnectAttempt: 0
})
mockConnectionManager.reconnect.mockImplementation(async (targetId: string) => {
const callbacks = mockConnectionManager.callbacksRef.current as {
onStateChange: (id: string, state: SshConnectionState) => void
}
callbacks.onStateChange(targetId, {
targetId,
status: 'reconnecting',
error: null,
reconnectAttempt: 1
})
callbacks.onStateChange(targetId, {
targetId,
status: 'connected',
error: null,
reconnectAttempt: 0
})
})
mockMux.probeLiveness.mockResolvedValue(false)
await handlers.get('ssh:connect')!(null, { targetId: 'ssh-1' })
const resumeListener = powerMonitorOnMock.mock.calls.find(([event]) => event === 'resume')?.[1]
expect(resumeListener).toBeTypeOf('function')
resumeListener()
await vi.waitFor(() => expect(mockConnectionManager.reconnect).toHaveBeenCalledWith('ssh-1'))
// Why: a failed first probe gets one retry before teardown (slow post-wake network).
expect(mockMux.probeLiveness).toHaveBeenCalledTimes(2)
expect(handlers.get('ssh:getState')!(null, { targetId: 'ssh-1' })).toMatchObject({
connectionGeneration: 2
})
})
it('skips reconnect on system resume when the relay link is still alive', async () => {
const target: SshTarget = {
id: 'ssh-1',
label: 'Server',
host: 'example.com',
port: 22,
username: 'deploy'
}
const conn = {}
mockSshStore.getTarget.mockReturnValue(target)
mockConnectionManager.connect.mockResolvedValue(conn)
mockConnectionManager.getConnection.mockReturnValue(conn)
mockConnectionManager.getState.mockReturnValue({
targetId: 'ssh-1',
status: 'connected',
error: null,
reconnectAttempt: 0
})
mockMux.probeLiveness.mockResolvedValue(true)
await handlers.get('ssh:connect')!(null, { targetId: 'ssh-1' })
const resumeListener = powerMonitorOnMock.mock.calls.find(([event]) => event === 'resume')?.[1]
expect(resumeListener).toBeTypeOf('function')
resumeListener()
await vi.waitFor(() => expect(mockMux.probeLiveness).toHaveBeenCalledTimes(1))
// Let the async resume handler settle before asserting no teardown happened.
await new Promise((resolve) => setTimeout(resolve, 0))
expect(mockConnectionManager.reconnect).not.toHaveBeenCalled()
})
it('does not reconnect after resume when the target was disconnected during the probe', async () => {
const target: SshTarget = {
id: 'ssh-1',
label: 'Server',
host: 'example.com',
port: 22,
username: 'deploy'
}
const conn = {}
mockSshStore.getTarget.mockReturnValue(target)
mockConnectionManager.connect.mockResolvedValue(conn)
mockConnectionManager.getConnection.mockReturnValue(conn)
mockConnectionManager.getState.mockReturnValue({
targetId: 'ssh-1',
status: 'connected',
error: null,
reconnectAttempt: 0
})
mockMux.probeLiveness.mockResolvedValue(false)
await handlers.get('ssh:connect')!(null, { targetId: 'ssh-1' })
const resumeListener = powerMonitorOnMock.mock.calls.find(([event]) => event === 'resume')?.[1]
expect(resumeListener).toBeTypeOf('function')
resumeListener()
// Why: the probe window is seconds long; a user disconnect during it must
// win — reconnecting afterwards would resurrect the torn-down target.
mockConnectionManager.getConnection.mockReturnValue(undefined)
await vi.waitFor(() => expect(mockMux.probeLiveness).toHaveBeenCalledTimes(2))
await new Promise((resolve) => setTimeout(resolve, 0))
expect(mockConnectionManager.reconnect).not.toHaveBeenCalled()
})
it('extends active relay grace while the system is suspending', async () => {
const target: SshTarget = {
id: 'ssh-1',
label: 'Server',
host: 'example.com',
port: 22,
username: 'deploy'
}
const conn = {}
mockSshStore.getTarget.mockReturnValue(target)
mockConnectionManager.connect.mockResolvedValue(conn)
mockConnectionManager.getConnection.mockReturnValue(conn)
mockConnectionManager.getState.mockReturnValue({
targetId: 'ssh-1',
status: 'connected',
error: null,
reconnectAttempt: 0
})
await handlers.get('ssh:connect')!(null, { targetId: 'ssh-1' })
mockMux.notify.mockClear()
const suspendListener = powerMonitorOnMock.mock.calls.find(
([event]) => event === 'suspend'
)?.[1]
expect(suspendListener).toBeTypeOf('function')
suspendListener()
expect(mockMux.notify).toHaveBeenCalledWith(SSH_RELAY_CONFIGURE_GRACE_TIME_METHOD, {
graceTimeSeconds: 0
})
})
it('ssh:resetRelay expires active-session leases instead of marking them terminated', async () => {
const target: SshTarget = {
id: 'ssh-1',
label: 'Server',
host: 'example.com',
port: 22,
username: 'deploy'
}
const conn = {}
mockSshStore.getTarget.mockReturnValue(target)
mockConnectionManager.connect.mockResolvedValue(conn)
mockConnectionManager.getConnection.mockReturnValue(conn)
mockConnectionManager.getState.mockReturnValue({
targetId: 'ssh-1',
status: 'connected',
error: null,
reconnectAttempt: 0
})
await handlers.get('ssh:connect')!(null, { targetId: 'ssh-1' })
mockStore.markSshRemotePtyLeasesAsync.mockClear()
mockStore.markSshRemotePtyLease.mockClear()
mockStore.getSshRemotePtyLeases.mockReturnValue([
{ targetId: 'ssh-1', ptyId: 'pty-1', state: 'attached' }
])
await handlers.get('ssh:resetRelay')!(null, { targetId: 'ssh-1' })
expect(mockStore.markSshRemotePtyLeasesAsync).not.toHaveBeenCalledWith('ssh-1', 'terminated')
expect(mockStore.markSshRemotePtyLeasesAsync).toHaveBeenCalledWith('ssh-1', 'detached')
expect(mockStore.markSshRemotePtyLease).toHaveBeenCalledWith('ssh-1', 'pty-1', 'expired')
expect(mockForceStopRelayForTarget).toHaveBeenCalledWith(conn, 'ssh-1')
})
describe('SSH PTY consumer identity across failed connects', () => {
function makeTarget(id: string): SshTarget {
return { id, label: 'Server', host: 'example.com', port: 22, username: 'deploy' }
}
function markConnected(targetId: string): void {
mockConnectionManager.getState.mockReturnValue({
targetId,
status: 'connected',
error: null,
reconnectAttempt: 0
})
}
it('reclaims the consumer identity after a failed transport connect', async () => {
const targetId = 'ssh-consumer-identity-connect-failure'
let settleLeasePersistence!: () => void
mockStore.markSshRemotePtyLeasesAsync.mockImplementationOnce(
() =>
new Promise<void>((resolve) => {
settleLeasePersistence = resolve
})
)
mockSshStore.getTarget.mockReturnValue(makeTarget(targetId))
mockConnectionManager.connect.mockRejectedValueOnce(new Error('transport refused'))
const failedConnect = handlers.get('ssh:connect')!(null, { targetId }) as Promise<unknown>
const failure = expect(failedConnect).rejects.toThrow('transport refused')
const settled = vi.fn()
void failedConnect.then(settled, settled)
await vi.waitFor(() =>
expect(mockStore.markSshRemotePtyLeasesAsync).toHaveBeenCalledWith(targetId, 'detached')
)
expect(mockStore.markSshRemotePtyLeases).not.toHaveBeenCalled()
// Why: the connect rejection is gated on the durable 'detached' write, so the retry it
// triggers cannot re-mark leases 'attached' ahead of the abandoned session's release.
expect(settled).not.toHaveBeenCalled()
settleLeasePersistence()
await failure
const claimedId = getSshPtyConsumerRecovery(targetId)?.clientInstanceId
expect(claimedId).toEqual(expect.any(String))
mockConnectionManager.connect.mockResolvedValue({})
markConnected(targetId)
await handlers.get('ssh:connect')!(null, { targetId })
expect(getSshPtyConsumerRecovery(targetId)?.clientInstanceId).toBe(claimedId)
expect(mockStore.upsertSshPtyConsumerRecovery).toHaveBeenCalledWith(
expect.objectContaining({ targetId, clientInstanceId: claimedId })
)
})
it('releases the abandoned leases before a fast reconnect re-owns them', async () => {
const targetId = 'ssh-consumer-identity-fast-reconnect'
const order: string[] = []
let settleLeaseRelease!: () => void
mockStore.markSshRemotePtyLeasesAsync.mockImplementationOnce((_id: string, state: string) => {
order.push(`leases:${state}`)
return new Promise<void>((resolve) => {
settleLeaseRelease = () => {
order.push(`leases:${state}:persisted`)
resolve()
}
})
})
mockStore.upsertSshPtyConsumerRecovery.mockImplementation(async () => {
order.push('recovery:upsert')
})
mockSshStore.getTarget.mockReturnValue(makeTarget(targetId))
mockConnectionManager.connect.mockRejectedValueOnce(new Error('transport refused'))
const failedConnect = handlers.get('ssh:connect')!(null, { targetId })
const failure = expect(failedConnect).rejects.toThrow('transport refused')
await vi.waitFor(() => expect(order).toContain('leases:detached'))
expect(order).not.toContain('leases:detached:persisted')
settleLeaseRelease()
await failure
mockConnectionManager.connect.mockResolvedValue({})
markConnected(targetId)
await handlers.get('ssh:connect')!(null, { targetId })
// Why: the reclaimed owner is only re-persisted after the abandoned 'detached' write landed,
// so no late release can strand the reconnected leases in 'detached'.
expect(order).toEqual(['leases:detached', 'leases:detached:persisted', 'recovery:upsert'])
})
it('holds a retry that starts while the detach write is still pending', async () => {
const targetId = 'ssh-consumer-identity-pending-retry'
const order: string[] = []
let settleLeaseRelease!: () => void
mockStore.markSshRemotePtyLeasesAsync.mockImplementationOnce((_id: string, state: string) => {
order.push(`leases:${state}`)
return new Promise<void>((resolve) => {
settleLeaseRelease = () => {
order.push(`leases:${state}:persisted`)
resolve()
}
})
})
mockStore.upsertSshPtyConsumerRecovery.mockImplementation(async () => {
order.push('recovery:upsert')
})
mockSshStore.getTarget.mockReturnValue(makeTarget(targetId))
mockConnectionManager.connect.mockRejectedValueOnce(new Error('transport refused'))
const failedConnect = handlers.get('ssh:connect')!(null, { targetId })
const failure = expect(failedConnect).rejects.toThrow('transport refused')
await vi.waitFor(() => expect(order).toContain('leases:detached'))
// Retry mid-write: it must not mint a session or re-own leases while the release is pending.
mockConnectionManager.connect.mockResolvedValue({})
markConnected(targetId)
const retry = handlers.get('ssh:connect')!(null, { targetId }) as Promise<unknown>
const retrySettled = vi.fn()
void retry.then(retrySettled, retrySettled)
await new Promise((resolve) => setTimeout(resolve, 0))
expect(retrySettled).not.toHaveBeenCalled()
expect(order).not.toContain('leases:detached:persisted')
settleLeaseRelease()
await failure
// Why: the retry folds onto the still-latched attempt rather than starting a second connect,
// so it inherits that attempt's failure instead of racing its teardown.
await expect(retry).rejects.toThrow('transport refused')
expect(mockConnectionManager.connect).toHaveBeenCalledTimes(1)
expect(order).toEqual(['leases:detached', 'leases:detached:persisted'])
await handlers.get('ssh:connect')!(null, { targetId })
expect(order).toEqual(['leases:detached', 'leases:detached:persisted', 'recovery:upsert'])
})
it('replaces a live session whose detach write keeps failing', async () => {
const targetId = 'ssh-consumer-identity-detach-write-failure'
mockSshStore.getTarget.mockReturnValue(makeTarget(targetId))
mockConnectionManager.connect.mockResolvedValue({})
markConnected(targetId)
await handlers.get('ssh:connect')!(null, { targetId })
const claimedId = getSshPtyConsumerRecovery(targetId)?.clientInstanceId
expect(claimedId).toEqual(expect.any(String))
// Why a permanent reject, not once: it proves the failed session is gone rather than merely
// retried — a second connect that still holds it would fail on the same write again.
mockStore.markSshRemotePtyLeasesAsync.mockImplementation((_id: string, state: string) =>
state === 'detached'
? Promise.reject(new Error('lease write failed'))
: Promise.resolve(undefined)
)
await expect(handlers.get('ssh:connect')!(null, { targetId })).rejects.toThrow(
'lease write failed'
)
mockConnectionManager.connect.mockClear()
await handlers.get('ssh:connect')!(null, { targetId })
expect(mockConnectionManager.connect).toHaveBeenCalledTimes(1)
// Why: the abandoned session still released its identity synchronously, so the replacement
// reclaims the owner instead of minting a new one.
expect(getSshPtyConsumerRecovery(targetId)?.clientInstanceId).toBe(claimedId)
})
it('resumes the remembered owner lease after a failed establish', async () => {
const targetId = 'ssh-consumer-identity-establish-failure'
const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
mockSshStore.getTarget.mockReturnValue(makeTarget(targetId))
mockConnectionManager.connect.mockResolvedValue({})
markConnected(targetId)
// Why: fail the first request after the consumer session opens, so establish() rejects with an
// owner lease already remembered — the state a retry must be able to resume from.
const openClientResponse = await mockMux.request('pty.openClient')
mockMux.request.mockImplementationOnce(() => Promise.resolve(openClientResponse))
mockMux.request.mockImplementationOnce(() =>
Promise.reject(new Error('relay handshake aborted'))
)
mockStore.markSshRemotePtyLeasesAsync.mockRejectedValueOnce(
new Error('lease persistence failed')
)
try {
await expect(handlers.get('ssh:connect')!(null, { targetId })).rejects.toThrow(
'relay handshake aborted'
)
await vi.waitFor(() => expect(warn).toHaveBeenCalled())
const claimedId = getSshPtyConsumerRecovery(targetId)?.clientInstanceId
expect(claimedId).toEqual(expect.any(String))
mockMux.request.mockClear()
await handlers.get('ssh:connect')!(null, { targetId })
expect(getSshPtyConsumerRecovery(targetId)?.clientInstanceId).toBe(claimedId)
expect(mockMux.request).toHaveBeenCalledWith(
'pty.openClient',
expect.objectContaining({
clientInstanceId: claimedId,
resume: { ownerGeneration: 1, ownerLease: 'ipc-test-owner' }
}),
expect.anything()
)
} finally {
warn.mockRestore()
}
})
})
it('ssh:getState returns connection state', async () => {
const state = {
targetId: 'ssh-1',
status: 'connected',
error: null,
reconnectAttempt: 0
}
mockConnectionManager.getState.mockReturnValue(state)
const result = await handlers.get('ssh:getState')!(null, { targetId: 'ssh-1' })
expect(result).toEqual({
...state,
providerEpoch: expect.any(String),
connectionGeneration: 0
})
})
})