diff --git a/src/main/runtime/rpc/methods/terminal.ts b/src/main/runtime/rpc/methods/terminal.ts index d1847e690c9b..c5758273e656 100644 --- a/src/main/runtime/rpc/methods/terminal.ts +++ b/src/main/runtime/rpc/methods/terminal.ts @@ -77,11 +77,14 @@ type SnapshotFrameOptions = { source?: 'headless' | 'renderer' oscLinks?: TerminalOscLinkRange[] pendingEscapeTailAnsi?: string + alternateScreen?: boolean + scrollbackAnsiLength?: number } type SerializedSnapshot = { data: string scrollbackAnsi?: string + alternateScreen?: boolean cols: number rows: number seq?: number @@ -665,6 +668,10 @@ function sendSnapshotFrames( source: options.source, oscLinks: options.oscLinks, pendingEscapeTailAnsi: options.pendingEscapeTailAnsi, + ...(options.alternateScreen === true ? { alternateScreen: true } : {}), + ...(typeof options.scrollbackAnsiLength === 'number' + ? { scrollbackAnsiLength: options.scrollbackAnsiLength } + : {}), truncated: options.truncated === true, truncatedByByteBudget: options.truncatedByByteBudget === true }) @@ -2096,6 +2103,11 @@ export const TERMINAL_METHODS: RpcAnyMethod[] = [ source: serialized?.source, oscLinks: serialized?.oscLinks, pendingEscapeTailAnsi: serialized?.pendingEscapeTailAnsi, + alternateScreen: serialized?.alternateScreen, + scrollbackAnsiLength: + typeof serialized?.scrollbackAnsi === 'string' + ? serialized.scrollbackAnsi.length + : undefined, truncated: false, truncatedByByteBudget: serialized?.truncatedByByteBudget, data: serialized?.data ?? '' diff --git a/src/main/runtime/rpc/terminal-multiplex-escape-tail.test.ts b/src/main/runtime/rpc/terminal-multiplex-escape-tail.test.ts index 88125c840b3e..5828d6d1fbfa 100644 --- a/src/main/runtime/rpc/terminal-multiplex-escape-tail.test.ts +++ b/src/main/runtime/rpc/terminal-multiplex-escape-tail.test.ts @@ -8,6 +8,7 @@ import { TerminalStreamOpcode, decodeTerminalStreamFrame, decodeTerminalStreamJson, + decodeTerminalStreamText, encodeTerminalStreamFrame, encodeTerminalStreamJson } from '../../../shared/terminal-stream-protocol' @@ -128,4 +129,149 @@ describe('terminal.multiplex pending-escape-tail threading (#7329)', () => { vi.useRealTimers() } }) + + it('carries requested-snapshot alternate-screen metadata through the SnapshotStart frame', async () => { + vi.useFakeTimers() + try { + const messages: string[] = [] + const binaryFrames: Uint8Array[] = [] + const handlers = new Map< + number, + (frame: NonNullable>) => void + >() + const cleanups = new Map void>() + const runtime = stubRuntime({ + resolveLiveLeafForHandle: vi.fn().mockReturnValue({ ptyId: 'pty-1' }), + readTerminal: vi.fn().mockResolvedValue({ tail: [], truncated: false }), + serializeTerminalBuffer: vi + .fn() + .mockResolvedValueOnce({ + data: 'user@host:~$ ', + cols: 80, + rows: 24 + }) + .mockResolvedValueOnce({ + data: 'alternate frame', + cols: 80, + rows: 24, + alternateScreen: true, + scrollbackAnsi: 'history\r\n' + }), + getTerminalSize: vi.fn().mockReturnValue({ cols: 80, rows: 24 }), + getMobileDisplayMode: vi.fn().mockReturnValue('auto'), + getLayout: vi.fn().mockReturnValue({ seq: 1 }), + registerRemoteTerminalViewSubscriber: vi.fn(() => () => {}), + subscribeToTerminalData: vi.fn().mockReturnValue(vi.fn()), + subscribeToTerminalResize: vi.fn().mockReturnValue(vi.fn()), + subscribeToFitOverrideChanges: vi.fn().mockReturnValue(vi.fn()), + subscribeToDriverChanges: vi.fn().mockReturnValue(vi.fn()), + getTerminalFitOverride: vi.fn().mockReturnValue(null), + getDriver: vi.fn().mockReturnValue({ kind: 'idle' }), + registerSubscriptionCleanup: vi.fn((id: string, cleanup: () => void) => { + cleanups.set(id, cleanup) + }), + cleanupSubscription: vi.fn((id: string) => { + const cleanup = cleanups.get(id) + cleanups.delete(id) + cleanup?.() + }), + waitForTerminal: vi.fn(() => new Promise(() => {})), + updateDesktopViewport: vi.fn().mockResolvedValue(true) + }) + const dispatcher = new RpcDispatcher({ + runtime, + methods: TERMINAL_METHODS + }) + + const dispatchPromise = dispatcher.dispatchStreaming( + makeRequest('terminal.multiplex', {}), + (msg) => messages.push(msg), + { + connectionId: 'conn-1', + sendBinary: (bytes) => { + binaryFrames.push(bytes) + }, + registerBinaryStreamHandler: (streamId, handler) => { + handlers.set(streamId, handler) + return () => handlers.delete(streamId) + } + } + ) + + await vi.runOnlyPendingTimersAsync() + expect(messages.some((msg) => JSON.parse(msg).result?.type === 'ready')).toBe(true) + + const handler = handlers.get(0)! + handler( + decodeTerminalStreamFrame( + encodeTerminalStreamFrame({ + opcode: TerminalStreamOpcode.Subscribe, + streamId: 0, + seq: 1, + payload: encodeTerminalStreamJson({ + streamId: 5, + terminal: 'terminal-1', + client: { id: 'desktop-1', type: 'desktop' } + }) + }) + )! + ) + for (let i = 0; i < 5; i += 1) { + await vi.runOnlyPendingTimersAsync() + } + + handlers.get(5)!( + decodeTerminalStreamFrame( + encodeTerminalStreamFrame({ + opcode: TerminalStreamOpcode.SnapshotRequest, + streamId: 5, + seq: 2, + payload: encodeTerminalStreamJson({ + requestId: 99, + scrollbackRows: 100 + }) + }) + )! + ) + for (let i = 0; i < 5; i += 1) { + await vi.runOnlyPendingTimersAsync() + } + + const requestedSnapshotStart = binaryFrames + .map((frame) => decodeTerminalStreamFrame(frame)) + .find((frame) => { + if (frame?.opcode !== TerminalStreamOpcode.SnapshotStart) { + return false + } + const payload = decodeTerminalStreamJson<{ requestId?: unknown }>(frame.payload) + return payload?.requestId === 99 + })! + expect(decodeTerminalStreamJson(requestedSnapshotStart.payload)).toMatchObject({ + requestId: 99, + alternateScreen: true, + scrollbackAnsiLength: 'history\r\n'.length + }) + const requestedSnapshotStartIndex = binaryFrames.findIndex((frame) => { + const decoded = decodeTerminalStreamFrame(frame) + if (decoded?.opcode !== TerminalStreamOpcode.SnapshotStart) { + return false + } + const payload = decodeTerminalStreamJson<{ requestId?: unknown }>(decoded.payload) + return payload?.requestId === 99 + }) + const requestedSnapshotChunk = binaryFrames + .slice(requestedSnapshotStartIndex + 1) + .map((frame) => decodeTerminalStreamFrame(frame)) + .find((frame) => frame?.opcode === TerminalStreamOpcode.SnapshotChunk) + expect(requestedSnapshotChunk).toBeTruthy() + expect(decodeTerminalStreamText(requestedSnapshotChunk!.payload)).toBe( + 'history\r\nalternate frame' + ) + + runtime.cleanupSubscription('terminal-multiplex:conn-1') + await dispatchPromise + } finally { + vi.useRealTimers() + } + }) }) diff --git a/src/renderer/src/components/terminal-pane/pty-connection.test.ts b/src/renderer/src/components/terminal-pane/pty-connection.test.ts index 7374e99e551d..afd8876ffd7e 100644 --- a/src/renderer/src/components/terminal-pane/pty-connection.test.ts +++ b/src/renderer/src/components/terminal-pane/pty-connection.test.ts @@ -11527,6 +11527,11 @@ describe('connectPanePty', () => { expect(getMainBufferSnapshot).not.toHaveBeenCalled() expect(transport.serializeBuffer).toHaveBeenCalledWith({ scrollbackRows: 5000 }) expect(pane.terminal.write).not.toHaveBeenCalledWith(hidden) + expect(pane.terminal.write).toHaveBeenCalledWith('\x1b[2J\x1b[3J\x1b[H', expect.any(Function)) + expect(pane.terminal.write).not.toHaveBeenCalledWith( + '\x1b[0m\x1b[?1049h\x1b[2J\x1b[H', + expect.any(Function) + ) expect(pane.terminal.write).toHaveBeenCalledWith( expect.stringContaining('remote snapshot with hidden remote output'), expect.any(Function) @@ -11534,6 +11539,110 @@ describe('connectPanePty', () => { disposable.dispose() }) + it('restores remote alternate-screen snapshots with preserved scrollback', async () => { + const { connectPanePty } = await import('./pty-connection') + const transport = createMockTransport('remote:env-1@@terminal-1') + const capturedDataCallback: { + current: ((data: string, meta?: { seq?: number; rawLength?: number }) => void) | null + } = { current: null } + const hidden = 'x'.repeat(2 * 1024 * 1024 + 1) + const live = 'visible remote output\r\n' + transport.serializeBuffer = vi.fn().mockResolvedValueOnce({ + data: 'remote alt snapshot with history\r\n', + cols: 120, + rows: 40, + seq: hidden.length + live.length, + source: 'headless', + alternateScreen: true, + scrollbackAnsi: 'remote shell history\r\n' + }) + transport.connect.mockImplementation(async ({ callbacks }: { callbacks: ConnectCallbacks }) => { + capturedDataCallback.current = callbacks.onData ?? null + return 'remote:env-1@@terminal-1' + }) + transportFactoryQueue.push(transport) + + const pane = createPane(1) + const manager = createManager(1) + const deps = createDeps({ isVisibleRef: { current: false } }) + const disposable = connectPanePty(pane as never, manager as never, deps as never) + await flushAsyncTicks(6) + + capturedDataCallback.current?.(hidden, { seq: hidden.length, rawLength: hidden.length }) + ;(deps.isVisibleRef as { current: boolean }).current = true + capturedDataCallback.current?.(live, { + seq: hidden.length + live.length, + rawLength: live.length + }) + await flushAsyncTicks(20) + + expect(pane.terminal.write).toHaveBeenCalledWith( + '\x1b[?1049l\x1b[2J\x1b[3J\x1b[H', + expect.any(Function) + ) + expect(pane.terminal.write).toHaveBeenCalledWith( + 'remote shell history\r\n', + expect.any(Function) + ) + expect(pane.terminal.write).toHaveBeenCalledWith( + 'remote alt snapshot with history\r\n', + expect.any(Function) + ) + + disposable.dispose() + }) + + it('restores remote alternate-screen snapshots without preserved scrollback', async () => { + const { connectPanePty } = await import('./pty-connection') + const transport = createMockTransport('remote:env-1@@terminal-1') + const capturedDataCallback: { + current: ((data: string, meta?: { seq?: number; rawLength?: number }) => void) | null + } = { current: null } + const hidden = 'x'.repeat(2 * 1024 * 1024 + 1) + const live = 'visible remote output\r\n' + transport.serializeBuffer = vi.fn().mockResolvedValue({ + data: 'remote alt snapshot without history\r\n', + cols: 120, + rows: 40, + seq: hidden.length + live.length, + source: 'headless', + alternateScreen: true + }) + transport.connect.mockImplementation(async ({ callbacks }: { callbacks: ConnectCallbacks }) => { + capturedDataCallback.current = callbacks.onData ?? null + return 'remote:env-1@@terminal-1' + }) + transportFactoryQueue.push(transport) + + const pane = createPane(1) + const manager = createManager(1) + const deps = createDeps({ isVisibleRef: { current: false } }) + const disposable = connectPanePty(pane as never, manager as never, deps as never) + await flushAsyncTicks(6) + + capturedDataCallback.current?.(hidden, { seq: hidden.length, rawLength: hidden.length }) + ;(deps.isVisibleRef as { current: boolean }).current = true + capturedDataCallback.current?.(live, { + seq: hidden.length + live.length, + rawLength: live.length + }) + await flushAsyncTicks(20) + + expect(pane.terminal.write).toHaveBeenCalledWith( + '\x1b[0m\x1b[?1049h\x1b[2J\x1b[H', + expect.any(Function) + ) + expect(pane.terminal.write).not.toHaveBeenCalledWith( + '\x1b[?1049l\x1b[2J\x1b[3J\x1b[H', + expect.any(Function) + ) + expect(pane.terminal.write).toHaveBeenCalledWith( + 'remote alt snapshot without history\r\n', + expect.any(Function) + ) + disposable.dispose() + }) + it('defers inactive split-pane plain hidden output restore until the pane returns', async () => { const { resetHiddenOutputRestoreSchedulerForTests } = await import('./hidden-output-restore-scheduler') diff --git a/src/renderer/src/runtime/remote-runtime-terminal-frame-drop-resync.test.ts b/src/renderer/src/runtime/remote-runtime-terminal-frame-drop-resync.test.ts index 03a6a944618d..b241283724eb 100644 --- a/src/renderer/src/runtime/remote-runtime-terminal-frame-drop-resync.test.ts +++ b/src/renderer/src/runtime/remote-runtime-terminal-frame-drop-resync.test.ts @@ -45,6 +45,8 @@ class FakeMultiplexServer { snapshotRequests: (number | undefined)[] = [] private heldManualRequestId: number | null = null private snapshotData = 'INITIAL' + private snapshotAlternateScreen = false + private snapshotScrollbackAnsiLength: number | undefined constructor( private readonly toClient: (bytes: Uint8Array) => void, @@ -73,7 +75,9 @@ class FakeMultiplexServer { } // Resync request: the server serializes the *current* buffer, so recovery // includes everything the client missed. - this.snapshotData = 'RECOVERED' + if (typeof payload?.requestId !== 'number') { + this.snapshotData = 'RECOVERED' + } if (typeof payload?.requestId !== 'number' && this.holdNextRecoverySnapshot) { // The reply's binary frames were all dropped under backpressure. this.holdNextRecoverySnapshot = false @@ -108,7 +112,11 @@ class FakeMultiplexServer { rows: 24, seq: options?.truncated ? undefined : this.cursorUnits, requestId, - truncated: options?.truncated + truncated: options?.truncated, + ...(this.snapshotAlternateScreen ? { alternateScreen: true } : {}), + ...(typeof this.snapshotScrollbackAnsiLength === 'number' + ? { scrollbackAnsiLength: this.snapshotScrollbackAnsiLength } + : {}) }), 0 ) @@ -167,6 +175,16 @@ class FakeMultiplexServer { this.snapshotData = 'MANUAL' this.sendSnapshot(requestId) } + + setSnapshot( + data: string, + options: { alternateScreen?: boolean; scrollbackAnsiLength?: number } = {} + ) { + this.snapshotData = data + this.snapshotAlternateScreen = options.alternateScreen === true + this.snapshotScrollbackAnsiLength = + typeof options.scrollbackAnsiLength === 'number' ? options.scrollbackAnsiLength : undefined + } } describe('remote terminal frame-drop resync', () => { @@ -250,6 +268,34 @@ describe('remote terminal frame-drop resync', () => { expect(data).toEqual(['aaa', 'ddd']) }) + it('splits remote alternate-screen scrollback from a requested snapshot', async () => { + const { stream } = await subscribeClient() + server.setSnapshot('shell history\ralternate frame', { + alternateScreen: true, + scrollbackAnsiLength: 'shell history\r'.length + }) + + await expect(stream.serializeBuffer({ scrollbackRows: 100 })).resolves.toMatchObject({ + data: 'alternate frame', + alternateScreen: true, + scrollbackAnsi: 'shell history\r' + }) + }) + + it('preserves remote alternate-screen snapshots when no scrollback boundary is present', async () => { + const { stream } = await subscribeClient() + server.setSnapshot('alternate frame', { + alternateScreen: true + }) + + const snapshot = await stream.serializeBuffer({ scrollbackRows: 100 }) + expect(snapshot).toMatchObject({ + data: 'alternate frame', + alternateScreen: true + }) + expect(snapshot?.scrollbackAnsi).toBeUndefined() + }) + it('retries a truncated recovery on a backoff without accepting output across the gap', async () => { vi.useFakeTimers() try { @@ -487,7 +533,10 @@ describe('remote terminal frame-drop resync', () => { await Promise.resolve() await Promise.resolve() - await expect(manualSnapshot).resolves.toMatchObject({ data: 'MANUAL' }) + const snapshot = await manualSnapshot + expect(snapshot).toMatchObject({ data: 'MANUAL' }) + expect(snapshot?.alternateScreen).toBeUndefined() + expect(snapshot?.scrollbackAnsi).toBeUndefined() expect(server.snapshotRequests).toHaveLength(2) expect(snapshots).toEqual(['INITIAL', '\x1b[2J\x1b[3J\x1b[HRECOVERED']) diff --git a/src/renderer/src/runtime/remote-runtime-terminal-multiplexer.ts b/src/renderer/src/runtime/remote-runtime-terminal-multiplexer.ts index 0c13d2d20bf0..c32319453a08 100644 --- a/src/renderer/src/runtime/remote-runtime-terminal-multiplexer.ts +++ b/src/renderer/src/runtime/remote-runtime-terminal-multiplexer.ts @@ -71,6 +71,8 @@ export type RemoteRuntimeMultiplexedTerminal = { rows: number seq?: number source?: 'headless' | 'renderer' + alternateScreen?: boolean + scrollbackAnsi?: string } | null> close: () => void } @@ -114,6 +116,8 @@ type RemoteRuntimeSnapshotInfo = { // must write it AFTER the replay reset so the next live chunk completes it // instead of rendering literally (#7329). pendingEscapeTailAnsi?: string + alternateScreen?: boolean + scrollbackAnsiLength?: number } type RemoteRuntimeSnapshotRequest = { @@ -126,6 +130,8 @@ type RemoteRuntimeSnapshotRequest = { seq?: number source?: 'headless' | 'renderer' pendingEscapeTailAnsi?: string + alternateScreen?: boolean + scrollbackAnsi?: string } | null ) => void reject: (error: Error) => void @@ -634,14 +640,29 @@ class RemoteRuntimeTerminalMultiplexer { ? info.requestId === pendingRequest.requestId : stream.initialSnapshotReceived) if (snapshotApplied) { + const foldedData = data ?? '' + const hasAltScreenBoundary = + info?.alternateScreen === true && + typeof info.scrollbackAnsiLength === 'number' && + Number.isInteger(info.scrollbackAnsiLength) && + info.scrollbackAnsiLength >= 0 && + info.scrollbackAnsiLength <= foldedData.length + const scrollbackAnsi = hasAltScreenBoundary + ? foldedData.slice(0, info.scrollbackAnsiLength) + : undefined + const snapshotData = hasAltScreenBoundary + ? foldedData.slice(info.scrollbackAnsiLength) + : foldedData if (matchesPendingRequest) { pendingRequest.resolve({ - data: data ?? '', + data: snapshotData, cols: info?.cols ?? 80, rows: info?.rows ?? 24, seq: info?.seq, source: info?.source, - pendingEscapeTailAnsi: info?.pendingEscapeTailAnsi + pendingEscapeTailAnsi: info?.pendingEscapeTailAnsi, + ...(info?.alternateScreen === true ? { alternateScreen: true } : {}), + ...(hasAltScreenBoundary ? { scrollbackAnsi } : {}) }) clearPendingSnapshotRequest(stream) } else if (target === 'initial') { @@ -1118,6 +1139,8 @@ function decodeSnapshotInfo( requestId?: unknown truncated?: unknown pendingEscapeTailAnsi?: unknown + alternateScreen?: unknown + scrollbackAnsiLength?: unknown }>(payload) if (!raw) { return null @@ -1130,7 +1153,10 @@ function decodeSnapshotInfo( requestId: typeof raw.requestId === 'number' ? raw.requestId : undefined, truncated: raw.truncated === true, pendingEscapeTailAnsi: - typeof raw.pendingEscapeTailAnsi === 'string' ? raw.pendingEscapeTailAnsi : undefined + typeof raw.pendingEscapeTailAnsi === 'string' ? raw.pendingEscapeTailAnsi : undefined, + alternateScreen: raw.alternateScreen === true ? true : undefined, + scrollbackAnsiLength: + typeof raw.scrollbackAnsiLength === 'number' ? raw.scrollbackAnsiLength : undefined } }