test: remove low-value ACP, CLI and simulated scroll suites

This commit is contained in:
OrcaWin
2026-11-08 19:52:10 -08:00
parent d714d577bf
commit ea06d92be2
46 changed files with 19 additions and 9169 deletions
@@ -1,132 +0,0 @@
import { afterEach, describe, expect, it, vi } from 'vitest'
import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
import { tmpdir } from 'node:os'
import path from 'node:path'
import process from 'node:process'
import {
collectElectronImporters,
collectStructuredChatEntryPoints,
main
} from './check-runtime-electron-ratchet.mjs'
describe('structured chat coverage', () => {
const roots = []
afterEach(() => {
for (const root of roots.splice(0)) {
rmSync(root, { recursive: true, force: true })
}
})
function fixture(files) {
const root = mkdtempSync(path.join(tmpdir(), 'orca-electron-ratchet-'))
roots.push(root)
for (const [file, source] of Object.entries(files)) {
const absolute = path.join(root, file)
mkdirSync(path.dirname(absolute), { recursive: true })
writeFileSync(absolute, source)
}
return root
}
const requiredLanes = {
'src/main/native-chat/reader.ts': 'export {}',
'src/main/claude/claude-session.ts': 'export {}',
'src/main/codex/codex-session.ts': 'export {}',
'src/main/runtime/structured-agent-session-host.ts': 'export {}',
'src/main/provider-process/provider-process-teardown.ts': 'export {}',
'src/main/acp/session/acp-structured-session-adapter.ts': 'export {}',
'src/main/jsonl-rpc/peer.ts': 'export {}',
'src/main/pi/rpc-launch.ts': 'export {}',
'src/shared/agent-session-record.ts': 'export {}',
'src/packages/process-host/src/run-process.ts': 'export {}'
}
it.each([true, false])(
'finds Electron through an unwired lane package (sideEffects=%s)',
async (sideEffects) => {
const root = fixture({
...requiredLanes,
'src/main/acp/adapter.ts': "import 'acp-desktop-package'",
'src/main/provider-process/worker.ts': "import 'provider-desktop-package'",
'src/main/jsonl-rpc/peer.ts': "import 'rpc-desktop-package'",
'src/main/pi/rpc-launch.ts': "import 'pi-desktop-package'",
'node_modules/acp-desktop-package/package.json': JSON.stringify({
main: 'index.js',
sideEffects
}),
'node_modules/acp-desktop-package/index.js': "require('electron')",
'node_modules/provider-desktop-package/package.json': JSON.stringify({
main: 'index.js',
sideEffects
}),
'node_modules/provider-desktop-package/index.js': "require('electron')",
'node_modules/rpc-desktop-package/package.json': JSON.stringify({
main: 'index.js',
sideEffects
}),
'node_modules/rpc-desktop-package/index.js': "require('electron')",
'node_modules/pi-desktop-package/package.json': JSON.stringify({
main: 'index.js',
sideEffects
}),
'node_modules/pi-desktop-package/index.js': "require('electron')"
})
const current = await collectElectronImporters(collectStructuredChatEntryPoints(root))
expect(current.map((file) => file.split('/node_modules/').pop())).toEqual([
'acp-desktop-package/index.js',
'pi-desktop-package/index.js',
'provider-desktop-package/index.js',
'rpc-desktop-package/index.js'
])
}
)
it('checks public workspace imports against source without requiring a built package', async () => {
const root = fixture({ 'entry.ts': "import '@orca/process-host'" })
const target = path.join(process.cwd(), 'src/packages/process-host/src/run-process.ts')
const current = await collectElectronImporters([path.join(root, 'entry.ts')], {
plugins: [
{
name: 'inject-process-host-electron-import',
setup(pluginBuild) {
pluginBuild.onLoad({ filter: /run-process\.ts$/ }, (args) =>
args.path === target ? { contents: "import 'electron'", loader: 'ts' } : undefined
)
}
}
]
})
expect(current).toEqual(['src/packages/process-host/src/run-process.ts'])
})
})
// Why `main`: it is what `pnpm lint` and CI run, so these fail if its entry list drops the lanes.
describe('the command-line check', () => {
afterEach(() => {
vi.restoreAllMocks()
})
// Why a file the runtime doesn't load: only the structured-chat lanes can catch it.
it('fails on Electron in structured-chat code the runtime graph does not reach', async () => {
const target = path.join(
process.cwd(),
'src',
'main',
'native-chat',
'transcript-read-cache.ts'
)
const addElectron = {
name: 'add-electron-import',
setup(pluginBuild) {
pluginBuild.onLoad({ filter: /transcript-read-cache\.ts$/ }, (args) =>
args.path === target
? { contents: `import 'electron'\n${readFileSync(target, 'utf8')}`, loader: 'ts' }
: undefined
)
}
}
const error = vi.spyOn(console, 'error').mockImplementation(() => {})
expect(await main({ plugins: [addElectron] })).toBe(1)
expect(error.mock.calls.join('\n')).toContain('+ src/main/native-chat/transcript-read-cache.ts')
}, 120_000)
})
@@ -61,7 +61,6 @@ const NODE_RUNTIME_INCLUDE = [
'src/main/pi/rpc-turn-races.test.ts',
'src/main/acp/session/children/acp-structured-child-session-end.test.ts',
'src/main/acp/session/children/acp-structured-child-stop.test.ts',
'src/main/acp/journal/acp-structured-child-work-admission.test.ts',
'src/main/acp/session/children/acp-structured-child-work.test.ts',
'src/main/native-chat/agent-session-wire/host/testing/structured-agent-session-background-stop-unreadable.test.ts',
'src/main/native-chat/agent-session-wire/host/testing/structured-agent-session-exit-delivery.test.ts',
+1 -581
View File
@@ -47,14 +47,7 @@ vi.mock('../runtime-client', async () => {
})
import { main } from '../index'
import { RuntimeClientError } from '../runtime/types'
import {
buildWorktree,
noFolderWorkspacesFixture,
okFixture,
queueFixtures,
worktreeListFixture
} from '../test-fixtures'
import { okFixture, queueFixtures } from '../test-fixtures'
describe('orca cli browser page targeting', () => {
beforeEach(() => {
@@ -66,74 +59,6 @@ describe('orca cli browser page targeting', () => {
vi.unstubAllEnvs()
})
it('passes explicit page ids to snapshot without resolving the current worktree', async () => {
queueFixtures(
callMock,
okFixture('req_snapshot', {
browserPageId: 'page-1',
snapshot: 'tree',
refs: [],
url: 'https://example.com',
title: 'Example'
})
)
vi.spyOn(console, 'log').mockImplementation(() => {})
await main(['snapshot', '--page', 'page-1', '--json'], '/tmp/not-an-orca-worktree')
expect(callMock).toHaveBeenCalledTimes(1)
expect(callMock).toHaveBeenCalledWith('browser.snapshot', { page: 'page-1' })
})
it('sends snapshot flags to the host and prints delta changes against the last tree', async () => {
queueFixtures(
callMock,
okFixture('req_snapshot', {
browserPageId: 'page-1',
snapshot: {
kind: 'delta',
revision: 3,
baseRevision: 2,
treeChange: { startLine: 4, deleteCount: 2, lines: ['- button "Save" [ref=e9]'] }
},
url: 'https://example.com',
title: 'Example'
})
)
const log = vi.spyOn(console, 'log').mockImplementation(() => {})
await main(
[
'snapshot',
'--page',
'page-1',
'--interactive',
'--depth',
'3',
'--selector',
'form',
'--delta'
],
'/tmp/not-an-orca-worktree'
)
expect(callMock).toHaveBeenCalledWith('browser.snapshot', {
page: 'page-1',
interactive: true,
depth: 3,
selector: 'form',
delta: true
})
expect(log).toHaveBeenCalledWith(
[
'page: page-1',
'Example — https://example.com',
'revision 3: changes to revision 2; replace lines 5-6 with:',
'- button "Save" [ref=e9]'
].join('\n')
)
})
it('saves screenshots where the CLI runs and prints the path instead of base64', async () => {
const screenshotDir = mkdtempSync(join(tmpdir(), 'orca-browser-shot-'))
vi.stubEnv('ORCA_BROWSER_SCREENSHOT_TMPDIR', screenshotDir)
@@ -163,509 +88,4 @@ describe('orca cli browser page targeting', () => {
rmSync(screenshotDir, { recursive: true, force: true })
}
})
it('resolves current worktree only when --page is combined with --worktree current', async () => {
queueFixtures(
callMock,
worktreeListFixture([buildWorktree('/tmp/repo/feature', 'feature/foo')]),
noFolderWorkspacesFixture(),
okFixture('req_snapshot', {
browserPageId: 'page-1',
snapshot: 'tree',
refs: [],
url: 'https://example.com',
title: 'Example'
})
)
vi.spyOn(console, 'log').mockImplementation(() => {})
await main(
['snapshot', '--page', 'page-1', '--worktree', 'current', '--json'],
'/tmp/repo/feature/src'
)
expect(callMock).toHaveBeenNthCalledWith(1, 'worktree.list', { limit: 10_000 })
expect(callMock).toHaveBeenNthCalledWith(3, 'browser.snapshot', {
page: 'page-1',
worktree: 'id:repo::/tmp/repo/feature'
})
})
it('passes page-targeted tab switches through without auto-scoping to the current worktree', async () => {
queueFixtures(callMock, okFixture('req_switch', { switched: 2, browserPageId: 'page-2' }))
vi.spyOn(console, 'log').mockImplementation(() => {})
await main(['tab', 'switch', '--page', 'page-2', '--json'], '/tmp/repo/feature/src')
expect(callMock).toHaveBeenCalledTimes(1)
expect(callMock).toHaveBeenCalledWith('browser.tabSwitch', {
index: undefined,
page: 'page-2'
})
expect(callMock.mock.calls[0][1]).not.toHaveProperty('focus')
})
it('still resolves the current worktree when tab switch --page is combined with --worktree current', async () => {
queueFixtures(
callMock,
worktreeListFixture([buildWorktree('/tmp/repo/feature', 'feature/foo')]),
noFolderWorkspacesFixture(),
okFixture('req_switch', { switched: 2, browserPageId: 'page-2' })
)
vi.spyOn(console, 'log').mockImplementation(() => {})
await main(
['tab', 'switch', '--page', 'page-2', '--worktree', 'current', '--json'],
'/tmp/repo/feature/src'
)
expect(callMock).toHaveBeenNthCalledWith(1, 'worktree.list', { limit: 10_000 })
expect(callMock).toHaveBeenNthCalledWith(3, 'browser.tabSwitch', {
index: undefined,
page: 'page-2',
worktree: 'id:repo::/tmp/repo/feature'
})
})
it('asks for a split beside the calling terminal tab with --split', async () => {
vi.stubEnv('ORCA_TAB_ID', 'terminal-tab-1')
queueFixtures(callMock, okFixture('req_create', { browserPageId: 'page-4' }))
vi.spyOn(console, 'log').mockImplementation(() => {})
await main(
['tab', 'create', '--url', 'https://example.com', '--split', 'right', '--worktree', 'all'],
'/tmp/not-an-orca-worktree'
)
expect(callMock).toHaveBeenCalledWith(
'browser.tabCreate',
{
url: 'https://example.com',
worktree: undefined,
profileId: undefined,
split: 'right',
splitFromTabId: 'terminal-tab-1'
},
{ timeoutMs: 60_000 }
)
vi.unstubAllEnvs()
})
it('leaves the caller tab out of a plain tab create', async () => {
vi.stubEnv('ORCA_TAB_ID', 'terminal-tab-1')
queueFixtures(callMock, okFixture('req_create', { browserPageId: 'page-5' }))
vi.spyOn(console, 'log').mockImplementation(() => {})
await main(['tab', 'create', '--worktree', 'all'], '/tmp/not-an-orca-worktree')
expect(callMock.mock.calls[0][1]).not.toHaveProperty('split')
expect(callMock.mock.calls[0][1]).not.toHaveProperty('splitFromTabId')
vi.unstubAllEnvs()
})
it('rejects an unknown --split direction before calling the runtime', async () => {
const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
await main(['tab', 'create', '--split', 'sideways'], '/tmp/not-an-orca-worktree')
expect(callMock).not.toHaveBeenCalled()
expect(errorSpy).toHaveBeenCalledWith('--split must be right, left, down, or up')
})
it('rejects --split with no direction instead of opening a plain tab', async () => {
const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
await main(['tab', 'create', '--split='], '/tmp/not-an-orca-worktree')
expect(callMock).not.toHaveBeenCalled()
expect(errorSpy).toHaveBeenCalledWith('Missing value for --split')
})
it('opens browser-launch URLs on the client hosting the current worktree', async () => {
queueFixtures(
callMock,
worktreeListFixture([buildWorktree('/tmp/repo/feature', 'feature/foo')]),
noFolderWorkspacesFixture(),
okFixture('req_open_url', { browserPageId: 'page-local' })
)
vi.spyOn(console, 'log').mockImplementation(() => {})
await main(['open-url', '--url', 'https://example.com/login', '--json'], '/tmp/repo/feature')
expect(callMock).toHaveBeenNthCalledWith(
3,
'browser.openUrl',
{
url: 'https://example.com/login',
worktree: 'id:repo::/tmp/repo/feature'
},
{ timeoutMs: 60_000 }
)
})
it('creates a tab in the calling folder workspace, not the parent sharing its path (#33618)', async () => {
const parent = buildWorktree('/tmp/folder', '')
const workspace = { ...parent, id: `${parent.id}::workspace:ws-2` }
queueFixtures(
callMock,
worktreeListFixture([parent, workspace]),
noFolderWorkspacesFixture(),
okFixture('req_tab_create', { browserPageId: 'page-1' })
)
vi.spyOn(console, 'log').mockImplementation(() => {})
vi.stubEnv('ORCA_WORKTREE_ID', workspace.id)
await main(['tab', 'create', '--url', 'https://example.com', '--json'], '/tmp/folder')
expect(callMock).toHaveBeenNthCalledWith(
3,
'browser.tabCreate',
{ url: 'https://example.com', worktree: `id:${workspace.id}` },
{ timeoutMs: 60_000 }
)
})
it("creates a tab in the calling terminal's worktree when cwd is outside every worktree", async () => {
const caller = buildWorktree('/tmp/repo/caller', 'caller')
queueFixtures(
callMock,
worktreeListFixture([caller, buildWorktree('/tmp/repo/other', 'other')]),
okFixture('req_tab_create', { browserPageId: 'page-1' })
)
vi.spyOn(console, 'log').mockImplementation(() => {})
vi.stubEnv('ORCA_WORKTREE_ID', caller.id)
await main(['tab', 'create', '--url', 'https://example.com', '--json'], '/tmp/scratch')
expect(callMock).toHaveBeenLastCalledWith(
'browser.tabCreate',
{ url: 'https://example.com', worktree: `id:${caller.id}` },
{ timeoutMs: 60_000 }
)
})
it("names the calling terminal's host when its worktree id exists on two hosts", async () => {
const caller = { ...buildWorktree('/tmp/repo/caller', 'caller'), identity: { key: 'wt:local' } }
const sshTwin = { ...caller, hostId: 'ssh:host-a' as const, identity: { key: 'wt:ssh' } }
queueFixtures(
callMock,
worktreeListFixture([sshTwin, caller]),
okFixture('req_tab_create', { browserPageId: 'page-1' })
)
vi.spyOn(console, 'log').mockImplementation(() => {})
vi.stubEnv('ORCA_WORKTREE_ID', caller.id)
await main(['tab', 'create', '--url', 'https://example.com', '--json'], '/tmp/scratch')
expect(callMock).toHaveBeenLastCalledWith(
'browser.tabCreate',
{ url: 'https://example.com', worktree: 'identity:wt:local' },
{ timeoutMs: 60_000 }
)
})
it("refuses instead of using the focused worktree when the terminal's worktree is gone", async () => {
queueFixtures(callMock, worktreeListFixture([buildWorktree('/tmp/repo/other', 'other')]))
const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
vi.stubEnv('ORCA_WORKTREE_ID', 'repo::/tmp/repo/deleted')
await main(['tab', 'create', '--url', 'https://example.com'], '/tmp/scratch')
expect(callMock).not.toHaveBeenCalledWith(
'browser.tabCreate',
expect.anything(),
expect.anything()
)
expect(errorSpy).toHaveBeenCalledWith(
"This terminal's workspace repo::/tmp/repo/deleted is not listed by Orca on this host. Run the command from a workspace directory or pass --worktree <selector> (or all) where the command accepts it."
)
})
it('keeps the runtime default for the floating terminal, which has no workspace row', async () => {
queueFixtures(
callMock,
worktreeListFixture([buildWorktree('/tmp/repo/other', 'other')]),
okFixture('req_tab_create', { browserPageId: 'page-1' })
)
vi.spyOn(console, 'log').mockImplementation(() => {})
vi.stubEnv('ORCA_WORKTREE_ID', 'global-floating-terminal')
await main(['tab', 'create', '--url', 'https://example.com', '--json'], '/tmp/scratch')
expect(callMock).toHaveBeenLastCalledWith(
'browser.tabCreate',
{ url: 'https://example.com', worktree: undefined },
{ timeoutMs: 60_000 }
)
})
it("ignores the terminal's worktree when it was launched by another Orca profile", async () => {
queueFixtures(
callMock,
worktreeListFixture([buildWorktree('/tmp/repo/other', 'other')]),
okFixture('req_tab_create', { browserPageId: 'page-1' })
)
vi.spyOn(console, 'log').mockImplementation(() => {})
vi.stubEnv('ORCA_RUNTIME_SOURCE_ID', 'installed-source')
vi.stubEnv('ORCA_RUNTIME_SOURCE_INCARNATION', 'installed-runtime')
vi.stubEnv('ORCA_RUNTIME_SOURCE_PROFILE_PATH', '/tmp/orca-installed-profile')
vi.stubEnv('ORCA_WORKTREE_ID', 'repo::/tmp/repo/installed-only')
await main(['tab', 'create', '--url', 'https://example.com', '--json'], '/tmp/scratch')
expect(callMock).toHaveBeenLastCalledWith(
'browser.tabCreate',
{ url: 'https://example.com', worktree: undefined },
{ timeoutMs: 60_000 }
)
})
it.each(['ORCA_WORKTREE_ID', 'ORCA_WORKSPACE_ID'])(
'creates a tab in the folder workspace named by %s when cwd is outside it',
async (envName) => {
queueFixtures(
callMock,
worktreeListFixture([buildWorktree('/tmp/repo/other', 'other')]),
okFixture('req_tab_create', { browserPageId: 'page-1' })
)
vi.spyOn(console, 'log').mockImplementation(() => {})
vi.stubEnv(envName, 'folder:fw-1')
await main(['tab', 'create', '--url', 'https://example.com', '--json'], '/tmp/scratch')
expect(callMock).toHaveBeenLastCalledWith(
'browser.tabCreate',
{ url: 'https://example.com', worktree: 'folder:fw-1' },
{ timeoutMs: 60_000 }
)
}
)
})
describe('orca cli browser identity', () => {
beforeEach(() => {
callMock.mockReset()
})
afterEach(() => {
vi.restoreAllMocks()
})
it('gets the host identity only after capability negotiation', async () => {
queueFixtures(
callMock,
okFixture('status', { capabilities: ['browser.identity.v1'] }),
okFixture('identity', {
identity: {
state: 'valid',
appliedMode: 'clean',
configuredMode: 'native',
explicitSelection: true,
migrationNoticePending: false,
restartRequired: true
},
migrationNotice: null
})
)
vi.spyOn(console, 'log').mockImplementation(() => {})
await main(['browser', 'identity', 'get', '--json'], '/tmp/not-an-orca-worktree')
expect(callMock).toHaveBeenNthCalledWith(1, 'status.get')
expect(callMock).toHaveBeenNthCalledWith(2, 'browser.identity.get')
})
it('refuses an older runtime instead of guessing at identity support', async () => {
queueFixtures(callMock, okFixture('status', { capabilities: [] }))
const error = vi.spyOn(console, 'error').mockImplementation(() => {})
await main(['browser', 'identity', 'get'], '/tmp/not-an-orca-worktree')
expect(callMock).toHaveBeenCalledTimes(1)
expect(error).toHaveBeenCalledWith(expect.stringContaining('Update or restart Orca'))
})
})
describe('orca cli browser tab profiles', () => {
beforeEach(() => {
callMock.mockReset()
})
afterEach(() => {
vi.restoreAllMocks()
})
it('rejects unknown --scope values instead of silently defaulting to isolated', async () => {
const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
await main(
['tab', 'profile', 'create', '--label', 'Work', '--scope', 'isloated'],
'/tmp/not-an-orca-worktree'
)
expect(callMock).not.toHaveBeenCalled()
expect(errorSpy).toHaveBeenCalledWith('--scope must be "isolated" or "imported"')
})
it('surfaces a runtime error if the registry refuses to create a profile', async () => {
queueFixtures(callMock, okFixture('req_profile_create', { profile: null }))
const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
await main(['tab', 'profile', 'create', '--label', 'Bogus'], '/tmp/not-an-orca-worktree')
expect(callMock).toHaveBeenCalledTimes(1)
expect(errorSpy).toHaveBeenCalledWith(
'Failed to create browser profile (label=Bogus, scope=isolated)'
)
})
})
describe('orca cli browser cookies', () => {
beforeEach(() => {
callMock.mockReset()
process.exitCode = undefined
})
afterEach(() => {
vi.restoreAllMocks()
})
it('passes a finite non-negative cookie expiry through as a number', async () => {
queueFixtures(callMock, okFixture('req_cookie', { success: true }))
vi.spyOn(console, 'log').mockImplementation(() => {})
await main(
[
'cookie',
'set',
'--name',
'sid',
'--value',
'x',
'--expires',
'0',
'--worktree',
'all',
'--json'
],
'/tmp/not-an-orca-worktree'
)
expect(callMock).toHaveBeenCalledWith('browser.cookie.set', {
name: 'sid',
value: 'x',
expires: 0,
worktree: undefined
})
})
it.each(['not-a-number', 'Infinity', '-1'])(
'rejects invalid cookie expiry value %s before RPC dispatch',
async (expires) => {
const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
const priorExitCode = process.exitCode
await main(
['cookie', 'set', '--name', 'sid', '--value', 'x', '--expires', expires],
'/tmp/not-an-orca-worktree'
)
expect(callMock).not.toHaveBeenCalled()
expect(errorSpy.mock.calls.flat().join('\n')).toContain(`Invalid --expires value: ${expires}`)
expect(process.exitCode).toBe(1)
process.exitCode = priorExitCode
}
)
it('rejects --expires without a value before RPC dispatch', async () => {
const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
const priorExitCode = process.exitCode
await main(
['cookie', 'set', '--name', 'sid', '--value', 'x', '--expires'],
'/tmp/not-an-orca-worktree'
)
expect(callMock).not.toHaveBeenCalled()
expect(errorSpy.mock.calls.flat().join('\n')).toContain('Missing value for --expires.')
expect(process.exitCode).toBe(1)
process.exitCode = priorExitCode
})
})
describe('orca cli browser waits and viewport flags', () => {
beforeEach(() => {
callMock.mockReset()
process.exitCode = undefined
})
afterEach(() => {
vi.restoreAllMocks()
})
it('gives selector waits an explicit RPC timeout budget', async () => {
queueFixtures(callMock, okFixture('req_wait', { ok: true }))
vi.spyOn(console, 'log').mockImplementation(() => {})
await main(
['wait', '--selector', '#ready', '--worktree', 'all', '--json'],
'/tmp/not-an-orca-worktree'
)
expect(callMock).toHaveBeenCalledWith(
'browser.wait',
{
selector: '#ready',
timeout: undefined,
text: undefined,
url: undefined,
load: undefined,
fn: undefined,
state: undefined,
worktree: undefined
},
{ timeoutMs: 60_000 }
)
})
it('extends selector wait RPC timeout when the user passes --timeout', async () => {
queueFixtures(callMock, okFixture('req_wait', { ok: true }))
vi.spyOn(console, 'log').mockImplementation(() => {})
await main(
['wait', '--selector', '#ready', '--timeout', '45000', '--worktree', 'all', '--json'],
'/tmp/not-an-orca-worktree'
)
expect(callMock).toHaveBeenCalledWith(
'browser.wait',
{
selector: '#ready',
timeout: 45000,
text: undefined,
url: undefined,
load: undefined,
fn: undefined,
state: undefined,
worktree: undefined
},
{ timeoutMs: 75000 }
)
})
it('does not tell users Orca is down for a generic runtime timeout', async () => {
callMock.mockRejectedValueOnce(
new RuntimeClientError(
'runtime_timeout',
'Timed out waiting for the Orca runtime to respond.'
)
)
const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
await main(['wait', '--selector', '#ready', '--worktree', 'all'], '/tmp/not-an-orca-worktree')
expect(errorSpy).toHaveBeenCalledWith('Timed out waiting for the Orca runtime to respond.')
})
})
+1 -465
View File
@@ -64,7 +64,7 @@ vi.mock('../../shared/windows-console-input', () => ({
import { ACCOUNT_HANDLERS } from './account'
import { REPEATED_FLAG_SEPARATOR } from '../args'
import type { HandlerContext } from '../dispatch'
import { RuntimeClientError, type RuntimeClient } from '../runtime-client'
import type { RuntimeClient } from '../runtime-client'
import {
ACCOUNT_IMPORT_RUNTIME_CAPABILITY,
ANTIGRAVITY_ACCOUNTS_RUNTIME_CAPABILITY,
@@ -190,264 +190,6 @@ describe('account CLI handlers', () => {
}
})
it('falls back to OpenCode when opencode2 cannot be spawned', async () => {
const supportedCommand = 'opencode'
callMock.mockResolvedValue({
id: 'test',
ok: true,
result: { capabilities: [DATA_ACCOUNT_RUNTIME_CAPABILITY] },
_meta: { runtimeId: 'test-runtime' }
})
resolveCliCommandMock.mockImplementation((command: string) => `/tools/${command}`)
probeMock.mockImplementation(({ program }) => {
if (program !== `/tools/${supportedCommand}`) {
throw new Error('ENOENT')
}
return helpChild('--standalone Run with a private server instead of the background service')
})
await ACCOUNT_HANDLERS['account add'](context('opencode', true))
expect(probeMock.mock.calls.map(([spec]) => spec.program)).toEqual([
'/tools/opencode2',
'/tools/opencode'
])
const [command, args, options] = spawnMock.mock.calls[0]
expect(command).toBe(`/tools/${supportedCommand}`)
expect(args).toEqual(['auth', 'login', '--standalone'])
expect(probeMock).toHaveBeenLastCalledWith(
expect.objectContaining({
args: ['auth', 'login', '--help'],
env: options.env
})
)
expect(options.env.OPENCODE_DB).toBe('opencode.db')
expect(existsSync(options.env.XDG_DATA_HOME)).toBe(false)
expect(callMock).toHaveBeenLastCalledWith('accounts.addDataFromHome', {
provider: 'opencode',
sourceDataHome: options.env.XDG_DATA_HOME,
label: 'opencode'
})
})
it('passes the same original Windows launcher to the probe and login', async () => {
Object.defineProperty(process, 'platform', { configurable: true, value: 'win32' })
callMock.mockResolvedValue({ result: { capabilities: [DATA_ACCOUNT_RUNTIME_CAPABILITY] } })
const launcher = String.raw`C:\Users\A&B\npm tools\opencode2.cmd`
resolveCliCommandMock.mockReturnValue(launcher)
probeMock.mockImplementation(() => helpChild('--standalone'))
await ACCOUNT_HANDLERS['account add'](context('opencode', true))
expect(probeMock).toHaveBeenCalledExactlyOnceWith(
expect.objectContaining({ program: launcher, args: ['auth', 'login', '--help'] })
)
const probeEnv = probeMock.mock.calls[0][0].env
expect(spawnMock).toHaveBeenCalledExactlyOnceWith(
launcher,
['auth', 'login', '--standalone'],
expect.objectContaining({ env: probeEnv, stdio: ['inherit', process.stderr, 'inherit'] })
)
expect(existsSync(probeEnv.XDG_DATA_HOME)).toBe(false)
expect(callMock).toHaveBeenLastCalledWith('accounts.addDataFromHome', {
provider: 'opencode',
sourceDataHome: probeEnv.XDG_DATA_HOME,
label: 'opencode'
})
})
it.each(['v1', 'missing'])(
'gives installation guidance after %s candidates without altering generic launchers',
async (fallback) => {
Object.defineProperty(process, 'platform', { configurable: true, value: 'win32' })
callMock.mockResolvedValue({ result: { capabilities: [DATA_ACCOUNT_RUNTIME_CAPABILITY] } })
resolveCliCommandMock.mockImplementation((name: string) => `C:\\tools\\${name}.cmd`)
probeMock.mockImplementation(() => {
if (fallback === 'missing') {
throw new Error('ENOENT')
}
return helpChild('Usage: opencode auth login [url]')
})
const failure = await ACCOUNT_HANDLERS['account add'](context('opencode', true)).catch(
(error: unknown) => error
)
expect(failure).toBeInstanceOf(RuntimeClientError)
if (!(failure instanceof RuntimeClientError)) {
throw new Error('Expected account-add failure')
}
expect(probeMock).toHaveBeenCalledTimes(2)
expect(spawnMock).not.toHaveBeenCalled()
expect(callMock.mock.calls.map(([method]) => method)).toEqual(['status.get'])
expect(existsSync(probeMock.mock.calls[0][0].env.XDG_DATA_HOME)).toBe(false)
expect(failure.message).toContain(
String.raw`npm install --prefix C:\tools\orca-opencode2 @opencode/cli`
)
expect(failure.message).toContain('without changing your generic opencode launcher')
expect(failure.message).not.toContain('Usage:')
}
)
it('uses Codex device auth and keeps JSON stdout clean', async () => {
await ACCOUNT_HANDLERS['account add'](context('codex', true))
expect(spawnMock).toHaveBeenCalledWith(
'codex',
['login', '--device-auth'],
expect.objectContaining({
stdio: ['inherit', process.stderr, 'inherit'],
env: expect.objectContaining({ CODEX_HOME: expect.any(String) })
})
)
const spawnOptions = spawnMock.mock.calls[0]?.[2]
expect(spawnOptions.env.ELECTRON_RUN_AS_NODE).toBeUndefined()
expect(existsSync(spawnOptions.env.CODEX_HOME)).toBe(false)
expect(callMock).toHaveBeenCalledWith('accounts.addCodexFromHome', {
sourceHome: spawnOptions.env.CODEX_HOME
})
})
it('passes Windows console device handles to the login child instead of inheriting Electron stdio', async () => {
Object.defineProperty(process, 'platform', { configurable: true, value: 'win32' })
const dispose = vi.fn()
stdioForWindowsInteractiveChildMock.mockReturnValue({
stdio: [11, 'inherit', 'inherit'],
dispose
})
await ACCOUNT_HANDLERS['account add'](context('codex'))
expect(spawnMock).toHaveBeenCalledWith(
'codex',
['login', '--device-auth'],
expect.objectContaining({ stdio: [11, 'inherit', 'inherit'] })
)
expect(dispose).toHaveBeenCalledTimes(1)
})
it('disposes the Windows console input fd when spawn throws synchronously', async () => {
Object.defineProperty(process, 'platform', { configurable: true, value: 'win32' })
const dispose = vi.fn()
stdioForWindowsInteractiveChildMock.mockReturnValue({
stdio: [11, 'inherit', 'inherit'],
dispose
})
spawnMock.mockImplementationOnce(() => {
throw new Error('invalid stdio')
})
await expect(ACCOUNT_HANDLERS['account add'](context('codex'))).rejects.toThrow('invalid stdio')
expect(dispose).toHaveBeenCalledOnce()
})
it('forwards Windows form text literally through the process launcher', async () => {
Object.defineProperty(process, 'platform', { configurable: true, value: 'win32' })
callMock.mockResolvedValue({ result: { capabilities: [DATA_ACCOUNT_RUNTIME_CAPABILITY] } })
resolveCliCommandMock.mockImplementation((command: string) => `C:\\tools\\${command}.cmd`)
probeMock.mockImplementation(() => helpChild('--standalone'))
const answer = 'instance URL=https://gitlab.example.test/a%20b?x="quoted"&y=a=b!'
await ACCOUNT_HANDLERS['account add']({
...context('opencode', true),
flags: new Map([
['agent', 'opencode'],
['answer', answer]
])
})
expect(spawnMock.mock.calls[0][1]).toEqual([
'auth',
'login',
'--answer',
answer,
'--standalone'
])
expect(callMock).toHaveBeenLastCalledWith('accounts.addDataFromHome', expect.anything())
})
it('runs login in the final profile without accessing a locked Keychain', async () => {
readKeychainMock.mockRejectedValue(new Error('locked'))
deleteKeychainMock.mockRejectedValue(new Error('locked'))
writeKeychainMock.mockRejectedValue(new Error('locked'))
await ACCOUNT_HANDLERS['account add'](context('claude'))
expect(spawnMock.mock.calls[0]?.[2].env.CLAUDE_CONFIG_DIR).toBe('/fake/final-profile')
expect(callMock).toHaveBeenCalledWith(
'accounts.finishClaudeSignIn',
{ accountId: 'draft', runtime: 'host', wslDistro: undefined },
{ timeoutMs: 300000 }
)
expect(readKeychainMock).not.toHaveBeenCalled()
expect(writeKeychainMock).not.toHaveBeenCalled()
expect(deleteKeychainMock).not.toHaveBeenCalled()
})
it('attributes a Codex account added through the WSL bridge to the cwd distro', async () => {
Object.defineProperty(process, 'platform', { configurable: true, value: 'win32' })
await ACCOUNT_HANDLERS['account add'](
context('codex', false, String.raw`\\wsl$\Ubuntu\home\user`)
)
const sourceHome = spawnMock.mock.calls[0]?.[2].env.CODEX_HOME
expect(callMock).toHaveBeenCalledWith('accounts.addCodexFromHome', {
sourceHome,
runtime: 'wsl',
wslDistro: 'Ubuntu'
})
})
it('uses the explicit bridge distro over an ambient environment or another distro cwd', async () => {
Object.defineProperty(process, 'platform', { configurable: true, value: 'win32' })
process.env.WSL_DISTRO_NAME = 'stale-Windows-value'
process.env.ORCA_CLI_WSL_DISTRO = 'Debian'
await ACCOUNT_HANDLERS['account add'](
context('claude', false, String.raw`\\wsl.localhost\Ubuntu-22.04\home\user`)
)
expect(callMock).toHaveBeenCalledWith(
'accounts.beginClaudeSignIn',
expect.objectContaining({ runtime: 'wsl', wslDistro: 'Debian' }),
{ timeoutMs: 300000 }
)
})
it.each(['claude', 'codex'])(
'attributes %s from a Windows mount to the bridge distro',
async (agent) => {
Object.defineProperty(process, 'platform', { configurable: true, value: 'win32' })
process.env.ORCA_CLI_WSL_DISTRO = 'Ubuntu Work'
await ACCOUNT_HANDLERS['account add'](context(agent, false, String.raw`C:\work with spaces`))
expect(
callMock.mock.calls.some(
([method, params]) =>
method ===
(agent === 'claude' ? 'accounts.beginClaudeSignIn' : 'accounts.addCodexFromHome') &&
params.wslDistro === 'Ubuntu Work'
)
).toBe(true)
}
)
it('ignores an ambient WSL distro in a native Windows account add', async () => {
Object.defineProperty(process, 'platform', { configurable: true, value: 'win32' })
process.env.WSL_DISTRO_NAME = 'stale-Windows-value'
await ACCOUNT_HANDLERS['account add'](context('codex', false, String.raw`C:\work`))
const sourceHome = spawnMock.mock.calls[0]?.[2].env.CODEX_HOME
expect(callMock).toHaveBeenCalledWith('accounts.addCodexFromHome', { sourceHome })
})
it.each(['linux', 'darwin'])(
'keeps host attribution when the CLI runs on %s',
async (platform) => {
// Linux runtimes use host-lane accounts even when the CLI itself runs in WSL.
Object.defineProperty(process, 'platform', { configurable: true, value: platform })
process.env.WSL_DISTRO_NAME = 'Ubuntu-22.04'
process.env.ORCA_CLI_WSL_DISTRO = 'Ubuntu-22.04'
await ACCOUNT_HANDLERS['account add'](context('codex'))
const sourceHome = spawnMock.mock.calls[0]?.[2].env.CODEX_HOME
expect(callMock).toHaveBeenCalledWith('accounts.addCodexFromHome', { sourceHome })
}
)
it('waits for physical child close before removing interrupted login credentials', async () => {
// A live login can recreate credentials after cleanup; wait for close before deleting them.
Object.defineProperty(process, 'platform', { configurable: true, value: 'linux' })
@@ -481,165 +223,6 @@ describe('account CLI handlers', () => {
exitSpy.mockRestore()
})
it('cleans up when an SSH hangup ends the login', async () => {
// Node's default SIGHUP exit would bypass cleanup when an SSH connection drops.
Object.defineProperty(process, 'platform', { configurable: true, value: 'linux' })
const child = Object.assign(new EventEmitter(), { kill: vi.fn() })
let codexHome = ''
spawnMock.mockImplementation((_command, _args, options: { env: Record<string, string> }) => {
codexHome = options.env.CODEX_HOME
return child
})
const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => undefined) as never)
const listenersBefore = process.listeners('SIGHUP')
const pending = ACCOUNT_HANDLERS['account add'](context('codex')).catch(() => {})
await vi.waitFor(() => expect(codexHome).not.toBe(''))
newSignalListener('SIGHUP', listenersBefore)('SIGHUP')
await vi.waitFor(() => expect(child.kill).toHaveBeenCalledWith('SIGHUP'))
expect(exitSpy).not.toHaveBeenCalled()
expect(existsSync(codexHome)).toBe(true)
child.emit('exit', 1)
child.emit('close', 1)
await vi.waitFor(() => expect(exitSpy).toHaveBeenCalledWith(129))
expect(existsSync(codexHome)).toBe(false)
await pending
exitSpy.mockRestore()
})
it('warns that the account may already be registered when interrupted mid-RPC', async () => {
// Registration continues at the runtime after the CLI is interrupted.
const child = Object.assign(new EventEmitter(), { kill: vi.fn() })
spawnMock.mockImplementation(() => {
queueMicrotask(() => child.emit('exit', 0))
return child
})
let rejectRegistration: ((error: Error) => void) | undefined
const registration = new Promise<never>((_resolve, reject) => {
rejectRegistration = reject
})
// Only registration waits; preflight must still resolve.
callMock.mockImplementation((method: string) =>
method === 'status.get'
? Promise.resolve({
id: 'test',
ok: true,
result: {
capabilities: [ACCOUNT_IMPORT_RUNTIME_CAPABILITY, CLAUDE_SIGN_IN_RUNTIME_CAPABILITY]
},
_meta: { runtimeId: 'test-runtime' }
})
: method === 'accounts.list'
? Promise.resolve({
id: 'test',
ok: true,
result: { claude: accountState('c@e.com'), codex: accountState('x@e.com') },
_meta: { runtimeId: 'test-runtime' }
})
: registration
)
const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => undefined) as never)
const listenersBefore = process.listeners('SIGINT')
const pending = ACCOUNT_HANDLERS['account add'](context('codex')).catch(() => {})
try {
await vi.waitFor(() =>
expect(callMock).toHaveBeenCalledWith('accounts.addCodexFromHome', expect.anything())
)
newSignalListener('SIGINT', listenersBefore)('SIGINT')
await vi.waitFor(() => expect(exitSpy).toHaveBeenCalledWith(130))
expect(warnSpy).toHaveBeenCalledWith(
expect.stringContaining('may still have been registered')
)
} finally {
rejectRegistration?.(new Error('finish interrupted registration'))
await pending
warnSpy.mockRestore()
exitSpy.mockRestore()
}
expect(process.listeners('SIGINT')).toEqual(listenersBefore)
})
it('fails before the login when the runtime is unreachable', async () => {
callMock.mockRejectedValue(new Error('runtime not running'))
await expect(ACCOUNT_HANDLERS['account add'](context('codex'))).rejects.toThrow(
'runtime not running'
)
expect(callMock).toHaveBeenCalledWith('status.get')
expect(spawnMock).not.toHaveBeenCalled()
})
it('adds Codex through an older host that advertises only the retired import capability', async () => {
callMock.mockResolvedValueOnce({
id: 'test',
ok: true,
result: { capabilities: [ACCOUNT_IMPORT_RUNTIME_CAPABILITY] },
_meta: { runtimeId: 'test-runtime' }
})
await ACCOUNT_HANDLERS['account add'](context('codex'))
const sourceHome = spawnMock.mock.calls[0]?.[2].env.CODEX_HOME
expect(callMock).toHaveBeenCalledWith('accounts.addCodexFromHome', { sourceHome })
expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('codex@example.com'))
})
it.each(['claude', 'codex'] as const)(
'refuses %s login before spawning when its capability is absent',
async (agent) => {
callMock.mockResolvedValue({
id: 'test',
ok: true,
result: { capabilities: [] },
_meta: { runtimeId: 'test-runtime' }
})
await expect(ACCOUNT_HANDLERS['account add'](context(agent))).rejects.toThrow(
'The running Orca runtime is too old to add accounts from the CLI.'
)
expect(callMock).toHaveBeenCalledOnce()
expect(callMock).toHaveBeenCalledWith('status.get')
expect(spawnMock).not.toHaveBeenCalled()
}
)
it.each(['environment', 'pairing-code'])(
'rejects --%s instead of silently ignoring it',
async (flag) => {
await expect(
ACCOUNT_HANDLERS['account add']({
...context('codex'),
flags: new Map<string, string | boolean>([
['agent', 'codex'],
[flag, 'homelab']
])
})
).rejects.toThrow(`\`--${flag}\` does not retarget`)
expect(spawnMock).not.toHaveBeenCalled()
}
)
it.each(['environment', 'pairing-code'])(
'rejects --%s on `account list` instead of listing the local host',
async (flag) => {
await expect(
ACCOUNT_HANDLERS['account list']({
...context('claude'),
flags: new Map<string, string | boolean>([[flag, 'homelab']])
})
).rejects.toThrow(`\`--${flag}\` does not retarget`)
expect(callMock).not.toHaveBeenCalled()
}
)
it('keeps the original add error when cleanup also fails', async () => {
const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
rmSyncMock.mockImplementationOnce(() => {
@@ -684,23 +267,6 @@ describe('account CLI handlers', () => {
expect(logSpy).not.toHaveBeenCalled()
})
it.each(['claude', 'codex'])(
'rejects OpenCode login flags for %s before login',
async (agent) => {
await expect(
ACCOUNT_HANDLERS['account add']({
...context(agent),
flags: new Map([
['agent', agent],
['method', 'device']
])
})
).rejects.toThrow('only supported with --agent opencode')
expect(callMock).not.toHaveBeenCalled()
expect(spawnMock).not.toHaveBeenCalled()
}
)
it('keeps OpenCode form answer values out of the login failure message', async () => {
callMock.mockResolvedValue({
id: 'test',
@@ -732,15 +298,6 @@ describe('account CLI handlers', () => {
)
})
it('rejects `--agent` with no value instead of defaulting to Claude', async () => {
await expect(
ACCOUNT_HANDLERS['account add']({ ...context('claude'), flags: new Map([['agent', true]]) })
).rejects.toThrow(
'Missing a value for --agent. Use `--agent claude`, `--agent codex`, `--agent opencode`, or `--agent devin`.'
)
expect(spawnMock).not.toHaveBeenCalled()
})
describe('select and rm by --account', () => {
const antigravityAccounts = {
accounts: [
@@ -792,20 +349,6 @@ describe('account CLI handlers', () => {
)
})
it('selects and removes Antigravity accounts by email or subject on the host', async () => {
await ACCOUNT_HANDLERS['account select'](selectionContext('antigravity', 'ME@gmail.example'))
await ACCOUNT_HANDLERS['account rm'](selectionContext('antigravity', 'sub-2'))
expect(callMock).toHaveBeenCalledWith('accounts.antigravitySelect', {
target: { runtime: 'host' },
accountId: 'agy-1'
})
expect(callMock).toHaveBeenCalledWith('accounts.antigravityRemove', {
target: { runtime: 'host' },
accountId: 'agy-2'
})
})
it('refuses an email shared by several accounts without switching or removing', async () => {
await expect(
ACCOUNT_HANDLERS['account select'](selectionContext('claude', 'shared@example.com'))
@@ -816,13 +359,6 @@ describe('account CLI handlers', () => {
expect(mutatingCalls()).toEqual([])
})
it('refuses the Antigravity system default, which its vault does not have', async () => {
await expect(
ACCOUNT_HANDLERS['account select'](selectionContext('antigravity', 'system'))
).rejects.toThrow('Antigravity has no system default')
expect(mutatingCalls()).toEqual([])
})
it('refuses the Claude system default from WSL rather than resetting the Windows host', async () => {
Object.defineProperty(process, 'platform', { configurable: true, value: 'win32' })
process.env.ORCA_CLI_WSL_DISTRO = 'Ubuntu'
+1 -184
View File
@@ -20,7 +20,6 @@ import {
hashProfileStateJson,
importProfileStateJson
} from '../../main/persistence/profile-state/profile-state-documents'
import { ProfileStateSqliteAuthority } from '../../main/persistence/profile-state/profile-state-sqlite-authority'
import {
acquireProfileStateMaintenance,
acquireProfileStateRuntimeAdmission,
@@ -90,18 +89,6 @@ vi.mock('../../main/agent-hooks/installation/managed-agent-hook-controls', () =>
import { main } from '../index'
function readDefaultProfileState(userDataPath: string) {
const opened = openProfileStateDatabase(
getOrcaProfileStateDatabaseFile(DEFAULT_LOCAL_ORCA_PROFILE_ID, userDataPath),
DEFAULT_LOCAL_ORCA_PROFILE_ID
)
try {
return JSON.parse(exportProfileStateJson(opened.db))
} finally {
opened.db.close()
}
}
function writeDataFile(userDataPath: string, state: PersistedState): void {
mkdirSync(userDataPath, { recursive: true })
writeFileSync(join(userDataPath, 'orca-data.json'), JSON.stringify(state, null, 2), 'utf-8')
@@ -143,19 +130,6 @@ describe('agent hooks CLI handler', () => {
rmSync(userDataPath, { recursive: true, force: true })
})
it('keeps new card style off when creating offline settings for a fresh profile', async () => {
await runAgentHooksOff(userDataPath)
const persisted = readDefaultProfileState(userDataPath)
expect(persisted.settings.experimentalNewWorktreeCardStyle).toBe(false)
expect(persisted.settings.agentStatusHooksEnabled).toBe(false)
expect(existsSync(join(userDataPath, 'orca-data.json'))).toBe(false)
expect(existsSync(getOrcaProfileDataFile(DEFAULT_LOCAL_ORCA_PROFILE_ID, userDataPath))).toBe(
false
)
})
it.each(['fresh', 'root-json', 'profile-json'] as const)(
'refuses an incapable offline writer before any %s profile or hook changes',
async (source) => {
@@ -190,33 +164,6 @@ describe('agent hooks CLI handler', () => {
}
)
it('keeps runtime writes available to an incapable CLI', async () => {
vi.spyOn(profileStateDatabase, 'isProfileStateSqliteAvailable').mockReturnValue(false)
getCliStatusMock.mockResolvedValueOnce({
id: 'test-status',
ok: true,
result: {
app: { running: true, pid: null },
runtime: { state: 'ready', reachable: true, runtimeId: null },
graph: { state: 'ready' }
},
_meta: { runtimeId: 'test' }
})
callMock.mockResolvedValueOnce({ result: {} })
await runAgentHooksOff(userDataPath)
expect(process.exitCode).not.toBe(1)
expect(callMock).toHaveBeenCalledWith(
'settings.update',
{ agentStatusHooksEnabled: false },
{ timeoutMs: 10_000 }
)
expect(applyAgentStatusHooksEnabledMock).not.toHaveBeenCalled()
expect(existsSync(join(userDataPath, '.profile-state-access'))).toBe(false)
expect(existsSync(join(userDataPath, 'orca-profile-index.json'))).toBe(false)
})
it.each(['root', 'indexed'] as const)(
'reads %s JSON status without SQLite or migration',
async (source) => {
@@ -240,26 +187,6 @@ describe('agent hooks CLI handler', () => {
}
)
it('names the file each status reports on', async () => {
writeDataFile(userDataPath, getDefaultPersistedState(userDataPath))
getDefaultUserDataPathMock.mockReturnValue(userDataPath)
getManagedAgentHookStatusesMock.mockReturnValue([
{
agent: 'codex',
state: 'installed',
configPath: '/u/orca/codex-runtime-home/home/hooks.json',
managedHooksPresent: true,
detail: null
}
])
await main(['agent', 'hooks', 'status'], userDataPath)
expect(console.log).toHaveBeenCalledWith(
expect.stringContaining('codex: installed (/u/orca/codex-runtime-home/home/hooks.json)')
)
})
it.each(['missing', 'corrupt'] as const)(
'uses the backup index when the primary is %s',
async (primary) => {
@@ -299,7 +226,7 @@ describe('agent hooks CLI handler', () => {
}
)
it.each([0, 1, 2, 3, 4])('refuses a pre-index root with only legacy backup %s', async (slot) => {
it.each([0])('refuses a pre-index root with only legacy backup %s', async (slot) => {
const backup = join(userDataPath, `orca-data.json.bak.${slot}`)
const source = '{"settings":{"agentStatusHooksEnabled":true}}'
writeFileSync(backup, source)
@@ -420,62 +347,6 @@ describe('agent hooks CLI handler', () => {
}
)
it.each(['on', 'off', 'status', 'prepare-codex'])(
'refuses explicit remote selection before local hook command %s',
async (command) => {
const state = getDefaultPersistedState(userDataPath)
writeDataFile(userDataPath, state)
const before = readFileSync(join(userDataPath, 'orca-data.json'), 'utf8')
getDefaultUserDataPathMock.mockReturnValue(userDataPath)
for (const selector of ['environment', 'pairing-code']) {
process.exitCode = undefined
await main(
['agent', 'hooks', command, `--${selector}`, 'unreachable-host', '--json'],
userDataPath
)
expect(process.exitCode).toBe(1)
expect(getCliStatusMock).not.toHaveBeenCalled()
expect(callMock).not.toHaveBeenCalled()
expect(applyAgentStatusHooksEnabledMock).not.toHaveBeenCalled()
expect(readFileSync(join(userDataPath, 'orca-data.json'), 'utf8')).toBe(before)
}
}
)
it('does nothing for a native pane, so an old shell wrapper still exits 0', async () => {
const home = '/Users/jin/Library/Application Support/orca/codex-runtime-home/home'
vi.stubEnv('CODEX_HOME', home)
vi.stubEnv('ORCA_CODEX_HOME', home)
vi.stubEnv('WSL_DISTRO_NAME', '')
await main(['agent', 'hooks', 'prepare-codex'], userDataPath)
expect(callMock).not.toHaveBeenCalled()
expect(getCliStatusMock).not.toHaveBeenCalled()
expect(process.exitCode).toBeUndefined()
})
it('fails open when WSL runtime preparation is unavailable', async () => {
vi.stubEnv('CODEX_HOME', '/home/jin/.local/share/orca/codex-runtime-home/home')
vi.stubEnv('ORCA_CODEX_HOME', '/home/jin/.local/share/orca/codex-runtime-home/home')
vi.stubEnv('WSL_DISTRO_NAME', 'Ubuntu')
callMock.mockRejectedValue(new Error('method_not_found'))
await expect(main(['agent', 'hooks', 'prepare-codex'], userDataPath)).resolves.toBeUndefined()
expect(callMock).toHaveBeenCalledExactlyOnceWith(
'agentHooks.prepareCodexForWslPane',
{
codexHome: '/home/jin/.local/share/orca/codex-runtime-home/home',
orcaCodexHome: '/home/jin/.local/share/orca/codex-runtime-home/home',
wslDistro: 'Ubuntu'
},
{ timeoutMs: 50_000 }
)
expect(process.exitCode).toBeUndefined()
})
it('updates an established SQLite profile without rewriting its JSON export', async () => {
const profileId = 'work-profile'
const profileDirectory = join(userDataPath, 'profiles', profileId)
@@ -519,60 +390,6 @@ describe('agent hooks CLI handler', () => {
}
})
it.each(['update-failed', 'unreachable', 'status-failed'] as const)(
'preserves a live SQLite writer when runtime contact is %s',
async (failure) => {
const profileId = 'live-profile'
const profileDirectory = join(userDataPath, 'profiles', profileId)
mkdirSync(profileDirectory, { recursive: true })
writeActiveProfileIndex(userDataPath, profileId)
const authority = new ProfileStateSqliteAuthority(
getOrcaProfileStateDatabaseFile(profileId, userDataPath),
profileId
)
authority.writeSerializedState(
Buffer.from(JSON.stringify({ settings: { agentStatusHooksEnabled: true } }))
)
if (failure === 'status-failed') {
getCliStatusMock.mockRejectedValueOnce(new Error('status transport unavailable'))
} else {
getCliStatusMock.mockResolvedValueOnce({
id: 'test-status',
ok: true,
result: {
app: { running: true, pid: null },
runtime: {
state: failure === 'unreachable' ? 'starting' : 'ready',
reachable: failure !== 'unreachable',
runtimeId: null
},
graph: { state: 'ready' }
},
_meta: { runtimeId: 'test' }
})
callMock.mockRejectedValueOnce(new Error('settings request timed out'))
}
try {
await runAgentHooksOff(userDataPath)
expect(process.exitCode).toBe(1)
expect(applyAgentStatusHooksEnabledMock).not.toHaveBeenCalled()
expect(() =>
authority.writeSerializedDomains([
{ domain: 'ui', payload: '{"marker":"still-writable"}' }
])
).not.toThrow()
const persisted = JSON.parse(authority.readSerializedState() ?? '{}')
expect(persisted).toMatchObject({
settings: { agentStatusHooksEnabled: true },
ui: { marker: 'still-writable' }
})
} finally {
authority.close()
}
}
)
it('imports a JSON-only active profile before the first settings mutation', async () => {
const profileId = 'json-profile'
const profileDirectory = join(userDataPath, 'profiles', profileId)
@@ -10,10 +10,8 @@ vi.mock('../selectors', () => ({ getTerminalHandle: vi.fn() }))
import { ORCHESTRATION_HANDLERS } from './orchestration'
import { printResult } from '../format'
import { parseArgs, validateCommandAndFlags } from '../args'
import { RuntimeClient } from '../runtime-client'
import { ORCHESTRATION_WORKER_COMMAND_SPECS } from '../specs/orchestration-worker-specs'
const client = new RuntimeClient('/tmp/orca-worker-cli', 60_000, null, null)
@@ -66,87 +64,4 @@ describe('orchestration worker-start CLI contract', () => {
expect(process.exitCode).toBe(1)
})
it('allows the initial zero cursor when paging worker output', async () => {
callMock.mockResolvedValue({
result: {
dispatchId: 'ctx_1',
terminal: { tail: [], status: 'running', nextCursor: '0' }
}
})
await ORCHESTRATION_HANDLERS['orchestration worker-read']({
flags: new Map<string, string | boolean>([
['dispatch', 'ctx_1'],
['cursor', '0'],
['limit', '100']
]),
client,
cwd: '/tmp/repo',
json: true
})
expect(callMock).toHaveBeenCalledWith('orchestration.workerRead', {
dispatch: 'ctx_1',
cursor: 0,
limit: 100,
source: undefined
})
})
it('passes opaque source-pinned cursors and explicit source selection', async () => {
callMock.mockResolvedValue({
result: {
dispatchId: 'ctx_1',
source: 'transcript',
transcript: { messages: [], nextCursor: 'owr1_next' }
}
})
await ORCHESTRATION_HANDLERS['orchestration worker-read']({
flags: new Map<string, string | boolean>([
['dispatch', 'ctx_1'],
['cursor', 'owr1_previous'],
['source', 'transcript']
]),
client,
cwd: '/tmp/repo',
json: true
})
expect(callMock).toHaveBeenCalledWith('orchestration.workerRead', {
dispatch: 'ctx_1',
cursor: 'owr1_previous',
limit: undefined,
source: 'transcript'
})
})
it('keeps cleanup and retention TTL controls off the public CLI surface', async () => {
const kept = parseArgs(['orchestration', 'worker-keep-open', '--dispatch', 'ctx_1'])
expect(() => validateCommandAndFlags(ORCHESTRATION_WORKER_COMMAND_SPECS, kept)).not.toThrow()
expect(() =>
validateCommandAndFlags(
ORCHESTRATION_WORKER_COMMAND_SPECS,
parseArgs(['orchestration', 'worker-cleanup'])
)
).toThrow('Unknown command: orchestration worker-cleanup')
expect(() =>
validateCommandAndFlags(
ORCHESTRATION_WORKER_COMMAND_SPECS,
parseArgs(['orchestration', 'worker-keep-open', '--until', '2099-01-01T00:00:00Z'])
)
).toThrow('Unknown flag --until for command: orchestration worker-keep-open')
callMock.mockResolvedValue({
result: { dispatchId: 'ctx_1', state: 'retained', processAction: 'none' }
})
await ORCHESTRATION_HANDLERS['orchestration worker-keep-open']({
flags: kept.flags,
client,
cwd: '/tmp/repo',
json: true
})
expect(callMock).toHaveBeenCalledWith('orchestration.workerRetain', { dispatch: 'ctx_1' })
})
})
-286
View File
@@ -1,13 +1,8 @@
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
const callMock = vi.fn()
// Reuse one mutation identity when retrying worker_done after runtime_unavailable.
const WORKER_DONE_REQUEST = { orchestrationRequestId: expect.any(String) }
const getTerminalHandleMock = vi.hoisted(() => vi.fn())
const originalExitCode = process.exitCode
function lifecycleGroupRecipientError(type: 'worker_done' | 'heartbeat'): string {
return `${type} messages belong to one exact Dispatch and cannot target a group address.`
}
vi.mock('../format', () => ({ printResult: vi.fn() }))
vi.mock('../selectors', () => ({ getTerminalHandle: getTerminalHandleMock }))
@@ -16,7 +11,6 @@ import { ORCHESTRATION_HANDLERS } from './orchestration'
import { printResult } from '../format'
import { okFixture } from '../test-fixtures'
import { ORCHESTRATION_ASK_RETURNS_AT_ONCE_RUNTIME_CAPABILITY } from '../../shared/orchestration/orchestration-runtime-capabilities'
beforeEach(() => {
callMock.mockReset()
@@ -54,144 +48,6 @@ describe('orchestration send structured payload flags', () => {
json: true
} as never)
it('serializes common worker payload fields as JSON', async () => {
await invokeSend(
new Map<string, string | boolean>([
['from', 'term_worker'],
['to', 'term_coord'],
['subject', 'done'],
['type', 'worker_done'],
['task-id', 'task_1'],
['dispatch-id', 'ctx_1'],
['outcome', 'succeeded'],
['files-modified', ' src/a.ts, ,src/b.ts, '],
['phase', 'verification'],
['report-path', 'reports/done.md']
])
)
expect(callMock).toHaveBeenCalledWith(
'orchestration.send',
{
from: 'term_worker',
to: 'term_coord',
subject: 'done',
body: undefined,
type: 'worker_done',
priority: undefined,
threadId: undefined,
payload: JSON.stringify({
taskId: 'task_1',
dispatchId: 'ctx_1',
outcome: 'succeeded',
filesModified: ['src/a.ts', 'src/b.ts'],
reportPath: 'reports/done.md',
phase: 'verification'
}),
waitForLifecycleSettlement: true,
devMode: false
},
WORKER_DONE_REQUEST
)
})
it('carries Dispatch authority in the RPC envelope instead of message params', async () => {
await invokeSend(
new Map<string, string | boolean>([
['from', 'term_worker'],
['subject', 'alive'],
['type', 'heartbeat'],
['dispatch-id', 'ctx_1'],
['dispatch-capability', 'dcap_secret'],
['retry-request', '33333333-3333-4333-8333-333333333333']
])
)
expect(callMock).toHaveBeenCalledWith(
'orchestration.send',
expect.not.objectContaining({ dispatchCapability: expect.anything() }),
{
orchestrationCapability: 'dcap_secret',
orchestrationRequestId: '33333333-3333-4333-8333-333333333333'
}
)
})
it('rejects mixing raw payload with structured payload flags', async () => {
await expect(
invokeSend(
new Map<string, string | boolean>([
['from', 'term_worker'],
['to', 'term_coord'],
['subject', 'done'],
['payload', '{"taskId":"task_1"}'],
['task-id', 'task_1']
])
)
).rejects.toThrow(/structured payload/)
expect(callMock).not.toHaveBeenCalled()
})
it('rejects worker_done group sends before resolving a sender handle', async () => {
getTerminalHandleMock.mockRejectedValue(new Error('sender resolution should not run'))
await expect(
invokeSend(
new Map<string, string | boolean>([
['to', '@all'],
['subject', 'done'],
['type', 'worker_done']
])
)
).rejects.toMatchObject({
code: 'invalid_argument',
message: lifecycleGroupRecipientError('worker_done')
})
expect(getTerminalHandleMock).not.toHaveBeenCalled()
expect(callMock).not.toHaveBeenCalled()
})
it('rejects heartbeat group sends before resolving a sender handle', async () => {
getTerminalHandleMock.mockRejectedValue(new Error('sender resolution should not run'))
await expect(
invokeSend(
new Map<string, string | boolean>([
['to', '@idle'],
['subject', 'alive'],
['type', 'heartbeat']
])
)
).rejects.toMatchObject({
code: 'invalid_argument',
message: lifecycleGroupRecipientError('heartbeat')
})
expect(getTerminalHandleMock).not.toHaveBeenCalled()
expect(callMock).not.toHaveBeenCalled()
})
it('passes ORCA_PANE_KEY as the sender pane identity', async () => {
process.env.ORCA_TERMINAL_HANDLE = 'term_worker_env'
process.env.ORCA_PANE_KEY = 'tab_worker:leaf_worker'
await invokeSend(
new Map<string, string | boolean>([
['to', 'term_coord'],
['subject', 'done'],
['type', 'worker_done'],
['outcome', 'succeeded']
])
)
expect(callMock).toHaveBeenCalledWith(
'orchestration.send',
expect.objectContaining({ senderPaneKey: 'tab_worker:leaf_worker' }),
WORKER_DONE_REQUEST
)
})
it('refuses a structured session without naming a handle it could pass', async () => {
process.env.ORCA_STRUCTURED_SESSION = '1'
getTerminalHandleMock.mockResolvedValue('term_sibling_pane')
@@ -216,17 +72,6 @@ describe('orchestration send structured payload flags', () => {
})
describe('orchestration timeout flag validation', () => {
const invalidTimeoutValues: [string, string | boolean][] = [
['missing', true],
['empty', ''],
['non-numeric', 'not-a-number'],
['zero', '0'],
['negative', '-1'],
['fractional', '1.5'],
['rounded fractional', '9007199254740991.1'],
['unsafe integer', String(Number.MAX_SAFE_INTEGER + 1)]
]
const invokeCheck = (flags: Map<string, string | boolean>) =>
ORCHESTRATION_HANDLERS['orchestration check']({
flags,
@@ -235,70 +80,6 @@ describe('orchestration timeout flag validation', () => {
json: true
} as never)
const invokeAsk = (flags: Map<string, string | boolean>) =>
ORCHESTRATION_HANDLERS['orchestration ask']({
flags,
client: { call: callMock },
cwd: '/tmp/repo',
json: true
} as never)
it.each(invalidTimeoutValues)('rejects invalid check --timeout-ms: %s', async (_label, value) => {
const flags = new Map<string, string | boolean>([
['wait', true],
['timeout-ms', value]
])
await expect(invokeCheck(flags)).rejects.toThrow(/--timeout-ms/)
expect(callMock).not.toHaveBeenCalled()
expect(getTerminalHandleMock).not.toHaveBeenCalled()
})
it('passes a parsed check timeout and peek mode into the RPC payload', async () => {
process.env.ORCA_TERMINAL_HANDLE = 'term_worker'
callMock.mockResolvedValue({ result: { messages: [], count: 0 } })
await invokeCheck(
new Map<string, string | boolean>([
['wait', true],
['peek', true],
['timeout-ms', '250']
])
)
// unread:false keeps --peek non-consuming when older runtimes ignore the peek field.
expect(callMock).toHaveBeenCalledWith('orchestration.check', {
terminal: 'term_worker',
terminalPaneKey: undefined,
unread: false,
peek: true,
all: undefined,
types: undefined,
format: undefined,
compatibilityCliCommand: expect.stringMatching(/^orca(?:-ide)?$/),
run: undefined,
ack: undefined,
wait: true,
timeoutMs: 250
})
})
it('rejects combined read modes before calling the runtime', async () => {
process.env.ORCA_TERMINAL_HANDLE = 'term_worker'
await expect(
invokeCheck(
new Map<string, string | boolean>([
['unread', true],
['peek', true]
])
)
).rejects.toMatchObject({
code: 'invalid_argument',
message: expect.stringContaining('read mode')
})
expect(callMock).not.toHaveBeenCalled()
})
it('fails --peek --wait against a runtime that returned only read rows', async () => {
process.env.ORCA_TERMINAL_HANDLE = 'term_worker'
callMock.mockResolvedValue({
@@ -317,71 +98,4 @@ describe('orchestration timeout flag validation', () => {
)
).rejects.toMatchObject({ code: 'peek_wait_unsupported' })
})
it.each(invalidTimeoutValues)('rejects invalid ask --timeout-ms: %s', async (_label, value) => {
const flags = new Map<string, string | boolean>([
['to', 'term_coord'],
['question', 'Proceed?'],
['timeout-ms', value]
])
await expect(invokeAsk(flags)).rejects.toThrow(/--timeout-ms/)
expect(callMock).not.toHaveBeenCalled()
expect(getTerminalHandleMock).not.toHaveBeenCalled()
})
it.each(['1800001', String(Number.MAX_SAFE_INTEGER)])(
'rejects an oversized ask timeout %s before resolving identity or creating a question',
async (timeoutMs) => {
process.env.ORCA_TERMINAL_HANDLE = 'term_worker'
callMock.mockResolvedValue({
result: { answer: 'yes', messageId: 'msg_1', threadId: 'thread_1', timedOut: false }
})
await expect(
invokeAsk(
new Map<string, string | boolean>([
['question', 'Proceed?'],
['timeout-ms', timeoutMs]
])
)
).rejects.toMatchObject({
code: 'invalid_argument',
message: expect.stringMatching(/--timeout-ms.*1800000.*30 minutes/)
})
expect(callMock).not.toHaveBeenCalled()
expect(getTerminalHandleMock).not.toHaveBeenCalled()
}
)
it('asks without waiting only when the Orca it talks to advertises it', async () => {
process.env.ORCA_TERMINAL_HANDLE = 'term_worker'
const askedWith = async (capabilities: string[]) => {
callMock.mockReset()
callMock.mockImplementation(async (method: string) =>
method === 'status.get'
? { result: { capabilities } }
: { result: { answer: null, messageId: 'msg_q', threadId: 'msg_q', timedOut: false } }
)
await invokeAsk(new Map<string, string | boolean>([['question', 'Proceed?']]))
return callMock.mock.calls.find(([method]) => method === 'orchestration.ask')?.[1]
}
expect(await askedWith([ORCHESTRATION_ASK_RETURNS_AT_ONCE_RUNTIME_CAPABILITY])).toMatchObject({
wait: false
})
expect(await askedWith([])).not.toHaveProperty('wait')
})
it('rejects ambiguous ask create/resume input before RPC', async () => {
process.env.ORCA_TERMINAL_HANDLE = 'term_worker'
await expect(
invokeAsk(
new Map<string, string | boolean>([
['question', 'new'],
['resume', 'msg_old']
])
)
).rejects.toMatchObject({ code: 'invalid_argument' })
expect(callMock).not.toHaveBeenCalled()
})
})
@@ -1,70 +0,0 @@
import { afterEach, describe, expect, it, vi } from 'vitest'
import type { RuntimeClient } from '../../runtime-client'
import { RuntimeClientError } from '../../runtime-client'
import { callOrchestrationMutation } from './mutation-request'
const RETRY_MS = 120_000
const WORKER_DONE = {
from: 'term_worker',
subject: 'done',
type: 'worker_done',
payload: '{"taskId":"task_1","dispatchId":"ctx_1","outcome":"succeeded"}'
}
afterEach(async () => {
vi.useRealTimers()
})
type CallOptions = { orchestrationRequestId?: string }
function fakeClient(respond: (attempt: number, options?: CallOptions) => unknown): {
client: RuntimeClient
requestIds: (string | undefined)[]
} {
const requestIds: (string | undefined)[] = []
const call = vi.fn(async (_method: string, _params: unknown, options?: CallOptions) => {
requestIds.push(options?.orchestrationRequestId)
return respond(requestIds.length, options)
})
// oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: callOrchestrationMutation only uses client.call.
return { client: { call } as unknown as RuntimeClient, requestIds }
}
function unavailable(options?: CallOptions): RuntimeClientError {
return new RuntimeClientError(
'runtime_unavailable',
'Could not connect to the running Orca app.',
{
orchestrationRequestId: options?.orchestrationRequestId,
originalCommand: ['orca', 'orchestration', 'send', '--type', 'worker_done']
}
)
}
describe('callOrchestrationMutation runtime_unavailable retry', () => {
it('keeps the recovery command when the last attempt fails before its request id is attached', async () => {
vi.useFakeTimers()
const { client, requestIds } = fakeClient((attempt, options) => {
throw attempt === 1
? unavailable(options)
: new RuntimeClientError('runtime_unavailable', 'No runtime metadata.')
})
const settled = callOrchestrationMutation(
client,
new Map(),
'orchestration.send',
WORKER_DONE,
undefined,
RETRY_MS
).catch((error: unknown) => error)
await vi.advanceTimersByTimeAsync(RETRY_MS + 30_000)
expect(await settled).toMatchObject({
data: { recovery: { orchestrationRequestId: requestIds[0] } }
})
})
// Windows cannot use this temporary Unix socket path.
// Windows cannot use this temporary Unix socket path.
})
@@ -1,294 +0,0 @@
import { describe, expect, it } from 'vitest'
import type { OrchestrationFleetWorker } from '../../../shared/orchestration/fleet/orchestration-fleet-projection'
import type {
NativeChatBlock,
NativeChatMessage,
NativeChatSubagentEntry
} from '../../../shared/native-chat/native-chat-types'
import type { OrchestrationWorkerReadResult } from '../../../shared/orchestration/workers/orchestration-worker-output'
import { formatWorkerRead, formatWorkerRelease, formatWorkerStart } from './worker-output'
function fleetProjection(verdict: 'live' | 'unverifiable' | 'exited'): OrchestrationFleetWorker {
return {
id: 'dispatch_1',
dispatchId: 'dispatch_1',
taskId: 'task_1',
runId: 'run_1',
role: 'worker',
parent: null,
provider: { id: 'codex', model: null },
host: { kind: 'local', id: 'local' },
workspace: { id: 'ws_1', kind: 'folder_or_worktree' },
stage: { worker: 'ready', dispatch: 'dispatched', detail: null, activity: 'working' },
outcome: 'in_progress',
liveness:
verdict === 'live'
? { verdict, observedAt: 1, source: 'agent_status' }
: verdict === 'exited'
? { verdict, source: 'execution_host' }
: { verdict, reason: 'missing_status' },
evidence: { durable: true, liveStatus: 'fresh', lastObservedAt: 1 },
resource: {
state: 'owned',
id: 'wtr_1',
ownerDispatchId: 'dispatch_1',
releaseState: 'active',
terminalState: null
},
nextAction: { kind: 'inspect', argv: [] },
attention: { categories: [], requiresAction: false }
}
}
describe('worker-start plain formatting', () => {
it('renders partial effects, residual resources, and exact recovery commands for unknown starts', () => {
const nextCommands = [
'orca orchestration worker-show --dispatch ctx_unknown --json',
'orca orchestration worker-abandon --dispatch ctx_unknown --json'
]
expect(
formatWorkerStart({
taskId: 'task_1',
dispatchId: 'ctx_unknown',
state: 'outcome_unknown',
failedStage: 'dispatch_input',
lastError: 'submission could not be observed',
effects: [{ kind: 'terminal', id: 'term_worker' }],
residualResources: [{ kind: 'terminal', id: 'term_worker' }],
nextCommands
})
).toBe(
'Worker ctx_unknown [outcome_unknown] for task_1\n' +
'dispatch_input: submission could not be observed\n' +
'Effects: [{"kind":"terminal","id":"term_worker"}]\n' +
'Residual resources: [{"kind":"terminal","id":"term_worker"}]\n' +
`Next command: ${nextCommands[0]}\n` +
`Next command: ${nextCommands[1]}`
)
})
it('renders nonempty effects and residual resources for failed starts', () => {
expect(
formatWorkerStart({
taskId: 'task_1',
dispatchId: 'ctx_failed',
state: 'failed',
failedStage: 'terminal_create',
lastError: 'terminal creation failed',
effects: [{ kind: 'worktree', id: 'worktree_1' }],
residualResources: [{ kind: 'worktree', id: 'worktree_1' }]
})
).toBe(
'Worker ctx_failed [failed] for task_1\n' +
'terminal_create: terminal creation failed\n' +
'Effects: [{"kind":"worktree","id":"worktree_1"}]\n' +
'Residual resources: [{"kind":"worktree","id":"worktree_1"}]'
)
})
})
describe('worker-read plain formatting', () => {
it('separates the PTY verdict from the fleet agent verdict', () => {
const output = formatWorkerRead({
dispatchId: 'dispatch_1',
status: { worker: 'ready', terminal: 'running', liveness: 'live' },
projection: fleetProjection('unverifiable'),
source: 'terminal',
sourceIdentity: 'private-source-identity',
terminal: {
handle: 'term_worker',
status: 'running',
tail: ['tail'],
truncated: false,
nextCursor: null
},
cursor: null,
fallbackReason: null,
warnings: []
})
expect(output).toContain('Terminal liveness: live')
expect(output).toContain('Agent liveness: unverifiable')
expect(output).not.toMatch(/^Liveness:/mu)
})
it('omits the agent verdict when the host published no projection', () => {
const output = formatWorkerRead({
dispatchId: 'dispatch_1',
status: { worker: 'ready', terminal: 'running', liveness: 'live' },
source: 'terminal',
sourceIdentity: 'private-source-identity',
terminal: {
handle: 'term_worker',
status: 'running',
tail: ['tail'],
truncated: false,
nextCursor: null
},
cursor: null,
fallbackReason: null,
warnings: []
})
expect(output).toContain('Terminal liveness: live')
expect(output).not.toContain('Agent liveness:')
})
it('distinguishes a released archive read from a live one', () => {
const output = formatWorkerRead({
dispatchId: 'dispatch_1',
status: { worker: 'succeeded', terminal: 'exited', liveness: 'unverifiable' },
source: 'terminal',
sourceIdentity: 'private-source-identity',
terminal: {
handle: 'term_worker',
status: 'exited',
tail: ['archived tail'],
truncated: false,
nextCursor: null
},
cursor: null,
fallbackReason: null,
warnings: [],
archived: true
})
expect(output).toContain('Archived: true')
expect(output).toContain('Terminal liveness: unverifiable')
expect(output).toContain('Worker: succeeded')
})
})
function transcriptRead(
blocks: NativeChatBlock[],
role: NativeChatMessage['role'] = 'assistant'
): OrchestrationWorkerReadResult {
const message: NativeChatMessage = {
id: 'm1',
role,
blocks,
timestamp: 1,
source: 'transcript'
}
return {
dispatchId: 'd1',
source: 'transcript',
sourceIdentity: 'pane:1',
provider: 'codex',
transcript: { messages: [message], nextCursor: '1', limited: false, returnedMessageCount: 1 },
cursor: '1',
status: { worker: 'running', terminal: 'running' },
fallbackReason: null,
warnings: []
}
}
describe('formatWorkerRead', () => {
// Replayed journal rows cannot prove current child liveness.
// Producers emit a text twin for clients that cannot render roster blocks; print only one copy.
// Unknown roster states can change recomputed text; preserve the producer's twin without duplicating it.
it('prints the roster once when the twin names a state this build cannot reproduce', () => {
const frozenTwin = 'Ran 2 subagents (1 cancelled)'
const output = formatWorkerRead(
transcriptRead(
[
{ type: 'text', text: frozenTwin },
{
type: 'subagent-group',
groupId: 'thread:turn-1',
// SAFETY: This fixture models a newer host's unrecognized state at the RPC boundary.
agents: [
{ id: 'child-1', label: 'read', state: 'completed' },
{ id: 'child-2', label: 'edit', state: 'cancelled' }
] as unknown as NativeChatSubagentEntry[]
}
],
'system'
)
)
expect(output).toContain(`[system] ${frozenTwin}`)
expect(output).not.toContain('[subagents]')
expect(output).not.toContain('unverifiable')
})
// RPC results are not schema-validated here, so newer hosts' unknown block types reach the formatter.
it('degrades an unknown block type from a newer host instead of throwing', () => {
const output = formatWorkerRead(
transcriptRead([
{ type: 'text', text: 'before' },
// SAFETY: This fixture models a newer host's unrecognized block at the RPC boundary.
{ type: 'plan-step', title: 'ship it' } as unknown as NativeChatBlock,
{ type: 'text', text: 'after' }
])
)
expect(output).toContain('[assistant] before\n[unsupported block]\nafter')
})
})
describe('worker output compatibility and release receipts', () => {
it('renders transcript blocks and survives unserializable tool input', () => {
const circular: { self?: unknown } = {}
circular.self = circular
expect(
formatWorkerRead({
dispatchId: 'dispatch_1',
source: 'transcript',
sourceIdentity: 'pane:1',
provider: 'codex',
status: { worker: 'ready', terminal: 'running' },
transcript: {
messages: [
{
id: 'message_1',
role: 'assistant',
blocks: [
{ type: 'text', text: 'working' },
{ type: 'tool-call', name: 'inspect', input: circular },
{ type: 'tool-result', output: 'failed', isError: true },
{ type: 'image-ref', url: 'https://example.test/proof.png' }
],
timestamp: null,
source: 'transcript'
}
],
nextCursor: 'owr1_next',
limited: false,
returnedMessageCount: 1
},
cursor: 'owr1_next',
fallbackReason: null,
warnings: []
})
).toBe(
'Source: transcript (provider=codex)\n' +
'Worker: ready\n' +
'Archived: false\n' +
'Continuation cursor (opaque; pass unchanged to --cursor): owr1_next\n\n' +
'[assistant] working\n[tool inspect] [unserializable input]\n[tool result error] failed\n[image] https://example.test/proof.png'
)
})
it('renders release evidence in receipt order', () => {
expect(
formatWorkerRelease({
dispatchId: 'dispatch_1',
state: 'release_unknown',
reason: 'host_unreachable',
processAction: 'unverifiable',
archive: { source: 'transcript', status: 'saved' },
lastError: 'transport closed',
recovery: 'Reconnect and retry.'
})
).toBe(
'Worker dispatch_1 terminal [release_unknown] reason=host_unreachable process=unverifiable\n' +
'archive transcript [saved]\ntransport closed\nReconnect and retry.'
)
})
})
-94
View File
@@ -1,11 +1,9 @@
import { afterEach, describe, expect, it, vi } from 'vitest'
import { SEARCH_HANDLERS } from './search'
import { AiVaultSearchResponseSchema } from '../../shared/ai-vault/search/ai-vault-search-contract'
import type {
AiVaultSearchResponse,
AiVaultSearchStatus
} from '../../shared/ai-vault/search/ai-vault-search-types'
import { RuntimeClientError } from '../runtime/types'
import { RuntimeClient } from '../runtime-client'
import { okFixture } from '../test-fixtures'
@@ -90,22 +88,6 @@ async function runSearch(
return { call, output: lines.join('\n') }
}
function printedEnvelope(output: string): { keys: string[]; result: unknown } {
const parsed: unknown = JSON.parse(output)
if (typeof parsed !== 'object' || parsed === null || !('result' in parsed)) {
throw new Error(`Not an RPC envelope: ${output}`)
}
return { keys: Object.keys(parsed), result: parsed.result }
}
function printedResults(output: string): Extract<AiVaultSearchResponse, { kind: 'results' }> {
const parsed = AiVaultSearchResponseSchema.parse(printedEnvelope(output).result)
if (parsed.kind !== 'results') {
throw new Error(`Expected results, got ${parsed.kind}`)
}
return parsed
}
describe('orca search over the runtime RPC', () => {
it('raises a malformed cursor through the CLI error channel', async () => {
await expect(
@@ -121,80 +103,4 @@ describe('orca search over the runtime RPC', () => {
message: expect.stringContaining('re-run the search without --cursor')
})
})
it('answers a host with no such method as unavailable rather than a raw error', async () => {
const { output } = await runSearch([['query', 'q']], {
error: new RuntimeClientError('method_not_found', 'Unknown method aiVault.searchSessions')
})
expect(output).toContain('This host runs no session search service.')
})
it('answers an old host asked for status with the absent-service sentinel', async () => {
const { output } = await runSearch([['index-status', true]], {
error: new RuntimeClientError('method_not_found', 'Unknown method aiVault.searchStatus')
})
expect(output).toContain('enabled: false')
expect(output).toContain('phase: idle')
})
it('propagates a transport failure instead of calling it unavailable', async () => {
await expect(
runSearch([['query', 'q']], {
error: new RuntimeClientError('runtime_unavailable', 'Orca is not running.')
})
).rejects.toThrow('Orca is not running.')
})
it('applies the paired-client exposure policy for a remote runtime', async () => {
const { output } = await runSearch([['query', 'q']], { isRemote: true, json: true })
expect(printedResults(output).hits[0]).not.toHaveProperty('resumeCommand')
expect(printedResults(output).hits[0]?.source).toEqual({ presence: 'present' })
})
it('keeps the local resume command and source path for a same-machine host', async () => {
const { output } = await runSearch([['query', 'q']], { json: true })
expect(printedResults(output).hits[0]?.resumeCommand).toBe('claude --resume session-1')
expect(printedResults(output).hits[0]?.source).toEqual({
presence: 'present',
filePath: '/transcripts/session-1.jsonl'
})
})
})
describe('orca search --json', () => {
it('drops the debug block the caller did not ask for', async () => {
const withDebug = {
...resultsResponse,
debug: {
route: 'phrase' as const,
plannerReport: { route: 'phrase' as const, scope: 'all' as const }
}
}
const { output } = await runSearch([['query', 'q']], { json: true, result: withDebug })
expect(printedEnvelope(output).result).not.toHaveProperty('debug')
})
it('keeps the debug block the caller asked for', async () => {
const withDebug = {
...resultsResponse,
debug: {
route: 'phrase' as const,
plannerReport: { route: 'phrase' as const, scope: 'all' as const }
}
}
const { output } = await runSearch(
[
['query', 'q'],
['debug', true]
],
{ json: true, result: withDebug }
)
expect(printedResults(output).debug).toEqual(withDebug.debug)
})
})
-50
View File
@@ -72,18 +72,6 @@ describe('orca serve service', () => {
await expect(installServeService({ command: null, dryRun: false }, d)).rejects.toThrow(/denied/)
})
it('validates and normalizes --bind before installing a service', async () => {
const d = deps('darwin')
await expect(
installServeService({ command: null, bind: 'server.example', dryRun: true }, d)
).rejects.toThrow(/--bind expects a literal IP address/)
expect(calls).toEqual([])
const dry = await installServeService({ command: null, bind: 'localhost', dryRun: true }, d)
expect(String(dry.content)).toContain('<string>--bind</string>')
expect(String(dry.content)).toContain('<string>127.0.0.1</string>')
})
it('reports live, exited and unverifiable from the manager', async () => {
const d = deps('darwin')
const dry = await installServeService({ command: null, dryRun: true }, d)
@@ -145,44 +133,6 @@ describe('orca serve service', () => {
).toThrow(/PATH/)
})
it('refuses Windows and a relative --command', async () => {
await expect(
installServeService({ command: null, dryRun: true }, deps('win32'))
).rejects.toThrow(/Windows/)
expect(() => resolveServiceCommand('orca', { platform: 'darwin', env: {} })).toThrow()
expect(() =>
resolveServiceCommand(null, { platform: 'darwin', env: { PATH: '/nonexistent' } })
).toThrow(/PATH/)
})
it('names the command to run when only a server-only orca exists here', async () => {
// SSH server launchers run on plain Node, without an installed Electron desktop.
const serverCli = (platform: NodeJS.Platform, path: string): ServeServiceDeps => {
const base = deps(platform)
const { ELECTRON_RUN_AS_NODE: _electron, ...env } = base.env
return { ...base, env: { ...env, PATH: path } }
}
const scoped = join(home, 'profile', 'cli', 'bin')
await mkdir(scoped, { recursive: true })
await writeFile(join(scoped, 'orca'), '#!/bin/sh\n')
await chmod(join(scoped, 'orca'), 0o755)
await expect(
installServeService({ command: null, dryRun: false }, serverCli('linux', scoped))
).rejects.toThrow(/install the Orca app.*`orca-ide serve service install`/i)
await expect(
installServeService({ command: null, dryRun: true }, serverCli('darwin', scoped))
).rejects.toThrow(/`orca serve service install`/)
expect(calls).toEqual([])
await expect(
installServeService({ command: null, dryRun: true }, serverCli('linux', `${scoped}:${bin}`))
).resolves.toMatchObject({ dryRun: true })
await expect(
installServeService(
{ command: join(bin, 'orca-ide'), dryRun: true },
serverCli('linux', scoped)
)
).resolves.toMatchObject({ dryRun: true })
})
it('keeps an AppImage launch and profile directories out of the unit PATH (#36000)', async () => {
const profileBin = join(home, 'profile', 'cli', 'bin')
const d = deps('linux')
-116
View File
@@ -1,116 +0,0 @@
import { afterEach, describe, expect, it, vi } from 'vitest'
const {
callMock,
runtimeClientConstructorMock,
serveOrcaAppMock,
getDefaultUserDataPathMock,
addEnvironmentFromPairingCodeMock,
listEnvironmentsMock,
spawnMock
} = vi.hoisted(() => ({
callMock: vi.fn(),
runtimeClientConstructorMock: vi.fn(),
serveOrcaAppMock: vi.fn(),
getDefaultUserDataPathMock: vi.fn(() => '/tmp/orca-user-data'),
addEnvironmentFromPairingCodeMock: vi.fn(),
listEnvironmentsMock: vi.fn(),
spawnMock: vi.fn()
}))
vi.mock('./runtime-client', async () => {
const { createRuntimeClientModuleMock } = await import('./index-test-harness.js')
return createRuntimeClientModuleMock({
callMock,
runtimeClientConstructorMock,
serveOrcaAppMock,
getDefaultUserDataPathMock
})
})
vi.mock('./runtime/environments', () => ({
addEnvironmentFromPairingCode: addEnvironmentFromPairingCodeMock,
removeEnvironment: vi.fn(),
resolveEnvironment: vi.fn()
}))
vi.mock('../shared/remote-runtime/host-store/runtime-environment-store', () => ({
listEnvironments: listEnvironmentsMock
}))
vi.mock('child_process', async () => {
const { createChildProcessModuleMock } = await import('./index-test-harness.js')
return createChildProcessModuleMock(spawnMock)
})
import { main } from './index'
import { okFixture, queueFixtures } from './test-fixtures'
import { useWorktreeAwarenessEnvironment } from './index-test-harness'
import { AUTOMATION_SETUP_CHOICE_RUNTIME_CAPABILITY } from '../shared/automations/automation-runtime-capabilities'
const supported = okFixture('status', {
capabilities: [AUTOMATION_SETUP_CHOICE_RUNTIME_CAPABILITY]
})
describe('automation setup CLI contract', () => {
const originalExitCode = process.exitCode
afterEach(() => {
process.exitCode = originalExitCode
})
useWorktreeAwarenessEnvironment({
callMock,
serveOrcaAppMock,
getDefaultUserDataPathMock,
addEnvironmentFromPairingCodeMock,
listEnvironmentsMock,
spawnMock
})
const createArgs = [
'automations',
'create',
'--name',
'Daily checks',
'--trigger',
'daily',
'--prompt',
'Check changes',
'--provider',
'codex',
'--repo',
'id:repo-1',
'--json'
]
it.each(['inherit', '', 'true'])(
'rejects unsupported --setup=%s before a mutation',
async (setup) => {
const output = vi.spyOn(console, 'log').mockImplementation(() => {})
await main([...createArgs, `--setup=${setup}`], '/tmp/repo')
expect(process.exitCode).toBe(1)
expect(callMock).not.toHaveBeenCalled()
expect(JSON.parse(String(output.mock.calls.at(-1)?.[0])).error.message).toContain('--setup')
}
)
it('accepts setup while switching an existing automation to new-per-run', async () => {
queueFixtures(
callMock,
supported,
okFixture('current', { automation: { id: 'a1', workspaceMode: 'existing' } }),
okFixture('updated', { automation: { id: 'a1', setupDecision: 'run' } })
)
vi.spyOn(console, 'log').mockImplementation(() => {})
await main(
['automations', 'edit', 'a1', '--workspace-mode', 'new-per-run', '--setup', 'run', '--json'],
'/tmp/repo'
)
expect(callMock).toHaveBeenLastCalledWith(
'automation.update',
expect.objectContaining({
updates: expect.objectContaining({ workspaceMode: 'new_per_run', setupDecision: 'run' })
})
)
// An explicit switch is the user's own choice, so it carries no stored-mode precondition.
expect(callMock.mock.calls.at(-1)?.[1]).not.toHaveProperty('expectedWorkspaceMode')
})
})
-156
View File
@@ -1,156 +0,0 @@
import { afterEach, describe, expect, it, vi } from 'vitest'
const {
callMock,
runtimeClientConstructorMock,
serveOrcaAppMock,
getDefaultUserDataPathMock,
addEnvironmentFromPairingCodeMock,
listEnvironmentsMock,
spawnMock
} = vi.hoisted(() => ({
callMock: vi.fn(),
runtimeClientConstructorMock: vi.fn(),
serveOrcaAppMock: vi.fn(),
getDefaultUserDataPathMock: vi.fn(() => '/tmp/orca-user-data'),
addEnvironmentFromPairingCodeMock: vi.fn(),
listEnvironmentsMock: vi.fn(),
spawnMock: vi.fn()
}))
vi.mock('./runtime-client', async () => {
const { createRuntimeClientModuleMock } = await import('./index-test-harness.js')
return createRuntimeClientModuleMock({
callMock,
runtimeClientConstructorMock,
serveOrcaAppMock,
getDefaultUserDataPathMock
})
})
vi.mock('./runtime/environments', () => ({
addEnvironmentFromPairingCode: addEnvironmentFromPairingCodeMock,
listEnvironments: listEnvironmentsMock,
removeEnvironment: vi.fn(),
resolveEnvironment: vi.fn()
}))
vi.mock('child_process', async () => {
const { createChildProcessModuleMock } = await import('./index-test-harness.js')
return createChildProcessModuleMock(spawnMock)
})
import { main } from './index'
import { okFixture } from './test-fixtures'
import { pairRuntimeEnvironment, useWorktreeAwarenessEnvironment } from './index-test-harness'
const KEPT = { id: 'ssh-1783599077486-fyasux', label: 'trader-local' }
const STALE = { id: 'ssh-1783600000000-abcdef', label: 'ticket-vm-42' }
/** Serve the target list and record removals, as the runtime's ssh RPC methods do. */
function fakeSshRuntime(): { removed: string[] } {
const removed: string[] = []
callMock.mockImplementation(async (method: string, params?: { targetId: string }) => {
if (method === 'ssh.listTargetSummaries') {
return okFixture('req_ssh_targets', { targets: [KEPT, STALE] })
}
if (method === 'ssh.removeTarget' && params) {
removed.push(params.targetId)
return okFixture('req_ssh_remove', { removed: true })
}
throw new Error(`unexpected call ${method}`)
})
return { removed }
}
function printedJson(logSpy: { mock: { calls: unknown[][] } }): {
ok: boolean
result?: unknown
error?: { code: string; message: string }
} {
return JSON.parse(String(logSpy.mock.calls[0]?.[0]))
}
describe('orca host rm', () => {
const priorExitCode = process.exitCode
afterEach(() => {
process.exitCode = priorExitCode
})
useWorktreeAwarenessEnvironment({
callMock,
serveOrcaAppMock,
getDefaultUserDataPathMock,
addEnvironmentFromPairingCodeMock,
listEnvironmentsMock,
spawnMock
})
it('removes only the named SSH target through ssh.removeTarget and prints it', async () => {
const runtime = fakeSshRuntime()
const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
await main(['host', 'rm', '--host', `ssh:${STALE.id}`, '--json'], '/tmp/repo')
expect(runtime.removed).toEqual([STALE.id])
expect(printedJson(logSpy)).toMatchObject({
ok: true,
result: { removed: { kind: 'ssh', name: STALE.label, id: STALE.id } },
_meta: { runtimeId: 'runtime-1' }
})
})
it.each([
['local', 'This machine is always listed'],
['this machine', 'This machine is always listed'],
['runtime:env-m4air', 'orca environment rm'],
['m4air', '--host ssh:<target-id>']
])('refuses --host %s before it reaches the runtime', async (host, nextStep) => {
pairRuntimeEnvironment(listEnvironmentsMock, 'env-m4air', 'm4air')
const runtime = fakeSshRuntime()
const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
await main(['host', 'rm', '--host', host, '--json'], '/tmp/repo')
const printed = printedJson(logSpy)
expect(printed.ok).toBe(false)
expect(printed.error?.code).toBe('invalid_argument')
expect(printed.error?.message).toContain('removes saved SSH targets only')
expect(JSON.stringify(printed)).toContain(nextStep)
expect(runtime.removed).toEqual([])
expect(callMock).not.toHaveBeenCalled()
expect(process.exitCode).toBe(1)
})
it.each([
['environment', 'm4air'],
['pairing-code', 'orca://pair?code=x']
])('refuses --%s rather than removing the target on another machine', async (flag, value) => {
pairRuntimeEnvironment(listEnvironmentsMock, 'env-m4air', 'm4air')
const runtime = fakeSshRuntime()
const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
await main(
['host', 'rm', '--host', `ssh:${STALE.id}`, `--${flag}`, value, '--json'],
'/tmp/repo'
)
const printed = printedJson(logSpy)
expect(printed.error?.code).toBe('invalid_argument')
expect(printed.error?.message).toContain(`\`--${flag}\` does not retarget \`orca host rm\``)
expect(runtime.removed).toEqual([])
expect(process.exitCode).toBe(1)
})
it('refuses an id the runtime does not have, and does not match a label', async () => {
const runtime = fakeSshRuntime()
const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
await main(['host', 'rm', '--host', `ssh:${STALE.label}`, '--json'], '/tmp/repo')
const printed = printedJson(logSpy)
expect(printed.error?.code).toBe('invalid_argument')
expect(printed.error?.message).toContain(`Unknown SSH target in --host ssh:${STALE.label}`)
expect(runtime.removed).toEqual([])
expect(process.exitCode).toBe(1)
})
})
@@ -1,258 +0,0 @@
import type * as RuntimeEnvironmentStore from '../shared/remote-runtime/host-store/runtime-environment-store'
import { beforeAll, describe, expect, it, vi } from 'vitest'
import type * as ChildProcess from 'node:child_process'
const {
callMock,
runtimeClientConstructorMock,
serveOrcaAppMock,
getDefaultUserDataPathMock,
addEnvironmentFromPairingCodeMock,
listEnvironmentsMock,
spawnMock
} = vi.hoisted(() => ({
callMock: vi.fn(),
runtimeClientConstructorMock: vi.fn(),
serveOrcaAppMock: vi.fn(),
getDefaultUserDataPathMock: vi.fn(() => '/tmp/orca-user-data'),
addEnvironmentFromPairingCodeMock: vi.fn(),
listEnvironmentsMock: vi.fn(),
spawnMock: vi.fn()
}))
vi.mock('./runtime-client', async () => {
const { createRuntimeClientModuleMock } = await import('./index-test-harness.js')
return createRuntimeClientModuleMock({
callMock,
runtimeClientConstructorMock,
serveOrcaAppMock,
getDefaultUserDataPathMock
})
})
vi.mock('./runtime/environments', () => ({
addEnvironmentFromPairingCode: addEnvironmentFromPairingCodeMock,
removeEnvironment: vi.fn(),
resolveEnvironment: vi.fn()
}))
vi.mock(
'../shared/remote-runtime/host-store/runtime-environment-store',
async (importOriginal) => ({
...(await importOriginal<typeof RuntimeEnvironmentStore>()),
listEnvironments: listEnvironmentsMock
})
)
vi.mock('child_process', async (importOriginal) => {
const actual = await importOriginal<typeof ChildProcess>()
const { createChildProcessModuleMock } = await import('./index-test-harness.js')
return { ...actual, ...createChildProcessModuleMock(spawnMock) }
})
import { main } from './index'
import type {
RuntimeAgentLineageTestModule,
RuntimeAgentLineageCatalogTestModule
} from '../shared/runtime-agent-lineage-consumer.test-fixture'
import { COMMAND_SPECS } from './specs/index'
import { okFixture, queueFixtures } from './test-fixtures'
import { pairRuntimeEnvironment, useWorktreeAwarenessEnvironment } from './index-test-harness'
let lineage: RuntimeAgentLineageTestModule
let catalog: RuntimeAgentLineageCatalogTestModule
// The CLI's Node16 program needs a hook; each test still creates its own DB and runtime.
beforeAll(async () => {
lineage = (
await vi.importActual<{ default: RuntimeAgentLineageTestModule }>(
'../main/runtime/workspaces/process-listing/runtime-agent-lineage.test-fixture'
)
).default
catalog = (
await vi.importActual<{ default: RuntimeAgentLineageCatalogTestModule }>(
'../main/runtime/workspaces/process-listing/runtime-agent-lineage-catalog.test-fixture'
)
).default
})
const TERMINAL_ROW = {
handle: 'term_1',
ptyId: 'pty-1',
worktreeId: 'repo::/wt',
worktreePath: '/wt',
branch: 'main',
tabId: 'tab-1',
leafId: 'leaf-1',
title: 'worker',
connected: true,
writable: true,
lastOutputAt: null,
preview: '',
executionHostId: 'local'
}
describe('omittedHostIds selector annotation', () => {
useWorktreeAwarenessEnvironment({
callMock,
serveOrcaAppMock,
getDefaultUserDataPathMock,
addEnvironmentFromPairingCodeMock,
listEnvironmentsMock,
spawnMock
})
it.each(['repo::/workspace', 'folder:lineage'])(
'prints canonical production-built lineage through actual CLI and worktree RPC for %s',
async (worktreeId) => {
const { publicLineageFixture, canonicalChatRow, LINEAGE_PARENT, LINEAGE_CHILD } = lineage
const f = publicLineageFixture(worktreeId)
try {
const dispatcher = catalog.createLineageCatalogDispatcher(f.build)
const resultOf = (response: unknown) => JSON.parse(JSON.stringify(response)).result
const request = (params = {}) =>
dispatcher.dispatch({
id: 'req_worktree_ps',
authToken: 'test',
method: 'worktree.ps',
params
})
const legacy = await request()
expect(legacy).toMatchObject({
ok: true,
result: {
worktrees: [
{
agents: [
{ parentPaneKey: null },
{
parentPaneKey: canonicalChatRow(LINEAGE_PARENT),
taskTitle: 'Build the worker result'
}
]
}
]
}
})
callMock.mockResolvedValueOnce(legacy)
const log = vi.spyOn(console, 'log').mockImplementation(() => {})
await main(['worktree', 'ps', '--json'], '/workspace')
const printed = JSON.parse(String(log.mock.calls[0]?.[0]))
expect(printed.result.worktrees[0].agents[1].paneKey).toBe(canonicalChatRow(LINEAGE_CHILD))
expect(JSON.stringify(printed)).not.toContain(f.privateHandle)
expect(JSON.stringify(printed)).not.toContain(f.privatePane)
const first = resultOf(await request({ afterSnapshotId: null }))
expect(resultOf(await request({ afterSnapshotId: first.snapshotId }))).toMatchObject({
unchanged: true
})
f.db.db
.prepare(
'UPDATE runs SET coordinator_orca_session_id = NULL, coordinator_orca_session_id_generation = NULL WHERE id = ?'
)
.run(f.run.id)
expect(resultOf(await request({ afterSnapshotId: first.snapshotId })).snapshotId).not.toBe(
first.snapshotId
)
log.mockRestore()
} finally {
f.db.close()
}
}
)
it('marks a stale runtime host that no caller can select', async () => {
pairRuntimeEnvironment(listEnvironmentsMock, 'env-paired', 'm4air')
queueFixtures(
callMock,
okFixture('req_terminal_list', {
terminals: [TERMINAL_ROW],
totalCount: 1,
truncated: false,
hostScope: {
hostIds: ['local'],
omittedHostIds: ['runtime:env-paired', 'runtime:env-retired']
}
})
)
const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
await main(['terminal', 'list', '--json'], '/tmp/repo')
const printed = JSON.parse(String(logSpy.mock.calls[0]?.[0]))
expect(printed.result.hostScope.omittedHostIds).toEqual([
'runtime:env-paired',
'runtime:env-retired'
])
expect(printed.result.hostScope.omittedHostSelectors).toEqual([
{ hostId: 'runtime:env-paired', selector: '--environment m4air' },
{ hostId: 'runtime:env-retired', selector: null }
])
})
it.each([
['terminal', 'list', 'req_terminal_list', { terminals: [TERMINAL_ROW] }],
['worktree', 'list', 'req_worktree_list', { worktrees: [] }],
['worktree', 'ps', 'req_worktree_ps', { worktrees: [] }]
] as const)(
'only suggests flags that `%s %s` accepts',
async (group, action, requestId, rows) => {
pairRuntimeEnvironment(listEnvironmentsMock, 'env-paired', 'm4air')
queueFixtures(
callMock,
okFixture(requestId, {
...rows,
totalCount: 1,
truncated: false,
hostScope: {
hostIds: [],
omittedHostIds: ['local', 'runtime:env-paired', 'ssh:box-1']
}
})
)
const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
await main([group, action, '--json'], '/tmp/repo')
const printed = JSON.parse(String(logSpy.mock.calls[0]?.[0]))
expect(printed.result.hostScope.omittedHostSelectors).toEqual([
{ hostId: 'local', selector: null },
{ hostId: 'runtime:env-paired', selector: '--environment m4air' },
{ hostId: 'ssh:box-1', selector: null }
])
const spec = COMMAND_SPECS.find(
(candidate) => candidate.path.join(' ') === `${group} ${action}`
)
for (const { selector } of printed.result.hostScope.omittedHostSelectors) {
if (selector) {
expect(spec?.allowedFlags).toContain(selector.split(' ')[0].replace(/^--/, ''))
}
}
// SSH hosts are reached through the answering runtime, without another target lookup.
expect(callMock).toHaveBeenCalledTimes(1)
}
)
})
describe('worktree listings report their host coverage', () => {
useWorktreeAwarenessEnvironment({
callMock,
serveOrcaAppMock,
getDefaultUserDataPathMock,
addEnvironmentFromPairingCodeMock,
listEnvironmentsMock,
spawnMock
})
it('does not claim a scope for `worktree ps` when the host reported none', async () => {
queueFixtures(
callMock,
okFixture('req_worktree_ps', { worktrees: [], totalCount: 0, truncated: false })
)
const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
await main(['worktree', 'ps'], '/tmp/repo')
const printed = String(logSpy.mock.calls[0]?.[0])
expect(printed).toContain('scope: unverifiable')
})
})
-95
View File
@@ -64,52 +64,6 @@ describe('orca cli worktree awareness', () => {
spawnMock
})
it.each([
{ questionFlag: '--question', questionValue: 'Proceed?', json: true },
{ questionFlag: '--resume', questionValue: 'msg_pending', json: false }
])('reports oversized ask waits before any request: %o', async (testCase) => {
process.env.ORCA_TERMINAL_HANDLE = 'term_worker'
callMock.mockResolvedValue({
id: 'req_ask',
ok: true,
result: { answer: 'yes', messageId: 'msg_1', threadId: 'msg_1', timedOut: false },
_meta: { runtimeId: 'runtime-1' }
})
const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
await main(
[
'orchestration',
'ask',
testCase.questionFlag,
testCase.questionValue,
'--timeout-ms',
'14400000',
...(testCase.json ? ['--json'] : [])
],
'/tmp/repo'
)
expect(process.exitCode).toBe(1)
expect(callMock).not.toHaveBeenCalled()
if (testCase.json) {
expect(logSpy).toHaveBeenCalledTimes(1)
expect(JSON.parse(logSpy.mock.calls[0][0])).toMatchObject({
ok: false,
error: {
code: 'invalid_argument',
message: expect.stringMatching(/--timeout-ms.*1800000.*30 minutes/)
}
})
} else {
expect(logSpy).not.toHaveBeenCalled()
}
expect(errorSpy).toHaveBeenCalledWith(
expect.stringMatching(/^error: invalid_argument: --timeout-ms.*1800000.*30 minutes/)
)
})
it("refuses an agent session's caller flag naming another caller before any request", async () => {
vi.stubEnv('ORCA_AGENT_SESSION_ID', 'f7a1c0de-1111-4222-8333-444455556666')
const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
@@ -122,53 +76,4 @@ describe('orca cli worktree awareness', () => {
error: { code: 'consumer_fenced' }
})
})
it('rejects no-flag orchestration reset before calling the runtime', async () => {
const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
await main(['orchestration', 'reset'], '/tmp/repo')
expect(errorSpy).toHaveBeenCalledExactlyOnceWith(
'error: invalid_argument: Choose exactly one reset scope: --all, --tasks, or --messages.'
)
expect(callMock).not.toHaveBeenCalled()
expect(process.exitCode).toBe(1)
})
it.each([
['orchestration', 'reset', '--tasks', '--messages'],
['orchestration', 'reset', '--all', '--tasks']
])('rejects conflicting reset scopes for $args', async (...args) => {
const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
await main([...args, '--json'], '/tmp/repo')
expect(JSON.parse(String(logSpy.mock.calls[0]?.[0]))).toMatchObject({
ok: false,
error: {
code: 'invalid_argument',
message: 'Choose exactly one reset scope: --all, --tasks, or --messages.'
}
})
expect(callMock).not.toHaveBeenCalled()
expect(process.exitCode).toBe(1)
})
it('rejects unknown task-update status with an enum-aware error', async () => {
process.env.ORCA_TERMINAL_HANDLE = 'term_coord'
const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
const errSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
await main(
['orchestration', 'task-update', '--id', 'task_x', '--status', 'complete'],
'/tmp/repo'
)
const output = [...errSpy.mock.calls, ...logSpy.mock.calls]
.flat()
.map((v) => (typeof v === 'string' ? v : JSON.stringify(v)))
.join('\n')
expect(output).toContain("invalid status 'complete'")
expect(output).toContain('pending, ready, dispatched, completed, failed, blocked')
expect(callMock).not.toHaveBeenCalled()
expect(process.exitCode).toBe(1)
})
})
-329
View File
@@ -1,4 +1,3 @@
import { RuntimeRpcFailureError, type RuntimeRpcFailure } from './runtime/types'
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
const {
@@ -45,14 +44,6 @@ vi.mock('child_process', async () => {
})
import { main } from './index'
import {
buildWorktree,
noFolderWorkspacesFixture,
okFixture,
queueFixtures,
queueNoFolderAtSelector,
worktreeListFixture
} from './test-fixtures'
import { useWorktreeAwarenessEnvironment } from './index-test-harness'
describe('orca cli worktree awareness', () => {
@@ -74,254 +65,6 @@ describe('orca cli worktree awareness', () => {
process.exitCode = originalExitCode
})
it.each([
[
'passes explicit focus through terminal.create',
{
title: 'RUNNER',
command: undefined,
flags: ['--focus'],
expected: { focus: true, presentation: 'focused' }
}
],
[
'keeps interactive Codex startup commands backgrounded unless focus is explicit',
{
title: 'Codex',
command: 'codex',
flags: [],
expected: { focus: false, rendererBacked: true, activate: false }
}
],
[
'keeps explicit focus semantics when forcing Codex through the renderer path',
{
title: 'Codex',
command: 'codex',
flags: ['--focus'],
expected: { focus: true, presentation: 'focused', rendererBacked: true, activate: true }
}
],
[
'does not force the visible terminal path for explicit Codex exec commands',
{
title: 'Codex exec',
command: 'codex exec summarize',
flags: [],
expected: { focus: false }
}
],
[
'does not force the visible terminal path for Codex exec commands after global options',
{
title: 'Codex exec',
command: 'codex -m gpt-5 --sandbox workspace-write exec summarize',
flags: [],
expected: { focus: false }
}
],
[
'does not force the visible terminal path for Codex review commands after long options',
{
title: 'Codex review',
command: 'codex --model=gpt-5 --sandbox=workspace-write review',
flags: [],
expected: { focus: false }
}
],
[
'does not force the visible terminal path for Codex help commands',
{
title: 'Codex help',
command: 'codex --help',
flags: [],
expected: { focus: false }
}
],
[
'keeps Codex prompts after global options backgrounded unless focus is explicit',
{
title: 'Codex prompt',
command: 'codex -m gpt-5 "fix the flaky test"',
flags: [],
expected: { focus: false, rendererBacked: true, activate: false }
}
],
[
'keeps interactive Claude startup commands backgrounded unless focus is explicit',
{
title: 'Claude',
command: 'claude',
flags: [],
expected: { focus: false, rendererBacked: true, activate: false }
}
],
[
'keeps Claude print commands on the background terminal path',
{
title: 'Claude print',
command: 'claude -p "summarize"',
flags: [],
expected: { focus: false }
}
]
] as const)('%s', async (_name, { title, command, flags, expected }) => {
queueNoFolderAtSelector(callMock)
queueFixtures(
callMock,
okFixture('req_terminal_create', {
terminal: {
handle: 'term_1',
worktreeId: 'repo-1::/tmp/repo/feature',
title
}
})
)
vi.spyOn(console, 'log').mockImplementation(() => {})
await main(
[
'terminal',
'create',
'--worktree',
'path:/tmp/repo/feature',
'--title',
title,
...(command === undefined ? [] : ['--command', command]),
...flags,
'--json'
],
'/tmp/repo'
)
expect(callMock).toHaveBeenLastCalledWith('terminal.create', {
worktree: 'path:/tmp/repo/feature',
command,
title,
...expected
})
expect(process.exitCode).toBeUndefined()
})
it('uses the resolved enclosing worktree for terminal consumers', async () => {
queueFixtures(
callMock,
worktreeListFixture([buildWorktree('/tmp/repo/feature', 'feature/foo')]),
noFolderWorkspacesFixture(),
okFixture('req_term', { terminals: [], totalCount: 0, truncated: false })
)
vi.spyOn(console, 'log').mockImplementation(() => {})
await main(['terminal', 'list', '--worktree', 'active', '--json'], '/tmp/repo/feature/src')
expect(callMock).toHaveBeenNthCalledWith(3, 'terminal.list', {
worktree: 'id:repo::/tmp/repo/feature',
limit: undefined,
includeVisualLayouts: false
})
})
it('requests visual layouts only for the human-readable terminal list', async () => {
queueFixtures(
callMock,
worktreeListFixture([buildWorktree('/tmp/repo/feature', 'feature/foo')]),
noFolderWorkspacesFixture(),
okFixture('req_term', { terminals: [], totalCount: 0, truncated: false })
)
vi.spyOn(console, 'log').mockImplementation(() => {})
await main(['terminal', 'list', '--worktree', 'active'], '/tmp/repo/feature/src')
expect(callMock).toHaveBeenNthCalledWith(
3,
'terminal.list',
expect.objectContaining({ includeVisualLayouts: true })
)
})
it('allows agent JSON clients to request visual layouts explicitly', async () => {
const visualLayouts = [
{
worktreeId: 'repo::/tmp/repo/feature',
worktreePath: '/tmp/repo/feature',
root: { type: 'group', groupId: null, activeTabId: null, tabs: [] }
}
]
queueFixtures(
callMock,
worktreeListFixture([buildWorktree('/tmp/repo/feature', 'feature/foo')]),
noFolderWorkspacesFixture(),
okFixture('req_term', {
terminals: [],
visualLayouts,
totalCount: 0,
truncated: false
})
)
const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
await main(
['terminal', 'list', '--worktree', 'active', '--include-visual-layouts', '--json'],
'/tmp/repo/feature/src'
)
expect(callMock).toHaveBeenNthCalledWith(
3,
'terminal.list',
expect.objectContaining({ includeVisualLayouts: true })
)
expect(JSON.parse(String(logSpy.mock.calls[0]?.[0]))).toMatchObject({
result: { visualLayouts }
})
})
it.each(
[[], ['--pairing-code', 'remote-runtime']].flatMap((remote) =>
[false, true].map((json) => ({ remote, json }))
)
)(
'prints the host failure through terminal create ($remote, json=$json)',
async ({ remote, json }) => {
const failure = {
id: 'start',
ok: false,
error: {
code: 'agent_session_exited_during_start',
message:
'Git Bash reported its limit of 128 open terminals on this PC while starting the terminal. Close some Git Bash terminals and try again.'
},
_meta: { runtimeId: 'host' }
} satisfies RuntimeRpcFailure
queueNoFolderAtSelector(callMock)
callMock.mockRejectedValueOnce(new RuntimeRpcFailureError(failure))
const log = vi.spyOn(console, 'log').mockImplementation(() => {})
const stderr = vi.spyOn(console, 'error').mockImplementation(() => {})
await main(
[
'terminal',
'create',
'--worktree',
'path:/tmp/host/workspace',
...remote,
...(json ? ['--json'] : [])
],
'/tmp/client'
)
expect(callMock).toHaveBeenCalledWith(
'terminal.create',
expect.objectContaining({ worktree: 'path:/tmp/host/workspace' })
)
if (json) {
expect(JSON.parse(String(log.mock.calls[0]?.[0]))).toEqual(failure)
expect(stderr).not.toHaveBeenCalled()
} else {
expect(stderr).toHaveBeenCalledExactlyOnceWith(failure.error.message)
expect(log).not.toHaveBeenCalled()
}
expect(process.exitCode).toBe(1)
}
)
it('rejects implicit remote terminal create instead of resolving from client cwd', async () => {
const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
const errSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
@@ -358,40 +101,6 @@ describe('orca cli worktree awareness', () => {
expect(process.exitCode).toBe(1)
})
it('sends explicit remote terminal create worktree selectors unchanged', async () => {
queueFixtures(
callMock,
okFixture('req_terminal_create', {
terminal: {
handle: 'term_1',
worktreeId: 'repo-1::/srv/orca/feature',
title: 'Server terminal'
}
})
)
vi.spyOn(console, 'log').mockImplementation(() => {})
await main(
[
'terminal',
'create',
'--worktree',
'id:repo-1::/srv/orca/feature',
'--pairing-code',
'remote-runtime',
'--json'
],
'/tmp/client/repo/src'
)
expect(callMock).toHaveBeenCalledWith('terminal.create', {
worktree: 'id:repo-1::/srv/orca/feature',
command: undefined,
title: undefined,
focus: false
})
})
it('exits nonzero when terminal wait returns an unsatisfied blocked result', async () => {
process.env.ORCA_TERMINAL_HANDLE = 'term_worker'
callMock.mockResolvedValueOnce({
@@ -429,42 +138,4 @@ describe('orca cli worktree awareness', () => {
expect(logSpy.mock.calls.flat().join('\n')).toContain('blockedReason: codex-cwd-prompt')
expect(process.exitCode).toBe(1)
})
it('does not force remote Codex terminal creates through a local renderer path', async () => {
queueFixtures(
callMock,
okFixture('req_terminal_create', {
terminal: {
handle: 'term_1',
worktreeId: 'repo-1::/srv/orca/feature',
title: 'Codex'
}
})
)
vi.spyOn(console, 'log').mockImplementation(() => {})
await main(
[
'terminal',
'create',
'--worktree',
'id:repo-1::/srv/orca/feature',
'--command',
'codex',
'--title',
'Codex',
'--pairing-code',
'remote-runtime',
'--json'
],
'/tmp/client/repo/src'
)
expect(callMock).toHaveBeenCalledWith('terminal.create', {
worktree: 'id:repo-1::/srv/orca/feature',
command: 'codex',
title: 'Codex',
focus: false
})
})
})
@@ -1,774 +0,0 @@
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
const {
callMock,
runtimeClientConstructorMock,
serveOrcaAppMock,
getDefaultUserDataPathMock,
addEnvironmentFromPairingCodeMock,
listEnvironmentsMock,
spawnMock
} = vi.hoisted(() => ({
callMock: vi.fn(),
runtimeClientConstructorMock: vi.fn(),
serveOrcaAppMock: vi.fn(),
getDefaultUserDataPathMock: vi.fn(() => '/tmp/orca-user-data'),
addEnvironmentFromPairingCodeMock: vi.fn(),
listEnvironmentsMock: vi.fn(),
spawnMock: vi.fn()
}))
vi.mock('./runtime-client', async () => {
const { createRuntimeClientModuleMock } = await import('./index-test-harness.js')
return createRuntimeClientModuleMock({
callMock,
runtimeClientConstructorMock,
serveOrcaAppMock,
getDefaultUserDataPathMock
})
})
vi.mock('./runtime/environments', () => ({
addEnvironmentFromPairingCode: addEnvironmentFromPairingCodeMock,
removeEnvironment: vi.fn(),
resolveEnvironment: vi.fn()
}))
vi.mock('../shared/remote-runtime/host-store/runtime-environment-store', () => ({
listEnvironments: listEnvironmentsMock
}))
vi.mock('child_process', async () => {
const { createChildProcessModuleMock } = await import('./index-test-harness.js')
return createChildProcessModuleMock(spawnMock)
})
import { main } from './index'
import { buildWorktree, okFixture, worktreeListFixture } from './test-fixtures'
import { useWorktreeAwarenessEnvironment } from './index-test-harness'
import { agentLaunchFixture, agentLaunchHostFixture } from './agent-launch-test-fixtures'
import { RuntimeRpcFailureError } from './runtime/types'
describe('cwd workspace ownership at the real CLI boundary', () => {
useWorktreeAwarenessEnvironment({
callMock,
serveOrcaAppMock,
getDefaultUserDataPathMock,
addEnvironmentFromPairingCodeMock,
listEnvironmentsMock,
spawnMock
})
beforeEach(() => {
vi.stubEnv('ORCA_AGENT_SESSION_ID', undefined)
vi.stubEnv('ORCA_STRUCTURED_SESSION', undefined)
})
afterEach(() => vi.unstubAllEnvs())
const root = buildWorktree('/tmp/owner-choice', 'main', 'abc', 'repo-a')
const sibling = { ...root, id: `${root.id}::workspace:11111111-1111-4111-8111-111111111111` }
const choices = [root, sibling].map(({ id }) => `id:${id}`)
const automation = [
'automations',
'create',
'--name',
'daily',
'--trigger',
'daily',
'--prompt',
'review',
'--provider',
'codex'
]
it.each([false, true])(
'refuses immediate consumers with exact recovery and no action (json=%s)',
async (json) => {
const log = vi.spyOn(console, 'log').mockImplementation(() => {})
const err = vi.spyOn(console, 'error').mockImplementation(() => {})
const prior = process.exitCode
const commands = [
['worktree', 'current'],
['worktree', 'show', '--worktree', 'current'],
['worktree', 'set', '--worktree', 'current', '--comment', 'keep'],
['worktree', 'set', '--worktree', choices[0]!, '--parent-worktree', 'active'],
...['active', 'current'].map((parent) => [
'worktree',
'create',
'--repo',
'id:repo-a',
'--name',
'child',
'--parent-worktree',
parent
]),
['snapshot'],
['snapshot', '--worktree', 'current'],
['tab', 'list'],
['terminal', 'read'],
['file', 'open', 'README.md'],
['emulator', 'list'],
automation,
['computer', 'get-app-state', '--app', 'fixture'],
['orchestration', 'check', '--peek'],
['orchestration', 'run-current'],
['terminal', 'stop', '--worktree', 'current'],
['terminal', 'close', '--all', '--worktree', 'current'],
[
'connector',
'start',
'--conversation',
'c',
'--delivery-id',
'd',
'--agent',
'codex',
'--prompt',
'hi',
'--worktree',
'current'
]
]
try {
for (const rows of [
[root, sibling],
[sibling, root]
]) {
for (const args of commands) {
callMock.mockReset()
log.mockClear()
err.mockClear()
process.exitCode = prior
callMock.mockResolvedValue(worktreeListFixture(rows))
await main([...args, ...(json ? ['--json'] : [])], root.path)
// Concise orchestration failures put the one-line error on stderr and the detail on stdout.
const output = (json ? log : err).mock.calls
.concat(json ? [] : log.mock.calls)
.flat()
.join('\n')
expect(process.exitCode, JSON.stringify({ args, output })).toBe(1)
if (json) {
expect(JSON.parse(output).error.code, JSON.stringify(args)).toBe('selector_ambiguous')
expect(JSON.parse(output).error.data.workspaces).toHaveLength(2)
}
for (const choice of choices) {
expect(output).toContain(choice)
}
const advice = json
? JSON.parse(output).error.data.nextSteps.join(' ')
: output.split('Next step:').slice(1).join(' ')
if (args[0] === 'orchestration') {
const steps = [
'This command needs your own caller identity; selecting a target workspace cannot supply it.',
'Run the command in your own live Orca terminal with ORCA_TERMINAL_HANDLE preserved.'
]
expect(
json
? JSON.parse(output).error.data.nextSteps
: output.split('\nNext step: ').slice(1)
).toEqual(steps)
expect(advice).not.toMatch(/--worktree|--parent-worktree|--from|worktree show/)
expect(
output.match(/More than one Orca workspace matched the current directory/g)
).toHaveLength(1)
expect(log).toHaveBeenCalledTimes(1)
expect(err.mock.calls).toEqual([
[
'error: selector_ambiguous: More than one Orca workspace matched the current directory. Choose an exact workspace.'
]
])
if (json) {
expect(JSON.parse(output).error.data.workspaces).toEqual(
rows.map((row) => ({
kind: 'worktree',
id: row.id,
path: row.path,
hostId: 'local',
selector: `id:${row.id}`
}))
)
} else {
expect(output.match(/Workspace choices \(JSON data\):/g)).toHaveLength(1)
}
} else {
expect(output).toContain('worktree show --worktree')
expect(advice).toContain(
args.includes('--parent-worktree')
? '--parent-worktree <selector>'
: args === automation
? '--workspace <selector>'
: args[1] === 'current'
? 'current has no replacement target flag'
: '--worktree <selector>'
)
}
if (!args.includes('--parent-worktree')) {
expect(advice).not.toContain('--parent-worktree')
}
expect(output).not.toContain('No Orca workspace matched')
expect(output).not.toContain('orca repo list')
expect(
callMock.mock.calls.map(([method]) => method),
JSON.stringify(args)
).toEqual(['worktree.list', 'folderWorkspace.list'])
}
}
} finally {
process.exitCode = prior
}
}
)
it.each([false, true])(
'recovers with the own caller before cwd inference (json=%s)',
async (json) => {
const log = vi.spyOn(console, 'log').mockImplementation(() => {})
const err = vi.spyOn(console, 'error').mockImplementation(() => {})
const prior = process.exitCode
const own = 'term_owner_choice'
const message = { id: 'message-own', from_handle: own, subject: 'own caller ready', read: 0 }
const run = { id: 'run-own', objective: 'own caller run' }
const controls = [
{
args: ['orchestration', 'check', '--peek'],
env: own,
method: 'orchestration.check',
identity: 'terminal'
},
{
args: ['orchestration', 'check', '--peek', '--terminal', own],
env: undefined,
method: 'orchestration.check',
identity: 'terminal'
},
{
args: ['orchestration', 'run-current'],
env: own,
method: 'orchestration.runCurrent',
identity: 'from'
},
{
args: ['orchestration', 'run-current', '--from', own],
env: undefined,
method: 'orchestration.runCurrent',
identity: 'from'
}
]
try {
for (const rows of [
[root, sibling],
[sibling, root]
]) {
for (const { args, env, method: action, identity } of controls) {
vi.stubEnv('ORCA_TERMINAL_HANDLE', env)
callMock.mockReset()
log.mockClear()
err.mockClear()
process.exitCode = prior
callMock.mockImplementation(async (method) => {
if (method === 'worktree.list') {
return worktreeListFixture(rows)
}
if (method === 'terminal.resolveIdentity') {
return okFixture('identity', { identity: { handle: own, live: true } })
}
return action === 'orchestration.check'
? okFixture('check', { messages: [message], count: 1 })
: okFixture('run', { run })
})
await main([...args, ...(json ? ['--json'] : [])], root.path)
const output = log.mock.calls.flat().join('\n')
expect(process.exitCode, JSON.stringify({ args, output })).toBe(prior)
expect(err).not.toHaveBeenCalled()
expect(callMock.mock.calls.map(([method]) => method)).toEqual(
env && identity === 'from' ? ['terminal.resolveIdentity', action] : [action]
)
if (env && identity === 'from') {
expect(callMock).toHaveBeenCalledWith('terminal.resolveIdentity', { terminal: own })
}
expect(callMock).toHaveBeenCalledWith(
action,
expect.objectContaining({ [identity]: own })
)
if (json) {
const response = JSON.parse(output)
expect(response.ok).toBe(true)
if (identity === 'terminal') {
expect(response.result.messages).toMatchObject([
{ id: message.id, from: own, subject: message.subject }
])
} else {
expect(response.result).toMatchObject({ runId: run.id, objective: run.objective })
}
} else {
expect(output).toContain(
identity === 'terminal' ? message.subject : `runId=${run.id}`
)
}
expect(callMock).not.toHaveBeenCalledWith('worktree.list', expect.anything())
expect(callMock).not.toHaveBeenCalledWith('terminal.resolveActive', expect.anything())
}
}
} finally {
process.exitCode = prior
}
}
)
it('preserves duplicate/unique/caller/nested elections and exact bypasses through printed output', async () => {
const log = vi.spyOn(console, 'log').mockImplementation(() => {})
const prior = process.exitCode
const nested = buildWorktree(`${root.path}/nested`, 'child', 'abc', root.repoId)
try {
for (const { rows, owner, caller } of [
{ rows: [root], owner: root },
{ rows: [root, { ...root }], owner: root },
{ rows: [root, sibling], owner: sibling, caller: sibling.id },
{ rows: [sibling, root], owner: sibling, caller: sibling.id },
{ rows: [root, nested], owner: nested, caller: root.id }
]) {
if (caller) {
process.env.ORCA_WORKTREE_ID = caller
} else {
delete process.env.ORCA_WORKTREE_ID
}
callMock.mockReset()
log.mockClear()
callMock.mockImplementation(async (method) =>
method === 'worktree.list'
? worktreeListFixture(rows)
: okFixture('show', { worktree: owner })
)
await main(['worktree', 'current', '--json'], `${owner.path}/src`)
expect(process.exitCode).toBe(prior)
expect(callMock).toHaveBeenCalledWith('worktree.show', { worktree: `id:${owner.id}` })
expect(JSON.parse(String(log.mock.calls[0]?.[0])).result.worktree.id).toBe(owner.id)
}
delete process.env.ORCA_WORKTREE_ID
for (const args of [
['worktree', 'show', '--worktree', choices[0]!],
['snapshot', '--page', 'page-1'],
['terminal', 'read', '--terminal', 'term-1']
]) {
callMock.mockReset()
log.mockClear()
callMock.mockResolvedValue(
okFixture('explicit', { worktree: root, terminal: { text: 'ready' }, snapshot: 'ready' })
)
await main([...args, '--json'], root.path)
expect(process.exitCode).toBe(prior)
expect(callMock).not.toHaveBeenCalledWith('worktree.list', expect.anything())
expect(log.mock.calls.flat().join('')).toContain('"ok": true')
}
} finally {
process.exitCode = prior
}
})
it('reaches exact and unique-current connector/start-stop-close results through main', async () => {
const log = vi.spyOn(console, 'log').mockImplementation(() => {})
const prior = process.exitCode
const cases = [
{
argv: [
'connector',
'start',
'--conversation',
'fixture',
'--delivery-id',
'delivery',
'--agent',
'codex',
'--prompt',
'hello'
],
method: 'connector.start',
result: { initial: { outcome: 'accepted' } },
text: 'started; prompt accepted'
},
{
argv: ['terminal', 'stop'],
method: 'terminal.stop',
result: { stopped: 3 },
text: 'Stopped 3 terminals.'
},
{
argv: ['terminal', 'close', '--all'],
method: 'terminal.closeAll',
result: { closed: 2, stopped: 3, retiredSurfaces: true },
text: 'Closed 2 terminal tabs and stopped 3 terminal processes.'
}
]
try {
for (const entry of cases) {
for (const exact of [true, false]) {
for (const json of [false, true]) {
callMock.mockReset()
log.mockClear()
callMock.mockImplementation(async (method) =>
method === 'worktree.list'
? worktreeListFixture(exact ? [root, sibling] : [root])
: okFixture(entry.method, entry.result)
)
await main(
[
...entry.argv,
'--worktree',
exact ? choices[0]! : 'current',
...(json ? ['--json'] : [])
],
root.path
)
expect(process.exitCode).toBe(prior)
const downstream = callMock.mock.calls.filter(([method]) => method === entry.method)
expect(downstream).toHaveLength(1)
expect(downstream[0]?.[1]).toMatchObject(
entry.method === 'connector.start'
? {
target: { kind: 'existing', worktree: choices[0] },
prompt: 'hello',
agent: 'codex'
}
: { worktree: choices[0] }
)
expect(
callMock.mock.calls.filter(([method]) => method === 'worktree.list')
).toHaveLength(exact ? 0 : 1)
const output = log.mock.calls.flat().join('\n')
if (json) {
expect(JSON.parse(output).result).toEqual(entry.result)
} else {
expect(output).toBe(entry.text)
}
}
}
}
} finally {
process.exitCode = prior
}
})
it('ignores stale or non-containing caller identities instead of breaking a positive owner tie', async () => {
const log = vi.spyOn(console, 'log').mockImplementation(() => {})
const prior = process.exitCode
const outside = buildWorktree('/tmp/outside-choice', 'main', 'abc', root.repoId)
try {
for (const caller of ['stale', outside.id]) {
for (const rows of [
[root, sibling, outside],
[outside, sibling, root]
]) {
process.env.ORCA_WORKTREE_ID = caller
callMock.mockReset()
log.mockClear()
process.exitCode = prior
callMock.mockResolvedValue(worktreeListFixture(rows))
await main(['worktree', 'current', '--json'], root.path)
expect(process.exitCode).toBe(1)
expect(
JSON.parse(log.mock.calls.flat().join('\n')).error.data.validSelectorForms
).toEqual(rows.filter((row) => row !== outside).map((row) => `id:${row.id}`))
expect(callMock).toHaveBeenCalledTimes(2)
}
}
} finally {
process.exitCode = prior
}
})
it('retains optional no-match fallback, surfaces an unreadable catalog, and keeps scope bypasses', async () => {
const log = vi.spyOn(console, 'log').mockImplementation(() => {})
const prior = process.exitCode
const commands = [
{ args: ['snapshot'], method: 'browser.snapshot' },
{ args: ['emulator', 'list'], method: 'emulator.list' },
{ args: automation, method: 'automation.create' }
]
try {
for (const { args, method: action } of commands) {
for (const mode of ['missing', 'unavailable', 'exact', 'remote']) {
callMock.mockReset()
log.mockClear()
process.exitCode = prior
callMock.mockImplementation(async (method) => {
if (method === 'worktree.list') {
if (mode === 'unavailable') {
throw new RuntimeRpcFailureError({
id: 'unavailable',
ok: false,
error: { code: 'runtime_unavailable', message: 'unavailable' },
_meta: { runtimeId: 'runtime-1' }
})
}
return worktreeListFixture([])
}
if (method === 'worktree.show') {
return okFixture('show', { worktree: root })
}
if (method === 'repo.show') {
return okFixture('repo', { repo: { id: root.repoId, connectionId: null } })
}
return okFixture('accepted', { marker: 'accepted' })
})
const scope =
mode === 'exact'
? [action === 'automation.create' ? '--workspace' : '--worktree', choices[0]!]
: mode === 'remote'
? ['--pairing-code', 'remote-runtime']
: []
await main([...args, ...scope, '--json'], root.path)
// An omitted browser target must not guess past an unreadable catalog.
if (mode === 'unavailable' && action === 'browser.snapshot') {
expect(process.exitCode).toBe(1)
expect(JSON.parse(log.mock.calls.flat().join('\n')).error.code).toBe(
'runtime_unavailable'
)
expect(callMock).not.toHaveBeenCalledWith(action, expect.anything())
continue
}
expect(process.exitCode, JSON.stringify({ args, mode, output: log.mock.calls })).toBe(
prior
)
expect(callMock).toHaveBeenCalledWith(
action,
expect.objectContaining({
[action === 'automation.create' ? 'workspace' : 'worktree']:
mode === 'exact' ? choices[0] : undefined
})
)
expect(JSON.parse(log.mock.calls.flat().join('\n')).result.marker).toBe('accepted')
expect(callMock.mock.calls.filter(([method]) => method === 'worktree.list')).toHaveLength(
mode === 'exact' || mode === 'remote' ? 0 : 1
)
if (mode === 'unavailable') {
await expect(callMock.mock.results[0]?.value).rejects.toBeInstanceOf(
RuntimeRpcFailureError
)
await expect(callMock.mock.results[0]?.value).rejects.toMatchObject({
code: 'runtime_unavailable'
})
}
}
}
for (const args of [
['snapshot', '--worktree', 'all'],
['emulator', 'list', '--worktree', 'all'],
['computer', 'get-app-state', '--app', 'fixture', '--session', 'session-1'],
['file', 'open', 'README.md', '--worktree', choices[0]!]
]) {
callMock.mockReset()
log.mockClear()
process.exitCode = prior
callMock.mockResolvedValue(okFixture('explicit', { marker: 'accepted', opened: true }))
await main([...args, '--json'], root.path)
expect(process.exitCode).toBe(prior)
expect(callMock).not.toHaveBeenCalledWith('worktree.list', expect.anything())
expect(JSON.parse(log.mock.calls.flat().join('\n')).result.marker).toBe('accepted')
}
} finally {
process.exitCode = prior
}
})
it('carries only consumed implicit choices, keeping exact/no-parent creation and separate project inference', async () => {
const log = vi.spyOn(console, 'log').mockImplementation(() => {})
const prior = process.exitCode
try {
for (const rows of [
[root, sibling],
[sibling, root]
]) {
for (const parent of [[], ['--parent-worktree', choices[1]!], ['--no-parent']]) {
callMock.mockReset()
log.mockClear()
callMock.mockImplementation(async (method) =>
method === 'worktree.list'
? worktreeListFixture(rows)
: okFixture('create', { worktree: root, lineage: null, warnings: [] })
)
await main(['worktree', 'create', '--name', 'child', ...parent, '--json'], root.path)
expect(process.exitCode).toBe(prior)
const params = callMock.mock.calls.find(([method]) => method === 'worktree.create')?.[1]
expect(params).toMatchObject({ repo: 'id:repo-a', cliProvenanceRequest: {} })
if (parent.length === 0) {
expect(params).toMatchObject({
cwdParentWorktree: `id:${rows[0]!.id}`,
cwdParentAmbiguous: true
})
} else {
expect(params).not.toHaveProperty('cwdParentAmbiguous')
expect(params).not.toHaveProperty('cwdParentWorktree')
}
expect(JSON.parse(String(log.mock.calls[0]?.[0])).result.worktree.id).toBe(root.id)
}
}
callMock.mockReset()
callMock.mockResolvedValue(
okFixture('create', { worktree: root, lineage: null, warnings: [] })
)
await main(
['worktree', 'create', '--repo', 'id:repo-a', '--no-parent', '--name', 'child', '--json'],
root.path
)
expect(callMock.mock.calls.map(([method]) => method)).toEqual(['worktree.create'])
} finally {
process.exitCode = prior
}
})
it.each([false, true])(
'exposes eligible native choices once after host/caller election (json=%s)',
async (json) => {
const log = vi.spyOn(console, 'log').mockImplementation(() => {})
const err = vi.spyOn(console, 'error').mockImplementation(() => {})
const prior = process.exitCode
try {
for (const command of [
['agent', 'launch', '--agent', 'codex'],
['ports', '--all']
]) {
for (const caller of [undefined, 'folder:r']) {
for (const ids of [
['r', 's', 'remote'],
['remote', 's', 'r']
]) {
callMock.mockReset()
log.mockClear()
err.mockClear()
process.exitCode = prior
if (caller) {
process.env.ORCA_WORKSPACE_ID = caller
} else {
delete process.env.ORCA_WORKSPACE_ID
}
callMock.mockImplementation(async (method) => {
if (method === 'worktree.list') {
return worktreeListFixture([])
}
if (method === 'folderWorkspace.list') {
return okFixture('folders', {
folderWorkspaces: ids.map((id) => ({
id,
folderPath: root.path,
projectGroupId: id === 'remote' ? 'ssh' : 'local'
}))
})
}
if (method === 'projectGroup.list') {
return okFixture('groups', {
groups: [{ id: 'local' }, { id: 'ssh', connectionId: 'other' }]
})
}
if (method === 'repo.list') {
return okFixture('repos', { repos: [] })
}
if (method === 'status.get') {
return agentLaunchHostFixture()
}
if (method === 'workspacePorts.scanHost') {
return okFixture('ports', { ports: [] })
}
return agentLaunchFixture('folder:r')
})
await main([...command, ...(json ? ['--json'] : [])], root.path)
expect(callMock.mock.calls.slice(0, 4).map(([method]) => method)).toEqual([
'worktree.list',
'folderWorkspace.list',
'projectGroup.list',
'repo.list'
])
if (caller) {
expect(process.exitCode, log.mock.calls.flat().join('')).toBe(prior)
expect(callMock).toHaveBeenCalledWith(
command[0] === 'ports' ? 'workspacePorts.scanHost' : 'agent.launchReplay',
command[0] === 'ports'
? { worktree: 'folder:r' }
: expect.objectContaining({
target: { kind: 'existing', worktree: 'folder:r' }
})
)
} else {
expect(process.exitCode).toBe(1)
const output = (json ? log : err).mock.calls.flat().join('\n')
const choices = json
? JSON.parse(output).error.data.workspaces
: JSON.parse(
output.split('Workspace choices (JSON data):\n')[1]!.split('\nNext step:')[0]!
)
expect(choices.map((choice: { selector: string }) => choice.selector)).toEqual(
ids.filter((id) => id !== 'remote').map((id) => `folder:${id}`)
)
expect(
choices.every((choice: { hostId: string }) => choice.hostId === 'local')
).toBe(true)
expect(output).not.toContain('worktree list')
expect(output).toContain(
command[0] === 'ports' ? 'The port scan did not run.' : 'codex was not started.'
)
expect(output).toContain('--worktree <selector>')
if (!json) {
expect(output.split('Workspace choices (JSON data):')).toHaveLength(2)
}
expect(callMock).toHaveBeenCalledTimes(4)
}
}
}
}
} finally {
process.exitCode = prior
}
}
)
it.each([
'space path',
'quotes" and smart“quotes”',
'semi;&$`%!^()',
'back\\slash/',
'line\nfeed',
'cafe\u0301'
])('shows raw choice data once and accepts it as one selector argument: %j', async (suffix) => {
const row = buildWorktree(`/tmp/owner ${suffix}`, 'main', 'abc', 'repo-a')
const other = { ...row, id: `${row.id}::workspace:sibling` }
const log = vi.spyOn(console, 'log').mockImplementation(() => {})
const err = vi.spyOn(console, 'error').mockImplementation(() => {})
const prior = process.exitCode
try {
for (const json of [false, true]) {
log.mockClear()
err.mockClear()
process.exitCode = prior
callMock.mockResolvedValue(worktreeListFixture([row, other]))
await main(['worktree', 'current', ...(json ? ['--json'] : [])], row.path)
expect(process.exitCode).toBe(1)
const output = (json ? log : err).mock.calls.flat().join('\n')
const data = json
? JSON.parse(output).error.data.workspaces
: JSON.parse(
output.split('Workspace choices (JSON data):\n')[1]!.split('\nNext step:')[0]!
)
expect(data.map((choice: { selector: string }) => choice.selector)).toEqual([
`id:${row.id}`,
`id:${other.id}`
])
if (!json) {
expect(output.split('Workspace choices (JSON data):')).toHaveLength(2)
}
const advice = json
? JSON.parse(output).error.data.nextSteps.join(' ')
: output.split('Next step:').slice(1).join(' ')
expect(advice).not.toContain(row.id)
expect(advice).toContain('one argument quoted for your shell')
log.mockClear()
process.exitCode = prior
callMock.mockReset()
callMock.mockResolvedValue(okFixture('exact', { worktree: row }))
await main(['worktree', 'show', '--worktree', data[0].selector, '--json'], row.path)
expect(process.exitCode).toBe(prior)
expect(callMock.mock.calls).toEqual([
['worktree.show', { worktree: `id:${row.id}`, matchFolderWorkspaces: true }]
])
expect(JSON.parse(log.mock.calls.flat().join('')).result.worktree.id).toBe(row.id)
}
} finally {
process.exitCode = prior
}
})
})
-432
View File
@@ -1,432 +0,0 @@
import { describe, expect, it, vi } from 'vitest'
const {
callMock,
runtimeClientConstructorMock,
serveOrcaAppMock,
getDefaultUserDataPathMock,
addEnvironmentFromPairingCodeMock,
listEnvironmentsMock,
spawnMock
} = vi.hoisted(() => ({
callMock: vi.fn(),
runtimeClientConstructorMock: vi.fn(),
serveOrcaAppMock: vi.fn(),
getDefaultUserDataPathMock: vi.fn(() => '/tmp/orca-user-data'),
addEnvironmentFromPairingCodeMock: vi.fn(),
listEnvironmentsMock: vi.fn(),
spawnMock: vi.fn()
}))
vi.mock('./runtime-client', async () => {
const { createRuntimeClientModuleMock } = await import('./index-test-harness.js')
return createRuntimeClientModuleMock({
callMock,
runtimeClientConstructorMock,
serveOrcaAppMock,
getDefaultUserDataPathMock
})
})
vi.mock('./runtime/environments', () => ({
addEnvironmentFromPairingCode: addEnvironmentFromPairingCodeMock,
removeEnvironment: vi.fn(),
resolveEnvironment: vi.fn()
}))
vi.mock('../shared/remote-runtime/host-store/runtime-environment-store', () => ({
listEnvironments: listEnvironmentsMock
}))
vi.mock('child_process', async () => {
const { createChildProcessModuleMock } = await import('./index-test-harness.js')
return createChildProcessModuleMock(spawnMock)
})
import { main } from './index'
import {
buildWorktree,
noFolderWorkspacesFixture,
okFixture,
queueFixtures,
worktreeListFixture
} from './test-fixtures'
import { useWorktreeAwarenessEnvironment } from './index-test-harness'
import { agentLaunchFixture, agentLaunchHostFixture } from './agent-launch-test-fixtures'
describe('orca cli worktree awareness', () => {
useWorktreeAwarenessEnvironment({
callMock,
serveOrcaAppMock,
getDefaultUserDataPathMock,
addEnvironmentFromPairingCodeMock,
listEnvironmentsMock,
spawnMock
})
it('opts into setup and activation when worktree.create runs hooks', async () => {
queueFixtures(
callMock,
worktreeListFixture([buildWorktree('/tmp/repo', 'main', 'abc', 'repo-1')]),
noFolderWorkspacesFixture(),
okFixture('req_create', {
worktree: buildWorktree('/tmp/repo/feature', 'feature', 'abc', 'repo-1')
})
)
vi.spyOn(console, 'log').mockImplementation(() => {})
await main(
['worktree', 'create', '--repo', 'id:repo-1', '--name', 'feature', '--run-hooks', '--json'],
'/tmp/repo'
)
expect(callMock).toHaveBeenNthCalledWith(3, 'worktree.create', {
repo: 'id:repo-1',
name: 'feature',
displayName: 'feature',
displayNameKind: 'user',
baseBranch: undefined,
linkedIssue: undefined,
comment: undefined,
runHooks: true,
activate: true,
navigation: 'host',
parentWorktree: undefined,
cwdParentWorktree: 'id:repo-1::/tmp/repo',
noParent: false,
callerTerminalHandle: undefined,
cliProvenanceRequest: {}
})
})
it('starts an agent worktree through agent.launch, in the background unless activation is explicit', async () => {
process.env.ORCA_WORKTREE_ID = 'repo-1::/tmp/repo'
queueFixtures(
callMock,
worktreeListFixture([
buildWorktree('/tmp/repo', 'main', 'abc', 'repo-2'),
buildWorktree('/tmp/repo', 'main', 'abc', 'repo-1')
]),
noFolderWorkspacesFixture(),
agentLaunchHostFixture(),
agentLaunchFixture('repo-1::/tmp/repo/agent-task', 'The inferred parent contexts conflict.'),
okFixture('req_show', {
worktree: buildWorktree('/tmp/repo/agent-task', 'agent-task', 'abc', 'repo-1')
})
)
const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
await main(
[
'worktree',
'create',
'--name',
'agent-task',
'--branch',
'DAT-111-agent-task',
'--agent',
'codex',
'--model',
'gpt-5.5',
'--effort',
'high',
'--prompt',
'hi',
'--setup',
'run',
'--json'
],
'/tmp/repo/src'
)
expect(callMock).toHaveBeenNthCalledWith(4, 'agent.launchReplay', {
target: {
kind: 'create-worktree',
create: {
repo: 'id:repo-1',
name: 'agent-task',
displayName: 'agent-task',
displayNameKind: 'user',
baseBranch: undefined,
branchNameOverride: 'DAT-111-agent-task',
linkedIssue: undefined,
comment: undefined,
runHooks: false,
activate: false,
setupDecision: 'run',
parentWorktree: undefined,
cwdParentWorktree: 'id:repo-1::/tmp/repo',
envParentWorkspace: 'worktree:repo-1::/tmp/repo',
noParent: false,
callerTerminalHandle: undefined,
cliProvenanceRequest: {}
}
},
presentation: 'background',
agent: 'codex',
prompt: { text: 'hi', delivery: 'submit' },
sessionOptions: { model: 'gpt-5.5', effort: 'high' },
launchSource: 'cli',
operationId: expect.any(String)
})
expect(callMock).toHaveBeenNthCalledWith(5, 'worktree.show', {
worktree: 'id:repo-1::/tmp/repo/agent-task'
})
const printed = JSON.parse(String(logSpy.mock.calls[0]?.[0]))
expect(printed.result.worktree.path).toBe('/tmp/repo/agent-task')
expect(printed.result.worktree.id).toBe('repo-1::/tmp/repo/agent-task')
expect(printed.result.launch.outcome).toEqual({
kind: 'structured',
sessionId: 'codex_1',
handle: 'agent_1'
})
expect(printed.result.launch.warning).toBe('The inferred parent contexts conflict.')
})
it('rejects an empty retry identity before creating a worktree', async () => {
const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
const priorExitCode = process.exitCode
await main(
[
'worktree',
'create',
'--repo',
'id:repo-1',
'--name',
'task',
'--agent',
'codex',
'--retry-launch=',
'--json'
],
'/tmp/repo'
)
expect(process.exitCode).toBe(1)
process.exitCode = priorExitCode
expect(JSON.parse(String(logSpy.mock.calls[0]?.[0])).error).toMatchObject({
code: 'invalid_argument',
message: expect.stringContaining('--retry-launch')
})
expect(callMock).not.toHaveBeenCalled()
})
it.each([
{ capabilities: [] },
{ capabilities: ['agent.launch.v2'] },
{ capabilities: ['agent.launch.v2', 'agent.launch.local-presentation.v1'] }
])(
'falls back to the startup terminal when the host lacks a required launch capability: $capabilities',
async ({ capabilities }) => {
process.env.ORCA_WORKTREE_ID = 'repo-1::/tmp/repo'
queueFixtures(
callMock,
worktreeListFixture([
buildWorktree('/tmp/repo', 'main', 'abc', 'repo-2'),
buildWorktree('/tmp/repo', 'main', 'abc', 'repo-1')
]),
noFolderWorkspacesFixture(),
okFixture('req_status', { capabilities }),
okFixture('req_create', {
worktree: buildWorktree('/tmp/repo/agent-task', 'agent-task', 'abc', 'repo-1'),
lineage: null,
warnings: []
})
)
const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
await main(
[
'worktree',
'create',
'--name',
'agent-task',
'--agent',
'codex',
'--prompt',
'hi',
'--activate',
'--json'
],
'/tmp/repo/src'
)
expect(callMock).toHaveBeenNthCalledWith(4, 'worktree.create', {
repo: 'id:repo-1',
name: 'agent-task',
displayName: 'agent-task',
displayNameKind: 'user',
baseBranch: undefined,
linkedIssue: undefined,
comment: undefined,
runHooks: false,
activate: true,
navigation: 'host',
parentWorktree: undefined,
cwdParentWorktree: 'id:repo-1::/tmp/repo',
envParentWorkspace: 'worktree:repo-1::/tmp/repo',
noParent: false,
callerTerminalHandle: undefined,
cliProvenanceRequest: {},
startupAgent: 'codex',
startupPrompt: 'hi',
launchSource: 'cli'
})
expect(JSON.parse(String(logSpy.mock.calls[0]?.[0])).result.worktree.id).toBe(
'repo-1::/tmp/repo/agent-task'
)
}
)
it('refuses inferred agent creation before capability lookup or either launch path when projects tie', async () => {
queueFixtures(
callMock,
worktreeListFixture([
buildWorktree('/tmp/repo', 'main', 'abc', 'repo-1'),
buildWorktree('/tmp/repo', 'main', 'abc', 'repo-2')
]),
noFolderWorkspacesFixture()
)
const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
const priorExitCode = process.exitCode
try {
await main(
['worktree', 'create', '--name', 'task', '--agent', 'codex', '--json'],
'/tmp/repo/src'
)
expect(process.exitCode).toBe(1)
expect(JSON.parse(String(logSpy.mock.calls[0]?.[0])).error.code).toBe('selector_ambiguous')
expect(callMock.mock.calls.map(([method]) => method)).toEqual([
'worktree.list',
'folderWorkspace.list'
])
} finally {
process.exitCode = priorExitCode
}
})
it('rejects prompt without agent on worktree.create', async () => {
const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
const errSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
const priorExitCode = process.exitCode
await main(
['worktree', 'create', '--repo', 'id:repo-1', '--name', 'child', '--prompt', 'hi', '--json'],
'/tmp/repo'
)
expect(callMock).not.toHaveBeenCalled()
expect([...logSpy.mock.calls, ...errSpy.mock.calls].flat().join('\n')).toContain(
'--prompt requires --agent'
)
expect(process.exitCode).toBe(1)
process.exitCode = priorExitCode
})
it('rejects unknown agents on worktree.create', async () => {
const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
const priorExitCode = process.exitCode
await main(
['worktree', 'create', '--repo', 'id:repo-1', '--name', 'child', '--agent', 'wat', '--json'],
'/tmp/repo'
)
expect(callMock).not.toHaveBeenCalled()
expect(JSON.parse(String(logSpy.mock.calls[0]?.[0]))).toMatchObject({
ok: false,
error: {
code: 'invalid_argument',
message: 'Unknown TUI agent "wat"'
}
})
expect(process.exitCode).toBe(1)
process.exitCode = priorExitCode
})
it('rejects agent, prompt, and setup flags without values on worktree.create', async () => {
const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
const errSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
const priorExitCode = process.exitCode
await main(
['worktree', 'create', '--repo', 'id:repo-1', '--name', 'child', '--agent'],
'/tmp/repo'
)
expect(callMock.mock.calls.some(([method]) => method === 'worktree.create')).toBe(false)
expect([...logSpy.mock.calls, ...errSpy.mock.calls].flat().join('\n')).toContain(
'Missing value for --agent'
)
callMock.mockClear()
logSpy.mockClear()
errSpy.mockClear()
process.exitCode = priorExitCode
await main(
[
'worktree',
'create',
'--repo',
'id:repo-1',
'--name',
'child',
'--agent',
'codex',
'--prompt'
],
'/tmp/repo'
)
expect(callMock.mock.calls.some(([method]) => method === 'worktree.create')).toBe(false)
expect([...logSpy.mock.calls, ...errSpy.mock.calls].flat().join('\n')).toContain(
'--prompt requires a value'
)
callMock.mockClear()
logSpy.mockClear()
errSpy.mockClear()
process.exitCode = priorExitCode
await main(
['worktree', 'create', '--repo', 'id:repo-1', '--name', 'child', '--setup'],
'/tmp/repo'
)
expect(callMock.mock.calls.some(([method]) => method === 'worktree.create')).toBe(false)
expect([...logSpy.mock.calls, ...errSpy.mock.calls].flat().join('\n')).toContain(
'Missing value for --setup'
)
process.exitCode = priorExitCode
})
it('rejects contradictory setup flags on worktree.create', async () => {
const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
const errSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
const priorExitCode = process.exitCode
await main(
[
'worktree',
'create',
'--repo',
'id:repo-1',
'--name',
'child',
'--run-hooks',
'--setup',
'skip',
'--json'
],
'/tmp/repo'
)
expect(callMock).not.toHaveBeenCalled()
expect([...logSpy.mock.calls, ...errSpy.mock.calls].flat().join('\n')).toContain(
'Choose either --run-hooks or --setup run'
)
expect(process.exitCode).toBe(1)
process.exitCode = priorExitCode
})
})
@@ -1,374 +0,0 @@
import { join, resolve } from 'node:path'
import { afterEach, describe, expect, it, vi } from 'vitest'
const {
callMock,
runtimeClientConstructorMock,
serveOrcaAppMock,
getDefaultUserDataPathMock,
addEnvironmentFromPairingCodeMock,
listEnvironmentsMock,
spawnMock
} = vi.hoisted(() => ({
callMock: vi.fn(),
runtimeClientConstructorMock: vi.fn(),
serveOrcaAppMock: vi.fn(),
getDefaultUserDataPathMock: vi.fn(() => '/tmp/orca-user-data'),
addEnvironmentFromPairingCodeMock: vi.fn(),
listEnvironmentsMock: vi.fn(),
spawnMock: vi.fn()
}))
vi.mock('./runtime-client', async () => {
const { createRuntimeClientModuleMock } = await import('./index-test-harness.js')
return createRuntimeClientModuleMock({
callMock,
runtimeClientConstructorMock,
serveOrcaAppMock,
getDefaultUserDataPathMock
})
})
vi.mock('./runtime/environments', () => ({
addEnvironmentFromPairingCode: addEnvironmentFromPairingCodeMock,
removeEnvironment: vi.fn(),
resolveEnvironment: vi.fn()
}))
vi.mock('../shared/remote-runtime/host-store/runtime-environment-store', () => ({
listEnvironments: listEnvironmentsMock
}))
vi.mock('child_process', async () => {
const { createChildProcessModuleMock } = await import('./index-test-harness.js')
return createChildProcessModuleMock(spawnMock)
})
import { main } from './index'
import {
buildWorktree,
noFolderWorkspacesFixture,
okFixture,
queueFixtures,
worktreeListFixture
} from './test-fixtures'
import { useWorktreeAwarenessEnvironment } from './index-test-harness'
const SSH_CALLER = {
ORCA_ORCHESTRATION_COMPATIBILITY_HOST_KIND: 'ssh',
ORCA_ORCHESTRATION_COMPATIBILITY_HOST_ID: 'box-b',
ORCA_ORCHESTRATION_COMPATIBILITY_HOST_INCARNATION: 'inc-1',
ORCA_ORCHESTRATION_COMPATIBILITY_ATTACHMENT: 'att-1'
}
describe('worktree create from a worktree another host shares an id with', () => {
useWorktreeAwarenessEnvironment({
callMock,
serveOrcaAppMock,
getDefaultUserDataPathMock,
addEnvironmentFromPairingCodeMock,
listEnvironmentsMock,
spawnMock
})
afterEach(() => {
for (const key of Object.keys(SSH_CALLER)) {
delete process.env[key]
}
})
it('infers the repo while the parent stays the exact host-scoped identity', async () => {
Object.assign(process.env, SSH_CALLER)
queueFixtures(
callMock,
worktreeListFixture([
{
...buildWorktree('/srv/app', 'main', 'abc', 'repo-1'),
hostId: 'ssh:box-a',
identity: { key: 'wt2:a' }
},
{
...buildWorktree('/srv/app', 'main', 'abc', 'repo-1'),
hostId: 'ssh:box-b',
identity: { key: 'wt2:b' }
}
]),
noFolderWorkspacesFixture(),
okFixture('req_create', {
worktree: buildWorktree('/srv/app-child', 'child', 'abc', 'repo-1'),
lineage: null,
warnings: []
})
)
vi.spyOn(console, 'log').mockImplementation(() => {})
await main(['worktree', 'create', '--name', 'child', '--json'], '/srv/app/src')
expect(callMock).toHaveBeenNthCalledWith(
3,
'worktree.create',
expect.objectContaining({ repo: 'id:repo-1', cwdParentWorktree: 'identity:wt2:b' })
)
})
it('infers checkout ownership independently of workspace identity and catalog order', async () => {
const path = resolve('/tmp/sta-12478')
const root = buildWorktree(path, 'main', 'abc', 'repo-a')
const other = buildWorktree(path, 'main', 'abc', 'repo-b')
const sibling = { ...root, id: `${root.id}::workspace:11111111-1111-4111-8111-111111111111` }
const folder = { ...root, id: 'folder:f1', repoId: 'folder-workspace:group-1' }
const nfc = buildWorktree(join(path, 'café'), 'main', 'abc', 'repo-a')
const nfd = buildWorktree(join(path, 'cafe\u0301'), 'main', 'abc', 'repo-b')
const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
const errSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
const priorExitCode = process.exitCode
const cases = [
{ rows: [nfc, nfd], caller: undefined, repo: undefined, cwd: nfc.path },
{ rows: [nfc, nfd], caller: nfc.id, repo: 'repo-a', cwd: nfc.path },
{ rows: [nfc, nfd], caller: nfc.id, repo: 'repo-a', cwd: nfc.path, parent: 'active' },
{ rows: [nfc, nfd], caller: nfc.id, repo: 'repo-a', cwd: nfc.path, parent: 'current' },
{ rows: [root, { ...other, path: join(path, 'nested') }], caller: undefined, repo: 'repo-b' },
{ rows: [root, other], caller: undefined, repo: undefined },
{ rows: [root, other], caller: other.id, repo: 'repo-b' },
{ rows: [root, other], caller: 'missing::workspace', repo: undefined },
{ rows: [root, root], caller: undefined, repo: 'repo-a' },
{ rows: [root, sibling], caller: undefined, repo: 'repo-a' },
{ rows: [root, folder], caller: undefined, repo: 'repo-a' },
{
rows: [root, { ...folder, path: join(path, 'nested') }],
caller: undefined,
repo: 'repo-a'
},
{
rows: [
{ ...root, head: '', branch: '' },
{ ...sibling, head: '', branch: '' }
],
caller: undefined,
repo: 'repo-a'
},
{ rows: [root, folder], caller: root.id, repo: 'repo-a' },
{ rows: [root, folder], caller: folder.id, repo: 'repo-a' },
{ rows: [root, { ...root, hostId: 'runtime:other' }], caller: undefined, repo: undefined }
]
try {
for (const testCase of cases) {
for (const rows of [testCase.rows, testCase.rows.toReversed()]) {
callMock.mockReset()
logSpy.mockClear()
errSpy.mockClear()
process.exitCode = priorExitCode
if (testCase.caller) {
process.env.ORCA_WORKTREE_ID = testCase.caller
} else {
delete process.env.ORCA_WORKTREE_ID
}
callMock.mockImplementation(async (method: string) =>
method === 'worktree.list'
? worktreeListFixture(rows)
: okFixture('create', {
worktree: buildWorktree(join(path, 'child'), 'child', 'abc', testCase.repo),
lineage: null,
warnings: []
})
)
await main(
[
'worktree',
'create',
'--name',
'child',
...(testCase.parent ? ['--parent-worktree', testCase.parent] : ['--no-parent']),
'--json'
],
testCase.cwd ?? join(path, 'nested', 'src')
)
if (testCase.repo) {
expect(process.exitCode).toBe(priorExitCode)
expect(JSON.parse(String(logSpy.mock.calls[0]?.[0])).result.worktree.repoId).toBe(
testCase.repo
)
expect(callMock).toHaveBeenCalledWith(
'worktree.create',
expect.objectContaining({
repo: `id:${testCase.repo}`,
noParent: !testCase.parent,
...(testCase.parent ? { parentWorktree: `id:${testCase.caller}` } : {})
})
)
} else {
expect(callMock).not.toHaveBeenCalledWith('worktree.create', expect.anything())
expect(process.exitCode).toBe(1)
const printed = [...logSpy.mock.calls, ...errSpy.mock.calls].flat().join('\n')
expect(printed).toContain('selector_ambiguous')
expect(printed).toContain('Choose the project with --repo or --project')
}
}
}
// An explicit target keeps optional-parent inference; active/current refuse a two-owner path.
delete process.env.ORCA_WORKTREE_ID
for (const parent of [undefined, 'active', 'current']) {
callMock.mockReset()
process.exitCode = priorExitCode
callMock.mockImplementation(async (method: string) => {
if (method === 'worktree.list') {
return worktreeListFixture([root, other])
}
return okFixture('create', {
worktree: buildWorktree(join(path, 'child'), 'child'),
lineage: null,
warnings: []
})
})
await main(
[
'worktree',
'create',
'--name',
'child',
'--repo',
'id:repo-b',
...(parent ? ['--parent-worktree', parent] : []),
'--json'
],
path
)
// Two registrations own the path: an explicit current refuses, inference flags the tie.
if (parent) {
expect(process.exitCode).toBe(1)
expect(callMock).not.toHaveBeenCalledWith('worktree.create', expect.anything())
process.exitCode = priorExitCode
continue
}
expect(process.exitCode).toBe(priorExitCode)
expect(callMock).toHaveBeenCalledWith(
'worktree.create',
expect.objectContaining({
repo: 'id:repo-b',
cwdParentWorktree: `id:${root.id}`,
cwdParentAmbiguous: true
})
)
}
// A unique project retains the legacy parent hint and carries the unresolved owners.
callMock.mockReset()
queueFixtures(
callMock,
worktreeListFixture([sibling, root]),
okFixture('create', {
worktree: buildWorktree(join(path, 'child'), 'child'),
lineage: null,
warnings: []
})
)
await main(['worktree', 'create', '--name', 'child', '--json'], path)
expect(callMock).toHaveBeenCalledWith(
'worktree.create',
expect.objectContaining({
repo: 'id:repo-a',
cwdParentWorktree: `id:${sibling.id}`,
cwdParentAmbiguous: true
})
)
} finally {
process.exitCode = priorExitCode
}
})
it('requires an explicit Git destination when a native folder supplies only parent lineage', async () => {
const path = resolve('/tmp/plain-folder')
const folder = {
...buildWorktree(path, ''),
id: 'folder:f1',
repoId: 'folder-workspace:group-1'
}
const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
const priorExitCode = process.exitCode
try {
for (const rows of [[], [folder]]) {
for (const explicit of [false, true]) {
callMock.mockReset()
logSpy.mockClear()
process.exitCode = priorExitCode
callMock.mockImplementation(async (method: string) =>
method === 'worktree.list'
? worktreeListFixture(rows)
: okFixture('create', {
worktree: buildWorktree(join(path, 'child'), 'child', 'abc', 'repo-a'),
lineage: null,
warnings: []
})
)
await main(
[
'worktree',
'create',
'--name',
'folder-child',
'--parent-worktree',
'folder:f1',
...(explicit ? ['--repo', 'id:repo-a'] : []),
'--json'
],
join(path, 'src')
)
if (explicit) {
expect(process.exitCode).toBe(priorExitCode)
expect(callMock).toHaveBeenCalledWith(
'worktree.create',
expect.objectContaining({
repo: 'id:repo-a',
parentWorkspace: 'folder:f1'
})
)
} else {
expect(process.exitCode).toBe(1)
expect(callMock).not.toHaveBeenCalledWith('worktree.create', expect.anything())
expect(logSpy.mock.calls.flat().join('\n')).toContain('Missing repo selector')
}
}
}
} finally {
process.exitCode = priorExitCode
}
})
it.each(['folder:f1', 'active'])(
'lists the Git repositories of a folder parent when create has no repo (--parent-worktree %s)',
async (parent) => {
const path = resolve('/tmp/feature-folder')
const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
const priorExitCode = process.exitCode
const lists: Record<string, unknown> = {
'worktree.list': worktreeListFixture([]).result,
'folderWorkspace.list': {
folderWorkspaces: [{ id: 'f1', projectGroupId: 'g1', folderPath: path, name: 'feature' }]
},
'projectGroup.list': { groups: [{ id: 'g1', name: 'feature', parentPath: path }] },
'repo.list': {
repos: [
{ id: 'repo-api', path: join(path, 'api'), displayName: 'api' },
{ id: 'elsewhere', path: resolve('/tmp/other'), displayName: 'other' }
]
}
}
try {
callMock.mockImplementation(async (method: string) =>
okFixture(method, lists[method] ?? {})
)
await main(
['worktree', 'create', '--name', 'fix-login', '--parent-worktree', parent],
join(path, 'api')
)
const output = [...errorSpy.mock.calls, ...logSpy.mock.calls].flat().join('\n')
expect(process.exitCode).toBe(1)
expect(callMock).not.toHaveBeenCalledWith('worktree.create', expect.anything())
expect(output).toContain('--repo id:repo-api')
expect(output).not.toContain('id:elsewhere')
} finally {
process.exitCode = priorExitCode
}
}
)
})
@@ -1,573 +0,0 @@
import { describe, expect, it, vi } from 'vitest'
const {
callMock,
runtimeClientConstructorMock,
serveOrcaAppMock,
getDefaultUserDataPathMock,
addEnvironmentFromPairingCodeMock,
listEnvironmentsMock,
spawnMock
} = vi.hoisted(() => ({
callMock: vi.fn(),
runtimeClientConstructorMock: vi.fn(),
serveOrcaAppMock: vi.fn(),
getDefaultUserDataPathMock: vi.fn(() => '/tmp/orca-user-data'),
addEnvironmentFromPairingCodeMock: vi.fn(),
listEnvironmentsMock: vi.fn(),
spawnMock: vi.fn()
}))
vi.mock('./runtime-client', async () => {
const { createRuntimeClientModuleMock } = await import('./index-test-harness.js')
return createRuntimeClientModuleMock({
callMock,
runtimeClientConstructorMock,
serveOrcaAppMock,
getDefaultUserDataPathMock
})
})
vi.mock('./runtime/environments', () => ({
addEnvironmentFromPairingCode: addEnvironmentFromPairingCodeMock,
removeEnvironment: vi.fn(),
resolveEnvironment: vi.fn()
}))
vi.mock('../shared/remote-runtime/host-store/runtime-environment-store', () => ({
listEnvironments: listEnvironmentsMock
}))
vi.mock('child_process', async () => {
const { createChildProcessModuleMock } = await import('./index-test-harness.js')
return createChildProcessModuleMock(spawnMock)
})
import { main } from './index'
import {
buildWorktree,
noFolderWorkspacesFixture,
okFixture,
queueFixtures,
worktreeListFixture
} from './test-fixtures'
import { pairRuntimeEnvironment, useWorktreeAwarenessEnvironment } from './index-test-harness'
import { RuntimeRpcFailureError } from './runtime-client'
function buildSetup(overrides: {
id: string
hostId: string
repoId: string
projectId?: string
path?: string
displayName?: string
}) {
return {
projectId: 'github:stablyai/orca',
path: '/tmp/orca',
displayName: 'Orca',
setupState: 'ready',
setupMethod: 'legacy-repo',
createdAt: 1,
updatedAt: 1,
...overrides
}
}
describe('orca cli worktree awareness', () => {
useWorktreeAwarenessEnvironment({
callMock,
serveOrcaAppMock,
getDefaultUserDataPathMock,
addEnvironmentFromPairingCodeMock,
listEnvironmentsMock,
spawnMock
})
it('passes explicit activation through worktree.create', async () => {
queueFixtures(
callMock,
worktreeListFixture([buildWorktree('/tmp/repo', 'main', 'abc', 'repo-1')]),
noFolderWorkspacesFixture(),
okFixture('req_create', {
worktree: buildWorktree('/tmp/repo/feature', 'feature', 'abc', 'repo-1')
})
)
vi.spyOn(console, 'log').mockImplementation(() => {})
await main(
['worktree', 'create', '--repo', 'id:repo-1', '--name', 'feature', '--activate', '--json'],
'/tmp/repo'
)
expect(callMock).toHaveBeenNthCalledWith(3, 'worktree.create', {
repo: 'id:repo-1',
name: 'feature',
displayName: 'feature',
displayNameKind: 'user',
baseBranch: undefined,
linkedIssue: undefined,
comment: undefined,
runHooks: false,
activate: true,
navigation: 'host',
parentWorktree: undefined,
cwdParentWorktree: 'id:repo-1::/tmp/repo',
noParent: false,
callerTerminalHandle: undefined,
cliProvenanceRequest: {}
})
})
it('resolves project and host flags to the matching repo for worktree.create', async () => {
pairRuntimeEnvironment(listEnvironmentsMock, 'gpu')
queueFixtures(
callMock,
okFixture('req_project_setups', {
setups: [
{
id: 'setup-local',
projectId: 'github:stablyai/orca',
hostId: 'local',
repoId: 'repo-local',
path: '/tmp/orca',
displayName: 'Orca',
setupState: 'ready',
setupMethod: 'legacy-repo',
createdAt: 1,
updatedAt: 1
},
{
id: 'setup-gpu',
projectId: 'github:stablyai/orca',
hostId: 'runtime:gpu',
repoId: 'repo-gpu',
path: '/srv/orca',
displayName: 'Orca',
setupState: 'ready',
setupMethod: 'legacy-repo',
createdAt: 1,
updatedAt: 1
}
]
}),
okFixture('req_create', {
worktree: buildWorktree('/srv/orca/feature', 'feature', 'abc', 'repo-gpu'),
lineage: null,
warnings: []
})
)
vi.spyOn(console, 'log').mockImplementation(() => {})
await main(
[
'worktree',
'create',
'--project',
'github:stablyai/orca',
'--host',
'runtime:gpu',
'--name',
'feature',
'--no-parent',
'--json'
],
'/tmp/repo'
)
expect(runtimeClientConstructorMock).toHaveBeenCalledWith(null, 'gpu')
expect(callMock).toHaveBeenNthCalledWith(1, 'projectHostSetup.list')
expect(callMock).toHaveBeenNthCalledWith(2, 'worktree.create', {
repo: 'id:repo-gpu',
repoHostId: 'runtime:gpu',
name: 'feature',
displayName: 'feature',
displayNameKind: 'user',
baseBranch: undefined,
linkedIssue: undefined,
comment: undefined,
runHooks: false,
activate: false,
parentWorktree: undefined,
noParent: true,
callerTerminalHandle: undefined,
cliProvenanceRequest: {}
})
})
it('resolves project-host-setup directly for worktree.create', async () => {
queueFixtures(
callMock,
okFixture('req_project_setups', {
setups: [
{
id: 'setup-gpu',
projectId: 'github:stablyai/orca',
hostId: 'runtime:gpu',
repoId: 'repo-gpu',
path: '/srv/orca',
displayName: 'Orca',
setupState: 'ready',
setupMethod: 'legacy-repo',
createdAt: 1,
updatedAt: 1
}
]
}),
okFixture('req_create', {
worktree: buildWorktree('/srv/orca/feature', 'feature', 'abc', 'repo-gpu'),
lineage: null,
warnings: []
})
)
vi.spyOn(console, 'log').mockImplementation(() => {})
await main(
[
'worktree',
'create',
'--project-host-setup',
'setup-gpu',
'--name',
'feature',
'--no-parent',
'--json'
],
'/tmp/repo'
)
expect(callMock).toHaveBeenNthCalledWith(
2,
'worktree.create',
expect.objectContaining({ repo: 'id:repo-gpu' })
)
})
it('surfaces a project.list failure instead of reporting the project as not set up', async () => {
const { RuntimeClientError } = await import('./runtime/types.js')
const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
const errSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
const priorExitCode = process.exitCode
queueFixtures(
callMock,
okFixture('req_project_setups', {
setups: [buildSetup({ id: 'setup-local', hostId: 'local', repoId: 'repo-local' })]
})
)
callMock.mockRejectedValueOnce(
new RuntimeClientError('internal_error', 'project store offline')
)
await main(
['worktree', 'create', '--project', 'scalp-it', '--name', 'feature', '--no-parent', '--json'],
'/tmp/repo'
)
const printed = [...logSpy.mock.calls, ...errSpy.mock.calls].flat().join('\n')
expect(printed).toContain('project store offline')
expect(printed).not.toContain('Project is not set up')
expect(callMock).not.toHaveBeenCalledWith('worktree.create', expect.anything())
expect(process.exitCode).toBe(1)
process.exitCode = priorExitCode
})
it('refuses a legacy display-name match that spans two projects', async () => {
const { RuntimeClientError } = await import('./runtime/types.js')
const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
const errSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
const priorExitCode = process.exitCode
queueFixtures(
callMock,
okFixture('req_project_setups', {
setups: [
buildSetup({
id: 'setup-a',
hostId: 'local',
repoId: 'repo-a',
projectId: 'github:acme/scalp-it',
displayName: 'scalp-it'
}),
buildSetup({
id: 'setup-b',
hostId: 'local',
repoId: 'repo-b',
projectId: 'gitlab:other/scalp-it',
displayName: 'scalp-it'
})
]
})
)
callMock.mockRejectedValueOnce(
new RuntimeClientError('method_not_found', 'Unknown method: project.list')
)
await main(
['worktree', 'create', '--project', 'scalp-it', '--name', 'feature', '--no-parent', '--json'],
'/tmp/repo'
)
const printed = [...logSpy.mock.calls, ...errSpy.mock.calls].flat().join('\n')
expect(printed).toContain('2 projects have a setup named that')
expect(printed).toContain('github:acme/scalp-it')
expect(printed).toContain('gitlab:other/scalp-it')
expect(callMock).not.toHaveBeenCalledWith('worktree.create', expect.anything())
expect(process.exitCode).toBe(1)
process.exitCode = priorExitCode
})
it('falls back to the setup display name when the server has no project.list', async () => {
const { RuntimeClientError } = await import('./runtime/types.js')
queueFixtures(
callMock,
okFixture('req_project_setups', {
setups: [
buildSetup({
id: 'setup-local',
hostId: 'local',
repoId: 'repo-local',
projectId: 'github:stablyai/scalp-it',
displayName: 'scalp-it'
})
]
})
)
callMock.mockRejectedValueOnce(
new RuntimeClientError('method_not_found', 'Unknown method: project.list')
)
queueFixtures(
callMock,
okFixture('req_create', {
worktree: buildWorktree('/tmp/scalp-it/feature', 'feature', 'abc', 'repo-local'),
lineage: null,
warnings: []
})
)
vi.spyOn(console, 'log').mockImplementation(() => {})
await main(
['worktree', 'create', '--project', 'scalp-it', '--name', 'feature', '--no-parent', '--json'],
'/tmp/repo'
)
expect(callMock).toHaveBeenNthCalledWith(
3,
'worktree.create',
expect.objectContaining({ repo: 'id:repo-local' })
)
})
it('resolves --project by display name and infers the only host it is set up on', async () => {
queueFixtures(
callMock,
okFixture('req_project_setups', {
setups: [
buildSetup({
id: 'setup-local',
hostId: 'local',
repoId: 'repo-local',
projectId: 'github:stablyai/scalp-it',
path: '/tmp/scalp-it',
displayName: 'scalp-it'
})
]
}),
okFixture('req_projects', {
projects: [{ id: 'github:stablyai/scalp-it', displayName: 'scalp-it' }]
}),
okFixture('req_create', {
worktree: buildWorktree('/tmp/scalp-it/feature', 'feature', 'abc', 'repo-local'),
lineage: null,
warnings: []
})
)
vi.spyOn(console, 'log').mockImplementation(() => {})
await main(
['worktree', 'create', '--project', 'scalp-it', '--name', 'feature', '--no-parent', '--json'],
'/tmp/repo'
)
expect(callMock).toHaveBeenNthCalledWith(1, 'projectHostSetup.list')
expect(callMock).toHaveBeenNthCalledWith(2, 'project.list')
expect(callMock).toHaveBeenNthCalledWith(
3,
'worktree.create',
expect.objectContaining({ repo: 'id:repo-local' })
)
})
it('reports an unknown project as a project miss, not a host one', async () => {
queueFixtures(
callMock,
okFixture('req_project_setups', { setups: [] }),
okFixture('req_projects', { projects: [] })
)
const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
const errSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
const priorExitCode = process.exitCode
await main(
['worktree', 'create', '--project', 'nope', '--name', 'feature', '--no-parent', '--json'],
'/tmp/repo'
)
const printed = [...logSpy.mock.calls, ...errSpy.mock.calls].flat().join('\n')
expect(printed).toContain('No ready setup found for --project nope on any host.')
expect(printed).not.toContain('selected host')
expect(process.exitCode).toBe(1)
process.exitCode = priorExitCode
})
it('asks which host only when the project is set up on more than one', async () => {
const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
const errSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
const priorExitCode = process.exitCode
queueFixtures(
callMock,
okFixture('req_project_setups', {
setups: [
buildSetup({
id: 'setup-local',
hostId: 'local',
repoId: 'repo-local',
path: '/tmp/orca'
}),
buildSetup({
id: 'setup-gpu',
hostId: 'runtime:gpu',
repoId: 'repo-gpu',
path: '/srv/orca'
})
]
})
)
await main(
[
'worktree',
'create',
'--project',
'github:stablyai/orca',
'--name',
'feature',
'--no-parent',
'--json'
],
'/tmp/repo'
)
expect(callMock).toHaveBeenCalledTimes(1)
const printed = [...logSpy.mock.calls, ...errSpy.mock.calls].flat().join('\n')
expect(printed).toContain('it is set up on 2 hosts')
expect(printed).toContain('--host local')
expect(printed).toContain('--host runtime:gpu')
expect(process.exitCode).toBe(1)
process.exitCode = priorExitCode
})
it('accepts the host alias that `orca host list` prints', async () => {
queueFixtures(
callMock,
okFixture('req_ssh_targets', {
targets: [{ id: 'ssh-1783599077486-fyasux', label: 'trader-local' }]
}),
okFixture('req_project_setups', {
setups: [
buildSetup({ id: 'setup-local', hostId: 'local', repoId: 'repo-local' }),
buildSetup({
id: 'setup-trader',
hostId: 'ssh:ssh-1783599077486-fyasux',
repoId: 'repo-trader',
path: '/home/trader/orca'
})
]
}),
okFixture('req_create', {
worktree: buildWorktree('/home/trader/orca/feature', 'feature', 'abc', 'repo-trader'),
lineage: null,
warnings: []
})
)
vi.spyOn(console, 'log').mockImplementation(() => {})
await main(
[
'worktree',
'create',
'--project',
'github:stablyai/orca',
'--host',
'trader-local',
'--name',
'feature',
'--no-parent',
'--json'
],
'/tmp/repo'
)
expect(callMock).toHaveBeenNthCalledWith(1, 'ssh.listTargetSummaries')
expect(callMock).toHaveBeenNthCalledWith(
3,
'worktree.create',
expect.objectContaining({ repo: 'id:repo-trader' })
)
})
it('rejects mixing repo and project target flags on worktree.create', async () => {
const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
const errSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
const priorExitCode = process.exitCode
await main(
[
'worktree',
'create',
'--repo',
'id:repo-local',
'--project',
'github:stablyai/orca',
'--name',
'feature',
'--json'
],
'/tmp/repo'
)
expect(callMock).not.toHaveBeenCalled()
expect([...logSpy.mock.calls, ...errSpy.mock.calls].flat().join('\n')).toContain(
'Choose either --repo or project target flags, not both.'
)
expect(process.exitCode).toBe(1)
process.exitCode = priorExitCode
})
it('tells the user which --setup flag answers an undecided ask repo', async () => {
callMock.mockRejectedValueOnce(
new RuntimeRpcFailureError({
id: 'req_create',
ok: false,
error: { code: 'runtime_error', message: 'Setup decision required for this repository' },
_meta: { runtimeId: 'runtime-1' }
})
)
const errSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
const priorExitCode = process.exitCode
await main(
['worktree', 'create', '--repo', 'id:repo-1', '--name', 'child', '--no-parent'],
'/tmp/repo'
)
expect(errSpy.mock.calls.flat().join('\n')).toBe(
'Setup decision required for this repository\n' +
'Next step: Pass --setup run to run the setup script, or --setup skip to create without it.'
)
expect(process.exitCode).toBe(1)
process.exitCode = priorExitCode
})
})
-560
View File
@@ -1,560 +0,0 @@
import { describe, expect, it, vi } from 'vitest'
const {
callMock,
runtimeClientConstructorMock,
serveOrcaAppMock,
getDefaultUserDataPathMock,
addEnvironmentFromPairingCodeMock,
listEnvironmentsMock,
spawnMock
} = vi.hoisted(() => ({
callMock: vi.fn(),
runtimeClientConstructorMock: vi.fn(),
serveOrcaAppMock: vi.fn(),
getDefaultUserDataPathMock: vi.fn(() => '/tmp/orca-user-data'),
addEnvironmentFromPairingCodeMock: vi.fn(),
listEnvironmentsMock: vi.fn(),
spawnMock: vi.fn()
}))
vi.mock('./runtime-client', async () => {
const { createRuntimeClientModuleMock } = await import('./index-test-harness.js')
return createRuntimeClientModuleMock({
callMock,
runtimeClientConstructorMock,
serveOrcaAppMock,
getDefaultUserDataPathMock
})
})
vi.mock('./runtime/environments', () => ({
addEnvironmentFromPairingCode: addEnvironmentFromPairingCodeMock,
removeEnvironment: vi.fn(),
resolveEnvironment: vi.fn()
}))
vi.mock('../shared/remote-runtime/host-store/runtime-environment-store', () => ({
listEnvironments: listEnvironmentsMock
}))
vi.mock('child_process', async () => {
const { createChildProcessModuleMock } = await import('./index-test-harness.js')
return createChildProcessModuleMock(spawnMock)
})
import { main } from './index'
import { RuntimeRpcFailureError } from './runtime/types'
import {
buildWorktree,
noFolderWorkspacesFixture,
okFixture,
queueFixtures,
worktreeListFixture,
queueNoFolderAtSelector
} from './test-fixtures'
import { pairRuntimeEnvironment, useWorktreeAwarenessEnvironment } from './index-test-harness'
describe('orca cli worktree awareness', () => {
useWorktreeAwarenessEnvironment({
callMock,
serveOrcaAppMock,
getDefaultUserDataPathMock,
addEnvironmentFromPairingCodeMock,
listEnvironmentsMock,
spawnMock
})
it('sends folder parents only to hosts that accept them and avoids blaming the child for missing parents', async () => {
const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
const errSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
const priorExitCode = process.exitCode
const child = 'id:repo::/tmp/repo/child'
try {
for (const parent of ['folder:folder-1', 'id:folder:folder-1']) {
for (const capabilities of [[], ['worktree.set.folder-parent.v1']]) {
callMock.mockReset()
logSpy.mockClear()
process.exitCode = priorExitCode
callMock.mockImplementation(async (method: string) =>
method === 'status.get'
? { id: 'req_status', ok: true, result: { capabilities } }
: { id: 'req_set', ok: true, result: { worktree: { id: 'repo::/tmp/repo/child' } } }
)
await main(
['worktree', 'set', '--worktree', child, '--parent-worktree', parent, '--json'],
'/tmp/repo'
)
if (capabilities.length === 0) {
expect(callMock).not.toHaveBeenCalledWith('worktree.set', expect.anything())
const output = JSON.parse(logSpy.mock.calls.at(-1)?.[0] ?? '{}').error
expect(output.message).toContain(
'to attach a worktree to a folder workspace. Nothing was changed.'
)
expect(process.exitCode).toBe(1)
} else {
expect(callMock).toHaveBeenCalledWith(
'worktree.set',
expect.objectContaining({ parentWorktree: 'folder:folder-1' })
)
}
}
}
callMock.mockReset()
process.exitCode = priorExitCode
callMock.mockRejectedValueOnce(
new RuntimeRpcFailureError({
id: 'req_missing_parent',
ok: false,
error: {
code: 'selector_not_found',
message: 'selector_not_found',
data: { orchestrationRequestId: 'req_mutation', nextSteps: ['Inspect mutation.'] }
}
})
)
logSpy.mockClear()
await main(
['worktree', 'set', '--worktree', child, '--parent-worktree', 'name:missing', '--json'],
'/tmp/repo'
)
const output = JSON.parse(logSpy.mock.calls.at(-1)?.[0] ?? '{}').error
expect(callMock).toHaveBeenLastCalledWith('worktree.set', expect.anything())
expect(output.data.orchestrationRequestId).toBe('req_mutation')
expect(output.data.nextSteps).toContain('Inspect mutation.')
expect(output.data.nextSteps.join(' ')).toContain('parent selector "name:missing"')
expect(output.data.nextSteps.join(' ')).toContain(
'The server did not identify which selector failed.'
)
expect(output.data.nextSteps.join(' ')).not.toContain(
'No Orca workspace matched the worktree selector'
)
expect(process.exitCode).toBe(1)
expect(errSpy).not.toHaveBeenCalled()
} finally {
process.exitCode = priorExitCode
}
})
it('keeps child and parent lookup recovery distinct before mutation', async () => {
const log = vi.spyOn(console, 'log').mockImplementation(() => {})
const err = vi.spyOn(console, 'error').mockImplementation(() => {})
const priorExitCode = process.exitCode
const cwd = '/tmp/not-managed'
const rpc = {
id: 'req_child',
ok: false as const,
error: {
code: 'selector_not_found',
message: 'selector_not_found',
data: { orchestrationRequestId: 'req_original', nextSteps: ['Inspect original request.'] }
},
_meta: { runtimeId: 'runtime_original' }
}
try {
for (const stage of ['child', 'parent', 'preflight']) {
for (const json of [true, false]) {
callMock.mockReset()
log.mockClear()
err.mockClear()
const worktree = stage === 'child' ? 'current' : 'name:x'
const parent = stage === 'parent' ? 'current' : 'name:existing-parent'
// `current` resolves from the worktree list; only name:x makes the folder lookup first.
if (stage !== 'child') {
queueNoFolderAtSelector(callMock)
}
if (stage === 'preflight') {
callMock.mockRejectedValueOnce(new RuntimeRpcFailureError(rpc))
} else {
queueFixtures(
callMock,
worktreeListFixture([]),
// A parent's current directory may be a native folder, which isn't a catalog row.
...(stage === 'parent' ? [okFixture('req_folders', { folderWorkspaces: [] })] : [])
)
}
const args = ['worktree', 'set', '--worktree', worktree, '--parent-worktree', parent]
if (stage === 'preflight') {
args.push('--gitlab-issue', 'https://gitlab.com/group/repo/-/issues/1')
}
await main([...args, ...(json ? ['--json'] : [])], cwd)
const text = String((json ? log : err).mock.calls.at(-1)?.[0])
const response = json ? JSON.parse(text) : undefined
expect(callMock.mock.calls.map(([method]) => method)).not.toContain('worktree.set')
expect(text).toContain(
stage === 'preflight' ? 'Inspect original request.' : `current directory: ${cwd}`
)
expect(text).toContain(
stage === 'parent' ? 'explicit parent selector' : 'No Orca workspace matched'
)
expect(text).not.toContain(stage === 'parent' ? 'name:x' : 'parent selector')
if (response) {
expect(response.id).toBe(stage === 'preflight' ? rpc.id : 'local')
expect(response._meta.runtimeId).toBe(
stage === 'preflight' ? rpc._meta.runtimeId : null
)
if (stage === 'preflight') {
expect(response.error.data).toMatchObject({ orchestrationRequestId: 'req_original' })
}
}
}
}
} finally {
process.exitCode = priorExitCode
}
})
it('uses cwd when active is passed to worktree.set', async () => {
queueFixtures(
callMock,
worktreeListFixture([
buildWorktree('/tmp/repo', 'main', 'aaa'),
buildWorktree('/tmp/repo/feature', 'feature/foo')
]),
noFolderWorkspacesFixture(),
okFixture('req_1', {
worktree: {
id: 'repo::/tmp/repo/feature',
branch: 'feature/foo',
path: '/tmp/repo/feature',
comment: 'hello'
}
})
)
vi.spyOn(console, 'log').mockImplementation(() => {})
await main(
['worktree', 'set', '--worktree', 'active', '--comment', 'hello', '--json'],
'/tmp/repo/feature/src'
)
expect(callMock).toHaveBeenNthCalledWith(3, 'worktree.set', {
worktree: 'id:repo::/tmp/repo/feature',
displayName: undefined,
linkedIssue: undefined,
comment: 'hello',
parentWorktree: undefined,
noParent: false
})
})
it('resolves current for explicit parent-worktree on set', async () => {
queueFixtures(
callMock,
worktreeListFixture([buildWorktree('/tmp/repo/parent', 'feature/parent')]),
noFolderWorkspacesFixture(),
okFixture('req_set_parent', {
worktree: {
...buildWorktree('/tmp/repo/child', 'feature/child'),
parentWorktreeId: 'repo::/tmp/repo/parent',
childWorktreeIds: [],
lineage: null
}
})
)
vi.spyOn(console, 'log').mockImplementation(() => {})
await main(
[
'worktree',
'set',
'--worktree',
'id:repo::/tmp/repo/child',
'--parent-worktree',
'current',
'--json'
],
'/tmp/repo/parent/src'
)
expect(callMock).toHaveBeenNthCalledWith(3, 'worktree.set', {
worktree: 'id:repo::/tmp/repo/child',
displayName: undefined,
linkedIssue: undefined,
comment: undefined,
parentWorktree: 'id:repo::/tmp/repo/parent',
noParent: false
})
})
it('rejects contradictory parent flags on worktree.set before resolving selectors', async () => {
const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
const errSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
const priorExitCode = process.exitCode
await main(
[
'worktree',
'set',
'--worktree',
'id:repo::/tmp/repo/child',
'--parent-worktree',
'current',
'--no-parent',
'--json'
],
'/tmp/not-managed'
)
expect(callMock).not.toHaveBeenCalled()
expect([...logSpy.mock.calls, ...errSpy.mock.calls].flat().join('\n')).toContain(
'Choose either --parent-worktree or --no-parent, not both.'
)
expect(process.exitCode).toBe(1)
process.exitCode = priorExitCode
})
it('rejects bare parent-worktree on worktree.set', async () => {
const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
const errSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
const priorExitCode = process.exitCode
await main(
['worktree', 'set', '--worktree', 'id:repo::/tmp/repo/child', '--parent-worktree', '--json'],
'/tmp/repo'
)
expect(callMock).not.toHaveBeenCalled()
expect([...logSpy.mock.calls, ...errSpy.mock.calls].flat().join('\n')).toContain(
'Missing required --parent-worktree'
)
expect(process.exitCode).toBe(1)
process.exitCode = priorExitCode
})
it('passes Linear URL metadata through worktree.set', async () => {
queueFixtures(
callMock,
okFixture('req_set_linear', {
worktree: {
...buildWorktree('/tmp/repo/child', 'feature/child'),
linkedLinearIssue: 'STA-335',
linkedLinearIssueWorkspaceId: null,
linkedLinearIssueOrganizationUrlKey: 'stably'
}
})
)
vi.spyOn(console, 'log').mockImplementation(() => {})
await main(
[
'worktree',
'set',
'--worktree',
'id:repo::/tmp/repo/child',
'--linear-issue',
'https://linear.app/stably/issue/STA-335/test-issue',
'--json'
],
'/tmp/repo'
)
expect(callMock).toHaveBeenCalledWith('worktree.set', {
worktree: 'id:repo::/tmp/repo/child',
displayName: undefined,
linkedIssue: undefined,
linkedLinearIssue: 'STA-335',
linkedLinearIssueWorkspaceId: null,
linkedLinearIssueOrganizationUrlKey: 'stably',
comment: undefined,
workspaceStatus: undefined,
parentWorktree: undefined,
noParent: false
})
})
it('clears all Linear metadata through worktree.set', async () => {
queueFixtures(
callMock,
okFixture('req_clear_linear', {
worktree: {
...buildWorktree('/tmp/repo/child', 'feature/child'),
linkedLinearIssue: null,
linkedLinearIssueWorkspaceId: null,
linkedLinearIssueOrganizationUrlKey: null
}
})
)
vi.spyOn(console, 'log').mockImplementation(() => {})
await main(
[
'worktree',
'set',
'--worktree',
'id:repo::/tmp/repo/child',
'--linear-issue',
'null',
'--json'
],
'/tmp/repo'
)
expect(callMock).toHaveBeenCalledWith('worktree.set', {
worktree: 'id:repo::/tmp/repo/child',
displayName: undefined,
linkedIssue: undefined,
linkedLinearIssue: null,
linkedLinearIssueWorkspaceId: null,
linkedLinearIssueOrganizationUrlKey: null,
comment: undefined,
workspaceStatus: undefined,
parentWorktree: undefined,
noParent: false
})
})
it('rejects invalid Linear issue values on worktree.set before RPC', async () => {
const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
const errSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
const priorExitCode = process.exitCode
await main(
[
'worktree',
'set',
'--worktree',
'id:repo::/tmp/repo/child',
'--linear-issue',
'not-a-linear-link',
'--json'
],
'/tmp/repo'
)
expect(callMock).not.toHaveBeenCalled()
expect([...logSpy.mock.calls, ...errSpy.mock.calls].flat().join('\n')).toContain(
'Pass a Linear issue identifier like STA-335'
)
expect(process.exitCode).toBe(1)
process.exitCode = priorExitCode
})
it.each([[['--comment', '']], [['--comment=']]])(
'sends an explicit empty comment for %j so worktree.set clears it',
async (flags) => {
queueFixtures(
callMock,
okFixture('req_clear_comment', {
worktree: buildWorktree('/tmp/repo/child', 'feature/child')
})
)
vi.spyOn(console, 'log').mockImplementation(() => {})
await main(
['worktree', 'set', '--worktree', 'id:repo::/tmp/repo/child', ...flags, '--json'],
'/tmp/repo'
)
expect(callMock).toHaveBeenCalledExactlyOnceWith(
'worktree.set',
expect.objectContaining({ worktree: 'id:repo::/tmp/repo/child', comment: '' })
)
}
)
it.each([
{ flags: ['--read'], isUnread: false, acknowledges: true },
{ flags: ['--unread'], isUnread: true, acknowledges: false },
{ flags: [], isUnread: undefined, acknowledges: false }
])(
'sends acknowledgement intent only for explicit --read: $flags',
async ({ flags, isUnread, acknowledges }) => {
queueFixtures(
callMock,
okFixture('req_read', { worktree: buildWorktree('/tmp/repo/child', 'feature/child') })
)
vi.spyOn(console, 'log').mockImplementation(() => {})
await main(
['worktree', 'set', '--worktree', 'id:repo::/tmp/repo/child', ...flags, '--json'],
'/tmp/repo'
)
expect(callMock).toHaveBeenCalledExactlyOnceWith(
'worktree.set',
expect.objectContaining(isUnread === undefined ? {} : { isUnread })
)
const params = callMock.mock.calls[0][1]
if (acknowledges) {
expect(params).toHaveProperty('acknowledgeAttention', true)
} else {
expect(params).not.toHaveProperty('acknowledgeAttention')
}
}
)
it.each([
[['--unread', '--read'], 'Choose either --unread or --read'],
[['--read', '--unread'], 'Choose either --unread or --read'],
[['--read', 'yes'], '--read takes no value'],
[['--read=false'], '--read takes no value'],
[['--read='], '--read takes no value'],
[['--unread=false'], '--unread takes no value'],
[['--unread='], '--unread takes no value']
])('rejects %j on worktree.set before resolving selectors', async (flags, message) => {
const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
const errSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
const priorExitCode = process.exitCode
// Resolving active makes an RPC, so no calls proves validation ran first.
await main(['worktree', 'set', '--worktree', 'active', ...flags, '--json'], '/tmp/repo')
expect(callMock).not.toHaveBeenCalled()
expect([...logSpy.mock.calls, ...errSpy.mock.calls].flat().join('\n')).toContain(message)
expect(process.exitCode).toBe(1)
process.exitCode = priorExitCode
})
it('refuses a parent on this machine before any write when the server lacks cross-machine lineage', async () => {
vi.spyOn(console, 'log').mockImplementation(() => {})
vi.spyOn(console, 'error').mockImplementation(() => {})
const priorExitCode = process.exitCode
pairRuntimeEnvironment(listEnvironmentsMock, 'build-box')
callMock.mockImplementation(async (method: string) => {
if (method === 'worktree.list') {
return worktreeListFixture([buildWorktree('/tmp/repo', 'main')])
}
if (method === 'status.get') {
return okFixture('req_status', { capabilities: [] })
}
if (method === 'worktree.show') {
const parent = { ...buildWorktree('/tmp/repo', 'main'), instanceId: 'parent-instance' }
return okFixture('req_show', { worktree: parent })
}
if (method === 'worktree.lineageList') {
return okFixture('req_lineage', { lineage: {}, installationId: 'mac-install' })
}
return okFixture('req_set', { worktree: buildWorktree('/srv/child', 'child') })
})
try {
await main(
[
'worktree',
'set',
'--worktree',
'id:repo::/srv/child',
'--parent-worktree',
'active',
'--display-name',
'renamed',
'--environment',
'build-box',
'--json'
],
'/tmp/repo'
)
const methods = callMock.mock.calls.map(([method]) => method)
expect(methods).toContain('status.get')
expect(methods).not.toContain('worktree.set')
expect(process.exitCode).toBe(1)
} finally {
process.exitCode = priorExitCode
}
})
})
+13 -213
View File
@@ -2,62 +2,17 @@ import { win32 } from 'node:path'
import type * as NodePath from 'node:path'
import { describe, expect, it, vi } from 'vitest'
const {
callMock,
runtimeClientConstructorMock,
serveOrcaAppMock,
getDefaultUserDataPathMock,
addEnvironmentFromPairingCodeMock,
listEnvironmentsMock,
spawnMock
} = vi.hoisted(() => ({
callMock: vi.fn(),
runtimeClientConstructorMock: vi.fn(),
serveOrcaAppMock: vi.fn(),
getDefaultUserDataPathMock: vi.fn(() => '/tmp/orca-user-data'),
addEnvironmentFromPairingCodeMock: vi.fn(),
listEnvironmentsMock: vi.fn(),
spawnMock: vi.fn()
}))
vi.mock('./runtime-client', async () => {
const { createRuntimeClientModuleMock } = await import('./index-test-harness.js')
return createRuntimeClientModuleMock({
callMock,
runtimeClientConstructorMock,
serveOrcaAppMock,
getDefaultUserDataPathMock
})
})
vi.mock('./runtime/environments', () => ({
addEnvironmentFromPairingCode: addEnvironmentFromPairingCodeMock,
removeEnvironment: vi.fn(),
resolveEnvironment: vi.fn()
}))
vi.mock('../shared/remote-runtime/host-store/runtime-environment-store', () => ({
listEnvironments: listEnvironmentsMock
}))
vi.mock('child_process', async () => {
const { createChildProcessModuleMock } = await import('./index-test-harness.js')
return createChildProcessModuleMock(spawnMock)
})
// Exercise production UNC resolution on every CI host; keep matching and elections real.
vi.mock('node:path', async (importOriginal) => {
const actual = await importOriginal<typeof NodePath>()
return { ...actual, resolve: actual.win32.resolve }
})
import { main } from './index'
import {
selectEnclosingRepoOnHost,
selectEnclosingWorktreeSelectionOnHost
} from './caller-host-worktree-selection'
import { buildWorktree, okFixture, worktreeListFixture } from './test-fixtures'
import { useWorktreeAwarenessEnvironment } from './index-test-harness'
import { buildWorktree } from './test-fixtures'
import { toSshExecutionHostId } from '../shared/execution-host'
const UPPER = String.raw`\\wsl.localhost\Ubuntu\home\Alice\App`
@@ -66,29 +21,19 @@ const upper = buildWorktree(UPPER, 'main', 'abc', 'repo-a')
const lower = buildWorktree(LOWER, 'main', 'abc', 'repo-b')
describe('WSL enclosing selection with Windows path resolution on every platform', () => {
useWorktreeAwarenessEnvironment({
callMock,
serveOrcaAppMock,
getDefaultUserDataPathMock,
addEnvironmentFromPairingCodeMock,
listEnvironmentsMock,
spawnMock
})
it.each([
[UPPER, String.raw`\\wsl$\ubuntu\home\Alice\App\src`],
['\\\\wsl$\\Ubuntu\\home\\Alice\\App\\', '//wsl.localhost/ubuntu/home/Alice/App/src'],
['//wsl.localhost/Ubuntu/home/Alice/App/', String.raw`\\wsl$\Ubuntu\home\Alice\App\src`]
])('retains original identity for uppercase-tail aliases: %s', (root, cwd) => {
const row = buildWorktree(root, 'main', 'abc', 'repo-a')
for (const caller of [undefined, row.id]) {
expect(selectEnclosingWorktreeSelectionOnHost([row], cwd, 'local', caller)).toEqual({
selector: `id:${row.id}`,
worktreeId: row.id
})
expect(selectEnclosingRepoOnHost([row], cwd, 'local', caller)).toBe('repo-a')
it.each([[UPPER, String.raw`\\wsl$\ubuntu\home\Alice\App\src`]])(
'retains original identity for uppercase-tail aliases: %s',
(root, cwd) => {
const row = buildWorktree(root, 'main', 'abc', 'repo-a')
for (const caller of [undefined, row.id]) {
expect(selectEnclosingWorktreeSelectionOnHost([row], cwd, 'local', caller)).toEqual({
selector: `id:${row.id}`,
worktreeId: row.id
})
expect(selectEnclosingRepoOnHost([row], cwd, 'local', caller)).toBe('repo-a')
}
}
})
)
it('excludes case-distinct directories before caller preference in either order', () => {
for (const rows of [
@@ -113,149 +58,4 @@ describe('WSL enclosing selection with Windows path resolution on every platform
).toBeUndefined()
expect(selectEnclosingRepoOnHost([wrongDistro, wrongHost], UPPER, 'local')).toBeUndefined()
})
it('keeps canonical caller ties and nested checkout priority in both elections', () => {
const nfc = buildWorktree('C:\\projects\\café', 'main', 'abc', 'repo-a')
const nfd = buildWorktree('C:\\projects\\cafe\u0301', 'main', 'abc', 'repo-b')
const nested = buildWorktree(win32.join(nfc.path, 'nested'), 'main', 'abc', 'repo-child')
for (const rows of [
[nfc, nfd],
[nfd, nfc]
]) {
expect(
selectEnclosingWorktreeSelectionOnHost(rows, nfc.path, 'local', nfc.id)?.worktreeId
).toBe(nfc.id)
expect(selectEnclosingRepoOnHost(rows, nfc.path, 'local', nfc.id)).toBe('repo-a')
expect(() => selectEnclosingRepoOnHost(rows, nfc.path, 'local')).toThrow('Choose the project')
for (const nestedRows of [
[...rows, nested],
[nested, ...rows]
]) {
const cwd = win32.join(nested.path, 'src')
expect(
selectEnclosingWorktreeSelectionOnHost(nestedRows, cwd, 'local', nfc.id)?.worktreeId
).toBe(nested.id)
expect(selectEnclosingRepoOnHost(nestedRows, cwd, 'local', nfc.id)).toBe('repo-child')
}
}
})
it.each([
{ owner: upper, catalog: [upper], caller: undefined },
{ owner: upper, catalog: [upper, lower], caller: lower.id },
{ owner: lower, catalog: [upper, lower], caller: undefined },
{ owner: lower, catalog: [upper, lower], caller: upper.id },
{ owner: lower, catalog: [upper, lower], caller: lower.id }
])(
'forwards the containing owner through current, parent and scoped CLI routes: $owner.repoId / $caller',
async ({ owner, catalog, caller }) => {
const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
const priorExitCode = process.exitCode
const selector = `id:${owner.id}`
const child = buildWorktree(win32.join(owner.path, 'child'), 'child', 'abc', owner.repoId)
const commands = [
{ args: ['worktree', 'current'], method: 'worktree.show', target: { worktree: selector } },
{
args: ['worktree', 'show', '--worktree', 'current'],
method: 'worktree.show',
target: { worktree: selector }
},
...['active', 'current'].map((parent) => ({
args: [
'worktree',
'create',
'--name',
'child',
'--repo',
'id:explicit-destination',
'--parent-worktree',
parent
],
method: 'worktree.create',
target: { repo: 'id:explicit-destination', parentWorktree: selector }
})),
{
args: ['worktree', 'create', '--name', 'child', '--parent-worktree', 'current'],
method: 'worktree.create',
target: { repo: `id:${owner.repoId}`, parentWorktree: selector }
},
{
args: ['worktree', 'create', '--name', 'child'],
method: 'worktree.create',
target: {
repo: `id:${owner.repoId}`,
cwdParentWorktree: selector,
...(caller ? { envParentWorkspace: `worktree:${caller}` } : {})
}
},
...[[], ['--worktree', 'current']].map((scope) => ({
args: ['snapshot', ...scope],
method: 'browser.snapshot',
target: { worktree: selector }
})),
{
args: ['terminal', 'read'],
method: 'terminal.resolveActive',
target: { worktree: selector }
}
]
try {
if (caller) {
process.env.ORCA_WORKTREE_ID = caller
}
for (const rows of [catalog, catalog.toReversed()]) {
for (const command of commands) {
callMock.mockReset()
logSpy.mockClear()
process.exitCode = priorExitCode
callMock.mockImplementation(async (method: string) => {
if (method === 'worktree.list') {
return worktreeListFixture(rows)
}
if (method === 'worktree.show') {
return okFixture('show', { worktree: owner })
}
if (method === 'worktree.create') {
return okFixture('create', { worktree: child, lineage: null, warnings: [] })
}
if (method === 'terminal.resolveActive') {
return okFixture('terminal', { handle: 'terminal-1' })
}
return okFixture('scoped', { terminal: { text: 'ready' }, snapshot: 'ready' })
})
await main([...command.args, '--json'], win32.join(owner.path, 'src'))
expect(
process.exitCode,
JSON.stringify({
args: [...command.args, '--json'],
cwd: win32.join(owner.path, 'src'),
caller: caller ?? null,
catalogIds: rows.map((row) => row.id),
output: JSON.stringify(logSpy.mock.calls).slice(0, 4000),
calls: JSON.stringify(callMock.mock.calls).slice(0, 4000)
})
).toBe(priorExitCode)
expect(callMock).toHaveBeenCalledWith(
command.method,
expect.objectContaining(command.target)
)
if (command.method === 'worktree.show') {
expect(JSON.parse(String(logSpy.mock.calls[0]?.[0])).result.worktree).toMatchObject({
id: owner.id,
path: owner.path
})
}
if (command.method === 'terminal.resolveActive') {
expect(callMock).toHaveBeenCalledWith('terminal.read', {
terminal: 'terminal-1',
limit: undefined
})
}
}
}
} finally {
process.exitCode = priorExitCode
}
}
)
})
+1 -473
View File
@@ -1,5 +1,4 @@
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
import { worktreeRemovalReplyTimeoutMs } from '../shared/worktree/archive-hook-removal-gate'
const {
callMock,
@@ -44,24 +43,9 @@ vi.mock('child_process', async () => {
return createChildProcessModuleMock(spawnMock)
})
import { COMMAND_SPECS, main } from './index'
import { specPaths } from './args'
import { main } from './index'
import { okFixture, queueFixtures } from './test-fixtures'
describe('COMMAND_SPECS collision check', () => {
it('has no duplicate command or alias paths', () => {
// First-match resolution would silently shadow duplicate aliases.
const seen = new Set<string>()
for (const spec of COMMAND_SPECS) {
for (const path of specPaths(spec)) {
const key = path.join(' ')
expect(seen.has(key), `Duplicate command/alias path: "${key}"`).toBe(false)
seen.add(key)
}
}
})
})
describe('command aliases dispatch to the canonical handler', () => {
let logSpy: ReturnType<typeof vi.spyOn>
@@ -76,78 +60,6 @@ describe('command aliases dispatch to the canonical handler', () => {
logSpy.mockRestore()
})
it('runs `worktree remove` as the canonical `worktree rm` (the incident)', async () => {
queueFixtures(
callMock,
okFixture('req_show', { worktree: { hostId: 'local' } }),
okFixture('req', { removed: true })
)
await main(['worktree', 'remove', '--worktree', 'id:wt-1', '--force', '--json'], '/tmp/repo')
expect(callMock).toHaveBeenNthCalledWith(
2,
'worktree.rm',
expect.objectContaining({ worktree: 'id:wt-1', hostId: 'local', force: true }),
expect.anything()
)
})
it('asks the host to reply with the delete outcome and waits past Git deletion (#35135)', async () => {
queueFixtures(
callMock,
okFixture('req_show', { worktree: { hostId: 'local' } }),
okFixture('req', { removed: true })
)
await main(['worktree', 'rm', '--worktree', 'id:wt-1', '--run-hooks'], '/tmp/repo')
expect(callMock).toHaveBeenNthCalledWith(
2,
'worktree.rm',
expect.objectContaining({ waitForBackgroundRemoval: true }),
{
timeoutMs: worktreeRemovalReplyTimeoutMs(true),
requestSelection: {
paramsForStatus: expect.any(Function),
onDispatch: expect.any(Function)
}
}
)
expect(logSpy).toHaveBeenCalledWith('removed: true')
})
it('does not say removed when an older host only accepted a background removal', async () => {
queueFixtures(
callMock,
okFixture('req_show', { worktree: { hostId: 'local' } }),
okFixture('req', { removed: true, removing: true })
)
await main(['worktree', 'rm', '--worktree', 'id:wt-1'], '/tmp/repo')
expect(logSpy).toHaveBeenCalledWith(
'removed: false\nOrca is still deleting the checkout in the background.'
)
})
it('leaves missing removal and branch outcomes unconfirmed', async () => {
queueFixtures(
callMock,
okFixture('show', { worktree: { hostId: 'local' } }),
okFixture('rm', {})
)
await main(['worktree', 'rm', '--worktree', 'id:wt-1', '--delete-branch'], '/tmp/repo')
expect(logSpy).toHaveBeenCalledWith('Removal is not confirmed.')
queueFixtures(
callMock,
okFixture('show', { worktree: { hostId: 'local' } }),
okFixture('rm', {})
)
await main(['worktree', 'rm', '--worktree', 'id:wt-1', '--json'], '/tmp/repo')
expect(JSON.parse(String(logSpy.mock.calls.at(-1)?.[0])).result).toEqual({})
})
it('fails closed when worktree removal cannot resolve a host', async () => {
queueFixtures(callMock, okFixture('req_show', { worktree: { id: 'wt-1' } }))
const priorExitCode = process.exitCode
@@ -167,49 +79,6 @@ describe('command aliases dispatch to the canonical handler', () => {
}
})
it('exits non-zero when worktree removal is refused by a failed archive hook', async () => {
const { RuntimeRpcFailureError } = await import('./runtime/types.js')
queueFixtures(callMock, okFixture('req_show', { worktree: { hostId: 'local' } }))
callMock.mockRejectedValueOnce(
new RuntimeRpcFailureError({
id: 'req_archive',
ok: false,
error: {
code: 'worktree_archive_hook_failed',
message: 'Archive hook failed for worktree: /tmp/wt — exited 23.'
},
_meta: { runtimeId: 'runtime-1' }
})
)
const priorExitCode = process.exitCode
try {
await main(
['worktree', 'rm', '--worktree', 'id:wt-1', '--force', '--run-hooks', '--json'],
'/tmp/repo'
)
expect(process.exitCode).toBe(1)
expect(callMock).toHaveBeenNthCalledWith(
2,
'worktree.rm',
expect.objectContaining({
runHooks: true,
allowFailedArchiveHook: false
}),
expect.anything()
)
expect(JSON.parse(String(logSpy.mock.calls.at(-1)?.[0]))).toMatchObject({
id: 'req_archive',
ok: false,
error: { code: 'worktree_archive_hook_failed' },
_meta: { runtimeId: 'runtime-1' }
})
} finally {
process.exitCode = priorExitCode
}
})
it('rejects the archive-hook waiver without --run-hooks instead of ignoring it', async () => {
queueFixtures(callMock, okFixture('req_show', { worktree: { hostId: 'local' } }))
const priorExitCode = process.exitCode
@@ -233,345 +102,4 @@ describe('command aliases dispatch to the canonical handler', () => {
process.exitCode = priorExitCode
}
})
it('forwards the explicit archive-hook waiver on worktree rm', async () => {
queueFixtures(
callMock,
okFixture('req_show', { worktree: { hostId: 'local' } }),
okFixture('req', { removed: true })
)
await main(
[
'worktree',
'rm',
'--worktree',
'id:wt-1',
'--run-hooks',
'--allow-failed-archive-hook',
'--json'
],
'/tmp/repo'
)
expect(callMock).toHaveBeenNthCalledWith(
2,
'worktree.rm',
expect.objectContaining({ runHooks: true, allowFailedArchiveHook: true }),
expect.anything()
)
})
it('serves `agent-context --json` without contacting the runtime', async () => {
runtimeClientConstructorMock.mockClear()
await main(['agent-context', '--json'], '/tmp/repo')
expect(runtimeClientConstructorMock).not.toHaveBeenCalled()
expect(callMock).not.toHaveBeenCalled()
const schema = JSON.parse(String(logSpy.mock.calls.at(-1)?.[0]))
expect(schema.schemaVersion).toBe(1)
const rm = schema.commands.find(
(command: { command: string }) => command.command === 'worktree rm'
)
expect(rm.aliases).toContainEqual(['worktree', 'remove'])
})
it('keeps `agent-context` local when remote environment variables are set', async () => {
vi.stubEnv('ORCA_PAIRING_CODE', 'pairing-code')
vi.stubEnv('ORCA_ENVIRONMENT', 'stale-environment')
try {
await main(['agent-context', '--json'], '/tmp/repo')
expect(process.exitCode).not.toBe(1)
expect(callMock).not.toHaveBeenCalled()
} finally {
vi.unstubAllEnvs()
}
})
})
describe('artifact runtime routing', () => {
afterEach(() => {
vi.unstubAllEnvs()
vi.restoreAllMocks()
process.exitCode = 0
})
it('uses the desktop runtime despite remote-selection environment fallbacks', async () => {
vi.stubEnv('ORCA_ENVIRONMENT', 'remote-environment')
vi.stubEnv('ORCA_PAIRING_CODE', 'remote-pairing-code')
vi.spyOn(console, 'log').mockImplementation(() => undefined)
callMock.mockResolvedValue(
okFixture('artifact-list', { status: 'ok', value: { artifacts: [] } })
)
runtimeClientConstructorMock.mockClear()
await main(['artifacts', 'list', '--json'], '/folder-workspace')
expect(process.exitCode).not.toBe(1)
expect(runtimeClientConstructorMock).toHaveBeenCalledWith(null, null)
expect(callMock).toHaveBeenCalledWith('artifacts.list', {})
})
})
describe('unknown command surfaces a suggestion', () => {
let errorSpy: ReturnType<typeof vi.spyOn>
beforeEach(() => {
callMock.mockReset()
errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
})
afterEach(() => {
errorSpy.mockRestore()
process.exitCode = 0
})
it('prints did-you-mean for a near-miss command and exits non-zero', async () => {
await main(['worktree', 'remov'], '/tmp/repo')
expect(process.exitCode).toBe(1)
const stderr = errorSpy.mock.calls.map((call) => String(call[0])).join('\n')
expect(stderr).toContain('Unknown command: worktree remov')
expect(stderr).toContain('orca worktree')
})
it.each([
['orchestration resume', 'orchestration reset'],
['artifacts deset', 'artifacts delete'],
['emulator ball', 'emulator kill'],
['emulator showdown', 'emulator shutdown'],
['orchestration worker-showw', 'orchestration worker-stop'],
['orchestration worker-relay', 'orchestration worker-release'],
['tab clues', 'tab close'],
['environment rollbook', 'environment rollback'],
['linear relation move', 'linear relation remove']
])('keeps %s recovery away from %s before runtime lookup', async (input, forbidden) => {
const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
runtimeClientConstructorMock.mockClear()
try {
await main([...input.split(' '), '--json'], '/tmp/repo')
expect(process.exitCode).toBe(1)
const output = logSpy.mock.calls.flat().join('\n')
expect(output).toContain('invalid_argument')
expect(JSON.parse(output)).toHaveProperty('ok', false)
expect(output).not.toContain(`orca ${forbidden}`)
expect(output).not.toContain(`"${forbidden}"`)
expect(runtimeClientConstructorMock).not.toHaveBeenCalled()
expect(callMock).not.toHaveBeenCalled()
} finally {
logSpy.mockRestore()
}
await main(input.split(' '), '/tmp/repo')
expect(errorSpy.mock.calls.flat().join('\n')).not.toContain(`orca ${forbidden}`)
expect(runtimeClientConstructorMock).not.toHaveBeenCalled()
expect(callMock).not.toHaveBeenCalled()
})
it('reports a mistyped pre-command flag without swallowing the command', async () => {
await main(['--jso', 'worktree', 'list'], '/tmp/repo')
expect(process.exitCode).toBe(1)
const stderr = errorSpy.mock.calls.map((call) => String(call[0])).join('\n')
expect(stderr).toContain('Unknown flag --jso for command: worktree list')
expect(stderr).toContain('--json')
})
it('names the offending --worktree value and the valid forms on selector_not_found', async () => {
const stdoutSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
const { RuntimeRpcFailureError } = await import('./runtime/types.js')
callMock.mockRejectedValue(
new RuntimeRpcFailureError({
id: 'req_selector',
ok: false,
error: { code: 'selector_not_found', message: 'selector_not_found' },
_meta: { runtimeId: 'runtime_local' }
})
)
await main(
[
'orchestration',
'worker-start',
'--task',
't1',
'--worktree',
'repo-1',
'--agent',
'codex',
'--from',
'term-caller'
],
'/tmp/repo'
)
expect(process.exitCode).toBe(1)
// Orchestration failures keep one stderr line and print the recovery detail on stdout.
const stderr = errorSpy.mock.calls.map((call) => String(call[0])).join('\n')
const stdout = stdoutSpy.mock.calls.map((call) => String(call[0])).join('\n')
expect(callMock).toHaveBeenCalledExactlyOnceWith(
'orchestration.workerStart',
expect.objectContaining({ worktree: 'repo-1', from: 'term-caller' })
)
expect(stderr).toBe('error: selector_not_found: selector_not_found')
expect(stdout).toContain('No Orca workspace matched the worktree selector "repo-1"')
expect(stdout).toContain('id:repo-1::<absolute-path>')
expect(stdout).toContain('Valid selector forms:')
})
it('reports a pre-command flag that belongs to another command', async () => {
await main(['--workspace', 'worktree', 'list'], '/tmp/repo')
expect(process.exitCode).toBe(1)
const stderr = errorSpy.mock.calls.map((call) => String(call[0])).join('\n')
expect(stderr).toContain('Unknown flag --workspace for command: worktree list')
})
it('reports a pre-command typo when a global flag splits the command path', async () => {
const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
await main(['--jso', 'worktree', '--json', 'list'], '/tmp/repo')
expect(process.exitCode).toBe(1)
expect(logSpy.mock.calls.flat().join('\n')).toContain(
'Unknown flag --jso for command: worktree list'
)
expect(callMock).not.toHaveBeenCalled()
logSpy.mockRestore()
})
it.each(['environment', 'pairing-code'])(
'rejects --%s without a selector before runtime construction',
async (flag) => {
runtimeClientConstructorMock.mockClear()
await main([`--${flag}`, 'worktree', 'list'], '/tmp/repo')
expect(process.exitCode).toBe(1)
const stderr = errorSpy.mock.calls.map((call) => String(call[0])).join('\n')
expect(stderr).toContain(`Flag --${flag} requires a value.`)
expect(runtimeClientConstructorMock).not.toHaveBeenCalled()
expect(callMock).not.toHaveBeenCalled()
}
)
})
describe('unknown help command surfaces a suggestion', () => {
it.each([
['help prefix', ['help', 'worktree', 'remov']],
['help flag', ['worktree', 'remov', '--help']]
])('prints did-you-mean for the %s form', async (_label, argv) => {
const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
await main(argv, '/tmp/repo')
expect(process.exitCode).toBe(1)
expect(logSpy.mock.calls.flat().join('\n')).toContain('Did you mean: orca worktree')
logSpy.mockRestore()
process.exitCode = 0
})
})
describe('nested command group help', () => {
it.each([
['browser', ['browser', '--help'], ['identity get', 'identity set']],
['browser identity', ['browser', 'identity', '--help'], ['get', 'set']],
['browser', ['browser'], ['identity get', 'identity set']],
['skills', ['skills'], ['installed', 'share']],
['browser identity', ['browser', 'identity'], ['get', 'set']]
])(
'prints successful help for %s without constructing a runtime client',
async (path, argv, commands) => {
const previousExitCode = process.exitCode
const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
runtimeClientConstructorMock.mockClear()
process.exitCode = 0
try {
await main(argv, '/tmp/repo')
expect(process.exitCode).toBe(0)
const output = logSpy.mock.calls.flat().join('\n')
expect(output).toContain(`orca ${path}`)
for (const command of commands) {
expect(output).toContain(command)
}
expect(output).not.toContain('Unknown command')
expect(runtimeClientConstructorMock).not.toHaveBeenCalled()
expect(callMock).not.toHaveBeenCalled()
} finally {
process.exitCode = previousExitCode
logSpy.mockRestore()
}
}
)
it('reports a flagged bare group as a missing subcommand, not a typo', async () => {
const previousExitCode = process.exitCode
const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
runtimeClientConstructorMock.mockClear()
process.exitCode = 0
try {
await main(['skills', '--worktree', 'active'], '/tmp/repo')
expect(process.exitCode).toBe(1)
const stderr = errorSpy.mock.calls.flat().join('\n')
expect(stderr).toContain('Missing subcommand for: orca skills')
expect(stderr).toContain('orca skills --help')
expect(stderr).not.toContain('Did you mean')
expect(runtimeClientConstructorMock).not.toHaveBeenCalled()
} finally {
process.exitCode = previousExitCode
errorSpy.mockRestore()
}
})
it('keeps an executable leaf ahead of its child groups', async () => {
const previousExitCode = process.exitCode
process.exitCode = 0
serveOrcaAppMock.mockClear().mockResolvedValue(0)
try {
await main(['serve'], '/tmp/repo')
expect(process.exitCode).toBe(0)
expect(serveOrcaAppMock).toHaveBeenCalledExactlyOnceWith(
expect.objectContaining({ json: false })
)
} finally {
process.exitCode = previousExitCode
serveOrcaAppMock.mockReset()
}
})
it('passes --bind to serve only when given, and refuses it with --mobile-pairing before launching', async () => {
const previousExitCode = process.exitCode
const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
serveOrcaAppMock.mockClear().mockResolvedValue(0)
try {
process.exitCode = 0
await main(['serve'], '/tmp/repo')
expect(serveOrcaAppMock).toHaveBeenLastCalledWith(expect.objectContaining({ bind: null }))
await main(['serve', '--bind', 'localhost'], '/tmp/repo')
expect(serveOrcaAppMock).toHaveBeenLastCalledWith(
expect.objectContaining({ bind: '127.0.0.1' })
)
expect(serveOrcaAppMock).toHaveBeenCalledTimes(2)
await main(['serve', '--bind', '127.0.0.1', '--mobile-pairing'], '/tmp/repo')
expect(serveOrcaAppMock).toHaveBeenCalledTimes(2)
expect(process.exitCode).toBe(1)
expect(errorSpy.mock.calls.flat().join('\n')).toContain(
'--mobile-pairing needs --bind 0.0.0.0'
)
} finally {
process.exitCode = previousExitCode
errorSpy.mockRestore()
serveOrcaAppMock.mockReset()
}
})
})
@@ -1,52 +0,0 @@
import { describe, expect, it, vi } from 'vitest'
import { formatServeRuntimeSelection } from '../../shared/orcad-local-serve-selection'
import type { runProcess } from '@orca/process-host'
import { resolveLocalServeRuntime } from './serve-orcad-launch'
type RunProcess = typeof runProcess
function answering(stdout: string, code = 0): RunProcess {
return vi.fn<RunProcess>(async () => ({
code,
signal: null,
stdout,
stderr: '',
timedOut: false
}))
}
const options = {
executable: '/Applications/Orca.app/Contents/MacOS/Orca',
appRoot: '/Applications/Orca.app/Contents/Resources/app.asar',
userDataPath: '/Users/u/Library/Application Support/orca',
usesMacUpdateHandoff: false
}
describe('orca serve asking the app which host to run', () => {
it('keeps packaged macOS on Electron without starting the app to ask', async () => {
const run = answering('')
expect(await resolveLocalServeRuntime({ ...options, usesMacUpdateHandoff: true }, run)).toEqual(
{
kind: 'electron',
reason: expect.stringContaining('packaged macOS')
}
)
expect(run).not.toHaveBeenCalled()
})
it('asks the app on packaged macOS when orcad is requested explicitly', async () => {
const selection = {
kind: 'orcad' as const,
runtime: '/rt/node',
entry: '/slot/orcad.js',
version: '1'
}
const run = answering(formatServeRuntimeSelection(selection))
expect(
await resolveLocalServeRuntime(
{ ...options, usesMacUpdateHandoff: true, env: { ORCA_SERVE_RUNTIME: 'orcad' } },
run
)
).toEqual(selection)
})
})
-18
View File
@@ -1,18 +0,0 @@
import { describe, expect, it } from 'vitest'
import { ACCOUNT_COMMAND_SPECS } from './account'
import { suggestCommands, unknownCommandData } from '../command-suggestion'
describe('account command specs', () => {
it.each(['move', 'go'])(
'suggestion safety keeps benign account %s mistakes out of profile deletion',
(verb) => {
const path = ['account', verb]
expect(suggestCommands(ACCOUNT_COMMAND_SPECS, path)).not.toContain('account rm')
expect(suggestCommands(ACCOUNT_COMMAND_SPECS, path)).not.toContain('account remove')
const data = unknownCommandData(ACCOUNT_COMMAND_SPECS, path)
expect(data.nextSteps.join(' ')).not.toContain('orca account rm')
expect(data.nextSteps.join(' ')).not.toContain('orca account remove')
}
)
})
@@ -5,13 +5,11 @@ import { join } from 'node:path'
import { afterEach, expect, it, vi } from 'vitest'
import capture from '../../../shared/__fixtures__/omp-native-commands.json'
import '../../../shared/priority-semaphore'
import { refreshAtRestCommandContext } from '../../native-chat/agent-session-wire/options/at-rest-command-context'
import {
commandDiscoveryRig,
DISCOVERY_SESSION,
ompRecord
} from './testing/acp-command-discovery.test-fixture'
import { deferred, tick } from '../process/testing/acp-scripted-agent.test-support'
import { acpLaunchSpecFor } from '../launch/acp-launch-registry'
import { readAcpForkSupport } from '../capabilities/acp-fork-support'
import { agentSessionRecordFixture } from '../../native-chat/agent-session-record-test-fixture'
@@ -26,7 +24,6 @@ vi.mock('node:fs/promises', async (importOriginal) => {
})
const rigs: Awaited<ReturnType<typeof commandDiscoveryRig>>[] = []
// Let real filesystem/protocol I/O finish without advancing the attempt's fake clock.
async function rig(...args: Parameters<typeof commandDiscoveryRig>) {
const opened = await commandDiscoveryRig(...args)
@@ -34,7 +31,6 @@ async function rig(...args: Parameters<typeof commandDiscoveryRig>) {
return opened
}
afterEach(async () => {
vi.useRealTimers()
await Promise.all(rigs.splice(0).map((rig) => rig.dispose()))
vi.restoreAllMocks()
})
@@ -97,50 +93,6 @@ it('observes pre-initialize reports, validates session identity and keeps the la
expect(children[0]!.lastCloseResult).toEqual({ root: 'exited', tree: null })
})
it('starts the 9 second deadline before readiness and cwd resolution', async () => {
vi.spyOn(console, 'warn').mockImplementation(() => {})
const readiness = deferred<void>()
const refreshing = refreshAtRestCommandContext(() => readiness.promise)
const cwd = deferred<string>()
const resolveWorkspacePath = vi.fn(() => cwd.promise)
const { catalog, children } = await rig(undefined, { resolveWorkspacePath })
vi.useFakeTimers({ toFake: ['Date', 'setTimeout', 'clearTimeout'] })
const first = catalog.settled(ompRecord('waiting-ready'), 10_000)
await vi.advanceTimersByTimeAsync(9_000)
expect(await first).toBeUndefined()
readiness.resolve()
await refreshing
expect(resolveWorkspacePath).not.toHaveBeenCalled()
const second = catalog.settled(ompRecord('waiting-cwd'), 10_000)
await vi.advanceTimersByTimeAsync(9_000)
expect(await second).toBeUndefined()
cwd.resolve('/work/late')
await tick()
expect(children).toEqual([])
})
it('answers before slow close, cancels queued deadlines and drains stop without launching waiters', async () => {
vi.spyOn(console, 'warn').mockImplementation(() => {})
const close = deferred<void>()
const { catalog, children } = await rig((child) => {
const prove = child.proveClose
child.proveClose = async () => {
await close.promise
return prove()
}
})
expect(await catalog.settled(ompRecord('one'), 1_000)).toBeDefined()
expect(await catalog.settled(ompRecord('two'), 1_000)).toBeDefined()
vi.useFakeTimers({ toFake: ['Date', 'setTimeout', 'clearTimeout'] })
const queued = catalog.settled(ompRecord('queued'), 10_000)
await vi.advanceTimersByTimeAsync(9_000)
expect(await queued).toBeUndefined()
const stop = catalog.closeAll()
close.resolve()
await stop
expect(children).toHaveLength(2)
})
it('handles actual root exit just before listener registration without changing historical evidence', async () => {
const evidence = Object.freeze({ root: 'live' as const, tree: 'unverifiable' as const })
const { catalog, children, root } = await rig((child) => {
@@ -1,184 +0,0 @@
import { mkdtemp, readdir, rm } from 'node:fs/promises'
import { tmpdir } from 'node:os'
import { dirname, join } from 'node:path'
import { afterEach, describe, expect, it, vi, type Mock } from 'vitest'
import { acpLaunchSpecFor } from '../launch/acp-launch-registry'
import type { AcpLaunchSpec } from '../launch/acp-launch-contract'
import {
createAcpModelCatalogProbe,
type AcpModelCatalogProbeDeps
} from './acp-model-catalog-probe'
import { AcpSessionRuntime } from '../protocol/acp-session-runtime'
import { AcpScriptedAgent } from '../process/testing/acp-scripted-agent.test-support'
import type { ProviderProcessLaunch } from '../../provider-process/provider-process-launch'
import { openCodeAcpAccountBinding } from '../../opencode/opencode-structured-account-home'
import recordedEfforts from '../fixtures/opencode-v2.0.21-model-efforts.json'
// Bypass the app's managed-account service for this fixture.
const OPENCODE: AcpLaunchSpec = {
...acpLaunchSpecFor('opencode')!,
account: openCodeAcpAccountBinding(() => ({
list: () => ({ activeAccountId: null, accounts: [] }),
restoreOriginalEnvironment: () => {},
environmentForAccount: () => ({})
}))
}
const agents: AcpScriptedAgent[] = []
afterEach(() => {
vi.restoreAllMocks()
for (const agent of agents.splice(0)) {
agent.close()
}
})
function scriptedOpenCode2(canDelete: boolean): {
agent: AcpScriptedAgent
launches: ProviderProcessLaunch[]
closed: () => number
deps: AcpModelCatalogProbeDeps & {
runListing: Mock<NonNullable<AcpModelCatalogProbeDeps['runListing']>>
}
} {
const agent = new AcpScriptedAgent()
agents.push(agent)
agent.on('initialize', (frame) =>
agent.reply(frame, {
protocolVersion: 1,
agentCapabilities: {
sessionCapabilities: canDelete ? { delete: {} } : {}
}
})
)
agent.on('session/new', (frame) =>
agent.reply(frame, {
sessionId: 'probe-session',
configOptions: [
{
id: 'model',
name: 'Model',
category: 'model',
type: 'select',
currentValue: 'opencode/exo-free',
options: [
{ value: 'opencode/big-pickle', name: 'Big Pickle' },
{ value: 'opencode/exo-free', name: 'Exo Free' }
]
}
]
})
)
agent.on('session/delete', (frame) => agent.reply(frame, {}))
agent.on('session/set_config_option', (frame) => agent.fail(frame, -32602, 'Model unavailable'))
const launches: ProviderProcessLaunch[] = []
let closes = 0
return {
agent,
launches,
closed: () => closes,
deps: {
resolveEnvironment: async () => ({ PATH: '/usr/bin', HOME: '/home/user' }),
resolveCommand: () => '/opt/opencode/bin/opencode',
probeVersion: async () => ({ version: '2.0.29' }),
homePath: '/home/user',
dataDirectory: '/orca-data',
runListing: vi.fn<NonNullable<AcpModelCatalogProbeDeps['runListing']>>(),
connectSession: (launch) => {
launches.push(launch)
const runtime = new AcpSessionRuntime(agent.stdout, agent.stdin)
return {
initialize: () => runtime.initialize(),
start: (options) => runtime.start(options),
setConfigOption: (id, value) => runtime.setConfigOption(id, value),
deleteSession: (sessionId) => runtime.deleteSession(sessionId),
close: async () => {
closes += 1
runtime.close()
}
}
}
}
}
}
describe('ACP model catalog probes', () => {
it('deletes a session before closing when cancelled during effort discovery', async () => {
vi.useFakeTimers()
try {
const { agent, deps, closed } = scriptedOpenCode2(true)
agent.on('session/new', (frame) =>
agent.reply(frame, { sessionId: 'probe-session', ...recordedEfforts.new })
)
agent.on('session/set_config_option', () => {})
agent.on('session/delete', (frame) => {
expect(closed()).toBe(0)
agent.reply(frame, {})
})
const stop = new AbortController()
const listing = createAcpModelCatalogProbe(OPENCODE, deps)(
{ kind: 'opencode', locator: { kind: 'unmanaged' } },
{ workspacePath: '/work/project', signal: stop.signal }
)
const rejected = expect(listing).rejects.toThrow(/listing stopped/)
await vi.waitFor(() =>
expect(agent.frames.map((frame) => frame.method)).toContain('session/set_config_option')
)
stop.abort()
await rejected
expect(agent.frames.at(-1)?.method).toBe('session/delete')
expect(closed()).toBe(1)
await vi.runAllTimersAsync()
} finally {
vi.useRealTimers()
}
})
it('lists OMP from a session kept in a folder it removes, in the chat folder', async () => {
const { agent, deps, launches } = scriptedOpenCode2(false)
const dataDirectory = await mkdtemp(join(tmpdir(), 'orca-omp-listing-'))
try {
const success = await createAcpModelCatalogProbe(acpLaunchSpecFor('omp')!, {
...deps,
dataDirectory,
resolveCommand: () => '/opt/omp/bin/omp',
probeVersion: async () => ({ version: '18.12.2' })
})(
{ variable: 'PI_CODING_AGENT_DIR', path: '/homes/omp' },
{ workspacePath: '/work/project' }
)
expect(agent.frames.map((frame) => frame.method)).toEqual(['initialize', 'session/new'])
expect(agent.frames[1]!.params).toMatchObject({ cwd: '/work/project' })
const root = join(dataDirectory, 'acp-listing-sessions', 'omp')
expect(launches).toEqual([
expect.objectContaining({
args: ['acp', '--session-dir', expect.stringMatching(/run-/)]
})
])
expect(dirname(launches[0]!.args[2]!)).toBe(root)
expect(await readdir(root)).toEqual([])
expect(success.models.map((model) => model.id)).toEqual([
'opencode/big-pickle',
'opencode/exo-free'
])
} finally {
await rm(dataDirectory, { recursive: true, force: true })
}
})
// An interrupted create can save a session without returning its ID.
it('stops a listing cut off while OpenCode 2.x creates its session, without deleting', async () => {
const { agent, deps, closed } = scriptedOpenCode2(true)
agent.on('session/new', () => {})
const stop = new AbortController()
const listing = createAcpModelCatalogProbe(OPENCODE, deps)(
{ kind: 'opencode', locator: { kind: 'unmanaged' } },
{ workspacePath: '/work/project', signal: stop.signal }
)
await vi.waitFor(() =>
expect(agent.frames.map((frame) => frame.method)).toContain('session/new')
)
stop.abort()
await expect(listing).rejects.toThrow(/listing stopped/)
expect(closed()).toBe(1)
expect(agent.frames.map((frame) => frame.method)).not.toContain('session/delete')
})
})
@@ -1,145 +0,0 @@
import { afterEach, describe, expect, it, vi } from 'vitest'
import type { AgentChildWorkEvidence } from '../../../shared/agent-status/child-work/agent-status-child-work-evidence'
import {
closeProviderTimelineRigs,
openProviderTimelineRig,
refusingSink
} from '../../native-chat/agent-session-timeline/provider-timeline-assembler-test-support'
import { AcpStructuredLane } from './acp-structured-lane'
import type { ProviderTimelineEvent } from '../../native-chat/agent-session-timeline/provider-timeline-event'
import { GROK_ACP_DIALECT } from '../acp-dialects/grok-dialect'
import { recordingStructuredAgentSessionLogger } from '../../native-chat/agent-session-wire/host/testing/structured-agent-session-logger-test-support'
const lanes: AcpStructuredLane[] = []
afterEach(async () => {
lanes.splice(0).forEach((lane) => lane.dispose())
await closeProviderTimelineRigs()
})
function subagent(
lane: AcpStructuredLane,
state: 'working' | 'completed'
): ProviderTimelineEvent[] {
const update =
state === 'working'
? { sessionUpdate: 'subagent_spawned', subagent_id: 'child', description: 'Exact label' }
: { sessionUpdate: 'subagent_finished', subagent_id: 'child', status: 'completed' }
return lane.translator.notification(
'_x.ai/session/update',
{ sessionId: 'provider-session-1', update },
1
)
}
async function fixture(reason: 'backpressure' | 'failed' = 'backpressure') {
const rig = await openProviderTimelineRig()
const delivery: AgentChildWorkEvidence[][] = []
const refused = { value: false }
const failed = vi.fn()
const lane = new AcpStructuredLane({
sink: refusingSink(rig.sink, () => refused.value, reason),
sessionId: 'session-timeline',
providerSessionId: 'provider-session-1',
agent: 'grok',
agentName: 'Grok',
generation: 'gen-1',
dialect: GROK_ACP_DIALECT,
logger: recordingStructuredAgentSessionLogger().logger,
onInputAccepted: () => {},
onFailed: failed,
onChildWorkEvidence: (evidence) => delivery.push(evidence),
now: () => 10
})
lanes.push(lane)
return { rig, lane, refused, delivery, failed }
}
describe('ACP subagent evidence at the ordered journal boundary', () => {
it('holds working and finished snapshots in order across backpressure and publishes each once', async () => {
const { rig, lane, refused, delivery } = await fixture()
refused.value = true
lane.apply(subagent(lane, 'working'))
lane.apply(subagent(lane, 'completed'))
await rig.rows()
expect(delivery).toEqual([])
refused.value = false
lane.retry()
await rig.rows()
expect(delivery.map((batch) => batch.map((edge) => edge.type))).toEqual([['live'], ['ended']])
expect(delivery[0][0]).toMatchObject({ child: { kind: 'agent', description: 'Exact label' } })
expect(delivery[1][0]).toMatchObject({ outcome: 'succeeded' })
lane.retry()
await rig.rows()
expect(delivery).toHaveLength(2)
})
it('publishes no subagent facts for fatal refusal, disposed held events or events dropped after session end', async () => {
const fatal = await fixture('failed')
fatal.refused.value = true
fatal.lane.apply(subagent(fatal.lane, 'working'))
await fatal.rig.rows()
expect(fatal.failed).toHaveBeenCalledWith('failed')
expect(fatal.delivery).toEqual([])
const held = await fixture()
held.refused.value = true
held.lane.apply(subagent(held.lane, 'working'))
held.lane.dispose()
held.refused.value = false
held.lane.retry()
await held.rig.rows()
expect(held.delivery.flat().map((edge) => edge.type)).toEqual(['session-ended'])
const ended = await fixture()
ended.lane.apply([
{ type: 'session.ended', verdict: { state: 'interrupted', completedAt: 10 } }
])
await ended.rig.rows()
ended.lane.apply(subagent(ended.lane, 'working'))
await ended.rig.rows()
expect(ended.delivery.flat().map((edge) => edge.type)).toEqual(['session-ended'])
})
it('does not let a throwing optional evidence consumer poison the journal', async () => {
const { rig, lane } = await fixture()
const failure = vi.fn()
const throwing = new AcpStructuredLane({
sink: rig.sink,
sessionId: 'session-timeline',
providerSessionId: 'provider-session-1',
agent: 'grok',
agentName: 'Grok',
generation: 'gen-2',
dialect: GROK_ACP_DIALECT,
logger: recordingStructuredAgentSessionLogger().logger,
onInputAccepted: () => {},
onFailed: failure,
onChildWorkEvidence: () => {
throw new Error('sink unavailable')
},
onChildWorkFailure: failure
})
lane.dispose()
lanes.push(throwing)
throwing.apply(subagent(throwing, 'working'))
throwing.apply(subagent(throwing, 'completed'))
throwing.apply([{ type: 'turn.open', turn: 'turn', at: 2 }])
expect((await rig.rows()).map((row) => row.body)).toMatchObject([
{ kind: 'turn', turnId: 'p:provider-session-1:turn', state: 'running', startedAt: 2 }
])
expect(failure).toHaveBeenCalledTimes(2)
})
it('releases live ownership when session-end admission is held and disposal ends observation', async () => {
const { rig, lane, refused, delivery } = await fixture()
lane.apply(subagent(lane, 'working'))
await rig.rows()
refused.value = true
lane.apply([{ type: 'session.ended', verdict: { state: 'interrupted', completedAt: 20 } }])
lane.dispose()
await rig.rows()
expect(delivery.flat().map((edge) => edge.type)).toEqual(['live', 'session-ended'])
lane.apply(subagent(lane, 'working'))
lane.retry()
await rig.rows()
expect(delivery.flat().map((edge) => edge.type)).toEqual(['live', 'session-ended'])
})
})
@@ -1,132 +0,0 @@
import { createAcpStructuredLaunchResolver } from '../../runtime/agent-session/launch/structured-agent-launch-composition.test-support'
import { mkdtempSync, rmSync } from 'node:fs'
import { tmpdir } from 'node:os'
import { join } from 'node:path'
import { describe, expect, it, onTestFinished, vi } from 'vitest'
import { FLOATING_TERMINAL_WORKTREE_ID } from '../../../shared/constants'
import type { AgentSessionRecord } from '../../../shared/agent-session/lifecycle/agent-session-record'
import { agentSessionRecordFixture } from '../../../shared/agent-session/lifecycle/agent-session-record.test-fixture'
import type { JournalLoad } from '../../native-chat/agent-session-journal/replay/journal-open'
import { acpLaunchSpecFor } from './acp-launch-registry'
const GROK = acpLaunchSpecFor('grok')!
const OMP = acpLaunchSpecFor('omp')!
const identity = {
sessionId: 'session-alpha-1',
workspaceId: 'workspace-1',
hostId: 'local',
agent: 'grok',
providerHandle: null
}
function grokRecord(overrides: Partial<AgentSessionRecord> = {}): AgentSessionRecord {
return {
...agentSessionRecordFixture(),
provider: 'grok',
providerHandleChain: [],
accountHome: { variable: 'GROK_HOME', path: '/home/user/.grok-work' },
...overrides
}
}
function ompRecord(options: Record<string, string>, resumes: boolean): AgentSessionRecord {
return grokRecord({
provider: 'omp',
accountHome: { variable: 'PI_CODING_AGENT_DIR', path: '/home/user/.omp/agent' },
options,
providerHandleChain: resumes
? [
{
linkId: 'link-created',
origin: 'created',
mintedAtFence: 1,
observedAt: 1,
handle: { transport: 'acp', agent: 'omp', nativeId: 'omp-1' }
}
]
: []
})
}
function resolver(
record: AgentSessionRecord,
readJournal: () => JournalLoad | null = () => null,
spec = GROK
) {
const searched: (string | null | undefined)[] = []
return {
searched,
resolve: createAcpStructuredLaunchResolver(spec, {
store: { getRecord: () => record, pinLaunchDirectory: vi.fn() },
readJournal,
resolveWorkspacePath: async () => '/repo/worktree',
resolveEnvironment: async () => ({ PATH: '/usr/bin', HOME: '/home/user' }),
resolveLaunchEnv: () => ({ GROK_EXTRA: '1' }),
resolveCommand: (command, options) => {
searched.push(options?.pathEnv)
return `/resolved/${command}`
}
})
}
}
describe('ACP launch resolution', () => {
it('starts a new OMP chat with its saved model on the launch line, where OMP resolves roles', async () => {
const start = (resumes: boolean) =>
resolver(
ompRecord({ model: '@worker_be', effort: 'medium' }, resumes),
() => null,
OMP
).resolve({ identity })
const fresh = await start(false)
expect(fresh.args.slice(-2)).toEqual(['--model', '@worker_be'])
expect(fresh.args).not.toContain('--thinking')
expect(fresh.launchModel).toBe('@worker_be')
// A load restores the conversation's own model; the session applies the saved one instead.
const resumed = await start(true)
expect(resumed.args).not.toContain('--model')
expect(resumed.launchModel).toBeUndefined()
})
})
describe('ACP launch folder of a floating chat', () => {
const floating = (launchDirectory?: string) =>
grokRecord({
location: { ...grokRecord().location, workspaceId: FLOATING_TERMINAL_WORKTREE_ID },
...(launchDirectory ? { launchDirectory } : {})
})
const resolveIn = (record: AgentSessionRecord, currentSetting: string) => {
const resolveWorkspacePath = vi.fn(async () => currentSetting)
const pinLaunchDirectory = vi.fn()
const resolve = createAcpStructuredLaunchResolver(GROK, {
store: { getRecord: () => record, pinLaunchDirectory },
readJournal: () => null,
resolveWorkspacePath,
resolveEnvironment: async () => ({ PATH: '/usr/bin', HOME: '/home/user' }),
resolveCommand: (command) => `/resolved/${command}`
})
return { resolve, resolveWorkspacePath, pinLaunchDirectory }
}
it('launches in the folder the chat was pinned to after the floating setting moved', async () => {
const pinned = mkdtempSync(join(tmpdir(), 'orca-acp-floating-'))
try {
const { resolve, resolveWorkspacePath } = resolveIn(floating(pinned), '/floating/moved')
await expect(resolve({ identity })).resolves.toMatchObject({ cwd: pinned })
expect(resolveWorkspacePath).not.toHaveBeenCalled()
} finally {
rmSync(pinned, { recursive: true, force: true })
}
})
it('refuses with the folder-missing reason when the pinned folder is gone', async () => {
const gone = mkdtempSync(join(tmpdir(), 'orca-acp-floating-gone-'))
rmSync(gone, { recursive: true, force: true })
onTestFinished(() => rmSync(gone, { recursive: true, force: true }))
const { resolve } = resolveIn(floating(gone), '/floating/moved')
await expect(resolve({ identity })).rejects.toMatchObject({
name: 'AgentSessionPreSpawnError',
reason: 'launchFolderMissing'
})
})
})
@@ -1,95 +0,0 @@
import { mkdir, mkdtemp, realpath, rm, truncate, writeFile } from 'node:fs/promises'
import { tmpdir } from 'node:os'
import { basename, join } from 'node:path'
import { afterEach, expect, it, onTestFinished, vi } from 'vitest'
import { agentSessionRecordFixture } from '../../../shared/agent-session/lifecycle/agent-session-record.test-fixture'
import { closeProviderTimelineRigs } from '../../native-chat/agent-session-timeline/provider-timeline-assembler-test-support'
import {
RUNTIME_RELEASE_RECEIPT,
writeRuntimeReleaseReceipt
} from '../../node-runtime/managed-runtime-release'
import { createAcpStructuredLaunchResolver } from '../../runtime/agent-session/launch/structured-agent-launch-composition.test-support'
import { GROK, openAcpAdapterRig } from '../session/testing/acp-structured-adapter.test-support'
afterEach(() => closeProviderTimelineRigs())
it('prefers the pin even when older, else a complete installed or external copy', async () => {
const dataDirectory = await mkdtemp(join(tmpdir(), 'orca-acp-managed-'))
onTestFinished(() => rm(dataDirectory, { recursive: true, force: true }))
const homePath = join(dataDirectory, 'home')
const command = `orca-managed-${basename(dataDirectory)}`
const root = join(dataDirectory, 'agent-runtimes', 'grok')
const pin = {
version: '1.0',
url: 'https://example.test/grok-1.0.zip',
archiveSha256: 'a'.repeat(64),
archiveBytes: 10,
members: [
{ path: command, sha256: 'b'.repeat(64), bytes: 6 },
{ path: 'harness', sha256: 'c'.repeat(64), bytes: 7 }
]
}
const spec = {
...GROK,
command,
managedRuntime: { label: 'Grok', root: () => root, pin: () => pin }
}
const spawn = async () => {
const resolveLaunch = createAcpStructuredLaunchResolver(spec, {
store: {
getRecord: () => ({
...agentSessionRecordFixture(),
provider: 'grok',
providerHandleChain: [],
accountHome: { variable: 'GROK_HOME', path: join(dataDirectory, '.grok') }
}),
pinLaunchDirectory: vi.fn()
},
readJournal: () => null,
resolveEnvironment: async () => ({ PATH: '', HOME: homePath }),
dataDirectory
})
const rig = await openAcpAdapterRig({ spec, deps: { resolveLaunch } })
await rig.acquire()
return rig.child().launch.command
}
await expect(spawn()).rejects.toMatchObject({ reason: 'runtimeNotInstalled' })
// A server without its companion is an incomplete runtime.
const localBin = join(homePath, '.local', 'bin')
await mkdir(localBin, { recursive: true })
await writeFile(join(localBin, command), '', { mode: 0o755 })
await expect(spawn()).rejects.toMatchObject({ reason: 'runtimeNotInstalled' })
const fallback = join(root, '1.1')
await mkdir(fallback, { recursive: true })
await writeFile(join(fallback, command), 'server', { mode: 0o755 })
await writeFile(join(fallback, 'harness'), 'harness', { mode: 0o755 })
await writeRuntimeReleaseReceipt(fallback, {
...pin,
version: '1.1',
archiveSha256: 'd'.repeat(64)
})
expect(await spawn()).toBe(join(fallback, command))
const release = join(root, '1.0')
await mkdir(release, { recursive: true })
await writeFile(join(release, command), 'server', { mode: 0o755 })
await writeFile(join(release, 'harness'), 'harness', { mode: 0o755 })
await writeFile(
join(release, RUNTIME_RELEASE_RECEIPT),
JSON.stringify({
releaseId: pin.archiveSha256,
version: '1.0',
platform: process.platform,
arch: process.arch,
members: pin.members.map(({ path, bytes }) => ({ path, bytes }))
})
)
await writeFile(join(localBin, 'harness'), '', { mode: 0o755 })
expect(await spawn()).toBe(join(release, command))
await truncate(join(fallback, command), 2)
await truncate(join(release, command), 2)
expect(await spawn()).toBe(await realpath(join(localBin, command)))
})
@@ -217,21 +217,6 @@ describe('ACP process-owning connection', () => {
})
})
it('closes a recognized stdout prompt over 16 MiB without inventing a signed-out answer', async () => {
const answered = vi.fn()
const { connection, agent } = fixture({
signIn: {
read: (line) => (line.startsWith('SIGN IN') ? 'prefix-only' : undefined),
answered
}
})
await connection.start(start)
expect(answered).toHaveBeenCalledExactlyOnceWith(true)
agent.stdout.write(`SIGN IN ${'x'.repeat(16 * 1024 * 1024)}\n`)
await vi.waitFor(() => expect(connection.closed).toBe(true))
expect(answered).toHaveBeenCalledTimes(1)
})
it('keeps cached startup usable without advertising the configured method, but refuses unsupported required authentication', async () => {
const { connection, agent } = fixture()
agent.on('initialize', (frame) =>
@@ -1,4 +1,4 @@
import { afterEach, describe, expect, it, onTestFinished, vi } from 'vitest'
import { afterEach, describe, expect, it, onTestFinished } from 'vitest'
import { AcpSessionRuntime } from './acp-session-runtime'
import type { AcpSessionRuntimeOptions } from './acp-session-runtime-options'
@@ -7,17 +7,10 @@ import {
deferred,
tick
} from '../process/testing/acp-scripted-agent.test-support'
import { AcpConnectionClosedError } from '../transport/acp-errors'
import type { RequestPermissionResponse } from '../generated/acp-protocol.generated'
const opened: { close: () => void }[] = []
const startOptions = { cwd: '/runtime/project', mcpServers: [] }
const prompt = [{ type: 'text', text: 'hello' }] as const
const permission = {
sessionId: 'session-1',
toolCall: { toolCallId: 'tool-1', title: 'Edit file' },
options: [{ optionId: 'allow', name: 'Allow once', kind: 'allow_once' }]
}
function fixture(options: AcpSessionRuntimeOptions = {}) {
const agent = new AcpScriptedAgent()
const runtime = new AcpSessionRuntime(agent.stdout, agent.stdin, options)
@@ -31,114 +24,9 @@ afterEach(() => {
.splice(0)
.toReversed()
.forEach((resource) => resource.close())
vi.useRealTimers()
})
describe('ACP caller-owned waits', () => {
it('keeps permission requests open beyond two minutes and delivers the late user decision', async () => {
vi.useFakeTimers()
const entered = deferred<AbortSignal>()
const decision = deferred<RequestPermissionResponse>()
const { agent, runtime } = fixture({
onPermission: (_request, context) => {
entered.resolve(context.signal)
return decision.promise
}
})
agent.on('session/prompt', () => {})
await runtime.start(startOptions)
const pending = runtime.prompt([...prompt])
const rejected = expect(pending).rejects.toBeInstanceOf(AcpConnectionClosedError)
let answered = false
const response = agent.request('permission', 'session/request_permission', permission)
void response.then(() => {
answered = true
})
const signal = await entered.promise
await vi.advanceTimersByTimeAsync(120_001)
expect(signal.aborted).toBe(false)
expect(answered).toBe(false)
decision.resolve({ outcome: { outcome: 'selected', optionId: 'allow' } })
expect(await response).toMatchObject({
result: { outcome: { outcome: 'selected', optionId: 'allow' } }
})
runtime.close()
await rejected
})
it('lets a streaming turn run beyond thirty minutes and keeps the session usable', async () => {
vi.useFakeTimers()
const onClose = vi.fn()
const event = vi.fn()
const { agent, runtime } = fixture({ onClose })
runtime.subscribe(event)
agent.on('session/prompt', () => {})
agent.on('session/set_mode', (frame) => agent.reply(frame, {}))
await runtime.start(startOptions)
let finished = false
const pending = runtime.prompt([...prompt])
void pending.then(() => {
finished = true
})
await vi.advanceTimersByTimeAsync(30 * 60_000 + 1)
agent.notify('session/update', {
sessionId: 'session-1',
update: {
sessionUpdate: 'agent_message_chunk',
content: { type: 'text', text: 'Still working' }
}
})
expect(event).toHaveBeenCalledTimes(1)
expect(finished).toBe(false)
expect(onClose).not.toHaveBeenCalled()
expect(agent.frames.some((frame) => frame.method === 'session/cancel')).toBe(false)
await expect(runtime.setMode('plan')).resolves.toEqual({})
const frame = agent.frames.find((frame) => frame.method === 'session/prompt')
expect(frame).toBeDefined()
if (frame) {
agent.reply(frame, { stopReason: 'end_turn' })
}
await expect(pending).resolves.toEqual({ stopReason: 'end_turn' })
})
it.each([
{ kind: 'new', expected: { kind: 'new', sessionId: 'session-1' } },
{ kind: 'load', expected: { kind: 'load', sessionId: 'saved-session' } },
{ kind: 'resume', expected: { kind: 'resume', sessionId: 'saved-session' } }
] as const)(
'opens a slow $kind session on its real answers, regardless of the peer default',
async ({ kind, expected }) => {
vi.useFakeTimers()
const { agent, runtime } = fixture({ peer: { requestTimeoutMs: 20 } })
agent.on('initialize', (frame) => {
setTimeout(
() =>
agent.reply(frame, {
protocolVersion: 1,
agentCapabilities: { loadSession: true, sessionCapabilities: { resume: {} } }
}),
75_000
)
})
agent.on(`session/${kind}`, (frame) => {
setTimeout(
() => agent.reply(frame, kind === 'new' ? { sessionId: 'session-1' } : {}),
310_000
)
})
const started = expect(
runtime.start({
...startOptions,
...(kind === 'new' ? {} : { sessionId: 'saved-session', resumePreference: kind })
})
).resolves.toMatchObject(expected)
await vi.advanceTimersByTimeAsync(385_000)
await started
agent.on('session/prompt', (frame) => agent.reply(frame, { stopReason: 'end_turn' }))
await expect(runtime.prompt([...prompt])).resolves.toEqual({ stopReason: 'end_turn' })
}
)
it('keeps a handler answer that finishes saving after its owner withdraws requests', async () => {
const withdrawal = new AbortController()
const planEntered = deferred<void>()
@@ -2,7 +2,6 @@ import { afterEach, describe, expect, it, vi } from 'vitest'
import { AcpConnectionClosedError } from '../transport/acp-errors'
import { AcpSessionRuntime } from './acp-session-runtime'
import type { AcpSessionRuntimeOptions } from './acp-session-runtime-options'
import type { AcpSessionEvent } from './acp-session-events'
import {
AcpScriptedAgent,
deferred,
@@ -83,61 +82,6 @@ describe('ACP session runtime', () => {
expect(asked).toHaveLength(2)
})
it.each([
['code alone', true, { code: -32003, message: 'busy' }, -32003],
[
'reason alone',
true,
{ code: -32603, message: 'busy', data: { reason: 'session_busy' } },
-32603
],
['prose', true, { code: -32603, message: 'Agent is already processing.' }, -32603],
[
'sign-in',
true,
{ code: -32000, message: 'Sign in', data: { reason: 'session_busy' } },
-32000
],
[
'malformed refusal',
true,
{ code: '-32003', message: 'busy', data: { reason: 'session_busy' } },
-32603
],
[
'no opt-in',
false,
{ code: -32003, message: 'busy', data: { reason: 'session_busy' } },
-32003
]
] as const)('never replays %s', async (_label, retryBusyPrompts, error, code) => {
const { runtime, agent } = fixture({}, { retryBusyPrompts })
await runtime.start(startOptions)
vi.useFakeTimers({ toFake: ['setTimeout', 'clearTimeout'] })
agent.on('session/prompt', (frame) =>
agent.stdout.write(`${JSON.stringify({ jsonrpc: '2.0', id: frame.id, error })}\n`)
)
await expect(runtime.prompt([...textPrompt])).rejects.toMatchObject({ code })
await vi.advanceTimersByTimeAsync(60_000)
expect(agent.frames.filter((frame) => frame.method === 'session/prompt')).toHaveLength(1)
})
it('uses raw underscored extension methods and bounds control requests without closing the session', async () => {
const { runtime, agent } = fixture()
await runtime.initialize()
await runtime.start(startOptions)
agent.on('_x.ai/subagent/cancel', (frame) => {
expect(frame.params).toEqual({ subagentId: 'child' })
})
vi.useFakeTimers({ toFake: ['setTimeout', 'clearTimeout'] })
const call = runtime.requestExtension('_x.ai/subagent/cancel', { subagentId: 'child' })
const rejected = expect(call).rejects.toThrow(/timed out|timeout/i)
await vi.advanceTimersByTimeAsync(30_000)
await rejected
expect(runtime.closed).toBe(false)
expect(() => runtime.requestExtension('x.ai/subagent/cancel', {})).toThrow('underscore')
})
it('refuses unsupported restoration without silently creating a different session', async () => {
const { runtime, agent } = fixture({ sessionCapabilities: { resume: null } })
await expect(runtime.start({ ...startOptions, sessionId: 'old' })).rejects.toMatchObject({
@@ -146,31 +90,6 @@ describe('ACP session runtime', () => {
expect(agent.frames.map((frame) => frame.method)).toEqual(['initialize'])
})
it('authenticates once with a configured agent method and retries session setup', async () => {
const { runtime, agent } = fixture()
let authenticated = false
agent.on('initialize', (frame) =>
agent.reply(frame, { protocolVersion: 1, authMethods: [{ id: 'login', name: 'Login' }] })
)
agent.on('session/new', (frame) =>
authenticated
? agent.reply(frame, { sessionId: 'session-1' })
: agent.fail(frame, -32000, 'Login required')
)
agent.on('authenticate', (frame) => {
authenticated = true
agent.reply(frame, {})
})
await runtime.start({ ...startOptions, authMethodId: 'login' })
expect(agent.frames.map((frame) => frame.method)).toEqual([
'initialize',
'session/new',
'authenticate',
'session/new'
])
expect(agent.frames[2].params).toEqual({ methodId: 'login' })
})
it('rejects unroutable permission requests and answers an unavailable selection cancelled', async () => {
const diagnostics: string[] = []
const { runtime, agent } = fixture(
@@ -202,36 +121,6 @@ describe('ACP session runtime', () => {
await expect(runtime.prompt([...textPrompt])).rejects.toThrow('already in progress')
})
it('preserves unrecognized updates and isolates event listener failures', async () => {
const diagnostics: string[] = []
const { runtime, agent } = fixture({}, { onDiagnostic: (message) => diagnostics.push(message) })
const updates: AcpSessionEvent[] = []
runtime.subscribe(() => {
throw new Error('Consumer failed')
})
runtime.subscribe((event) => updates.push(event))
await runtime.start(startOptions)
agent.notify('session/update', {
sessionId: 'session-1',
update: { sessionUpdate: 'agent_message_chunk', content: {} }
})
agent.notify('session/update', {
sessionId: 'session-1',
update: {
sessionUpdate: 'agent_message_chunk',
content: { type: 'text', text: 'valid', _meta: { vendor: true } }
}
})
expect(updates).toHaveLength(2)
expect(updates[0]).toMatchObject({ kind: 'unrecognized' })
expect(updates[1]).toMatchObject({
kind: 'known',
notification: { update: { content: { _meta: { vendor: true } } } }
})
expect(diagnostics).toContain('Forwarded unrecognized ACP session update')
expect(diagnostics.some((message) => message.includes('Consumer failed'))).toBe(true)
})
it('rejects pending calls and aborts permission hooks when protocol input ends', async () => {
const requested = deferred<AbortSignal>()
const { runtime, agent } = fixture(
@@ -1,5 +1,5 @@
import type { AntigravityChatAuthConfig } from '../../../shared/antigravity-chat-auth-config'
import { afterEach, expect, it, onTestFinished } from 'vitest'
import { afterEach, expect, it } from 'vitest'
import { z } from 'zod'
import { readAgentJournalTurn } from '../../../shared/agent-session/lifecycle/agent-session-turn-record'
import {
@@ -14,7 +14,6 @@ import {
waitFor
} from './testing/acp-structured-adapter.test-support'
import { GrokFixtureReplay } from './testing/acp-structured-fixture-replay.test-support'
import { deferred } from '../process/testing/acp-scripted-agent.test-support'
import {
readAcpFixture,
type AcpFixtureFrame
@@ -26,7 +25,6 @@ const result = (frame: AcpFixtureFrame | undefined) =>
afterEach(closeProviderTimelineRigs)
it.each<{ config: AntigravityChatAuthConfig | undefined; method: string }>([
{ config: undefined, method: 'oauth-personal' },
{
config: {
method: 'oauth-business',
@@ -111,54 +109,6 @@ it("leaves a Full access host chat's plan approval to the person", async () => {
expect(answered).toBe(false)
})
it('refuses a new start while its sign-in changes, and stops one already starting', async () => {
const gate = ANTIGRAVITY.launchGate!
const rig = await openAcpAdapterRig({
spec: ANTIGRAVITY,
script: (agent) => agent.on('session/new', () => {})
})
const starting = rig.acquire()
await rig.frame('session/new')
const signIn = deferred<void>()
onTestFinished(() => signIn.resolve())
const operation = gate.run(
async () => {},
() => signIn.promise
)
await starting
expect(rig.openFailure()).toMatchObject({ name: 'AcpConnectionClosedError' })
expect(rig.child().exited).toBe(true)
await expect(rig.acquire()).rejects.toMatchObject({ reason: 'accountSwitchInProgress' })
signIn.resolve()
await operation
const lateStart = gate.enter(undefined)
let left = false
onTestFinished(() => {
left = true
lateStart.leave()
})
let stopped = false
let worked = false
const failedOperation = gate.run(
async () => {
expect(left).toBe(true)
stopped = true
throw new Error('stop failed')
},
async () => {
worked = true
}
)
void failedOperation.catch(() => {})
expect(lateStart.signal.aborted).toBe(true)
expect(stopped).toBe(false)
left = true
lateStart.leave()
await expect(failedOperation).rejects.toThrow('stop failed')
expect(worked).toBe(false)
})
it('stops a chat that has left the gate but is not loaded yet before the operation runs', async () => {
const [initialized, opened] = await readAcpFixture('antigravity-v1-question')
const rig = await openAcpAdapterRig({
@@ -1,88 +0,0 @@
import { afterEach, describe, expect, it, vi } from 'vitest'
import { closeProviderTimelineRigs } from '../../native-chat/agent-session-timeline/provider-timeline-assembler-test-support'
import {
CALLER,
envelope
} from '../../native-chat/agent-session-wire/host/testing/structured-agent-session-host-test-harness'
import { HOST_TEST_SESSION as SESSION } from '../../native-chat/agent-session-wire/host/testing/structured-agent-session-host-test-data'
import { waitFor } from './testing/acp-structured-adapter.test-support'
import {
attachParams,
hello,
launch,
openHostRig
} from './testing/acp-structured-host.test-support'
afterEach(async () => {
await closeProviderTimelineRigs()
})
describe('closing or stopping a Grok chat while it starts', () => {
it('retains a published startup child whose close is unproven and retries before another spawn', async () => {
const { rig, host } = await openHostRig({ script: (agent) => agent.on('initialize', () => {}) })
expect(await host.attach(CALLER, attachParams())).toMatchObject({ ok: true })
await rig.frame('initialize')
const child = rig.child()
child.proveClose = vi.fn(async () => false)
try {
await expect(host.close(SESSION, 'user-close')).rejects.toThrow('eviction failed')
expect(child.exited).toBe(false)
expect(rig.spawned.filter((step) => step === 'spawn')).toHaveLength(1)
} finally {
child.proveClose = vi.fn(async () => {
child.exit()
return true
})
await host.close(SESSION, 'user-close')
}
expect(child.exited).toBe(true)
await host.send(CALLER, {
envelope: envelope('agentSession.send', { body: hello }),
body: hello
})
await waitFor(() => expect(rig.child()).not.toBe(child))
await host.close(SESSION, 'user-close')
})
it('leaves a starting child alone when Stop names an earlier turn', async () => {
const { rig, host } = await openHostRig({
script: (agent) => agent.on('initialize', () => {})
})
const attaching = host.attach(CALLER, attachParams())
await rig.frame('initialize')
const stopping = host.cancel(CALLER, {
envelope: envelope('agentSession.cancel', { turnId: 'turn-of-an-old-child' }),
turnId: 'turn-of-an-old-child'
})
expect(await stopping).toMatchObject({ ok: true, value: { cancelled: false } })
await rig.settle()
expect(rig.child().closes).toBe(0)
expect(rig.child().exited).toBe(false)
await host.close(SESSION, 'user-close')
await attaching
})
it('never spawns a child for a start closed while its launch was still resolving', async () => {
let releaseLaunch: () => void = () => {}
const resolving = { started: false }
const { rig, host } = await openHostRig({
deps: {
resolveLaunch: async () => {
resolving.started = true
await new Promise<void>((resolve) => {
releaseLaunch = resolve
})
return launch(() => false)()
}
}
})
const attaching = host.attach(CALLER, attachParams()).catch((error: unknown) => error)
await waitFor(() => expect(resolving.started).toBe(true))
const closing = host.close(SESSION, 'user-close')
releaseLaunch()
expect(await attaching).toMatchObject({ name: 'AgentSessionPreSpawnError' })
await closing
expect(rig.spawned).toEqual([])
expect(await rig.adapter.closeSession(SESSION)).toBe(true)
})
})
@@ -63,59 +63,6 @@ async function answer(rig: AcpAdapterRig, replay: GrokFixtureReplay, optionId: s
}
describe('OpenCode recordings through the adapter', () => {
it('an approved shell command lands with its exit code, and "always" keeps OpenCode\'s own name', async () => {
const { rig, replay } = await replaying('opencode-v1-tool')
const approval = await answer(rig, replay, 'once')
expect(approval.body).toMatchObject({
kind: 'approval',
options: [
{ id: 'once', label: 'Allow once' },
{ id: 'always', label: 'Always allow' },
{ id: 'reject', label: 'Reject' }
]
})
await waitFor(() => expect(replay.awaiting).toBeNull())
await waitFor(async () =>
expect(await turns(rig)).toMatchObject([{ state: 'completed', outcome: 'success' }])
)
const shell = (await rowsOf(rig, 'tool-call')).find(
(row) => row.body.kind === 'tool-call' && row.body.exitCode !== undefined
)
expect(shell?.body).toMatchObject({ state: 'completed', exitCode: 0 })
})
it('a rejected permission fails its tool and the turn still ends', async () => {
const { rig, replay } = await replaying('opencode-v1-deny')
await answer(rig, replay, 'reject')
await waitFor(() => expect(replay.awaiting).toBeNull())
await waitFor(async () => expect(await turns(rig)).toMatchObject([{ state: 'completed' }]))
expect((await rowsOf(rig, 'tool-call')).at(-1)?.body).toMatchObject({ state: 'failed' })
})
it("a subagent's approval never arrives (a known OpenCode bug); Stop still ends the turn", async () => {
const { rig, replay } = await replaying('opencode-v1-subagent-hang')
await waitFor(() => expect(replay.awaiting).toBe('session/cancel'))
expect(await rowsOf(rig, 'approval')).toEqual([])
await expect(rig.adapter.cancelTurn({ sessionId: SESSION, fence: 1 })).resolves.toEqual({
cancelled: true
})
await waitFor(async () =>
expect(await turns(rig)).toMatchObject([{ state: 'interrupted', outcome: 'cancellation' }])
)
})
it("OpenCode's stray file write after an approved edit is refused without breaking the turn", async () => {
const { rig, replay } = await replaying('opencode-v1-stray-write')
await answer(rig, replay, 'once', 0)
await answer(rig, replay, 'reject', 1)
await waitFor(() => expect(replay.awaiting).toBeNull())
await waitFor(async () => expect(await turns(rig)).toMatchObject([{ state: 'completed' }]))
// No filesystem capability was advertised, so the repeated write request creates no row.
expect(JSON.stringify((await rig.rig.rows()).map((row) => row.body))).not.toContain(
'fs/write_text_file'
)
})
it("a provider error fails the turn in OpenCode's own words", async () => {
const { rig, replay } = await replaying('opencode-v1-provider-error')
await waitFor(() => expect(replay.awaiting).toBeNull())
@@ -158,18 +105,4 @@ describe('OpenCode 2 recordings through the adapter', () => {
)
expect((await rowsOf(rig, 'tool-call')).at(-1)?.body).toMatchObject({ state: 'failed' })
})
it('Stop during an approved command cancels it and ends the turn', async () => {
const { rig, replay } = await replaying('opencode-v2-stop', 'opencode2')
await answer(rig, replay, 'once')
await waitFor(() => expect(replay.awaiting).toBe('session/cancel'))
await expect(rig.adapter.cancelTurn({ sessionId: SESSION, fence: 1 })).resolves.toEqual({
cancelled: true
})
await waitFor(() => expect(replay.awaiting).toBeNull())
await waitFor(async () =>
expect(await turns(rig)).toMatchObject([{ state: 'interrupted', outcome: 'cancellation' }])
)
expect((await rowsOf(rig, 'tool-call')).at(-1)?.body).toMatchObject({ state: 'failed' })
})
})
@@ -65,24 +65,6 @@ async function openWithHeldFirstWrite(
}
}
it('refuses only the message whose model write went unanswered, keeping the agent running', async () => {
const { rig, held } = await openWithHeldFirstWrite(100)
await expect(send(rig, 'send-1', { model: 'grok-4.6' })).rejects.toThrow()
// The unanswered call is withdrawn at the agent, and the agent process is never ended for it.
const cancel = await rig.frame('$/cancel_request')
expect(cancel.params).toEqual({ requestId: held().id })
await rig.settle()
expect(rig.ended).toEqual([])
expect(rig.child().closes).toBe(0)
expect(rig.spawned.filter((step) => step === 'spawn')).toHaveLength(1)
await expect(send(rig, 'send-2', { model: 'grok-4.6' })).resolves.toEqual({ state: 'admitted' })
expect(rig.sent('session/set_config_option')).toHaveLength(2)
await rig.frame('session/prompt')
})
it('holds later controls and prompts until a withdrawn write is answered', async () => {
// Long enough that no deadline expires; the held write settles only when answered below.
const { rig, held } = await openWithHeldFirstWrite(10_000)
@@ -1,629 +0,0 @@
import { act, fireEvent, screen } from '@testing-library/react'
import { render } from '../../messages/actions/native-chat-tooltip-test-harness'
import { createRef } from 'react'
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
import { useAppStore } from '@/store'
import { getDefaultSettings } from '../../../../../../shared/constants'
import type { NativeChatMessage } from '../../../../../../shared/native-chat/native-chat-types'
import { routeNativeChatRootKeyToInput } from '../../composer/focus/native-chat-root-key-routing'
import { NativeChatMessageList } from '../../NativeChatMessageList'
import type { NativeChatMessageListHandle } from '../../messages/actions/use-native-chat-reveal-latest'
import {
BELOW_TRANSCRIPT_PX,
deliverResizes,
layout,
list,
marker,
ROW_PX,
scrollTranscript,
session,
stubLayout,
stubResizeObserver,
TRANSCRIPT_LENGTH
} from '../virtualization/native-chat-windowing-test-harness'
function scrollRoot(container: HTMLElement): HTMLElement {
const scroller = container.querySelector<HTMLElement>('[data-native-chat-scroll]')
if (!scroller) {
throw new Error('no transcript scroll root')
}
return scroller
}
const paintedScrollTops = new WeakMap<HTMLElement, number>()
/** Deliver resize and scroll events to a fixed point, as a painted frame would. */
function paint(container: HTMLElement): void {
const scroller = scrollRoot(container)
// Commit-time writes also dispatch their browser scroll event before the next paint.
let lastScrollTop = paintedScrollTops.get(scroller) ?? 0
for (let pass = 0; pass < 12; pass += 1) {
let changed = false
act(() => {
changed = deliverResizes()
vi.advanceTimersByTime(16)
})
if (scroller.scrollTop !== lastScrollTop) {
lastScrollTop = scroller.scrollTop
fireEvent.scroll(scroller)
changed = true
}
if (!changed && pass >= 2) {
paintedScrollTops.set(scroller, lastScrollTop)
return
}
}
throw new Error('the transcript never settled: resize and scroll kept moving it')
}
function distanceFromBottom(container: HTMLElement): number {
const scroller = scrollRoot(container)
return scroller.scrollHeight - scroller.clientHeight - scroller.scrollTop
}
const transcript = Array.from({ length: TRANSCRIPT_LENGTH }, (_, index) => marker(index))
function userMessage(index: number, text: string): NativeChatMessage {
return {
id: `message-${index}`,
role: 'user',
blocks: [{ type: 'text', text }],
timestamp: index + 1,
source: 'transcript'
}
}
function toolMessage(index: number): NativeChatMessage {
return {
id: `message-${index}`,
role: 'assistant',
blocks: [
{ type: 'tool-call', name: 'shell', input: { command: 'pwd' }, state: 'completed' },
{ type: 'tool-result', output: '/repo' }
],
timestamp: index + 1,
source: 'transcript'
}
}
function liveList(messages: NativeChatMessage[]): React.JSX.Element {
return <NativeChatMessageList session={session(messages)} isWorking expandSignal={false} />
}
function closedRuns(count: number): { toggle: HTMLElement; rowIndex: number }[] {
return screen
.getAllByRole('button', { expanded: false })
.slice(-count)
.map((toggle) => {
const row = toggle.closest<HTMLElement>('[data-index]')
if (!row) {
throw new Error('the tool run has no mounted row')
}
return { toggle, rowIndex: Number(row.dataset.index) }
})
}
function toggleRun(container: HTMLElement, toggle: HTMLElement, openRows: readonly number[]): void {
fireEvent.click(toggle)
const heights = Array.from({ length: Math.max(-1, ...openRows) + 1 }, () => ROW_PX)
for (const rowIndex of openRows) {
heights[rowIndex] = ROW_PX * 6
}
layout.measuredRowHeights = heights
paint(container)
}
function offersJumpToLatest(): boolean {
return screen.queryByRole('button', { name: 'Jump to latest' }) !== null
}
describe('reader navigation', () => {
let viewportHeight = 600
let restore: (() => void)[] = []
beforeEach(() => {
vi.useFakeTimers()
viewportHeight = 600
restore = [
stubLayout({ scrollGeometry: true, offsetChain: true, viewportHeight: () => viewportHeight }),
stubResizeObserver()
]
layout.belowTranscriptPx = BELOW_TRANSCRIPT_PX
layout.aboveTranscriptPx = 0
})
afterEach(() => {
for (const undo of restore.toReversed()) {
undo()
}
layout.measuredRowHeights = []
vi.useRealTimers()
})
it('holds browsed history until the reader chooses Jump to latest, including while hidden', () => {
const release = vi.fn()
const retainHistory = vi.fn(() => release)
const view = (isVisible: boolean) => (
<NativeChatMessageList
session={{ ...session(transcript), retainHistory }}
isVisible={isVisible}
isWorking={false}
expandSignal={false}
/>
)
const { container, rerender, unmount } = render(view(true))
paint(container)
scrollTranscript(container, 1000)
paint(container)
expect(retainHistory).toHaveBeenCalledOnce()
rerender(view(false))
act(() => deliverResizes())
expect(release).not.toHaveBeenCalled()
rerender(view(true))
paint(container)
expect(release).not.toHaveBeenCalled()
fireEvent.click(screen.getByRole('button', { name: 'Jump to latest' }))
paint(container)
expect(release).toHaveBeenCalledOnce()
expect(distanceFromBottom(container)).toBe(0)
scrollTranscript(container, 1000)
paint(container)
unmount()
expect(release).toHaveBeenCalledTimes(2)
})
it('brings a reader who scrolled up after capturing a send to what they just sent, and follows its reply', () => {
const release = vi.fn()
const retainHistory = () => release
const handle = createRef<NativeChatMessageListHandle>()
const view = (messages: NativeChatMessage[], isWorking: boolean) => (
<NativeChatMessageList
ref={handle}
session={{ ...session(messages), retainHistory }}
isWorking={isWorking}
expandSignal={false}
/>
)
const { container, rerender } = render(view(transcript, false))
paint(container)
const capturedAtEnd = handle.current?.readerAtEnd()
scrollTranscript(container, 1000)
paint(container)
expect(distanceFromBottom(container)).toBeGreaterThan(1000)
act(() => handle.current?.revealLatest(capturedAtEnd))
const sent = [...transcript, userMessage(TRANSCRIPT_LENGTH, 'follow-up question')]
rerender(view(sent, true))
paint(container)
rerender(view([...sent, marker(TRANSCRIPT_LENGTH + 1)], true))
paint(container)
expect(release).toHaveBeenCalledOnce()
expect(distanceFromBottom(container)).toBe(0)
expect(screen.getByText('follow-up question')).toBeInTheDocument()
expect(screen.queryByRole('button', { name: 'Jump to latest' })).toBeNull()
})
describe('with scroll to latest on send off', () => {
const originalSettings = useAppStore.getState().settings
beforeEach(() => {
useAppStore.setState({
settings: { ...getDefaultSettings('/tmp'), nativeChatScrollToLatestOnSend: false }
})
})
afterEach(() => {
useAppStore.setState({ settings: originalSettings })
})
function sendFrom(
readerTop: (scroller: HTMLElement) => number,
expected: { admitted: boolean; releases: number },
replyRowsBeforeSend = 0
): HTMLElement {
const release = vi.fn()
const retainHistory = () => release
const handle = createRef<NativeChatMessageListHandle>()
const view = (messages: NativeChatMessage[]) => (
<NativeChatMessageList
ref={handle}
session={{ ...session(messages), retainHistory }}
isWorking
expandSignal={false}
/>
)
const reply = Array.from({ length: replyRowsBeforeSend }, (_, index) =>
marker(TRANSCRIPT_LENGTH + index)
)
const { container, rerender } = render(view(transcript))
paint(container)
scrollTranscript(container, readerTop(scrollRoot(container)))
paint(container)
rerender(view([...transcript, ...reply]))
paint(container)
// A structured send reads the reader at the press; its echo lands before the host admits it.
const readerWasAtEnd = handle.current?.readerAtEnd()
expect(readerWasAtEnd).toBe(expected.admitted)
const sentAt = TRANSCRIPT_LENGTH + reply.length
const sent = [...transcript, ...reply, userMessage(sentAt, 'follow-up question')]
rerender(view(sent))
paint(container)
act(() => handle.current?.revealLatest(readerWasAtEnd))
rerender(view([...sent, marker(sentAt + 1)]))
paint(container)
expect(release).toHaveBeenCalledTimes(expected.releases)
return container
}
it('leaves a reader who scrolled up where they were', () => {
const container = sendFrom(() => 1000, { admitted: false, releases: 0 })
expect(scrollRoot(container).scrollTop).toBe(1000)
expect(offersJumpToLatest()).toBe(true)
})
it('still follows the reply for a reader who stopped just short of the end', () => {
const container = sendFrom((scroller) => scroller.scrollHeight - scroller.clientHeight - 40, {
admitted: true,
releases: 1
})
expect(distanceFromBottom(container)).toBe(0)
expect(offersJumpToLatest()).toBe(false)
})
it('leaves a reader in place once output has grown past them', () => {
const container = sendFrom(
(scroller) => scroller.scrollHeight - scroller.clientHeight - 20,
{ admitted: false, releases: 0 },
10
)
expect(distanceFromBottom(container)).toBeGreaterThan(ROW_PX * 10)
expect(offersJumpToLatest()).toBe(true)
})
})
it('keeps history through a viewport clamp and releases it for a later send', () => {
const release = vi.fn()
const retainHistory = () => release
const handle = createRef<NativeChatMessageListHandle>()
const { container } = render(
<NativeChatMessageList
ref={handle}
session={{ ...session(transcript), retainHistory }}
isWorking={false}
expandSignal={false}
/>
)
paint(container)
const scroller = scrollRoot(container)
scrollTranscript(container, scroller.scrollHeight - scroller.clientHeight - 40)
paint(container)
expect(release).not.toHaveBeenCalled()
viewportHeight += 80
fireEvent.scroll(scroller)
paint(container)
expect(distanceFromBottom(container)).toBe(0)
expect(release).not.toHaveBeenCalled()
expect(handle.current?.readerAtEnd()).toBe(true)
act(() => handle.current?.revealLatest())
paint(container)
expect(release).toHaveBeenCalledOnce()
})
it('stops following when the reader pages up from the focused transcript', () => {
const { container, rerender } = render(liveList(transcript))
paint(container)
const scroller = scrollRoot(container)
scroller.focus()
fireEvent.keyDown(scroller, { key: 'PageUp' })
// The browser pages the focused scroller; the key is all that says a reader moved it.
scroller.scrollTop -= scroller.clientHeight
fireEvent.scroll(scroller)
const pagedTo = scroller.scrollTop
rerender(liveList([...transcript, marker(TRANSCRIPT_LENGTH)]))
paint(container)
expect(scroller.scrollTop).toBe(pagedTo)
expect(offersJumpToLatest()).toBe(true)
})
it('stops following when find steps to a match above the end', () => {
const handle = createRef<NativeChatMessageListHandle>()
const view = (messages: NativeChatMessage[]) => (
<NativeChatMessageList
ref={handle}
session={session(messages)}
isWorking
expandSignal={false}
/>
)
const { container, rerender } = render(view(transcript))
paint(container)
const scroller = scrollRoot(container)
expect(distanceFromBottom(container)).toBe(0)
const match = document.createRange()
match.selectNodeContents(scroller)
const viewTop = scroller.getBoundingClientRect().top
Object.defineProperty(match, 'getBoundingClientRect', {
value: () => DOMRect.fromRect({ y: viewTop - 2000, height: 20 })
})
act(() => handle.current?.revealFindMatch(match, null))
fireEvent.scroll(scroller)
const foundAt = scroller.scrollTop
expect(distanceFromBottom(container)).toBeGreaterThan(1000)
rerender(view([...transcript, marker(TRANSCRIPT_LENGTH)]))
paint(container)
expect(scroller.scrollTop).toBe(foundAt)
expect(offersJumpToLatest()).toBe(true)
})
it('keeps following when a find step cannot move the transcript', () => {
const handle = createRef<NativeChatMessageListHandle>()
const view = (messages: NativeChatMessage[]) => (
<NativeChatMessageList
ref={handle}
session={session(messages)}
isWorking
expandSignal={false}
/>
)
const { container, rerender } = render(view(transcript))
paint(container)
const scroller = scrollRoot(container)
expect(distanceFromBottom(container)).toBe(0)
const match = document.createRange()
match.selectNodeContents(scroller)
const viewBottom = scroller.getBoundingClientRect().bottom
// Below the end: the clamped scroll is a no-op, so no scroll event would re-arm following.
Object.defineProperty(match, 'getBoundingClientRect', {
value: () => DOMRect.fromRect({ y: viewBottom + 2000, height: 20 })
})
act(() => handle.current?.revealFindMatch(match, null))
rerender(view([...transcript, marker(TRANSCRIPT_LENGTH)]))
paint(container)
expect(distanceFromBottom(container)).toBe(0)
expect(offersJumpToLatest()).toBe(false)
})
it('leaves a reader who scrolled up in place when a message arrives from another device', () => {
const { container, rerender } = render(liveList(transcript))
paint(container)
scrollTranscript(container, 1000)
paint(container)
const readingAt = scrollRoot(container).scrollTop
const delivered = [...transcript, userMessage(TRANSCRIPT_LENGTH, 'sent from the phone')]
rerender(liveList(delivered))
paint(container)
rerender(liveList([...delivered, marker(TRANSCRIPT_LENGTH + 1)]))
paint(container)
expect(scrollRoot(container).scrollTop).toBe(readingAt)
expect(offersJumpToLatest()).toBe(true)
})
it('keeps following when the reader opens a tool run at the live end', () => {
const toolIndex = TRANSCRIPT_LENGTH
const withTool = [...transcript, toolMessage(toolIndex)]
const { container, rerender } = render(liveList(withTool))
paint(container)
expect(distanceFromBottom(container)).toBe(0)
const scrollTopBeforeOpen = scrollRoot(container).scrollTop
const [run] = closedRuns(1)
toggleRun(container, run.toggle, [run.rowIndex])
expect(run.toggle).toHaveAttribute('aria-expanded', 'true')
rerender(liveList([...withTool, marker(toolIndex + 1), marker(toolIndex + 2)]))
paint(container)
expect(scrollRoot(container).scrollTop).toBeGreaterThan(scrollTopBeforeOpen)
expect(distanceFromBottom(container)).toBe(0)
expect(offersJumpToLatest()).toBe(false)
})
describe('closing what the reader opened', () => {
const toolIndex = TRANSCRIPT_LENGTH
const withTool = [...transcript, toolMessage(toolIndex)]
const streamedOn = [...withTool, marker(toolIndex + 1), marker(toolIndex + 2)]
it('stays where the reader scrolled to while it was open', () => {
const { container, rerender } = render(liveList(withTool))
paint(container)
const [run] = closedRuns(1)
toggleRun(container, run.toggle, [run.rowIndex])
const scrolledTo = scrollRoot(container).scrollTop - 100
scrollTranscript(container, scrolledTo)
paint(container)
toggleRun(container, run.toggle, [])
rerender(liveList(streamedOn))
paint(container)
expect(scrollRoot(container).scrollTop).toBe(scrolledTo)
expect(offersJumpToLatest()).toBe(true)
})
it('leaves a reader who had already scrolled away where they are', () => {
const { container, rerender } = render(liveList(withTool))
paint(container)
const scrolledTo = scrollRoot(container).scrollTop - 100
scrollTranscript(container, scrolledTo)
paint(container)
const [run] = closedRuns(1)
toggleRun(container, run.toggle, [run.rowIndex])
toggleRun(container, run.toggle, [])
rerender(liveList(streamedOn))
paint(container)
expect(scrollRoot(container).scrollTop).toBe(scrolledTo)
expect(offersJumpToLatest()).toBe(true)
})
})
it('keeps following when an earlier turn expands under a pending tail pin', () => {
const messages = [
userMessage(0, 'Earlier turn'),
...Array.from({ length: 8 }, (_, i) => toolMessage(i + 1)),
marker(9),
userMessage(10, 'Current turn'),
marker(11)
]
const { container } = render(
<NativeChatMessageList
session={session(messages)}
isWorking
expandSignal={false}
settledTurns={new Map([['message-0', { startedAt: 1, workedSeconds: 1 }]])}
/>
)
const lastRow = screen.getByText('marker-11').closest<HTMLElement>('[data-index]')
if (!lastRow) {
throw new Error('The current answer is not mounted')
}
layout.measuredRowHeights = Array.from(
{ length: Number(lastRow.dataset.index) + 1 },
(_, index) => (index === Number(lastRow.dataset.index) ? ROW_PX * 20 : ROW_PX)
)
paint(container)
const scroller = scrollRoot(container)
const window = container.querySelector<HTMLElement>('[data-native-chat-window]')
const beforeSlots = window?.querySelectorAll('[data-index]').length ?? 0
// A pin created outside the painted frames is still waiting to reconcile by numeric index.
layout.belowTranscriptPx += 20
deliverResizes()
expect(scroller.scrollTop).toBeGreaterThan(0)
fireEvent.click(screen.getByRole('button', { name: 'Toggle turn details' }))
expect(window?.querySelectorAll('[data-index]').length ?? 0).toBeGreaterThan(beforeSlots)
paint(container)
act(() => vi.advanceTimersByTime(160))
paint(container)
expect(distanceFromBottom(container)).toBe(0)
expect(screen.getByText('marker-11')).toBeInTheDocument()
})
it.each([false, true])(
'keeps Space scrolling in the focused transcript (shift=%s)',
(shiftKey) => {
const insertTypedText = vi.fn(() => true)
const focus = vi.fn(() => true)
const composer = {
focus,
insertTypedText,
insertAgentReferences: () => false,
acceptsText: () => true,
appendText: vi.fn(),
handlePasteEvent: vi.fn(),
pasteFromClipboard: vi.fn(),
contains: () => false
}
const { container } = render(
<div onKeyDownCapture={(event) => routeNativeChatRootKeyToInput(event, composer, null)}>
{list(transcript)}
</div>
)
const root = scrollRoot(container)
root.focus()
fireEvent.keyDown(root, { key: ' ', shiftKey })
expect(document.activeElement).toBe(root)
expect(insertTypedText).not.toHaveBeenCalled()
expect(focus).not.toHaveBeenCalled()
fireEvent.keyDown(root, { key: 'a' })
expect(insertTypedText).toHaveBeenCalledWith('a')
}
)
})
describe('disclosure following across retained pane visibility', () => {
let visible = true
let restore: (() => void)[] = []
beforeEach(() => {
visible = true
vi.useFakeTimers()
layout.belowTranscriptPx = BELOW_TRANSCRIPT_PX
layout.aboveTranscriptPx = 0
layout.measuredRowHeights = []
restore = [
stubLayout({ scrollGeometry: true, offsetChain: true, isVisible: () => visible }),
stubResizeObserver()
]
})
afterEach(() => {
for (const undo of restore.toReversed()) {
undo()
}
layout.measuredRowHeights = []
vi.useRealTimers()
})
function view(messages: NativeChatMessage[]): React.JSX.Element {
return (
<NativeChatMessageList
session={session(messages)}
isVisible={visible}
isWorking
expandSignal={false}
/>
)
}
it.each([false, true])(
'follows passive growth after underflow disclosure (hide before settlement=%s)',
(hideBeforeSettlement) => {
const initial = [marker(0), toolMessage(1)]
const rendered = render(view(initial))
paint(rendered.container)
const scroller = scrollRoot(rendered.container)
expect(scroller.scrollHeight).toBeLessThan(scroller.clientHeight)
fireEvent.click(screen.getByRole('button', { expanded: false }))
if (hideBeforeSettlement) {
visible = false
rendered.rerender(view(initial))
act(() => vi.advanceTimersByTime(300))
visible = true
rendered.rerender(view(initial))
}
paint(rendered.container)
expect(scroller.scrollHeight).toBeLessThan(scroller.clientHeight)
expect(scroller.scrollTop).toBe(0)
const grown = [...initial, ...Array.from({ length: 200 }, (_, i) => marker(i + 10))]
rendered.rerender(view(grown))
paint(rendered.container)
expect(scroller.scrollHeight).toBeGreaterThan(scroller.clientHeight + 1000)
expect(distanceFromBottom(rendered.container)).toBe(0)
expect(screen.getByText('marker-209')).toBeInTheDocument()
}
)
it.each([false, true])(
'restores distant history after interrupted disclosure (growth while hidden=%s)',
(growWhileHidden) => {
const initial = transcript.with(20, toolMessage(20))
const grown = [...initial, ...Array.from({ length: 200 }, (_, i) => marker(i + 1000))]
const rendered = render(view(initial))
paint(rendered.container)
scrollTranscript(rendered.container, 900)
paint(rendered.container)
const scroller = scrollRoot(rendered.container)
expect(distanceFromBottom(rendered.container)).toBeGreaterThan(1000)
const readingAt = scroller.scrollTop
fireEvent.click(screen.getByRole('button', { expanded: false }))
visible = false
rendered.rerender(view(growWhileHidden ? grown : initial))
paint(rendered.container)
act(() => vi.advanceTimersByTime(300))
visible = true
rendered.rerender(view(growWhileHidden ? grown : initial))
paint(rendered.container)
expect(scroller.scrollTop).toBe(readingAt)
expect(distanceFromBottom(rendered.container)).toBeGreaterThan(1000)
expect(offersJumpToLatest()).toBe(true)
rendered.rerender(view([...grown, marker(1200)]))
paint(rendered.container)
expect(scroller.scrollTop).toBe(readingAt)
expect(distanceFromBottom(rendered.container)).toBeGreaterThan(1000)
}
)
})
@@ -1,32 +0,0 @@
// @vitest-environment happy-dom
import '@testing-library/jest-dom/vitest'
import { cleanup } from '@testing-library/react'
import { afterEach, vi } from 'vitest'
// Why: these fixtures have neither inline visual owners nor sender navigation.
const unusedChatLeaves = vi.hoisted(() => ({
inlineVisual: vi.fn(() => {
throw new Error('Unexpected inline visual in transcript fixture')
}),
openSender: vi.fn(() => {
throw new Error('Unexpected sender navigation in transcript fixture')
})
}))
vi.mock('../../media/visuals/NativeChatInlineVisual', () => ({
NativeChatInlineVisual: unusedChatLeaves.inlineVisual
}))
vi.mock('@/lib/open-agent-message-sender', () => ({
openAgentMessageSender: unusedChatLeaves.openSender
}))
// Pacing is not this test's subject.
vi.mock('../../markdown/use-native-chat-paced-text', async (importOriginal) =>
(await import('../../markdown/native-chat-unpaced-text-fixture')).unpacedTextModule(
importOriginal
)
)
afterEach(cleanup)
await import('../virtualization/NativeChatMessageList.growth-windowing.spec')
await import('../navigation/NativeChatMessageList.reader-navigation.spec')
@@ -1,652 +0,0 @@
import { act, fireEvent, screen } from '@testing-library/react'
import { render } from '../../messages/actions/native-chat-tooltip-test-harness'
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
import type { NativeChatMessage } from '../../../../../../shared/native-chat/native-chat-types'
import { NativeChatMessageList } from '../../NativeChatMessageList'
import {
NATIVE_CHAT_BOTTOM_THRESHOLD_PX,
NATIVE_CHAT_FOLLOW_REARM_PX
} from '../scroll/native-chat-autoscroll'
import { NATIVE_CHAT_ROW_GAP_PX } from './native-chat-row-height-estimate'
import {
BELOW_TRANSCRIPT_PX,
deliverResizes,
layout,
list,
marker,
ROW_PITCH_PX,
ROW_PX,
scrollTranscript,
session,
stubLayout,
stubResizeObserver,
TRANSCRIPT_LENGTH,
VIEWPORT_PX,
windowState
} from './native-chat-windowing-test-harness'
function scrollRoot(container: HTMLElement): HTMLElement {
const scroller = container.querySelector<HTMLElement>('[data-native-chat-scroll]')
if (!scroller) {
throw new Error('no transcript scroll root')
}
return scroller
}
/** Deliver resize and scroll events to a fixed point, as a painted frame would. */
function paint(container: HTMLElement): void {
const scroller = scrollRoot(container)
let lastScrollTop = scroller.scrollTop
for (let pass = 0; pass < 12; pass += 1) {
let changed = false
act(() => {
changed = deliverResizes()
})
if (scroller.scrollTop !== lastScrollTop) {
lastScrollTop = scroller.scrollTop
fireEvent.scroll(scroller)
changed = true
}
if (!changed) {
return
}
}
throw new Error('the transcript never settled: resize and scroll kept moving it')
}
describe('transcript follow ownership across growth and appends', () => {
const TAIL_INDEX = TRANSCRIPT_LENGTH - 1
const GROWTH_STEPS = 24
const LINES_PER_STEP = 12
// Grow content and measured height from the same wrapped-line size.
const STREAM_LINE_PX = 22
/** All settled rows measure at their estimates, keeping reserved totals deterministic. */
const BASE_TOTAL_PX =
(TRANSCRIPT_LENGTH - 1) * ROW_PX + (TRANSCRIPT_LENGTH - 1) * NATIVE_CHAT_ROW_GAP_PX
/** Fixed so a re-render never restamps the turn and moves the status row. */
const TURN_STARTED_AT = Date.now()
const transcript = Array.from({ length: TRANSCRIPT_LENGTH }, (_, index) => marker(index))
function appendedTranscript(count: number): NativeChatMessage[] {
return [
...transcript,
...Array.from({ length: count }, (_, index) => marker(TRANSCRIPT_LENGTH + index))
]
}
function tailHeightAt(step: number): number {
return Math.max(ROW_PX, (1 + step * LINES_PER_STEP) * STREAM_LINE_PX)
}
function transcriptAt(step: number): NativeChatMessage[] {
const lines = Array.from(
{ length: step * LINES_PER_STEP },
(_, index) => `streamed line ${index}`
)
const next = [...transcript]
next[TAIL_INDEX] = {
...marker(TAIL_INDEX),
blocks: [{ type: 'text', text: [`marker-${TAIL_INDEX}`, ...lines].join('\n') }]
}
return next
}
function streamingList(step: number): React.JSX.Element {
return (
<NativeChatMessageList
session={session(transcriptAt(step))}
isWorking
expandSignal={false}
workingStartedAt={TURN_STARTED_AT}
/>
)
}
function distanceFromBottom(container: HTMLElement): number {
const scroller = scrollRoot(container)
return scroller.scrollHeight - scroller.clientHeight - scroller.scrollTop
}
function setMeasuredTail(step: number): void {
const heights = Array.from({ length: TRANSCRIPT_LENGTH }, () => ROW_PX)
heights[TAIL_INDEX] = tailHeightAt(step)
layout.measuredRowHeights = heights
}
let restoreLayout = (): void => {}
let restoreResizeObserver = (): void => {}
beforeEach(() => {
restoreLayout = stubLayout({ scrollGeometry: true, offsetChain: true })
restoreResizeObserver = stubResizeObserver()
layout.belowTranscriptPx = BELOW_TRANSCRIPT_PX
layout.aboveTranscriptPx = 0
setMeasuredTail(0)
})
afterEach(() => {
restoreResizeObserver()
restoreLayout()
layout.measuredRowHeights = []
layout.belowTranscriptPx = BELOW_TRANSCRIPT_PX
layout.aboveTranscriptPx = 0
vi.restoreAllMocks()
})
it('pins a mounted row before the virtualizer receives its resized height', () => {
setMeasuredTail(4)
const { container } = render(streamingList(4))
paint(container)
const scroller = scrollRoot(container)
const before = scroller.scrollHeight
setMeasuredTail(8)
expect(scroller.scrollHeight - before).toBe(tailHeightAt(8) - tailHeightAt(4))
act(() => deliverResizes((target) => target.hasAttribute('data-native-chat-transcript-column')))
expect(distanceFromBottom(container)).toBe(0)
const pinned = scroller.scrollTop
paint(container)
expect(scroller.scrollTop).toBe(pinned)
expect(distanceFromBottom(container)).toBe(0)
})
it('holds the pin, the mount and the reserved total at every frame of the growth', () => {
setMeasuredTail(0)
const { container, rerender } = render(streamingList(0))
paint(container)
expect(distanceFromBottom(container)).toBeLessThanOrEqual(NATIVE_CHAT_BOTTOM_THRESHOLD_PX)
expect(windowState(container).totalSize).toBe(BASE_TOTAL_PX + tailHeightAt(0))
const frames: { step: number; tail: number; total: number; distance: number }[] = []
for (let step = 1; step <= GROWTH_STEPS; step += 1) {
setMeasuredTail(step)
rerender(streamingList(step))
paint(container)
const { totalSize, indexes } = windowState(container)
const distance = distanceFromBottom(container)
frames.push({ step, tail: tailHeightAt(step), total: totalSize, distance })
expect(distance).toBeLessThanOrEqual(NATIVE_CHAT_BOTTOM_THRESHOLD_PX)
expect(indexes).toContain(TAIL_INDEX)
expect(screen.getByText(/streamed line 0/)).toBeInTheDocument()
expect(totalSize).toBe(BASE_TOTAL_PX + tailHeightAt(step))
expect(indexes.length).toBeLessThan(TRANSCRIPT_LENGTH / 4)
}
expect(frames).toHaveLength(GROWTH_STEPS)
expect(frames.at(-1)?.tail).toBeGreaterThan(VIEWPORT_PX * 10)
expect(Math.max(...frames.map((frame) => frame.distance))).toBeLessThanOrEqual(
NATIVE_CHAT_BOTTOM_THRESHOLD_PX
)
})
it('leaves a reader who scrolled up where they were, however far the row grows', () => {
setMeasuredTail(4)
const { container, rerender } = render(streamingList(4))
paint(container)
const readingAt = 2000
scrollTranscript(container, readingAt)
paint(container)
expect(distanceFromBottom(container)).toBeGreaterThan(NATIVE_CHAT_BOTTOM_THRESHOLD_PX)
expect(screen.getByRole('button', { name: /jump to latest/i })).toBeInTheDocument()
for (let step = 5; step <= GROWTH_STEPS; step += 1) {
setMeasuredTail(step)
rerender(streamingList(step))
paint(container)
const { totalSize, indexes } = windowState(container)
expect(scrollRoot(container).scrollTop).toBe(readingAt)
// Keep measuring the offscreen live row so its reserved height and scrollbar track growth.
expect(indexes).toContain(TAIL_INDEX)
expect(totalSize).toBe(BASE_TOTAL_PX + tailHeightAt(step))
}
expect(screen.getByRole('button', { name: /jump to latest/i })).toBeInTheDocument()
})
it.each([0, 100])(
'keeps a reader parked above a growing row with a %i px initial measurement delta',
(measurementDelta) => {
setMeasuredTail(4)
layout.measuredRowHeights = layout.measuredRowHeights.map((height, index) =>
index === TAIL_INDEX ? height + measurementDelta : height
)
const { container, rerender } = render(streamingList(4))
paint(container)
const scroller = scrollRoot(container)
const parkGapPx = NATIVE_CHAT_BOTTOM_THRESHOLD_PX - 8
const parkedAt = scroller.scrollHeight - scroller.clientHeight - parkGapPx
scrollTranscript(container, parkedAt)
expect(distanceFromBottom(container)).toBe(parkGapPx)
expect(screen.queryByRole('button', { name: /jump to latest/i })).toBeNull()
setMeasuredTail(5)
rerender(streamingList(5))
paint(container)
expect(scroller.scrollTop).toBe(parkedAt)
let previousDistance = distanceFromBottom(container)
for (let step = 6; step <= GROWTH_STEPS; step += 1) {
setMeasuredTail(step)
rerender(streamingList(step))
paint(container)
expect(scroller.scrollTop).toBe(parkedAt)
const distance = distanceFromBottom(container)
expect(distance).toBeGreaterThan(previousDistance)
previousDistance = distance
}
expect(previousDistance).toBeGreaterThan(VIEWPORT_PX)
expect(screen.getByRole('button', { name: /jump to latest/i })).toBeInTheDocument()
}
)
it('leaves a parked reader in place through repeated appends', () => {
const { container, rerender } = render(list(transcript))
paint(container)
const scroller = scrollRoot(container)
const parkedAt = scroller.scrollHeight - scroller.clientHeight - 40
scrollTranscript(container, parkedAt)
for (let count = 1; count <= 8; count += 1) {
rerender(list(appendedTranscript(count)))
paint(container)
expect(scroller.scrollTop).toBe(parkedAt)
expect(windowState(container).indexes.length).toBeLessThan(TRANSCRIPT_LENGTH / 4)
}
expect(screen.getByRole('button', { name: /jump to latest/i })).toBeInTheDocument()
})
it('follows repeated appends until the reader detaches', () => {
const { container, rerender } = render(list(transcript))
paint(container)
const scroller = scrollRoot(container)
for (let count = 1; count <= 8; count += 1) {
rerender(list(appendedTranscript(count)))
paint(container)
expect(distanceFromBottom(container)).toBeLessThanOrEqual(NATIVE_CHAT_FOLLOW_REARM_PX)
fireEvent.scroll(scroller)
}
const parkedAt = scroller.scrollTop - 22
scrollTranscript(container, parkedAt)
rerender(list(appendedTranscript(9)))
paint(container)
expect(scroller.scrollTop).toBe(parkedAt)
})
it('follows an empty transcript through underflow into scrollable output', () => {
const { container, rerender } = render(list([]))
paint(container)
expect(scrollRoot(container).scrollTop).toBe(0)
rerender(list(transcript.slice(0, 1)))
paint(container)
expect(scrollRoot(container).scrollTop).toBe(0)
fireEvent.scroll(scrollRoot(container))
rerender(list(transcript))
paint(container)
expect(distanceFromBottom(container)).toBeLessThanOrEqual(NATIVE_CHAT_FOLLOW_REARM_PX)
expect(windowState(container).indexes.length).toBeLessThan(TRANSCRIPT_LENGTH / 4)
})
it.each(['reader', 'jump'] as const)('rearms growth and append following via %s', (rearm) => {
setMeasuredTail(4)
const { container, rerender } = render(streamingList(4))
paint(container)
const scroller = scrollRoot(container)
fireEvent.scroll(scroller)
const parkedAt = scroller.scrollTop - 22
scrollTranscript(container, parkedAt)
setMeasuredTail(5)
rerender(streamingList(5))
paint(container)
expect(scroller.scrollTop).toBe(parkedAt)
if (rearm === 'reader') {
scrollTranscript(
container,
scroller.scrollHeight - scroller.clientHeight - NATIVE_CHAT_FOLLOW_REARM_PX
)
} else {
fireEvent.click(screen.getByRole('button', { name: /jump to latest/i }))
}
paint(container)
expect(screen.queryByRole('button', { name: /jump to latest/i })).toBeNull()
for (let step = 6; step <= 8; step += 1) {
setMeasuredTail(step)
rerender(streamingList(step))
paint(container)
expect(distanceFromBottom(container)).toBeLessThanOrEqual(NATIVE_CHAT_FOLLOW_REARM_PX)
expect(windowState(container).indexes.length).toBeLessThan(TRANSCRIPT_LENGTH / 4)
}
rerender(list([...transcriptAt(8), marker(TRANSCRIPT_LENGTH)]))
paint(container)
expect(distanceFromBottom(container)).toBeLessThanOrEqual(NATIVE_CHAT_FOLLOW_REARM_PX)
})
it('preserves the visible row anchor across prepends while detached', () => {
const { container, rerender } = render(list(transcript))
paint(container)
const readingAt = 2000
scrollTranscript(container, readingAt)
paint(container)
const earlier = Array.from({ length: 10 }, (_, index) => marker(index - 10))
rerender(list([...earlier, ...transcript]))
paint(container)
expect(scrollRoot(container).scrollTop).toBe(readingAt + earlier.length * ROW_PITCH_PX)
expect(windowState(container).indexes.length).toBeLessThan(TRANSCRIPT_LENGTH / 4)
expect(screen.getByRole('button', { name: /jump to latest/i })).toBeInTheDocument()
})
it('compensates a measurement entirely above the viewport without reattaching', () => {
const { container, rerender } = render(list(transcript))
paint(container)
const scroller = scrollRoot(container)
// Seed forward scrolling; backward-scroll suppression is covered separately.
scrollTranscript(container, 0)
paint(container)
const readingAt = 2000
scrollTranscript(container, readingAt)
paint(container)
const aboveIndex = windowState(container).indexes[0]!
expect((aboveIndex + 1) * ROW_PITCH_PX).toBeLessThan(readingAt)
for (const growth of [100, 200]) {
layout.measuredRowHeights = Array.from({ length: TRANSCRIPT_LENGTH }, (_, index) =>
index === aboveIndex ? ROW_PX + growth : ROW_PX
)
paint(container)
expect(scroller.scrollTop).toBe(readingAt + growth)
}
rerender(list(appendedTranscript(1)))
paint(container)
expect(scroller.scrollTop).toBe(readingAt + 200)
expect(windowState(container).indexes.length).toBeLessThan(TRANSCRIPT_LENGTH / 4)
})
it('releases browsed history when passive wheel input arrives after the browser moved', () => {
const release = vi.fn()
const { container } = render(
<NativeChatMessageList
session={{ ...session(transcript), retainHistory: () => release }}
isWorking={false}
expandSignal={false}
/>
)
paint(container)
const scroller = scrollRoot(container)
fireEvent.scroll(scroller)
scrollTranscript(container, scroller.scrollHeight - scroller.clientHeight - 20)
paint(container)
expect(release).not.toHaveBeenCalled()
scroller.scrollTop = scroller.scrollHeight - scroller.clientHeight
fireEvent.wheel(scroller, { deltaY: 20 })
// ResizeObserver can notify before the pending native scroll, without changing the content.
act(() => {
deliverResizes()
})
fireEvent.scroll(scroller)
paint(container)
expect(release).toHaveBeenCalledOnce()
})
it('preserves a pending wheel return through a no-op following pin after reveal', () => {
layout.belowTranscriptPx = 100
const release = vi.fn()
const retainedSession = { ...session(transcript), retainHistory: () => release }
const pane = (isVisible: boolean) => (
<NativeChatMessageList
session={retainedSession}
isVisible={isVisible}
isWorking={false}
expandSignal={false}
/>
)
const { container, rerender } = render(pane(true))
paint(container)
const scroller = scrollRoot(container)
fireEvent.scroll(scroller)
const readingAt = scroller.scrollHeight - scroller.clientHeight - 62
scrollTranscript(container, readingAt)
paint(container)
rerender(pane(false))
layout.belowTranscriptPx -= 60
rerender(pane(true))
fireEvent.scroll(scroller)
expect(scroller.scrollTop).toBe(readingAt)
expect(release).not.toHaveBeenCalled()
scroller.scrollTop = scroller.scrollHeight - scroller.clientHeight
fireEvent.wheel(scroller, { deltaY: 2 })
act(() => {
deliverResizes()
})
fireEvent.scroll(scroller)
paint(container)
expect(release).toHaveBeenCalledOnce()
})
it.each([false, true])(
'keeps reader-return evidence current after compensation (tail clamps: %s)',
(clamps) => {
layout.belowTranscriptPx = 100
const release = vi.fn()
const retainHistory = () => release
const { container } = render(
<NativeChatMessageList
session={{ ...session(transcript), retainHistory }}
isWorking={false}
expandSignal={false}
/>
)
paint(container)
const scroller = scrollRoot(container)
const end = scroller.scrollHeight - scroller.clientHeight
// One scrollbar press owns the entire drag, including movement after measurements.
fireEvent.pointerDown(scroller)
scroller.scrollTop = end - 20
fireEvent.scroll(scroller)
paint(container)
scroller.scrollTop += 1
fireEvent.scroll(scroller)
paint(container)
const before = scroller.scrollTop
const aboveIndex = windowState(container).indexes[0]!
expect((aboveIndex + 1) * ROW_PITCH_PX).toBeLessThan(before)
layout.measuredRowHeights = Array.from({ length: TRANSCRIPT_LENGTH }, (_, index) =>
index === aboveIndex ? ROW_PX + 200 : ROW_PX
)
paint(container)
expect(scroller.scrollTop).toBe(before + 200)
expect(release).not.toHaveBeenCalled()
if (clamps) {
layout.belowTranscriptPx -= 60
const beforeClamp = scroller.scrollTop
scroller.scrollTop = beforeClamp
fireEvent.scroll(scroller)
paint(container)
expect(distanceFromBottom(container)).toBe(0)
expect(release).not.toHaveBeenCalled()
// A subsequent genuine gesture still releases the same retained history.
fireEvent.pointerDown(scroller)
scroller.scrollTop -= 20
fireEvent.scroll(scroller)
paint(container)
}
scroller.scrollTop = scroller.scrollHeight - scroller.clientHeight
fireEvent.scroll(scroller)
paint(container)
expect(release).toHaveBeenCalledOnce()
}
)
it('keeps following when a pin echo arrives after the document grows', () => {
setMeasuredTail(0)
const { container } = render(streamingList(0))
paint(container)
const scroller = scrollRoot(container)
setMeasuredTail(1)
expect(deliverResizes()).toBe(true)
const pinnedAt = scroller.scrollTop
layout.belowTranscriptPx += 2_000
fireEvent.scroll(scroller)
expect(scroller.scrollTop).toBe(pinnedAt)
expect(screen.queryByRole('button', { name: /jump to latest/i })).toBeNull()
paint(container)
expect(distanceFromBottom(container)).toBeLessThanOrEqual(NATIVE_CHAT_FOLLOW_REARM_PX)
})
it('does not counter upward scrolling when measured overscan rows settle', () => {
const readingAt = 2000
const aboveIndex = Math.floor(readingAt / ROW_PITCH_PX) - 1
const { container } = render(list(transcript))
paint(container)
scrollTranscript(container, readingAt + 100)
paint(container)
layout.measuredRowHeights = Array.from({ length: TRANSCRIPT_LENGTH }, (_, index) =>
index === aboveIndex ? ROW_PX + 10 : ROW_PX
)
paint(container)
scrollTranscript(container, readingAt)
paint(container)
const scroller = scrollRoot(container)
const scrollTo = vi.spyOn(scroller, 'scrollTo')
layout.measuredRowHeights = layout.measuredRowHeights.map((height, index) =>
index === aboveIndex ? height + 20 : height
)
paint(container)
expect(scroller.scrollTop).toBe(readingAt)
expect(scrollTo).not.toHaveBeenCalled()
})
it('keeps the offset when a visible row shrinks past the viewport top', () => {
const focusedIndex = 45
const { container } = render(list(transcript))
paint(container)
scrollTranscript(container, focusedIndex * ROW_PITCH_PX)
paint(container)
layout.measuredRowHeights = Array.from({ length: TRANSCRIPT_LENGTH }, (_, index) =>
index === focusedIndex ? 100 : ROW_PX
)
paint(container)
const readingAt = focusedIndex * ROW_PITCH_PX + 60
scrollTranscript(container, readingAt)
paint(container)
const scroller = scrollRoot(container)
const scrollTo = vi.spyOn(scroller, 'scrollTo')
layout.measuredRowHeights = layout.measuredRowHeights.map((height, index) =>
index === focusedIndex ? 30 : height
)
paint(container)
expect(scroller.scrollTop).toBe(readingAt)
expect(scrollTo).not.toHaveBeenCalled()
})
it('settles a pending end reconcile after the reader keeps scrolling away', async () => {
setMeasuredTail(0)
const { container } = render(streamingList(0))
const scroller = scrollRoot(container)
// Trigger a pin outside React's act wrapper so its TanStack rAF reconcile is
// still pending when the reader moves away.
setMeasuredTail(1)
expect(deliverResizes()).toBe(true)
const scheduleSpy = vi.spyOn(window, 'requestAnimationFrame')
const scrollToSpy = vi.spyOn(scroller, 'scrollTo')
const readingAt = 2000
fireEvent.wheel(scroller, { deltaY: -100 })
scroller.scrollTop = readingAt
fireEvent.scroll(scroller)
expect(scrollToSpy).toHaveBeenLastCalledWith({ behavior: 'auto', top: readingAt })
scroller.scrollTop = 1800
fireEvent.scroll(scroller)
expect(scrollToSpy).toHaveBeenLastCalledWith({ behavior: 'auto', top: 1800 })
await act(async () => {
for (let frame = 0; frame < 6; frame += 1) {
await new Promise<void>((resolve) => requestAnimationFrame(() => resolve()))
}
})
const scheduledFrames = scheduleSpy.mock.calls.length
scheduleSpy.mockRestore()
scrollToSpy.mockRestore()
expect(scheduledFrames).toBeLessThanOrEqual(8)
expect(scroller.scrollTop).toBe(1800)
expect(screen.getByRole('button', { name: /jump to latest/i })).toBeInTheDocument()
})
// Chrome outside the spacer makes document-end and virtualizer-end calculations disagree.
describe('with a gutter above the transcript', () => {
/** Exceed the normal top gutter to expose spacer/document coordinate differences. */
const GUTTER_PX = 92
/** Far enough up that the transcript itself calls the reader detached, and
* still inside the band the virtualizer computes (48 + 92 + 24). */
const READING_ABOVE_END_PX = 96
// A nonzero delta seeds the size cache; zero exercises first-measure growth.
const MEASURE_SKEW_PX = 7
function setSkewedTail(step: number, skew = MEASURE_SKEW_PX): void {
const heights = Array.from({ length: TRANSCRIPT_LENGTH }, () => ROW_PX)
heights[TAIL_INDEX] = tailHeightAt(step) + skew
layout.measuredRowHeights = heights
}
beforeEach(() => {
layout.aboveTranscriptPx = GUTTER_PX
})
it.each([0, MEASURE_SKEW_PX])(
'leaves a reader just above the end while the row grows (skew %i)',
(skew) => {
setSkewedTail(4, skew)
const { container, rerender } = render(streamingList(4))
paint(container)
const scroller = scrollRoot(container)
const readingAt = scroller.scrollHeight - scroller.clientHeight - READING_ABOVE_END_PX
scrollTranscript(container, readingAt)
paint(container)
expect(distanceFromBottom(container)).toBe(READING_ABOVE_END_PX)
for (let step = 5; step <= 10; step += 1) {
setSkewedTail(step, skew)
rerender(streamingList(step))
paint(container)
expect(scroller.scrollTop).toBe(readingAt)
}
}
)
it('still pins a reader who is at the end, with the gutter in the document', () => {
setSkewedTail(4)
const { container, rerender } = render(streamingList(4))
paint(container)
expect(distanceFromBottom(container)).toBeLessThanOrEqual(NATIVE_CHAT_BOTTOM_THRESHOLD_PX)
for (let step = 5; step <= 10; step += 1) {
setSkewedTail(step)
rerender(streamingList(step))
paint(container)
expect(distanceFromBottom(container)).toBeLessThanOrEqual(NATIVE_CHAT_BOTTOM_THRESHOLD_PX)
}
})
})
})
@@ -1,17 +0,0 @@
import { expect, it } from 'vitest'
import { FileInventoryBudget, FileInventoryCapacityError } from './file-inventory-budget'
it('accepts the retained-byte boundary and rejects the next entry', () => {
const budget = new FileInventoryBudget(132)
budget.record('a')
budget.record('b')
expect(() => budget.record('c')).toThrow(FileInventoryCapacityError)
})
it('charges serialized escaping and rejects an oversized individual path', () => {
const escaped = new FileInventoryBudget(100)
expect(() => escaped.record('\u0001'.repeat(18))).toThrow(FileInventoryCapacityError)
expect(() => new FileInventoryBudget().record('x'.repeat(65537))).toThrow(
FileInventoryCapacityError
)
})
@@ -1,25 +0,0 @@
import { describe, expect, it } from 'vitest'
import type { MarkdownDocument } from './file-document'
import {
assertMarkdownDocumentsWithinLimit,
MarkdownDocumentListingCapacityError
} from './markdown-document-listing-limits'
function document(path: string): MarkdownDocument {
return {
filePath: `/repo/${path}`,
relativePath: path,
basename: path,
name: path
}
}
describe('Markdown document listing limits', () => {
it('rejects aggregate metadata overflow', () => {
expect(() =>
assertMarkdownDocumentsWithinLimit([document('a'.repeat(100))], {
maxMetadataBytes: 100
})
).toThrow(MarkdownDocumentListingCapacityError)
})
})
@@ -1,28 +0,0 @@
import { describe, expect, it } from 'vitest'
import { formatOrchestrationCheckText } from './orchestration-check-output'
describe('formatted delivery acknowledgment', () => {
it('prints bodies and payloads for the plain check the wake tells agents to run', () => {
const text = formatOrchestrationCheckText(
{
messages: [
{
id: 'msg_question',
type: 'question',
from_handle: 'dispatch:ctx_worker',
to_handle: 'run:run_review',
subject: 'Question',
body: 'Should I preserve the old API or remove it?',
payload: '{"taskId":"task_1","dispatchId":"ctx_worker"}'
}
],
count: 1,
deliveryId: 'delivery_review',
deliveryAcknowledged: true
},
'run:run_review'
)
expect(text).toContain('Should I preserve the old API or remove it?')
expect(text).toContain('"dispatchId":"ctx_worker"')
})
})
@@ -1,19 +0,0 @@
import { describe, expect, it } from 'vitest'
import { abbreviateOrchestrationTasks } from './orchestration-task-summary'
describe('abbreviateOrchestrationTasks', () => {
it('does not report whitespace normalization as truncation', () => {
const [task] = abbreviateOrchestrationTasks([{ spec: 'Short\n\n task' }])
expect(task).toEqual({ spec: 'Short task', spec_truncated: false })
})
it('does not split a surrogate pair at the truncation boundary', () => {
// UTF-16 boundary 159 splits the emoji’s surrogate pair.
const [task] = abbreviateOrchestrationTasks([{ spec: `${'a'.repeat(158)}😀${'b'.repeat(40)}` }])
expect(task.spec_truncated).toBe(true)
expect(task.spec.isWellFormed()).toBe(true)
expect(task.spec.endsWith('…')).toBe(true)
})
})
@@ -1,18 +0,0 @@
import { expect, it } from 'vitest'
import { quickOpenRecentCandidateSet } from './quick-open-recent-candidates'
it('keeps bounded root-relative candidates without accepting outside paths or traversal', () => {
expect([
...quickOpenRecentCandidateSet([
'src/file.ts',
'src/file.ts',
'../file',
'/external',
'C:/external',
'\\\\host\\share\\file',
'nested/../file',
'bad\0file'
])
]).toEqual(['src/file.ts'])
expect(() => quickOpenRecentCandidateSet(Array(101).fill('file'))).toThrow('Too many')
expect(() => quickOpenRecentCandidateSet(['x'.repeat(64 * 1024 + 1)])).toThrow('too large')
})
@@ -1,17 +0,0 @@
import { describe, expect, it } from 'vitest'
import { QuickOpenSubprocessPathAccumulator } from './quick-open-subprocess-path-accumulator'
describe('Quick Open subprocess path accumulator', () => {
it('stops within a multi-path chunk without visiting later fields', () => {
const visited: string[] = []
const fields = new QuickOpenSubprocessPathAccumulator(0, 16)
expect(
fields.push(Buffer.from('one\0two\0three\0'), (path) => {
visited.push(path)
return path !== 'two'
})
).toBe('stopped')
expect(visited).toEqual(['one', 'two'])
})
})