mirror of
https://github.com/stablyai/orca.git
synced 2026-11-19 04:23:57 +00:00
* feat(wsl): serve saved WSL work behind a closed hosts gate (serve-only) The WSL hosts gate gains three states. A closed gate with a saved WSL host or a committed move becomes serve-only: saved hosts stay listed and reachable, committed rewrites, retention, interrupted-move recovery and the way back keep running, and the preload API is exposed through a stamped window argument. Adding hosts and starting moves still need the open gate. With nothing saved the gate stays closed exactly as before. * fix(wsl): stamp serve-only into the dashboard popout and Space windows too They load the same preload, so without the argument they hid saved WSL hosts' status and Connect in serve-only. One helper now supplies the argument for every window on the shared preload. * fix(wsl): reviewer follow-ups for the serve-only gate - Refuse wslHosts:add unless the internal gate is open here, so this PR is safe on its own. - Promote on any move journal entry, so recovery can reset an in-flight move whose host record is gone. - List unfinished moves in serve-only. - An unreadable WSL deployment store fails closed in serve-only too, through a shared serving flag main sets at startup. - Report the gate state in wsl_usage_snapshot as an optional field.
359 lines
14 KiB
TypeScript
359 lines
14 KiB
TypeScript
import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
|
|
import { tmpdir } from 'node:os'
|
|
import { join } from 'node:path'
|
|
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
|
|
import { encodePairingOffer } from './pairing'
|
|
import {
|
|
addManagedOrcadEnvironment,
|
|
recordManagedOrcadMigration
|
|
} from './runtime-environment-managed-orcad-store'
|
|
import {
|
|
getRuntimeEnvironmentSidecarPath,
|
|
overlayRuntimeEnvironmentSidecar,
|
|
readRuntimeEnvironmentSidecar
|
|
} from './runtime-environment-sidecar'
|
|
import {
|
|
addEnvironmentFromPairingCode,
|
|
getEnvironmentStorePath,
|
|
listEnvironments,
|
|
markEnvironmentUsed
|
|
} from './runtime-environment-store'
|
|
import {
|
|
readPersistedEnvironmentStore,
|
|
RuntimeEnvironmentStoreError,
|
|
writeEnvironmentStore
|
|
} from './runtime-environment-store-file'
|
|
import { RuntimeEnvironmentStoreSchema } from './runtime-environments'
|
|
import {
|
|
getWslHostDeploymentStorePath,
|
|
readWslHostDeployments,
|
|
writeWslHostDeployment,
|
|
WslHostDeploymentStoreInvalidError,
|
|
type WslHostDeploymentRecord
|
|
} from './wsl-host-deployment-store'
|
|
import { noteWslHostsServeOnly, WSL_HOSTS_INTERNAL_GATE_ENV } from './wsl-host-internal-gate'
|
|
|
|
const pairing = {
|
|
v: 2 as const,
|
|
publicKeyB64: Buffer.alloc(32, 1).toString('base64'),
|
|
deviceToken: 'private-device-token'
|
|
}
|
|
const WSL_PAIRING_KEY = Buffer.alloc(32, 2).toString('base64')
|
|
const sshTunnel = {
|
|
sshTargetId: 'target',
|
|
sshTargetGeneration: 3,
|
|
localPort: 41000,
|
|
remotePort: 6768
|
|
}
|
|
|
|
function wslRecord(overrides: Partial<WslHostDeploymentRecord> = {}): WslHostDeploymentRecord {
|
|
return {
|
|
kind: 'wsl',
|
|
environmentId: 'wsl-ubuntu',
|
|
distro: 'Ubuntu-24.04',
|
|
distroId: '0e3a7f2c-1b4d-4c5e-9f60-7a8b9c0d1e2f',
|
|
localPort: 42000,
|
|
remotePort: 6769,
|
|
createdAt: 200,
|
|
...overrides
|
|
}
|
|
}
|
|
|
|
describe('WSL host deployment store', () => {
|
|
let userDataPath: string
|
|
beforeEach(() => {
|
|
userDataPath = mkdtempSync(join(tmpdir(), 'orca-wsl-host-deployments-'))
|
|
vi.spyOn(console, 'warn').mockImplementation(() => {})
|
|
})
|
|
afterEach(() => {
|
|
vi.restoreAllMocks()
|
|
vi.unstubAllEnvs()
|
|
rmSync(userDataPath, { recursive: true, force: true })
|
|
})
|
|
|
|
function addSshManaged() {
|
|
return addManagedOrcadEnvironment(userDataPath, {
|
|
id: 'ssh-managed',
|
|
name: 'Build box',
|
|
pairingCode: encodePairingOffer({ ...pairing, endpoint: 'ws://127.0.0.1:41000/runtime' }),
|
|
orcadDeployment: sshTunnel,
|
|
now: 100
|
|
})
|
|
}
|
|
|
|
// Keep the pairing store readable by older builds.
|
|
function addWslManaged(record = wslRecord()) {
|
|
const environment = addEnvironmentFromPairingCode(userDataPath, {
|
|
name: 'Ubuntu',
|
|
// Each pairing key identifies one server; duplicate keys are rejected.
|
|
pairingCode: encodePairingOffer({
|
|
...pairing,
|
|
publicKeyB64: WSL_PAIRING_KEY,
|
|
endpoint: `ws://127.0.0.1:${record.localPort}/runtime`
|
|
}),
|
|
now: 150
|
|
})
|
|
writeWslHostDeployment(userDataPath, environment.id, {
|
|
...record,
|
|
environmentId: environment.id
|
|
})
|
|
return environment.id
|
|
}
|
|
|
|
function bytes(path: string): string {
|
|
return readFileSync(path, 'utf8')
|
|
}
|
|
|
|
it('leaves an SSH-only profile byte-for-byte unchanged across a read and rewrite', () => {
|
|
addSshManaged()
|
|
recordManagedOrcadMigration(userDataPath, 'ssh-managed', '2026-10-01T00:00:00.000Z')
|
|
const storePath = getEnvironmentStorePath(userDataPath)
|
|
const sidecarPath = getRuntimeEnvironmentSidecarPath(userDataPath)
|
|
const before = { store: bytes(storePath), sidecar: bytes(sidecarPath) }
|
|
|
|
const [environment] = listEnvironments(userDataPath)
|
|
expect(environment?.orcadDeployment).toEqual(sshTunnel)
|
|
writeEnvironmentStore(userDataPath, readPersistedEnvironmentStore(userDataPath))
|
|
recordManagedOrcadMigration(userDataPath, 'ssh-managed', '2026-10-01T00:00:00.000Z')
|
|
|
|
expect({ store: bytes(storePath), sidecar: bytes(sidecarPath) }).toEqual(before)
|
|
expect(before.sidecar).not.toContain('"kind"')
|
|
expect(existsSync(getWslHostDeploymentStorePath(userDataPath))).toBe(false)
|
|
})
|
|
|
|
it('overlays a WSL deployment as a managed server without touching the shared files', () => {
|
|
addSshManaged()
|
|
const storeBefore = bytes(getEnvironmentStorePath(userDataPath))
|
|
const sidecarBefore = bytes(getRuntimeEnvironmentSidecarPath(userDataPath))
|
|
const wslId = addWslManaged()
|
|
|
|
const byId = new Map(listEnvironments(userDataPath).map((entry) => [entry.id, entry]))
|
|
expect(byId.get('ssh-managed')?.orcadDeployment).toEqual(sshTunnel)
|
|
const { environmentId: _id, createdAt: _at, ...link } = wslRecord()
|
|
expect(byId.get(wslId)).toMatchObject({ orcadDeployment: link })
|
|
expect(byId.get(wslId)?.connectionDependency).toBeUndefined()
|
|
expect(bytes(getRuntimeEnvironmentSidecarPath(userDataPath))).toBe(sidecarBefore)
|
|
expect(bytes(getEnvironmentStorePath(userDataPath))).not.toContain('wsl')
|
|
expect(storeBefore).not.toContain('wsl')
|
|
})
|
|
|
|
describe('downgrade to builds that never read the WSL file', () => {
|
|
it('keeps every environment readable by a build that rejects the whole store on one bad record', () => {
|
|
addSshManaged()
|
|
const wslId = addWslManaged()
|
|
|
|
// Builds before the per-record store parsed orca-environments.json whole.
|
|
const strict = RuntimeEnvironmentStoreSchema.parse(
|
|
JSON.parse(bytes(getEnvironmentStorePath(userDataPath)))
|
|
)
|
|
expect(strict.environments.map((entry) => entry.id).sort()).toEqual(
|
|
['ssh-managed', wslId].sort()
|
|
)
|
|
expect(Object.keys(readRuntimeEnvironmentSidecar(userDataPath).unreadable)).toEqual([])
|
|
})
|
|
|
|
it("keeps SSH servers managed under main's reader, which sees the WSL server as a plain pairing", () => {
|
|
addSshManaged()
|
|
const wslId = addWslManaged()
|
|
|
|
const sidecar = readRuntimeEnvironmentSidecar(userDataPath)
|
|
const mainView = readPersistedEnvironmentStore(userDataPath).environments.map((entry) =>
|
|
overlayRuntimeEnvironmentSidecar(entry, sidecar.entries[entry.id])
|
|
)
|
|
const byId = new Map(mainView.map((entry) => [entry.id, entry]))
|
|
expect(byId.get('ssh-managed')?.orcadDeployment).toEqual(sshTunnel)
|
|
expect(byId.get(wslId)?.orcadDeployment).toBeUndefined()
|
|
})
|
|
|
|
it('keeps the WSL deployment after an older build rewrites the store', () => {
|
|
addSshManaged()
|
|
const wslId = addWslManaged()
|
|
// An older build's routine write: parse, strip unknown keys, rewrite.
|
|
const path = getEnvironmentStorePath(userDataPath)
|
|
writeFileSync(
|
|
path,
|
|
JSON.stringify(RuntimeEnvironmentStoreSchema.parse(JSON.parse(bytes(path))), null, 2)
|
|
)
|
|
markEnvironmentUsed(userDataPath, wslId, { now: 10_000 })
|
|
|
|
expect(listEnvironments(userDataPath).find((entry) => entry.id === wslId)).toMatchObject({
|
|
orcadDeployment: { kind: 'wsl', distro: 'Ubuntu-24.04' }
|
|
})
|
|
})
|
|
})
|
|
|
|
describe('records this build cannot read', () => {
|
|
const futureKind = { kind: 'hyperv', environmentId: 'future', vmName: 'dev', createdAt: 1 }
|
|
const corrupt = { kind: 'wsl', environmentId: 'broken', distro: 'not a name!' }
|
|
const anonymous = { note: 'no environment id' }
|
|
|
|
function seed(...records: unknown[]): string {
|
|
const path = getWslHostDeploymentStorePath(userDataPath)
|
|
writeFileSync(path, JSON.stringify({ version: 1, deployments: records }))
|
|
return path
|
|
}
|
|
|
|
it('rewrites unknown records verbatim and in place when another record changes', () => {
|
|
const extended = { ...wslRecord({ environmentId: 'extended' }), futureField: { x: 1 } }
|
|
const path = seed(futureKind, extended, corrupt, anonymous)
|
|
|
|
writeWslHostDeployment(userDataPath, 'new', wslRecord({ environmentId: 'new' }))
|
|
writeWslHostDeployment(
|
|
userDataPath,
|
|
'new',
|
|
wslRecord({ environmentId: 'new', remotePort: 7000 })
|
|
)
|
|
|
|
expect(JSON.parse(bytes(path)).deployments).toEqual([
|
|
futureKind,
|
|
extended,
|
|
corrupt,
|
|
anonymous,
|
|
wslRecord({ environmentId: 'new', remotePort: 7000 })
|
|
])
|
|
writeWslHostDeployment(userDataPath, 'new', null)
|
|
expect(JSON.parse(bytes(path)).deployments).toEqual([
|
|
futureKind,
|
|
extended,
|
|
corrupt,
|
|
anonymous
|
|
])
|
|
})
|
|
|
|
it('hides the environment an unreadable record owns and refuses to replace that record', () => {
|
|
vi.stubEnv(WSL_HOSTS_INTERNAL_GATE_ENV, '1')
|
|
addSshManaged()
|
|
const wslId = addWslManaged()
|
|
const future = { ...futureKind, environmentId: wslId }
|
|
seed(future)
|
|
|
|
expect(readWslHostDeployments(userDataPath).unreadableEnvironmentIds).toEqual(
|
|
new Set([wslId])
|
|
)
|
|
expect(listEnvironments(userDataPath).map((entry) => entry.id)).toEqual(['ssh-managed'])
|
|
expect(() => writeWslHostDeployment(userDataPath, wslId, null)).toThrow(
|
|
WslHostDeploymentStoreInvalidError
|
|
)
|
|
expect(JSON.parse(bytes(getWslHostDeploymentStorePath(userDataPath))).deployments).toEqual([
|
|
future
|
|
])
|
|
})
|
|
|
|
it('treats two records for one environment as unreadable', () => {
|
|
seed(wslRecord(), wslRecord({ remotePort: 7000 }))
|
|
expect(readWslHostDeployments(userDataPath)).toEqual({
|
|
deployments: [],
|
|
unreadableEnvironmentIds: new Set(['wsl-ubuntu'])
|
|
})
|
|
})
|
|
|
|
it('fails closed when the file itself is corrupt and WSL hosts are enabled', () => {
|
|
vi.stubEnv(WSL_HOSTS_INTERNAL_GATE_ENV, '1')
|
|
addSshManaged()
|
|
writeFileSync(getWslHostDeploymentStorePath(userDataPath), '{"version":1,"deployments":{}}')
|
|
expect(() => listEnvironments(userDataPath)).toThrow(RuntimeEnvironmentStoreError)
|
|
expect(() => writeWslHostDeployment(userDataPath, 'x', null)).toThrow(
|
|
WslHostDeploymentStoreInvalidError
|
|
)
|
|
})
|
|
|
|
it('fails closed when the file itself is corrupt in serve-only too', () => {
|
|
vi.stubEnv(WSL_HOSTS_INTERNAL_GATE_ENV, '')
|
|
noteWslHostsServeOnly(true)
|
|
try {
|
|
addSshManaged()
|
|
writeFileSync(getWslHostDeploymentStorePath(userDataPath), '{"version":1,"deployments":{}}')
|
|
expect(() => listEnvironments(userDataPath)).toThrow(RuntimeEnvironmentStoreError)
|
|
} finally {
|
|
noteWslHostsServeOnly(false)
|
|
}
|
|
})
|
|
|
|
it('keeps every other server listed when the file is corrupt and the gate is closed', () => {
|
|
vi.stubEnv(WSL_HOSTS_INTERNAL_GATE_ENV, '')
|
|
addSshManaged()
|
|
writeFileSync(getWslHostDeploymentStorePath(userDataPath), '{"version":1,"deployments":{}}')
|
|
expect(listEnvironments(userDataPath).map((entry) => entry.id)).toEqual(['ssh-managed'])
|
|
})
|
|
|
|
it('hides nothing for an unreadable record while the gate is closed', () => {
|
|
vi.stubEnv(WSL_HOSTS_INTERNAL_GATE_ENV, '')
|
|
const wslId = addWslManaged()
|
|
seed({ ...futureKind, environmentId: wslId })
|
|
expect(listEnvironments(userDataPath).map((entry) => entry.id)).toEqual([wslId])
|
|
})
|
|
|
|
it('never hides a remote paired server behind an unreadable WSL record', () => {
|
|
const remote = addEnvironmentFromPairingCode(userDataPath, {
|
|
name: 'Remote',
|
|
pairingCode: encodePairingOffer({
|
|
...pairing,
|
|
publicKeyB64: Buffer.alloc(32, 3).toString('base64'),
|
|
endpoint: 'wss://build.example.com/runtime'
|
|
}),
|
|
now: 150
|
|
})
|
|
seed({ ...futureKind, environmentId: remote.id })
|
|
expect(listEnvironments(userDataPath).map((entry) => entry.id)).toEqual([remote.id])
|
|
})
|
|
|
|
it('never hides an SSH-managed server behind an unreadable WSL record', () => {
|
|
addSshManaged()
|
|
seed({ ...futureKind, environmentId: 'ssh-managed' })
|
|
expect(listEnvironments(userDataPath)[0]?.orcadDeployment).toEqual(sshTunnel)
|
|
})
|
|
})
|
|
|
|
it('ignores a stale record whose port no longer matches the pairing', () => {
|
|
const wslId = addWslManaged()
|
|
writeWslHostDeployment(
|
|
userDataPath,
|
|
wslId,
|
|
wslRecord({ environmentId: wslId, localPort: 43000 })
|
|
)
|
|
const [environment] = listEnvironments(userDataPath)
|
|
expect(environment?.id).toBe(wslId)
|
|
expect(environment?.orcadDeployment).toBeUndefined()
|
|
})
|
|
|
|
it('ignores a record written for another server re-paired under the same id and port', () => {
|
|
const wslId = addWslManaged(
|
|
wslRecord({ pairingPublicKeyB64: Buffer.alloc(32, 3).toString('base64') })
|
|
)
|
|
const [environment] = listEnvironments(userDataPath)
|
|
expect(environment?.id).toBe(wslId)
|
|
expect(environment?.orcadDeployment).toBeUndefined()
|
|
})
|
|
|
|
it('overlays a record bound to the pairing key (keyless records keep port-only binding)', () => {
|
|
addWslManaged(wslRecord({ pairingPublicKeyB64: WSL_PAIRING_KEY }))
|
|
expect(listEnvironments(userDataPath)[0]?.orcadDeployment).toEqual({
|
|
kind: 'wsl',
|
|
distro: 'Ubuntu-24.04',
|
|
distroId: '0e3a7f2c-1b4d-4c5e-9f60-7a8b9c0d1e2f',
|
|
localPort: 42000,
|
|
remotePort: 6769
|
|
})
|
|
})
|
|
|
|
it('ignores a WSL record on a server that already has an SSH deployment', () => {
|
|
addSshManaged()
|
|
writeWslHostDeployment(
|
|
userDataPath,
|
|
'ssh-managed',
|
|
wslRecord({ environmentId: 'ssh-managed', localPort: 41000 })
|
|
)
|
|
expect(listEnvironments(userDataPath)[0]?.orcadDeployment).toEqual(sshTunnel)
|
|
})
|
|
|
|
it('rejects a record written under another environment id or with an invalid distro', () => {
|
|
expect(() => writeWslHostDeployment(userDataPath, 'other', wslRecord())).toThrow()
|
|
expect(() =>
|
|
writeWslHostDeployment(userDataPath, 'wsl-ubuntu', wslRecord({ distro: 'Ubuntu 24.04' }))
|
|
).toThrow()
|
|
expect(() =>
|
|
writeWslHostDeployment(userDataPath, 'wsl-ubuntu', wslRecord({ distroId: '{ABC}' }))
|
|
).toThrow()
|
|
})
|
|
})
|