Files
orca/tests/e2e/workspace-sleep-in-main.spec.ts
Jinwoo HongandClaude 41661e3312 feat(sidebar): main runs workspace sleep; the window follows (P3b) (#31564)
* fix(sidebar): land flip-a's switch-on fixes on main, still dark (no flip)

The fixes found while the sidebar ran from main's feed, without turning
that on: ORCA_SIDEBAR_INPUTS_IS_MAIN stays false, and none of flip-a's
stop-gaps come along.

- Main stops counting a closed tab's terminal once it was asked to stop
  and no pane shows it; a failed or refused stop takes the request back,
  and a host out of contact stays unverifiable.
- Main fetches a paired server's rows with the transport's normal bound,
  so a server slower than 5 s still lists.
- A deferred unread raise flips the folder row it was decided for, and a
  read while the owner check is out cancels it.
- Phone: no worktree.ps flash before the feed; a host's last installed
  feed stands in while a fresh read is out; it highlights its own
  last-opened workspace and a fold never scrolls; projects file under
  their project group with the desktop's indent; the collapse spinner
  shows only after 500 ms; "Reopen to update" keeps the rows on screen.
- e2e helpers and journeys for the switch-on suite.

* fix(sidebar): keep an owed relay stop marked, clear a thrown stop, and prune pending unread raises

- A stop-and-wait that throws takes its stop request back, like one that fails.
- A final stop the legacy relay still owes stays marked, since the relay retries it.
- Pending unread raises are tracked only while one waits, so the map no longer grows.
- The paired-server fallback poll test gives its third fetch a reply and asserts live.

* feat(sidebar): main publishes cached snapshots and announces its own stores; detected, view and live-content domains (inert)

* fix(sidebar): keep links confirmed only by a new git run, no rescan on metadata writes, no phone wait on detected checkouts

* fix(sidebar): rescan the workspace rows when the Windows runtime default changes

* feat(sidebar): one lifecycle queue per workspace in main, with in-progress hints (switch-gated)

Create, delete, terminal.closeAll, terminal.sleep and worktree.sleep now run through one
first-in, first-out queue per host-qualified workspace: strict order, no merging, delete
cancels what has not started and waits for what has, an unconfirmed outcome pauses until
the host's own answer. Hints publish in a new inProgress feed domain (no reader yet); the
creations domain is its projection. A finished create or delete keeps its hint until a scan
started after it applies, in the same revision. Adds the paired-server metadata serializer
(saving domain, no caller yet). Replaces the creation registry.

* fix(sidebar): a create never queues behind the previous occupant's delete

* feat(sidebar): main runs sleep; the window follows (P3b)

* fix(sidebar): keep electron out of the headless server's sleep path

The desktop registers how sleep reaches paired servers; a headless serve has none.

Co-Authored-By: Claude <noreply@anthropic.com>

* test(sidebar): type-check the sleep e2e specs; drop the removed VM suspend stub

Co-Authored-By: Claude <noreply@anthropic.com>

* fix(sidebar): resume a paused workspace by re-observing, never replaying

- A command issued while paused waits behind the pause; when the owner answers again main
  re-reads terminal liveness and the listing, then carries on. A forced delete runs past it.
- Commands keep their arrival order across a workspace lookup; deletes by name key by the
  resolved id, so they wait for that workspace's running sleep.
- A second delete with different options is refused as already in progress.
- Close and delete read lost contact as sleep does.
- A create always frees its own queue entry, even after a retry took over its id.
- Drops the unused opId, and the paired-server write serializer and its feed section,
  which land with their first caller.

Co-Authored-By: Claude <noreply@anthropic.com>

* fix(sidebar): main is the only writer of a sleep's wake records; sleep classifies only lost contact as unconfirmed

- The window no longer captures wake records for a sleep main runs; it takes main's records
  from main's answer, which its wake and tab-open resume then read.
- A workspace reopened during its sleep keeps its VM running (the window and a phone's
  activation tell main).
- Only lost contact pauses: a definite chat-stop failure or a server's still-live answer is a
  plain failure with today's toast.
- A paired server's chats are asked with the Sleep mark, and again without it when an older
  server refuses the field, instead of reading an unprobed status.
- A phone's worktree.sleep is answered on acceptance and its activation no longer waits on a
  queued wake, so neither can outlast the phone's request timeout. The web client passes
  markChatsAsleep and keeps the receipts.
- One desktop adapter, passed where the desktop builds the runtime, replaces the two module
  slots; a headless server gets none.

Co-Authored-By: Claude <noreply@anthropic.com>

* chore(sidebar): share worktree.sleep's params with the RPC catalog; lint fixes

Co-Authored-By: Claude <noreply@anthropic.com>

* test(sidebar): test the paired-server sleep where main runs it; drop the window's copies

The window no longer sleeps a paired server's terminals, so its convergence and order tests for
that path move to main (remote-workspace-terminal-sleep.test.ts) or follow main's answer.

Co-Authored-By: Claude <noreply@anthropic.com>

* test(sidebar): retry the sleep spec's liveness read while terminals stop

Co-Authored-By: Claude <noreply@anthropic.com>

* fix(sleep): main resumes every workspace-sleep wake; the window only attaches

- Main claims and starts each slept pane through its windowless resume path, with or
  without a window: the "window present" check is gone.
- A phone's open queues main's wake, which finishes only once the resumes have started,
  and always notes the reopen so a running sleep leaves the VM up.
- The window no longer relaunches a workspace sleep's records in fresh tabs; opening a
  slept pane asks main to resume it and the pane's spawn attaches to main's terminal.
- A window save cannot overwrite main's workspace-sleep records.
- A VM that would not suspend no longer reads as "kept open": the terminals slept, and
  the toast says the machine is still running.

* test(e2e): main resumes a slept pane once, in place, and keeps its record

* chore(i18n): add the VM-still-running sleep message

* fix(sleep): a phone's or the CLI's failed sleep shows the desktop toast again

* fix: restore main's final P2 test fixes a merge reverted

* fix(sleep): window saves never write or clear main's sleep records; headless wake report counts only real sleeps

* test: a same-id twin's grace follows the rows' change, not the removed catalog hook

* fix(sleep): drop the 1 s settle wait after an observed exit, and wake a slept workspace's mounted agents on phone open

A workspace sleep stopped each terminal through main's stop-and-verify, which polled for a
further second after the exit it had already seen. And a phone opening a slept workspace no
longer reached the window's mounted panes of agents that had finished before the sleep, so
they stayed asleep until the window opened their tab.

* test: give the workspace-sleep wake record its prompt field

* refactor: match slept-agent records to the workspace with worktreeIdsEqual

* chore(sleep): one import from sleep-record-pane-claim

* test(sleep): route the disconnected-sleep SSH spec, declare the desktop sleep adapter, and open the workspace after its sleep starts

* test(sleep): delete a workspace the spec creates, not the seeded one later specs share

---------

Co-authored-by: Claude <noreply@anthropic.com>
2026-10-22 19:39:07 -04:00

196 lines
7.3 KiB
TypeScript

/**
* Main runs a workspace's sleep and the window follows it: Sleep from the sidebar, a phone's
* `worktree.sleep`, sleep then an immediate wake, and a delete during a sleep.
*/
import { randomUUID } from 'node:crypto'
import type { Page } from '@stablyai/playwright-test'
import { test, expect } from './helpers/orca-app'
import {
ensureTerminalVisible,
getAllWorktreeIds,
switchToWorktree,
waitForActiveWorktree,
waitForSessionReady
} from './helpers/store'
import {
sendToTerminal,
waitForActivePanePtyId,
waitForActiveTerminalManager,
waitForTerminalOutput
} from './helpers/terminal'
type SleepState = {
/** Terminals the window still binds; a sleep main ran leaves none. */
windowLivePtys: number
/** The tabs survive a sleep, so a wake reopens them. */
tabs: number
/** Main's own count, from a fresh liveness read. */
hostLiveTerminals: number
}
function readSleepState(page: Page, worktreeId: string): Promise<SleepState> {
return page.evaluate(async (id) => {
const state = window.__store!.getState()
const tabs = state.tabsByWorktree[id] ?? []
const listed = await window.api.runtime.call({
method: 'terminal.list',
params: { worktree: `id:${id}`, requireFreshPtyLiveness: true }
})
// A liveness read can be briefly unavailable while terminals stop; the poll asks again.
if (!listed.ok) {
return { windowLivePtys: -1, tabs: -1, hostLiveTerminals: -1 }
}
const result = listed.result
if (
typeof result !== 'object' ||
result === null ||
!('totalCount' in result) ||
typeof result.totalCount !== 'number'
) {
throw new Error('terminal.list returned no totalCount')
}
return {
windowLivePtys: tabs.reduce((n, tab) => n + (state.ptyIdsByTabId[tab.id]?.length ?? 0), 0),
tabs: tabs.length,
hostLiveTerminals: result.totalCount
}
}, worktreeId)
}
async function liveTerminalIn(page: Page, worktreeId: string): Promise<string> {
await switchToWorktree(page, worktreeId)
await ensureTerminalVisible(page)
await waitForActiveTerminalManager(page, 30_000)
const ptyId = await waitForActivePanePtyId(page)
const marker = `SLEEP_MAIN_${randomUUID().slice(0, 8)}`
await sendToTerminal(page, ptyId, `echo ${marker}\r`)
await waitForTerminalOutput(page, marker, 10_000, 20_000)
return ptyId
}
const asleep = { windowLivePtys: 0, tabs: 1, hostLiveTerminals: 0 }
async function secondWorktree(page: Page): Promise<{ first: string; second: string }> {
await waitForSessionReady(page)
const first = await waitForActiveWorktree(page)
const second = (await getAllWorktreeIds(page)).find((id) => id !== first)
if (!second) {
throw new Error('needs the seeded secondary worktree')
}
return { first, second }
}
test.describe('Workspace sleep runs in main', () => {
test('Sleep from the sidebar stops the terminals in main and keeps the tab', async ({
orcaPage
}) => {
const { first, second } = await secondWorktree(orcaPage)
await liveTerminalIn(orcaPage, second)
await switchToWorktree(orcaPage, first)
const row = orcaPage.locator(`[data-worktree-sidebar] [data-worktree-id="${second}"]`).first()
await row.click({ button: 'right' })
await orcaPage.getByRole('menuitem', { name: 'Sleep', exact: true }).click()
await expect.poll(() => readSleepState(orcaPage, second), { timeout: 20_000 }).toEqual(asleep)
await expect(orcaPage.getByText('Failed to sleep workspace')).toHaveCount(0)
// Opening it again wakes it: the kept tab gets a live terminal.
await switchToWorktree(orcaPage, second)
await ensureTerminalVisible(orcaPage)
await waitForActivePanePtyId(orcaPage)
await expect
.poll(async () => (await readSleepState(orcaPage, second)).hostLiveTerminals, {
timeout: 20_000
})
.toBeGreaterThan(0)
})
test("a phone's sleep runs in main, and the window follows it", async ({ orcaPage }) => {
const { first, second } = await secondWorktree(orcaPage)
await liveTerminalIn(orcaPage, second)
// The window shows it while the phone sleeps it: the window gives up the selection.
const reply = await orcaPage.evaluate(
(id) =>
window.api.runtime.call({ method: 'worktree.sleep', params: { worktree: `id:${id}` } }),
second
)
expect(reply.ok).toBe(true)
await expect.poll(() => readSleepState(orcaPage, second), { timeout: 20_000 }).toEqual(asleep)
await expect
.poll(() => orcaPage.evaluate(() => window.__store!.getState().activeWorktreeId))
.not.toBe(second)
await switchToWorktree(orcaPage, first)
})
test('opening a workspace as soon as its sleep starts ends awake', async ({ orcaPage }) => {
const { first, second } = await secondWorktree(orcaPage)
await liveTerminalIn(orcaPage, second)
await switchToWorktree(orcaPage, first)
await orcaPage.evaluate(async (id) => {
const store = window.__store!
const windowPtys = (): number => {
const state = store.getState()
return (state.tabsByWorktree[id] ?? []).reduce(
(n, tab) => n + (state.ptyIdsByTabId[tab.id]?.length ?? 0),
0
)
}
const reply = window.api.runtime.call({
method: 'worktree.sleep',
params: { worktree: `id:${id}` }
})
// Why wait for the window's detach: a selection made before the sleep starts is dropped by it.
const deadline = Date.now() + 20_000
while (windowPtys() > 0 && Date.now() < deadline) {
await new Promise((resolve) => setTimeout(resolve, 10))
}
store.getState().setActiveWorktree(id)
// Why after the reply: the sleep has stopped its terminal, so a live one is the open's.
await reply
}, second)
await expect
.poll(() => readSleepState(orcaPage, second).then((state) => state.hostLiveTerminals > 0), {
timeout: 30_000
})
.toBe(true)
})
test('a delete during a sleep waits for it and removes the workspace', async ({ orcaPage }) => {
const { first } = await secondWorktree(orcaPage)
// Why its own workspace: the seeded secondary one is shared by every later spec in this run.
const second = await orcaPage.evaluate(async (firstId) => {
const state = window.__store!.getState()
const repoId = state.getKnownWorktreeById(firstId)?.repoId
if (!repoId) {
throw new Error('no repo for the active workspace')
}
const created = await state.createWorktree(
repoId,
`e2e-sleep-delete-${Date.now()}`,
undefined,
'skip'
)
await state.fetchWorktrees(repoId)
return created.worktree.id
}, first)
await liveTerminalIn(orcaPage, second)
await switchToWorktree(orcaPage, first)
const removed = await orcaPage.evaluate(async (id) => {
const sleeping = window.api.runtime.call({
method: 'worktree.sleep',
params: { worktree: `id:${id}` }
})
const removing = window
.__store!.getState()
.removeWorktree({ id, executionHostId: null }, true)
const [sleep, removal] = await Promise.allSettled([sleeping, removing])
return { sleep: sleep.status, removal: removal.status }
}, second)
expect(removed).toEqual({ sleep: 'fulfilled', removal: 'fulfilled' })
await expect
.poll(async () => (await getAllWorktreeIds(orcaPage)).includes(second), { timeout: 30_000 })
.toBe(false)
})
})