Skip to content

Commit b4780e2

Browse files
committed
fix: preserve advisory claim ownership
1 parent faf048b commit b4780e2

7 files changed

Lines changed: 206 additions & 29 deletions

File tree

‎src/daemon/__tests__/device-claims.test.ts‎

Lines changed: 52 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -61,6 +61,26 @@ test('preserves a live foreign advisory claim without blocking or overwriting it
6161
assert.equal(inspectDeviceClaims({ serial: device.id })[0]?.claim?.session, 'first');
6262
});
6363

64+
test('does not treat a same-named session in another worktree as its claim owner', async () => {
65+
const root = useClaimsRoot();
66+
const first = await acquireAdvisoryDeviceClaim({
67+
device,
68+
session: 'default',
69+
workspace: '/worktrees/first',
70+
stateDir: root,
71+
});
72+
assert.ok(first.ownership);
73+
const second = await acquireAdvisoryDeviceClaim({
74+
device,
75+
session: 'default',
76+
workspace: '/worktrees/second',
77+
stateDir: path.join(root, 'second-state'),
78+
});
79+
assert.equal(second.ownership, undefined);
80+
await clearAdvisoryDeviceClaim(second.ownership);
81+
assert.equal(inspectDeviceClaims({ serial: device.id })[0]?.claim?.workspace, '/worktrees/first');
82+
});
83+
6484
test('clears only the exact owner token and identity, never a successor claim', async () => {
6585
const root = useClaimsRoot();
6686
const acquired = await acquireAdvisoryDeviceClaim({
@@ -121,3 +141,35 @@ test('fails closed when claim inspection encounters a permission or transient I/
121141
const claims = inspectDeviceClaims({});
122142
assert.equal(claims[0]?.classification, 'unknown');
123143
});
144+
145+
test('classifies transient claim-file read errors as unknown, not inconsistent', () => {
146+
const root = useClaimsRoot();
147+
fs.writeFileSync(path.join(root, 'transient.json'), '{}');
148+
vi.spyOn(fs, 'readFileSync').mockImplementation(() => {
149+
const error = new Error('I/O error') as NodeJS.ErrnoException;
150+
error.code = 'EIO';
151+
throw error;
152+
});
153+
const claims = inspectDeviceClaims({});
154+
assert.equal(claims[0]?.classification, 'unknown');
155+
});
156+
157+
test('matches public Apple claim records through the shared platform selector semantics', async () => {
158+
const root = useClaimsRoot();
159+
await acquireAdvisoryDeviceClaim({
160+
device: {
161+
platform: 'apple',
162+
appleOs: 'ios',
163+
id: 'ios-claim',
164+
name: 'iPhone',
165+
kind: 'simulator',
166+
booted: true,
167+
},
168+
session: 'ios',
169+
workspace: process.cwd(),
170+
stateDir: root,
171+
});
172+
assert.equal(inspectDeviceClaims({ platform: 'apple' }).length, 1);
173+
assert.equal(inspectDeviceClaims({ platform: 'ios' }).length, 1);
174+
assert.equal(inspectDeviceClaims({ platform: 'macos' }).length, 0);
175+
});

‎src/daemon/device-claim-inspection.ts‎

Lines changed: 25 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,10 @@
11
import fs from 'node:fs';
22
import path from 'node:path';
3-
import type { PlatformSelector } from '../kernel/device.ts';
3+
import {
4+
deviceFieldsFromPublicPlatform,
5+
matchesPlatformSelector,
6+
type PlatformSelector,
7+
} from '../kernel/device.ts';
48
import { classifyOwnerLiveness, type OwnerLiveness } from '../utils/owner-identity.ts';
59
import { resolveDeviceClaimRoot } from './device-claim-paths.ts';
610
import type { DeviceClaim } from './device-claims.ts';
@@ -70,16 +74,30 @@ function matchesClaimDevice(claim: DeviceClaim, device: string | undefined): boo
7074
}
7175

7276
function matchesClaimPlatform(claim: DeviceClaim, platform: PlatformSelector | undefined): boolean {
73-
if (!platform) return true;
74-
if (platform === 'ios') return claim.device.platform === 'ios';
75-
if (platform === 'macos') return claim.device.platform === 'macos';
76-
return claim.device.platform === platform;
77+
return matchesPlatformSelector(
78+
{ ...deviceFieldsFromPublicPlatform(claim.device.platform), appleOs: claim.device.appleOs },
79+
platform,
80+
);
7781
}
7882

7983
export function inspectDeviceClaimFile(filePath: string): InspectedDeviceClaim | null {
8084
const fileName = path.basename(filePath);
8185
try {
82-
const claim = normalizeClaim(JSON.parse(fs.readFileSync(filePath, 'utf8')) as unknown);
86+
return inspectClaimContents(fileName, fs.readFileSync(filePath, 'utf8'));
87+
} catch (error) {
88+
const code = (error as NodeJS.ErrnoException).code;
89+
if (code === 'ENOENT' || code === 'ENOTDIR') return null;
90+
return {
91+
fileName,
92+
classification: 'unknown',
93+
error: String(error),
94+
};
95+
}
96+
}
97+
98+
function inspectClaimContents(fileName: string, contents: string): InspectedDeviceClaim {
99+
try {
100+
const claim = normalizeClaim(JSON.parse(contents) as unknown);
83101
if (!claim) return { fileName, classification: 'inconsistent' };
84102
return {
85103
fileName,
@@ -91,13 +109,7 @@ export function inspectDeviceClaimFile(filePath: string): InspectedDeviceClaim |
91109
}),
92110
};
93111
} catch (error) {
94-
const code = (error as NodeJS.ErrnoException).code;
95-
if (code === 'ENOENT' || code === 'ENOTDIR') return null;
96-
return {
97-
fileName,
98-
classification: code === 'EACCES' || code === 'EPERM' ? 'unknown' : 'inconsistent',
99-
error: String(error),
100-
};
112+
return { fileName, classification: 'inconsistent', error: String(error) };
101113
}
102114
}
103115

‎src/daemon/device-claims.ts‎

Lines changed: 18 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -64,13 +64,10 @@ export async function acquireAdvisoryDeviceClaim(params: {
6464
}): Promise<{ ownership?: DeviceClaimSessionOwnership; conflict?: InspectedDeviceClaim }> {
6565
const deviceKey = canonicalLocalDeviceKey(params.device);
6666
return await withDeviceClaimLock(deviceKey, async () => {
67+
const owner = readCurrentOwnerIdentity();
6768
const existing = inspectDeviceClaimFile(resolveDeviceClaimPath(deviceKey));
6869
if (existing) {
69-
if (
70-
existing.claim &&
71-
existing.claim.session === params.session &&
72-
existing.classification === 'live'
73-
) {
70+
if (existing.claim && isCurrentClaimOwner(existing.claim, params, owner)) {
7471
return { ownership: ownershipFromClaim(existing.claim) };
7572
}
7673
emitDiagnostic({
@@ -85,7 +82,6 @@ export async function acquireAdvisoryDeviceClaim(params: {
8582
});
8683
return { conflict: existing };
8784
}
88-
const owner = readCurrentOwnerIdentity();
8985
const now = Date.now();
9086
const claim: DeviceClaim = {
9187
schemaVersion: DEVICE_CLAIM_SCHEMA_VERSION,
@@ -112,6 +108,22 @@ export async function acquireAdvisoryDeviceClaim(params: {
112108
});
113109
}
114110

111+
function isCurrentClaimOwner(
112+
claim: DeviceClaim,
113+
params: Pick<
114+
Parameters<typeof acquireAdvisoryDeviceClaim>[0],
115+
'session' | 'workspace' | 'stateDir'
116+
>,
117+
owner: ReturnType<typeof readCurrentOwnerIdentity>,
118+
): boolean {
119+
return (
120+
claim.session === params.session &&
121+
claim.workspace === params.workspace &&
122+
claim.stateDir === params.stateDir &&
123+
ownerIdentityMatches({ pid: claim.ownerPid, startTime: claim.ownerStartTime }, owner)
124+
);
125+
}
126+
115127
export async function clearAdvisoryDeviceClaim(
116128
ownership: DeviceClaimSessionOwnership | undefined,
117129
): Promise<void> {

‎src/daemon/handlers/__tests__/session-device-claims.test.ts‎

Lines changed: 22 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -67,6 +67,28 @@ test('failed local open rolls its advisory claim back', async () => {
6767
assert.deepEqual(inspectDeviceClaims({ serial: android.id }), []);
6868
});
6969

70+
test('failed local open response rolls its advisory claim back', async () => {
71+
const { store, stateDir } = setup();
72+
mockResolveTargetDevice.mockResolvedValue(android);
73+
74+
const response = await handleOpenCommand({
75+
req: {
76+
command: 'open',
77+
token: 'test',
78+
session: 'claim-response-rollback',
79+
positionals: ['Demo'],
80+
flags: { platform: 'android' },
81+
runtime: { metroHost: '10.0.0.10', metroPort: 70_000 },
82+
},
83+
sessionName: 'claim-response-rollback',
84+
logPath: path.join(stateDir, 'daemon.log'),
85+
sessionStore: store,
86+
});
87+
88+
assert.equal(response.ok, false);
89+
assert.deepEqual(inspectDeviceClaims({ serial: android.id }), []);
90+
});
91+
7092
test('remote open creates no host-local advisory claim', async () => {
7193
const { store, stateDir } = setup();
7294
mockResolveTargetDevice.mockResolvedValue(android);

‎src/daemon/handlers/session-open.ts‎

Lines changed: 4 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -576,7 +576,10 @@ async function openNewSessionWithAdvisoryClaim(params: {
576576
openTarget,
577577
}),
578578
});
579-
if (details.type === 'response') return details.response;
579+
if (details.type === 'response') {
580+
await clearAdvisoryDeviceClaim(localClaim.ownership);
581+
return details.response;
582+
}
580583
const response = await completeOpenCommand({
581584
req,
582585
sessionName,
Lines changed: 71 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,71 @@
1+
import fs from 'node:fs';
2+
import os from 'node:os';
3+
import path from 'node:path';
4+
import { afterEach, expect, test, vi } from 'vitest';
5+
6+
vi.mock('../session-teardown.ts', () => ({ teardownSessionResources: vi.fn() }));
7+
8+
import { SessionStore } from '../session-store.ts';
9+
import { teardownSessionResources } from '../session-teardown.ts';
10+
import type { SessionState } from '../types.ts';
11+
import { teardownDaemonSessionForShutdown } from './daemon-runtime.ts';
12+
13+
const mockTeardownSessionResources = vi.mocked(teardownSessionResources);
14+
const roots: string[] = [];
15+
16+
afterEach(() => {
17+
vi.useRealTimers();
18+
vi.clearAllMocks();
19+
for (const root of roots.splice(0)) fs.rmSync(root, { recursive: true, force: true });
20+
});
21+
22+
function setup(): { session: SessionState; sessionStore: SessionStore; stateDir: string } {
23+
const stateDir = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-device-shutdown-claim-'));
24+
roots.push(stateDir);
25+
const session: SessionState = {
26+
name: 'claim-session',
27+
device: { platform: 'android', id: 'emulator-5554', name: 'Pixel', kind: 'emulator' },
28+
createdAt: Date.now(),
29+
actions: [],
30+
};
31+
const sessionStore = new SessionStore(path.join(stateDir, 'sessions'));
32+
sessionStore.set(session.name, session);
33+
return { session, sessionStore, stateDir };
34+
}
35+
36+
test('does not run beforeDelete after shutdown teardown rejects', async () => {
37+
const { session, sessionStore, stateDir } = setup();
38+
mockTeardownSessionResources.mockRejectedValueOnce(new Error('teardown failed'));
39+
const beforeDelete = vi.fn(async () => {});
40+
41+
await teardownDaemonSessionForShutdown({
42+
session,
43+
sessionStore,
44+
stateDir,
45+
stderr: { write: () => {} },
46+
beforeDelete,
47+
});
48+
49+
expect(beforeDelete).not.toHaveBeenCalled();
50+
expect(sessionStore.get(session.name)).toBeUndefined();
51+
});
52+
53+
test('does not run beforeDelete after shutdown teardown times out', async () => {
54+
vi.useFakeTimers();
55+
const { session, sessionStore, stateDir } = setup();
56+
mockTeardownSessionResources.mockReturnValueOnce(new Promise(() => {}));
57+
const beforeDelete = vi.fn(async () => {});
58+
59+
const teardown = teardownDaemonSessionForShutdown({
60+
session,
61+
sessionStore,
62+
stateDir,
63+
stderr: { write: () => {} },
64+
beforeDelete,
65+
});
66+
await vi.advanceTimersByTimeAsync(5_000);
67+
await teardown;
68+
69+
expect(beforeDelete).not.toHaveBeenCalled();
70+
expect(sessionStore.get(session.name)).toBeUndefined();
71+
});

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

Lines changed: 14 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -99,24 +99,29 @@ export async function teardownDaemonSessionForShutdown(params: {
9999
}): Promise<void> {
100100
const { session, sessionStore, stateDir, stderr, beforeDelete } = params;
101101
const timeoutMs = resolveDaemonSessionTeardownTimeoutMs(session);
102-
const teardown = teardownSessionResources(session, session.name, stateDir).catch((error) => {
103-
stderr.write(
104-
`Daemon session teardown error (${session.name}): ${
105-
error instanceof Error ? error.message : String(error)
106-
}\n`,
107-
);
108-
});
109-
await Promise.race([
102+
const teardown = teardownSessionResources(session, session.name, stateDir).then(
103+
() => true,
104+
(error) => {
105+
stderr.write(
106+
`Daemon session teardown error (${session.name}): ${
107+
error instanceof Error ? error.message : String(error)
108+
}\n`,
109+
);
110+
return false;
111+
},
112+
);
113+
const teardownSucceeded = await Promise.race([
110114
teardown,
111115
sleep(timeoutMs).then(() => {
112116
stderr.write(`Daemon session teardown timed out (${session.name}).\n`);
117+
return false;
113118
}),
114119
]);
115120
// ADR 0012 decision 6, R7 + commit semantics (C2/C5a): commit the healed
116121
// `.ad` iff the repair transaction completed, else leave a bounded
117122
// `REPAIR_SESSION_EXPIRED` tombstone for the reaped-before-finalize case.
118123
sessionStore.finalizeRepairTeardown(session);
119-
await beforeDelete?.(session);
124+
if (teardownSucceeded) await beforeDelete?.(session);
120125
sessionStore.delete(session.name);
121126
}
122127

0 commit comments

Comments
 (0)