mirror of
https://github.com/stablyai/orca.git
synced 2026-11-16 02:47:34 +00:00
665 lines
26 KiB
TypeScript
665 lines
26 KiB
TypeScript
// Drive DOM keydown→capture→policy→transport→IPC for every terminal chord.
|
||
// Intercept main pty:write for exact bytes without OS-specific readline; assert action effects through panes/search/buffer.
|
||
// Skip platform-only chords where runtime policy would never emit them.
|
||
|
||
import { test, expect } from './helpers/orca-app'
|
||
import type { ElectronApplication, Page } from '@stablyai/playwright-test'
|
||
import { FLOATING_TERMINAL_WORKTREE_ID } from '../../src/shared/constants'
|
||
import {
|
||
execInTerminal,
|
||
sendToTerminal,
|
||
countVisibleTerminalPanes,
|
||
waitForActiveTerminalManager,
|
||
waitForTerminalOutput,
|
||
waitForPaneCount,
|
||
getTerminalContent,
|
||
waitForActivePanePtyId,
|
||
focusActiveTerminalInput
|
||
} from './helpers/terminal'
|
||
import { waitForSessionReady, waitForActiveWorktree, ensureTerminalVisible } from './helpers/store'
|
||
import {
|
||
clearTerminalPtyWriteLog as clearPtyWriteLog,
|
||
installTerminalPtyWriteSpy as installMainProcessPtyWriteSpy,
|
||
readTerminalPtyWrites as getPtyWrites
|
||
} from './helpers/terminal-pty-write-spy'
|
||
import {
|
||
armKittyKeyboardFromPty,
|
||
getKittyKeyboardFlags,
|
||
interruptAndExpectEtx
|
||
} from './helpers/terminal-kitty-keyboard'
|
||
|
||
async function setActivePaneForegroundAgent(
|
||
page: Page,
|
||
agent: 'droid' | 'antigravity' | null
|
||
): Promise<string> {
|
||
return page.evaluate((agent) => {
|
||
const state = window.__store?.getState()
|
||
const worktreeId = state?.activeWorktreeId
|
||
const tabId =
|
||
state?.activeTabType === 'terminal'
|
||
? state.activeTabId
|
||
: worktreeId
|
||
? (state?.activeTabIdByWorktree?.[worktreeId] ?? null)
|
||
: null
|
||
const manager = tabId ? window.__paneManagers?.get(tabId) : null
|
||
const pane = manager?.getActivePane?.() ?? manager?.getPanes?.()[0] ?? null
|
||
if (!state || !tabId || !pane) {
|
||
throw new Error('No active terminal pane for foreground-agent setup')
|
||
}
|
||
const paneKey = `${tabId}:${pane.leafId}`
|
||
state.setPaneForegroundAgent(paneKey, {
|
||
agent,
|
||
shellForeground: false,
|
||
// The shortcut only emits CSI-u for a process identity confirmed to
|
||
// belong to this PTY; keep the fixture aligned with that trust gate.
|
||
routingTrusted: agent === 'droid'
|
||
})
|
||
return paneKey
|
||
}, agent)
|
||
}
|
||
|
||
async function focusFloatingTerminal(page: Page): Promise<void> {
|
||
await page
|
||
.locator(
|
||
`[data-floating-terminal-panel][aria-hidden="false"] [data-terminal-tab-id] .xterm-helper-textarea`
|
||
)
|
||
.first()
|
||
.focus()
|
||
}
|
||
|
||
async function seedFloatingTerminalTabSwitchScenario(page: Page): Promise<{
|
||
backgroundFirstTabId: string
|
||
floatingFirstTabId: string
|
||
floatingSecondTabId: string
|
||
}> {
|
||
return page.evaluate((floatingWorktreeId) => {
|
||
const store = window.__store
|
||
if (!store) {
|
||
throw new Error('Store unavailable')
|
||
}
|
||
const state = store.getState()
|
||
const backgroundWorktreeId = state.activeWorktreeId
|
||
if (!backgroundWorktreeId) {
|
||
throw new Error('No active background worktree')
|
||
}
|
||
|
||
const backgroundFirst =
|
||
state.tabsByWorktree[backgroundWorktreeId]?.find(
|
||
(tab) => tab.id === state.activeTabIdByWorktree[backgroundWorktreeId]
|
||
) ??
|
||
state.tabsByWorktree[backgroundWorktreeId]?.find((tab) => tab.id === state.activeTabId) ??
|
||
state.createTab(backgroundWorktreeId)
|
||
state.createTab(backgroundWorktreeId)
|
||
state.setActiveTab(backgroundFirst.id)
|
||
state.setActiveTabType('terminal', window.__store?.getState().activeWorktreeId ?? null)
|
||
|
||
const floatingFirst = state.createTab(floatingWorktreeId, undefined, undefined, {
|
||
activate: false
|
||
})
|
||
state.activateTab(floatingFirst.id)
|
||
const floatingGroupId =
|
||
state.activeGroupIdByWorktree[floatingWorktreeId] ??
|
||
state.groupsByWorktree[floatingWorktreeId]?.[0]?.id
|
||
const floatingSecond = state.createTab(floatingWorktreeId, floatingGroupId, undefined, {
|
||
activate: false
|
||
})
|
||
state.activateTab(floatingFirst.id)
|
||
|
||
return {
|
||
backgroundFirstTabId: backgroundFirst.id,
|
||
floatingFirstTabId: floatingFirst.id,
|
||
floatingSecondTabId: floatingSecond.id
|
||
}
|
||
}, FLOATING_TERMINAL_WORKTREE_ID)
|
||
}
|
||
|
||
async function getActiveFloatingTerminalTabId(page: Page): Promise<string | null> {
|
||
return page.evaluate((floatingWorktreeId) => {
|
||
const state = window.__store?.getState()
|
||
if (!state) {
|
||
return null
|
||
}
|
||
const groupId = state.activeGroupIdByWorktree[floatingWorktreeId]
|
||
const group =
|
||
(groupId
|
||
? state.groupsByWorktree[floatingWorktreeId]?.find((candidate) => candidate.id === groupId)
|
||
: null) ??
|
||
state.groupsByWorktree[floatingWorktreeId]?.find((candidate) => candidate.activeTabId) ??
|
||
null
|
||
const activeTab = group?.activeTabId
|
||
? state.unifiedTabsByWorktree[floatingWorktreeId]?.find((tab) => tab.id === group.activeTabId)
|
||
: null
|
||
return activeTab?.contentType === 'terminal' ? activeTab.entityId : null
|
||
}, FLOATING_TERMINAL_WORKTREE_ID)
|
||
}
|
||
|
||
async function getActiveBackgroundTerminalTabId(page: Page): Promise<string | null> {
|
||
return page.evaluate(() => {
|
||
const state = window.__store?.getState()
|
||
const worktreeId = state?.activeWorktreeId
|
||
return worktreeId ? (state.activeTabIdByWorktree[worktreeId] ?? state.activeTabId) : null
|
||
})
|
||
}
|
||
|
||
async function getActiveTerminalViewport(
|
||
page: Page
|
||
): Promise<{ viewportY: number; baseY: number }> {
|
||
return page.evaluate(() => {
|
||
const state = window.__store?.getState()
|
||
const worktreeId = state?.activeWorktreeId
|
||
const tabId =
|
||
state?.activeTabType === 'terminal'
|
||
? state.activeTabId
|
||
: worktreeId
|
||
? (state?.activeTabIdByWorktree?.[worktreeId] ?? null)
|
||
: null
|
||
const manager = tabId ? window.__paneManagers?.get(tabId) : null
|
||
const pane = manager?.getActivePane?.() ?? manager?.getPanes?.()[0] ?? null
|
||
const buffer = pane?.terminal.buffer.active
|
||
if (!buffer) {
|
||
throw new Error('No active terminal buffer')
|
||
}
|
||
return {
|
||
viewportY: buffer.viewportY,
|
||
baseY: buffer.baseY
|
||
}
|
||
})
|
||
}
|
||
|
||
async function pressAndExpectWrite(
|
||
page: Page,
|
||
app: ElectronApplication,
|
||
chord: string,
|
||
expectedData: string,
|
||
repetitions = 1
|
||
): Promise<void> {
|
||
await clearPtyWriteLog(app)
|
||
await focusActiveTerminalInput(page)
|
||
for (let index = 0; index < repetitions; index++) {
|
||
await page.keyboard.press(chord)
|
||
}
|
||
|
||
// Match exact bytes: single control codes can occur inside unrelated prompt/paste writes.
|
||
await expect
|
||
.poll(async () => (await getPtyWrites(app)).filter((write) => write === expectedData).length, {
|
||
timeout: 5_000,
|
||
message: `Expected chord "${chord}" to write ${JSON.stringify(expectedData)}`
|
||
})
|
||
.toBeGreaterThanOrEqual(repetitions)
|
||
}
|
||
|
||
const isMac = process.platform === 'darwin'
|
||
const mod = isMac ? 'Meta' : 'Control'
|
||
|
||
// Mac splits use Cmd+D/Cmd+Shift+D; Linux/Windows reserve Ctrl+D for EOF (#586) and use Ctrl+Shift+D/Alt+Shift+D.
|
||
const splitVerticalChord = isMac ? `${mod}+d` : `${mod}+Shift+d`
|
||
const splitHorizontalChord = isMac ? `${mod}+Shift+d` : 'Alt+Shift+d'
|
||
|
||
// Poll confirmation/count because fresh split may transiently report a running child.
|
||
async function closeActivePaneAndSettle(page: Page, expectedCount: number): Promise<void> {
|
||
// Focus PaneManager’s active textarea, not the first of multiple split panes.
|
||
await focusActiveTerminalInput(page)
|
||
await page.keyboard.press(`${mod}+w`)
|
||
// The "Stop running command?" confirm surfaces a "Stop and Close" action when
|
||
// the pane still reports a running child.
|
||
const confirmButton = page.getByRole('button', { name: /Stop and Close/i })
|
||
await expect
|
||
.poll(
|
||
async () => {
|
||
if (await confirmButton.isVisible().catch(() => false)) {
|
||
// Surface click errors directly instead of hiding actionability/strictness failure behind a count timeout.
|
||
await confirmButton.click().catch((err) => {
|
||
console.warn('closeActivePaneAndSettle: confirm click failed', err)
|
||
})
|
||
}
|
||
return countVisibleTerminalPanes(page)
|
||
},
|
||
{
|
||
timeout: 10_000,
|
||
message: `Expected ${expectedCount} visible terminal panes after close`
|
||
}
|
||
)
|
||
.toBe(expectedCount)
|
||
}
|
||
|
||
// Serialize shared layout/buffer/expand state and the singleton main pty:write spy to prevent interleaved chord effects.
|
||
test.describe.configure({ mode: 'serial' })
|
||
test.describe('Terminal Shortcuts', () => {
|
||
test.beforeEach(async ({ orcaPage }) => {
|
||
await waitForSessionReady(orcaPage)
|
||
await waitForActiveWorktree(orcaPage)
|
||
await ensureTerminalVisible(orcaPage)
|
||
const hasPaneManager = await waitForActiveTerminalManager(orcaPage, 30_000)
|
||
.then(() => true)
|
||
.catch(() => false)
|
||
test.skip(
|
||
!hasPaneManager,
|
||
'Electron automation in this environment never mounts the live TerminalPane manager.'
|
||
)
|
||
await waitForPaneCount(orcaPage, 1, 30_000)
|
||
})
|
||
|
||
test('Shift+Enter follows the pane Kitty keyboard state', async ({ orcaPage, electronApp }) => {
|
||
await installMainProcessPtyWriteSpy(electronApp)
|
||
const ptyId = await waitForActivePanePtyId(orcaPage)
|
||
|
||
await pressAndExpectWrite(orcaPage, electronApp, 'Shift+Enter', '\x1b\r')
|
||
if (process.platform === 'win32') {
|
||
return
|
||
}
|
||
|
||
// Drive the production PTY-output mirror that shortcut policy reads, not renderer-local flags.
|
||
// Disarm before exit because host grounding clears flags left armed.
|
||
await execInTerminal(orcaPage, ptyId, "printf '\\033[>1u'; read -r _; printf '\\033[<u'")
|
||
await expect.poll(() => getKittyKeyboardFlags(orcaPage)).toBe(1)
|
||
await pressAndExpectWrite(orcaPage, electronApp, 'Shift+Enter', '\x1b[13;2u')
|
||
|
||
await sendToTerminal(orcaPage, ptyId, '\r')
|
||
await expect.poll(() => getKittyKeyboardFlags(orcaPage)).toBe(0)
|
||
await pressAndExpectWrite(orcaPage, electronApp, 'Shift+Enter', '\x1b\r')
|
||
})
|
||
|
||
test('Droid gets CSI-u Shift+Enter on Windows without changing Antigravity', async ({
|
||
orcaPage,
|
||
electronApp
|
||
}) => {
|
||
test.skip(process.platform !== 'win32', 'Windows ConPTY encoding contract')
|
||
await installMainProcessPtyWriteSpy(electronApp)
|
||
await waitForActivePanePtyId(orcaPage)
|
||
const paneKey = await setActivePaneForegroundAgent(orcaPage, 'droid')
|
||
try {
|
||
await pressAndExpectWrite(orcaPage, electronApp, 'Shift+Enter', '\x1b[13;2u', 2)
|
||
await setActivePaneForegroundAgent(orcaPage, 'antigravity')
|
||
await pressAndExpectWrite(orcaPage, electronApp, 'Shift+Enter', '\x1b\r')
|
||
} finally {
|
||
await orcaPage.evaluate(
|
||
(key) => window.__store?.getState().clearPaneForegroundAgent(key),
|
||
paneKey
|
||
)
|
||
}
|
||
})
|
||
|
||
test('Windows forwards genuine Ctrl+Alt text chords to the PTY', async ({
|
||
orcaPage,
|
||
electronApp
|
||
}) => {
|
||
test.skip(process.platform !== 'win32', 'Windows xterm AltGr classification regression')
|
||
await installMainProcessPtyWriteSpy(electronApp)
|
||
await waitForActivePanePtyId(orcaPage)
|
||
|
||
await pressAndExpectWrite(orcaPage, electronApp, 'Control+Alt+u', '\x1b\x15')
|
||
await pressAndExpectWrite(orcaPage, electronApp, 'Control+Alt+2', '\x1b2')
|
||
await pressAndExpectWrite(orcaPage, electronApp, 'Control+Alt+;', '\x1b;')
|
||
})
|
||
|
||
test('Ctrl+Enter protects local ConPTY shells without breaking trusted TUI chords', async ({
|
||
orcaPage,
|
||
electronApp
|
||
}) => {
|
||
await installMainProcessPtyWriteSpy(electronApp)
|
||
await waitForActivePanePtyId(orcaPage)
|
||
|
||
if (process.platform === 'win32') {
|
||
await pressAndExpectWrite(orcaPage, electronApp, 'Control+Enter', '\r')
|
||
const paneKey = await setActivePaneForegroundAgent(orcaPage, 'droid')
|
||
try {
|
||
// Droid queries CSI-u without activating live flags; trusted process evidence preserves cue/queue.
|
||
await pressAndExpectWrite(orcaPage, electronApp, 'Control+Enter', '\x1b[13;5u')
|
||
} finally {
|
||
await orcaPage.evaluate(
|
||
(key) => window.__store?.getState().clearPaneForegroundAgent(key),
|
||
paneKey
|
||
)
|
||
}
|
||
return
|
||
}
|
||
|
||
// Preserve the established query-only Droid/Grok contract outside local ConPTY.
|
||
await pressAndExpectWrite(orcaPage, electronApp, 'Control+Enter', '\x1b[13;5u')
|
||
})
|
||
|
||
test('plain Ctrl+C sends ETX and leaves a surviving app its kitty flags', async ({
|
||
orcaPage,
|
||
electronApp
|
||
}) => {
|
||
test.skip(process.platform === 'win32', 'POSIX trap and printf fixture')
|
||
await installMainProcessPtyWriteSpy(electronApp)
|
||
const ptyId = await waitForActivePanePtyId(orcaPage)
|
||
// SIGINT during shell startup kills the shell, so interrupt only a ready prompt.
|
||
await execInTerminal(orcaPage, ptyId, 'echo "CTRL_C_""READY"')
|
||
await waitForTerminalOutput(orcaPage, 'CTRL_C_READY')
|
||
// An app that survives SIGINT, like an agent TUI, and disarms its own flags on exit.
|
||
await armKittyKeyboardFromPty(
|
||
orcaPage,
|
||
ptyId,
|
||
`bash -c 'trap "" INT; printf "\\033[=31u"; read -r _; printf "\\033[=0u"'`
|
||
)
|
||
|
||
await interruptAndExpectEtx(orcaPage, electronApp)
|
||
|
||
// Require xterm and policy mirror to retain encoding after unproven app death (Shift+Enter stays CSI-u).
|
||
expect(await getKittyKeyboardFlags(orcaPage)).toBe(31)
|
||
await pressAndExpectWrite(orcaPage, electronApp, 'Shift+Enter', '\x1b[13;2u')
|
||
|
||
await sendToTerminal(orcaPage, ptyId, '\r')
|
||
await expect.poll(async () => await getKittyKeyboardFlags(orcaPage)).toBe(0)
|
||
await pressAndExpectWrite(orcaPage, electronApp, 'Shift+Enter', '\x1b\r')
|
||
})
|
||
|
||
test('the host grounds kitty flags an app killed by Ctrl+C left armed', async ({
|
||
orcaPage,
|
||
electronApp
|
||
}) => {
|
||
test.skip(process.platform === 'win32', 'POSIX printf fixture')
|
||
await installMainProcessPtyWriteSpy(electronApp)
|
||
const ptyId = await waitForActivePanePtyId(orcaPage)
|
||
await execInTerminal(orcaPage, ptyId, 'echo "CTRL_C_""READY"')
|
||
await waitForTerminalOutput(orcaPage, 'CTRL_C_READY')
|
||
// `cat` dies on SIGINT with the flags still armed, like a crashed TUI.
|
||
await armKittyKeyboardFromPty(orcaPage, ptyId, `printf '\\033[=31u'; cat`)
|
||
|
||
await interruptAndExpectEtx(orcaPage, electronApp)
|
||
|
||
await expect
|
||
.poll(async () => await getKittyKeyboardFlags(orcaPage), {
|
||
timeout: 5_000,
|
||
message: 'the host did not ground the dead app kitty flags at command end'
|
||
})
|
||
.toBe(0)
|
||
await clearPtyWriteLog(electronApp)
|
||
await focusActiveTerminalInput(orcaPage)
|
||
await orcaPage.keyboard.type('x')
|
||
await expect
|
||
.poll(async () => (await getPtyWrites(electronApp)).some((write) => write === 'x'), {
|
||
timeout: 5_000,
|
||
message: 'Post-interrupt keyboard input stayed in Kitty CSI-u mode'
|
||
})
|
||
.toBe(true)
|
||
expect((await getPtyWrites(electronApp)).join('')).not.toContain('\x1b[')
|
||
await orcaPage.keyboard.press('Backspace')
|
||
})
|
||
|
||
test('unselected Cmd+C reaches a Kitty app, including after Ctrl+C', async ({
|
||
orcaPage,
|
||
electronApp
|
||
}) => {
|
||
test.skip(process.platform !== 'darwin', 'macOS copy binding')
|
||
await installMainProcessPtyWriteSpy(electronApp)
|
||
const ptyId = await waitForActivePanePtyId(orcaPage)
|
||
await execInTerminal(orcaPage, ptyId, 'echo "CMD_C_""READY"')
|
||
await waitForTerminalOutput(orcaPage, 'CMD_C_READY')
|
||
const select = (text: string | null): Promise<string> =>
|
||
orcaPage.evaluate(async (selectedText) => {
|
||
const state = window.__store!.getState()
|
||
const pane = window.__paneManagers!.get(state.activeTabId!)!.getActivePane()!
|
||
if (selectedText === null) {
|
||
pane.terminal.clearSelection()
|
||
return ''
|
||
}
|
||
await new Promise<void>((resolve) =>
|
||
pane.terminal.write(`\r\n${selectedText}\r\n`, resolve)
|
||
)
|
||
const buffer = pane.terminal.buffer.active
|
||
pane.terminal.select(0, buffer.baseY + buffer.cursorY - 1, selectedText.length)
|
||
return pane.terminal.getSelection()
|
||
}, text)
|
||
// Presses Cmd+C, then a marker chord whose write proves the Cmd+C bytes had their turn.
|
||
const pressCmdC = async (marker: string, markerWrite: string): Promise<string[]> => {
|
||
await clearPtyWriteLog(electronApp)
|
||
await focusActiveTerminalInput(orcaPage)
|
||
await orcaPage.keyboard.press('Meta+c')
|
||
await orcaPage.keyboard.press(marker)
|
||
await expect.poll(async () => await getPtyWrites(electronApp)).toContain(markerWrite)
|
||
const writes = await getPtyWrites(electronApp)
|
||
return writes.slice(0, writes.indexOf(markerWrite))
|
||
}
|
||
const kittyCmdC = ['\x1b[99;9;99u', '\x1b[99;9:3u']
|
||
const originalClipboard = await electronApp.evaluate(({ clipboard }) => clipboard.readText())
|
||
try {
|
||
await select(null)
|
||
expect(await pressCmdC('x', 'x')).toEqual([])
|
||
await orcaPage.keyboard.press('Backspace')
|
||
|
||
// An app that survives SIGINT, like an agent TUI, and disarms its own flags on exit.
|
||
await armKittyKeyboardFromPty(
|
||
orcaPage,
|
||
ptyId,
|
||
`bash -c 'trap "" INT; printf "\\033[=31u"; read -r _; printf "\\033[=0u"'`
|
||
)
|
||
await select(null)
|
||
expect(await pressCmdC('Shift+Enter', '\x1b[13;2u')).toEqual(kittyCmdC)
|
||
|
||
const selectedText = await select('Terminal copy selection')
|
||
expect(selectedText).toBe('Terminal copy selection')
|
||
await electronApp.evaluate(({ clipboard }) => clipboard.writeText(''))
|
||
expect(await pressCmdC('Shift+Enter', '\x1b[13;2u')).toEqual([])
|
||
await expect
|
||
.poll(() => electronApp.evaluate(({ clipboard }) => clipboard.readText()))
|
||
.toBe(selectedText)
|
||
|
||
await interruptAndExpectEtx(orcaPage, electronApp)
|
||
expect(await getKittyKeyboardFlags(orcaPage)).toBe(31)
|
||
await select(null)
|
||
expect(await pressCmdC('Shift+Enter', '\x1b[13;2u')).toEqual(kittyCmdC)
|
||
|
||
await sendToTerminal(orcaPage, ptyId, '\r')
|
||
await expect.poll(async () => await getKittyKeyboardFlags(orcaPage)).toBe(0)
|
||
expect(await pressCmdC('x', 'x')).toEqual([])
|
||
await orcaPage.keyboard.press('Backspace')
|
||
} finally {
|
||
await electronApp.evaluate(
|
||
({ clipboard }, text) => clipboard.writeText(text),
|
||
originalClipboard
|
||
)
|
||
}
|
||
})
|
||
|
||
test('floating terminal owns tab switch shortcuts while focused', async ({ orcaPage }) => {
|
||
const scenario = await seedFloatingTerminalTabSwitchScenario(orcaPage)
|
||
await orcaPage.evaluate(async () => {
|
||
const state = window.__store?.getState()
|
||
if (state?.settings?.floatingTerminalEnabled !== true) {
|
||
await state?.updateSettings({ floatingTerminalEnabled: true })
|
||
}
|
||
if (!document.querySelector('[data-floating-terminal-panel][aria-hidden="false"]')) {
|
||
window.dispatchEvent(new CustomEvent('orca-toggle-floating-terminal'))
|
||
}
|
||
})
|
||
await expect(
|
||
orcaPage.locator('[data-floating-terminal-panel][aria-hidden="false"]')
|
||
).toBeVisible()
|
||
await focusFloatingTerminal(orcaPage)
|
||
|
||
await orcaPage.keyboard.press(`${mod}+Shift+BracketRight`)
|
||
await expect
|
||
.poll(() => getActiveFloatingTerminalTabId(orcaPage), {
|
||
timeout: 5_000,
|
||
message: 'floating terminal did not switch to the next tab'
|
||
})
|
||
.toBe(scenario.floatingSecondTabId)
|
||
await expect
|
||
.poll(() => getActiveBackgroundTerminalTabId(orcaPage), {
|
||
timeout: 1_000,
|
||
message: 'background terminal tab changed while floating terminal was focused'
|
||
})
|
||
.toBe(scenario.backgroundFirstTabId)
|
||
|
||
await focusFloatingTerminal(orcaPage)
|
||
await orcaPage.keyboard.press(`${mod}+Shift+BracketLeft`)
|
||
await expect
|
||
.poll(() => getActiveFloatingTerminalTabId(orcaPage), {
|
||
timeout: 5_000,
|
||
message: 'floating terminal did not switch back to the previous tab'
|
||
})
|
||
.toBe(scenario.floatingFirstTabId)
|
||
await expect(getActiveBackgroundTerminalTabId(orcaPage)).resolves.toBe(
|
||
scenario.backgroundFirstTabId
|
||
)
|
||
})
|
||
|
||
test('all terminal chords reach the PTY or fire their action', async ({
|
||
orcaPage,
|
||
electronApp
|
||
}) => {
|
||
await installMainProcessPtyWriteSpy(electronApp)
|
||
|
||
const ptyId = await waitForActivePanePtyId(orcaPage)
|
||
const marker = `SHORTCUT_TEST_${Date.now()}`
|
||
await execInTerminal(orcaPage, ptyId, `echo ${marker}`)
|
||
await waitForTerminalOutput(orcaPage, marker)
|
||
|
||
// Alt+←/→ → readline backward-word / forward-word (\eb / \ef).
|
||
await pressAndExpectWrite(orcaPage, electronApp, 'Alt+ArrowLeft', '\x1bb')
|
||
await pressAndExpectWrite(orcaPage, electronApp, 'Alt+ArrowRight', '\x1bf')
|
||
|
||
// Ctrl+←/→ on non-mac → readline backward-word / forward-word (\eb / \ef).
|
||
// macOS reserves Ctrl+Arrow; Windows ConPTY leaves it to PSReadLine.
|
||
if (!isMac && process.platform !== 'win32') {
|
||
await pressAndExpectWrite(orcaPage, electronApp, 'Control+ArrowLeft', '\x1bb')
|
||
await pressAndExpectWrite(orcaPage, electronApp, 'Control+ArrowRight', '\x1bf')
|
||
}
|
||
|
||
// Alt+Backspace → Esc+DEL (readline backward-kill-word).
|
||
await pressAndExpectWrite(orcaPage, electronApp, 'Alt+Backspace', '\x1b\x7f')
|
||
|
||
// Ctrl+Backspace → \x17 (unix-word-rubout).
|
||
await pressAndExpectWrite(orcaPage, electronApp, 'Control+Backspace', '\x17')
|
||
|
||
// The shell has not enabled KKP, so Shift+Enter must not leak CSI-u text.
|
||
await pressAndExpectWrite(orcaPage, electronApp, 'Shift+Enter', '\x1b\r')
|
||
|
||
if (isMac) {
|
||
// Cmd+←/→ → Ctrl+A / Ctrl+E (beginning/end of line).
|
||
await pressAndExpectWrite(orcaPage, electronApp, 'Meta+ArrowLeft', '\x01')
|
||
await pressAndExpectWrite(orcaPage, electronApp, 'Meta+ArrowRight', '\x05')
|
||
|
||
// Cmd+Backspace → Ctrl+U (kill line). Cmd+Delete → Ctrl+K (kill to EOL).
|
||
await pressAndExpectWrite(orcaPage, electronApp, 'Meta+Backspace', '\x15')
|
||
await pressAndExpectWrite(orcaPage, electronApp, 'Meta+Delete', '\x0b')
|
||
}
|
||
|
||
await orcaPage.evaluate(async () => {
|
||
await window.__store!.getState().setKeybindingOverride('terminal.clear', ['Mod+Shift+K'])
|
||
})
|
||
await focusActiveTerminalInput(orcaPage)
|
||
await orcaPage.keyboard.press(`${mod}+Shift+k`)
|
||
await expect
|
||
.poll(async () => (await getTerminalContent(orcaPage)).includes(marker), {
|
||
timeout: 5_000,
|
||
message: 'The configured clear shortcut did not clear the terminal buffer'
|
||
})
|
||
.toBe(false)
|
||
await orcaPage.evaluate(async () => {
|
||
await window.__store!.getState().resetKeybindingOverride('terminal.clear')
|
||
})
|
||
|
||
const panesBeforeSplit = await countVisibleTerminalPanes(orcaPage)
|
||
await focusActiveTerminalInput(orcaPage)
|
||
await orcaPage.keyboard.press(splitVerticalChord)
|
||
await waitForPaneCount(orcaPage, panesBeforeSplit + 1)
|
||
// Require the split PTY binding before close to avoid racing unfinished creation.
|
||
await waitForActivePanePtyId(orcaPage)
|
||
|
||
await focusActiveTerminalInput(orcaPage)
|
||
await orcaPage.keyboard.press(`${mod}+BracketRight`)
|
||
await focusActiveTerminalInput(orcaPage)
|
||
await orcaPage.keyboard.press(`${mod}+BracketLeft`)
|
||
expect(await countVisibleTerminalPanes(orcaPage)).toBe(panesBeforeSplit + 1)
|
||
|
||
// Test expand while split remains open because it requires >1 pane.
|
||
const readExpanded = async (): Promise<boolean> =>
|
||
orcaPage.evaluate(() => {
|
||
const state = window.__store?.getState()
|
||
const tabId = state?.activeTabId
|
||
if (!state || !tabId) {
|
||
return false
|
||
}
|
||
return state.expandedPaneByTabId[tabId] === true
|
||
})
|
||
expect(await readExpanded()).toBe(false)
|
||
await focusActiveTerminalInput(orcaPage)
|
||
await orcaPage.keyboard.press(`${mod}+Shift+Enter`)
|
||
await expect
|
||
.poll(readExpanded, { timeout: 3_000, message: 'Cmd+Shift+Enter did not expand pane' })
|
||
.toBe(true)
|
||
await focusActiveTerminalInput(orcaPage)
|
||
await orcaPage.keyboard.press(`${mod}+Shift+Enter`)
|
||
await expect
|
||
.poll(readExpanded, { timeout: 3_000, message: 'Cmd+Shift+Enter did not collapse pane' })
|
||
.toBe(false)
|
||
|
||
await closeActivePaneAndSettle(orcaPage, panesBeforeSplit)
|
||
|
||
const panesBeforeHSplit = await countVisibleTerminalPanes(orcaPage)
|
||
await focusActiveTerminalInput(orcaPage)
|
||
await orcaPage.keyboard.press(splitHorizontalChord)
|
||
await waitForPaneCount(orcaPage, panesBeforeHSplit + 1)
|
||
await waitForActivePanePtyId(orcaPage)
|
||
await closeActivePaneAndSettle(orcaPage, panesBeforeHSplit)
|
||
|
||
await focusActiveTerminalInput(orcaPage)
|
||
await orcaPage.keyboard.press(`${mod}+f`)
|
||
const searchInput = orcaPage.locator('[data-terminal-search-root] input').first()
|
||
// Wait for search-input focus: React’s Escape handler otherwise loses an early key to xterm.
|
||
await expect(searchInput).toBeFocused({ timeout: 3_000 })
|
||
await orcaPage.keyboard.press('Escape')
|
||
await expect(orcaPage.locator('[data-terminal-search-root]').first()).toBeHidden({
|
||
timeout: 3_000
|
||
})
|
||
})
|
||
|
||
test('Cmd+Up/Down scrolls terminal viewport without writing to the PTY on macOS', async ({
|
||
orcaPage,
|
||
electronApp
|
||
}) => {
|
||
test.skip(!isMac, 'Cmd+Up/Down terminal scroll navigation is macOS-only')
|
||
|
||
await installMainProcessPtyWriteSpy(electronApp)
|
||
|
||
const ptyId = await waitForActivePanePtyId(orcaPage)
|
||
const marker = `CMD_ARROW_SCROLL_${Date.now()}`
|
||
await execInTerminal(orcaPage, ptyId, `for i in {1..120}; do echo ${marker}_$i; done`)
|
||
await waitForTerminalOutput(orcaPage, `${marker}_120`)
|
||
|
||
await expect
|
||
.poll(
|
||
async () => {
|
||
const viewport = await getActiveTerminalViewport(orcaPage)
|
||
return viewport.baseY > 0 && viewport.viewportY === viewport.baseY
|
||
},
|
||
{
|
||
timeout: 5_000,
|
||
message: 'terminal did not settle at the bottom with scrollback for Cmd+Up/Down repro'
|
||
}
|
||
)
|
||
.toBe(true)
|
||
|
||
await clearPtyWriteLog(electronApp)
|
||
await focusActiveTerminalInput(orcaPage)
|
||
await orcaPage.keyboard.press('Meta+ArrowUp')
|
||
await expect
|
||
.poll(async () => getActiveTerminalViewport(orcaPage), {
|
||
timeout: 5_000,
|
||
message: 'Cmd+Up did not scroll the terminal viewport to the top'
|
||
})
|
||
.toMatchObject({ viewportY: 0 })
|
||
expect(await getPtyWrites(electronApp)).toEqual([])
|
||
|
||
await focusActiveTerminalInput(orcaPage)
|
||
await orcaPage.keyboard.press('Meta+ArrowDown')
|
||
await expect
|
||
.poll(
|
||
async () => {
|
||
const viewport = await getActiveTerminalViewport(orcaPage)
|
||
return viewport.viewportY === viewport.baseY
|
||
},
|
||
{
|
||
timeout: 5_000,
|
||
message: 'Cmd+Down did not scroll the terminal viewport to the bottom'
|
||
}
|
||
)
|
||
.toBe(true)
|
||
expect(await getPtyWrites(electronApp)).toEqual([])
|
||
})
|
||
})
|