mirror of
https://github.com/stablyai/orca.git
synced 2026-11-16 19:07:41 +00:00
* chore(lint): remove disable directives that suppress nothing
Each was reported unused by the oxlint config that owns its rule (root,
casting, react-doctor, anti-slop, native-plugins), including 17 file-level
react-doctor blanket disables whose rule no longer fires. An unused
react-hooks disable was masking a react/purity finding in
useAgentBucketCounts (compiler rules skip functions with hook
suppressions); suppress that one explicitly where the code explains it.
* test(tab-bar): use typed tab/file fixtures instead of @ts-expect-error partials
* chore(lint): fix misc suppressed lint violations instead of disabling
- consistent-type-imports: the "vi.importActual requires inline import()"
rationale was wrong; use typed vi.mock(import(...), importOriginal) or a
type-only namespace import.
- no-control-regex: source-control commit/push failure summaries, shell PATH
hydration, and ipynb ANSI parsing reuse the shared ansi-escape-sequences
stripper and control-character pattern instead of private copies.
- no-explicit-any / no-useless-spread / no-this-alias: typed `this` in
bridge test mocks, drop blanket file-level disables, drop a this-alias.
* refactor(main): replace avoidable type assertions with checked narrowing
17 production cast suppressions in main/wsl-guest removed: untrusted IPC
and RPC payloads (Jira issue update, WSL guest plugin install, handshake
type) now narrow through isRecord/type guards and build typed results;
redundant casts dropped; hand-rolled object checks and errno casts use the
existing isRecord / hasErrorCode helpers.
* refactor(renderer,mobile): replace avoidable type assertions with checked types
13 production cast suppressions removed: RPC failures read through the
`ok` discriminant instead of casting to RpcFailure; react-native-web host
refs narrowed with instanceof HTMLElement; redundant reply/diff casts
become checked annotations; the TUI agent param uses z.custom(isTuiAgent)
like its sibling schemas; the agent-status slice cast that hid missing
actions is gone so the creator's return type checks the whole slice.
* chore(lint): drop dead tiptap wrapper; scope anti-slop mocking rule to test support
- safe-react-node-view-renderer patched handleSelectionUpdate, which
@tiptap/react 3.31.3 no longer has, so it always returned early. Use the
stock ReactNodeViewRenderer.
- The anti-slop test override only matched *.test.{ts,tsx}, forcing
file-level no-module-mocking disables in test harnesses and fixtures.
Match *-test-harness, *-test-fixture(s), .test-fixture and *.test.mjs,
then drop those disables and the now-redundant per-file exemptions.
* test: replace repeated cast suppressions with typed fixtures (main/shared/e2e)
Net -119 cast directives. Typed fixtures replace recurring casts:
unusedSshConnection/unusedOrcadHostTransport placeholders, a typed
readPersistedState harness read (exposed a test treating optional
httpProxyUrl as always set), real Response objects in fetch spies, an
updater main-window fixture, a CDP webContents adapter, one shared
releaseModuleExport for cross-version tests, and requireOverlayDir in
place of `as string` on possibly-undefined overlay paths.
* fix(runtime): validate loaded device rows and host scope instead of casting
Two cast suppressions claimed checks that did not happen:
- device-registry-file-read: "normalizeLoadedDeviceRow re-validates every
field" was false; deviceId, token, name and timestamps were never
checked. Rows without an identity are now dropped and the file is set
aside through the existing corrupt-file path (registry reads as
doubtful, so no revocation verdicts); a non-string token is stripped
so the row stays listed but cannot authenticate.
- client-ui: "only optionality differs" was false; any string reached
persisted workspaceHostScope. Narrow it with isWorkspaceHostScope and
ignore unknown scopes (wire schema unchanged for mixed versions). The
remaining cast now states what it actually covers.
* test(runtime,ipc): drop redundant cast suppressions; typed runtime store fixture
-98 cast directives across runtime/ipc tests: 61 casts that typecheck
without the assertion; a typed vi.fn for scoped invalidation; a
partialRuntimeStore fixture in place of `store as never` for
OrcaRuntimeService; typed worker terminal/authority builders in the
incarnation-fallback suite (the old stub lacked runtimeId, ptyId,
worktreeId and launchTokenHash) plus removal of stacked duplicate
directives there.
* chore(lint): typed vi.mock imports and explicit listener snapshot in shared-bucket tests
Remaining files from the misc-rule pass that overlapped other buckets:
codex-accounts mocks use the typed vi.mock(import(...)) form instead of
a consistent-type-imports disable; the daemon late-exit fixture copies
its listener set with Array.from instead of a no-useless-spread disable.
* refactor(github,mobile): narrow routing settings type; drop remaining avoidable casts
- work-item-routing cast a one-field object to AppState['settings'] under
a claim that readers only consume activeRuntimeEnvironmentId. Return the
existing RuntimeFocusSettings pick instead and narrow the cache-key
chain's parameters, so the compiler enforces that claim.
- mobile file preview reads refusals through the RpcResponse `ok`
discriminant rather than a cast.
- terminal document host-notify accepts `unknown` errors, removing the
message-bridge cast.
- native chat readability drops a redundant repo-list cast.
* test(renderer): replace repeated cast suppressions with typed fixtures
-140 cast directives (and ~150 unsuppressed casts of the same shapes):
- mockPanePtyArgs owns the connectPanePty fixture casts, so a wrong
argument order or fixture is now a type error; drop binding casts for
members PanePtyBinding already declares.
- Seed AppState tab rows with the typed makeTerminalTab; this exposed a
split direction 'row' that is not a TerminalPaneSplitDirection.
- Partial GlobalSettings use getDefaultSettings overrides; Jira-only
stores use createTestStore; runtime environment rows/statuses come from
a typed paired-runtime-environment fixture.
* chore(lint): drop no-module-mocking disable now covered by the test-fixture glob
* test(e2e): fix all 221 grandfathered e2e type errors; baseline to zero
The e2e typecheck baseline grandfathered 221 errors in 119 files. About a
third were tests drifted from the current API, several of which would
fail or mislead at runtime:
- terminal-shortcuts called a nonexistent xterm buffer method;
- the daemon-lifecycle fake lacked terminateOwnedTree, hidden by importing
its type from a module that does not export it;
- arguments in the wrong position (listProcesses(hostId, opts), a dropped
pty.write inputKind, an extra toWebTerminalSurfaceTabId argument);
- removed enum values ('drawer', 'idle', 'editor',
'session-insecure-origin') and a launch_source the telemetry schema
rejects;
- missing required fields (turnScope, childWorkOpen, providerIdentity,
reviewLookupOutcome, runtimeServiceAccount behind an `as RelayConfig`);
- dead reads (tab.customTitle, bucket.targets, changedPixels).
Also lifts variables that narrowed to `never` after poll-callback
assignment, and adds a typed xterm render-dimensions accessor. Includes
the cross-version suites' shared releaseModuleExport adoption.
* chore(typecheck): gate the now-clean e2e typecheck in local lint
The e2e baseline is empty, so the ratchet now rejects any tests/ type
error. CI already runs it via run-ratchets; add it to pnpm lint's
explicit ratchet list and replace the stale 'not yet clean' note.
* test(mobile): typecheck every mobile test; baseline 105 files -> 0
mobile/tests-typecheck-baseline.txt grandfathered 105 test files (531
errors) whose types CI never checked. Contract changes had landed without
these tests following, and type pins in them silently checked nothing.
- Root cause: salvagedOptional (src/shared/zod-salvage.ts) cast away
zod's optional marker, so every reply type built on it claimed
salvaged fields were always present. Return a real ZodOptional;
runtime is unchanged (the outer optional short-circuits undefined).
- Production now takes the port it uses: RpcOperationSender instead of
RpcClient for send-only callers, a narrow fetch signature, and only the
request fields push-receive reads.
- findAllByHostType/findByHostType replace `'Text' as never` lookups;
stubRpcClient gives tests a typed RpcClient.
- Real test bugs: settings-host-client-lifecycle "relay" hosts were
direct hosts (relayHostId no longer exists); two toEqualTypeOf pins
could never hold; a recovery hook ran with an undefined scope key;
a create-PR test cast to a never-imported type; "no URL" assertions
passed on null; plus stale required props, args and enum values.
* test(e2e): parse workerStart result instead of casting it
* test(runtime): typed partial runtime stores with production-shaped fixture data
Route every partial store passed to OrcaRuntimeService through
partialRuntimeStore with typed row builders, removing 60 cast directives
that hid fixture data production never produces:
- paired-client-navigation-test-harness keyed setWorktreeMeta writes by
`[object Object]` (it took an id where the store takes a target), so
reads never saw them;
- invalid worktree lineage origin/capture and incomplete workspace lineage;
- getWorkspaceSession returning null where the store returns the default
session; getGitHubCache returning undefined;
- orcad migration states missing migrationId/manifest/receipt, with a
toEqual pinned to that incomplete shape;
- partial repos, metadata, folders, project groups and notification rows.
* refactor(renderer): resolve suppressed React hook lint instead of disabling it
109 of 187 react-hooks/react-doctor suppressions fixed:
- ~95 exhaustive-deps disables only hid stable refs and setters passed
through controller objects; list them (identity never changes, so
nothing re-runs), plus a few real stale closures (tabId/worktreeId).
- Effects keyed on one value that read the latest props now use
useEffectEvent (WebConnect, skill freshness, Bitbucket dialog seeding,
Landing preflight, automation catalog, structured-session recovery,
file explorer).
- The conditional layout-owner hook is selected once at module load from
the build constant instead of a rules-of-hooks disable that also hid
the whole controller from compiler and react-doctor rules.
- A hook disable was masking a react/purity Date.now() in the palette's
recent-tabs memo; sample it when the snapshot is captured.
- Three identical debounced-search effects share
useTaskSearchDebouncedApply; layout snapshot merge helpers move out to
stay under max-lines.
Remaining suppressions are mount-once resources, invalidation epochs,
deliberately keyed fields, and test harnesses that mock the dispatcher.
* chore(ratchet): exempt test harnesses and fixtures from the focus-read ratchet
The ratchet skipped *.test-fixture.ts but scanned *-test-harness,
*-test-fixture(s) and *.test-support files. Those seed settings with
getDefaultSettings (which the ratchet discovers as a focus reader) and
never route host work, so 17 baseline entries were false positives, and
replacing a test's `settings: {...} as never` with typed defaults tripped
it. Match the repo's test-support names and prune (which also drops one
stale entry), and rename the frame-ordering harness to *-test-harness like
its siblings. A blanket "-harness" match would also exempt
e2e-terminal-pty-harness, which production imports, so the names stay
explicit.
* test: merge duplicate shared/constants imports
* revert(file-explorer): restore original tree load effects pending SSH e2e investigation
* test(runtime): drop RuntimeStore cast now that the fixture is typed
---------
Co-authored-by: OrcaWin <293788423+OrcaWin@users.noreply.github.com>
269 lines
9.7 KiB
TypeScript
269 lines
9.7 KiB
TypeScript
import { chmodSync, existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
|
|
import os from 'node:os'
|
|
import path from 'node:path'
|
|
import { test as base, expect } from './helpers/orca-app'
|
|
import {
|
|
buildFakeAgentCommandOverride,
|
|
FAKE_AGENT_WINDOWS_SHELL
|
|
} from './helpers/fake-agent-command-override'
|
|
import {
|
|
ensureTerminalVisible,
|
|
getActiveTabId,
|
|
switchToOtherWorktree,
|
|
switchToWorktree,
|
|
waitForActiveWorktree,
|
|
waitForSessionReady
|
|
} from './helpers/store'
|
|
import { waitForActivePaneHookDescriptor, waitForActivePanePtyId } from './helpers/terminal'
|
|
import { RuntimeClient } from '../../src/cli/runtime-client'
|
|
import type { RuntimeTerminalListResult, RuntimeTerminalRead } from '../../src/shared/runtime-types'
|
|
import { FAKE_CODEX_LAUNCH_PROBES_SOURCE } from './helpers/fake-codex-launch-probes'
|
|
|
|
const fakeCliDir = mkdtempSync(path.join(os.tmpdir(), 'orca-e2e-orchestration-worker-'))
|
|
const spawnLedgerPath = path.join(fakeCliDir, 'spawn.jsonl')
|
|
const interruptionLedgerPath = path.join(fakeCliDir, 'interruption.jsonl')
|
|
const fakeCodexPath = path.join(fakeCliDir, process.platform === 'win32' ? 'codex.cmd' : 'codex')
|
|
const fakeCodexCommand = buildFakeAgentCommandOverride(fakeCodexPath)
|
|
const fakeCodexSource = `
|
|
const { appendFileSync } = require('node:fs')
|
|
function appendLedger(envName, event) {
|
|
const ledgerPath = process.env[envName]
|
|
if (!ledgerPath) return
|
|
try {
|
|
appendFileSync(ledgerPath, JSON.stringify({ pid: process.pid, at: Date.now(), ...event }) + '\\n')
|
|
} catch {}
|
|
}
|
|
${FAKE_CODEX_LAUNCH_PROBES_SOURCE}
|
|
appendLedger('ORCA_E2E_SPAWN_LEDGER', { event: 'spawn', startedAt: Date.now() })
|
|
process.stdout.write('\\u001b]0;Codex Ready\\u0007OpenAI Codex\\nmodel: e2e\\ndirectory: e2e\\n')
|
|
let acknowledged = false
|
|
process.stdin.on('data', (chunk) => {
|
|
const input = chunk.toString()
|
|
if (input.includes('\\x03')) {
|
|
appendLedger('ORCA_E2E_INTERRUPTION_LEDGER', { event: 'stdin-ctrl-c' })
|
|
}
|
|
if (!acknowledged && input.includes('\\r')) {
|
|
acknowledged = true
|
|
process.stdout.write('ACK\\n')
|
|
}
|
|
})
|
|
for (const signal of ['SIGINT', 'SIGHUP', 'SIGTERM']) {
|
|
process.on(signal, () => {
|
|
appendLedger('ORCA_E2E_INTERRUPTION_LEDGER', { event: 'signal', signal })
|
|
process.exit(0)
|
|
})
|
|
}
|
|
process.stdin.resume()
|
|
setInterval(() => {}, 60_000)
|
|
`
|
|
|
|
if (process.platform === 'win32') {
|
|
writeFileSync(path.join(fakeCliDir, 'fake-codex.js'), fakeCodexSource)
|
|
writeFileSync(
|
|
path.join(fakeCliDir, 'codex.cmd'),
|
|
'@echo off\r\nnode "%~dp0\\fake-codex.js" %*\r\n'
|
|
)
|
|
} else {
|
|
const executable = path.join(fakeCliDir, 'codex')
|
|
writeFileSync(executable, `#!/usr/bin/env node\n${fakeCodexSource}`)
|
|
chmodSync(executable, 0o755)
|
|
}
|
|
|
|
const test = base.extend({
|
|
launchEnv: {
|
|
PATH: `${fakeCliDir}${path.delimiter}${process.env.PATH ?? ''}`,
|
|
ORCA_E2E_SPAWN_LEDGER: spawnLedgerPath,
|
|
ORCA_E2E_INTERRUPTION_LEDGER: interruptionLedgerPath
|
|
}
|
|
})
|
|
|
|
test.afterAll(() => {
|
|
rmSync(fakeCliDir, { recursive: true, force: true })
|
|
})
|
|
|
|
type LedgerEvent = {
|
|
pid: number
|
|
event: string
|
|
startedAt?: number
|
|
signal?: string
|
|
}
|
|
|
|
function readLedger(ledgerPath: string): LedgerEvent[] {
|
|
if (!existsSync(ledgerPath)) {
|
|
return []
|
|
}
|
|
return readFileSync(ledgerPath, 'utf8')
|
|
.split(/\r?\n/)
|
|
.filter(Boolean)
|
|
.map((line) => JSON.parse(line) as LedgerEvent)
|
|
}
|
|
|
|
function isProcessAlive(pid: number): boolean {
|
|
try {
|
|
process.kill(pid, 0)
|
|
return true
|
|
} catch {
|
|
return false
|
|
}
|
|
}
|
|
|
|
test('worker-start preserves one live inactive worker across workspace re-entry', async ({
|
|
orcaPage,
|
|
electronApp
|
|
}) => {
|
|
await waitForSessionReady(orcaPage)
|
|
await orcaPage.evaluate(
|
|
async ({ agentCommand, terminalWindowsShell }) => {
|
|
await window.__store?.getState().updateSettings({
|
|
agentCmdOverrides: { codex: agentCommand },
|
|
terminalWindowsShell
|
|
})
|
|
},
|
|
{ agentCommand: fakeCodexCommand, terminalWindowsShell: FAKE_AGENT_WINDOWS_SHELL }
|
|
)
|
|
const worktreeId = await waitForActiveWorktree(orcaPage)
|
|
await ensureTerminalVisible(orcaPage)
|
|
const coordinatorTabId = await getActiveTabId(orcaPage)
|
|
expect(coordinatorTabId).toBeTruthy()
|
|
await waitForActivePanePtyId(orcaPage)
|
|
const coordinatorPane = await waitForActivePaneHookDescriptor(orcaPage)
|
|
const userDataDir = await electronApp.evaluate(({ app }) => app.getPath('userData'))
|
|
const client = new RuntimeClient(userDataDir, 30_000, null, null)
|
|
const coordinator = await client.call<{ terminal: { handle: string } }>('terminal.resolvePane', {
|
|
paneKey: coordinatorPane.paneKey
|
|
})
|
|
const run = await client.call<{ run: { id: string } }>('orchestration.runCreate', {
|
|
objective: 'Verify worker terminal visibility',
|
|
from: coordinator.result.terminal.handle
|
|
})
|
|
const task = await client.call<{ task: { id: string } }>('orchestration.taskCreate', {
|
|
spec: 'Respond ACK and remain idle',
|
|
run: run.result.run.id,
|
|
callerTerminalHandle: coordinator.result.terminal.handle
|
|
})
|
|
const coordinatorTerminal = await client.call<{ terminal: { worktreeId: string } }>(
|
|
'terminal.show',
|
|
{ terminal: coordinator.result.terminal.handle }
|
|
)
|
|
await expect
|
|
.poll(async () => {
|
|
const listed = await client.call<{ worktrees: { id: string }[] }>('worktree.list', {})
|
|
return listed.result.worktrees.some(
|
|
(worktree) => worktree.id === coordinatorTerminal.result.terminal.worktreeId
|
|
)
|
|
})
|
|
.toBe(true)
|
|
|
|
const started = await client.call<{
|
|
effects: { kind: string; role?: string; id?: string }[]
|
|
}>('orchestration.workerStart', {
|
|
task: task.result.task.id,
|
|
from: coordinator.result.terminal.handle,
|
|
agent: 'codex',
|
|
timeoutMs: 15_000
|
|
})
|
|
const workerHandle = started.result.effects.find(
|
|
(effect) => effect.kind === 'terminal' && effect.role === 'agent'
|
|
)?.id
|
|
expect(workerHandle).toBeTruthy()
|
|
const workerTabTitle = `worker-${task.result.task.id}`
|
|
|
|
const terminals = await client.call<RuntimeTerminalListResult>('terminal.list')
|
|
const workerTerminal = terminals.result.terminals.find(
|
|
(terminal) => terminal.handle === workerHandle
|
|
)
|
|
expect(workerTerminal?.tabId).toBeTruthy()
|
|
expect(workerTerminal?.leafId).toBeTruthy()
|
|
await expect
|
|
.poll(async () => {
|
|
const read = await client.call<{ terminal: RuntimeTerminalRead }>('terminal.read', {
|
|
terminal: workerTerminal!.handle,
|
|
limit: 200
|
|
})
|
|
return read.result.terminal.tail.join('\n')
|
|
})
|
|
.toContain('ACK')
|
|
const initialWorkerIdentity = {
|
|
ptyId: workerTerminal!.ptyId,
|
|
incarnationId: workerTerminal!.incarnationId,
|
|
worktreeId: workerTerminal!.worktreeId,
|
|
tabId: workerTerminal!.tabId,
|
|
leafId: workerTerminal!.leafId
|
|
}
|
|
const initialDispatch = await client.call<{
|
|
dispatch: { id: string; task_id: string; assignee_handle: string } | null
|
|
}>('orchestration.dispatchShow', { task: task.result.task.id })
|
|
expect(initialDispatch.result.dispatch).toEqual(
|
|
expect.objectContaining({
|
|
task_id: task.result.task.id,
|
|
assignee_handle: workerHandle
|
|
})
|
|
)
|
|
await expect.poll(() => readLedger(spawnLedgerPath)).toHaveLength(1)
|
|
const [spawn] = readLedger(spawnLedgerPath)
|
|
expect(spawn).toEqual(
|
|
expect.objectContaining({
|
|
event: 'spawn',
|
|
pid: expect.any(Number),
|
|
startedAt: expect.any(Number)
|
|
})
|
|
)
|
|
expect(isProcessAlive(spawn.pid)).toBe(true)
|
|
expect(readLedger(interruptionLedgerPath)).toEqual([])
|
|
const workerTab = orcaPage.locator(
|
|
`[data-testid="sortable-tab"][data-tab-id="${workerTerminal!.tabId}"]`
|
|
)
|
|
await expect(workerTab).toBeVisible()
|
|
await expect(workerTab).toHaveAttribute('data-active', 'false')
|
|
await expect(
|
|
orcaPage.locator(`[data-testid="sortable-tab"][data-tab-id="${coordinatorTabId}"]`)
|
|
).toHaveAttribute('data-active', 'true')
|
|
|
|
await client.call('orchestration.send', {
|
|
from: workerHandle,
|
|
to: `run:${run.result.run.id}`,
|
|
subject: 'ACK'
|
|
})
|
|
const checked = await client.call<{ messages: { subject: string }[] }>('orchestration.check', {
|
|
terminal: 'term_stale_coordinator',
|
|
terminalPaneKey: coordinatorPane.paneKey
|
|
})
|
|
expect(checked.result.messages).toEqual([expect.objectContaining({ subject: 'ACK' })])
|
|
|
|
const otherWorktreeId = await switchToOtherWorktree(orcaPage, worktreeId)
|
|
expect(otherWorktreeId).toBeTruthy()
|
|
await expect(workerTab).not.toBeVisible()
|
|
await switchToWorktree(orcaPage, worktreeId)
|
|
|
|
await expect(workerTab).toBeVisible()
|
|
await expect(
|
|
orcaPage.locator(`[data-testid="sortable-tab"][data-tab-id="${workerTerminal!.tabId}"]`)
|
|
).toHaveCount(1)
|
|
await expect(
|
|
orcaPage.locator(`[data-testid="sortable-tab"][data-tab-title="${workerTabTitle}"]`)
|
|
).toHaveCount(1)
|
|
const terminalsAfterReturn = await client.call<RuntimeTerminalListResult>('terminal.list')
|
|
const workerAfterReturn = terminalsAfterReturn.result.terminals.find(
|
|
(terminal) => terminal.ptyId === initialWorkerIdentity.ptyId
|
|
)
|
|
expect(workerAfterReturn).toEqual(expect.objectContaining(initialWorkerIdentity))
|
|
const dispatchAfterReturn = await client.call<{
|
|
dispatch: { id: string; task_id: string; assignee_handle: string } | null
|
|
}>('orchestration.dispatchShow', { task: task.result.task.id })
|
|
expect(dispatchAfterReturn.result.dispatch).toEqual(initialDispatch.result.dispatch)
|
|
expect(readLedger(spawnLedgerPath)).toEqual([spawn])
|
|
expect(readLedger(interruptionLedgerPath)).toEqual([])
|
|
expect(isProcessAlive(spawn.pid)).toBe(true)
|
|
const workerOutputAfterReturn = await client.call<{ terminal: RuntimeTerminalRead }>(
|
|
'terminal.read',
|
|
{
|
|
terminal: workerAfterReturn!.handle,
|
|
limit: 200
|
|
}
|
|
)
|
|
expect(workerOutputAfterReturn.result.terminal.tail.join('\n')).not.toContain(
|
|
'Conversation interrupted'
|
|
)
|
|
await expect(orcaPage.locator('body')).not.toContainText('Conversation interrupted')
|
|
})
|