mirror of
https://github.com/stablyai/orca.git
synced 2026-11-16 10:58:10 +00:00
499 lines
18 KiB
TypeScript
499 lines
18 KiB
TypeScript
import { EVERY_AGENT_CHAT } from '../../src/shared/native-chat/every-agent-chat.test-fixture'
|
|
|
|
import type { createChatRendererBridge } from './helpers/automation-chat-renderer-test-harness'
|
|
import { exerciseBusyChatReuse } from './helpers/automation-chat-reuse-test-harness'
|
|
import { readAutomationRunReceipt } from '../../src/main/automations/automation-run-receipt'
|
|
import {
|
|
AUTOMATION_AGENT_CALLER,
|
|
automationRunOperationId
|
|
} from '../../src/main/automations/automation-run-operation'
|
|
import { rpcCallerOperationKey } from '../../src/main/runtime/rpc/rpc-caller-identity'
|
|
import {
|
|
HOST_TEST_NOW,
|
|
HOST_TEST_SESSION,
|
|
HOST_TEST_LOCATION
|
|
} from '../../src/main/native-chat/agent-session-wire/host/testing/structured-agent-session-host-test-data'
|
|
import type { callStructuredAgentSession } from '@/runtime/native-chat/requests/structured-agent-session-call'
|
|
import type { StructuredAgentSessionHost } from '../../src/main/native-chat/agent-session-wire/host/structured-agent-session-host'
|
|
import { createQueuedMessageTestRig } from '../../src/main/native-chat/agent-session-wire/host/testing/structured-agent-session-queued-message-rig.test-fixture'
|
|
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
|
|
import type { OrcaRuntimeService } from '../../src/main/runtime/orca-runtime'
|
|
import type { AgentLaunchResult } from '../../src/shared/agent-launch/contracts/agent-launch-intent'
|
|
import { buildProfileStateCutoverFixture } from '../../src/main/persistence/profile-state-cutover-fixture'
|
|
import { launchAutomationChatAgent } from '../../src/main/automations/automation-chat-agent-launch'
|
|
|
|
const mocks = vi.hoisted(() => {
|
|
const hostState: {
|
|
actualHost: StructuredAgentSessionHost | null
|
|
renderer: Awaited<ReturnType<typeof createChatRendererBridge>> | null
|
|
} = { actualHost: null, renderer: null }
|
|
return {
|
|
...hostState,
|
|
hostAvailable: true,
|
|
readChat: vi.fn<typeof callStructuredAgentSession>().mockResolvedValue({}),
|
|
launch: vi.fn(),
|
|
host: { journalSnapshot: vi.fn(), currentWork: vi.fn(), send: vi.fn() }
|
|
}
|
|
})
|
|
vi.mock('../../src/main/runtime/rpc/methods/agent-launch/agent-launch', () => ({
|
|
launchAgentOnHost: mocks.launch
|
|
}))
|
|
vi.mock(
|
|
'../../src/main/native-chat/agent-session-wire/host/structured-agent-session-registry',
|
|
() => ({
|
|
getStructuredAgentSessionHost: () =>
|
|
mocks.actualHost ?? (mocks.hostAvailable ? mocks.host : null)
|
|
})
|
|
)
|
|
vi.mock(
|
|
'../../src/renderer/src/runtime/native-chat/requests/structured-agent-session-call',
|
|
() => ({
|
|
callStructuredAgentSession: (...args: Parameters<typeof callStructuredAgentSession>) =>
|
|
mocks.readChat(...args)
|
|
})
|
|
)
|
|
vi.mock('@/runtime/rpc/calls/runtime-rpc-call', () => ({
|
|
callRuntimeRpc: (
|
|
target: Parameters<NonNullable<typeof mocks.renderer>['call']>[0],
|
|
method: string,
|
|
params: unknown
|
|
) => {
|
|
if (!mocks.renderer) {
|
|
throw new Error('renderer not bound')
|
|
}
|
|
return mocks.renderer.call(target, method, params)
|
|
}
|
|
}))
|
|
vi.mock('@/runtime/rpc/compatibility/runtime-capability-proof', () => ({
|
|
runtimeEnvironmentSupportsCapability: async () => true
|
|
}))
|
|
vi.mock('@/lib/workspace/activation/worktree-activation', () => ({
|
|
activateAndRevealWorktree: () => true
|
|
}))
|
|
vi.mock('@/store', () => ({
|
|
useAppStore: {
|
|
getState: () =>
|
|
mocks.renderer?.store.getState() ?? {
|
|
settings: {},
|
|
repos: [],
|
|
worktreesByRepo: {},
|
|
getTab: () => undefined,
|
|
terminalLayoutsByTabId: {},
|
|
ptyIdsByTabId: {}
|
|
}
|
|
}
|
|
}))
|
|
vi.mock('sonner', () => ({ toast: { error: vi.fn(), message: vi.fn() } }))
|
|
const state = buildProfileStateCutoverFixture('/fixture')
|
|
const run = { ...state.automationRuns[0], id: 'run-1', createdAt: Date.now() }
|
|
const automation = {
|
|
...state.automations[0],
|
|
id: run.automationId,
|
|
agentId: 'claude' as const,
|
|
workspaceMode: 'existing' as const,
|
|
workspaceId: 'wt-1',
|
|
prompt: 'Audit',
|
|
surface: 'chat' as const,
|
|
extraAgentArgs: undefined
|
|
}
|
|
const target = { ok: true as const, repo: state.repos[0], cwd: '/fixture' }
|
|
const terminal: AgentLaunchResult = {
|
|
worktreeId: 'wt-1',
|
|
outcome: { kind: 'terminal', handle: 'term-1', paneKey: 'tab-1:leaf-1' },
|
|
receipt: {
|
|
mode: 'terminal',
|
|
preferred: 'structured',
|
|
reason: 'structured_unsupported_on_host',
|
|
detail: 'Fallback'
|
|
},
|
|
prompt: { delivery: 'submit', outcome: 'handed-to-terminal' }
|
|
}
|
|
const chat: AgentLaunchResult = {
|
|
...terminal,
|
|
outcome: { kind: 'structured', sessionId: 'claude_chat', handle: 'chat-tab' },
|
|
prompt: { delivery: 'submit', outcome: 'journaled', messageId: 'first-message' }
|
|
}
|
|
function fixture() {
|
|
const conversation = (id: string) => ({
|
|
sessionId: id,
|
|
provider: 'claude',
|
|
location: { workspaceId: 'wt-1' },
|
|
currentFence: 2
|
|
})
|
|
const records = {
|
|
readOnly: false,
|
|
selectWritableRecord: vi.fn((_id: string): { kind: 'writable' | 'missing' | 'unreadable' } => ({
|
|
kind: 'writable'
|
|
})),
|
|
isSessionUnreadable: vi.fn(() => false),
|
|
readCommandReceipt: vi.fn(() => ({ verdict: 'absent' })),
|
|
getOperationRow: vi.fn(),
|
|
getConversation: vi.fn<(id: string) => ReturnType<typeof conversation> | null>(conversation)
|
|
}
|
|
const runtime = {
|
|
requireStore: () => ({
|
|
getSettings: () => ({
|
|
nativeChatProviders: EVERY_AGENT_CHAT,
|
|
workspaceDir: '/fixture',
|
|
nestWorkspaces: false,
|
|
agentDefaultArgs: { claude: '--model sonnet --add-dir docs' }
|
|
})
|
|
}),
|
|
showTerminalWorkspaceLaunchScope: vi.fn(async () => ({
|
|
id: 'wt-1',
|
|
path: '/fixture',
|
|
connectionId: 'ssh-test'
|
|
})),
|
|
showManagedWorktree: vi.fn(async () => ({ displayName: 'Audit' })),
|
|
showTerminal: vi.fn(async () => ({ tabId: 'tab-1' })),
|
|
getTerminalPtyIdForHandle: vi.fn(() => 'pty-1'),
|
|
getTerminalPaneKey: vi.fn(() => 'tab-1:leaf-1'),
|
|
getTerminalHandleForPaneKey: vi.fn(() => 'term-prev'),
|
|
getAgentStatusRowsForPane: vi.fn(() => [{ state: 'done', agentType: 'claude', receivedAt: 1 }]),
|
|
ensureStructuredAgentSessionHost: vi.fn(),
|
|
openAgentSessionRecordStore: vi.fn(async () => records)
|
|
}
|
|
// oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: only the runtime boundaries above are reached; the ordinary launch is mocked separately.
|
|
return { runtime: runtime as unknown as OrcaRuntimeService, records }
|
|
}
|
|
beforeEach(() => {
|
|
vi.clearAllMocks()
|
|
mocks.actualHost = null
|
|
mocks.hostAvailable = true
|
|
mocks.launch.mockResolvedValue(terminal)
|
|
mocks.host.currentWork.mockReturnValue({ working: () => false })
|
|
mocks.host.send.mockResolvedValue({ ok: true })
|
|
})
|
|
describe('automations through agent.launch', () => {
|
|
it('chooses the newest compatible Chat despite busy work and stale nonfinal history', async () => {
|
|
const { runtime, records } = fixture()
|
|
mocks.host.currentWork.mockReturnValue({ working: () => true })
|
|
const previous = {
|
|
...run,
|
|
id: 'newest',
|
|
createdAt: run.createdAt + 10,
|
|
status: 'dispatched' as const,
|
|
workspaceId: 'stale-workspace',
|
|
sessionKind: 'chat' as const,
|
|
chatSessionId: 'claude_prev'
|
|
}
|
|
const result = await launchAutomationChatAgent(runtime, {
|
|
automation: { ...automation, surface: 'chat', reuseSession: true },
|
|
run,
|
|
target,
|
|
runs: [
|
|
{ ...previous, id: 'non-chat', createdAt: previous.createdAt + 1, sessionKind: 'terminal' },
|
|
{
|
|
...previous,
|
|
id: 'other-automation',
|
|
automationId: 'other',
|
|
createdAt: previous.createdAt + 2
|
|
},
|
|
{ ...previous, id: run.id, createdAt: previous.createdAt + 3 },
|
|
previous,
|
|
{ ...previous, id: 'duplicate', createdAt: run.createdAt },
|
|
{
|
|
...previous,
|
|
id: 'older-idle',
|
|
chatSessionId: 'claude_idle',
|
|
createdAt: run.createdAt - 1,
|
|
status: 'completed'
|
|
}
|
|
]
|
|
})
|
|
expect(result).toMatchObject({ chatSessionId: 'claude_prev', workspaceId: 'wt-1' })
|
|
expect(records.getConversation).toHaveBeenCalledExactlyOnceWith('claude_prev')
|
|
expect(mocks.host.send).toHaveBeenCalledExactlyOnceWith(
|
|
expect.anything(),
|
|
expect.objectContaining({
|
|
delivery: 'queue-if-active',
|
|
envelope: expect.objectContaining({
|
|
sessionId: 'claude_prev',
|
|
clientOperationId: automationRunOperationId(run, 'reuse-send'),
|
|
expectedRuntimeFence: 2
|
|
})
|
|
})
|
|
)
|
|
expect(mocks.host.currentWork).not.toHaveBeenCalled()
|
|
expect(mocks.host.journalSnapshot).not.toHaveBeenCalled()
|
|
expect(mocks.launch).not.toHaveBeenCalled()
|
|
})
|
|
it('skips genuinely missing/incompatible records and never needs a current work projection', async () => {
|
|
const { runtime, records } = fixture()
|
|
mocks.host.currentWork.mockReturnValue(null)
|
|
records.selectWritableRecord.mockImplementation((id) => ({
|
|
kind: id === 'missing' ? 'missing' : 'writable'
|
|
}))
|
|
records.getConversation.mockImplementation((id) => ({
|
|
sessionId: id,
|
|
provider: 'claude',
|
|
location: { workspaceId: id === 'moved' ? 'elsewhere' : 'wt-1' },
|
|
currentFence: 2
|
|
}))
|
|
const runs = ['missing', 'moved', 'claude_prev'].map((id, n) => ({
|
|
...run,
|
|
id,
|
|
createdAt: run.createdAt - n - 1,
|
|
status: 'dispatch_failed' as const,
|
|
sessionKind: 'chat' as const,
|
|
chatSessionId: id
|
|
}))
|
|
const request = {
|
|
automation: { ...automation, surface: 'chat' as const, reuseSession: true },
|
|
run,
|
|
target,
|
|
runs
|
|
}
|
|
expect((await launchAutomationChatAgent(runtime, request)).chatSessionId).toBe('claude_prev')
|
|
expect(mocks.launch).not.toHaveBeenCalled()
|
|
mocks.host.send.mockClear()
|
|
mocks.launch.mockResolvedValue(chat)
|
|
await launchAutomationChatAgent(runtime, { ...request, runs: runs.slice(0, 2) })
|
|
expect(mocks.host.send).not.toHaveBeenCalled()
|
|
expect(mocks.launch).toHaveBeenCalledOnce()
|
|
expect(mocks.launch.mock.calls[0][0].operationId).toBe(
|
|
automationRunOperationId(run, 'fresh-launch')
|
|
)
|
|
})
|
|
})
|
|
|
|
it.each(['terminal', 'chat'] as const)(
|
|
'preserves published %s identity for refused, uncertain and throwing settlement',
|
|
async (kind) => {
|
|
const { runtime, records } = fixture()
|
|
const paneKey = 'tab-1:11111111-1111-4111-8111-111111111111'
|
|
const published =
|
|
kind === 'chat'
|
|
? chat
|
|
: { ...terminal, outcome: { kind: 'terminal' as const, handle: 'term-1', paneKey } }
|
|
for (const outcome of ['not-delivered', 'unconfirmed', 'throw', 'accepted-throw'] as const) {
|
|
mocks.launch.mockImplementationOnce(async (_params, _context, policy) => {
|
|
policy.onSurfacePublished(published)
|
|
if (outcome === 'accepted-throw') {
|
|
records.getOperationRow.mockImplementation((_caller, id) =>
|
|
id === automationRunOperationId(run, 'fresh-launch')
|
|
? { outcome: { status: 'succeeded', launch: published } }
|
|
: undefined
|
|
)
|
|
throw new Error('accepted reply lost')
|
|
}
|
|
if (outcome === 'throw') {
|
|
throw new Error('settlement transport lost')
|
|
}
|
|
return { ...published, prompt: { delivery: 'submit', outcome } }
|
|
})
|
|
const result = await launchAutomationChatAgent(runtime, {
|
|
automation: {
|
|
...automation,
|
|
surface: 'chat'
|
|
},
|
|
run,
|
|
target,
|
|
runs: []
|
|
}).catch((error) => error)
|
|
expect(outcome === 'accepted-throw' ? { target: result } : result).toMatchObject({
|
|
target: {
|
|
workspaceId: 'wt-1',
|
|
sessionKind: kind === 'chat' ? 'chat' : 'terminal',
|
|
...(kind === 'chat'
|
|
? { chatSessionId: 'claude_chat', terminalPaneKey: null, terminalSessionId: null }
|
|
: {
|
|
terminalPaneKey: paneKey,
|
|
terminalSessionId: 'tab-1',
|
|
terminalPtyId: 'pty-1'
|
|
})
|
|
}
|
|
})
|
|
}
|
|
expect(mocks.launch).toHaveBeenCalledTimes(4)
|
|
expect(mocks.host.send).not.toHaveBeenCalled()
|
|
}
|
|
)
|
|
|
|
it.each(['normal', 'lost-reply', 'restart'] as const)(
|
|
'keeps busy Chat Q→S through %s, exact persisted output and normal Details',
|
|
(mode) =>
|
|
exerciseBusyChatReuse(mode, automation, target, {
|
|
setHost: (host) => {
|
|
mocks.actualHost = host
|
|
},
|
|
bindRenderer: (renderer) => {
|
|
mocks.renderer = renderer
|
|
},
|
|
launch: mocks.launch
|
|
})
|
|
)
|
|
|
|
it('retains a known identity when record/host preparation cannot prove availability', async () => {
|
|
for (const failure of [
|
|
'unreadable',
|
|
'null-view',
|
|
'read-failed',
|
|
'read-only-missing',
|
|
'host-absent',
|
|
'host-failed'
|
|
] as const) {
|
|
const { runtime, records } = fixture()
|
|
mocks.host.send.mockClear()
|
|
mocks.hostAvailable = failure !== 'host-absent'
|
|
if (failure === 'unreadable') {
|
|
records.selectWritableRecord.mockReturnValue({ kind: 'unreadable' })
|
|
}
|
|
if (failure === 'null-view') {
|
|
records.getConversation.mockReturnValue(null)
|
|
}
|
|
if (failure === 'read-failed') {
|
|
records.getConversation.mockImplementation(() => {
|
|
throw new Error('unreadable disk')
|
|
})
|
|
}
|
|
if (failure === 'read-only-missing') {
|
|
records.readOnly = true
|
|
records.selectWritableRecord.mockReturnValue({ kind: 'missing' })
|
|
}
|
|
if (failure === 'host-failed') {
|
|
vi.spyOn(runtime, 'ensureStructuredAgentSessionHost').mockRejectedValueOnce(
|
|
new Error('host failed')
|
|
)
|
|
}
|
|
await expect(
|
|
launchAutomationChatAgent(runtime, {
|
|
automation: { ...automation, surface: 'chat', reuseSession: true },
|
|
run,
|
|
target,
|
|
runs: [{ ...run, id: 'old', sessionKind: 'chat', chatSessionId: 'claude_prev' }]
|
|
})
|
|
).rejects.toMatchObject({ target: { sessionKind: 'chat', chatSessionId: 'claude_prev' } })
|
|
expect(mocks.host.send).not.toHaveBeenCalled()
|
|
expect(mocks.launch).not.toHaveBeenCalled()
|
|
}
|
|
})
|
|
|
|
it.each(['before-admission', 'accepted-reply', 'accepted-lost-reply'] as const)(
|
|
'permits fresh only for authoritative deletion %s',
|
|
async (when) => {
|
|
vi.spyOn(Date, 'now').mockReturnValue(HOST_TEST_NOW)
|
|
const current = { ...run, createdAt: HOST_TEST_NOW }
|
|
const rig = await createQueuedMessageTestRig({ restartable: true })
|
|
mocks.actualHost = rig.host
|
|
let removedRecord = rig.store.getRecord(HOST_TEST_SESSION)!
|
|
const removeRecord = () =>
|
|
rig.store['transact']((draft) => {
|
|
removedRecord = draft.records.get(HOST_TEST_SESSION)!
|
|
draft.records.delete(HOST_TEST_SESSION)
|
|
})
|
|
try {
|
|
const { runtime } = fixture()
|
|
vi.spyOn(runtime, 'openAgentSessionRecordStore').mockResolvedValue(rig.store)
|
|
const sent = rig.host.send.bind(rig.host)
|
|
const send = vi.spyOn(rig.host, 'send').mockImplementationOnce(async (...args) => {
|
|
if (when === 'before-admission') {
|
|
await removeRecord()
|
|
}
|
|
const reply = await sent(...args)
|
|
if (when === 'before-admission') {
|
|
expect(reply).toMatchObject({
|
|
ok: false,
|
|
refusal: {
|
|
code: 'agent_session_ownership_unknown',
|
|
details: { reason: 'sessionNotAttached' }
|
|
}
|
|
})
|
|
} else {
|
|
expect(reply.ok).toBe(true)
|
|
await removeRecord()
|
|
if (when === 'accepted-lost-reply') {
|
|
throw new Error('accepted reply lost after deletion')
|
|
}
|
|
}
|
|
return reply
|
|
})
|
|
mocks.launch.mockResolvedValue(chat)
|
|
const attempt = launchAutomationChatAgent(runtime, {
|
|
automation: {
|
|
...automation,
|
|
agentId: 'codex',
|
|
workspaceId: HOST_TEST_LOCATION.workspaceId,
|
|
surface: 'chat',
|
|
reuseSession: true
|
|
},
|
|
run: current,
|
|
target,
|
|
runs: [{ ...run, id: 'old', sessionKind: 'chat', chatSessionId: HOST_TEST_SESSION }]
|
|
})
|
|
if (when === 'accepted-lost-reply') {
|
|
await expect(attempt).rejects.toMatchObject({
|
|
target: { chatSessionId: HOST_TEST_SESSION }
|
|
})
|
|
} else {
|
|
expect((await attempt).chatSessionId).toBe(
|
|
when === 'before-admission' ? 'claude_chat' : HOST_TEST_SESSION
|
|
)
|
|
}
|
|
const q = automationRunOperationId(current, 'reuse-send')
|
|
expect(rig.store.readCommandReceipt({ kind: 'global' }, q).verdict).toBe('absent')
|
|
expect(readAutomationRunReceipt(rig.store, current)).toBeNull()
|
|
expect(
|
|
rig.store.getOperationRow(rpcCallerOperationKey(AUTOMATION_AGENT_CALLER), q)?.outcome.status
|
|
).toBe(when === 'before-admission' ? undefined : 'succeeded')
|
|
expect(send).toHaveBeenCalledOnce()
|
|
expect(mocks.launch).toHaveBeenCalledTimes(when === 'before-admission' ? 1 : 0)
|
|
if (when === 'before-admission') {
|
|
expect(mocks.launch.mock.calls[0][0].operationId).toBe(
|
|
automationRunOperationId(current, 'fresh-launch')
|
|
)
|
|
}
|
|
} finally {
|
|
mocks.actualHost = null
|
|
// Restore the injected deletion only after assertions so ordinary host teardown can run.
|
|
await rig.store['transact']((draft) => {
|
|
draft.records.set(HOST_TEST_SESSION, removedRecord)
|
|
})
|
|
await rig.dispose()
|
|
}
|
|
}
|
|
)
|
|
|
|
it.each(['unknown', 'refused', 'conflict', 'failed-row'] as const)(
|
|
'retains known reused Chat on %s acceptance without resending',
|
|
async (acceptance) => {
|
|
const { runtime, records } = fixture()
|
|
mocks.host.send.mockImplementationOnce(async () => {
|
|
if (acceptance === 'unknown') {
|
|
throw new Error('transport lost')
|
|
}
|
|
return {
|
|
ok: false,
|
|
refusal: {
|
|
code:
|
|
acceptance === 'conflict' ? 'agent_session_conflict' : 'agent_session_operation_unknown'
|
|
}
|
|
}
|
|
})
|
|
records.getOperationRow.mockReturnValue(
|
|
acceptance === 'failed-row' ? { outcome: { status: 'failed' } } : undefined
|
|
)
|
|
await expect(
|
|
launchAutomationChatAgent(runtime, {
|
|
automation: { ...automation, surface: 'chat', reuseSession: true },
|
|
run,
|
|
target,
|
|
runs: [
|
|
{
|
|
...run,
|
|
id: 'old',
|
|
status: 'completed',
|
|
workspaceId: 'wt-1',
|
|
sessionKind: 'chat',
|
|
chatSessionId: 'claude_prev'
|
|
}
|
|
]
|
|
})
|
|
).rejects.toMatchObject({ target: { sessionKind: 'chat', chatSessionId: 'claude_prev' } })
|
|
expect(mocks.host.send).toHaveBeenCalledOnce()
|
|
expect(mocks.launch).not.toHaveBeenCalled()
|
|
}
|
|
)
|
|
|
|
afterEach(() => vi.restoreAllMocks())
|