test: remove low-value IPC and SSH recovery cases

This commit is contained in:
OrcaWin
2026-11-09 16:26:36 -08:00
parent 668089d638
commit 2576a09c7b
9 changed files with 39 additions and 2454 deletions
File diff suppressed because one or more lines are too long
@@ -5804,7 +5804,6 @@
"src/renderer/src/components/terminal-pane/titles/TerminalPaneHeaderOverlay.test.tsx": 1104,
"src/renderer/src/components/terminal-pane/pty-transport/remote-runtime/recovery/TerminalPaneRecoveryPortals.test.tsx": 670,
"src/renderer/src/components/terminal-pane/pty-transport/remote-runtime/recovery/TerminalRemoteRuntimeReconnectBanner.test.tsx": 812,
"src/renderer/src/components/terminal-pane/pty-transport/recovery/ssh/TerminalSshReconnectOverlay.test.tsx": 2354,
"src/renderer/src/components/terminal-pane/account-restart/detached/account-restart-queue-progress.test.ts": 1988,
"src/renderer/src/components/terminal-pane/agent-completion/agent-completion-coordinator-attention-dispatch.test.ts": 301,
"src/renderer/src/components/terminal-pane/agent-completion/agent-completion-coordinator-completion-replay-guard.test.ts": 318,
@@ -5924,7 +5923,6 @@
"src/renderer/src/components/terminal-pane/pty-transport/ipc/pty-transport-pi-coalesce.test.ts": 683,
"src/renderer/src/components/terminal-pane/pty-transport/ipc/pty-transport-reattach-admission.test.ts": 1636,
"src/renderer/src/components/terminal-pane/pty-transport/ipc/pty-transport-recycled-pty-incarnation.test.ts": 787,
"src/renderer/src/components/terminal-pane/pty-transport/ipc/pty-transport-spawn-errors.test.ts": 1218,
"src/renderer/src/components/terminal-pane/input/focus/regular-terminal-focus-ownership.test.ts": 208,
"src/renderer/src/components/terminal-pane/pty-connection/output-restore/remote-hidden-output-restore-outcomes.test.ts": 2794,
"src/renderer/src/components/terminal-pane/pty-connection/output-restore/remote-hidden-output-restore-unavailable-banner.repro.test.ts": 2355,
@@ -1,32 +1,21 @@
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
import {
flushPtySideEffects,
installIpcPtyWindow,
restorePtySpecWindow
} from './pty-transport-test-harness'
import { installIpcPtyWindow, restorePtySpecWindow } from './pty-transport-test-harness'
describe('createIpcPtyTransport', () => {
const originalWindow = (globalThis as { window?: typeof window }).window
let onData: ((payload: { id: string; data: string }) => void) | null = null
let onReplay: ((payload: { id: string; data: string }) => void) | null = null
let onExit:
| ((payload: { id: string; code: number; preserveRendererBinding?: boolean }) => void)
| null = null
beforeEach(() => {
vi.resetModules()
onData = null
onReplay = null
onExit = null
installIpcPtyWindow(originalWindow, {
data: (callback) => {
onData = callback
},
replay: (callback) => {
onReplay = callback
},
exit: (callback) => {
onExit = callback
}
})
})
@@ -35,134 +24,6 @@ describe('createIpcPtyTransport', () => {
restorePtySpecWindow(originalWindow)
})
it('ignores a stale exit for a previous PTY after reconnecting the same transport', async () => {
const { createIpcPtyTransport } = await import('./pty-transport')
const spawn = window.api.pty.spawn as unknown as ReturnType<typeof vi.fn>
const onPtyExit = vi.fn()
spawn.mockResolvedValueOnce({ id: 'pty-old' }).mockResolvedValueOnce({ id: 'pty-new' })
const transport = createIpcPtyTransport({ onPtyExit })
await transport.connect({ url: '', callbacks: {} })
await transport.connect({ url: '', callbacks: {} })
onExit?.({ id: 'pty-old', code: 0 })
expect(onPtyExit).not.toHaveBeenCalledWith('pty-old', 0)
expect(transport.getPtyId()).toBe('pty-new')
expect(transport.isConnected()).toBe(true)
onExit?.({ id: 'pty-new', code: 0 })
expect(onPtyExit).toHaveBeenCalledWith('pty-new', 0)
expect(transport.getPtyId()).toBeNull()
expect(transport.isConnected()).toBe(false)
})
it('ignores stale data and replay for a previous PTY after reconnecting the same transport', async () => {
const { createIpcPtyTransport } = await import('./pty-transport')
const spawn = window.api.pty.spawn as unknown as ReturnType<typeof vi.fn>
const onDataCallback = vi.fn()
const onReplayData = vi.fn()
spawn.mockResolvedValueOnce({ id: 'pty-old' }).mockResolvedValueOnce({ id: 'pty-new' })
const transport = createIpcPtyTransport({})
await transport.connect({
url: '',
callbacks: { onData: vi.fn(), onReplayData: vi.fn() }
})
await transport.connect({
url: '',
callbacks: { onData: onDataCallback, onReplayData }
})
onData?.({ id: 'pty-old', data: 'old data' })
onReplay?.({ id: 'pty-old', data: 'old replay' })
expect(onDataCallback).not.toHaveBeenCalled()
expect(onReplayData).not.toHaveBeenCalled()
onData?.({ id: 'pty-new', data: 'new data' })
onReplay?.({ id: 'pty-new', data: 'new replay' })
expect(onDataCallback).toHaveBeenCalledWith('new data')
expect(onReplayData).toHaveBeenCalledWith('new replay')
})
it('unregisterPtyDataHandlers prevents final data burst from triggering notifications', async () => {
const { createIpcPtyTransport } = await import('./pty-transport')
await import('../delivery/pty-dispatcher')
const { unregisterPtyDataHandlers } = await import('../shutdown/pty-shutdown-data-suspension')
const onTitleChange = vi.fn()
const onBell = vi.fn()
const onAgentBecameIdle = vi.fn()
const onAgentBecameWorking = vi.fn()
const onPtyExit = vi.fn()
const transport = createIpcPtyTransport({
onTitleChange,
onBell,
onAgentBecameIdle,
onAgentBecameWorking,
onPtyExit
})
await transport.connect({ url: '', callbacks: {} })
onData?.({ id: 'pty-1', data: ']0;. Claude working' })
await flushPtySideEffects()
expect(onAgentBecameWorking).toHaveBeenCalledTimes(1)
// Simulate shutdownWorktreeTerminals: unregister data handlers before kill.
const snapshots = unregisterPtyDataHandlers(['pty-1'])
// Final burst after the handler was removed: its title change and BEL must not produce a notification.
onData?.({ id: 'pty-1', data: ']0;Claude done' })
expect(onAgentBecameIdle).not.toHaveBeenCalled()
expect(onBell).not.toHaveBeenCalled()
for (const snapshot of snapshots) {
snapshot.commit()
}
onExit?.({ id: 'pty-1', code: -1 })
expect(onPtyExit).toHaveBeenCalledWith('pty-1', -1)
})
it('marks a host reversible-stop exit before delivering it to the pane', async () => {
const { createIpcPtyTransport } = await import('./pty-transport')
const { consumeCommittedPtyShutdownExit } =
await import('../shutdown/pty-shutdown-exit-deferral')
const transport = createIpcPtyTransport()
await transport.connect({ url: '', callbacks: {} })
onExit?.({ id: 'pty-1', code: 0, preserveRendererBinding: true })
expect(consumeCommittedPtyShutdownExit('pty-1')).toBe(true)
})
it('restores data handlers when an intentional shutdown fails before exit', async () => {
const { createIpcPtyTransport } = await import('./pty-transport')
await import('../delivery/pty-dispatcher')
const { restorePtyDataHandlersAfterFailedShutdown, unregisterPtyDataHandlers } =
await import('../shutdown/pty-shutdown-data-suspension')
const onDataCallback = vi.fn()
const transport = createIpcPtyTransport()
await transport.connect({ url: '', callbacks: { onData: onDataCallback } })
const snapshots = unregisterPtyDataHandlers(['pty-1'])
onData?.({ id: 'pty-1', data: 'final burst while detached' })
expect(onDataCallback).not.toHaveBeenCalled()
restorePtyDataHandlersAfterFailedShutdown(snapshots)
expect(onDataCallback).toHaveBeenCalledWith('final burst while detached')
onData?.({ id: 'pty-1', data: 'live again' })
expect(onDataCallback).toHaveBeenCalledWith('live again')
})
it('retains rollback replay until a pane detached during sleep registers again', async () => {
const { createIpcPtyTransport } = await import('./pty-transport')
await import('../delivery/pty-dispatcher')
@@ -213,43 +74,4 @@ describe('createIpcPtyTransport', () => {
expect(sidecar).toHaveBeenCalledWith('buffered while both owners are pending')
ptyDataSidecars.delete('pty-1')
})
it('unregisterPtyDataHandlers cancels staleTitleTimer so it cannot fire stale idle transition', async () => {
vi.useFakeTimers()
try {
const { createIpcPtyTransport } = await import('./pty-transport')
await import('../delivery/pty-dispatcher')
const { unregisterPtyDataHandlers } = await import('../shutdown/pty-shutdown-data-suspension')
const onTitleChange = vi.fn()
const onAgentBecameIdle = vi.fn()
const onAgentBecameWorking = vi.fn()
const transport = createIpcPtyTransport({
onTitleChange,
onAgentBecameIdle,
onAgentBecameWorking
})
await transport.connect({ url: '', callbacks: {} })
onData?.({ id: 'pty-1', data: ']0;. Claude working' })
vi.advanceTimersByTime(0)
expect(onAgentBecameWorking).toHaveBeenCalledTimes(1)
onData?.({ id: 'pty-1', data: 'some output without title\r\n' })
vi.advanceTimersByTime(0)
// Unregister must cancel the staleTitleTimer and reset the tracker so no stale idle transition fires.
const snapshots = unregisterPtyDataHandlers(['pty-1'])
vi.advanceTimersByTime(4000)
expect(onAgentBecameIdle).not.toHaveBeenCalled()
for (const snapshot of snapshots) {
snapshot.commit()
}
} finally {
vi.useRealTimers()
}
})
})
@@ -1,20 +1,11 @@
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
import {
TERMINAL_INPUT_CHUNK_MAX_BYTES,
TERMINAL_INPUT_MAX_BYTES
} from '../../../../../../shared/terminal/input/terminal-input'
import { TERMINAL_INPUT_CHUNK_MAX_BYTES } from '../../../../../../shared/terminal/input/terminal-input'
import { CLIPBOARD_TEXT_MEASURE_YIELD_CODE_UNITS } from '../../../../../../shared/clipboard-text'
import '../input/pty-input-write-queue'
import { PTY_INPUT_WRITE_QUEUE_MAX_PENDING_REPLIES } from '../input/pty-input-write-queue-contract'
import {
createDeferred,
flushAsyncTicks
} from '../../pty-connection/test-fixtures/pty-connection-test-async'
import {
PTY_PRECONNECT_INPUT_MAX_CODE_UNITS,
PTY_PRECONNECT_INPUT_MAX_ENTRIES,
type PtyPreconnectInputEntry
} from '../input/pty-preconnect-input-buffer'
import type { PtyPreconnectInputEntry } from '../input/pty-preconnect-input-buffer'
import {
installIpcPtyWindow,
restorePtySpecWindow,
@@ -23,19 +14,14 @@ import {
describe('createIpcPtyTransport', () => {
const originalWindow = (globalThis as { window?: typeof window }).window
let onWriteUnavailable: ((payload: { id: string }) => void) | null = null
let onExit: ((payload: PtyExitPayload) => void) | null = null
beforeEach(() => {
vi.resetModules()
onWriteUnavailable = null
onExit = null
installIpcPtyWindow(originalWindow, {
exit: (callback) => {
onExit = callback
},
writeUnavailable: (callback) => {
onWriteUnavailable = callback
}
})
})
@@ -44,185 +30,6 @@ describe('createIpcPtyTransport', () => {
restorePtySpecWindow(originalWindow)
})
it('routes a rejected daemon write to the owning transport recovery callback', async () => {
const { createIpcPtyTransport } = await import('./pty-transport')
const recovery = vi.fn()
const transport = createIpcPtyTransport({})
await transport.connect({ url: '', callbacks: { onWriteUnavailable: recovery } })
onWriteUnavailable?.({ id: 'pty-1' })
expect(recovery).toHaveBeenCalledOnce()
transport.disconnect()
})
it('routes a thrown renderer write to the owning transport recovery callback', async () => {
const failure = new Error('ipc write failed')
vi.mocked(window.api.pty.write).mockImplementation(() => {
throw failure
})
const warn = vi.spyOn(console, 'warn').mockImplementation(() => undefined)
try {
const { createIpcPtyTransport } = await import('./pty-transport')
const recovery = vi.fn()
const transport = createIpcPtyTransport({})
await transport.connect({ url: '', callbacks: { onWriteUnavailable: recovery } })
expect(transport.sendInput('input', 'driving')).toBe(true)
expect(transport.sendInput('later-input', 'driving')).toBe(false)
expect(recovery).toHaveBeenCalledOnce()
expect(warn).toHaveBeenCalledWith('[pty-input-write-queue] drain failed:', failure)
} finally {
warn.mockRestore()
}
})
it('uses acknowledged writes only for local IPC PTYs', async () => {
const { createIpcPtyTransport } = await import('./pty-transport')
const localTransport = createIpcPtyTransport({})
await localTransport.connect({ url: '', callbacks: {} })
await expect(localTransport.sendInputAccepted?.('\x03', 'driving')).resolves.toBe(true)
expect(window.api.pty.writeAccepted).toHaveBeenCalledWith('pty-1', '\x03', 'driving')
const sshTransport = createIpcPtyTransport({ connectionId: 'ssh-1' })
await sshTransport.connect({ url: '', callbacks: {} })
expect(sshTransport.sendInputAccepted).toBeUndefined()
})
it('flushes ordinary, accepted, and immediate split input in byte order', async () => {
const spawn = createDeferred<{ id: string }>()
vi.mocked(window.api.pty.spawn).mockReturnValue(spawn.promise as never)
const delivered: string[] = []
vi.mocked(window.api.pty.write).mockImplementation((_id, data) => {
delivered.push(data)
})
vi.mocked(window.api.pty.writeAccepted).mockImplementation(async (_id, data) => {
delivered.push(data)
return true
})
const { createIpcPtyTransport } = await import('./pty-transport')
const transport = createIpcPtyTransport({ bufferInputUntilConnect: true })
const connecting = transport.connect({ url: '', callbacks: {} })
expect(transport.sendInput('first-', 'driving')).toBe(true)
const accepted = transport.sendInputAccepted?.('second-', 'driving')
expect(transport.sendInputImmediate('third')).toBe(true)
expect(window.api.pty.write).not.toHaveBeenCalled()
expect(window.api.pty.writeAccepted).not.toHaveBeenCalled()
spawn.resolve({ id: 'pty-1' })
await connecting
await expect(accepted).resolves.toBe(true)
await flushAsyncTicks()
expect(delivered).toEqual(['first-', 'second-', 'third'])
})
it('delivers keys typed during a slow SSH spawn in order once the PTY binds', async () => {
const spawn = createDeferred<{ id: string }>()
vi.mocked(window.api.pty.spawn).mockReturnValue(spawn.promise as never)
const { createIpcPtyTransport } = await import('./pty-transport')
const transport = createIpcPtyTransport({
connectionId: 'ssh-1',
bufferInputUntilConnect: true
})
expect(transport.sendInput('ec', 'driving')).toBe(true)
const connecting = transport.connect({ url: '', callbacks: {} })
expect(transport.sendInput('ho hi\r', 'driving')).toBe(true)
expect(window.api.pty.write).not.toHaveBeenCalled()
spawn.resolve({ id: 'pty-1' })
await connecting
await flushAsyncTicks()
expect(vi.mocked(window.api.pty.write).mock.calls).toEqual([
['pty-1', 'ec', 'driving'],
['pty-1', 'ho hi\r', 'driving']
])
// Live input still writes straight through.
expect(transport.sendInput('next', 'driving')).toBe(true)
await flushAsyncTicks()
expect(window.api.pty.write).toHaveBeenLastCalledWith('pty-1', 'next', 'driving')
})
it('drops held keys instead of flushing them when startup work appeared before the bind', async () => {
const spawn = createDeferred<{ id: string }>()
vi.mocked(window.api.pty.spawn).mockReturnValue(spawn.promise as never)
const warn = vi.spyOn(console, 'warn').mockImplementation(() => undefined)
let release = true
const { createIpcPtyTransport } = await import('./pty-transport')
const transport = createIpcPtyTransport({
bufferInputUntilConnect: true,
releasePreconnectInput: () => release
})
const connecting = transport.connect({ url: '', callbacks: {} })
expect(transport.sendInput('make the tests pass\r', 'driving')).toBe(true)
release = false
spawn.resolve({ id: 'pty-1' })
await connecting
await flushAsyncTicks()
expect(window.api.pty.write).not.toHaveBeenCalled()
// Live input after the bind is unchanged.
expect(transport.sendInput('next', 'driving')).toBe(true)
await flushAsyncTicks()
expect(window.api.pty.write).toHaveBeenCalledWith('pty-1', 'next', 'driving')
warn.mockRestore()
})
it('flushes remount-handoff input before newly typed input without recapturing the seed', async () => {
const spawn = createDeferred<{ id: string }>()
vi.mocked(window.api.pty.spawn).mockReturnValue(spawn.promise as never)
const delivered: string[] = []
vi.mocked(window.api.pty.write).mockImplementation((_id, data) => {
delivered.push(data)
})
vi.mocked(window.api.pty.writeAccepted).mockImplementation(async (_id, data) => {
delivered.push(data)
return true
})
const onPreconnectInput = vi.fn()
const { createIpcPtyTransport } = await import('./pty-transport')
const transport = createIpcPtyTransport({
bufferInputUntilConnect: true,
preconnectInput: [
{ data: 'before-remount-', kind: 'ordinary', inputKind: 'driving' },
{ data: '\x1b[0n', kind: 'immediate', inputKind: 'query-reply' },
{ data: '\x03', kind: 'accepted', inputKind: 'driving' }
],
onPreconnectInput
})
const connecting = transport.connect({ url: '', callbacks: {} })
expect(transport.sendInput('new-ordinary-', 'driving')).toBe(true)
expect(transport.sendInputImmediate('new-immediate-')).toBe(true)
const accepted = transport.sendInputAccepted?.('new-accepted', 'driving')
expect(onPreconnectInput.mock.calls).toEqual([
[{ data: 'new-ordinary-', kind: 'ordinary', inputKind: 'driving' }],
[{ data: 'new-immediate-', kind: 'immediate', inputKind: 'query-reply' }],
[{ data: 'new-accepted', kind: 'accepted', inputKind: 'driving' }]
])
spawn.resolve({ id: 'pty-1' })
await connecting
await expect(accepted).resolves.toBe(true)
await flushAsyncTicks()
expect(delivered).toEqual([
'before-remount-',
'\x1b[0n',
'\x03',
'new-ordinary-',
'new-immediate-',
'new-accepted'
])
})
it('settles a predecessor accepted write while its successor replays the captured bytes', async () => {
const spawn = createDeferred<{ id: string }>()
vi.mocked(window.api.pty.spawn).mockReturnValue(spawn.promise as never)
@@ -253,69 +60,6 @@ describe('createIpcPtyTransport', () => {
expect(delivered).toEqual(['\x03'])
})
it('contains capture callback failures without rejecting retained input', async () => {
const onPreconnectInput = vi.fn(() => {
throw new Error('capture failed')
})
const { createIpcPtyTransport } = await import('./pty-transport')
const transport = createIpcPtyTransport({
bufferInputUntilConnect: true,
onPreconnectInput
})
expect(transport.sendInput('ordinary', 'driving')).toBe(true)
expect(transport.sendInputImmediate('immediate')).toBe(true)
const accepted = transport.sendInputAccepted?.('accepted', 'driving')
expect(onPreconnectInput).toHaveBeenCalledTimes(3)
await transport.connect({ url: '', callbacks: {} })
await expect(accepted).resolves.toBe(true)
expect(window.api.pty.write).toHaveBeenCalledWith('pty-1', 'ordinary', 'driving')
expect(window.api.pty.write).toHaveBeenCalledWith('pty-1', 'immediate', 'query-reply')
expect(window.api.pty.writeAccepted).toHaveBeenCalledWith('pty-1', 'accepted', 'driving')
})
it('keeps live acknowledged input ahead of later ordinary and immediate writes', async () => {
vi.useFakeTimers()
const acceptedWrite = createDeferred<boolean>()
const delivered: string[] = []
vi.mocked(window.api.pty.write).mockImplementation((_id, data) => {
delivered.push(`ordinary:${data}`)
})
vi.mocked(window.api.pty.writeAccepted).mockImplementation(async (_id, data) => {
delivered.push(`accepted:${data}`)
return acceptedWrite.promise
})
try {
const { createIpcPtyTransport } = await import('./pty-transport')
const transport = createIpcPtyTransport({})
await transport.connect({ url: '', callbacks: {} })
expect(transport.sendInput('first', 'driving')).toBe(true)
const accepted = transport.sendInputAccepted?.('second', 'driving')
expect(transport.sendInput('third', 'driving')).toBe(true)
expect(transport.sendInputImmediate('fourth')).toBe(true)
await flushAsyncTicks()
expect(delivered).toEqual(['ordinary:first', 'accepted:second'])
acceptedWrite.resolve(true)
await vi.runAllTimersAsync()
await expect(accepted).resolves.toBe(true)
expect(delivered).toEqual([
'ordinary:first',
'accepted:second',
'ordinary:third',
'ordinary:fourth'
])
} finally {
vi.useRealTimers()
}
})
it('preserves queue order across the preconnect-to-live boundary', async () => {
vi.useFakeTimers()
const delivered: { data: string; kind: 'ordinary' | 'accepted' }[] = []
@@ -362,132 +106,6 @@ describe('createIpcPtyTransport', () => {
}
})
it('reports a resolved split cwd through local recovery metadata', async () => {
const { createIpcPtyTransport } = await import('./pty-transport')
const options = { cwd: '/fallback', bufferInputUntilConnect: true }
const transport = createIpcPtyTransport(options)
options.cwd = '/resolved/source-cwd'
expect(transport.getLocalSessionMetadata?.()).toEqual({ cwd: '/resolved/source-cwd' })
})
it('settles and drops preconnect input when the split transport is destroyed', async () => {
const { createIpcPtyTransport } = await import('./pty-transport')
const transport = createIpcPtyTransport({ bufferInputUntilConnect: true })
expect(transport.sendInput('ordinary', 'driving')).toBe(true)
const accepted = transport.sendInputAccepted?.('accepted', 'driving')
await transport.destroy?.()
await expect(accepted).resolves.toBe(false)
expect(transport.sendInput('after-destroy', 'driving')).toBe(false)
expect(transport.sendInputImmediate('after-destroy')).toBe(false)
await expect(transport.sendInputAccepted?.('after-destroy', 'driving')).resolves.toBe(false)
expect(window.api.pty.write).not.toHaveBeenCalled()
expect(window.api.pty.writeAccepted).not.toHaveBeenCalled()
})
it.each(['disconnect', 'destroy', 'exit'] as const)(
'cancels an in-flight preconnect accepted write on %s',
async (teardown) => {
const spawn = createDeferred<{ id: string }>()
const acceptedWrite = createDeferred<boolean>()
vi.mocked(window.api.pty.spawn).mockReturnValue(spawn.promise as never)
vi.mocked(window.api.pty.writeAccepted).mockReturnValue(acceptedWrite.promise)
const { createIpcPtyTransport } = await import('./pty-transport')
const transport = createIpcPtyTransport({ bufferInputUntilConnect: true })
const connecting = transport.connect({ url: '', callbacks: {} })
const accepted = transport.sendInputAccepted?.('first', 'driving')
expect(transport.sendInput('later', 'driving')).toBe(true)
spawn.resolve({ id: 'pty-1' })
await flushAsyncTicks()
expect(window.api.pty.writeAccepted).toHaveBeenCalledWith('pty-1', 'first', 'driving')
if (teardown === 'disconnect') {
transport.disconnect()
} else if (teardown === 'destroy') {
transport.destroy?.()
} else {
onExit?.({ id: 'pty-1', code: 0 })
}
await expect(accepted).resolves.toBe(false)
await expect(connecting).resolves.toBe('pty-1')
expect(window.api.pty.write).not.toHaveBeenCalled()
expect(transport.sendInput('after-teardown', 'driving')).toBe(false)
acceptedWrite.resolve(true)
await flushAsyncTicks()
expect(window.api.pty.write).not.toHaveBeenCalled()
await expect(accepted).resolves.toBe(false)
}
)
it.each(['disconnect', 'detach', 'exit'] as const)(
'cancels an in-flight live accepted write on %s',
async (teardown) => {
const acceptedWrite = createDeferred<boolean>()
vi.mocked(window.api.pty.writeAccepted).mockReturnValue(acceptedWrite.promise)
const { createIpcPtyTransport } = await import('./pty-transport')
const transport = createIpcPtyTransport({})
await transport.connect({ url: '', callbacks: {} })
const accepted = transport.sendInputAccepted?.('first', 'driving')
expect(transport.sendInput('later', 'driving')).toBe(true)
await flushAsyncTicks()
expect(window.api.pty.writeAccepted).toHaveBeenCalledWith('pty-1', 'first', 'driving')
if (teardown === 'disconnect') {
transport.disconnect()
} else if (teardown === 'detach') {
transport.detach?.()
} else {
onExit?.({ id: 'pty-1', code: 0 })
}
await expect(accepted).resolves.toBe(false)
expect(window.api.pty.write).not.toHaveBeenCalled()
expect(transport.sendInput('after-teardown', 'driving')).toBe(false)
acceptedWrite.resolve(true)
await flushAsyncTicks()
expect(window.api.pty.write).not.toHaveBeenCalled()
await expect(accepted).resolves.toBe(false)
}
)
it.each(['disconnect', 'detach'] as const)(
'retires a late fresh spawn after %s invalidates its connect',
async (teardown) => {
const spawn = createDeferred<{ id: string }>()
vi.mocked(window.api.pty.spawn).mockReturnValue(spawn.promise as never)
const { createIpcPtyTransport } = await import('./pty-transport')
const transport = createIpcPtyTransport({ bufferInputUntilConnect: true })
const onConnect = vi.fn()
const connecting = transport.connect({ url: '', callbacks: { onConnect } })
const accepted = transport.sendInputAccepted?.('pending', 'driving')
if (teardown === 'disconnect') {
transport.disconnect()
} else {
transport.detach?.()
}
spawn.resolve({ id: 'pty-late' })
await expect(connecting).resolves.toBeUndefined()
await expect(accepted).resolves.toBe(false)
expect(window.api.pty.kill).toHaveBeenCalledExactlyOnceWith('pty-late')
expect(onConnect).not.toHaveBeenCalled()
expect(transport.isConnected()).toBe(false)
expect(transport.getPtyId()).toBeNull()
}
)
it('does not retire a stale fresh spawn id owned by a newer attach', async () => {
const spawn = createDeferred<{ id: string }>()
vi.mocked(window.api.pty.spawn).mockReturnValue(spawn.promise as never)
@@ -504,58 +122,6 @@ describe('createIpcPtyTransport', () => {
expect(transport.getPtyId()).toBe('pty-reused')
})
it.each(['disconnect', 'detach'] as const)(
'drops a late spawn error after %s invalidates its connect',
async (teardown) => {
const spawn = createDeferred<{ id: string }>()
vi.mocked(window.api.pty.spawn).mockReturnValue(spawn.promise as never)
const { createIpcPtyTransport } = await import('./pty-transport')
const transport = createIpcPtyTransport({ bufferInputUntilConnect: true })
const staleOnError = vi.fn()
const currentOnError = vi.fn()
const connecting = transport.connect({ url: '', callbacks: { onError: staleOnError } })
if (teardown === 'disconnect') {
transport.disconnect()
} else {
transport.detach?.()
}
transport.attach({ existingPtyId: 'pty-current', callbacks: { onError: currentOnError } })
spawn.reject(new Error('late spawn failed'))
await expect(connecting).resolves.toBeUndefined()
expect(staleOnError).not.toHaveBeenCalled()
expect(currentOnError).not.toHaveBeenCalled()
expect(transport.getPtyId()).toBe('pty-current')
}
)
it.each(['disconnect', 'detach'] as const)(
'does not surface a rejected spawn after %s invalidates its connect',
async (teardown) => {
const spawn = createDeferred<{ id: string }>()
vi.mocked(window.api.pty.spawn).mockReturnValue(spawn.promise as never)
const { createIpcPtyTransport } = await import('./pty-transport')
const transport = createIpcPtyTransport({ bufferInputUntilConnect: true })
const onError = vi.fn()
const connecting = transport.connect({ url: '', callbacks: { onError } })
if (teardown === 'disconnect') {
transport.disconnect()
} else {
transport.detach?.()
}
spawn.reject(new Error('late spawn failed'))
await expect(connecting).resolves.toBeUndefined()
expect(onError).not.toHaveBeenCalled()
expect(transport.isConnected()).toBe(false)
expect(transport.getPtyId()).toBeNull()
}
)
it('does not leave stale exit handlers when onPtySpawn tears down synchronously', async () => {
const onExitCallback = vi.fn()
const onPtyExit = vi.fn()
@@ -653,282 +219,4 @@ describe('createIpcPtyTransport', () => {
expect(window.api.pty.writeAccepted).toHaveBeenCalledExactlyOnceWith('pty-1', chunk, 'driving')
await expect(accepted).resolves.toBe(false)
})
it('settles buffered input once and does not re-arm after disconnect', async () => {
const { createIpcPtyTransport } = await import('./pty-transport')
const transport = createIpcPtyTransport({ bufferInputUntilConnect: true })
expect(transport.sendInputImmediate('immediate')).toBe(true)
const accepted = transport.sendInputAccepted?.('accepted', 'driving')
transport.disconnect()
await expect(accepted).resolves.toBe(false)
expect(transport.sendInput('after-disconnect', 'driving')).toBe(false)
expect(transport.sendInputImmediate('after-disconnect')).toBe(false)
await expect(transport.sendInputAccepted?.('after-disconnect', 'driving')).resolves.toBe(false)
expect(window.api.pty.write).not.toHaveBeenCalled()
expect(window.api.pty.writeAccepted).not.toHaveBeenCalled()
})
it('clears preconnect input when attach observes a buffered exit', async () => {
const ptyId = 'pty-exited-before-attach-with-input'
const { bufferPreHandlerPtyExit, clearPreHandlerPtyState } =
await import('../delivery/pty-pre-handler-buffer')
bufferPreHandlerPtyExit(ptyId, 0)
const { createIpcPtyTransport } = await import('./pty-transport')
const transport = createIpcPtyTransport({ bufferInputUntilConnect: true })
const accepted = transport.sendInputAccepted?.('input', 'driving')
transport.attach({ existingPtyId: ptyId, callbacks: {} })
await expect(accepted).resolves.toBe(false)
expect(transport.isConnected()).toBe(false)
expect(transport.sendInput('after-exit', 'driving')).toBe(false)
clearPreHandlerPtyState(ptyId)
})
it('clears preconnect input when attach throws before binding', async () => {
vi.mocked(window.api.pty.onData).mockImplementationOnce(() => {
throw new Error('dispatcher attach failed')
})
const { createIpcPtyTransport } = await import('./pty-transport')
const transport = createIpcPtyTransport({ bufferInputUntilConnect: true })
const accepted = transport.sendInputAccepted?.('input', 'driving')
expect(() => transport.attach({ existingPtyId: 'pty-attach-failure', callbacks: {} })).toThrow(
'dispatcher attach failed'
)
await expect(accepted).resolves.toBe(false)
expect(transport.isConnected()).toBe(false)
expect(transport.sendInput('after-failure', 'driving')).toBe(false)
})
it('settles and drops preconnect input when the split spawn fails', async () => {
vi.mocked(window.api.pty.spawn).mockRejectedValue(new Error('spawn failed'))
const { createIpcPtyTransport } = await import('./pty-transport')
const transport = createIpcPtyTransport({ bufferInputUntilConnect: true })
const onError = vi.fn()
expect(transport.sendInput('ordinary', 'driving')).toBe(true)
const accepted = transport.sendInputAccepted?.('accepted', 'driving')
await transport.connect({ url: '', callbacks: { onError } })
await expect(accepted).resolves.toBe(false)
expect(transport.sendInput('after-failure', 'driving')).toBe(false)
expect(transport.sendInputImmediate('after-failure')).toBe(false)
await expect(transport.sendInputAccepted?.('after-failure', 'driving')).resolves.toBe(false)
expect(onError).toHaveBeenCalledWith('spawn failed')
expect(window.api.pty.write).not.toHaveBeenCalled()
expect(window.api.pty.writeAccepted).not.toHaveBeenCalled()
})
it('drops later preconnect input when an acknowledged write fails', async () => {
const spawn = createDeferred<{ id: string }>()
vi.mocked(window.api.pty.spawn).mockReturnValue(spawn.promise as never)
vi.mocked(window.api.pty.writeAccepted).mockRejectedValue(new Error('write failed'))
const { createIpcPtyTransport } = await import('./pty-transport')
const transport = createIpcPtyTransport({ bufferInputUntilConnect: true })
const connecting = transport.connect({ url: '', callbacks: {} })
expect(transport.sendInput('first', 'driving')).toBe(true)
const accepted = transport.sendInputAccepted?.('second', 'driving')
expect(transport.sendInput('third', 'driving')).toBe(true)
spawn.resolve({ id: 'pty-1' })
await connecting
await expect(accepted).resolves.toBe(false)
expect(window.api.pty.write).toHaveBeenCalledOnce()
expect(window.api.pty.write).toHaveBeenCalledWith('pty-1', 'first', 'driving')
})
it('drops acknowledged preconnect input when an earlier ordinary write fails', async () => {
const failure = new Error('ordinary write failed')
const warn = vi.spyOn(console, 'warn').mockImplementation(() => undefined)
vi.mocked(window.api.pty.write).mockImplementationOnce(() => {
throw failure
})
const { createIpcPtyTransport } = await import('./pty-transport')
const transport = createIpcPtyTransport({ bufferInputUntilConnect: true })
try {
expect(transport.sendInput('first', 'driving')).toBe(true)
const accepted = transport.sendInputAccepted?.('second', 'driving')
await transport.connect({ url: '', callbacks: {} })
await expect(accepted).resolves.toBe(false)
expect(window.api.pty.writeAccepted).not.toHaveBeenCalled()
expect(warn).toHaveBeenCalledWith('[pty-input-write-queue] drain failed:', failure)
} finally {
warn.mockRestore()
}
})
it('bounds input retained before a split connects', async () => {
const { createIpcPtyTransport } = await import('./pty-transport')
const transport = createIpcPtyTransport({ bufferInputUntilConnect: true })
for (let index = 0; index < PTY_PRECONNECT_INPUT_MAX_ENTRIES; index += 1) {
expect(transport.sendInput('x', 'driving')).toBe(true)
}
expect(transport.sendInput('overflow', 'driving')).toBe(false)
const oversized = createIpcPtyTransport({ bufferInputUntilConnect: true })
expect(
oversized.sendInput('x'.repeat(PTY_PRECONNECT_INPUT_MAX_CODE_UNITS + 1), 'driving')
).toBe(false)
await transport.destroy?.()
await oversized.destroy?.()
})
it('chunks large local IPC terminal input before renderer-to-main writes', async () => {
vi.useFakeTimers()
try {
const { createIpcPtyTransport } = await import('./pty-transport')
const transport = createIpcPtyTransport({})
const chunk = 'x'.repeat(TERMINAL_INPUT_CHUNK_MAX_BYTES)
await transport.connect({ url: '', callbacks: {} })
expect(transport.sendInput(`${chunk}tail`, 'driving')).toBe(true)
expect(window.api.pty.write).toHaveBeenCalledTimes(1)
expect(window.api.pty.write).toHaveBeenNthCalledWith(1, 'pty-1', chunk, 'driving')
await vi.runOnlyPendingTimersAsync()
expect(window.api.pty.write).toHaveBeenCalledTimes(2)
expect(window.api.pty.write).toHaveBeenNthCalledWith(2, 'pty-1', 'tail', 'driving')
} finally {
vi.useRealTimers()
}
})
it('bounds immediate cooked replies without shedding ordinary-path lookalikes', async () => {
vi.useFakeTimers()
try {
const { createIpcPtyTransport } = await import('./pty-transport')
const transport = createIpcPtyTransport({})
const first = '\x1b[?10000;1n'
const ordinary = '\x1b]10;user-ordinary-marker\x1b\\'
const replies = Array.from({ length: 10_000 }, (_, index) => `\x1b[?${index};1n`)
await transport.connect({ url: '', callbacks: {} })
expect(transport.sendInputImmediate(first)).toBe(true)
expect(transport.sendInput(ordinary, 'driving')).toBe(true)
for (const reply of replies) {
expect(transport.sendInputImmediate(reply)).toBe(true)
}
await vi.runAllTimersAsync()
expect(vi.mocked(window.api.pty.write).mock.calls).toEqual([
['pty-1', first, 'query-reply'],
['pty-1', ordinary, 'driving'],
...replies
.slice(-PTY_INPUT_WRITE_QUEUE_MAX_PENDING_REPLIES)
.map((reply) => ['pty-1', reply, 'query-reply'])
])
} finally {
vi.useRealTimers()
}
})
it('yields while validating accepted large local IPC terminal input before renderer-to-main writes', async () => {
vi.useFakeTimers()
try {
const { createIpcPtyTransport } = await import('./pty-transport')
const transport = createIpcPtyTransport({})
const text = 'é'.repeat(CLIPBOARD_TEXT_MEASURE_YIELD_CODE_UNITS + 1)
await transport.connect({ url: '', callbacks: {} })
expect(transport.sendInput(text, 'driving')).toBe(true)
expect(window.api.pty.write).not.toHaveBeenCalled()
await vi.runAllTimersAsync()
expect(
vi
.mocked(window.api.pty.write)
.mock.calls.map(([, chunk]) => chunk)
.join('')
).toBe(text)
} finally {
vi.useRealTimers()
}
})
it('rejects oversized local IPC terminal input before renderer-to-main writes', async () => {
const { createIpcPtyTransport } = await import('./pty-transport')
const transport = createIpcPtyTransport({})
await transport.connect({ url: '', callbacks: {} })
expect(transport.sendInput('x'.repeat(TERMINAL_INPUT_MAX_BYTES + 1), 'driving')).toBe(false)
expect(window.api.pty.write).not.toHaveBeenCalled()
})
it('chunks large acknowledged local IPC terminal input before writeAccepted IPC', async () => {
vi.useFakeTimers()
try {
const { createIpcPtyTransport } = await import('./pty-transport')
const transport = createIpcPtyTransport({})
const chunk = 'x'.repeat(TERMINAL_INPUT_CHUNK_MAX_BYTES)
await transport.connect({ url: '', callbacks: {} })
const accepted = transport.sendInputAccepted?.(`${chunk}tail`, 'driving')
await Promise.resolve()
expect(window.api.pty.writeAccepted).toHaveBeenCalledTimes(1)
expect(window.api.pty.writeAccepted).toHaveBeenNthCalledWith(1, 'pty-1', chunk, 'driving')
await vi.runOnlyPendingTimersAsync()
await expect(accepted).resolves.toBe(true)
expect(window.api.pty.writeAccepted).toHaveBeenCalledTimes(2)
expect(window.api.pty.writeAccepted).toHaveBeenNthCalledWith(2, 'pty-1', 'tail', 'driving')
} finally {
vi.useRealTimers()
}
})
it('yields while validating accepted large acknowledged local IPC terminal input before writeAccepted IPC', async () => {
vi.useFakeTimers()
try {
const { createIpcPtyTransport } = await import('./pty-transport')
const transport = createIpcPtyTransport({})
const text = 'é'.repeat(CLIPBOARD_TEXT_MEASURE_YIELD_CODE_UNITS + 1)
await transport.connect({ url: '', callbacks: {} })
const accepted = transport.sendInputAccepted?.(text, 'driving')
await Promise.resolve()
expect(window.api.pty.writeAccepted).not.toHaveBeenCalled()
await vi.runAllTimersAsync()
await expect(accepted).resolves.toBe(true)
expect(
vi
.mocked(window.api.pty.writeAccepted)
.mock.calls.map(([, chunk]) => chunk)
.join('')
).toBe(text)
} finally {
vi.useRealTimers()
}
})
it('rejects oversized acknowledged local IPC terminal input before writeAccepted IPC', async () => {
const { createIpcPtyTransport } = await import('./pty-transport')
const transport = createIpcPtyTransport({})
await transport.connect({ url: '', callbacks: {} })
await expect(
transport.sendInputAccepted?.('x'.repeat(TERMINAL_INPUT_MAX_BYTES + 1), 'driving')
).resolves.toBe(false)
expect(window.api.pty.writeAccepted).not.toHaveBeenCalled()
})
})
@@ -1,9 +1,5 @@
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
import {
flushPtySideEffects,
installIpcPtyWindow,
restorePtySpecWindow
} from './pty-transport-test-harness'
import { installIpcPtyWindow, restorePtySpecWindow } from './pty-transport-test-harness'
describe('createIpcPtyTransport', () => {
const originalWindow = (globalThis as { window?: typeof window }).window
@@ -23,21 +19,6 @@ describe('createIpcPtyTransport', () => {
restorePtySpecWindow(originalWindow)
})
it('retires an adopted PTY when recovery disconnects before a replacement spawn', async () => {
const { createIpcPtyTransport } = await import('./pty-transport')
const spawn = window.api.pty.spawn as unknown as ReturnType<typeof vi.fn>
const kill = window.api.pty.kill as unknown as ReturnType<typeof vi.fn>
spawn.mockResolvedValueOnce({ id: 'empty-reattach', isReattach: true })
const transport = createIpcPtyTransport({})
await transport.connect({ url: '', sessionId: 'empty-reattach', callbacks: {} })
transport.disconnect()
expect(kill).toHaveBeenCalledWith('empty-reattach')
expect(transport.getPtyId()).toBeNull()
expect(transport.isConnected()).toBe(false)
})
it('announces a daemon adoption before publishing its buffered PTY data', async () => {
const { createIpcPtyTransport } = await import('./pty-transport')
const spawn = window.api.pty.spawn as unknown as ReturnType<typeof vi.fn>
@@ -57,67 +38,6 @@ describe('createIpcPtyTransport', () => {
expect(order).toEqual(['adopt', 'data'])
})
it('does not reannounce an explicit reattach already owned by its caller', async () => {
const { createIpcPtyTransport } = await import('./pty-transport')
const spawn = window.api.pty.spawn as unknown as ReturnType<typeof vi.fn>
spawn.mockResolvedValueOnce({ id: 'restored-pty', isReattach: true })
const onReattachDetermined = vi.fn()
const transport = createIpcPtyTransport({})
await transport.connect({
url: '',
sessionId: 'restored-pty',
callbacks: { onReattachDetermined }
})
expect(onReattachDetermined).not.toHaveBeenCalled()
})
it('leaves the transport silently unbound after a failed connect — sendInput drops with no write IPC (frozen-terminal repro)', async () => {
const { createIpcPtyTransport } = await import('./pty-transport')
const spawn = window.api.pty.spawn as unknown as ReturnType<typeof vi.fn>
const write = window.api.pty.write as unknown as ReturnType<typeof vi.fn>
const transport = createIpcPtyTransport({})
// Generic spawn failure: onError fires, but the transport stays unbound and later keystrokes drop with no further signal.
spawn.mockRejectedValueOnce(new Error('daemon socket not ready'))
const onError = vi.fn()
await transport.connect({ url: '', callbacks: { onError } })
expect(onError).toHaveBeenCalled()
expect(transport.isConnected()).toBe(false)
expect(transport.sendInput('echo hello\r', 'driving')).toBe(false)
await flushPtySideEffects()
expect(write).not.toHaveBeenCalled()
// Tombstoned-session rejection has no callback at all, so a restored pane silently eats keystrokes while showing content (#2836).
spawn.mockRejectedValueOnce(new Error('TerminalKilledError: session xyz was explicitly killed'))
const onErrorKilled = vi.fn()
await transport.connect({ url: '', callbacks: { onError: onErrorKilled } })
expect(onErrorKilled).not.toHaveBeenCalled()
expect(transport.isConnected()).toBe(false)
expect(transport.sendInput('echo hello\r', 'driving')).toBe(false)
await flushPtySideEffects()
expect(write).not.toHaveBeenCalled()
})
it('mints a fresh id instead of reopening a discarded same-id session', async () => {
const { discardPreHandlerPtyState, clearPreHandlerPtyState } =
await import('../delivery/pty-pre-handler-buffer')
const { createIpcPtyTransport } = await import('./pty-transport')
const spawn = window.api.pty.spawn as unknown as ReturnType<typeof vi.fn>
const discardedId = 'removed-worktree@@discarded-session'
discardPreHandlerPtyState(discardedId)
await createIpcPtyTransport({}).connect({
url: '',
sessionId: discardedId,
callbacks: {}
})
expect(spawn).toHaveBeenCalledWith(expect.not.objectContaining({ sessionId: discardedId }))
clearPreHandlerPtyState(discardedId)
})
it('delivers a buffered dead-session exit without respawning the same session id', async () => {
const { bufferPreHandlerPtyData, bufferPreHandlerPtyExit } =
await import('../delivery/pty-pre-handler-buffer')
@@ -146,277 +66,4 @@ describe('createIpcPtyTransport', () => {
expect(onPtyExit).toHaveBeenCalledWith(sessionId, 17)
expect(transport.isConnected()).toBe(false)
})
it('respawns a sole-newborn preserved exit at reveal instead of replaying it', async () => {
const { bufferPreHandlerPtyExit, consumePreHandlerPtyState, clearPreHandlerPtyState } =
await import('../delivery/pty-pre-handler-buffer')
const { createIpcPtyTransport } = await import('./pty-transport')
const spawn = window.api.pty.spawn as unknown as ReturnType<typeof vi.fn>
spawn.mockResolvedValueOnce({ id: 'reveal-pty' })
const onExitCallback = vi.fn()
const sessionId = 'sole-newborn-dead-session'
// Consumed newborn-diagnostic exits need readmission; replaying one into reattach would close the preserved tab because it is no longer fresh-spawned.
bufferPreHandlerPtyExit(sessionId, 1)
consumePreHandlerPtyState(sessionId)
const result = await createIpcPtyTransport({}).connect({
url: '',
sessionId,
callbacks: { onExit: onExitCallback }
})
expect(result).not.toEqual(expect.objectContaining({ exitedBeforeAttach: true }))
expect(spawn).toHaveBeenCalledWith(expect.objectContaining({ sessionId }))
expect(onExitCallback).not.toHaveBeenCalled()
clearPreHandlerPtyState(sessionId)
})
it('preserves snapshot dimensions and split alt-frame strings when reattaching', async () => {
const { createIpcPtyTransport } = await import('./pty-transport')
const spawnMock = vi.fn().mockResolvedValue({
id: 'pty-reattach',
isReattach: true,
launchAgent: 'droid',
snapshot: 'snapshot data',
snapshotCols: 132,
snapshotRows: 43,
snapshotPrefixAnsi: 'history and modes',
snapshotFrameAnsi: 'visual frame',
snapshotFrameRestoreAnsi: 'live state'
})
;(globalThis as { window: typeof window }).window = {
...originalWindow,
api: {
...originalWindow?.api,
pty: {
...originalWindow?.api?.pty,
spawn: spawnMock,
write: vi.fn(),
resize: vi.fn(),
kill: vi.fn(),
onData: vi.fn((callback: (payload: { id: string; data: string }) => void) => {
onData = callback
return () => {}
}),
onReplay: vi.fn(() => () => {}),
onExit: vi.fn(() => () => {})
}
}
} as unknown as typeof window
const transport = createIpcPtyTransport()
const result = await transport.connect({
url: '',
sessionId: 'pty-reattach',
callbacks: {}
})
expect(result).toEqual({
id: 'pty-reattach',
isReattach: true,
launchAgent: 'droid',
snapshot: 'snapshot data',
snapshotCols: 132,
snapshotRows: 43,
snapshotPrefixAnsi: 'history and modes',
snapshotFrameAnsi: 'visual frame',
snapshotFrameRestoreAnsi: 'live state',
isAlternateScreen: undefined,
coldRestore: undefined,
replay: undefined,
sessionExpired: undefined
})
})
it('drops an unknown daemon launch identity from the connection result', async () => {
const { createIpcPtyTransport } = await import('./pty-transport')
const spawn = window.api.pty.spawn as unknown as ReturnType<typeof vi.fn>
spawn.mockResolvedValueOnce({
id: 'pty-unknown-launch-agent',
isReattach: true,
launchAgent: 'not-an-agent'
})
const result = await createIpcPtyTransport({}).connect({ url: '', callbacks: {} })
expect(result).toEqual({
id: 'pty-unknown-launch-agent',
isReattach: true,
snapshot: undefined,
snapshotCols: undefined,
snapshotRows: undefined,
isAlternateScreen: undefined,
sessionExpired: undefined,
coldRestore: undefined,
replay: undefined,
pendingEscapeTailAnsi: undefined
})
})
it('threads the daemon pendingEscapeTailAnsi through the reattach connect result (#7329)', async () => {
// Why: dropping the daemon's mid-escape tail from the reattach result silently regressed the local half of #7329.
const { createIpcPtyTransport } = await import('./pty-transport')
const spawnMock = vi.fn().mockResolvedValue({
id: 'pty-reattach-tail',
isReattach: true,
snapshot: 'snapshot data',
snapshotCols: 80,
snapshotRows: 24,
pendingEscapeTailAnsi: '\x1b[3'
})
;(globalThis as { window: typeof window }).window = {
...originalWindow,
api: {
...originalWindow?.api,
pty: {
...originalWindow?.api?.pty,
spawn: spawnMock,
write: vi.fn(),
resize: vi.fn(),
kill: vi.fn(),
onData: vi.fn(() => () => {}),
onReplay: vi.fn(() => () => {}),
onExit: vi.fn(() => () => {})
}
}
} as unknown as typeof window
const transport = createIpcPtyTransport()
const result = await transport.connect({
url: '',
sessionId: 'pty-reattach-tail',
callbacks: {}
})
expect(result).toMatchObject({
id: 'pty-reattach-tail',
pendingEscapeTailAnsi: '\x1b[3'
})
})
it('does not kill a pre-existing session when a reattach resolves after destroy', async () => {
const { createIpcPtyTransport } = await import('./pty-transport')
const spawnControls: {
resolve: ((value: { id: string; isReattach: true }) => void) | null
} = { resolve: null }
const spawnPromise = new Promise<{ id: string; isReattach: true }>((resolve) => {
spawnControls.resolve = resolve
})
const spawnMock = vi.fn().mockReturnValue(spawnPromise)
const killMock = vi.fn()
;(globalThis as { window: typeof window }).window = {
...originalWindow,
api: {
...originalWindow?.api,
pty: {
...originalWindow?.api?.pty,
spawn: spawnMock,
write: vi.fn(),
resize: vi.fn(),
kill: killMock,
onData: vi.fn(() => () => {}),
onReplay: vi.fn(() => () => {}),
onExit: vi.fn(() => () => {})
}
}
} as unknown as typeof window
const transport = createIpcPtyTransport({})
const connectPromise = transport.connect({
url: '',
callbacks: {},
// A reattach targets a pre-existing session, so destroying the view must not reap the user's live shell.
sessionId: 'pty-preexisting'
})
transport.destroy?.()
if (!spawnControls.resolve) {
throw new Error('Expected spawn resolver to be captured')
}
spawnControls.resolve({ id: 'pty-preexisting', isReattach: true })
await connectPromise
expect(killMock).not.toHaveBeenCalledWith('pty-preexisting')
})
it('kills a fresh session fallback that resolves after the transport was destroyed', async () => {
const { createIpcPtyTransport } = await import('./pty-transport')
const spawnControls: {
resolve: ((value: { id: string; sessionExpired: true }) => void) | null
} = { resolve: null }
const spawnPromise = new Promise<{ id: string; sessionExpired: true }>((resolve) => {
spawnControls.resolve = resolve
})
const spawn = window.api.pty.spawn as unknown as ReturnType<typeof vi.fn>
const kill = window.api.pty.kill as unknown as ReturnType<typeof vi.fn>
spawn.mockReturnValueOnce(spawnPromise)
const transport = createIpcPtyTransport({})
const connectPromise = transport.connect({
url: '',
sessionId: 'pty-missing',
callbacks: {}
})
transport.destroy?.()
if (!spawnControls.resolve) {
throw new Error('Expected spawn resolver to be captured')
}
spawnControls.resolve({ id: 'pty-fresh-fallback', sessionExpired: true })
await connectPromise
expect(kill).toHaveBeenCalledExactlyOnceWith('pty-fresh-fallback')
expect(transport.getPtyId()).toBeNull()
})
it('kills a PTY that finishes spawning after the transport was destroyed', async () => {
const { createIpcPtyTransport } = await import('./pty-transport')
const spawnControls: { resolve: ((value: { id: string }) => void) | null } = { resolve: null }
const spawnPromise = new Promise<{ id: string }>((resolve) => {
spawnControls.resolve = resolve
})
const spawnMock = vi.fn().mockReturnValue(spawnPromise)
const killMock = vi.fn()
const onPtySpawn = vi.fn()
// oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the test swaps in a window whose pty API is the spawn/kill mocks above.
;(globalThis as { window: typeof window }).window = {
...originalWindow,
api: {
...originalWindow?.api,
pty: {
...originalWindow?.api?.pty,
spawn: spawnMock,
write: vi.fn(),
resize: vi.fn(),
kill: killMock,
onData: vi.fn((callback: (payload: { id: string; data: string }) => void) => {
onData = callback
return () => {}
}),
onReplay: vi.fn(() => () => {}),
onExit: vi.fn(() => () => {})
}
}
} as unknown as typeof window
const transport = createIpcPtyTransport({ onPtySpawn })
const connectPromise = transport.connect({
url: '',
callbacks: {}
})
transport.destroy?.()
if (!spawnControls.resolve) {
throw new Error('Expected spawn resolver to be captured')
}
spawnControls.resolve({ id: 'pty-late' })
await connectPromise
expect(killMock).toHaveBeenCalledWith('pty-late')
expect(onPtySpawn).not.toHaveBeenCalled()
expect(transport.getPtyId()).toBeNull()
})
})
@@ -1,294 +0,0 @@
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
import { createTerminalSessionStateSaveFailureMessage } from '../../../../../../shared/workspace-session/terminal-session-state-save-failure'
import { installIpcPtyWindow, restorePtySpecWindow } from './pty-transport-test-harness'
describe('createIpcPtyTransport', () => {
const originalWindow = (globalThis as { window?: typeof window }).window
beforeEach(() => {
vi.resetModules()
installIpcPtyWindow(originalWindow, {})
})
afterEach(() => {
restorePtySpecWindow(originalWindow)
})
it('suppresses the error toast when pty:spawn rejects with TerminalKilledError', async () => {
// Why: a killed-session TerminalKilledError is intended, not a bug, so no toast; string is Electron's IPC-wrapped form to hit the real path.
const { createIpcPtyTransport } = await import('./pty-transport')
const spawnMock = vi
.fn()
.mockRejectedValue(
new Error(
`Error invoking remote method 'pty:spawn': TerminalKilledError: Session "pty-dead" was explicitly killed`
)
)
;(globalThis as { window: typeof window }).window = {
...originalWindow,
api: {
...originalWindow?.api,
pty: {
...originalWindow?.api?.pty,
spawn: spawnMock,
write: vi.fn(),
resize: vi.fn(),
kill: vi.fn(),
onData: vi.fn(() => () => {}),
onReplay: vi.fn(() => () => {}),
onExit: vi.fn(() => () => {})
}
}
} as unknown as typeof window
const transport = createIpcPtyTransport()
const onError = vi.fn()
const result = await transport.connect({
url: '',
sessionId: 'pty-dead',
callbacks: { onError }
})
expect(onError).not.toHaveBeenCalled()
expect(result).toBeUndefined()
})
it('still surfaces non-kill spawn errors via onError', async () => {
// Why: keep TerminalKilledError suppression narrow so real spawn failures (bad cwd, missing shell) still reach the user.
const { createIpcPtyTransport } = await import('./pty-transport')
const spawnMock = vi.fn().mockRejectedValue(new Error('ENOENT: spawn /bin/nope not found'))
;(globalThis as { window: typeof window }).window = {
...originalWindow,
api: {
...originalWindow?.api,
pty: {
...originalWindow?.api?.pty,
spawn: spawnMock,
write: vi.fn(),
resize: vi.fn(),
kill: vi.fn(),
onData: vi.fn(() => () => {}),
onReplay: vi.fn(() => () => {}),
onExit: vi.fn(() => () => {})
}
}
} as unknown as typeof window
const transport = createIpcPtyTransport()
const onError = vi.fn()
await transport.connect({
url: '',
callbacks: { onError }
})
expect(onError).toHaveBeenCalledWith('ENOENT: spawn /bin/nope not found')
})
it('surfaces the SSH-not-active toast for a regular SSH target with no PTY provider', async () => {
const { createIpcPtyTransport } = await import('./pty-transport')
const spawnMock = vi.fn().mockRejectedValue(new Error('No PTY provider for connection ssh-1'))
;(globalThis as { window: typeof window }).window = {
...originalWindow,
api: {
...originalWindow?.api,
pty: {
...originalWindow?.api?.pty,
spawn: spawnMock,
write: vi.fn(),
resize: vi.fn(),
kill: vi.fn(),
onData: vi.fn(() => () => {}),
onReplay: vi.fn(() => () => {}),
onExit: vi.fn(() => () => {})
}
}
} as unknown as typeof window
const onError = vi.fn()
await createIpcPtyTransport({ connectionId: 'ssh-1' }).connect({
url: '',
callbacks: { onError }
})
expect(onError).toHaveBeenCalledWith(
'SSH connection is not active. Use the reconnect dialog or Settings to connect.'
)
})
it('suppresses the SSH-not-active toast for a runtime-owned (per-workspace-env) target', async () => {
// Why: a runtime-owned SSH target disappearing is expected teardown (no reconnect dialog exists), so no toast should fire.
const { createIpcPtyTransport } = await import('./pty-transport')
const spawnMock = vi
.fn()
.mockRejectedValue(new Error('No PTY provider for connection runtime-ssh-orca-1'))
;(globalThis as { window: typeof window }).window = {
...originalWindow,
api: {
...originalWindow?.api,
pty: {
...originalWindow?.api?.pty,
spawn: spawnMock,
write: vi.fn(),
resize: vi.fn(),
kill: vi.fn(),
onData: vi.fn(() => () => {}),
onReplay: vi.fn(() => () => {}),
onExit: vi.fn(() => () => {})
}
}
} as unknown as typeof window
const onError = vi.fn()
await createIpcPtyTransport({ connectionId: 'runtime-ssh-orca-1' }).connect({
url: '',
callbacks: { onError }
})
expect(onError).not.toHaveBeenCalled()
})
it('refuses to call a cross-connection SSH reattach expired, and still raises no error toast', async () => {
// Client-side connection mismatch proves no host exit, even after same-machine re-adoption; keep it unverifiable to avoid duplicate resume while preserving toast suppression (#7661).
const { createIpcPtyTransport } = await import('./pty-transport')
const spawnMock = vi
.fn()
.mockRejectedValue(
new Error(
'PTY ssh:ssh-1779863656395-57g1q1@@pty-3 belongs to SSH connection "ssh-1779863656395-57g1q1"'
)
)
;(globalThis as { window: typeof window }).window = {
...originalWindow,
api: {
...originalWindow?.api,
pty: {
...originalWindow?.api?.pty,
spawn: spawnMock,
write: vi.fn(),
resize: vi.fn(),
kill: vi.fn(),
onData: vi.fn(() => () => {}),
onReplay: vi.fn(() => () => {}),
onExit: vi.fn(() => () => {})
}
}
} as unknown as typeof window
const onError = vi.fn()
const result = await createIpcPtyTransport({ connectionId: 'ssh-other' }).connect({
url: '',
sessionId: 'ssh:ssh-1779863656395-57g1q1@@pty-3',
callbacks: { onError }
})
expect(onError).not.toHaveBeenCalled()
// Unaddressable IDs remain unverifiable and cannot authorize respawn.
expect(result).toBeUndefined()
})
it('still calls a relay-attested gone session expired so a truly dead PTY respawns', async () => {
// Relay-proven expiry still authorizes respawn; only client mismatch lost that authority.
const { createIpcPtyTransport } = await import('./pty-transport')
const spawnMock = vi.fn().mockRejectedValue(new Error('SSH_SESSION_EXPIRED: ssh:ssh-1@@pty-3'))
;(globalThis as { window: typeof window }).window = {
...originalWindow,
api: {
...originalWindow?.api,
pty: {
...originalWindow?.api?.pty,
spawn: spawnMock,
write: vi.fn(),
resize: vi.fn(),
kill: vi.fn(),
onData: vi.fn(() => () => {}),
onReplay: vi.fn(() => () => {}),
onExit: vi.fn(() => () => {})
}
}
} as unknown as typeof window
const onError = vi.fn()
const result = await createIpcPtyTransport({ connectionId: 'ssh-1' }).connect({
url: '',
sessionId: 'ssh:ssh-1@@pty-3',
callbacks: { onError }
})
expect(onError).not.toHaveBeenCalled()
expect(result).toEqual({ id: 'ssh:ssh-1@@pty-3', sessionExpired: true })
})
it('calls a local daemon session-absence answer expired so a restored pane respawns silently', async () => {
const { createIpcPtyTransport } = await import('./pty-transport')
vi.mocked(window.api.pty.spawn).mockRejectedValueOnce(
new Error(
"Error invoking remote method 'pty:spawn': SessionNotFoundError: Session not found: repo-1::C:/proj/wt@@deadbeef"
)
)
const onError = vi.fn()
const result = await createIpcPtyTransport().connect({
url: '',
sessionId: 'repo-1::C:/proj/wt@@deadbeef',
callbacks: { onError }
})
expect(onError).not.toHaveBeenCalled()
expect(result).toEqual({ id: 'repo-1::C:/proj/wt@@deadbeef', sessionExpired: true })
})
it('surfaces terminal session state save failures without the Electron IPC wrapper', async () => {
const { createIpcPtyTransport } = await import('./pty-transport')
const wrappedMessage = `Error invoking remote method 'pty:spawn': Error: ${createTerminalSessionStateSaveFailureMessage()}`
const spawnMock = vi.fn().mockRejectedValue(new Error(wrappedMessage))
;(globalThis as { window: typeof window }).window = {
...originalWindow,
api: {
...originalWindow?.api,
pty: {
...originalWindow?.api?.pty,
spawn: spawnMock,
write: vi.fn(),
resize: vi.fn(),
kill: vi.fn(),
onData: vi.fn(() => () => {}),
onReplay: vi.fn(() => () => {}),
onExit: vi.fn(() => () => {})
}
}
} as unknown as typeof window
const transport = createIpcPtyTransport()
const onError = vi.fn()
await transport.connect({
url: '',
callbacks: { onError }
})
expect(onError).toHaveBeenCalledWith(createTerminalSessionStateSaveFailureMessage())
})
it('keeps every line of a multi-line spawn failure for the pane toast (#20386)', async () => {
const { createIpcPtyTransport } = await import('./pty-transport')
const diagnosis =
'Remote terminals are unavailable: make and a C++ compiler are not installed. Install them on the remote host, then reconnect:\n' +
' sudo apt-get install -y build-essential python3\n' +
'Host: linux/x64, glibc 2.36, Node v22.12.0 (ABI 127), prebuild slot linux-x64-glibc.'
vi.mocked(window.api.pty.spawn).mockRejectedValueOnce(
new Error(`Error invoking remote method 'pty:spawn': Error: ${diagnosis}`)
)
const onError = vi.fn()
await createIpcPtyTransport({ connectionId: 'ssh-1' }).connect({
url: '',
callbacks: { onError }
})
expect(onError).toHaveBeenCalledWith(diagnosis)
})
})
@@ -3,7 +3,6 @@ import type { TerminalSideEffectBatch } from '../../../../../../shared/terminal/
import {
_dispatchTerminalSideEffectBatchForTest,
_resetTerminalSideEffectFactConsumersForTest,
isMainTerminalSideEffectAuthorityForPty,
registerTerminalSideEffectFactConsumer,
type TerminalSideEffectFactConsumerCallbacks
} from './terminal-side-effect-facts-handler'
@@ -35,101 +34,6 @@ function batch(
return { ptyId: PTY_ID, seq: 0, facts, ...options }
}
describe('isMainTerminalSideEffectAuthorityForPty', () => {
const originalWindow = (globalThis as { window?: typeof window }).window
beforeEach(() => {
_resetTerminalSideEffectFactConsumersForTest()
delete (globalThis as { window?: unknown }).window
})
afterEach(() => {
_resetTerminalSideEffectFactConsumersForTest()
if (originalWindow) {
;(globalThis as { window: typeof window }).window = originalWindow
} else {
delete (globalThis as { window?: typeof window }).window
}
})
function setPersistedSettingsSync(settings: unknown): void {
;(globalThis as { window: unknown }).window = {
api: { settings: { getSync: () => settings } }
}
}
it('is on by default for PTYs whose bytes transit local main', () => {
expect(
isMainTerminalSideEffectAuthorityForPty({ settings: {}, runtimeEnvironmentId: null })
).toBe(true)
// Null startup settings must not disable default-on authority before hydration.
expect(
isMainTerminalSideEffectAuthorityForPty({ settings: null, runtimeEnvironmentId: null })
).toBe(true)
})
it('is off for remote-runtime PTYs regardless of the setting', () => {
expect(
isMainTerminalSideEffectAuthorityForPty({
settings: { terminalMainSideEffectAuthority: true },
runtimeEnvironmentId: 'env-1'
})
).toBe(false)
})
it('is off when the kill switch is disabled', () => {
expect(
isMainTerminalSideEffectAuthorityForPty({
settings: { terminalMainSideEffectAuthority: false },
runtimeEnvironmentId: null
})
).toBe(false)
})
it('honors the persisted kill switch before settings hydrate', () => {
// Creation-time authority must honor the persisted off switch even before settings hydrate.
setPersistedSettingsSync({ terminalMainSideEffectAuthority: false })
expect(
isMainTerminalSideEffectAuthorityForPty({ settings: null, runtimeEnvironmentId: null })
).toBe(false)
})
it('stays on pre-hydration when the persisted switch is on or unset', () => {
setPersistedSettingsSync({ terminalMainSideEffectAuthority: true })
expect(
isMainTerminalSideEffectAuthorityForPty({ settings: null, runtimeEnvironmentId: null })
).toBe(true)
_resetTerminalSideEffectFactConsumersForTest()
setPersistedSettingsSync({})
expect(
isMainTerminalSideEffectAuthorityForPty({ settings: null, runtimeEnvironmentId: null })
).toBe(true)
})
it('prefers hydrated settings over the persisted sync read', () => {
setPersistedSettingsSync({ terminalMainSideEffectAuthority: false })
expect(
isMainTerminalSideEffectAuthorityForPty({
settings: { terminalMainSideEffectAuthority: true },
runtimeEnvironmentId: null
})
).toBe(true)
})
it('caches the sync read so panes do not re-block per bind', () => {
const getSync = vi.fn(() => ({ terminalMainSideEffectAuthority: false }))
;(globalThis as { window: unknown }).window = { api: { settings: { getSync } } }
isMainTerminalSideEffectAuthorityForPty({ settings: null, runtimeEnvironmentId: null })
isMainTerminalSideEffectAuthorityForPty({ settings: null, runtimeEnvironmentId: null })
expect(getSync).toHaveBeenCalledTimes(1)
})
})
describe('registerTerminalSideEffectFactConsumer', () => {
const originalWindow = (globalThis as { window?: typeof window }).window
@@ -147,220 +51,6 @@ describe('registerTerminalSideEffectFactConsumer', () => {
}
})
it('routes live facts to the registered consumer in batch order', () => {
const { callbacks, events } = createCallbackRecorder()
registerTerminalSideEffectFactConsumer({
ptyId: PTY_ID,
callbacks: {
...callbacks,
onAgentStatus: (payload) => events.push(['status', payload.state, payload.agentType])
}
})
_dispatchTerminalSideEffectBatchForTest(
batch([
{
kind: 'agent-status',
payload: { state: 'working', prompt: 'fix it', agentType: 'codex' }
},
{ kind: 'title', normalizedTitle: '⠋ Claude', rawTitle: '⠋ Claude' },
{ kind: 'agent-working' },
{ kind: 'title', normalizedTitle: '✳ Claude', rawTitle: '✳ Claude' },
{ kind: 'agent-idle', title: '✳ Claude' },
{ kind: 'bell' }
])
)
expect(events).toEqual([
['status', 'working', 'codex'],
['title', '⠋ Claude', '⠋ Claude'],
['working'],
['title', '✳ Claude', '✳ Claude'],
['idle', '✳ Claude'],
['bell']
])
})
it('routes command-finished and pr-link facts to the registered consumer', () => {
const events: unknown[][] = []
registerTerminalSideEffectFactConsumer({
ptyId: PTY_ID,
callbacks: {
onCommandFinished: (exitCode) => events.push(['finished', exitCode]),
onPrLink: (link) => events.push(['pr', link.url, link.number])
}
})
_dispatchTerminalSideEffectBatchForTest(
batch([
{ kind: 'command-finished', exitCode: 130 },
{
kind: 'pr-link',
link: {
url: 'https://github.com/acme/orca/pull/42',
slug: { owner: 'acme', repo: 'orca' },
number: 42
}
},
{ kind: 'command-finished', exitCode: null }
])
)
expect(events).toEqual([
['finished', 130],
['pr', 'https://github.com/acme/orca/pull/42', 42],
['finished', null]
])
})
it('routes command-code scrape facts to the registered consumer', () => {
const events: unknown[][] = []
registerTerminalSideEffectFactConsumer({
ptyId: PTY_ID,
callbacks: {
onCommandCodeWorking: (prompt) => events.push(['cc-working', prompt]),
onCommandCodeDone: (prompt) => events.push(['cc-done', prompt])
}
})
_dispatchTerminalSideEffectBatchForTest(
batch([
{ kind: 'command-code-working', prompt: 'Fix the spinner' },
{ kind: 'command-code-done', prompt: 'Fix the spinner' }
])
)
expect(events).toEqual([
['cc-working', 'Fix the spinner'],
['cc-done', 'Fix the spinner']
])
})
it('never replays command-code scrape facts', () => {
// Replay is title-only; agent status seeds would resurrect finished turns.
const events: unknown[][] = []
registerTerminalSideEffectFactConsumer({
ptyId: PTY_ID,
callbacks: {
onTitleChange: (normalizedTitle) => events.push(['title', normalizedTitle]),
onCommandCodeWorking: (prompt) => events.push(['cc-working', prompt]),
onCommandCodeDone: (prompt) => events.push(['cc-done', prompt])
}
})
_dispatchTerminalSideEffectBatchForTest(
batch(
[
{ kind: 'title', normalizedTitle: 'restored', rawTitle: 'restored' },
{ kind: 'command-code-working', prompt: 'Fix the spinner' },
{ kind: 'command-code-done', prompt: 'Fix the spinner' }
],
{ replay: true, seq: 5 }
)
)
expect(events).toEqual([['title', 'restored']])
})
it('routes 2031-subscribe facts to the registered consumer but never replays them', () => {
// Live subscription facts enable hidden-view theme pushes; replay must not re-answer a satisfied query.
const events: unknown[][] = []
registerTerminalSideEffectFactConsumer({
ptyId: PTY_ID,
callbacks: {
onTitleChange: (normalizedTitle) => events.push(['title', normalizedTitle]),
onMode2031Subscribe: () => events.push(['2031-subscribe'])
}
})
_dispatchTerminalSideEffectBatchForTest(batch([{ kind: '2031-subscribe' }]))
expect(events).toEqual([['2031-subscribe']])
_dispatchTerminalSideEffectBatchForTest(
batch(
[
{ kind: 'title', normalizedTitle: 'restored', rawTitle: 'restored' },
{ kind: '2031-subscribe' }
],
{ replay: true, seq: 5 }
)
)
expect(events).toEqual([['2031-subscribe'], ['title', 'restored']])
})
it('never replays command-finished or pr-link facts', () => {
// Command/PR facts are attention too; snapshots restore only title state.
const events: unknown[][] = []
registerTerminalSideEffectFactConsumer({
ptyId: PTY_ID,
callbacks: {
onTitleChange: (normalizedTitle) => events.push(['title', normalizedTitle]),
onCommandFinished: (exitCode) => events.push(['finished', exitCode]),
onPrLink: (link) => events.push(['pr', link.url])
}
})
_dispatchTerminalSideEffectBatchForTest(
batch(
[
{ kind: 'title', normalizedTitle: 'restored', rawTitle: 'restored' },
{ kind: 'command-finished', exitCode: 0 },
{
kind: 'pr-link',
link: {
url: 'https://github.com/acme/orca/pull/42',
slug: { owner: 'acme', repo: 'orca' },
number: 42
}
}
],
{ replay: true, seq: 5 }
)
)
expect(events).toEqual([['title', 'restored']])
})
it('passes stale-clear provenance through to the title and idle callbacks', () => {
const events: unknown[][] = []
registerTerminalSideEffectFactConsumer({
ptyId: PTY_ID,
callbacks: {
onTitleChange: (normalizedTitle, _rawTitle, meta) =>
events.push(['title', normalizedTitle, meta]),
onAgentBecameIdle: (title, meta) => events.push(['idle', title, meta])
}
})
_dispatchTerminalSideEffectBatchForTest(
batch([
{ kind: 'agent-idle', title: 'Codex done' },
{
kind: 'title',
normalizedTitle: 'Codex',
rawTitle: 'Codex',
staleWorkingTitleClear: true
},
{ kind: 'agent-idle', title: 'Codex', staleWorkingTitleClear: true }
])
)
expect(events).toEqual([
['idle', 'Codex done', {}],
['title', 'Codex', { staleWorkingTitleClear: true }],
['idle', 'Codex', { staleWorkingTitleClear: true }]
])
})
it('drops batches for PTYs without a registered consumer', () => {
const { callbacks, events } = createCallbackRecorder()
registerTerminalSideEffectFactConsumer({ ptyId: PTY_ID, callbacks })
_dispatchTerminalSideEffectBatchForTest(batch([{ kind: 'bell' }], { ptyId: 'other-pty' }))
expect(events).toEqual([])
})
it('applies only title facts from replay batches — no attention replay', () => {
const { callbacks, events } = createCallbackRecorder()
registerTerminalSideEffectFactConsumer({ ptyId: PTY_ID, callbacks })
@@ -423,16 +113,6 @@ describe('registerTerminalSideEffectFactConsumer', () => {
expect(second.events).toEqual([['bell'], ['bell']])
})
it('stops routing after the consumer unregisters', () => {
const { callbacks, events } = createCallbackRecorder()
const dispose = registerTerminalSideEffectFactConsumer({ ptyId: PTY_ID, callbacks })
dispose()
_dispatchTerminalSideEffectBatchForTest(batch([{ kind: 'bell' }]))
expect(events).toEqual([])
})
it('hands off facts emitted between the parked watcher unregistering and the pane registering', () => {
// Reveal unregisters watchers before async pane registration; title-only replay cannot recover live bells/completions lost in that gap.
const watcher = createCallbackRecorder()
@@ -486,27 +166,6 @@ describe('registerTerminalSideEffectFactConsumer', () => {
expect(later).toEqual([])
})
it('does not buffer replay batches across a handoff', () => {
// New consumers request fresh snapshots; buffered replay could regress restored titles.
const dispose = registerTerminalSideEffectFactConsumer({
ptyId: PTY_ID,
callbacks: createCallbackRecorder().callbacks
})
dispose()
_dispatchTerminalSideEffectBatchForTest(
batch([{ kind: 'title', normalizedTitle: 'stale', rawTitle: 'stale' }], {
replay: true,
seq: 5
})
)
const { callbacks, events } = createCallbackRecorder()
registerTerminalSideEffectFactConsumer({ ptyId: PTY_ID, callbacks })
expect(events).toEqual([])
})
it('drains the handoff buffer before the register snapshot, so the replay is stale', async () => {
// Drain live titles before the async snapshot so sequence comparison rejects its stale predecessor.
const snapshot = batch([{ kind: 'title', normalizedTitle: 'snapshot', rawTitle: 'snapshot' }], {
@@ -538,50 +197,6 @@ describe('registerTerminalSideEffectFactConsumer', () => {
expect(events).toEqual([['title', 'live', 'live']])
})
it('drops a handoff-buffered batch once the buffer TTL expires', () => {
vi.useFakeTimers()
try {
const dispose = registerTerminalSideEffectFactConsumer({
ptyId: PTY_ID,
callbacks: createCallbackRecorder().callbacks
})
dispose()
_dispatchTerminalSideEffectBatchForTest(batch([{ kind: 'bell' }]))
expect(vi.getTimerCount()).toBe(1)
vi.advanceTimersByTime(15_001)
expect(vi.getTimerCount()).toBe(0)
const { callbacks, events } = createCallbackRecorder()
registerTerminalSideEffectFactConsumer({ ptyId: PTY_ID, callbacks })
expect(events).toEqual([])
} finally {
vi.useRealTimers()
}
})
it('subscribes to the channel once and routes IPC batches', () => {
let channelCallback: ((batch: TerminalSideEffectBatch) => void) | null = null
const onSideEffect = vi.fn((callback: (batch: TerminalSideEffectBatch) => void) => {
channelCallback = callback
return () => {
channelCallback = null
}
})
;(globalThis as { window: unknown }).window = {
api: { pty: { onSideEffect } }
}
const first = createCallbackRecorder()
const second = createCallbackRecorder()
registerTerminalSideEffectFactConsumer({ ptyId: PTY_ID, callbacks: first.callbacks })
registerTerminalSideEffectFactConsumer({ ptyId: 'pty-2', callbacks: second.callbacks })
expect(onSideEffect).toHaveBeenCalledTimes(1)
channelCallback!(batch([{ kind: 'bell' }], { ptyId: 'pty-2' }))
expect(second.events).toEqual([['bell']])
})
it('applies the title snapshot on register unless the registration was replaced', async () => {
let resolveSnapshot: (value: TerminalSideEffectBatch | null) => void = () => {}
const getSideEffectSnapshot = vi.fn(
@@ -616,25 +231,4 @@ describe('registerTerminalSideEffectFactConsumer', () => {
expect(first.events).toEqual([])
expect(second.events).toEqual([])
})
it('restores the snapshot title for a live registration', async () => {
const snapshot = batch([{ kind: 'title', normalizedTitle: 'restored', rawTitle: 'restored' }], {
replay: true,
seq: 5
})
;(globalThis as { window: unknown }).window = {
api: { pty: { getSideEffectSnapshot: vi.fn(async () => snapshot) } }
}
const { callbacks, events } = createCallbackRecorder()
registerTerminalSideEffectFactConsumer({
ptyId: PTY_ID,
callbacks,
restoreTitleOnRegister: true
})
await Promise.resolve()
await Promise.resolve()
expect(events).toEqual([['title', 'restored', 'restored']])
})
})
@@ -1,424 +0,0 @@
// @vitest-environment happy-dom
import '@testing-library/jest-dom/vitest'
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
import { act, cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react'
import userEvent from '@testing-library/user-event'
import { TerminalSshReconnectOverlay } from './TerminalSshReconnectOverlay'
import { useAppStore } from '@/store/index'
import { resetSshConnectInFlightForTests } from '@/ssh/ssh-connect-in-flight'
import type { SshConnectionState } from '../../../../../../../shared/ssh-types'
const toastMocks = vi.hoisted(() => ({
error: vi.fn()
}))
const deleteFlowMocks = vi.hoisted(() => ({
runWorktreeDelete: vi.fn()
}))
const environmentSshMocks = vi.hoisted(() => ({
connectRuntimeEnvironmentSshTarget: vi.fn(),
resyncRuntimeEnvironmentSshTargets: vi.fn()
}))
vi.mock('sonner', () => ({
toast: {
error: toastMocks.error
}
}))
vi.mock('../../../../sidebar/workspace-actions/deletion/delete-worktree-flow', () => ({
runWorktreeDelete: deleteFlowMocks.runWorktreeDelete
}))
vi.mock('@/runtime/hosts/ssh/runtime-environment-ssh-state', () => environmentSshMocks)
vi.mock('@/i18n/i18n', () => ({
translate: (_key: string, fallback: string, values?: Record<string, string>) =>
fallback.replace('{{value0}}', values?.value0 ?? '')
}))
function installSshConnect(
connect: ReturnType<typeof vi.fn>,
overrides: Record<string, ReturnType<typeof vi.fn>> = {}
): void {
Object.defineProperty(window, 'api', {
configurable: true,
value: {
ssh: {
connect,
listTargets: vi.fn().mockResolvedValue([]),
listRemovedTargetLabels: vi.fn().mockResolvedValue({}),
...overrides
}
}
})
}
describe('TerminalSshReconnectOverlay', () => {
beforeEach(() => {
useAppStore.setState(useAppStore.getInitialState(), true)
resetSshConnectInFlightForTests()
toastMocks.error.mockReset()
deleteFlowMocks.runWorktreeDelete.mockReset()
environmentSshMocks.connectRuntimeEnvironmentSshTarget.mockReset()
environmentSshMocks.resyncRuntimeEnvironmentSshTargets.mockReset()
})
afterEach(() => {
cleanup()
})
it('renders a non-blocking Connect banner for a disconnected SSH terminal', async () => {
const connect = vi.fn().mockResolvedValue(undefined)
installSshConnect(connect)
const user = userEvent.setup()
const { container } = render(
<TerminalSshReconnectOverlay
targetId="ssh-target-1"
targetLabel="devbox"
status="disconnected"
/>
)
expect(screen.getByText('SSH connection required')).toBeInTheDocument()
expect(screen.getByText(/This terminal is waiting for devbox/)).toBeInTheDocument()
expect(screen.getByRole('status')).toBeInTheDocument()
const banner = container.querySelector('[data-terminal-ssh-reconnect-banner="disconnected"]')
expect(banner).toHaveClass('inset-x-3', 'bottom-3', 'z-40')
expect(banner).not.toHaveClass('inset-0', 'bg-background/75')
await user.click(screen.getByRole('button', { name: 'Connect' }))
expect(connect).toHaveBeenCalledWith({ targetId: 'ssh-target-1' })
})
// Failure details carry the host-key remedy missing from the generic status sentence.
it('shows the failure detail beneath the status sentence', () => {
installSshConnect(vi.fn())
render(
<TerminalSshReconnectOverlay
targetId="ssh-target-1"
targetLabel="devbox"
status="error"
error="Host key verification failed for devbox. Run: ssh-keygen -R devbox"
/>
)
expect(screen.getByText(/The SSH connection to devbox failed/)).toBeInTheDocument()
expect(screen.getByText(/ssh-keygen -R devbox/)).toBeInTheDocument()
})
it('shows nothing extra when there is no detail', () => {
installSshConnect(vi.fn())
render(
<TerminalSshReconnectOverlay targetId="ssh-target-1" targetLabel="devbox" status="error" />
)
expect(screen.getByText(/The SSH connection to devbox failed/)).toBeInTheDocument()
expect(screen.queryByText(/ssh-keygen/)).not.toBeInTheDocument()
})
// Removed targets cannot reconnect; stale connection errors would contradict the removal notice.
it('suppresses the detail for a removed target', () => {
installSshConnect(vi.fn())
render(
<TerminalSshReconnectOverlay
targetId="ssh-target-1"
targetLabel="devbox"
status="error"
error="Host key verification failed for devbox."
targetRemoved
/>
)
expect(screen.queryByText(/Host key verification failed/)).not.toBeInTheDocument()
})
it('shows an in-flight state while the SSH target is reconnecting', () => {
const connect = vi.fn().mockResolvedValue(undefined)
installSshConnect(connect)
render(
<TerminalSshReconnectOverlay
targetId="ssh-target-1"
targetLabel="devbox"
status="reconnecting"
/>
)
expect(screen.getByText(/Connecting to devbox/)).toBeInTheDocument()
expect(screen.getByRole('button', { name: /Connecting…/ })).toBeDisabled()
expect(connect).not.toHaveBeenCalled()
})
it('reports connect failures and re-enables the Connect action', async () => {
const connect = vi.fn().mockRejectedValue(new Error('Passphrase rejected'))
installSshConnect(connect)
const user = userEvent.setup()
render(
<TerminalSshReconnectOverlay
targetId="ssh-target-1"
targetLabel="devbox"
status="auth-failed"
/>
)
await user.click(screen.getByRole('button', { name: 'Reconnect' }))
await waitFor(() => expect(toastMocks.error).toHaveBeenCalledWith('Passphrase rejected'))
expect(screen.getByRole('button', { name: 'Reconnect' })).toBeEnabled()
})
it('resyncs target metadata after a failed connect so a stale overlay converges', async () => {
const connect = vi.fn().mockRejectedValue(new Error('SSH target "ssh-dead" not found'))
const listTargets = vi
.fn()
.mockResolvedValue([
{ id: 'ssh-live', label: 'devbox', host: 'devbox', port: 22, username: 'me' }
])
const listRemovedTargetLabels = vi.fn().mockResolvedValue({ 'ssh-dead': 'devbox (removed)' })
installSshConnect(connect, { listTargets, listRemovedTargetLabels })
const user = userEvent.setup()
render(
<TerminalSshReconnectOverlay targetId="ssh-dead" targetLabel="devbox" status="disconnected" />
)
await user.click(screen.getByRole('button', { name: 'Connect' }))
// Refresh metadata so the pane replaces a failing Connect loop with removed-host recovery.
await waitFor(() => {
expect(useAppStore.getState().sshTargetLabels.get('ssh-live')).toBe('devbox')
expect(useAppStore.getState().removedSshTargetLabels.get('ssh-dead')).toBe('devbox (removed)')
})
})
it('still applies the target list when the removed-labels refresh fails', async () => {
const connect = vi.fn().mockRejectedValue(new Error('SSH target "ssh-dead" not found'))
const listTargets = vi
.fn()
.mockResolvedValue([
{ id: 'ssh-live', label: 'devbox', host: 'devbox', port: 22, username: 'me' }
])
const listRemovedTargetLabels = vi.fn().mockRejectedValue(new Error('unavailable'))
installSshConnect(connect, { listTargets, listRemovedTargetLabels })
const user = userEvent.setup()
render(
<TerminalSshReconnectOverlay targetId="ssh-dead" targetLabel="devbox" status="disconnected" />
)
await user.click(screen.getByRole('button', { name: 'Connect' }))
// Keep the refreshed target list even if removed-label metadata fails.
await waitFor(() => {
expect(useAppStore.getState().sshTargetLabels.get('ssh-live')).toBe('devbox')
expect(useAppStore.getState().sshTargetsHydrated).toBe(true)
})
})
it('offers to remove the workspace (not Connect) when the SSH target was removed', async () => {
const connect = vi.fn().mockResolvedValue(undefined)
installSshConnect(connect)
const user = userEvent.setup()
render(
<TerminalSshReconnectOverlay
targetId="ssh-dead"
targetLabel="ssh-dead"
status="disconnected"
targetRemoved
worktreeId="repo::/work/wt"
/>
)
expect(screen.getByText('SSH host removed')).toBeInTheDocument()
expect(screen.queryByRole('button', { name: 'Connect' })).not.toBeInTheDocument()
await user.click(screen.getByRole('button', { name: 'Remove workspace' }))
expect(deleteFlowMocks.runWorktreeDelete).toHaveBeenCalledWith('repo::/work/wt', {
expectedHostId: 'ssh:ssh-dead'
})
expect(connect).not.toHaveBeenCalled()
})
it('routes Connect to the owning environment runtime RPC for a remote-owned workspace', async () => {
const connect = vi.fn().mockResolvedValue(undefined)
installSshConnect(connect)
environmentSshMocks.connectRuntimeEnvironmentSshTarget.mockResolvedValue(null)
const user = userEvent.setup()
render(
<TerminalSshReconnectOverlay
targetId="ssh-remote-1"
targetLabel="devbox"
status="disconnected"
sshOwnerEnvironmentId="env-1"
/>
)
await user.click(screen.getByRole('button', { name: 'Connect' }))
await waitFor(() =>
expect(environmentSshMocks.connectRuntimeEnvironmentSshTarget).toHaveBeenCalledWith(
'env-1',
'ssh-remote-1'
)
)
expect(connect).not.toHaveBeenCalled()
})
it('resyncs the owning environment (not the local store) after a failed remote connect', async () => {
const connect = vi.fn().mockResolvedValue(undefined)
const listTargets = vi.fn().mockResolvedValue([])
installSshConnect(connect, { listTargets })
environmentSshMocks.connectRuntimeEnvironmentSshTarget.mockRejectedValue(
new Error('SSH target "ssh-remote-dead" not found')
)
environmentSshMocks.resyncRuntimeEnvironmentSshTargets.mockResolvedValue(undefined)
const user = userEvent.setup()
render(
<TerminalSshReconnectOverlay
targetId="ssh-remote-dead"
targetLabel="devbox"
status="disconnected"
sshOwnerEnvironmentId="env-1"
/>
)
await user.click(screen.getByRole('button', { name: 'Connect' }))
await waitFor(() =>
expect(toastMocks.error).toHaveBeenCalledWith('SSH target "ssh-remote-dead" not found')
)
await waitFor(() =>
expect(environmentSshMocks.resyncRuntimeEnvironmentSshTargets).toHaveBeenCalledWith('env-1')
)
expect(listTargets).not.toHaveBeenCalled()
expect(useAppStore.getState().sshTargetsHydrated).toBe(false)
})
it('suppresses a second connect before shared target banners repaint', async () => {
const pending = Promise.withResolvers<undefined>()
const connect = vi.fn().mockReturnValue(pending.promise)
installSshConnect(connect)
render(
<>
<TerminalSshReconnectOverlay
targetId="ssh-target-1"
targetLabel="devbox"
status="disconnected"
/>
<TerminalSshReconnectOverlay
targetId="ssh-target-1"
targetLabel="devbox"
status="disconnected"
/>
</>
)
const buttons = screen.getAllByRole('button', { name: 'Connect' })
try {
act(() => {
for (const button of buttons) {
fireEvent.click(button)
}
})
expect(connect).toHaveBeenCalledExactlyOnceWith({ targetId: 'ssh-target-1' })
for (const button of screen.getAllByRole('button', { name: /Connecting…/ })) {
expect(button).toBeDisabled()
}
} finally {
await act(async () => pending.resolve(undefined))
}
})
it('publishes the returned SSH state so deferred terminal reattach can resume', async () => {
const connectedState: SshConnectionState = {
targetId: 'ssh-target-1',
status: 'connected',
error: null,
reconnectAttempt: 0,
remotePlatform: 'linux'
}
const connect = vi.fn().mockResolvedValue(connectedState)
installSshConnect(connect)
const user = userEvent.setup()
render(
<TerminalSshReconnectOverlay
targetId="ssh-target-1"
targetLabel="devbox"
status="disconnected"
/>
)
await user.click(screen.getByRole('button', { name: 'Connect' }))
await waitFor(() =>
expect(useAppStore.getState().sshConnectionStates.get('ssh-target-1')).toEqual(connectedState)
)
})
it('offers Move anyway beside Retry for a local move refused only by saved state', async () => {
const allowMoveLeavingBehind = vi.fn().mockResolvedValue(undefined)
const connect = vi.fn().mockResolvedValue(null)
installSshConnect(connect)
Object.assign(window.api, {
runtimeEnvironments: { managedOrcad: { allowMoveLeavingBehind } }
})
useAppStore.getState().setSshConnectionState('ssh-target-1', {
targetId: 'ssh-target-1',
status: 'error',
error: 'blocked',
reconnectAttempt: 0,
managedServer: {
kind: 'relay',
reason: 'refused',
detail: 'This SSH host cannot move yet: automations (2).',
canLeaveBehind: true
}
})
const user = userEvent.setup()
const { rerender } = render(
<TerminalSshReconnectOverlay targetId="ssh-target-1" targetLabel="lambda" status="error" />
)
await user.click(screen.getByRole('button', { name: 'Move anyway…' }))
await user.click(screen.getByRole('button', { name: 'Move anyway' }))
await waitFor(() =>
expect(allowMoveLeavingBehind).toHaveBeenCalledWith({ sshTargetId: 'ssh-target-1' })
)
expect(connect).toHaveBeenCalledWith({ targetId: 'ssh-target-1' })
// A connect already in flight may clear the refusal, so the button waits for it.
rerender(
<TerminalSshReconnectOverlay
targetId="ssh-target-1"
targetLabel="lambda"
status="connecting"
/>
)
expect(screen.getByRole('button', { name: 'Move anyway…' })).toBeDisabled()
// A remote server's move is that server's own; this desktop can't drive it.
rerender(
<TerminalSshReconnectOverlay
targetId="ssh-target-1"
targetLabel="lambda"
status="error"
sshOwnerEnvironmentId="env-1"
/>
)
expect(screen.queryByRole('button', { name: 'Move anyway…' })).not.toBeInTheDocument()
})
})
@@ -1,6 +1,5 @@
import { describe, expect, it, vi } from 'vitest'
import { createRemoteRuntimeRecoveryInputHold } from './remote-runtime-recovery-input-hold'
import { PTY_PRECONNECT_INPUT_MAX_ENTRIES } from '../../input/pty-preconnect-input-buffer'
function createWriter() {
const sent: string[] = []
@@ -24,36 +23,6 @@ function createWriter() {
const endpoint = { handle: 'terminal-1', incarnationId: 'inc-1' }
describe('remote runtime recovery input hold', () => {
it('holds more keystrokes than the per-entry cap during a long outage', async () => {
const hold = createRemoteRuntimeRecoveryInputHold()
const { sent, writer } = createWriter()
// Typing one token a second through a minutes-long outage queues one entry per keystroke.
const keys = Array.from({ length: PTY_PRECONNECT_INPUT_MAX_ENTRIES * 2 }, (_, index) =>
String(index % 10)
)
for (const key of keys) {
expect(hold.enqueue(endpoint, key, 'driving')).toBe(true)
}
hold.release(endpoint, writer)
await vi.waitFor(() => expect(hold.isHolding()).toBe(false))
expect(sent.join('')).toBe(keys.join(''))
})
it('delivers held input in order to the terminal it was typed into', async () => {
const hold = createRemoteRuntimeRecoveryInputHold()
const { sent, writer } = createWriter()
expect(hold.enqueue(endpoint, 'ls', 'driving')).toBe(true)
const accepted = hold.enqueueAccepted(endpoint, '\r', 'driving')
hold.release(endpoint, writer)
await expect(accepted).resolves.toBe(true)
expect(sent).toEqual(['ls', '\r'])
await vi.waitFor(() => expect(hold.isHolding()).toBe(false))
})
it('pauses a release interrupted by another outage and keeps the rest for the next release', async () => {
const hold = createRemoteRuntimeRecoveryInputHold()
const { sent, writer } = createWriter()
@@ -84,20 +53,6 @@ describe('remote runtime recovery input hold', () => {
await vi.waitFor(() => expect(sent).toEqual(['typed after']))
})
it('keeps delivering typing after an accepted write the sequenced stream withdrew or could not confirm', async () => {
const hold = createRemoteRuntimeRecoveryInputHold()
const { sent, writer } = createWriter()
const paste = hold.enqueueAccepted(endpoint, 'paste', 'driving')
hold.enqueue(endpoint, 'typed after', 'driving')
hold.release(endpoint, {
...writer,
sendInputAccepted: vi.fn(async () => false),
continuesAfterFailedWrite: () => true
})
await expect(paste).resolves.toBe(false)
await vi.waitFor(() => expect(sent).toEqual(['typed after']))
})
it('drops held input when the pane rebinds to a different terminal', async () => {
const hold = createRemoteRuntimeRecoveryInputHold()
const { sent, writer } = createWriter()