Skip to content

Commit 01f284a

Browse files
committed
refactor(daemon): extract the replay terminal-lifecycle policy module (#1554 review)
session-replay-runtime.ts was already over the 500-line extract-before-adding-behavior tripwire before this PR; the keep-session/repair terminal-close decision, its live-session postcondition, and the dispatched-action count pushed it further past budget. Move that policy into a focused session-replay-terminal-lifecycle.ts (isExecutableReplayAction, resolveSuppressedTerminalCloseIndex, countExecutedReplayActions, requireLiveSessionForKeepSession) so the runtime file stays orchestration-only, and mirror its PR-added unit tests into session-replay-terminal-lifecycle.test.ts. Pure extraction: no assertions changed.
1 parent 1eaec72 commit 01f284a

4 files changed

Lines changed: 248 additions & 198 deletions

File tree

‎src/daemon/handlers/__tests__/session-replay-runtime.test.ts‎

Lines changed: 0 additions & 153 deletions
Original file line numberDiff line numberDiff line change
@@ -10,7 +10,6 @@ import os from 'node:os';
1010
import path from 'node:path';
1111
import { runReplayScriptFile } from '../session-replay-runtime.ts';
1212
import { SessionStore } from '../../session-store.ts';
13-
import type { DaemonRequest } from '../../types.ts';
1413
import { dispatchCommand } from '../../../core/dispatch.ts';
1514
import {
1615
makeIosSession,
@@ -77,59 +76,6 @@ test('a close-less replay reports sessionActive: true (real producer, session st
7776
expect(response.data).toMatchObject({ sessionActive: true, replayed: 2 });
7877
});
7978

80-
test('--keep-session suppresses a close that is terminal among executable actions', async () => {
81-
const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-device-replay-keep-marker-tail-'));
82-
const sessionStore = new SessionStore(path.join(root, 'sessions'));
83-
const sessionName = 'default';
84-
sessionStore.set(sessionName, makeIosSession(sessionName));
85-
const filePath = writeReplayFile(root, ['open "Demo"', 'close', 'replay "./nested-flow.ad"']);
86-
const commands: string[] = [];
87-
88-
const response = await runReplayScriptFile({
89-
req: baseReq({ positionals: [filePath], flags: { replayKeepSession: true } }),
90-
sessionName,
91-
logPath: path.join(root, 'daemon.log'),
92-
sessionStore,
93-
invoke: async (req) => {
94-
commands.push(req.command);
95-
if (req.command === 'close') sessionStore.delete(sessionName);
96-
return { ok: true, data: {} };
97-
},
98-
});
99-
100-
expect(response.ok).toBe(true);
101-
expect(commands).toEqual(['open']);
102-
if (!response.ok) return;
103-
expect(response.data).toMatchObject({ sessionActive: true, replayed: 1 });
104-
});
105-
106-
test('--keep-session fails explicitly when the completed replay has no live session', async () => {
107-
const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-device-replay-keep-postcondition-'));
108-
const sessionStore = new SessionStore(path.join(root, 'sessions'));
109-
const sessionName = 'default';
110-
sessionStore.set(sessionName, makeIosSession(sessionName));
111-
const filePath = writeReplayFile(root, ['open "Demo"', 'click "Log out"']);
112-
113-
const response = await runReplayScriptFile({
114-
req: baseReq({ positionals: [filePath], flags: { replayKeepSession: true } }),
115-
sessionName,
116-
logPath: path.join(root, 'daemon.log'),
117-
sessionStore,
118-
invoke: async (req) => {
119-
if (req.command === 'click') sessionStore.delete(sessionName);
120-
return { ok: true, data: {} };
121-
},
122-
});
123-
124-
expect(response).toMatchObject({
125-
ok: false,
126-
error: {
127-
code: 'COMMAND_FAILED',
128-
message: expect.stringContaining('--keep-session could not preserve session'),
129-
},
130-
});
131-
});
132-
13379
test('a replay whose terminal close removes the session reports sessionActive: false', async () => {
13480
const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-device-replay-session-closed-'));
13581
const sessionStore = new SessionStore(path.join(root, 'sessions'));
@@ -157,105 +103,6 @@ test('a replay whose terminal close removes the session reports sessionActive: f
157103
expect((response.data as { sessionActive: boolean }).sessionActive).toBe(false);
158104
});
159105

160-
test('--keep-session suppresses only the authored terminal close and reports the surviving session', async () => {
161-
const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-device-replay-keep-session-'));
162-
const sessionStore = new SessionStore(path.join(root, 'sessions'));
163-
const sessionName = 'default';
164-
sessionStore.set(sessionName, makeIosSession(sessionName));
165-
const filePath = writeReplayFile(root, ['open "Demo"', 'click "Save"', 'close']);
166-
const commands: string[] = [];
167-
168-
const response = await runReplayScriptFile({
169-
req: baseReq({ positionals: [filePath], flags: { replayKeepSession: true } }),
170-
sessionName,
171-
logPath: path.join(root, 'daemon.log'),
172-
sessionStore,
173-
invoke: async (req) => {
174-
commands.push(req.command);
175-
if (req.command === 'close') sessionStore.delete(sessionName);
176-
return { ok: true, data: {} };
177-
},
178-
});
179-
180-
expect(commands).toEqual(['open', 'click']);
181-
expect(response.ok).toBe(true);
182-
if (!response.ok) return;
183-
expect(sessionStore.get(sessionName)).toBeDefined();
184-
expect(response.data).toMatchObject({ sessionActive: true, replayed: 2 });
185-
});
186-
187-
test('--keep-session preserves an interior close instead of broad command filtering', async () => {
188-
const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-device-replay-keep-interior-close-'));
189-
const sessionStore = new SessionStore(path.join(root, 'sessions'));
190-
const sessionName = 'default';
191-
sessionStore.set(sessionName, makeIosSession(sessionName));
192-
const filePath = writeReplayFile(root, ['open "Demo"', 'close', 'open "Next"']);
193-
const commands: string[] = [];
194-
195-
const response = await runReplayScriptFile({
196-
req: baseReq({ positionals: [filePath], flags: { replayKeepSession: true } }),
197-
sessionName,
198-
logPath: path.join(root, 'daemon.log'),
199-
sessionStore,
200-
invoke: async (req) => {
201-
commands.push(req.command);
202-
return { ok: true, data: {} };
203-
},
204-
});
205-
206-
expect(response.ok).toBe(true);
207-
expect(commands).toEqual(['open', 'close', 'open']);
208-
});
209-
210-
test('--keep-session is a no-op for an already close-less script', async () => {
211-
const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-device-replay-keep-close-less-'));
212-
const sessionStore = new SessionStore(path.join(root, 'sessions'));
213-
const sessionName = 'default';
214-
sessionStore.set(sessionName, makeIosSession(sessionName));
215-
const filePath = writeReplayFile(root, ['open "Demo"', 'click "Save"']);
216-
const invoke = vi.fn(async (_req: DaemonRequest) => ({ ok: true as const, data: {} }));
217-
218-
const response = await runReplayScriptFile({
219-
req: baseReq({ positionals: [filePath], flags: { replayKeepSession: true } }),
220-
sessionName,
221-
logPath: path.join(root, 'daemon.log'),
222-
sessionStore,
223-
invoke,
224-
});
225-
226-
expect(response.ok).toBe(true);
227-
expect(invoke.mock.calls.map(([req]) => req.command)).toEqual(['open', 'click']);
228-
if (!response.ok) return;
229-
expect((response.data as { sessionActive: boolean }).sessionActive).toBe(true);
230-
});
231-
232-
test('--keep-session rejects Maestro YAML before engine dispatch', async () => {
233-
const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-device-replay-keep-maestro-'));
234-
const sessionStore = new SessionStore(path.join(root, 'sessions'));
235-
const sessionName = 'default';
236-
sessionStore.set(sessionName, makeIosSession(sessionName));
237-
const filePath = path.join(root, 'flow.yaml');
238-
fs.writeFileSync(filePath, ['appId: com.example.app', '---', '- launchApp'].join('\n'));
239-
const invoke = vi.fn(async () => ({ ok: true as const, data: {} }));
240-
241-
const response = await runReplayScriptFile({
242-
req: baseReq({
243-
positionals: [filePath],
244-
flags: { replayBackend: 'maestro', replayKeepSession: true },
245-
}),
246-
sessionName,
247-
logPath: path.join(root, 'daemon.log'),
248-
sessionStore,
249-
invoke,
250-
});
251-
252-
expect(response).toMatchObject({
253-
ok: false,
254-
error: { code: 'INVALID_ARGS', message: expect.stringContaining('--keep-session') },
255-
});
256-
expect(invoke).not.toHaveBeenCalled();
257-
});
258-
259106
test('Maestro YAML uses the typed engine while .ad remains generic', async () => {
260107
const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-device-typed-maestro-route-'));
261108
const sessionStore = new SessionStore(path.join(root, 'sessions'));
Lines changed: 170 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,170 @@
1+
import { test, expect, vi } from 'vitest';
2+
3+
vi.mock('../../../core/dispatch.ts', async (importOriginal) => {
4+
const actual = await importOriginal<typeof import('../../../core/dispatch.ts')>();
5+
return { ...actual, dispatchCommand: vi.fn(async () => ({})), resolveTargetDevice: vi.fn() };
6+
});
7+
8+
import fs from 'node:fs';
9+
import os from 'node:os';
10+
import path from 'node:path';
11+
import { runReplayScriptFile } from '../session-replay-runtime.ts';
12+
import { SessionStore } from '../../session-store.ts';
13+
import type { DaemonRequest } from '../../types.ts';
14+
import { makeIosSession } from '../../../__tests__/test-utils/session-factories.ts';
15+
import {
16+
baseReplayRequest as baseReq,
17+
writeReplayFile,
18+
} from './session-replay-runtime.fixtures.ts';
19+
20+
test('--keep-session suppresses a close that is terminal among executable actions', async () => {
21+
const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-device-replay-keep-marker-tail-'));
22+
const sessionStore = new SessionStore(path.join(root, 'sessions'));
23+
const sessionName = 'default';
24+
sessionStore.set(sessionName, makeIosSession(sessionName));
25+
const filePath = writeReplayFile(root, ['open "Demo"', 'close', 'replay "./nested-flow.ad"']);
26+
const commands: string[] = [];
27+
28+
const response = await runReplayScriptFile({
29+
req: baseReq({ positionals: [filePath], flags: { replayKeepSession: true } }),
30+
sessionName,
31+
logPath: path.join(root, 'daemon.log'),
32+
sessionStore,
33+
invoke: async (req) => {
34+
commands.push(req.command);
35+
if (req.command === 'close') sessionStore.delete(sessionName);
36+
return { ok: true, data: {} };
37+
},
38+
});
39+
40+
expect(response.ok).toBe(true);
41+
expect(commands).toEqual(['open']);
42+
if (!response.ok) return;
43+
expect(response.data).toMatchObject({ sessionActive: true, replayed: 1 });
44+
});
45+
46+
test('--keep-session fails explicitly when the completed replay has no live session', async () => {
47+
const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-device-replay-keep-postcondition-'));
48+
const sessionStore = new SessionStore(path.join(root, 'sessions'));
49+
const sessionName = 'default';
50+
sessionStore.set(sessionName, makeIosSession(sessionName));
51+
const filePath = writeReplayFile(root, ['open "Demo"', 'click "Log out"']);
52+
53+
const response = await runReplayScriptFile({
54+
req: baseReq({ positionals: [filePath], flags: { replayKeepSession: true } }),
55+
sessionName,
56+
logPath: path.join(root, 'daemon.log'),
57+
sessionStore,
58+
invoke: async (req) => {
59+
if (req.command === 'click') sessionStore.delete(sessionName);
60+
return { ok: true, data: {} };
61+
},
62+
});
63+
64+
expect(response).toMatchObject({
65+
ok: false,
66+
error: {
67+
code: 'COMMAND_FAILED',
68+
message: expect.stringContaining('--keep-session could not preserve session'),
69+
},
70+
});
71+
});
72+
73+
test('--keep-session suppresses only the authored terminal close and reports the surviving session', async () => {
74+
const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-device-replay-keep-session-'));
75+
const sessionStore = new SessionStore(path.join(root, 'sessions'));
76+
const sessionName = 'default';
77+
sessionStore.set(sessionName, makeIosSession(sessionName));
78+
const filePath = writeReplayFile(root, ['open "Demo"', 'click "Save"', 'close']);
79+
const commands: string[] = [];
80+
81+
const response = await runReplayScriptFile({
82+
req: baseReq({ positionals: [filePath], flags: { replayKeepSession: true } }),
83+
sessionName,
84+
logPath: path.join(root, 'daemon.log'),
85+
sessionStore,
86+
invoke: async (req) => {
87+
commands.push(req.command);
88+
if (req.command === 'close') sessionStore.delete(sessionName);
89+
return { ok: true, data: {} };
90+
},
91+
});
92+
93+
expect(commands).toEqual(['open', 'click']);
94+
expect(response.ok).toBe(true);
95+
if (!response.ok) return;
96+
expect(sessionStore.get(sessionName)).toBeDefined();
97+
expect(response.data).toMatchObject({ sessionActive: true, replayed: 2 });
98+
});
99+
100+
test('--keep-session preserves an interior close instead of broad command filtering', async () => {
101+
const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-device-replay-keep-interior-close-'));
102+
const sessionStore = new SessionStore(path.join(root, 'sessions'));
103+
const sessionName = 'default';
104+
sessionStore.set(sessionName, makeIosSession(sessionName));
105+
const filePath = writeReplayFile(root, ['open "Demo"', 'close', 'open "Next"']);
106+
const commands: string[] = [];
107+
108+
const response = await runReplayScriptFile({
109+
req: baseReq({ positionals: [filePath], flags: { replayKeepSession: true } }),
110+
sessionName,
111+
logPath: path.join(root, 'daemon.log'),
112+
sessionStore,
113+
invoke: async (req) => {
114+
commands.push(req.command);
115+
return { ok: true, data: {} };
116+
},
117+
});
118+
119+
expect(response.ok).toBe(true);
120+
expect(commands).toEqual(['open', 'close', 'open']);
121+
});
122+
123+
test('--keep-session is a no-op for an already close-less script', async () => {
124+
const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-device-replay-keep-close-less-'));
125+
const sessionStore = new SessionStore(path.join(root, 'sessions'));
126+
const sessionName = 'default';
127+
sessionStore.set(sessionName, makeIosSession(sessionName));
128+
const filePath = writeReplayFile(root, ['open "Demo"', 'click "Save"']);
129+
const invoke = vi.fn(async (_req: DaemonRequest) => ({ ok: true as const, data: {} }));
130+
131+
const response = await runReplayScriptFile({
132+
req: baseReq({ positionals: [filePath], flags: { replayKeepSession: true } }),
133+
sessionName,
134+
logPath: path.join(root, 'daemon.log'),
135+
sessionStore,
136+
invoke,
137+
});
138+
139+
expect(response.ok).toBe(true);
140+
expect(invoke.mock.calls.map(([req]) => req.command)).toEqual(['open', 'click']);
141+
if (!response.ok) return;
142+
expect((response.data as { sessionActive: boolean }).sessionActive).toBe(true);
143+
});
144+
145+
test('--keep-session rejects Maestro YAML before engine dispatch', async () => {
146+
const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-device-replay-keep-maestro-'));
147+
const sessionStore = new SessionStore(path.join(root, 'sessions'));
148+
const sessionName = 'default';
149+
sessionStore.set(sessionName, makeIosSession(sessionName));
150+
const filePath = path.join(root, 'flow.yaml');
151+
fs.writeFileSync(filePath, ['appId: com.example.app', '---', '- launchApp'].join('\n'));
152+
const invoke = vi.fn(async () => ({ ok: true as const, data: {} }));
153+
154+
const response = await runReplayScriptFile({
155+
req: baseReq({
156+
positionals: [filePath],
157+
flags: { replayBackend: 'maestro', replayKeepSession: true },
158+
}),
159+
sessionName,
160+
logPath: path.join(root, 'daemon.log'),
161+
sessionStore,
162+
invoke,
163+
});
164+
165+
expect(response).toMatchObject({
166+
ok: false,
167+
error: { code: 'INVALID_ARGS', message: expect.stringContaining('--keep-session') },
168+
});
169+
expect(invoke).not.toHaveBeenCalled();
170+
});

0 commit comments

Comments
 (0)