fix(runtime): revoke forked keys with their pairing (#37771)

* fix(runtime): revoke forked keys with their pairing

Fixes #37749

* test(runtime): fix revocation fixture expiration
This commit is contained in:
Kelvin Amoaba
2026-11-03 18:25:39 +00:00
committed by GitHub
parent 865b9544ae
commit 2b2d4aeff8
9 changed files with 465 additions and 68 deletions
@@ -326,26 +326,43 @@ describe('pairing.delegatedMobileDevice.sync', () => {
expect(registry.listDelegatedMobileDevices(desktop.pairedDeviceId!)).toHaveLength(1)
})
it('keeps the parent when a child cleanup cannot be saved', async () => {
const { server, registry } = await startServer()
const desktop = pairDesktop(server)
const [child] = await sync(desktop, [{ phoneKey: 'p', name: 'p' }])
expect(
server.setMobileRelayBinding(child!.deviceId, {
relayHostId: 'host',
relayDeviceId: child!.deviceId,
ownerIdentityKey: 'owner'
it.each(['bearer', 'fork'] as const)(
'keeps the ancestors when a %s child cleanup cannot be saved',
async (kind) => {
const { server, registry } = await startServer()
const desktop = pairDesktop(server)
const parent =
kind === 'fork'
? registry.forkDeviceKey(
desktop.pairedDeviceId!,
Buffer.alloc(32, 7).toString('base64'),
'Fork'
)
: registry.getDevice(desktop.pairedDeviceId!)!
const [child] = registry.upsertDelegatedMobileDevices(parent, [{ phoneKey: 'p', name: 'p' }])
expect(
server.setMobileRelayBinding(child!.deviceId, {
relayHostId: 'host',
relayDeviceId: child!.deviceId,
ownerIdentityKey: 'owner'
})
).toBe(true)
const enqueue = vi.spyOn(server.getRelayRevokeOutbox(), 'enqueue').mockImplementation(() => {
throw new Error('disk full')
})
).toBe(true)
const enqueue = vi.spyOn(server.getRelayRevokeOutbox(), 'enqueue').mockImplementation(() => {
throw new Error('disk full')
})
cleanups.push(() => enqueue.mockRestore())
cleanups.push(() => enqueue.mockRestore())
expect(server.revokeRuntimeAccess(desktop.pairedDeviceId!)).toBe(false)
expect(registry.getDevice(desktop.pairedDeviceId!)).not.toBeNull()
expect(registry.getDevice(child!.deviceId)).not.toBeNull()
})
expect(server.revokeRuntimeAccess(desktop.pairedDeviceId!)).toBe(false)
expect(registry.getDevice(desktop.pairedDeviceId!)).not.toBeNull()
expect(registry.getDevice(parent.deviceId)).not.toBeNull()
expect(registry.getDevice(child!.deviceId)).not.toBeNull()
enqueue.mockRestore()
expect(server.revokeRuntimeAccess(desktop.pairedDeviceId!)).toBe(true)
expect(registry.getDevice(parent.deviceId)).toBeNull()
expect(registry.getDevice(child!.deviceId)).toBeNull()
}
)
it('fails a sync whose dropped child cannot be revoked, keeping that child', async () => {
const { server, registry } = await startServer()
+26 -9
View File
@@ -44,6 +44,7 @@ export type DeviceKeyLookup =
| { kind: 'unknown' }
// An unusable key is not revocation evidence.
| { kind: 'not-keyed' }
| { kind: 'refused' }
| { kind: 'unavailable' }
// Only unscanned token rows are rotatable pairing offers; keyed rows never are.
@@ -59,13 +60,19 @@ export function sameGrants(entry: DeviceEntry, grants: readonly RuntimeDeviceGra
}
// Clients erase keys on unknown; reserve that verdict for readable absence.
export function lookupDeviceKeyRow(device: DeviceEntry | null): DeviceKeyLookup {
export function lookupDeviceKeyRow(
device: DeviceEntry | null,
devices: readonly DeviceEntry[]
): DeviceKeyLookup {
if (!device) {
return { kind: 'unknown' }
}
return device.credentialKind === 'device-key' && device.devicePublicKeyB64
if (device.credentialKind !== 'device-key' || !device.devicePublicKeyB64) {
return { kind: 'not-keyed' }
}
return withPairedParent(device, devices)
? { kind: 'found', device: { ...device, devicePublicKeyB64: device.devicePublicKeyB64 } }
: { kind: 'not-keyed' }
: { kind: 'refused' }
}
export type AuthenticatedPrincipalBinding = {
@@ -86,15 +93,25 @@ export function isStillAuthenticated(
)
}
/** A delegated child authenticates only while its parent desktop is still paired. */
// Forks and delegated phones lose authority with any ancestor pairing.
function withPairedParent(
device: DeviceEntry,
devices: readonly DeviceEntry[]
devices: readonly DeviceEntry[],
ancestors = new Set<string>()
): DeviceEntry | null {
const { parentDeviceId } = device
return parentDeviceId === undefined || devices.some((d) => d.deviceId === parentDeviceId)
? device
: null
if (ancestors.has(device.deviceId)) {
return null
}
ancestors.add(device.deviceId)
const paired = [device.parentDeviceId, device.forkedFrom].every((parentId) => {
if (parentId === undefined) {
return true
}
const parent = devices.find((candidate) => candidate.deviceId === parentId)
return parent !== undefined && withPairedParent(parent, devices, ancestors) !== null
})
ancestors.delete(device.deviceId)
return paired ? device : null
}
export function findTokenDevice(
@@ -75,4 +75,44 @@ describe('delegated phone auth follows its parent desktop', () => {
expect(registry.validateToken(phone.token)?.deviceId).toBe(phone.deviceId)
})
it.each(['mobile', 'runtime'] as const)(
'refuses a %s fork and its delegated phones after the bearer parent disappears on disk',
(scope) => {
const registry = new DeviceRegistry(dir)
const parent = registry.addDevice('Parent', scope)
registry.updateLastSeen(parent.deviceId)
const fork = registry.forkDeviceKey(
parent.deviceId,
Buffer.alloc(32, 1).toString('base64'),
'Migrated installation'
)
const children =
scope === 'runtime'
? registry.upsertDelegatedMobileDevices(fork, [{ phoneKey: 'phone', name: 'Pixel' }])
: []
const principal = { deviceId: fork.deviceId, credentialRevision: 0 }
expect(registry.lookupDeviceKey(fork.deviceId)).toMatchObject({ kind: 'found' })
expect(registry.resolveAuthenticatedPrincipal(principal)?.deviceId).toBe(fork.deviceId)
for (const child of children) {
expect(registry.validateToken(child.token)?.deviceId).toBe(child.deviceId)
}
removeOnDisk(parent.deviceId)
expect(registry.lookupDeviceKey(fork.deviceId)).toEqual({ kind: 'refused' })
expect(registry.resolveAuthenticatedPrincipal(principal)).toBeNull()
for (const child of children) {
expect(registry.validateToken(child.token)).toBeNull()
expect(
registry.resolveAuthenticatedPrincipal({
deviceId: child.deviceId,
credentialRevision: 0,
deviceToken: child.token
})
).toBeNull()
}
expect(registry.getDevice(fork.deviceId)).not.toBeNull()
}
)
})
+1 -1
View File
@@ -209,7 +209,7 @@ export class DeviceRegistry {
// Clients erase keys on unknown; reserve that verdict for readable absence.
lookupDeviceKey(deviceId: string): DeviceKeyLookup {
this.adoptExternalEdits()
const lookup = lookupDeviceKeyRow(this.getDevice(deviceId))
const lookup = lookupDeviceKeyRow(this.getDevice(deviceId), this.devices)
return lookup.kind === 'unknown' && (this.registryUnreadable || this.registryDoubtful)
? { kind: 'unavailable' }
: lookup
@@ -138,6 +138,15 @@ describe('device-key authentication (host)', () => {
deviceProofB64: sign(otherKey, 'register', other.transcriptHashB64)
})
expect(otherFork.deviceId).not.toBe(forked.deviceId)
registry.rotatePendingDevice('New QR', 'mobile')
expect(
connect((keyedHash) => ({
deviceId: forked.deviceId,
deviceProofB64: sign(key, 'auth', keyedHash)
})).reply
).toMatchObject({ type: 'e2ee_authenticated' })
expect(registry.validateToken(legacy.token)?.deviceId).toBe(legacy.deviceId)
})
it('refuses a keyed row presented with a token, a replayed proof and a wrong-purpose proof', () => {
@@ -204,6 +213,14 @@ describe('device-key authentication (host)', () => {
type: 'e2ee_error',
error: { code: 'unauthorized' }
})
registry.removeDevice(legacy.deviceId)
for (const metadata of [undefined, relay(legacy.deviceId)]) {
expect(harness(registry, metadata).connect(keyAuth).reply).toEqual({
type: 'e2ee_error',
error: { code: 'unauthorized' }
})
}
})
it('answers registry_unavailable, never device_revoked, after loading a corrupt registry', () => {
@@ -54,6 +54,7 @@ function registryFor(
token: string,
scope: 'mobile' | 'runtime' = 'mobile'
): DeviceRegistry {
// oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: transport tests use only credential lookups and last-seen writes.
return {
validateToken: (candidate: string) =>
candidate === token
@@ -66,6 +67,10 @@ function registryFor(
lastSeenAt: 0
}
: null,
resolveAuthenticatedPrincipal: (principal: { deviceId: string; deviceToken?: string }) =>
principal.deviceId === deviceId && principal.deviceToken === token
? { deviceId, token, name: 'Phone', scope, pairedAt: 1, lastSeenAt: 0 }
: null,
updateLastSeen: vi.fn(),
updateLastSeenDeferred: vi.fn()
} as unknown as DeviceRegistry
@@ -175,6 +175,12 @@ export class MobileSocketWiring {
message: MobileSocketPayload,
metadata: MobileSocketTransportMetadata
): void {
const socket = this.authenticatedSockets.get(ws)
if (socket && !this.deviceRegistry.resolveAuthenticatedPrincipal(socket.device)) {
ws.close(4001, 'Unauthorized')
this.handleClose(ws)
return
}
let channel = this.channels.get(ws)
if (!channel) {
const connectionId = randomBytes(8).toString('hex')
@@ -1,12 +1,24 @@
import type * as WorktreeScanCacheModule from '../git/worktrees/catalog/worktree-scan-cache'
import type * as WorktreeListingModule from '../git/worktrees/catalog/worktree-listing'
import { mkdtempSync } from 'node:fs'
import { mkdtempSync, readFileSync, writeFileSync } from 'node:fs'
import { tmpdir } from 'node:os'
import { join } from 'node:path'
import { describe, expect, it, vi } from 'vitest'
import nacl from 'tweetnacl'
import { encodeDeviceProofMessage } from '../../shared/device-key-proof'
import { SimulatedMobileE2EEV2Peer } from './mobile-cloud-relay/simulated-mobile-e2ee-v2-peer'
import { OrcaRuntimeService } from './orca-runtime'
import { DeviceRegistry } from './device-registry'
import { DEVICE_REGISTRY_FILENAME } from './mobile-pairing-files'
import { makeStore } from './runtime-rpc-worktree-store-fixtures'
import { partialRuntimeStore } from './runtime-store-partial-fixture'
import {
TerminalStreamOpcode,
encodeTerminalStreamFrame,
encodeTerminalStreamText
} from '../../shared/terminal-stream-protocol'
import { OrcaRuntimeRpcServer } from './runtime-rpc'
import { parsePairingCode } from '../../shared/pairing'
import { encodePairingOffer, parsePairingCode, type PairingOffer } from '../../shared/pairing'
import { generateKeyPair } from '../../shared/e2ee-crypto'
import { waitFor } from './runtime-rpc-test-harness'
import {
@@ -52,6 +64,37 @@ const { getWorktreeListingMocks } = vi.hoisted(() => {
return { getWorktreeListingMocks: () => (listings ??= createWorktreeListingMocks()) }
})
async function authenticateKeyedWs(offer: PairingOffer, deviceId: string, key: nacl.SignKeyPair) {
const ws = await connectWs(offer.endpoint)
const peer = new SimulatedMobileE2EEV2Peer(
nacl.box.keyPair(),
Uint8Array.from(Buffer.from(offer.publicKeyB64, 'base64')),
null
)
ws.send(JSON.stringify(peer.hello))
expect(peer.acceptReady(JSON.parse(await nextWsMessage(ws)))).toBe(true)
const transcriptHashB64 = peer.transcriptHashB64
const proof = nacl.sign.detached(
encodeDeviceProofMessage('auth', Buffer.from(transcriptHashB64, 'base64')),
key.secretKey
)
ws.send(
peer.sealText(
JSON.stringify({
type: 'e2ee_auth',
v: 2,
transcriptHashB64,
deviceId,
deviceProofB64: Buffer.from(proof).toString('base64')
})
)
)
expect(JSON.parse(peer.openText(await nextWsMessage(ws))!)).toMatchObject({
type: 'e2ee_authenticated'
})
return { ws, peer }
}
describe('OrcaRuntimeRpcServer', () => {
it('cleans up pre-auth E2EE WebSocket state when the socket closes', async () => {
const userDataPath = mkdtempSync(join(tmpdir(), 'orca-runtime-rpc-'))
@@ -209,4 +252,249 @@ describe('OrcaRuntimeRpcServer', () => {
await server.stop()
}
}, 15_000)
it.each([
['mobile', false],
['runtime', false],
['mobile', true]
] as const)(
'revoking a %s bearer, removed on disk %s, removes descendants and closes their sockets',
async (scope, removedOnDisk) => {
const userDataPath = mkdtempSync(join(tmpdir(), 'orca-fork-revoke-'))
const server = new OrcaRuntimeRpcServer({
runtime: new OrcaRuntimeService(),
userDataPath,
enableWebSocket: true,
wsPort: 0
})
await server.start()
try {
const offer = server.createPairingOffer({ address: '127.0.0.1', name: 'Parent', scope })
if (!offer.available) {
throw new Error('WebSocket pairing unavailable')
}
const parsed = parsePairingCode(offer.pairingUrl)!
const parentSocket = await authenticateMobileWs(offer.pairingUrl)
const registry = server.getDeviceRegistry()!
const key = nacl.sign.keyPair()
const fork = registry.forkDeviceKey(
offer.deviceId,
Buffer.from(key.publicKey).toString('base64'),
'Fork'
)
const idleFork = registry.forkDeviceKey(
offer.deviceId,
Buffer.alloc(32, 9).toString('base64'),
'Offline fork'
)
const { ws: forkSocket } = await authenticateKeyedWs(parsed, fork.deviceId, key)
const children =
scope === 'runtime'
? registry.upsertDelegatedMobileDevices(fork, [{ phoneKey: 'p', name: 'Pixel' }])
: []
const sockets = [parentSocket, forkSocket]
for (const child of children) {
sockets.push(
await authenticateMobileWs(
encodePairingOffer({
...parsed,
deviceToken: child.token,
pairedDeviceId: child.deviceId,
scope: 'mobile'
})
)
)
}
const unrelated = registry.addDevice('Unrelated', scope)
const unrelatedSocket = await authenticateMobileWs(
encodePairingOffer({
...parsed,
deviceToken: unrelated.token,
pairedDeviceId: unrelated.deviceId
})
)
const closed = sockets.map(waitForWsClose)
if (removedOnDisk) {
const path = join(userDataPath, DEVICE_REGISTRY_FILENAME)
const rows: { deviceId: string }[] = JSON.parse(readFileSync(path, 'utf8'))
writeFileSync(path, JSON.stringify(rows.filter((row) => row.deviceId !== offer.deviceId)))
}
const revoked =
scope === 'mobile'
? await server.revokeMobileDevice(offer.deviceId)
: server.revokeRuntimeAccess(offer.deviceId)
expect(revoked).toBe(true)
for (const device of [fork, idleFork, ...children]) {
expect(registry.getDevice(device.deviceId)).toBeNull()
expect(new DeviceRegistry(userDataPath).getDevice(device.deviceId)).toBeNull()
}
await Promise.all(closed)
expect(registry.validateToken(unrelated.token)?.deviceId).toBe(unrelated.deviceId)
expect(unrelatedSocket.readyState).toBe(unrelatedSocket.OPEN)
unrelatedSocket.close()
} finally {
await server.stop()
}
},
15_000
)
it.each(['binary', 'text', 'sibling-cascade'] as const)(
'retires an established keyed terminal subscription through %s revocation',
async (kind) => {
const userDataPath = mkdtempSync(join(tmpdir(), 'orca-fork-stream-revoke-'))
const runtime = new OrcaRuntimeService(partialRuntimeStore(makeStore()))
const write = vi.fn(() => true)
runtime.setPtyController({
spawn: vi.fn().mockResolvedValue({ id: 'fork-stream-pty' }),
write,
kill: () => true,
getForegroundProcess: async () => null
})
const cleanup = vi.spyOn(runtime, 'cleanupSubscriptionsForConnection')
const server = new OrcaRuntimeRpcServer({
runtime,
userDataPath,
enableWebSocket: true,
wsPort: 0
})
await server.start()
try {
const terminal = await runtime.createTerminal('id:repo-1::/tmp/worktree-a')
const offer = server.createPairingOffer({
address: '127.0.0.1',
name: 'Parent',
scope: kind === 'sibling-cascade' ? 'mobile' : 'runtime'
})
if (!offer.available) {
throw new Error('WebSocket pairing unavailable')
}
const registry = server.getDeviceRegistry()!
const key = nacl.sign.keyPair()
const earlier =
kind === 'sibling-cascade'
? registry.forkDeviceKey(
offer.deviceId,
Buffer.alloc(32, 7).toString('base64'),
'Earlier'
)
: null
const fork = registry.forkDeviceKey(
offer.deviceId,
Buffer.from(key.publicKey).toString('base64'),
'Fork'
)
const later =
kind === 'sibling-cascade'
? registry.forkDeviceKey(
offer.deviceId,
Buffer.alloc(32, 8).toString('base64'),
'Later'
)
: null
if (kind === 'sibling-cascade') {
server.setMobileRelayBinding(fork.deviceId, {
relayHostId: 'host',
relayDeviceId: fork.deviceId,
ownerIdentityKey: 'owner'
})
registry.setPushRegistration(fork.deviceId, {
registrationId: 'fork-push',
filter: {},
expiresAt: 4_000_000_000_000
})
}
const { ws, peer } = await authenticateKeyedWs(
parsePairingCode(offer.pairingUrl)!,
fork.deviceId,
key
)
const responses: { result?: { type?: string; streamId?: number } }[] = []
ws.on('message', (data, isBinary) => {
if (isBinary && Buffer.isBuffer(data)) {
peer.openBinary(data)
} else if (!isBinary) {
responses.push(JSON.parse(peer.openText(data.toString())!))
}
})
ws.send(
peer.sealText(
JSON.stringify({
id: 'subscribe',
method: 'terminal.subscribe',
params: { terminal: terminal.handle, capabilities: { terminalBinaryStream: 1 } }
})
)
)
await waitFor(() => responses.some((response) => response.result?.type === 'subscribed'))
const streamId = responses.find((response) => response.result?.type === 'subscribed')
?.result?.streamId
if (streamId === undefined) {
throw new Error('Expected binary terminal subscription')
}
const sendInput = (text: string) =>
ws.send(
peer.sealBinary(
encodeTerminalStreamFrame({
opcode: TerminalStreamOpcode.Input,
streamId,
seq: 1,
payload: encodeTerminalStreamText(text)
})
)
)
sendInput('before')
await waitFor(() => write.mock.calls.length === 1)
const path = join(userDataPath, DEVICE_REGISTRY_FILENAME)
const rows: { deviceId: string }[] = JSON.parse(readFileSync(path, 'utf8'))
writeFileSync(
path,
JSON.stringify(
rows.filter(
(row) =>
row.deviceId !== (kind === 'sibling-cascade' ? fork.deviceId : offer.deviceId)
)
)
)
const closed = waitForWsClose(ws)
if (kind === 'sibling-cascade') {
expect(await server.revokeMobileDevice(offer.deviceId)).toBe(true)
for (const device of [earlier, fork, later]) {
if (device) {
expect(registry.getDevice(device.deviceId)).toBeNull()
}
}
expect(registry.getDevice(offer.deviceId)).toBeNull()
expect(server.getRelayRevokeOutbox().pendingFor('owner', 'host')).toMatchObject([
{ relayDeviceId: fork.deviceId }
])
expect(server.getPushUnregisterOutbox().pending()).toMatchObject([
{ deviceId: fork.deviceId, registrationId: 'fork-push' }
])
} else if (kind === 'binary') {
sendInput('after')
} else {
ws.send(peer.sealText(JSON.stringify({ id: 'denied', method: 'status.get' })))
}
await waitFor(
() =>
cleanup.mock.calls.length > 0 ||
write.mock.calls.length > 1 ||
responses.some((response) => 'error' in response)
)
expect(write).toHaveBeenCalledTimes(1)
expect(cleanup).toHaveBeenCalledOnce()
await closed
expect(server['mobileSocketWiring']?.channelCount).toBe(0)
expect(server['mobileSocketWiring']?.connectionCount).toBe(0)
} finally {
cleanup.mockRestore()
await server.stop()
}
}
)
})
@@ -6,6 +6,7 @@ import type {
DelegatedPhone,
DelegatedMobileDeviceSyncResult
} from '../../../shared/delegated-mobile-device-contract'
import type { DeviceEntry } from '../device-registry'
import { RuntimeRpcRequestAdmission } from './runtime-rpc-request-admission'
// Why: below dispatch so a caller-bound RPC context can revoke and mint mobile devices.
@@ -13,50 +14,57 @@ export class RuntimeRpcMobileDevices extends RuntimeRpcRequestAdmission {
private onPushUnregisterQueued?: () => void
async revokeMobileDevice(deviceId: string): Promise<boolean> {
const revoked = this.revokeMobileDeviceNow(deviceId)
const device = this.deviceRegistry?.getDevice(deviceId)
const revoked = device?.scope === 'mobile' && this.revokeDevicesNow([device])
if (revoked) {
this.mobileDesktopRelay?.phonesChanged()
}
return revoked
}
private revokeMobileDeviceNow(deviceId: string): boolean {
const device = this.deviceRegistry?.getDevice(deviceId)
if (device?.scope !== 'mobile') {
return false
}
if (device.relayBinding) {
if (!this.queueRelayDeviceRevoke(device.relayBinding)) {
return false
}
}
// Capture gateway registration before deleting its device row so unpair also revokes push.
this.queuePushUnregister(deviceId, device.pushRegistration?.registrationId)
if (!this.deviceRegistry?.removeDevice(deviceId)) {
return false
}
this.mobileRelayPairingProvider?.onDemandStateChanged?.()
this.runtime.forgetClientNavigationState(deviceId)
this.mobileSocketWiring?.terminateDeviceConnections(deviceId)
return true
}
revokeRuntimeAccess(deviceId: string): boolean {
const device = this.deviceRegistry?.getDevice(deviceId)
if (device?.scope !== 'runtime') {
return device?.scope === 'runtime' && this.revokeDevicesNow([device])
}
private revokeDevicesNow(roots: readonly DeviceEntry[]): boolean {
const registry = this.deviceRegistry
if (!registry) {
return false
}
for (const child of this.deviceRegistry?.listDelegatedMobileDevices(deviceId) ?? []) {
// Keep parent until child cleanup is durable so retry can rediscover them.
if (!this.revokeMobileDeviceNow(child.deviceId)) {
return false
// Saves adopt disk deletions, so capture every descendant's cleanup facts before the first write.
const paired = registry.listDevices()
const plan: DeviceEntry[] = []
const visited = new Set<string>()
const visit = (device: DeviceEntry): void => {
if (visited.has(device.deviceId)) {
return
}
visited.add(device.deviceId)
for (const child of paired) {
if (child.parentDeviceId === device.deviceId || child.forkedFrom === device.deviceId) {
visit(child)
}
}
plan.push(device)
}
if (!this.deviceRegistry?.removeDevice(deviceId)) {
return false
roots.forEach(visit)
for (const device of plan) {
const { deviceId } = device
// Keep ancestors until child cleanup is durable so retry can rediscover them.
if (device.scope === 'mobile') {
if (device.relayBinding && !this.queueRelayDeviceRevoke(device.relayBinding)) {
return false
}
this.queuePushUnregister(deviceId, device.pushRegistration?.registrationId)
}
registry.removeDevice(deviceId)
if (device.scope === 'mobile') {
this.mobileRelayPairingProvider?.onDemandStateChanged?.()
}
this.runtime.forgetClientNavigationState(deviceId)
this.mobileSocketWiring?.terminateDeviceConnections(deviceId)
}
this.runtime.forgetClientNavigationState(deviceId)
this.mobileSocketWiring?.terminateDeviceConnections(deviceId)
return true
}
@@ -71,14 +79,13 @@ export class RuntimeRpcMobileDevices extends RuntimeRpcRequestAdmission {
throw new Error('delegated_device_parent_unavailable')
}
const wanted = new Set(phones.map((phone) => phone.phoneKey))
for (const child of registry.listDelegatedMobileDevices(parentDeviceId)) {
if (
(!child.phoneKey || !wanted.has(child.phoneKey)) &&
!this.revokeMobileDeviceNow(child.deviceId)
) {
throw new Error('delegated_device_revoke_failed')
}
const dropped = registry
.listDelegatedMobileDevices(parentDeviceId)
.filter((child) => !child.phoneKey || !wanted.has(child.phoneKey))
if (!this.revokeDevicesNow(dropped)) {
throw new Error('delegated_device_revoke_failed')
}
let devices = registry.upsertDelegatedMobileDevices(parent, phones)
// A child removed on disk meanwhile is dropped by the save; one rerun mints it fresh.
if (devices.length < phones.length) {