mirror of
https://github.com/stablyai/orca.git
synced 2026-11-16 02:47:34 +00:00
* 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>
196 lines
7.3 KiB
TypeScript
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)
|
|
})
|
|
})
|