Skip to content

Commit a3c7159

Browse files
committed
fix(runtime): close owners independently and preserve cleanup evidence
1 parent ca6e0af commit a3c7159

5 files changed

Lines changed: 202 additions & 21 deletions

File tree

Lines changed: 97 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,97 @@
1+
import fs from 'node:fs';
2+
import path from 'node:path';
3+
import { expect, test, vi } from 'vitest';
4+
import { mkdtempForTestSync } from '@agent-device/test-kit';
5+
import { AppError } from '@agent-device/kernel/errors';
6+
import {
7+
createOwnerScopedDeviceClaimReconciler,
8+
type OwnerScopedClaimRecovery,
9+
} from './device-claim-owner-recovery.ts';
10+
import type { DeviceClaim } from './device-claims.ts';
11+
import { resolveDeviceClaimPath } from './device-claim-paths.ts';
12+
import { writeDeviceClaim } from './device-claim-store.ts';
13+
import { settleVerifiedOrphanedClaim } from './device-claim-settlement.ts';
14+
15+
function fixture(reconcile: OwnerScopedClaimRecovery['reconcile']) {
16+
const stateDir = mkdtempForTestSync('claim-recovery-dispose-');
17+
const claim: DeviceClaim = {
18+
schemaVersion: 3,
19+
claimOwnerKind: 'open-session',
20+
deviceKey: 'local:android:none:emulator-5554',
21+
device: { family: 'android', id: 'emulator-5554', name: 'Pixel', kind: 'emulator' },
22+
session: 'owner-session',
23+
workspace: '/worktrees/dead',
24+
stateDir,
25+
ownerPid: 999_999_999,
26+
ownerStartTime: 'dead-start',
27+
ownerToken: 'claim-token',
28+
createdAtMs: 1,
29+
updatedAtMs: 1,
30+
};
31+
const env = { AGENT_DEVICE_CLAIMS_DIR: path.join(stateDir, 'claims') };
32+
writeDeviceClaim(claim, env);
33+
const cleanupError = new AppError('COMMAND_FAILED', 'owner disposal failed', {
34+
reason: 'owner-cleanup-refused',
35+
});
36+
const emit = vi.fn();
37+
const dispose = vi.fn(async () => {
38+
throw cleanupError;
39+
});
40+
const recovery = createOwnerScopedDeviceClaimReconciler({
41+
scope: {
42+
signal: new AbortController().signal,
43+
diagnostics: { emit },
44+
progress: { report: () => {} },
45+
},
46+
composeGateway: () => {
47+
throw new Error('the supplied recovery owns composition');
48+
},
49+
composeRecovery: () => ({ reconcile, dispose }),
50+
});
51+
return { claim, env, cleanupError, emit, dispose, recovery };
52+
}
53+
54+
test('cleanup-only failure prevents a reconciled claim from being released', async () => {
55+
const f = fixture(async () => ({ status: 'reconciled' }));
56+
57+
await expect(settleVerifiedOrphanedClaim(f.claim, f.recovery, f.env)).rejects.toBe(
58+
f.cleanupError,
59+
);
60+
expect(fs.existsSync(resolveDeviceClaimPath(f.claim.deviceKey, f.env))).toBe(true);
61+
expect(f.dispose).toHaveBeenCalledOnce();
62+
});
63+
64+
test('disposal failure preserves the primary reconciliation error and records secondary evidence', async () => {
65+
const primary = new AppError('DEVICE_IN_USE', 'reconciliation refused', {
66+
reason: 'primary-refusal',
67+
});
68+
const f = fixture(async () => {
69+
throw primary;
70+
});
71+
72+
await expect(f.recovery(f.claim)).rejects.toBe(primary);
73+
expect(f.emit).toHaveBeenCalledWith(
74+
expect.objectContaining({
75+
phase: 'device_claim_recovery_dispose_failed',
76+
data: expect.objectContaining({
77+
error: expect.objectContaining({ details: { reason: 'owner-cleanup-refused' } }),
78+
}),
79+
}),
80+
);
81+
expect(f.dispose).toHaveBeenCalledOnce();
82+
});
83+
84+
test('disposal failure preserves an existing retained-claim reason', async () => {
85+
const retained = { status: 'retained', reason: 'screen-recording-owner-mismatch' } as const;
86+
const f = fixture(async () => retained);
87+
88+
await expect(settleVerifiedOrphanedClaim(f.claim, f.recovery, f.env)).resolves.toBe(retained);
89+
expect(fs.existsSync(resolveDeviceClaimPath(f.claim.deviceKey, f.env))).toBe(true);
90+
expect(f.emit).toHaveBeenCalledWith(
91+
expect.objectContaining({
92+
phase: 'device_claim_recovery_dispose_failed',
93+
data: expect.objectContaining({ retainedReason: retained.reason }),
94+
}),
95+
);
96+
expect(f.dispose).toHaveBeenCalledOnce();
97+
});

‎packages/daemon-contracts/src/device-claim-owner-recovery.ts‎

Lines changed: 19 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -5,6 +5,7 @@ import {
55
} from './session-artifact-paths.ts';
66
import type { PlatformRequestScope } from '@agent-device/contracts/platform-runtime-host';
77
import { createOwnedProcessRecordStore } from '@agent-device/host-kit/process';
8+
import { normalizeError } from '@agent-device/kernel/errors';
89
import { resolveDaemonPaths } from './daemon-resolution.ts';
910
import {
1011
createDeviceClaimReconciler,
@@ -57,10 +58,26 @@ export function createOwnerScopedDeviceClaimReconciler(
5758
const inspection = await params.beforeGateway?.(claim);
5859
if (inspection?.status === 'retained') return inspection;
5960
const recovery = compose(claim.stateDir);
61+
let outcome: Awaited<ReturnType<DeviceClaimReconciler>> | undefined;
6062
try {
61-
return await recovery.reconcile(claim, inspection);
63+
outcome = await recovery.reconcile(claim, inspection);
64+
return outcome;
6265
} finally {
63-
await recovery.dispose();
66+
try {
67+
await recovery.dispose();
68+
} catch (error) {
69+
if (outcome?.status === 'reconciled') throw error;
70+
params.scope.diagnostics.emit({
71+
level: 'error',
72+
phase: 'device_claim_recovery_dispose_failed',
73+
data: {
74+
deviceKey: claim.deviceKey,
75+
ownerSession: claim.session,
76+
...(outcome?.status === 'retained' ? { retainedReason: outcome.reason } : {}),
77+
error: normalizeError(error),
78+
},
79+
});
80+
}
6481
}
6582
};
6683
}

‎packages/daemon/src/server/http/daemon-runtime.ts‎

Lines changed: 5 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -6,7 +6,7 @@ import {
66
type ClaimRecoveryGatewayFactory,
77
} from '@agent-device/daemon-contracts/device-claim-recovery';
88
import crypto from 'node:crypto';
9-
import { asAppError, AppError } from '@agent-device/kernel/errors';
9+
import { asAppError, AppError, normalizeError } from '@agent-device/kernel/errors';
1010
import { SessionStore } from '../../core/session-store.ts';
1111
import {
1212
DAEMON_CAPABILITIES,
@@ -872,8 +872,10 @@ async function startDaemonRuntimeOnHost(
872872
: 'closed';
873873
if (ownerClose.kind === 'rejected') {
874874
await emitDaemonDiagnostic(logPath, 'daemon_shutdown_platform_owner_failed', {
875-
error:
876-
ownerClose.error instanceof Error ? ownerClose.error.message : String(ownerClose.error),
875+
error: normalizeError(ownerClose.error),
876+
...(ownerClose.error instanceof AggregateError
877+
? { failures: ownerClose.error.errors.map((error) => normalizeError(error)) }
878+
: {}),
877879
});
878880
}
879881
const plugins = await pluginClose.close();

‎src/platform-runtime-gateway.test.ts‎

Lines changed: 59 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -13,6 +13,7 @@ import { createUnavailablePlatformRuntimeFacts } from '@agent-device/contracts/p
1313
import { screenshotRuntimeOperationFacts } from '@agent-device/contracts/screenshot-runtime';
1414
import { viewportRuntimeOperationFacts } from '@agent-device/contracts/viewport-runtime';
1515
import type { DeviceInfo } from '@agent-device/kernel/device';
16+
import { AppError } from '@agent-device/kernel/errors';
1617
import { createLimrunRuntime } from '@agent-device/provider-limrun';
1718
import { describe, expect, expectTypeOf, test, vi } from 'vitest';
1819
import type { AgentDeviceHost } from './sdk/host-types.ts';
@@ -71,10 +72,62 @@ describe('composed platform runtime gateway', () => {
7172
await closing;
7273
expect(shutdown).toHaveBeenCalledOnce();
7374
});
75+
test('an unfinished owner load does not delay shutdown of a loaded owner', async () => {
76+
const readyRef = providerRuntimeOwner('limrun', 'ready');
77+
const loadingRef = providerRuntimeOwner('limrun', 'loading');
78+
const readyShutdown = vi.fn(async () => {});
79+
const lateShutdown = vi.fn(async () => {});
80+
let finishLoad!: () => void;
81+
const loadReady = new Promise<void>((resolve) => {
82+
finishLoad = resolve;
83+
});
84+
const runtimeGateway = gateway([
85+
providerRuntime({
86+
ref: readyRef,
87+
load: async () => ({ ...runtimeOwner({ ref: readyRef }), shutdown: readyShutdown }),
88+
}),
89+
providerRuntime({
90+
ref: loadingRef,
91+
load: async () => {
92+
await loadReady;
93+
return { ...runtimeOwner({ ref: loadingRef }), shutdown: lateShutdown };
94+
},
95+
}),
96+
]);
97+
await runtimeGateway.bind({
98+
device,
99+
intent: { kind: 'exact-owner', owner: readyRef, fence: { token: 'ready', generation: 1 } },
100+
scope,
101+
});
102+
const loading = runtimeGateway.bind({
103+
device,
104+
intent: {
105+
kind: 'exact-owner',
106+
owner: loadingRef,
107+
fence: { token: 'loading', generation: 1 },
108+
},
109+
scope,
110+
});
111+
const closing = runtimeGateway.shutdown();
112+
try {
113+
await new Promise<void>((resolve) => setImmediate(resolve));
114+
expect(readyShutdown).toHaveBeenCalledOnce();
115+
expect(lateShutdown).not.toHaveBeenCalled();
116+
} finally {
117+
finishLoad();
118+
await loading;
119+
await closing;
120+
}
121+
expect(readyShutdown).toHaveBeenCalledOnce();
122+
expect(lateShutdown).toHaveBeenCalledOnce();
123+
});
74124
test('daemon reports a composed owner failure and retains registration while completing cleanup', async () => {
75125
const ref = providerRuntimeOwner('limrun', 'failed');
76126
const shutdown = vi.fn(async () => {
77-
throw new Error('owner refused');
127+
throw new AppError('COMMAND_FAILED', 'owner refused', {
128+
reason: 'owner-test-refusal',
129+
hint: 'Inspect the original owner failure.',
130+
});
78131
});
79132
const registration = providerRuntime({
80133
ref,
@@ -120,9 +173,11 @@ describe('composed platform runtime gateway', () => {
120173
expect(describeUnfinishedShutdownWork(report)).toEqual([
121174
expect.stringContaining('platform owner shutdown failed'),
122175
]);
123-
expect(fs.readFileSync(paths.logPath, 'utf8')).toContain(
124-
'daemon_shutdown_platform_owner_failed',
125-
);
176+
const log = fs.readFileSync(paths.logPath, 'utf8');
177+
expect(log).toContain('daemon_shutdown_platform_owner_failed');
178+
expect(log).toContain('owner refused');
179+
expect(log).toContain('owner-test-refusal');
180+
expect(log).toContain('Inspect the original owner failure.');
126181
expect(fs.existsSync(paths.infoPath)).toBe(true);
127182
expect(fs.existsSync(paths.lockPath)).toBe(true);
128183
expect(clearLock).not.toHaveBeenCalled();

‎src/platform-runtime-gateway.ts‎

Lines changed: 22 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -29,7 +29,7 @@ import {
2929
type DeviceInfo,
3030
type Platform,
3131
} from '@agent-device/kernel/device';
32-
import { AppError } from '@agent-device/kernel/errors';
32+
import { AppError, normalizeError } from '@agent-device/kernel/errors';
3333

3434
export type PlatformRuntimeProviderRegistration = Readonly<{
3535
runtime: ProviderDeviceRuntime;
@@ -189,22 +189,32 @@ export function createComposedPlatformRuntimeGateway(options: {
189189
},
190190
shutdown: () =>
191191
(closing ??= Promise.resolve().then(async () => {
192-
await Promise.allSettled([...localLoads.values(), ...providerLoads.values()]);
193-
const owners = [...loadedOwners.entries()];
194192
const outcomes = await Promise.allSettled(
195-
owners.map(async ([, owner]) => owner.shutdown()),
193+
[...localLoads.values(), ...providerLoads.values()].map((load) =>
194+
load.then(
195+
async (owner) => {
196+
try {
197+
await owner.shutdown();
198+
} catch (error) {
199+
const key = runtimeOwnerKey(owner.owner);
200+
const failure = normalizeError(error);
201+
throw new AppError(
202+
'COMMAND_FAILED',
203+
`Platform runtime owner ${key} failed to shut down: ${failure.message}`,
204+
{ reason: 'platform-owner-shutdown-failed', owner: key, failure },
205+
error,
206+
);
207+
}
208+
},
209+
() => undefined,
210+
),
211+
),
196212
);
197213
loadedOwners.clear();
198214
localLoads.clear();
199215
providerLoads.clear();
200-
const failures = outcomes.flatMap((outcome, index) =>
201-
outcome.status === 'rejected'
202-
? [
203-
new Error(`Platform runtime owner ${owners[index]![0]} failed to shut down`, {
204-
cause: outcome.reason,
205-
}),
206-
]
207-
: [],
216+
const failures = outcomes.flatMap((outcome) =>
217+
outcome.status === 'rejected' ? [outcome.reason] : [],
208218
);
209219
if (failures.length > 0) {
210220
throw new AggregateError(

0 commit comments

Comments
 (0)