Files
archived-orca/tests/e2e/cross-version-wire/cross-version-worktree-ps-verdict.unit.test.ts
Neil 43fbfd93cf refactor(mobile): group worktree modules by defining owner (#42406)
* refactor(mobile): group worktree modules by defining owner

* refactor(mobile): use erased recording adapter type imports
2026-11-14 06:49:50 -08:00

220 lines
8.7 KiB
TypeScript

import { beforeAll, describe, expect, it } from 'vitest'
import {
importReleaseCheckoutModule,
importWorkingTreeModuleCopy,
materializeReleaseCheckout
} from './release-checkout'
// Pin pre-mainAgent readers: old phones must read new rows by interrupted; new phones must keep that fallback for old hosts.
const PRE_CHANGE_REF = 'v1.4.212'
const SUITE_TIMEOUT_MS = 180_000
// Both builds load a copy in the checkout cache, out of reach of `mobile/tsconfig.json`.
const PHONE_ROW_READER = 'mobile/src/worktree/agent-row-display.ts'
const WORKTREE_ID = 'repo::/worktree'
const NOW = 1_000_000
type HookSnapshot = Record<string, unknown>
type AgentRow = Record<string, unknown>
type DotState = (row: AgentRow, now: number) => string
type HostRowModules = {
collectRuntimeWorktreeAgentSources: (args: Record<string, unknown>) => unknown
attachRuntimeWorktreeAgentRows: (args: Record<string, unknown>) => void
}
type Build = {
label: string
host: HostRowModules
agentDotState: DotState
}
function snapshot(
tabId: string,
fields: Pick<HookSnapshot, 'state'> & Partial<HookSnapshot>
): HookSnapshot {
return {
paneKey: `${tabId}:11111111-1111-4111-8111-111111111111`,
tabId,
worktreeId: WORKTREE_ID,
connectionId: null,
prompt: 'ship it',
agentType: 'claude',
receivedAt: NOW - 1_000,
stateStartedAt: NOW - 600_000,
...fields
}
}
// Separate main-agent failure, failure with working children, and an explicit user stop.
const SNAPSHOTS: HookSnapshot[] = [
snapshot('failed-done', {
state: 'done',
mainAgent: { state: 'done', outcome: 'failure', stateStartedAt: NOW - 600_000 }
}),
snapshot('failed-working', {
state: 'working',
mainAgent: { state: 'done', outcome: 'failure', stateStartedAt: NOW - 120_000 }
}),
snapshot('stopped', {
state: 'done',
interrupted: true,
mainAgent: { state: 'done', outcome: 'cancellation', stateStartedAt: NOW - 600_000 }
}),
// Host-observed crash/unknown endings set no interrupted flag, so old readers still see done.
snapshot('crash-cut', {
state: 'done',
mainAgent: { state: 'done', outcome: 'interruption', stateStartedAt: NOW - 600_000 }
}),
snapshot('unproven', {
state: 'done',
mainAgent: { state: 'done', outcome: 'unconfirmed', stateStartedAt: NOW - 600_000 }
}),
// A turn a newer request replaced: recorded, not a user's stop, so it sets no flag either.
snapshot('replaced', {
state: 'done',
mainAgent: { state: 'done', outcome: 'superseded', stateStartedAt: NOW - 600_000 }
})
]
/** A host's `worktree ps` rows, JSON round-tripped as the wire carries them. */
function publishRows(host: HostRowModules): Record<string, AgentRow> {
const summary: Record<string, unknown> = {
worktreeId: WORKTREE_ID,
status: 'inactive',
hasHostSidebarActivity: false,
agents: []
}
const summaries = new Map([[WORKTREE_ID, summary]])
host.attachRuntimeWorktreeAgentRows({
summaries,
pathIndex: { byPath: new Map(), byRealPath: new Map() },
missingWorktreeIds: new Set(),
// Builds read workingTerminalEvidenceByWorktreeId, then terminalTitleEvidenceByWorktreeId, now terminalTitleEvidenceByRow.
workingTerminalEvidenceByWorktreeId: new Map(),
terminalTitleEvidenceByWorktreeId: new Map(),
terminalTitleEvidenceByRow: new Map(),
rowSources: host.collectRuntimeWorktreeAgentSources({
hookSnapshots: SNAPSHOTS,
mirroredWorktreeIdByTabId: new Map(),
connectedPtyEvidence: {
tabIds: new Set(SNAPSHOTS.map((row) => row.tabId)),
paneKeys: new Set(),
ptyIdByTerminalHandle: new Map()
}
}),
orchestrationByPaneKey: null,
// Old builds pass (summaries, pathIndex, missingIds, id), then (id), now (id, hostId).
getSummary: (...args: unknown[]) =>
summaries.get(String(args.find((arg) => arg === WORKTREE_ID))) ?? null
})
// oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: JSON.parse of the rows the host just attached, which are plain objects keyed by paneKey.
const rows = JSON.parse(JSON.stringify(summary.agents)) as AgentRow[]
return Object.fromEntries(rows.map((row) => [String(row.paneKey).split(':')[0], row]))
}
function dotStates(build: Build, rows: Record<string, AgentRow>): Record<string, string> {
return Object.fromEntries(
Object.entries(rows).map(([tabId, row]) => [tabId, build.agentDotState(row, NOW)])
)
}
async function loadBuild(ref: string | null): Promise<Build> {
if (ref === null) {
const [sources, rows, display] = await Promise.all([
import('../../../src/main/runtime/workspaces/process-listing/runtime-worktree-agent-sources'),
import('../../../src/main/runtime/workspaces/process-listing/runtime-worktree-agent-rows'),
importWorkingTreeModuleCopy('mobile/src/worktree/agent-lineage/agent-row-display.ts')
])
return {
label: 'current',
// oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: a dynamic import is typed by its module; this spec drives both builds through one untyped surface.
host: { ...sources, ...rows } as unknown as HostRowModules,
// oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: a dynamic import of a copy is typed unknown; this is the current phone's row reader by path.
agentDotState: display.agentDotState as unknown as DotState
}
}
const checkout = await materializeReleaseCheckout(ref)
const [sources, rows, display] = await Promise.all([
importReleaseCheckoutModule(
checkout,
'src/main/runtime/workspaces/process-listing/runtime-worktree-agent-sources.ts'
),
importReleaseCheckoutModule(
checkout,
'src/main/runtime/workspaces/process-listing/runtime-worktree-agent-rows.ts'
),
importReleaseCheckoutModule(checkout, PHONE_ROW_READER)
])
return {
label: ref,
// oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: a dynamic import is typed unknown; these two modules are the old host's row surface by path.
host: { ...sources, ...rows } as unknown as HostRowModules,
// oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: a dynamic import is typed unknown; this is the old phone's row reader by path.
agentDotState: display.agentDotState as unknown as DotState
}
}
let oldBuild: Build
let newBuild: Build
let agentRowTimeAt: (row: AgentRow) => number
beforeAll(async () => {
;[oldBuild, newBuild] = await Promise.all([loadBuild(PRE_CHANGE_REF), loadBuild(null)])
const display = await importWorkingTreeModuleCopy(
'mobile/src/worktree/agent-lineage/agent-row-display.ts'
)
// oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the rows are JSON the current host published, so the current reader's row type holds.
agentRowTimeAt = display.agentRowTimeAt as unknown as (row: AgentRow) => number
}, SUITE_TIMEOUT_MS)
describe('cross-version worktree ps verdict', () => {
it('an OLD phone reads a new host row by the interrupted flag it always read', () => {
const rows = publishRows(newBuild.host)
expect(rows.stopped).toMatchObject({ interrupted: true })
expect(dotStates(oldBuild, rows)).toEqual({
'failed-done': 'done',
'failed-working': 'working',
stopped: 'interrupted',
'crash-cut': 'done',
unproven: 'done',
replaced: 'done'
})
expect(rows['crash-cut']).toMatchObject({ interrupted: false })
expect(rows.unproven).toMatchObject({ interrupted: false })
expect(rows.replaced).toMatchObject({ interrupted: false })
})
it('a NEW phone reads an old host row, which has no mainAgent, by the same flag', () => {
const rows = publishRows(oldBuild.host)
expect(dotStates(newBuild, rows)).toEqual({
'failed-done': 'done',
'failed-working': 'working',
// Both phones draw a user's Stop interrupted; only the new one draws it muted.
stopped: 'interrupted',
'crash-cut': 'done',
unproven: 'done',
replaced: 'done'
})
// Without the main agent's clock the row dates itself, as it always did.
expect(agentRowTimeAt(rows['failed-working'])).toBe(NOW - 600_000)
})
it('a NEW phone reads a new host failure as failed, dated by the main agent clock', () => {
const rows = publishRows(newBuild.host)
expect(dotStates(newBuild, rows)).toEqual({
'failed-done': 'failed',
'failed-working': 'failed',
stopped: 'interrupted',
'crash-cut': 'failed',
unproven: 'unconfirmed',
replaced: 'interrupted'
})
expect(rows['failed-working']).toMatchObject({
state: 'working',
mainAgent: { state: 'done', outcome: 'failure', stateStartedAt: NOW - 120_000 }
})
expect(agentRowTimeAt(rows['failed-working'])).toBe(NOW - 120_000)
})
})