diff --git a/src/main/ephemeral-vm/runtime-provisioning-persistence.ts b/src/main/ephemeral-vm/runtime-provisioning-persistence.ts index c0fd9636c84..c84ada676eb 100644 --- a/src/main/ephemeral-vm/runtime-provisioning-persistence.ts +++ b/src/main/ephemeral-vm/runtime-provisioning-persistence.ts @@ -22,12 +22,15 @@ import type { } from './runtime-service' import { cleanupFailedEphemeralVmStart } from './failed-start-cleanup' import { renameLegacyOrcaCloudEnvironments } from './legacy-orca-cloud-environment-names' +import { readOrcaCloudActiveAccountId } from '../hosted-sandbox/orca-cloud-active-account' export type EphemeralVmWriteAhead = { instanceId: string createdAt: number /** Set once the create command's process started; before that no VM can exist. */ launched: boolean + /** Orca Cloud: the team the sandbox is created under, read once so a mid-create switch can't refile it. */ + cloudAccountId?: string } // Creates owned by this process; any other `provisioning` record was orphaned by a crash or quit. @@ -41,10 +44,13 @@ export function isEphemeralVmProvisionLive(instanceId: string): boolean { export function beginEphemeralVmProvisioning( args: ProvisionEphemeralVmRuntimeArgs ): EphemeralVmWriteAhead { + const cloudAccountId = + args.recipe.provider === 'orca-cloud' ? readOrcaCloudActiveAccountId() : null const writeAhead: EphemeralVmWriteAhead = { instanceId: `orca-${randomUUID()}`, createdAt: args.now ?? Date.now(), - launched: false + launched: false, + ...(cloudAccountId ? { cloudAccountId } : {}) } if (args.recipe.checkoutMode) { assertEphemeralVmRuntimeCheckoutModeCanPersist(args.userDataPath, { @@ -214,6 +220,7 @@ function baseRuntimeRecord( ...(args.projectId ? { projectId: args.projectId } : {}), ...(args.workspaceId ? { workspaceId: args.workspaceId } : {}), ...(args.workspaceName ? { workspaceName: args.workspaceName } : {}), + ...(writeAhead.cloudAccountId ? { cloudAccountId: writeAhead.cloudAccountId } : {}), cleanupStatus: args.recipe.destroyDisabled ? 'disabled' : 'not_started', ...(args.recipe.destroyDisabled ? { cleanupDisabled: true } : {}), createdAt: writeAhead.createdAt diff --git a/src/main/hosted-sandbox/cloud-account-backfill.ts b/src/main/hosted-sandbox/cloud-account-backfill.ts new file mode 100644 index 00000000000..56d2056270c --- /dev/null +++ b/src/main/hosted-sandbox/cloud-account-backfill.ts @@ -0,0 +1,104 @@ +// Files Orca Cloud runtime records under the team that owns them. The control plane lists only the +// caller's account's sandboxes, so a sandbox in the active team's list belongs to that team. This +// files records written before the team was recorded, and corrects one a create filed under the +// team a switch left behind. Records it can't place stay unfiled, and lists hide them. +import { + listEphemeralVmRuntimes, + updateEphemeralVmRuntimeStatus +} from '../../shared/ephemeral-vm-runtime-store' +import type { EphemeralVmRuntimeRecord } from '../../shared/ephemeral-vm-runtimes' +import type { HostedSandboxView } from '../../shared/hosted-sandbox/hosted-sandbox-wire' +import { environmentHandleFromRecipeResult } from '../environment-providers/environment-provider-recipe-adapter' +import { HOSTED_SANDBOX_DRIVER_ID } from './hosted-sandbox-driver' + +const RETIRED = new Set(['cleaned', 'cleanup_pending']) + +function sandboxIdOf(runtime: EphemeralVmRuntimeRecord): string | null { + const handle = runtime.recipeResult + ? environmentHandleFromRecipeResult(runtime.recipeResult, HOSTED_SANDBOX_DRIVER_ID) + : null + const id = handle?.driverState.sandboxId + return typeof id === 'string' && id ? id : null +} + +export type CloudAccountBackfill = { + /** + * Lists the active team's sandboxes when a live record is unfiled, the team changed, or the last + * list is older than `relistMs` (the first run, at startup, always lists). + */ + run(): Promise +} + +export function createCloudAccountBackfill(deps: { + userDataPath: string + activeAccountId: () => string | null + list: () => Promise[]> + /** Each successful list, for the team it answered for (the gone-sandbox prune reads it). */ + onListed?: (account: string, listed: ReadonlySet) => Promise + /** Re-list this often even when nothing changed, so a sandbox destroyed elsewhere is noticed. */ + relistMs?: number + now?: () => number + log?: (line: string) => void +}): CloudAccountBackfill { + const now = deps.now ?? Date.now + // One list per (team, unfiled set) or per relistMs: the 30 s beat must not list on every tick. + let lastKey: string | null = null + let listedAt = Number.NEGATIVE_INFINITY + return { + async run() { + const account = deps.activeAccountId() + if (!account) { + return + } + const before = readCloud(deps.userDataPath) + // A team switch re-lists once even with nothing unfiled: it corrects a misfiled create. + const key = keyOf(account, before) + const stale = deps.relistMs !== undefined && now() - listedAt >= deps.relistMs + if (before.length === 0 || (key === lastKey && !stale)) { + return + } + let listed: ReadonlySet + try { + listed = new Set((await deps.list()).map((sandbox) => sandbox.id)) + } catch (error) { + deps.log?.(`[orca-cloud] could not list sandboxes to file them by team: ${String(error)}`) + return + } + // The list answered for whichever team the token was minted for; drop it if that moved. + if (deps.activeAccountId() !== account) { + return + } + for (const runtime of readCloud(deps.userDataPath)) { + const sandboxId = sandboxIdOf(runtime) + if (sandboxId && listed.has(sandboxId) && runtime.cloudAccountId !== account) { + updateEphemeralVmRuntimeStatus(deps.userDataPath, runtime.id, { + cloudAccountId: account, + updatedAt: runtime.updatedAt + }) + } + } + // Keyed on what is still unfiled, so this team does not list again until that changes. + lastKey = keyOf(account, readCloud(deps.userDataPath)) + listedAt = now() + await deps.onListed?.(account, listed) + } + } +} + +/** Live Orca Cloud records with a sandbox to look for. */ +function readCloud(userDataPath: string): EphemeralVmRuntimeRecord[] { + return listEphemeralVmRuntimes(userDataPath).filter( + (runtime) => + runtime.recipe?.provider === 'orca-cloud' && + !RETIRED.has(runtime.status) && + sandboxIdOf(runtime) !== null + ) +} + +function keyOf(account: string, cloud: readonly EphemeralVmRuntimeRecord[]): string { + const unfiled = cloud + .filter((runtime) => !runtime.cloudAccountId) + .map((runtime) => runtime.id) + .sort() + return JSON.stringify([account, unfiled]) +} diff --git a/src/main/hosted-sandbox/cloud-account-filing.test.ts b/src/main/hosted-sandbox/cloud-account-filing.test.ts new file mode 100644 index 00000000000..25ab666a4a7 --- /dev/null +++ b/src/main/hosted-sandbox/cloud-account-filing.test.ts @@ -0,0 +1,167 @@ +import { mkdtempSync, rmSync } from 'node:fs' +import { tmpdir } from 'node:os' +import { join } from 'node:path' +import { afterEach, describe, expect, it, vi } from 'vitest' +import { + listEphemeralVmRuntimes, + upsertEphemeralVmRuntime +} from '../../shared/ephemeral-vm-runtime-store' +import type { EphemeralVmRuntimeRecord } from '../../shared/ephemeral-vm-runtimes' +import { + beginEphemeralVmProvisioning, + endEphemeralVmProvisioning +} from '../ephemeral-vm/runtime-provisioning-persistence' +import { createCloudAccountBackfill } from './cloud-account-backfill' +import { ORCA_CLOUD_RECIPE } from './hosted-sandbox-recipe' +import { setOrcaCloudActiveAccountResolver } from './orca-cloud-active-account' +import { HOSTED_SANDBOX_DRIVER_ID } from './hosted-sandbox-driver' + +const dirs: string[] = [] +afterEach(() => { + setOrcaCloudActiveAccountResolver(null) + for (const dir of dirs.splice(0)) { + rmSync(dir, { recursive: true, force: true }) + } +}) + +function userData(): string { + const dir = mkdtempSync(join(tmpdir(), 'orca-cloud-account-')) + dirs.push(dir) + return dir +} + +function cloudRecord( + id: string, + sandboxId: string, + cloudAccountId?: string +): EphemeralVmRuntimeRecord { + return { + id, + recipeId: ORCA_CLOUD_RECIPE.id, + recipe: { + id: ORCA_CLOUD_RECIPE.id, + name: 'Orca Cloud', + create: 'orca-cloud create', + provider: 'orca-cloud' + }, + workspaceId: `ws-${id}`, + runtimeEnvironmentId: `env-${id}`, + status: 'running', + cleanupStatus: 'not_started', + createdAt: 1, + updatedAt: 1, + ...(cloudAccountId ? { cloudAccountId } : {}), + recipeResult: { + schemaVersion: 1, + connection: { + type: 'orca-server', + pairingCode: 'code', + projectRoot: '/vercel/sandbox/project' + }, + userData: { + environmentDriver: { + driverId: HOSTED_SANDBOX_DRIVER_ID, + environmentId: sandboxId, + driverState: { sandboxId } + } + } + } + } +} + +function accountOf(path: string, id: string): string | undefined { + return listEphemeralVmRuntimes(path).find((runtime) => runtime.id === id)?.cloudAccountId +} + +describe('Orca Cloud team filing at create', () => { + it('records the active team on an Orca Cloud runtime, read once at the write-ahead', () => { + const path = userData() + let team = 'org:team-one' + setOrcaCloudActiveAccountResolver(() => team) + const args = { userDataPath: path, repoPath: '/repo', recipe: ORCA_CLOUD_RECIPE } + const writeAhead = beginEphemeralVmProvisioning(args) + team = 'org:team-two' + + expect(accountOf(path, writeAhead.instanceId)).toBe('org:team-one') + expect(writeAhead.cloudAccountId).toBe('org:team-one') + endEphemeralVmProvisioning(args, writeAhead) + }) + + it('leaves recipe VMs that are not Orca Cloud unfiled', () => { + const path = userData() + setOrcaCloudActiveAccountResolver(() => 'org:team-one') + const recipe = { id: 'vm', name: 'VM', create: 'make-vm' } + const writeAhead = beginEphemeralVmProvisioning({ userDataPath: path, repoPath: '/r', recipe }) + expect(accountOf(path, writeAhead.instanceId)).toBeUndefined() + }) +}) + +describe('Orca Cloud team backfill', () => { + it("files unfiled records the active team's list names, and only those", async () => { + const path = userData() + upsertEphemeralVmRuntime(path, cloudRecord('mine', 'sbx-mine')) + upsertEphemeralVmRuntime(path, cloudRecord('other', 'sbx-other')) + const list = vi.fn(async () => [{ id: 'sbx-mine' }]) + const backfill = createCloudAccountBackfill({ + userDataPath: path, + activeAccountId: () => 'org:team-one', + list + }) + + await backfill.run() + expect(accountOf(path, 'mine')).toBe('org:team-one') + expect(accountOf(path, 'other')).toBeUndefined() + + // Nothing new to file for this team: the beat does not list again. + await backfill.run() + expect(list).toHaveBeenCalledTimes(1) + }) + + it('re-lists after a team switch and files that team, correcting a misfiled record', async () => { + const path = userData() + upsertEphemeralVmRuntime(path, cloudRecord('mine', 'sbx-mine', 'org:team-one')) + upsertEphemeralVmRuntime(path, cloudRecord('other', 'sbx-other', 'org:team-one')) + let team = 'org:team-one' + const list = vi.fn(async () => (team === 'org:team-two' ? [{ id: 'sbx-other' }] : [])) + const backfill = createCloudAccountBackfill({ + userDataPath: path, + activeAccountId: () => team, + list + }) + await backfill.run() + team = 'org:team-two' + await backfill.run() + + expect(list).toHaveBeenCalledTimes(2) + expect(accountOf(path, 'other')).toBe('org:team-two') + expect(accountOf(path, 'mine')).toBe('org:team-one') + }) + + it('files nothing when the team changed while listing', async () => { + const path = userData() + upsertEphemeralVmRuntime(path, cloudRecord('mine', 'sbx-mine')) + let team = 'org:team-one' + const backfill = createCloudAccountBackfill({ + userDataPath: path, + activeAccountId: () => team, + list: async () => { + team = 'org:team-two' + return [{ id: 'sbx-mine' }] + } + }) + await backfill.run() + expect(accountOf(path, 'mine')).toBeUndefined() + }) + + it('does not list when signed out', async () => { + const path = userData() + upsertEphemeralVmRuntime(path, cloudRecord('mine', 'sbx-mine')) + const list = vi.fn(async () => []) + await createCloudAccountBackfill({ + userDataPath: path, + activeAccountId: () => null, + list + }).run() + expect(list).not.toHaveBeenCalled() + }) +}) diff --git a/src/main/hosted-sandbox/cloud-sandbox-gone-prune.test.ts b/src/main/hosted-sandbox/cloud-sandbox-gone-prune.test.ts new file mode 100644 index 00000000000..1a6ef06f412 --- /dev/null +++ b/src/main/hosted-sandbox/cloud-sandbox-gone-prune.test.ts @@ -0,0 +1,185 @@ +import { mkdtempSync, rmSync } from 'node:fs' +import { tmpdir } from 'node:os' +import { join } from 'node:path' +import { afterEach, describe, expect, it, vi } from 'vitest' +import { upsertEphemeralVmRuntime } from '../../shared/ephemeral-vm-runtime-store' +import type { EphemeralVmRuntimeRecord } from '../../shared/ephemeral-vm-runtimes' +import { EnvironmentProviderError } from '../environment-providers/environment-provider-driver' +import { createCloudAccountBackfill } from './cloud-account-backfill' +import { createCloudSandboxGonePrune } from './cloud-sandbox-gone-prune' +import { HOSTED_SANDBOX_DRIVER_ID } from './hosted-sandbox-driver' + +const dirs: string[] = [] +afterEach(() => { + for (const dir of dirs.splice(0)) { + rmSync(dir, { recursive: true, force: true }) + } +}) + +const TEAM = 'org:team-one' + +function record( + id: string, + overrides: Partial = {} +): EphemeralVmRuntimeRecord { + return { + id, + recipeId: 'orca-cloud', + recipe: { id: 'orca-cloud', name: 'Orca Cloud', create: 'c', provider: 'orca-cloud' }, + workspaceId: `ws-${id}`, + runtimeEnvironmentId: `env-${id}`, + status: 'running', + cleanupStatus: 'not_started', + createdAt: 1, + updatedAt: 1, + cloudAccountId: TEAM, + recipeResult: { + schemaVersion: 1, + connection: { type: 'orca-server', pairingCode: 'code', projectRoot: '/p' }, + userData: { + environmentDriver: { + driverId: HOSTED_SANDBOX_DRIVER_ID, + environmentId: `sbx-${id}`, + driverState: { sandboxId: `sbx-${id}` } + } + } + }, + ...overrides + } +} + +function setup( + records: EphemeralVmRuntimeRecord[], + get: (id: string) => Promise<{ status: string }> +) { + const userDataPath = mkdtempSync(join(tmpdir(), 'orca-gone-prune-')) + dirs.push(userDataPath) + records.forEach((entry) => upsertEphemeralVmRuntime(userDataPath, entry)) + let team: string | null = TEAM + const retired: string[] = [] + const prune = createCloudSandboxGonePrune({ + userDataPath, + activeAccountId: () => team, + // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the prune reads only status. + get: get as never, + retire: async (runtime) => void retired.push(runtime.id) + }) + return { + prune, + retired, + userDataPath, + switchTeam: (next: string | null) => { + team = next + } + } +} + +const notFound = async (): Promise => { + throw new EnvironmentProviderError('not_found', 'no such sandbox') +} +const offline = async (): Promise => { + throw new EnvironmentProviderError('unavailable', 'offline') +} + +describe('Orca Cloud gone-sandbox prune', () => { + it('retires a sandbox missing from the list once its own read says not found', async () => { + const h = setup([record('cusk'), record('crayfish')], notFound) + await h.prune.observeList(TEAM, new Set(['sbx-crayfish'])) + expect(h.retired).toEqual(['cusk']) + }) + + it('retires on a destroyed answer, or on a second consecutive list without it', async () => { + const destroyed = setup([record('cusk')], async () => ({ status: 'destroyed' })) + await destroyed.prune.observeList(TEAM, new Set()) + expect(destroyed.retired).toEqual(['cusk']) + + const twice = setup([record('cusk')], offline) + await twice.prune.observeList(TEAM, new Set()) + expect(twice.retired).toEqual([]) + await twice.prune.observeList(TEAM, new Set()) + expect(twice.retired).toEqual(['cusk']) + }) + + it('keeps it through a network blip: one miss plus an unreadable sandbox is not proof', async () => { + const h = setup([record('cusk')], offline) + await h.prune.observeList(TEAM, new Set()) + // Listed again: the miss streak resets, so a later single miss is not a second one. + await h.prune.observeList(TEAM, new Set(['sbx-cusk'])) + await h.prune.observeList(TEAM, new Set()) + expect(h.retired).toEqual([]) + }) + + it('keeps a sandbox still being created, which the list may not show yet', async () => { + const h = setup([record('cusk', { status: 'provisioning' })], notFound) + await h.prune.observeList(TEAM, new Set()) + await h.prune.observeList(TEAM, new Set()) + expect(h.retired).toEqual([]) + }) + + it("keeps another team's sandbox, and one whose team is unknown", async () => { + const h = setup( + [ + record('otter', { cloudAccountId: 'org:team-two' }), + record('legacy', { cloudAccountId: undefined }) + ], + notFound + ) + await h.prune.observeList(TEAM, new Set()) + await h.prune.observeList(TEAM, new Set()) + expect(h.retired).toEqual([]) + }) + + it('never retires an asleep (suspended or archived) sandbox the team still lists', async () => { + const get = vi.fn(async () => ({ status: 'suspended' })) + const h = setup([record('asleep', { status: 'suspended' }), record('archived')], get) + for (let round = 0; round < 3; round++) { + await h.prune.observeList(TEAM, new Set(['sbx-asleep', 'sbx-archived'])) + } + expect(h.retired).toEqual([]) + expect(get).not.toHaveBeenCalled() + }) + + it('drops the confirmation when the team switched while it was read', async () => { + const h = setup([record('cusk')], async () => { + h.switchTeam('org:team-two') + throw new EnvironmentProviderError('not_found', 'gone') + }) + await h.prune.observeList(TEAM, new Set()) + expect(h.retired).toEqual([]) + }) +}) + +describe('Orca Cloud list reconcile', () => { + it('reconciles at startup and on each re-list, but never on a failed list', async () => { + const userDataPath = mkdtempSync(join(tmpdir(), 'orca-gone-reconcile-')) + dirs.push(userDataPath) + upsertEphemeralVmRuntime(userDataPath, record('cusk')) + let clock = 0 + let fail = true + const onListed = vi.fn(async () => {}) + const backfill = createCloudAccountBackfill({ + userDataPath, + activeAccountId: () => TEAM, + list: async () => { + if (fail) { + throw new EnvironmentProviderError('unavailable', 'offline') + } + return [] + }, + onListed, + relistMs: 1_000, + now: () => clock + }) + + await backfill.run() + expect(onListed).not.toHaveBeenCalled() + fail = false + await backfill.run() + expect(onListed).toHaveBeenCalledTimes(1) + await backfill.run() + expect(onListed).toHaveBeenCalledTimes(1) + clock = 1_000 + await backfill.run() + expect(onListed).toHaveBeenCalledTimes(2) + }) +}) diff --git a/src/main/hosted-sandbox/cloud-sandbox-gone-prune.ts b/src/main/hosted-sandbox/cloud-sandbox-gone-prune.ts new file mode 100644 index 00000000000..266b9719597 --- /dev/null +++ b/src/main/hosted-sandbox/cloud-sandbox-gone-prune.ts @@ -0,0 +1,82 @@ +// Retires Orca Cloud records whose sandbox no longer exists. A sandbox destroyed out of band (the +// team list's Delete on another desktop, the control plane) left its record, server and project +// here, and after a restart its clone came back as a stray folder project with a "Couldn't start" +// row. Only an authoritative answer retires one: missing from the active team's successful list, +// then confirmed by a second such list or by the sandbox itself answering not found or destroyed. +// Errors, a team switch mid-check, and asleep (suspended/archived, still listed) sandboxes never do. +import { listEphemeralVmRuntimes } from '../../shared/ephemeral-vm-runtime-store' +import type { EphemeralVmRuntimeRecord } from '../../shared/ephemeral-vm-runtimes' +import type { HostedSandboxView } from '../../shared/hosted-sandbox/hosted-sandbox-wire' +import { isEnvironmentProviderError } from '../environment-providers/environment-provider-driver' +import { environmentHandleFromRecipeResult } from '../environment-providers/environment-provider-recipe-adapter' +import { isEphemeralVmProvisionLive } from '../ephemeral-vm/runtime-provisioning-persistence' +import { HOSTED_SANDBOX_DRIVER_ID } from './hosted-sandbox-driver' + +const RETIRED = new Set(['cleaned', 'cleanup_pending']) + +function sandboxIdOf(runtime: EphemeralVmRuntimeRecord): string | null { + const handle = runtime.recipeResult + ? environmentHandleFromRecipeResult(runtime.recipeResult, HOSTED_SANDBOX_DRIVER_ID) + : null + const id = handle?.driverState.sandboxId + return typeof id === 'string' && id ? id : null +} + +export type CloudSandboxGonePrune = { + /** After a successful list of `account`'s sandboxes: retire that team's records it confirms gone. */ + observeList(account: string, listed: ReadonlySet): Promise +} + +export function createCloudSandboxGonePrune(deps: { + userDataPath: string + activeAccountId: () => string | null + get: (sandboxId: string) => Promise> + /** The app's own teardown for a destroyed cloud workspace: record, server, project. */ + retire: (runtime: EphemeralVmRuntimeRecord) => Promise + log?: (line: string) => void +}): CloudSandboxGonePrune { + // Sandboxes one list has missed; a second miss in a row confirms them. + let missedOnce = new Set() + + /** True only on a definite answer that the sandbox is gone; any error is "don't know". */ + async function confirmedGone(sandboxId: string): Promise { + try { + return (await deps.get(sandboxId)).status === 'destroyed' + } catch (error) { + return isEnvironmentProviderError(error, 'not_found') + } + } + + return { + async observeList(account, listed) { + const missing = listEphemeralVmRuntimes(deps.userDataPath).flatMap((runtime) => { + const sandboxId = runtime.recipe?.provider === 'orca-cloud' ? sandboxIdOf(runtime) : null + // A create in flight is not listed yet; its own outcome settles the record. + const creating = runtime.status === 'provisioning' || isEphemeralVmProvisionLive(runtime.id) + return sandboxId && + runtime.cloudAccountId === account && + !RETIRED.has(runtime.status) && + !creating && + !listed.has(sandboxId) + ? [{ runtime, sandboxId }] + : [] + }) + const previous = missedOnce + missedOnce = new Set(missing.map(({ sandboxId }) => sandboxId)) + for (const { runtime, sandboxId } of missing) { + const gone = previous.has(sandboxId) || (await confirmedGone(sandboxId)) + // The confirming answer must still be for the team this list was for. + if (!gone || deps.activeAccountId() !== account) { + continue + } + try { + await deps.retire(runtime) + missedOnce.delete(sandboxId) + deps.log?.(`[orca-cloud] retired ${runtime.workspaceName ?? runtime.id}: sandbox is gone`) + } catch (error) { + deps.log?.(`[orca-cloud] could not retire a gone sandbox's records: ${String(error)}`) + } + } + } + } +} diff --git a/src/main/hosted-sandbox/cloud-sandbox-gone-retire.test.ts b/src/main/hosted-sandbox/cloud-sandbox-gone-retire.test.ts new file mode 100644 index 00000000000..fca065d876c --- /dev/null +++ b/src/main/hosted-sandbox/cloud-sandbox-gone-retire.test.ts @@ -0,0 +1,53 @@ +import { mkdtempSync, rmSync } from 'node:fs' +import { tmpdir } from 'node:os' +import { join } from 'node:path' +import { afterEach, describe, expect, it, vi } from 'vitest' +import { + listEphemeralVmRuntimes, + upsertEphemeralVmRuntime +} from '../../shared/ephemeral-vm-runtime-store' + +const sent = vi.hoisted((): string[] => []) +vi.mock('electron', () => ({ + app: { getPath: () => tmpdir() }, + BrowserWindow: { + getAllWindows: () => [ + { isDestroyed: () => false, webContents: { send: (channel: string) => sent.push(channel) } } + ] + } +})) + +const { retireGoneCloudSandbox } = await import('./cloud-sandbox-gone-retire') + +const dirs: string[] = [] +afterEach(() => { + sent.splice(0) + for (const dir of dirs.splice(0)) { + rmSync(dir, { recursive: true, force: true }) + } +}) + +describe('retireGoneCloudSandbox', () => { + it('cleans the record and asks the window to refresh its servers, which purges the project', async () => { + const userDataPath = mkdtempSync(join(tmpdir(), 'orca-gone-retire-')) + dirs.push(userDataPath) + const runtime = upsertEphemeralVmRuntime(userDataPath, { + id: 'cusk', + recipeId: 'orca-cloud', + recipe: { id: 'orca-cloud', name: 'Orca Cloud', create: 'c', provider: 'orca-cloud' }, + runtimeEnvironmentId: 'env-cusk', + status: 'resume_failed', + cleanupStatus: 'not_started', + createdAt: 1, + updatedAt: 1 + }) + + await retireGoneCloudSandbox(userDataPath, undefined, runtime) + + expect(listEphemeralVmRuntimes(userDataPath)[0]).toMatchObject({ + status: 'cleaned', + cleanupStatus: 'succeeded' + }) + expect(sent).toEqual(['runtimeEnvironments:catalogChanged']) + }) +}) diff --git a/src/main/hosted-sandbox/cloud-sandbox-gone-retire.ts b/src/main/hosted-sandbox/cloud-sandbox-gone-retire.ts new file mode 100644 index 00000000000..1924014f0b4 --- /dev/null +++ b/src/main/hosted-sandbox/cloud-sandbox-gone-retire.ts @@ -0,0 +1,38 @@ +import { updateEphemeralVmRuntimeStatus } from '../../shared/ephemeral-vm-runtime-store' +import type { EphemeralVmRuntimeRecord } from '../../shared/ephemeral-vm-runtimes' +import { releaseEphemeralVmRuntimeEnvironments } from '../ephemeral-vm/runtime-environment-release' +import { + retireRemovedRuntimeEnvironment, + type RemovedServerStore +} from '../ipc/runtime-environments/runtime-environment-removal-cleanup' +import { invalidateRuntimeEnvironmentTransport } from '../ipc/runtime-environments/runtime-environments' +import { publishRuntimeEnvironmentCatalogChanged } from '../ipc/runtime-environments/runtime-environment-catalog-broadcast' + +/** + * A sandbox destroyed out of band goes the way the app's own delete takes a destroyed one + * (cleanupOwnedEphemeralVmRuntime after its destroy): the record is cleaned and its server + * retired. The window's catalog refresh then purges that host's project and setup, so its clone + * can never come back as a folder project. + */ +export async function retireGoneCloudSandbox( + userDataPath: string, + store: RemovedServerStore | undefined, + runtime: EphemeralVmRuntimeRecord +): Promise { + updateEphemeralVmRuntimeStatus(userDataPath, runtime.id, { + status: 'cleaned', + cleanupStatus: 'succeeded', + cleanupLastError: null + }) + await releaseEphemeralVmRuntimeEnvironments(userDataPath, runtime, (environmentId) => { + if (store) { + void retireRemovedRuntimeEnvironment( + environmentId, + invalidateRuntimeEnvironmentTransport, + store, + userDataPath + ) + } + }) + publishRuntimeEnvironmentCatalogChanged() +} diff --git a/src/main/hosted-sandbox/hosted-sandbox-install.ts b/src/main/hosted-sandbox/hosted-sandbox-install.ts index 29cf66e0514..97de012ff10 100644 --- a/src/main/hosted-sandbox/hosted-sandbox-install.ts +++ b/src/main/hosted-sandbox/hosted-sandbox-install.ts @@ -35,6 +35,12 @@ import { import { createHostedSessionRegistry, type HostedSessionRegistry } from './hosted-session-registry' import { registerCloudShareHandlers } from './hosted-sandbox-share-ipc' import { setHostedSessionSync } from './hosted-session-sync' +import { orcaCloudAccountId } from '../../shared/hosted-sandbox/orca-cloud-account' +import { setOrcaCloudActiveAccountResolver } from './orca-cloud-active-account' +import { createCloudAccountBackfill } from './cloud-account-backfill' +import { createCloudSandboxGonePrune } from './cloud-sandbox-gone-prune' +import { retireGoneCloudSandbox } from './cloud-sandbox-gone-retire' +import type { RemovedServerStore } from '../ipc/runtime-environments/runtime-environment-removal-cleanup' import { createUsageAlertRefreshScheduler } from '../billing/usage-alert-refresh' import { sendToTrustedUIRenderer } from '../ipc/ui' import { ORCA_BILLING_REFRESH_CHANNEL } from '../../shared/orca-billing' @@ -68,7 +74,9 @@ export function getHostedSandboxControlPlaneClient(): HostedSandboxControlPlaneC } /** `repos` is main's repo store: org-environment repo imports only read checkouts listed there. */ -export function installHostedSandbox(repos?: OrcaCloudEnvironmentRepoSource): void { +export function installHostedSandbox( + repos?: OrcaCloudEnvironmentRepoSource & RemovedServerStore +): void { // Idempotent; answers isConfigured() = false itself when this build has no control plane. registerOrcaCloudEnvironmentHandlers(repos ? { repos } : {}) if (installed) { @@ -92,6 +100,23 @@ export function installHostedSandbox(repos?: OrcaCloudEnvironmentRepoSource): vo const client = createHostedSandboxRecipeClient(config) const base = createHostedSandboxRecipeDriver(config, client) controlPlaneClient = client + // The team the sandbox token is minted for; creates are filed under it and lists scope to it. + const activeAccountId = (): string | null => + orcaCloudAccountId(ensureActiveOrcaProfile(userDataPath).profile.cloud) + setOrcaCloudActiveAccountResolver(activeAccountId) + const gonePrune = createCloudSandboxGonePrune({ + userDataPath, + activeAccountId, + get: (sandboxId) => client.get(sandboxId), + retire: (runtime) => retireGoneCloudSandbox(userDataPath, repos, runtime) + }) + const accountBackfill = createCloudAccountBackfill({ + userDataPath, + activeAccountId, + list: () => client.list(), + onListed: (account, listed) => gonePrune.observeList(account, listed), + relistMs: 10 * 60_000 + }) const mcpSync = installCloudMcpSync(userDataPath, { baseUrl: config.controlPlaneUrl, getAccessToken: config.getAccessToken @@ -123,8 +148,11 @@ export function installHostedSandbox(repos?: OrcaCloudEnvironmentRepoSource): vo driver, windows: () => BrowserWindow.getAllWindows(), onConnected: (runtimeEnvironmentId) => void mcpSync.sync(runtimeEnvironmentId, 'connect'), - onRunningChange: (anyRunning) => usageRefresh.setRunning(anyRunning) + onRunningChange: (anyRunning) => usageRefresh.setRunning(anyRunning), + activeAccountId }) + // Filing first, so a sandbox that just joined the active team gets its scheduler in this pass. + const syncSessions = (): Promise => accountBackfill.run().finally(() => registry.sync()) const workspaces = installHostedWorkspaceService({ userDataPath, // Every status read also carries the control plane's idle-sleep minutes. @@ -149,7 +177,8 @@ export function installHostedSandbox(repos?: OrcaCloudEnvironmentRepoSource): vo }, windows: () => BrowserWindow.getAllWindows(), syncSessions: () => void registry.sync(), - stopSession: (environmentId) => registry.stopEnvironment(environmentId) + stopSession: (environmentId) => registry.stopEnvironment(environmentId), + activeAccountId }) setHostedWorkspaceService(workspaces) const disposeTransfer = installCloudTransferHandlers({ @@ -183,7 +212,7 @@ export function installHostedSandbox(repos?: OrcaCloudEnvironmentRepoSource): vo beat = setTimeout(() => { // OOM in the guest is checked every other beat (~1 min) for running cloud workspaces. const oom = beats++ % 2 === 1 ? workspaces.pollOom() : Promise.resolve() - void Promise.all([registry.sync(), oom]).finally(() => schedule(30_000)) + void Promise.all([syncSessions(), oom]).finally(() => schedule(30_000)) }, ms) beat.unref?.() } @@ -207,7 +236,8 @@ export function installHostedSandbox(repos?: OrcaCloudEnvironmentRepoSource): vo installed = { registry } registerCloudRemoteDesktopHandlers(client) registerOrcaCloudDeviceEnroller(createHostedSandboxDeviceEnroller(config)) - setHostedSessionSync(() => void registry.sync()) + // Also the team-switch nudge: the old team's schedulers stop and the new team's records file. + setHostedSessionSync(() => void syncSessions()) schedule(0) app.once('will-quit', () => { if (beat) { @@ -220,6 +250,7 @@ export function installHostedSandbox(repos?: OrcaCloudEnvironmentRepoSource): vo setHostedWorkspaceService(null) setCloudArchiveCheck(null) setCloudAsleepCheck(null) + setOrcaCloudActiveAccountResolver(null) offline.dispose() setCloudOfflineService(null) }) diff --git a/src/main/hosted-sandbox/hosted-session-registry-team-scope.test.ts b/src/main/hosted-sandbox/hosted-session-registry-team-scope.test.ts new file mode 100644 index 00000000000..3e1510d41f2 --- /dev/null +++ b/src/main/hosted-sandbox/hosted-session-registry-team-scope.test.ts @@ -0,0 +1,86 @@ +import { mkdtempSync, rmSync } from 'node:fs' +import { tmpdir } from 'node:os' +import { join } from 'node:path' +import { afterEach, describe, expect, it, vi } from 'vitest' +import { upsertEphemeralVmRuntime } from '../../shared/ephemeral-vm-runtime-store' +import type { EphemeralVmRuntimeRecord } from '../../shared/ephemeral-vm-runtimes' +import type { HostedEnvironmentProviderDriver } from './hosted-environment-provider' +import { HOSTED_SANDBOX_DRIVER_ID } from './hosted-sandbox-driver' +import { createHostedSessionRegistry } from './hosted-session-registry' + +vi.mock('electron', () => ({ app: { getPath: () => tmpdir() }, ipcMain: {}, BrowserWindow: {} })) + +const dirs: string[] = [] +afterEach(() => { + for (const dir of dirs.splice(0)) { + rmSync(dir, { recursive: true, force: true }) + } +}) + +function record(id: string, cloudAccountId?: string): EphemeralVmRuntimeRecord { + return { + id, + recipeId: 'orca-cloud', + recipe: { id: 'orca-cloud', name: 'Orca Cloud', create: 'c', provider: 'orca-cloud' }, + workspaceId: `ws-${id}`, + runtimeEnvironmentId: `env-${id}`, + status: 'running', + cleanupStatus: 'not_started', + createdAt: 1, + updatedAt: 1, + ...(cloudAccountId ? { cloudAccountId } : {}), + recipeResult: { + schemaVersion: 1, + connection: { type: 'orca-server', pairingCode: 'code', projectRoot: '/p' }, + userData: { + environmentDriver: { + driverId: HOSTED_SANDBOX_DRIVER_ID, + environmentId: `sbx-${id}`, + driverState: { sandboxId: `sbx-${id}` } + } + } + } + } +} + +describe('hosted session registry team scope', () => { + it("keeps only the active team's sandboxes alive; other and unfiled teams get no calls", async () => { + const userDataPath = mkdtempSync(join(tmpdir(), 'orca-registry-team-')) + dirs.push(userDataPath) + upsertEphemeralVmRuntime(userDataPath, record('mine', 'org:team-one')) + upsertEphemeralVmRuntime(userDataPath, record('other', 'org:team-two')) + upsertEphemeralVmRuntime(userDataPath, record('unfiled')) + // A stopped answer ends start() before any scheduler or orcad call. + const status = vi.fn(async (_handle: { environmentId: string }) => ({ + status: 'stopped', + session: null + })) + // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: sync reads only status(). + const driver = { status, capabilities: {} } as unknown as HostedEnvironmentProviderDriver + let team = 'org:team-one' + const running: boolean[] = [] + const registry = createHostedSessionRegistry({ + userDataPath, + driver, + windows: () => [], + log: () => {}, + onRunningChange: (anyRunning) => running.push(anyRunning), + activeAccountId: () => team + }) + + await registry.sync() + expect(status.mock.calls.map(([handle]) => handle.environmentId)).toEqual(['sbx-mine']) + + team = 'org:team-two' + status.mockClear() + await registry.sync() + expect(status.mock.calls.map(([handle]) => handle.environmentId)).toEqual(['sbx-other']) + + status.mockClear() + team = 'org:team-three' + await registry.sync() + expect(status).not.toHaveBeenCalled() + expect(running).toEqual([true, true, false]) + registry.dispose() + }) +}) diff --git a/src/main/hosted-sandbox/hosted-session-registry.ts b/src/main/hosted-sandbox/hosted-session-registry.ts index 9c1955bc056..b4dd60ca240 100644 --- a/src/main/hosted-sandbox/hosted-session-registry.ts +++ b/src/main/hosted-sandbox/hosted-session-registry.ts @@ -27,6 +27,7 @@ import { HOSTED_SANDBOX_DRIVER_ID } from './hosted-sandbox-driver' import { createHostedRuntimeEnvironmentCall } from './hosted-runtime-environment-call' import type { HostedActivitySample } from './hosted-session-lease-policy' import { HostedSessionLeaseScheduler } from './hosted-session-lease-scheduler' +import { isOrcaCloudRuntimeInAccount } from '../../shared/hosted-sandbox/orca-cloud-account' import { noteIdleSleepRequested } from './idle-sleep-requests' import { cloudSshActiveAt } from '../cloud-ssh/cloud-ssh-activity' import { getRuntimePortForwardManager } from '../runtime-port-forward/runtime-port-forward-manager' @@ -64,6 +65,11 @@ export function createHostedSessionRegistry(deps: { onConnected?: (runtimeEnvironmentId: string) => void /** After each sync: whether any Orca Cloud workspace is recorded running. */ onRunningChange?: (anyRunning: boolean) => void + /** + * The active team (sandbox-control account). Another team's sandbox, or one not yet filed under + * a team, gets no scheduler: its lease, wake and orcad calls would only fail under this team. + */ + activeAccountId?: () => string | null }): HostedSessionRegistry { const running = new Map() const log = deps.log ?? ((line: string) => console.error(line)) @@ -193,11 +199,13 @@ export function createHostedSessionRegistry(deps: { return { async sync() { const live = new Set() + const account = deps.activeAccountId ? deps.activeAccountId() : undefined for (const runtime of listEphemeralVmRuntimes(deps.userDataPath)) { if ( runtime.recipe?.provider !== 'orca-cloud' || runtime.status !== 'running' || - !runtime.recipeResult + !runtime.recipeResult || + (account !== undefined && !isOrcaCloudRuntimeInAccount(runtime, account)) ) { continue } diff --git a/src/main/hosted-sandbox/hosted-workspace-service-team-scope.test.ts b/src/main/hosted-sandbox/hosted-workspace-service-team-scope.test.ts new file mode 100644 index 00000000000..f04e821cfb3 --- /dev/null +++ b/src/main/hosted-sandbox/hosted-workspace-service-team-scope.test.ts @@ -0,0 +1,82 @@ +import { mkdtempSync, rmSync } from 'node:fs' +import { tmpdir } from 'node:os' +import { join } from 'node:path' +import { afterEach, describe, expect, it, vi } from 'vitest' +import { upsertEphemeralVmRuntime } from '../../shared/ephemeral-vm-runtime-store' +import type { EphemeralVmRuntimeRecord } from '../../shared/ephemeral-vm-runtimes' +import { HOSTED_SANDBOX_DRIVER_ID } from './hosted-sandbox-driver' +import type { HostedSandboxControlPlaneClient } from './hosted-sandbox-control-plane-client' + +const handlers = vi.hoisted(() => new Map unknown>()) +vi.mock('electron', () => ({ + app: { getPath: () => tmpdir() }, + BrowserWindow: {}, + ipcMain: { + handle: (channel: string, handler: (...args: unknown[]) => unknown) => + handlers.set(channel, handler), + removeHandler: (channel: string) => handlers.delete(channel) + } +})) + +const { installHostedWorkspaceService } = await import('./hosted-workspace-service') + +const dirs: string[] = [] +afterEach(() => { + handlers.clear() + for (const dir of dirs.splice(0)) { + rmSync(dir, { recursive: true, force: true }) + } +}) + +function record(id: string, cloudAccountId?: string): EphemeralVmRuntimeRecord { + return { + id, + recipeId: 'orca-cloud', + recipe: { id: 'orca-cloud', name: 'Orca Cloud', create: 'c', provider: 'orca-cloud' }, + workspaceId: `ws-${id}`, + runtimeEnvironmentId: `env-${id}`, + status: 'running', + cleanupStatus: 'not_started', + createdAt: 1, + updatedAt: 1, + ...(cloudAccountId ? { cloudAccountId } : {}), + recipeResult: { + schemaVersion: 1, + connection: { type: 'orca-server', pairingCode: 'code', projectRoot: '/p' }, + userData: { + environmentDriver: { + driverId: HOSTED_SANDBOX_DRIVER_ID, + environmentId: `sbx-${id}`, + driverState: { sandboxId: `sbx-${id}` } + } + } + } + } +} + +describe('hosted workspace service team scope', () => { + it("polls and lists only the active team's cloud workspaces", async () => { + const userDataPath = mkdtempSync(join(tmpdir(), 'orca-workspace-team-')) + dirs.push(userDataPath) + upsertEphemeralVmRuntime(userDataPath, record('mine', 'org:team-one')) + upsertEphemeralVmRuntime(userDataPath, record('other', 'org:team-two')) + upsertEphemeralVmRuntime(userDataPath, record('unfiled')) + const workspaceStatus = vi.fn(async (_sandboxId: string) => ({ status: { metrics: null } })) + // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: pollOom reads only workspaceStatus(). + const client = { workspaceStatus } as unknown as HostedSandboxControlPlaneClient + const service = installHostedWorkspaceService({ + userDataPath, + client, + windows: () => [], + syncSessions: () => {}, + stopSession: () => {}, + log: () => {}, + activeAccountId: () => 'org:team-one' + }) + + await service.pollOom() + expect(workspaceStatus.mock.calls.map(([sandboxId]) => sandboxId)).toEqual(['sbx-mine']) + const listIds = handlers.get('orcaCloudWorkspace:listIds') + expect(await listIds?.()).toEqual(['ws-mine']) + }) +}) diff --git a/src/main/hosted-sandbox/hosted-workspace-service.ts b/src/main/hosted-sandbox/hosted-workspace-service.ts index 5c01538b59d..b001469bbe6 100644 --- a/src/main/hosted-sandbox/hosted-workspace-service.ts +++ b/src/main/hosted-sandbox/hosted-workspace-service.ts @@ -2,11 +2,9 @@ // progress and OOM notices. Maps the renderer's workspace id to its Orca Cloud runtime record. import { failQueuedCloudPrompts } from './cloud-offline-seam' import { ipcMain, type BrowserWindow } from 'electron' +import { listTeamCloudRuntimes } from './orca-cloud-active-account' import { HOSTED_ACCOUNT_CHANNELS, registerHostedAccountHandlers } from './hosted-account-ipc' -import { - listEphemeralVmRuntimes, - updateEphemeralVmRuntimeStatus -} from '../../shared/ephemeral-vm-runtime-store' +import { updateEphemeralVmRuntimeStatus } from '../../shared/ephemeral-vm-runtime-store' import { ORCA_CLOUD_WORKSPACE_CHANNELS as CH, type CloudWakeProgressEvent, @@ -61,8 +59,13 @@ export function installHostedWorkspaceService(deps: { /** Stop the lease scheduler of one environment (its session is about to be replaced). */ stopSession: (environmentId: string) => void log?: (line: string) => void + /** The active team; OOM polling and the window's cloud ids skip every other team's sandbox. */ + activeAccountId?: () => string | null }): HostedWorkspaceService { const log = deps.log ?? ((line: string) => console.error(line)) + // Records this service reads on its own (not per a window's request) stay in the active team. + const activeCloudRuntimes = () => + listTeamCloudRuntimes(deps.userDataPath, deps.activeAccountId?.()) const wakeSources = new Map() // Wakes in flight per workspace, so every phase carries the source the first one named. const wakes = new Map() @@ -135,22 +138,13 @@ export function installHostedWorkspaceService(deps: { }, async pollOom() { const live = new Set( - listEphemeralVmRuntimes(deps.userDataPath) - .filter( - (runtime) => - runtime.recipe?.provider === 'orca-cloud' && - runtime.status === 'running' && - runtime.workspaceId - ) + activeCloudRuntimes() + .filter((runtime) => runtime.status === 'running' && runtime.workspaceId) .map((runtime) => findCloudRuntime(deps.userDataPath, runtime.workspaceId!)?.sandboxId) ) oom.prune(live) - for (const runtime of listEphemeralVmRuntimes(deps.userDataPath)) { - if ( - runtime.recipe?.provider !== 'orca-cloud' || - runtime.status !== 'running' || - !runtime.workspaceId - ) { + for (const runtime of activeCloudRuntimes()) { + if (runtime.status !== 'running' || !runtime.workspaceId) { continue } const found = findCloudRuntime(deps.userDataPath, runtime.workspaceId) @@ -182,8 +176,8 @@ export function installHostedWorkspaceService(deps: { service.dispose() ipcMain.handle(CH.listCloudWorkspaceIds, () => - listEphemeralVmRuntimes(deps.userDataPath) - .filter((runtime) => runtime.recipe?.provider === 'orca-cloud' && runtime.workspaceId) + activeCloudRuntimes() + .filter((runtime) => runtime.workspaceId) .map((runtime) => runtime.workspaceId!) ) diff --git a/src/main/hosted-sandbox/orca-cloud-active-account.ts b/src/main/hosted-sandbox/orca-cloud-active-account.ts new file mode 100644 index 00000000000..4486f0e2bf2 --- /dev/null +++ b/src/main/hosted-sandbox/orca-cloud-active-account.ts @@ -0,0 +1,36 @@ +import { listEphemeralVmRuntimes } from '../../shared/ephemeral-vm-runtime-store' +import type { EphemeralVmRuntimeRecord } from '../../shared/ephemeral-vm-runtimes' +import { isOrcaCloudRuntimeInAccount } from '../../shared/hosted-sandbox/orca-cloud-account' + +// The Orca Cloud account (team) this desktop acts for right now, in sandbox-control's form. Set by +// the hosted-sandbox install; builds without Orca Cloud have no resolver and no cloud records. +let resolver: (() => string | null) | null = null + +export function setOrcaCloudActiveAccountResolver(next: (() => string | null) | null): void { + resolver = next +} + +/** Null when signed out of Orca Cloud or when this build has no Orca Cloud. */ +export function readOrcaCloudActiveAccountId(): string | null { + try { + return resolver?.() ?? null + } catch { + // An unreadable profile index is "no team", which hides cloud records rather than misfiling them. + return null + } +} + +/** + * Orca Cloud records in the given team; `undefined` (no team scoping wired) keeps them all, while + * null (signed out) keeps none. + */ +export function listTeamCloudRuntimes( + userDataPath: string, + account: string | null | undefined +): EphemeralVmRuntimeRecord[] { + return listEphemeralVmRuntimes(userDataPath).filter( + (runtime) => + runtime.recipe?.provider === 'orca-cloud' && + (account === undefined || isOrcaCloudRuntimeInAccount(runtime, account)) + ) +} diff --git a/src/main/ipc/runtime-environments/runtime-environment-tailscale-response.ts b/src/main/ipc/runtime-environments/runtime-environment-tailscale-response.ts index 0982462832d..27a62db2d57 100644 --- a/src/main/ipc/runtime-environments/runtime-environment-tailscale-response.ts +++ b/src/main/ipc/runtime-environments/runtime-environment-tailscale-response.ts @@ -5,7 +5,8 @@ import { withRuntimeUnreachableHint } from './runtime-environment-unreachable-hi export function withTailscaleHintForResponse( response: RuntimeRpcResponse, endpoint: string, - environment: Pick + environment: Pick & + Partial> ): RuntimeRpcResponse { if (response.ok === true) { return response diff --git a/src/main/ipc/runtime-environments/runtime-environment-unreachable-hint.test.ts b/src/main/ipc/runtime-environments/runtime-environment-unreachable-hint.test.ts new file mode 100644 index 00000000000..73328b930f7 --- /dev/null +++ b/src/main/ipc/runtime-environments/runtime-environment-unreachable-hint.test.ts @@ -0,0 +1,21 @@ +import { describe, expect, it } from 'vitest' +import { withRuntimeUnreachableHint } from './runtime-environment-unreachable-hint' + +const FAILURE = 'Could not connect to the remote Orca runtime: socket closed.' +const ENDPOINT = 'wss://203.0.113.7:6768' + +describe('withRuntimeUnreachableHint', () => { + it('hints Tailscale for a paired server on another network', () => { + expect( + withRuntimeUnreachableHint({ name: 'desk', source: 'manual' }, FAILURE, ENDPOINT) + ).toMatch(/Tailscale/) + }) + + it('leaves an Orca Cloud sandbox failure without a Tailscale hint', () => { + const cloud = { + name: 'orca-sandbox-push-test sandbox 1a2b3c4d', + source: 'ephemeral-vm' as const + } + expect(withRuntimeUnreachableHint(cloud, FAILURE, ENDPOINT)).toBe(FAILURE) + }) +}) diff --git a/src/main/ipc/runtime-environments/runtime-environment-unreachable-hint.ts b/src/main/ipc/runtime-environments/runtime-environment-unreachable-hint.ts index 3b329ba1237..58b27c5aa93 100644 --- a/src/main/ipc/runtime-environments/runtime-environment-unreachable-hint.ts +++ b/src/main/ipc/runtime-environments/runtime-environment-unreachable-hint.ts @@ -1,15 +1,22 @@ import { withRemoteRuntimeTailscaleHint } from '../../../shared/remote-runtime/remote-runtime-tailscale-hint' import { classifyRuntimeEnvironmentHost } from '../../../shared/remote-runtime/host-catalog/runtime-environment-host-kind' import type { KnownRuntimeEnvironment } from '../../../shared/remote-runtime/host-catalog/runtime-environments' +import { isOrcaCloudRuntimeEnvironment } from '../../../shared/remote-runtime/host-catalog/orca-cloud-environment-name' const UNREACHABLE_RE = /could not connect to the remote orca runtime|remote orca runtime closed the connection|timed out (?:waiting for|while connecting to) the remote orca runtime/i export function withRuntimeUnreachableHint( - environment: Pick, + environment: Pick & + Partial>, message: string, endpoint: string | null | undefined ): string { + // Orca Cloud sandboxes are reached through Orca Cloud, not the user's network: one that does not + // answer is asleep, gone, or another team's, and a Tailscale hint sends the user the wrong way. + if (isOrcaCloudRuntimeEnvironment(environment)) { + return message + } const host = classifyRuntimeEnvironmentHost(environment) switch (host.kind) { case 'network': diff --git a/src/main/startup/main-window-core-services.ts b/src/main/startup/main-window-core-services.ts index 8df56bbb260..72b0dd15af0 100644 --- a/src/main/startup/main-window-core-services.ts +++ b/src/main/startup/main-window-core-services.ts @@ -29,6 +29,7 @@ import { import { isRecoveryReloadInFlight } from './main-window-lifecycle-flags' import { RELAY_HOST_CLOSE_REASON } from '../../shared/relay-host-close-reason' import { holdLaunchReconnectOptOuts } from '../ipc/ssh/ssh-host-user-disconnect' +import { syncHostedSessions } from '../hosted-sandbox/hosted-session-sync' export function attachMainWindowCoreServices( window: BrowserWindow, @@ -118,6 +119,8 @@ export function attachMainWindowCoreServices( void state.desktopRelayInstaller?.authChanged() state.desktopRelayService?.authMutated() desktopConnectorCloud()?.accountChanged() + // A team switch moves Orca Cloud to another account: stop keeping the old team's sandboxes alive. + syncHostedSessions() }, // Only sign-out fences paired phones; reasonless quit/relaunch must not look like logout. onBeforeOrcaProfileSignOut: () => { diff --git a/src/renderer/src/components/sidebar/worktree-list/listing/WorktreeList.tsx b/src/renderer/src/components/sidebar/worktree-list/listing/WorktreeList.tsx index a3a6335224c..979ed29b4be 100644 --- a/src/renderer/src/components/sidebar/worktree-list/listing/WorktreeList.tsx +++ b/src/renderer/src/components/sidebar/worktree-list/listing/WorktreeList.tsx @@ -9,6 +9,7 @@ import { } from '@/store/slices/worktrees/listing/use-worktree-catalog' import { useProjectHostSetupProjection } from '@/store/projects/use-project-host-setup-projection' import { useRepoMap } from '@/store/repos/use-repository-catalog' +import { useSidebarScopedRepos } from '@/lib/orca-cloud/use-sidebar-hidden-checkouts' import type { ProjectGroup } from '../../../../../../shared/project-group-types' import type { Repo } from '../../../../../../shared/repo-types' import { openHeaderCreateComposer } from '../rows/header-create-workspace-target' @@ -86,7 +87,8 @@ const WorktreeList = React.memo(function WorktreeList({ const allWorktrees = useAllWorktrees() const repoMap = useRepoMap() const worktreeMap = useWorktreeMap() - const repos = useAppStore((s) => s.repos) + // Another team's sandbox projects never get a header (or an empty-project placeholder). + const repos = useSidebarScopedRepos() const worktreeLineageById = useAppStore((s) => s.worktreeLineageById) const workspaceLineageByChildKey = useAppStore((s) => s.workspaceLineageByChildKey) const crossStoreChildrenByFolderId = useAppStore(selectCrossStoreFolderChildrenById) diff --git a/src/renderer/src/components/sidebar/worktree-list/listing/use-main-list-model.ts b/src/renderer/src/components/sidebar/worktree-list/listing/use-main-list-model.ts index 6c9fbe9abd5..df2c3b16de1 100644 --- a/src/renderer/src/components/sidebar/worktree-list/listing/use-main-list-model.ts +++ b/src/renderer/src/components/sidebar/worktree-list/listing/use-main-list-model.ts @@ -9,11 +9,8 @@ import { } from '@/lib/sidebar-pending-layer' import { useSidebarListSession } from '@/lib/sidebar-list-session' import { readEndedCreations, subscribeEndedCreations } from '@/lib/sidebar-ended-creations' -import { - readHiddenVmCheckouts, - subscribeHiddenVmCheckouts, - withoutHiddenVmCheckouts -} from '@/lib/vm-create-hidden-checkouts' +import { withoutHiddenVmCheckouts } from '@/lib/vm-create-hidden-checkouts' +import { useSidebarHiddenCheckouts } from '@/lib/orca-cloud/use-sidebar-hidden-checkouts' import '../../../../../../shared/folder-workspaces/folder-workspace-execution-host' import { getFolderWorkspaceHostId } from '../../../../../../shared/folder-workspaces/folder-workspace-host-id' import type { FolderWorkspace } from '../../../../../../shared/folder-workspaces/folder-workspace-types' @@ -78,7 +75,7 @@ export function useMainSidebarListModel(args: SidebarListModelArgs): SidebarList const feed = useDesktopSidebarFeed() const pending = useSyncExternalStore(subscribeSidebarPendingLayer, readSidebarPendingLayer) const endedCreationIds = useSyncExternalStore(subscribeEndedCreations, readEndedCreations) - const hiddenVmCheckouts = useSyncExternalStore(subscribeHiddenVmCheckouts, readHiddenVmCheckouts) + const hiddenVmCheckouts = useSidebarHiddenCheckouts() const pendingCreationKeys = useAppStore( useShallow((s) => selectPendingWorktreeCreationKeys(s.pendingWorktreeCreations)) ) diff --git a/src/renderer/src/components/sidebar/worktree-list/listing/use-visible-worktrees.ts b/src/renderer/src/components/sidebar/worktree-list/listing/use-visible-worktrees.ts index 9a83fe32d62..c33f953ca27 100644 --- a/src/renderer/src/components/sidebar/worktree-list/listing/use-visible-worktrees.ts +++ b/src/renderer/src/components/sidebar/worktree-list/listing/use-visible-worktrees.ts @@ -1,5 +1,5 @@ import { selectSidebarLineageParentIdentities } from '@/store/slices/worktrees/metadata/cross-store-lineage-parents' -import { useMemo, useState, useSyncExternalStore } from 'react' +import { useMemo, useState } from 'react' import { shallow } from 'zustand/shallow' import type { AppState } from '@/store/types' import { useAppStore } from '@/store' @@ -24,11 +24,8 @@ import type { SidebarWorktreeFilters } from './use-filters' import { useReusedArrayIdentity } from './use-reused-array-identity' import { useSleepingSweepRetention } from './use-sleeping-sweep-retention' import { selectWorktreesByRepo } from '@/store/workspaces/catalog/workspace-record-fields' -import { - readHiddenVmCheckouts, - subscribeHiddenVmCheckouts, - withoutHiddenVmWorktrees -} from '@/lib/vm-create-hidden-checkouts' +import { withoutHiddenVmWorktrees } from '@/lib/vm-create-hidden-checkouts' +import { useSidebarHiddenCheckouts } from '@/lib/orca-cloud/use-sidebar-hidden-checkouts' const EMPTY_WORKTREE_ID_SET: ReadonlySet = new Set() @@ -123,7 +120,7 @@ export function useVisibleSidebarWorktrees(args: { worktreeIdsWithStructuredChat }) - const hiddenVmCheckouts = useSyncExternalStore(subscribeHiddenVmCheckouts, readHiddenVmCheckouts) + const hiddenVmCheckouts = useSidebarHiddenCheckouts() const recomputedVisibleWorktrees = useMemo(() => { const visible = computeVisibleWorktrees(worktreesByRepo, sortedIds, { filterRepoIds, diff --git a/src/renderer/src/components/worktree-jump/use-worktree-jump-palette-store-state.ts b/src/renderer/src/components/worktree-jump/use-worktree-jump-palette-store-state.ts index fb5113b520b..0634ebd21c2 100644 --- a/src/renderer/src/components/worktree-jump/use-worktree-jump-palette-store-state.ts +++ b/src/renderer/src/components/worktree-jump/use-worktree-jump-palette-store-state.ts @@ -1,4 +1,4 @@ -import { useMemo, useSyncExternalStore } from 'react' +import { useMemo } from 'react' import { useTranslation } from 'react-i18next' import { useShallow } from 'zustand/react/shallow' import { useAppStore } from '@/store/index' @@ -6,11 +6,11 @@ import { usePluginCommands } from '@/store/plugins/catalog/plugin-contribution-c import { usePluginNewFiles } from '@/store/plugins/file-creation/plugin-new-files' import { useSettingsNavigationMetadata } from '@/hooks/useSettingsNavigationMetadata' import { dedupePaletteWorktrees } from '@/lib/workspace/search/palette-repo-resolution' +import { withoutHiddenVmWorktreesByRepo } from '@/lib/vm-create-hidden-checkouts' import { - readHiddenVmCheckouts, - subscribeHiddenVmCheckouts, - withoutHiddenVmWorktreesByRepo -} from '@/lib/vm-create-hidden-checkouts' + useSidebarHiddenCheckouts, + withoutHiddenHostRepos +} from '@/lib/orca-cloud/use-sidebar-hidden-checkouts' import { selectPaletteIndexStatusSnapshot, selectPaletteStatusInputs @@ -42,14 +42,19 @@ export function useWorktreeJumpPaletteStoreState({ const recordFeatureInteraction = useAppStore((state) => state.recordFeatureInteraction) const revealSidebarRow = useAppStore((state) => state.revealSidebarRow) const storedWorktreesByRepo = useAppStore((state) => selectWorktreesByRepo(state)) - const hiddenVmCheckouts = useSyncExternalStore(subscribeHiddenVmCheckouts, readHiddenVmCheckouts) - // Why: a VM create's checkout is not a workspace until the create adopts it. + const storedRepos = useAppStore((state) => state.repos) + const hiddenVmCheckouts = useSidebarHiddenCheckouts() + // Why: a VM create's checkout is not a workspace until the create adopts it; a cloud clone beside + // its workspace is redundant, and another team's sandbox is out of scope. const worktreesByRepo = useMemo( () => withoutHiddenVmWorktreesByRepo(storedWorktreesByRepo, hiddenVmCheckouts), [storedWorktreesByRepo, hiddenVmCheckouts] ) const folderWorkspaces = useAppStore((state) => selectFolderWorkspaces(state)) - const repos = useAppStore((state) => state.repos) + const repos = useMemo( + () => withoutHiddenHostRepos(storedRepos, hiddenVmCheckouts), + [storedRepos, hiddenVmCheckouts] + ) const projectGroups = useAppStore((state) => state.projectGroups) const workspaces = useMemo( () => diff --git a/src/renderer/src/hooks/ipc-events/app-lifetime-ipc-bridge.ts b/src/renderer/src/hooks/ipc-events/app-lifetime-ipc-bridge.ts index 9ad502bc3af..c8a8975ebfc 100644 --- a/src/renderer/src/hooks/ipc-events/app-lifetime-ipc-bridge.ts +++ b/src/renderer/src/hooks/ipc-events/app-lifetime-ipc-bridge.ts @@ -19,6 +19,7 @@ import { registerBrowserStateIpcBridge } from './browser-state-ipc-bridge' import { registerContentCreationIpcBridge } from './content-creation-ipc-bridge' import { registerDirectSshStateIpcBridge } from './direct-ssh-state-ipc-bridge' import { registerEphemeralVmLifecycleIpcBridge } from './ephemeral-vm-lifecycle-ipc-bridge' +import { installLeaveOutOfTeamCloudWorkspace } from '@/lib/orca-cloud/leave-out-of-team-cloud-workspace' import { registerMobileAndTerminalCloseIpcBridge } from './mobile-terminal-close-ipc-bridge' import { registerMobileDriverIpcBridge } from './mobile-driver-ipc-bridge' import { registerOrcaProfileAuthIpcBridge } from './orca-profile-auth-ipc-bridge' @@ -93,6 +94,8 @@ export function installAppLifetimeIpcEvents(): () => void { registerBackgroundWorktreeRemovalBridge(unsubs) registerWslHostIpcBridge(unsubs) registerEphemeralVmLifecycleIpcBridge(unsubs) + // After a team switch, the old team's open cloud workspace leaves the main pane. + unsubs.push(installLeaveOutOfTeamCloudWorkspace(useAppStore)) registerProjectCatalogIpcBridge( unsubs, worktreeRuntime.worktreeChangeRefreshQueue, diff --git a/src/renderer/src/lib/orca-cloud/leave-out-of-team-cloud-workspace.test.ts b/src/renderer/src/lib/orca-cloud/leave-out-of-team-cloud-workspace.test.ts new file mode 100644 index 00000000000..e0e8c415ec1 --- /dev/null +++ b/src/renderer/src/lib/orca-cloud/leave-out-of-team-cloud-workspace.test.ts @@ -0,0 +1,90 @@ +import { describe, expect, it, vi } from 'vitest' +import type { AppState } from '@/store/types' +import { installLeaveOutOfTeamCloudWorkspace } from './leave-out-of-team-cloud-workspace' + +const environments = [ + { id: 'cusk', name: 'push-test sandbox 1a2b3c4d', source: 'ephemeral-vm' }, + { id: 'otter', name: 'push-test sandbox 5e6f7a8b', source: 'ephemeral-vm' } +] +const owners = { cusk: 'org:team-one', otter: 'org:team-two' } + +type State = Parameters[0] extends { + getState: () => infer S +} + ? S + : never + +function harness(initial: { activeHost: string | null; activeOrgId?: string }) { + const setActiveWorktree = vi.fn((id: string | null) => { + state = { ...state, activeWorktreeId: id, activeWorkspaceExecutionHostId: null } + }) + // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the observer reads only these fields. + let state = { + activeWorktreeId: initial.activeHost ? 'repo::/w/cusk' : null, + activeWorkspaceExecutionHostId: initial.activeHost, + folderWorkspaces: [], + projectGroups: [], + repos: [], + runtimeEnvironments: environments, + cloudAccountIdByEnvironmentId: owners, + orcaProfileAuthStatus: initial.activeOrgId + ? { cloud: { userId: 'u1', activeOrgId: initial.activeOrgId } } + : null, + setActiveWorktree + } as unknown as State + const listeners = new Set<(next: State) => void>() + const store = { + getState: () => state, + subscribe: (listener: (next: State) => void) => { + listeners.add(listener) + return () => listeners.delete(listener) + } + } + installLeaveOutOfTeamCloudWorkspace(store) + const set = (patch: Partial): void => { + // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: test patches only fields the observer reads. + state = { ...state, ...patch } as State + listeners.forEach((listener) => listener(state)) + } + return { set, setActiveWorktree, active: () => state.activeWorktreeId } +} + +function team(activeOrgId: string): Partial { + // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: only `cloud` is read. + return { orcaProfileAuthStatus: { cloud: { userId: 'u1', activeOrgId } } } as Partial +} + +describe('leaving an out-of-team cloud workspace', () => { + it('moves off the open cloud workspace when its team is switched away', () => { + const h = harness({ activeHost: 'runtime:cusk', activeOrgId: 'team-one' }) + h.set(team('team-two')) + expect(h.setActiveWorktree).toHaveBeenCalledWith(null) + expect(h.setActiveWorktree).toHaveBeenCalledTimes(1) + expect(h.active()).toBeNull() + }) + + it('moves off it on sign-out too', () => { + const h = harness({ activeHost: 'runtime:cusk', activeOrgId: 'team-one' }) + // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: only `cloud` is read. + h.set({ orcaProfileAuthStatus: null } as Partial) + expect(h.active()).toBeNull() + }) + + it('stays on a local workspace, or on the cloud workspace of the team switched to', () => { + const local = harness({ activeHost: 'local', activeOrgId: 'team-one' }) + local.set(team('team-two')) + expect(local.setActiveWorktree).not.toHaveBeenCalled() + + const otter = harness({ activeHost: 'runtime:otter', activeOrgId: 'team-one' }) + otter.set(team('team-two')) + expect(otter.setActiveWorktree).not.toHaveBeenCalled() + }) + + it('keeps a restored cloud workspace while the team and runtimes are still loading', () => { + // Launch: no auth status yet, so every sandbox reads as out of scope until it loads. + const h = harness({ activeHost: 'runtime:cusk' }) + h.set(team('team-one')) + expect(h.setActiveWorktree).not.toHaveBeenCalled() + expect(h.active()).toBe('repo::/w/cusk') + }) +}) diff --git a/src/renderer/src/lib/orca-cloud/leave-out-of-team-cloud-workspace.ts b/src/renderer/src/lib/orca-cloud/leave-out-of-team-cloud-workspace.ts new file mode 100644 index 00000000000..c0498a4933c --- /dev/null +++ b/src/renderer/src/lib/orca-cloud/leave-out-of-team-cloud-workspace.ts @@ -0,0 +1,68 @@ +import type { AppState } from '@/store/types' +import { workspaceOwnerHostId } from '@/lib/workspace/ownership/workspace-row-owner-host' +import { + parseOrcaCloudHostScopeKey, + selectOrcaCloudHostScopeKey +} from './use-sidebar-hidden-checkouts' + +type LeaveState = Pick< + AppState, + | 'activeWorktreeId' + | 'activeWorkspaceExecutionHostId' + | 'folderWorkspaces' + | 'projectGroups' + | 'repos' + | 'runtimeEnvironments' + | 'setActiveWorktree' +> & + Partial> + +function activeHostId(state: LeaveState): string | null { + if (!state.activeWorktreeId) { + return null + } + // The host-qualified selection first: a cloud project and its local twin share repo ids. + return state.activeWorkspaceExecutionHostId ?? workspaceOwnerHostId(state, state.activeWorktreeId) +} + +/** + * The active workspace's host just left the active team's scope: it was the team's a moment ago + * and now is not (a team or account switch). Only that edge counts, so a launch whose team or + * runtimes are still loading never drops a restored cloud workspace. + */ +export function activeCloudWorkspaceLeftTeam( + previousScopeKey: string, + nextScopeKey: string, + hostId: string | null +): boolean { + if (!hostId || previousScopeKey === nextScopeKey) { + return false + } + return ( + parseOrcaCloudHostScopeKey(previousScopeKey).primaryHostIds.has(hostId) && + parseOrcaCloudHostScopeKey(nextScopeKey).hiddenHostIds.has(hostId) + ) +} + +/** + * Why: a team switch hides the old team's sandboxes from every list, but the main pane kept + * showing the one that was open. Move off it as a host removal does (no active workspace, the + * empty landing). Its terminals stay: the sandbox is still the old team's to come back to. + */ +export function installLeaveOutOfTeamCloudWorkspace(store: { + getState: () => LeaveState + subscribe: (listener: (state: LeaveState) => void) => () => void +}): () => void { + let scopeKey = selectOrcaCloudHostScopeKey(store.getState()) + return store.subscribe((state) => { + const next = selectOrcaCloudHostScopeKey(state) + if (next === scopeKey) { + return + } + const previous = scopeKey + scopeKey = next + if (activeCloudWorkspaceLeftTeam(previous, next, activeHostId(state))) { + state.setActiveWorktree(null) + } + }) +} diff --git a/src/renderer/src/lib/orca-cloud/use-sidebar-hidden-checkouts.test.ts b/src/renderer/src/lib/orca-cloud/use-sidebar-hidden-checkouts.test.ts new file mode 100644 index 00000000000..5233fda403b --- /dev/null +++ b/src/renderer/src/lib/orca-cloud/use-sidebar-hidden-checkouts.test.ts @@ -0,0 +1,71 @@ +import { describe, expect, it } from 'vitest' +import type { AppState } from '@/store/types' +import { EMPTY_PENDING_VM_CHECKOUT_INDEX } from '../../../../shared/pending-vm-checkouts' +import { withOrcaCloudHosts } from '@/lib/vm-create-hidden-checkouts' +import { + parseOrcaCloudHostScopeKey, + selectOrcaCloudHostScopeKey, + withoutHiddenHostRepos +} from './use-sidebar-hidden-checkouts' + +const environments = [ + { id: 'a', name: 'push-test sandbox 1a2b3c4d', source: 'ephemeral-vm' }, + { id: 'b', name: 'push-test sandbox 5e6f7a8b', source: 'ephemeral-vm' }, + { id: 'unfiled', name: 'push-test sandbox 9c0d1e2f', source: 'ephemeral-vm' }, + { id: 'vm', name: 'my recipe VM', source: 'ephemeral-vm' }, + { id: 'manual', name: 'push-test sandbox 1a2b3c4d', source: 'manual' } +] +// Sandbox a is team one's, b is team two's; `unfiled` has no team recorded yet. +const owners = { a: 'org:team-one', b: 'org:team-two' } + +function scopeFor(activeOrgId: string | undefined) { + // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the selector reads only these fields. + const state = { + runtimeEnvironments: environments, + cloudAccountIdByEnvironmentId: owners, + orcaProfileAuthStatus: { cloud: { userId: 'u1', ...(activeOrgId ? { activeOrgId } : {}) } } + } as unknown as Pick + const { primaryHostIds, hiddenHostIds } = parseOrcaCloudHostScopeKey( + selectOrcaCloudHostScopeKey(state) + ) + return { primary: [...primaryHostIds], hidden: [...hiddenHostIds] } +} + +describe('Orca Cloud host scope', () => { + it("lists the active team's sandboxes and hides the other team's and unfiled ones", () => { + expect(scopeFor('team-one')).toEqual({ + primary: ['runtime:a'], + hidden: ['runtime:b', 'runtime:unfiled'] + }) + }) + + it('flips with a team switch', () => { + expect(scopeFor('team-two')).toEqual({ + primary: ['runtime:b'], + hidden: ['runtime:a', 'runtime:unfiled'] + }) + }) + + it('hides every sandbox when signed out of Orca Cloud', () => { + // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the selector reads only these fields. + const signedOut = { + runtimeEnvironments: environments, + cloudAccountIdByEnvironmentId: owners, + orcaProfileAuthStatus: null + } as unknown as Pick + expect( + parseOrcaCloudHostScopeKey(selectOrcaCloudHostScopeKey(signedOut)).primaryHostIds.size + ).toBe(0) + }) + + it("drops another team's sandbox project so it never gets its own header", () => { + const local = { id: 'r', executionHostId: 'local' as const } + const mine = { id: 'r', executionHostId: 'runtime:a' as const } + const theirs = { id: 'otter', executionHostId: 'runtime:b' as const } + const scope = withOrcaCloudHosts(EMPTY_PENDING_VM_CHECKOUT_INDEX, { + primaryHostIds: new Set(['runtime:a']), + hiddenHostIds: new Set(['runtime:b']) + }) + expect(withoutHiddenHostRepos([local, mine, theirs], scope)).toEqual([local, mine]) + }) +}) diff --git a/src/renderer/src/lib/orca-cloud/use-sidebar-hidden-checkouts.ts b/src/renderer/src/lib/orca-cloud/use-sidebar-hidden-checkouts.ts new file mode 100644 index 00000000000..b8a0c8dc1d0 --- /dev/null +++ b/src/renderer/src/lib/orca-cloud/use-sidebar-hidden-checkouts.ts @@ -0,0 +1,77 @@ +import { useMemo, useSyncExternalStore } from 'react' +import { useAppStore } from '@/store' +import type { AppState } from '@/store/types' +import { + readHiddenVmCheckouts, + subscribeHiddenVmCheckouts, + withOrcaCloudHosts, + type HiddenVmCheckouts +} from '@/lib/vm-create-hidden-checkouts' +import { getRepoExecutionHostId, toRuntimeExecutionHostId } from '../../../../shared/execution-host' +import { orcaCloudAccountId } from '../../../../shared/hosted-sandbox/orca-cloud-account' +import { isOrcaCloudRuntimeEnvironment } from '../../../../shared/remote-runtime/host-catalog/orca-cloud-environment-name' +import type { Repo } from '../../../../shared/repo-types' + +type CloudScopeState = Pick & + Partial> + +/** + * Every Orca Cloud server, `+host` when the active team owns it and `-host` otherwise (another + * team's, or one whose team is not known yet). Newline-joined so the selector compares by value. + */ +export function selectOrcaCloudHostScopeKey(state: CloudScopeState): string { + const active = orcaCloudAccountId(state.orcaProfileAuthStatus?.cloud) + const owners = state.cloudAccountIdByEnvironmentId ?? {} + return (state.runtimeEnvironments ?? []) + .filter((environment) => isOrcaCloudRuntimeEnvironment(environment)) + .map((environment) => { + const inTeam = active !== null && owners[environment.id] === active + return `${inTeam ? '+' : '-'}${toRuntimeExecutionHostId(environment.id)}` + }) + .join('\n') +} + +export function parseOrcaCloudHostScopeKey(key: string): { + primaryHostIds: ReadonlySet + hiddenHostIds: ReadonlySet +} { + const primaryHostIds = new Set() + const hiddenHostIds = new Set() + for (const entry of key ? key.split('\n') : []) { + ;(entry.startsWith('+') ? primaryHostIds : hiddenHostIds).add(entry.slice(1)) + } + return { primaryHostIds, hiddenHostIds } +} + +/** + * What sidebar lists hide: VM checkouts whose create is in progress, an Orca Cloud clone beside its + * listed workspace, and every row of another team's sandbox. + */ +export function useSidebarHiddenCheckouts(): HiddenVmCheckouts { + const pending = useSyncExternalStore(subscribeHiddenVmCheckouts, readHiddenVmCheckouts) + const scopeKey = useAppStore(selectOrcaCloudHostScopeKey) + return useMemo( + () => withOrcaCloudHosts(pending, parseOrcaCloudHostScopeKey(scopeKey)), + [pending, scopeKey] + ) +} + +/** Repos without another team's sandbox projects, so none surfaces as its own project header. */ +export function withoutHiddenHostRepos>( + repos: readonly R[], + checkouts: HiddenVmCheckouts +): readonly R[] { + const hidden = checkouts.hiddenHostIds + if (!hidden?.size) { + return repos + } + const kept = repos.filter((repo) => !hidden.has(getRepoExecutionHostId(repo))) + return kept.length === repos.length ? repos : kept +} + +/** The store's repos scoped like the sidebar's rows (useSidebarHiddenCheckouts). */ +export function useSidebarScopedRepos(): readonly Repo[] { + const repos = useAppStore((state) => state.repos) + const hidden = useSidebarHiddenCheckouts() + return useMemo(() => withoutHiddenHostRepos(repos, hidden), [repos, hidden]) +} diff --git a/src/renderer/src/lib/vm-create-hidden-checkouts.test.ts b/src/renderer/src/lib/vm-create-hidden-checkouts.test.ts index d56214a7ef6..50d449bc701 100644 --- a/src/renderer/src/lib/vm-create-hidden-checkouts.test.ts +++ b/src/renderer/src/lib/vm-create-hidden-checkouts.test.ts @@ -1,13 +1,16 @@ import { afterEach, describe, expect, it, vi } from 'vitest' import { EMPTY_SIDEBAR_FEED_DOMAINS } from '../../../shared/sidebar-feed-client/sidebar-feed-snapshot' import type { SidebarFeedDomains } from '../../../shared/sidebar-list/sidebar-feed-domains' +import { composeWorktreeHostIdentity } from '../../../shared/worktree/host-qualified-identity' import { hideVmCreateCheckout, readHiddenVmCheckouts, releaseVmCreateCheckout, settleVmCreateCheckoutAfterCleanup, + withOrcaCloudHosts, withoutHiddenVmCheckouts, - withoutHiddenVmWorktrees + withoutHiddenVmWorktrees, + withoutHiddenVmWorktreesByRepo } from './vm-create-hidden-checkouts' type Row = { repoId: string; path: string; isMainWorktree?: boolean } @@ -78,3 +81,78 @@ describe('hidden VM checkout lifecycle', () => { expect(isListed('vm')).toBe(true) }) }) + +describe('Orca Cloud sandboxes', () => { + // Two cloud workspaces of one project: each sandbox lists its clone (master) as primary. + const hostA = 'runtime:sandbox-a' + const hostB = 'runtime:sandbox-b' + const hostC = 'runtime:sandbox-c' + const otherTeam = 'runtime:sandbox-other-team' + const clone = (hostId: string) => ({ + repoId: 'r', + path: '/vercel/sandbox/project', + isMainWorktree: true, + hostId + }) + const sockeye = { repoId: 'r', path: '/w/sockeye', isMainWorktree: false, hostId: hostA } + const otter = { repoId: 'r', path: '/w/otter', isMainWorktree: false, hostId: hostB } + const local = { repoId: 'r', path: '/Users/me/repo', isMainWorktree: true, hostId: 'local' } + const scoped = (hiddenHostIds: string[] = []) => + withOrcaCloudHosts(readHiddenVmCheckouts(), { + primaryHostIds: new Set([hostA, hostB, hostC]), + hiddenHostIds: new Set(hiddenHostIds) + }) + + it('lists one row per cloud workspace across two sandboxes and no clone rows', () => { + const rows = [local, clone(hostA), clone(hostB), sockeye, otter] + const listed = withoutHiddenVmWorktrees(rows, scoped()) + + expect(listed).toEqual([local, sockeye, otter]) + expect(listed.filter((row) => row.hostId !== 'local' && row.isMainWorktree)).toEqual([]) + expect(withoutHiddenVmWorktreesByRepo({ r: rows }, scoped())).toEqual({ + r: [local, sockeye, otter] + }) + }) + + it("hides a sandbox's clone even when it is that sandbox's only row", () => { + expect(withoutHiddenVmWorktrees([local, clone(hostC)], scoped())).toEqual([local]) + }) + + it("leaves this computer's primary checkout alone", () => { + const rows = [local] + expect(withoutHiddenVmWorktrees(rows, scoped())).toBe(rows) + }) + + it("hides every row of another team's sandbox, and leaves local rows alone", () => { + const foreign = { repoId: 'r', path: '/w/x', isMainWorktree: false, hostId: otherTeam } + const rows = [local, clone(otherTeam), foreign, clone(hostA), sockeye] + expect(withoutHiddenVmWorktrees(rows, scoped([otherTeam]))).toEqual([local, sockeye]) + }) + + it("reads a paired-server row's host from its host-qualified key", () => { + const strip = ({ hostId: _hostId, ...row }: T) => row + const rowS = strip(sockeye) + // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the filter reads only repoId, path, isMainWorktree and the keys. + const domains = { + ...EMPTY_SIDEBAR_FEED_DOMAINS, + pairedServerRows: new Map([ + [composeWorktreeHostIdentity(hostA, 'r::/vercel/sandbox/project'), strip(clone(hostA))], + [composeWorktreeHostIdentity(hostA, 'r::/w/sockeye'), rowS], + [composeWorktreeHostIdentity(hostC, 'r::/vercel/sandbox/project'), strip(clone(hostC))], + [composeWorktreeHostIdentity(otherTeam, 'r::/w/x'), rowS] + ]) + } as unknown as SidebarFeedDomains + const filtered = withoutHiddenVmCheckouts(domains, scoped([otherTeam])) + + expect([...filtered.pairedServerRows.values()]).toEqual([rowS]) + }) + + it('leaves lists untouched when no Orca Cloud host is known', () => { + const rows = [local, clone(hostA)] + const none = withOrcaCloudHosts(readHiddenVmCheckouts(), { + primaryHostIds: new Set(), + hiddenHostIds: new Set() + }) + expect(withoutHiddenVmWorktrees(rows, none)).toBe(rows) + }) +}) diff --git a/src/renderer/src/lib/vm-create-hidden-checkouts.ts b/src/renderer/src/lib/vm-create-hidden-checkouts.ts index 6faf4a20a90..e1c9b2f4d01 100644 --- a/src/renderer/src/lib/vm-create-hidden-checkouts.ts +++ b/src/renderer/src/lib/vm-create-hidden-checkouts.ts @@ -1,4 +1,5 @@ import type { SidebarFeedDomains } from '../../../shared/sidebar-list/sidebar-feed-domains' +import { getExecutionHostIdFromWorktreeHostIdentity } from '../../../shared/worktree/host-qualified-identity' import { indexPendingVmCheckouts, isPendingVmCheckout, @@ -8,10 +9,58 @@ import { /** A VM's primary checkout, registered on its host before the create that owns it finishes. */ export type HiddenVmCheckout = PendingVmCheckout -type CheckoutRow = { repoId: string; path: string; isMainWorktree?: boolean } +type CheckoutRow = { + repoId: string + path: string + isMainWorktree?: boolean + hostId?: string +} -/** What lists filter by: this window's pending VM checkouts and every other window's. */ -export type HiddenVmCheckouts = PendingVmCheckoutIndex +/** + * What lists filter by: this window's pending VM checkouts and every other window's, plus the + * Orca Cloud hosts lists scope (withOrcaCloudHosts). + */ +export type HiddenVmCheckouts = PendingVmCheckoutIndex & { + /** Active-team Orca Cloud hosts: their primary checkout (the sandbox's clone) never lists. */ + readonly primaryHostIds?: ReadonlySet + /** Orca Cloud hosts of another team, or of no team we can resolve: every row hides. */ + readonly hiddenHostIds?: ReadonlySet +} + +/** + * Why: each Orca Cloud workspace is its own sandbox whose clone is registered as the project there, + * and the workspace is a worktree beside it (orca-worktree mode). That clone is scaffolding, not a + * workspace: listed, every cloud workspace added another identical " primary ยท + * Orca Cloud" row to its project. Another team's sandbox lists nothing at all. + */ +export function withOrcaCloudHosts( + checkouts: HiddenVmCheckouts, + hosts: { primaryHostIds: ReadonlySet; hiddenHostIds: ReadonlySet } +): HiddenVmCheckouts { + return hosts.primaryHostIds.size === 0 && hosts.hiddenHostIds.size === 0 + ? checkouts + : { ...checkouts, primaryHostIds: hosts.primaryHostIds, hiddenHostIds: hosts.hiddenHostIds } +} + +function hidesNothing(checkouts: HiddenVmCheckouts): boolean { + return ( + checkouts.keys.size === 0 && !checkouts.primaryHostIds?.size && !checkouts.hiddenHostIds?.size + ) +} + +function isHiddenCheckout( + checkouts: HiddenVmCheckouts, + row: CheckoutRow, + hostId: string | undefined = row.hostId +): boolean { + if (hostId && checkouts.hiddenHostIds?.has(hostId)) { + return true + } + if (row.isMainWorktree === true && hostId && checkouts.primaryHostIds?.has(hostId)) { + return true + } + return checkouts.keys.size > 0 && isPendingVmCheckout(checkouts, row) +} // Upper bound for a cleaned-up VM's rows to leave the lists (its host is retired asynchronously). const HIDDEN_AFTER_CLEANUP_MS = 60_000 @@ -131,28 +180,31 @@ export function readHiddenVmCheckouts(): HiddenVmCheckouts { return hidden } -/** The window's sidebar list without the primary checkouts of VMs whose creates are in progress. */ +/** The window's sidebar list without hidden VM checkouts, cloud clones and other teams' sandboxes. */ export function withoutHiddenVmWorktrees( worktrees: W[], checkouts: HiddenVmCheckouts ): W[] { - if (checkouts.keys.size === 0) { + if (hidesNothing(checkouts)) { return worktrees } - const kept = worktrees.filter((worktree) => !isPendingVmCheckout(checkouts, worktree)) + const kept = worktrees.filter((worktree) => !isHiddenCheckout(checkouts, worktree)) return kept.length === worktrees.length ? worktrees : kept } -/** Per-repo lists without pending VM checkouts; the same object when nothing matches. */ +/** Per-repo lists without hidden checkouts; the same object when nothing matches. */ export function withoutHiddenVmWorktreesByRepo( worktreesByRepo: Record, checkouts: HiddenVmCheckouts ): Record { - if (checkouts.keys.size === 0) { + if (hidesNothing(checkouts)) { return worktreesByRepo } + const hostScoped = Boolean(checkouts.primaryHostIds?.size || checkouts.hiddenHostIds?.size) let next: Record | null = null - for (const repoId of checkouts.repoIds) { + // Host-scoped rows can sit under any repo; pending checkouts only under theirs. + const repoIds = hostScoped ? Object.keys(worktreesByRepo) : checkouts.repoIds + for (const repoId of repoIds) { const list = worktreesByRepo[repoId] if (!list) { continue @@ -166,13 +218,15 @@ export function withoutHiddenVmWorktreesByRepo( return next ?? worktreesByRepo } -function withoutHiddenRows( +function withoutHiddenRows( rows: ReadonlyMap, checkouts: HiddenVmCheckouts ): ReadonlyMap { let kept: Map | null = null for (const [key, row] of rows) { - if (isPendingVmCheckout(checkouts, row)) { + // Paired-server rows carry their host only in the host-qualified key. + const hostId = row.hostId ?? getExecutionHostIdFromWorktreeHostIdentity(key) + if (isHiddenCheckout(checkouts, row, hostId)) { kept ??= new Map(rows) kept.delete(key) } @@ -180,12 +234,12 @@ function withoutHiddenRows( return kept ?? rows } -/** Main's rows without the primary checkouts of VMs whose creates are still in progress. */ +/** Main's rows without hidden VM checkouts, cloud clones and other teams' sandboxes. */ export function withoutHiddenVmCheckouts( domains: SidebarFeedDomains, checkouts: HiddenVmCheckouts ): SidebarFeedDomains { - if (checkouts.keys.size === 0) { + if (hidesNothing(checkouts)) { return domains } const workspaces = withoutHiddenRows(domains.workspaces, checkouts) diff --git a/src/renderer/src/store/slices/ephemeral-vm/ephemeral-vm-lifecycle.ts b/src/renderer/src/store/slices/ephemeral-vm/ephemeral-vm-lifecycle.ts index 58a4de8049f..21c29db1cee 100644 --- a/src/renderer/src/store/slices/ephemeral-vm/ephemeral-vm-lifecycle.ts +++ b/src/renderer/src/store/slices/ephemeral-vm/ephemeral-vm-lifecycle.ts @@ -39,6 +39,8 @@ function environmentBuildIdOf(record: EphemeralVmRuntimeRecord): string | undefi export type EphemeralVmLifecycleSlice = { /** Live (not cleaned up) VM runtimes by the workspace they back. */ ephemeralVmRuntimesByWorkspaceId: Record + /** Live Orca Cloud runtimes' owning team by runtime environment; unfiled ones are absent. */ + cloudAccountIdByEnvironmentId: Record /** Workspaces whose VM resume is in flight; the record only flips when it finishes. */ wakingEphemeralVmWorkspaceIds: Record refreshEphemeralVmRuntimes: () => Promise @@ -99,6 +101,29 @@ export function projectEphemeralVmWorkspaceRuntimes( return byWorkspaceId } +/** Which team owns each live Orca Cloud server, so lists can scope to the active team. */ +export function projectCloudAccountsByEnvironment( + records: readonly EphemeralVmRuntimeRecord[] +): Record { + const byEnvironment: Record = {} + for (const record of records) { + if ( + record.recipe?.provider === 'orca-cloud' && + record.runtimeEnvironmentId && + record.cloudAccountId && + !RETIRED_STATUSES.has(record.status) + ) { + byEnvironment[record.runtimeEnvironmentId] = record.cloudAccountId + } + } + return byEnvironment +} + +function sameAccounts(a: Record, b: Record): boolean { + const keys = Object.keys(a) + return keys.length === Object.keys(b).length && keys.every((key) => a[key] === b[key]) +} + function sameRuntimes( a: Record, b: Record @@ -133,6 +158,7 @@ export const createEphemeralVmLifecycleSlice: StateCreator< EphemeralVmLifecycleSlice > = (set) => ({ ephemeralVmRuntimesByWorkspaceId: {}, + cloudAccountIdByEnvironmentId: {}, wakingEphemeralVmWorkspaceIds: {}, refreshEphemeralVmRuntimes: () => { const listRuntimes = window.api?.ephemeralVm?.listRuntimes @@ -141,17 +167,24 @@ export const createEphemeralVmLifecycleSlice: StateCreator< } const sequence = ++refreshSequence const refresh = (async (): Promise => { - const next = projectEphemeralVmWorkspaceRuntimes(await listRuntimes()) + const records = await listRuntimes() + const next = projectEphemeralVmWorkspaceRuntimes(records) + const accounts = projectCloudAccountsByEnvironment(records) // Out-of-order replies must not roll a newer lifecycle status back; a superseded caller // settles with the newer read, so it never acts on a store that has not caught up. if (sequence !== refreshSequence) { return latestRefresh } - set((state) => - sameRuntimes(state.ephemeralVmRuntimesByWorkspaceId, next) + set((state) => { + const runtimesSame = sameRuntimes(state.ephemeralVmRuntimesByWorkspaceId, next) + const accountsSame = sameAccounts(state.cloudAccountIdByEnvironmentId ?? {}, accounts) + return runtimesSame && accountsSame ? state - : { ephemeralVmRuntimesByWorkspaceId: next } - ) + : { + ...(runtimesSame ? {} : { ephemeralVmRuntimesByWorkspaceId: next }), + ...(accountsSame ? {} : { cloudAccountIdByEnvironmentId: accounts }) + } + }) })() latestRefresh = refresh return refresh diff --git a/src/shared/ephemeral-vm-runtime-store.ts b/src/shared/ephemeral-vm-runtime-store.ts index 608a2f9a046..fd0fa218cac 100644 --- a/src/shared/ephemeral-vm-runtime-store.ts +++ b/src/shared/ephemeral-vm-runtime-store.ts @@ -164,6 +164,7 @@ export function updateEphemeralVmRuntimeStatus( : args.sshTargetId ? { sshTargetId: args.sshTargetId } : {}), + ...(args.cloudAccountId ? { cloudAccountId: args.cloudAccountId } : {}), ...(args.recipeResult ? { recipeResult: args.recipeResult } : {}), updatedAt: args.updatedAt ?? Date.now() }) diff --git a/src/shared/ephemeral-vm-runtimes.ts b/src/shared/ephemeral-vm-runtimes.ts index 7afc9f38f9e..37ee91ae670 100644 --- a/src/shared/ephemeral-vm-runtimes.ts +++ b/src/shared/ephemeral-vm-runtimes.ts @@ -61,6 +61,11 @@ export const EphemeralVmRuntimeRecordSchema = z.object({ connectionMode: EphemeralVmRuntimeConnectionModeSchema.optional(), runtimeEnvironmentId: z.string().min(1).optional(), sshTargetId: z.string().min(1).optional(), + /** + * Orca Cloud only: the control-plane account that owns the sandbox (`org:` or `user:`, + * see orcaCloudAccountId). Lists and keep-alive scope to the active team by it; absent until known. + */ + cloudAccountId: z.string().min(1).max(256).optional(), status: EphemeralVmRuntimeStatusSchema, cleanupStatus: EphemeralVmCleanupStatusSchema, cleanupDisabled: z.boolean().optional(), @@ -114,6 +119,7 @@ export type EphemeralVmRuntimeStatusPatch = { connectionMode?: EphemeralVmRuntimeRecord['connectionMode'] | null runtimeEnvironmentId?: string sshTargetId?: string | null + cloudAccountId?: string recipeResult?: EphemeralVmRuntimeRecord['recipeResult'] updatedAt?: number } diff --git a/src/shared/hosted-sandbox/orca-cloud-account.ts b/src/shared/hosted-sandbox/orca-cloud-account.ts new file mode 100644 index 00000000000..98b967022a2 --- /dev/null +++ b/src/shared/hosted-sandbox/orca-cloud-account.ts @@ -0,0 +1,27 @@ +import type { EphemeralVmRuntimeRecord } from '../ephemeral-vm-runtimes' + +/** + * The control-plane account a sandbox token acts for, in sandbox-control's own form + * (cloud/apps/sandbox-control/src/auth.ts accountIdFor): the selected team pays for its members, + * otherwise the user is the account. The token is minted for the profile's active org, so + * `activeOrgId` and the token's `org` claim are the same id. + */ +export function orcaCloudAccountId( + cloud: { userId?: string | null; activeOrgId?: string | null } | null | undefined +): string | null { + if (cloud?.activeOrgId) { + return `org:${cloud.activeOrgId}` + } + return cloud?.userId ? `user:${cloud.userId}` : null +} + +/** + * Whether an Orca Cloud runtime belongs to the active team. A record whose team is unknown (or no + * team is signed in) is not: another team's sandbox must never be listed or kept alive. + */ +export function isOrcaCloudRuntimeInAccount( + runtime: Pick, + activeAccountId: string | null +): boolean { + return activeAccountId !== null && runtime.cloudAccountId === activeAccountId +}