Orca is the place for working with a fleet of agents (e.g. Grok Bot, Claude Code). Run any coding agent with your own subscription. Available on desktop, mobile and remote runtime.
TypeScript adeagent-ideai-agentsautomationbotclaude-codecodexghosttygrok-bothermes-agentmobile-appmuseopenclawopencodeorchestrationpiruntimeterminalworktreesyc-backed
import { createElement } from 'react'
import { act, create, type ReactTestRenderer } from 'react-test-renderer'
import { afterEach, describe, expect, it, vi } from 'vitest'
import type { RpcClient } from '../transport/rpc-client'
import { FakeSession } from '../transport/mobile-endpoint-supervisor-test-fakes'
import { createStableLogicalRpcClient } from '../transport/stable-logical-rpc-client'
import { useNewWorktreeRuntimeCapabilities } from './worktree-create-capability'
import { createWorkspaceFromComposerSource } from './source-workspace-create'
function connection() {
let generation = 1
const client = new FakeSession('connected')
client.getLastConnectedAt = () => generation
client.sendRequest.mockResolvedValue({
id: 'status',
ok: true,
result: {
capabilities: ['mobile.tasks.v1', 'worktree.create-idempotency.v1'],
hostPlatform: 'linux'
},
_meta: { runtimeId: 'test' }
})
return {
client,
sendRequest: client.sendRequest,
reconnect() {
generation += 1
client.publishState('connected')
}
}
}
describe('capability probe recovery', () => {
let renderer: ReactTestRenderer | undefined
let current: ReturnType<typeof useNewWorktreeRuntimeCapabilities> | undefined
function Harness({ client, enabled }: { client: RpcClient; enabled: boolean }) {
current = useNewWorktreeRuntimeCapabilities(client, enabled)
return null
}
async function render(client: RpcClient, enabled = true) {
await act(async () => {
const element = createElement(Harness, { client, enabled })
if (renderer) {
renderer.update(element)
} else {
renderer = create(element)
}
})
}
afterEach(() => {
act(() => renderer?.unmount())
renderer = undefined
vi.useRealTimers()
})
it('retries a transient failure when the create sheet reopens on the same client', async () => {
const host = connection()
host.sendRequest.mockRejectedValueOnce(new Error('offline'))
await render(host.client)
expect(current?.tasksSupported).toBe(false)
await render(host.client, false)
await render(host.client)
expect(current?.tasksSupported).toBe(true)
await expect(current?.getWorktreeCreateCutoverSupport()).resolves.toBeTruthy()
})
it('recovers Tasks without requiring a sheet reopen', async () => {
vi.useFakeTimers()
const host = connection()
host.sendRequest.mockRejectedValueOnce(new Error('timeout'))
await render(host.client)
await act(async () => {
await vi.advanceTimersByTimeAsync(1_000)
})
expect(current?.tasksSupported).toBe(true)
})
it('does not publish a retired client probe after switching to a disabled host', async () => {
const first = connection()
const second = connection()
let resolve: ((value: Awaited<ReturnType<typeof first.sendRequest>>) => void) | undefined
first.sendRequest.mockImplementationOnce(
() =>
new Promise((done) => {
resolve = done
})
)
await render(first.client)
await render(second.client, false)
await act(async () =>
resolve?.({
id: 'late',
ok: true,
result: { capabilities: ['mobile.tasks.v1'] },
_meta: { runtimeId: 'retired' }
})
)
expect(current?.tasksSupported).toBe(false)
expect(current?.hostPlatform).toBeNull()
expect(second.sendRequest).not.toHaveBeenCalled()
})
it('reprobes after reconnect while keeping confirmed old hosts conservative', async () => {
const host = connection()
host.sendRequest.mockResolvedValueOnce({
id: 'status',
ok: true,
result: { capabilities: [] },
_meta: { runtimeId: 'old' }
})
await render(host.client)
await expect(current?.getWorktreeCreateCutoverSupport()).resolves.toBe(false)
expect(host.sendRequest).toHaveBeenCalledTimes(1)
await act(async () => host.reconnect())
expect(current?.tasksSupported).toBe(true)
expect(host.sendRequest).toHaveBeenCalledTimes(2)
})
it('keeps a pending create probe when the same host switches from LAN to relay', async () => {
const lan = new FakeSession('connected')
lan.getLastConnectedAt = () => 1
let dropLan: ((reason: Error) => void) | undefined
lan.sendRequest.mockImplementation(
() =>
new Promise((_resolve, reject) => {
dropLan = reject
})
)
const relay = connection()
relay.sendRequest.mockResolvedValue({
id: 'relay',
ok: true,
result: { capabilities: ['agent.launch.v2', 'worktree.create-idempotency.v1'] },
_meta: { runtimeId: 'test' }
})
const logical = createStableLogicalRpcClient(lan, 'lan')
await render(logical)
const launch = current?.getAgentLaunchSupport()
const branchIntent = current?.getBranchIntentSupport('open-existing-v2')
const idempotency = current?.getWorktreeCreateCutoverSupport()
await act(async () => {
await logical.migrateTo(relay.client, 'relay')
dropLan?.(new Error('socket closed'))
})
await expect(launch).resolves.toEqual({ replay: false })
await expect(branchIntent).resolves.toBe(false)
await expect(idempotency).resolves.toBeTruthy()
})
it.each(['before', 'after'])(
'ignores a prior connection reply resolved %s the current reply',
async (order) => {
const host = connection()
let resolveOld: ((value: Awaited<ReturnType<typeof host.sendRequest>>) => void) | undefined
let resolveNew: ((value: Awaited<ReturnType<typeof host.sendRequest>>) => void) | undefined
host.sendRequest.mockImplementationOnce(
() =>
new Promise((resolve) => {
resolveOld = resolve
})
)
host.sendRequest.mockImplementationOnce(
() =>
new Promise((resolve) => {
resolveNew = resolve
})
)
await render(host.client)
await act(async () => host.reconnect())
const oldReply: Awaited<ReturnType<typeof host.sendRequest>> = {
id: 'old',
ok: true,
result: {
capabilities: [
'mobile.tasks.v1',
'worktree.create-idempotency.v1',
'worktree.open-existing-branch.v2'
]
},
_meta: { runtimeId: 'old' }
}
const newReply: Awaited<ReturnType<typeof host.sendRequest>> = {
id: 'new',
ok: true,
result: { capabilities: [] },
_meta: { runtimeId: 'new' }
}
await act(async () => {
if (order === 'before') {
resolveOld?.(oldReply)
}
resolveNew?.(newReply)
})
expect(current?.tasksSupported).toBe(false)
if (order === 'after') {
await act(async () => resolveOld?.(oldReply))
}
expect(current?.tasksSupported).toBe(false)
await expect(current?.getWorktreeCreateCutoverSupport()).resolves.toBe(false)
await expect(current?.getBranchIntentSupport('open-existing-v2')).resolves.toBe(false)
expect(host.sendRequest).toHaveBeenCalledTimes(2)
}
)
it('shares one pending status barrier with branch creation without a second status request', async () => {
const host = connection()
let resolve: ((value: Awaited<ReturnType<typeof host.sendRequest>>) => void) | undefined
host.sendRequest.mockImplementationOnce(
() =>
new Promise((done) => {
resolve = done
})
)
await render(host.client)
const first = current?.getWorktreeCreateCutoverSupport()
const second = current?.getWorktreeCreateCutoverSupport()
const launch = current?.getAgentLaunchSupport()
const branchIntent = current?.getBranchIntentSupport('open-existing-v2')
host.sendRequest.mockResolvedValue({
id: 'created',
ok: true,
result: { worktree: { id: 'new-branch-workspace' } },
_meta: { runtimeId: 'test' }
})
const creation = createWorkspaceFromComposerSource({
client: host.client,
selection: {
kind: 'branch',
refName: 'refs/remotes/origin/topic',
baseBranch: 'origin/topic',
localBranchName: 'topic',
reuse: true
},
targetRepoId: 'repo',
workspaceName: undefined,
note: undefined,
agent: { choice: 'blank' },
setupDecision: 'skip',
worktreeCreateIdempotency: current!.getWorktreeCreateCutoverSupport(),
agentLaunchSupported: current!.getAgentLaunchSupport(),
branchIntentSupported: current!.getBranchIntentSupport('open-existing-v2')
})
expect(host.sendRequest).toHaveBeenCalledTimes(1)
await act(async () =>
resolve?.({
id: 'shared',
ok: true,
result: {
capabilities: [
'mobile.tasks.v1',
'worktree.create-idempotency.v1',
'worktree.open-existing-branch.v2-request.v1'
]
},
_meta: { runtimeId: 'test' }
})
)
await expect(first).resolves.toBeTruthy()
await expect(second).resolves.toBeTruthy()
await expect(launch).resolves.toBe(false)
await expect(branchIntent).resolves.toBe(true)
await expect(creation).resolves.toMatchObject({ worktreeId: 'new-branch-workspace' })
expect(host.sendRequest.mock.calls.map(([method]) => method)).toEqual([
'status.get',
'worktree.create'
])
expect(host.sendRequest).toHaveBeenLastCalledWith(
'worktree.create',
expect.objectContaining({ branchIntent: 'open-existing-v2' }),
expect.anything()
)
expect(current?.tasksSupported).toBe(true)
})
it('retains create-new support on an older V2 host without granting V2 reuse', async () => {
const host = connection()
host.sendRequest.mockResolvedValue({
id: 'status',
ok: true,
result: { capabilities: ['worktree.open-existing-branch.v2'] },
_meta: { runtimeId: 'test' }
})
await render(host.client)
await expect(current?.getBranchIntentSupport('create-new')).resolves.toBe(true)
await expect(current?.getBranchIntentSupport('open-existing-v2')).resolves.toBe(false)
expect(host.sendRequest).toHaveBeenCalledTimes(1)
})
it('cancels backoff while disabled and cannot rearm after unmount', async () => {
vi.useFakeTimers()
const host = connection()
host.sendRequest.mockRejectedValue(new Error('offline'))
await render(host.client)
await render(host.client, false)
await act(async () => {
await vi.advanceTimersByTimeAsync(60_000)
})
expect(host.sendRequest).toHaveBeenCalledTimes(1)
await render(host.client)
expect(host.sendRequest).toHaveBeenCalledTimes(2)
act(() => renderer?.unmount())
renderer = undefined
await act(async () => {
await vi.advanceTimersByTimeAsync(60_000)
})
expect(host.sendRequest).toHaveBeenCalledTimes(2)
})
it.each([true, false])(
'hides prior capabilities after reconnect with the sheet initially enabled=%s',
async (enabled) => {
const host = connection()
await render(host.client)
expect(current?.tasksSupported).toBe(true)
expect(current?.hostPlatform).toBe('linux')
await render(host.client, enabled)
let reject: ((reason: Error) => void) | undefined
host.sendRequest.mockImplementationOnce(
() =>
new Promise((_resolve, fail) => {
reject = fail
})
)
await act(async () => host.reconnect())
await render(host.client)
expect(current?.tasksSupported).toBe(false)
expect(current?.hostPlatform).toBeNull()
await act(async () => reject?.(new Error('replacement offline')))
expect(current?.tasksSupported).toBe(false)
}
)
it('bounds failed probes over ten minutes and stops all retries on close', async () => {
vi.useFakeTimers()
const host = connection()
host.sendRequest.mockRejectedValue(new Error('offline'))
await render(host.client)
await act(async () => {
await vi.advanceTimersByTimeAsync(600_000)
})
expect(host.sendRequest).toHaveBeenCalledTimes(24)
expect(vi.getTimerCount()).toBe(1)
await render(host.client, false)
expect(vi.getTimerCount()).toBe(0)
await act(async () => {
await vi.advanceTimersByTimeAsync(600_000)
})
expect(host.sendRequest).toHaveBeenCalledTimes(24)
})
it('does not poll a confirmed unsupported host across renders or sheet reopens', async () => {
vi.useFakeTimers()
const host = connection()
host.sendRequest.mockResolvedValue({
id: 'old',
ok: true,
result: { capabilities: [] },
_meta: { runtimeId: 'old' }
})
await render(host.client)
for (let reopen = 0; reopen < 20; reopen += 1) {
await render(host.client, false)
await render(host.client)
}
await act(async () => {
await vi.advanceTimersByTimeAsync(600_000)
})
expect(host.sendRequest).toHaveBeenCalledTimes(1)
expect(vi.getTimerCount()).toBe(0)
})
it.each(['old-first', 'new-first'])(
'leaves no retry or RPC after overlapping reconnect failures settle %s and unmount',
async (order) => {
vi.useFakeTimers()
const host = connection()
let failOld: ((reason: Error) => void) | undefined
let failNew: ((reason: Error) => void) | undefined
host.sendRequest.mockImplementationOnce(
() =>
new Promise((_resolve, reject) => {
failOld = reject
})
)
host.sendRequest.mockImplementationOnce(
() =>
new Promise((_resolve, reject) => {
failNew = reject
})
)
await render(host.client)
await act(async () => host.reconnect())
await act(async () => {
if (order === 'old-first') {
failOld?.(new Error('old offline'))
}
failNew?.(new Error('new offline'))
})
if (order === 'new-first') {
await act(async () => failOld?.(new Error('old offline')))
}
expect(vi.getTimerCount()).toBe(1)
act(() => renderer?.unmount())
renderer = undefined
expect(vi.getTimerCount()).toBe(0)
await act(async () => {
await vi.advanceTimersByTimeAsync(60_000)
})
expect(host.sendRequest).toHaveBeenCalledTimes(2)
host.reconnect()
expect(host.sendRequest).toHaveBeenCalledTimes(2)
}
)
})