@pi-chamber/web 0.9.3 → 0.9.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (92) hide show
  1. package/README.md +16 -1
  2. package/dist/assets/{DiagramEditor-DuGmiPZ5.js → DiagramEditor-BPDkGHsj.js} +1 -1
  3. package/dist/assets/DiagramView-D_EfDz2d.js +1 -0
  4. package/dist/assets/{DiffView-DVd1MLPB.js → DiffView-BmIVvheE.js} +2 -2
  5. package/dist/assets/FilesView-CJytSUAX.js +6 -0
  6. package/dist/assets/GitView-BNkzec7G.js +8 -0
  7. package/dist/assets/{JsonTreeView-Cyy0lEZR.js → JsonTreeView-C1Kzaybf.js} +1 -1
  8. package/dist/assets/MarkdownRendererImpl-qmKiFVpO.js +12 -0
  9. package/dist/assets/PatchDiff-D9JesZL1.js +1 -0
  10. package/dist/assets/{SessionSwitcherContent-dr3g9DR7.js → SessionSwitcherContent-DplV_ApH.js} +1 -1
  11. package/dist/assets/SessionSwitcherDropdown-DdgDKT6K.js +2 -0
  12. package/dist/assets/SessionUnreadDot-BdSDgvhC.js +1 -0
  13. package/dist/assets/SettingsView-z8uf0XyM.js +2 -0
  14. package/dist/assets/SettingsWindow-CPDmgNg2.js +1 -0
  15. package/dist/assets/ToolOutputDialog-DaF1xcM0.js +8 -0
  16. package/dist/assets/ToolPartDiffPreview-Di6Uo0Dt.js +1 -0
  17. package/dist/assets/{VirtualizedFileDiff-iqwryMNU.js → VirtualizedFileDiff-wqcrY0yr.js} +3 -3
  18. package/dist/assets/collapsible-DBQnXTNm.js +1 -0
  19. package/dist/assets/computeVirtualFileMetrics-Cr3jh0d6.js +3 -0
  20. package/dist/assets/contextFileOpenGuard-C_AOTYQD.js +1 -0
  21. package/dist/assets/gitStatusPredicates-BvPOjeOy.js +134 -0
  22. package/dist/assets/index-B8Wt2aN3.js +1 -0
  23. package/dist/assets/index-DIF8b4bh.css +1 -0
  24. package/dist/assets/index-jrfQYSvP.js +8 -0
  25. package/dist/assets/isDiffPlainText-L9uvgz2F.js +1 -0
  26. package/dist/assets/isFilePlainText-C4yk5BOo.js +1 -0
  27. package/dist/assets/main-C1OSzD-E.js +135 -0
  28. package/dist/assets/{main-DMyWi0qs.js → main-DCK6lLCo.js} +2 -2
  29. package/dist/assets/{markdownCore-BD5WkOKU.js → markdownCore-Czb_lINQ.js} +2 -2
  30. package/dist/assets/{miniChat-CLMNhna4.js → miniChat-CXiSlptL.js} +2 -2
  31. package/dist/assets/{mobile-rWMDwhtQ.js → mobile-D0HVxiyJ.js} +2 -2
  32. package/dist/assets/renderElectronMiniChatApp-BcG209a4.js +2 -0
  33. package/dist/assets/renderMobileApp-B5x_PWlc.js +11 -0
  34. package/dist/assets/runtimeEndpointReset-CUiPe6dQ.js +53 -0
  35. package/dist/assets/{runtimeSurface-CySRuLbN.js → runtimeSurface-vilE4xyj.js} +1 -1
  36. package/dist/assets/{useAppFontEffects-DfuJVB15.js → useAppFontEffects-BP07Vl6M.js} +102 -103
  37. package/dist/assets/useFilesViewSearch-oxIKk-ea.js +7 -0
  38. package/dist/assets/usePushVisibilityBeacon-CChMvoTL.js +10 -0
  39. package/dist/assets/useSwitcherItems-_RSo3F-A.js +1 -0
  40. package/dist/assets/{vendor-base-ui-vkqQ2P9o.js → vendor-base-ui-CdaWtC7e.js} +1 -1
  41. package/dist/assets/vendor-beautiful-mermaid-D3YCkKz7.js +111 -0
  42. package/dist/assets/{vendor-codemirror-commands-DYppkHEk.js → vendor-codemirror-commands-CNlncqrr.js} +1 -1
  43. package/dist/assets/{vendor-codemirror-language-data-CDdfwzlS.js → vendor-codemirror-language-data-BJrrV83E.js} +2 -2
  44. package/dist/assets/{vendor-replit-codemirror-vim-CGHHNQxC.js → vendor-replit-codemirror-vim-DaSwPsXt.js} +1 -1
  45. package/dist/assets/{web-components-C9wXMuCp.js → web-components-B5sMa_kC.js} +3 -3
  46. package/dist/index.html +4 -4
  47. package/dist/mini-chat.html +3 -3
  48. package/dist/mobile.html +3 -3
  49. package/package.json +2 -2
  50. package/server/lib/pi/routes.js +13 -3
  51. package/server/lib/pi/routes.test.js +55 -1
  52. package/server/lib/pi/session-daemon/DOCUMENTATION.md +17 -6
  53. package/server/lib/pi/session-daemon/prompt-operations.test.js +193 -0
  54. package/server/lib/pi/session-daemon/sdk-upgrade.test.js +157 -0
  55. package/server/lib/pi/session-daemon/session-daemon.js +418 -129
  56. package/server/lib/pi/session-daemon/session-daemon.test.js +186 -0
  57. package/server/lib/pi/session-daemon/session-idle-residency.test.js +742 -0
  58. package/server/lib/pi/session-daemon/session-replay.js +98 -0
  59. package/server/lib/pi/session-daemon/session-replay.test.js +626 -0
  60. package/server/lib/pi/ui-settings-store.js +16 -10
  61. package/server/lib/pi/ui-settings-store.test.js +91 -0
  62. package/server/lib/stt/DOCUMENTATION.md +1 -1
  63. package/server/lib/stt/local/worker-client.js +11 -3
  64. package/server/lib/stt/local/worker-client.test.js +255 -0
  65. package/dist/assets/DiagramView-CV-iReyY.js +0 -1
  66. package/dist/assets/FilesView-CPnW4I90.js +0 -6
  67. package/dist/assets/GitView-Dj_7hgX_.js +0 -8
  68. package/dist/assets/MarkdownRendererImpl-BXN78Wu_.js +0 -12
  69. package/dist/assets/PatchDiff-C7dA3U29.js +0 -1
  70. package/dist/assets/SessionSwitcherDropdown-C3zdd82V.js +0 -2
  71. package/dist/assets/SessionUnreadDot-qeik5qtT.js +0 -1
  72. package/dist/assets/SettingsView-C57uV1YS.js +0 -2
  73. package/dist/assets/SettingsWindow-Bbay2W76.js +0 -1
  74. package/dist/assets/ToolOutputDialog-CRTiN1CH.js +0 -8
  75. package/dist/assets/ToolPartDiffPreview-CqnNcLPk.js +0 -1
  76. package/dist/assets/collapsible-szfZ0Syc.js +0 -1
  77. package/dist/assets/computeVirtualFileMetrics-Bbugxxtp.js +0 -3
  78. package/dist/assets/contextFileOpenGuard-BC3ie230.js +0 -1
  79. package/dist/assets/gitStatusPredicates-DbThKVSf.js +0 -134
  80. package/dist/assets/index-DNoEeZ2U.css +0 -1
  81. package/dist/assets/index-KIdiBFJs.js +0 -8
  82. package/dist/assets/index-v6K3L94m.js +0 -1
  83. package/dist/assets/isDiffPlainText-Dl0RBjPZ.js +0 -1
  84. package/dist/assets/isFilePlainText-CbrmvrM6.js +0 -1
  85. package/dist/assets/main-4PkIvzf4.js +0 -135
  86. package/dist/assets/renderElectronMiniChatApp-BRhGNRJ8.js +0 -2
  87. package/dist/assets/renderMobileApp-DLy2YoQg.js +0 -11
  88. package/dist/assets/runtimeEndpointReset-Z9YtcHxZ.js +0 -54
  89. package/dist/assets/useFilesViewSearch-BZBHrZ90.js +0 -7
  90. package/dist/assets/usePushVisibilityBeacon-BxTkEajM.js +0 -10
  91. package/dist/assets/useSwitcherItems-jITqE8PV.js +0 -1
  92. package/dist/assets/vendor-beautiful-mermaid-DneUawHp.js +0 -119
@@ -0,0 +1,742 @@
1
+ import { afterEach, describe, expect, it } from 'vitest';
2
+ import { mkdtemp, rm, stat, writeFile } from 'node:fs/promises';
3
+ import { createHash } from 'node:crypto';
4
+ import { createConnection } from 'node:net';
5
+ import { tmpdir } from 'node:os';
6
+ import { join } from 'node:path';
7
+ import { StringDecoder } from 'node:string_decoder';
8
+
9
+ import { createSessionDaemon as createSessionDaemonImpl } from './session-daemon.js';
10
+
11
+ const credential = 'a-private-daemon-credential';
12
+
13
+ function createSessionDaemon(options) {
14
+ return createSessionDaemonImpl({ ...options, agentDir: options.agentDir ?? options.cwd });
15
+ }
16
+
17
+ function sleep(ms) {
18
+ return new Promise((resolve) => setTimeout(resolve, ms));
19
+ }
20
+
21
+ async function waitFor(predicate, { timeoutMs = 5_000, intervalMs = 10, message = 'Timed out' } = {}) {
22
+ const start = Date.now();
23
+ for (;;) {
24
+ try {
25
+ if (await predicate()) {
26
+ return true;
27
+ }
28
+ } catch {
29
+ // Retry until the timeout expires.
30
+ }
31
+ if (Date.now() - start > timeoutMs) {
32
+ throw new Error(message);
33
+ }
34
+ await sleep(intervalMs);
35
+ }
36
+ }
37
+
38
+ function createDeferred() {
39
+ let resolve;
40
+ let reject;
41
+ const promise = new Promise((accept, decline) => {
42
+ resolve = accept;
43
+ reject = decline;
44
+ });
45
+ return { promise, resolve, reject };
46
+ }
47
+
48
+ class FakeSession {
49
+ constructor(sessionId = 'pi-session-1', sessionFile, entries = []) {
50
+ this.sessionId = sessionId;
51
+ this.isStreaming = false;
52
+ this.isCompacting = false;
53
+ this.listeners = new Set();
54
+ this.names = [];
55
+ this.entries = entries;
56
+ this.sent = [];
57
+ this.aborted = 0;
58
+ this.compacted = 0;
59
+ this.pendingSend = undefined;
60
+ this.model = { provider: 'test', id: 'model' };
61
+ this.thinkingLevel = 'low';
62
+ this.sessionManager = {
63
+ getSessionFile: () => sessionFile,
64
+ getHeader: () => ({ timestamp: '2026-01-01T00:00:00.000Z' }),
65
+ getEntries: () => this.entries,
66
+ getEntry: (entryId) => this.entries.find((candidate) => candidate.id === entryId),
67
+ getLeafId: () => 'fake-entry',
68
+ getTree: () => [
69
+ {
70
+ entry: { id: 'fake-entry', parentId: undefined, timestamp: '2026-01-01T00:00:00.000Z' },
71
+ children: [],
72
+ },
73
+ ],
74
+ appendSessionInfo: (name) => this.names.push(name),
75
+ getSessionName: () => this.names[this.names.length - 1],
76
+ };
77
+ }
78
+
79
+ subscribe(listener) {
80
+ this.listeners.add(listener);
81
+ return () => this.listeners.delete(listener);
82
+ }
83
+
84
+ emit(event) {
85
+ for (const listener of this.listeners) {
86
+ listener(event);
87
+ }
88
+ }
89
+
90
+ async prompt() {}
91
+
92
+ async sendUserMessage(text, options) {
93
+ this.sent.push({ text, options });
94
+ if (this.pendingSend) {
95
+ await this.pendingSend;
96
+ }
97
+ }
98
+
99
+ async setModel(model) {
100
+ this.model = model;
101
+ }
102
+
103
+ setThinkingLevel(thinkingLevel) {
104
+ this.thinkingLevel = thinkingLevel;
105
+ }
106
+
107
+ async abort() {
108
+ this.aborted += 1;
109
+ this.isStreaming = false;
110
+ }
111
+
112
+ async compact() {
113
+ this.compacted += 1;
114
+ }
115
+
116
+ async navigateTree(messageId) {
117
+ this.navigatedTo = messageId;
118
+ return { cancelled: false };
119
+ }
120
+
121
+ getSteeringMessages() {
122
+ return [];
123
+ }
124
+
125
+ getFollowUpMessages() {
126
+ return [];
127
+ }
128
+ }
129
+
130
+ class FakeRuntime {
131
+ constructor({ cwd, session }) {
132
+ this.cwd = cwd;
133
+ this.session = session;
134
+ this.disposed = false;
135
+ }
136
+
137
+ async dispose() {
138
+ this.disposed = true;
139
+ }
140
+ }
141
+
142
+ function createUserMessageEntry(entryId, text) {
143
+ return {
144
+ type: 'message',
145
+ id: entryId,
146
+ timestamp: '2026-01-01T00:00:00.000Z',
147
+ message: {
148
+ role: 'user',
149
+ content: text,
150
+ timestamp: Date.parse('2026-01-01T00:00:00.000Z'),
151
+ },
152
+ };
153
+ }
154
+
155
+ function createSessionHeaderLine(sessionId, cwd) {
156
+ const header = {
157
+ type: 'session',
158
+ id: sessionId,
159
+ cwd,
160
+ timestamp: '2026-01-01T00:00:00.000Z',
161
+ };
162
+ return `${JSON.stringify(header)}\n`;
163
+ }
164
+
165
+ function testDaemonEndpoint(root) {
166
+ if (process.platform === 'win32') {
167
+ const pipeHash = createHash('sha1').update(root).digest('hex').slice(0, 16);
168
+ return `\\\\.\\pipe\\pichamber-test-${pipeHash}`;
169
+ }
170
+ return join(root, 'daemon.sock');
171
+ }
172
+
173
+ function connectDaemonClient(endpoint) {
174
+ const socket = createConnection({ path: endpoint });
175
+ const decoder = new StringDecoder('utf8');
176
+ let buffer = '';
177
+ const messages = [];
178
+ const waiters = [];
179
+
180
+ const publishMessage = (message) => {
181
+ messages.push(message);
182
+ for (let index = waiters.length - 1; index >= 0; index -= 1) {
183
+ const waiter = waiters[index];
184
+ if (waiter.predicate(message)) {
185
+ waiters.splice(index, 1);
186
+ clearTimeout(waiter.timer);
187
+ waiter.resolve(message);
188
+ }
189
+ }
190
+ };
191
+
192
+ const failPendingWaiters = (error) => {
193
+ for (const waiter of waiters.splice(0)) {
194
+ clearTimeout(waiter.timer);
195
+ waiter.reject(error);
196
+ }
197
+ };
198
+
199
+ socket.on('data', (chunk) => {
200
+ buffer += decoder.write(chunk);
201
+ let newlineIndex;
202
+ while ((newlineIndex = buffer.indexOf('\n')) !== -1) {
203
+ const line = buffer.slice(0, newlineIndex).replace(/\r$/, '');
204
+ buffer = buffer.slice(newlineIndex + 1);
205
+ if (line) {
206
+ publishMessage(JSON.parse(line));
207
+ }
208
+ }
209
+ });
210
+ socket.on('close', () => {
211
+ failPendingWaiters(new Error('Daemon connection closed'));
212
+ });
213
+
214
+ const waitForMessage = (predicate) => {
215
+ const hit = messages.find(predicate);
216
+ if (hit) {
217
+ return Promise.resolve(hit);
218
+ }
219
+ return new Promise((resolve, reject) => {
220
+ const waiter = {
221
+ predicate,
222
+ resolve: (message) => {
223
+ clearTimeout(waiter.timer);
224
+ resolve(message);
225
+ },
226
+ reject: (error) => {
227
+ clearTimeout(waiter.timer);
228
+ reject(error);
229
+ },
230
+ };
231
+ waiter.timer = setTimeout(() => {
232
+ const index = waiters.indexOf(waiter);
233
+ if (index !== -1) {
234
+ waiters.splice(index, 1);
235
+ }
236
+ reject(new Error('Timed out waiting for daemon message'));
237
+ }, 5_000);
238
+ waiters.push(waiter);
239
+ });
240
+ };
241
+
242
+ return {
243
+ socket,
244
+ waitForMessage,
245
+ async authenticate(credentialOverride = credential) {
246
+ await new Promise((resolve, reject) => {
247
+ socket.once('connect', resolve);
248
+ socket.once('error', reject);
249
+ });
250
+ socket.write(`${JSON.stringify({ kind: 'authenticate', credential: credentialOverride })}\n`);
251
+ await waitForMessage((message) => message.kind === 'authenticated');
252
+ return waitForMessage((message) => message.kind === 'event' && message.event === 'session.snapshot');
253
+ },
254
+ request(command, payload = {}) {
255
+ const requestId = `request-${Math.random()}`;
256
+ const frame = {
257
+ protocolVersion: 1,
258
+ kind: 'request',
259
+ requestId,
260
+ command,
261
+ payload,
262
+ };
263
+ socket.write(`${JSON.stringify(frame)}\n`);
264
+ return waitForMessage((message) => message.kind === 'response' && message.requestId === requestId);
265
+ },
266
+ async close() {
267
+ failPendingWaiters(new Error('Daemon client closed'));
268
+ if (socket.destroyed) {
269
+ return;
270
+ }
271
+ socket.end();
272
+ await Promise.race([
273
+ new Promise((resolve) => socket.once('close', resolve)),
274
+ new Promise((resolve) => setTimeout(resolve, 1_000)),
275
+ ]);
276
+ },
277
+ };
278
+ }
279
+
280
+ describe('Pi session daemon idle residency', () => {
281
+ let daemon;
282
+ const temporaryRoots = new Set();
283
+ const connectedClients = new Set();
284
+
285
+ const createTemporaryRoot = async (prefix) => {
286
+ const root = await mkdtemp(join(tmpdir(), prefix));
287
+ temporaryRoots.add(root);
288
+ return root;
289
+ };
290
+
291
+ const connectAuthenticatedClient = async (endpoint) => {
292
+ const client = connectDaemonClient(endpoint);
293
+ connectedClients.add(client);
294
+ await client.authenticate();
295
+ return client;
296
+ };
297
+
298
+ const createPendingClient = (endpoint) => {
299
+ const client = connectDaemonClient(endpoint);
300
+ connectedClients.add(client);
301
+ return client;
302
+ };
303
+
304
+ const openSession = (client, sessionId, directory) => {
305
+ if (directory) {
306
+ return client.request('sessions.open', { sessionId, directory });
307
+ }
308
+ return client.request('sessions.open', { sessionId });
309
+ };
310
+
311
+ const isExpectedSocketClosure = (error) => /Daemon (connection closed|client closed)/.test(error?.message ?? '');
312
+
313
+ async function expectRequestFailure(requestPromise) {
314
+ try {
315
+ await expect(requestPromise).rejects.toThrow();
316
+ } catch (error) {
317
+ if (!isExpectedSocketClosure(error)) {
318
+ throw error;
319
+ }
320
+ }
321
+ }
322
+
323
+ async function startSingleSessionDaemon(prefix, sessionId, idleTimeoutMs, createRuntimeOverride) {
324
+ const root = await createTemporaryRoot(prefix);
325
+ const endpoint = testDaemonEndpoint(root);
326
+ const sessionFile = join(root, 'session.jsonl');
327
+ await writeFile(sessionFile, createSessionHeaderLine(sessionId, root));
328
+
329
+ const runtimes = [];
330
+ const defaultCreateRuntime = async (daemonOptions) => {
331
+ const runtimeCwd = typeof daemonOptions?.cwd === 'string' && daemonOptions.cwd.length > 0
332
+ ? daemonOptions.cwd
333
+ : root;
334
+ const runtime = new FakeRuntime({
335
+ cwd: runtimeCwd,
336
+ session: new FakeSession(sessionId, sessionFile),
337
+ });
338
+ runtimes.push(runtime);
339
+ return runtime;
340
+ };
341
+ const createRuntimeFactory = createRuntimeOverride ?? defaultCreateRuntime;
342
+ const trackedCreateRuntime = async (...args) => {
343
+ const runtime = await createRuntimeFactory(...args);
344
+ if (!runtimes.includes(runtime)) {
345
+ runtimes.push(runtime);
346
+ }
347
+ return runtime;
348
+ };
349
+
350
+ daemon = createSessionDaemon({
351
+ endpoint,
352
+ credential,
353
+ cwd: root,
354
+ idleTimeoutMs,
355
+ listSessions: async () => [{ path: sessionFile, id: sessionId, cwd: root }],
356
+ createRuntime: trackedCreateRuntime,
357
+ });
358
+ await daemon.start();
359
+ return { root, endpoint, sessionFile, runtimes };
360
+ }
361
+
362
+ afterEach(async () => {
363
+ for (const client of [...connectedClients]) {
364
+ connectedClients.delete(client);
365
+ await client.close().catch(() => {});
366
+ }
367
+ await daemon?.stop().catch(() => {});
368
+ daemon = undefined;
369
+ for (const root of [...temporaryRoots]) {
370
+ temporaryRoots.delete(root);
371
+ await rm(root, { recursive: true, force: true }).catch(() => {});
372
+ }
373
+ });
374
+
375
+ it('disposes browse-only sessions after the idle timeout and reopens them from JSONL', async () => {
376
+ const sessionCount = 20;
377
+ const root = await createTemporaryRoot('pichamber-pi-daemon-idle-residency-');
378
+ const endpoint = testDaemonEndpoint(root);
379
+ const sessionFiles = [];
380
+ for (let index = 0; index < sessionCount; index += 1) {
381
+ const sessionId = `idle-session-${index}`;
382
+ const sessionPath = join(root, `idle-${index}.jsonl`);
383
+ await writeFile(sessionPath, createSessionHeaderLine(sessionId, root));
384
+ sessionFiles.push({ path: sessionPath, id: sessionId, cwd: root });
385
+ }
386
+
387
+ const runtimes = [];
388
+ const createdRuntimes = [];
389
+ daemon = createSessionDaemon({
390
+ endpoint,
391
+ credential,
392
+ cwd: root,
393
+ idleTimeoutMs: 600,
394
+ listSessions: async () => sessionFiles,
395
+ createRuntime: async (daemonOptions) => {
396
+ createdRuntimes.push(daemonOptions);
397
+ const matchedFile = sessionFiles.find((candidate) => candidate.path === daemonOptions.sessionFile);
398
+ const runtimeCwd = typeof daemonOptions?.cwd === 'string' && daemonOptions.cwd.length > 0
399
+ ? daemonOptions.cwd
400
+ : root;
401
+ const runtime = new FakeRuntime({
402
+ cwd: runtimeCwd,
403
+ session: new FakeSession(
404
+ matchedFile.id,
405
+ matchedFile.path,
406
+ [createUserMessageEntry(`entry-${matchedFile.id}`, `hello ${matchedFile.id}`)],
407
+ ),
408
+ });
409
+ runtimes.push(runtime);
410
+ return runtime;
411
+ },
412
+ });
413
+ await daemon.start();
414
+
415
+ const client = await connectAuthenticatedClient(endpoint);
416
+ for (const sessionFile of sessionFiles) {
417
+ const opened = await openSession(client, sessionFile.id, root);
418
+ expect(opened.result.session.id).toBe(sessionFile.id);
419
+ }
420
+ expect(runtimes.filter((runtime) => !runtime.disposed)).toHaveLength(sessionCount);
421
+ expect(createdRuntimes).toHaveLength(sessionCount);
422
+
423
+ await waitFor(() => runtimes.every((runtime) => runtime.disposed), {
424
+ timeoutMs: 8_000,
425
+ message: 'browse-only sessions were not disposed',
426
+ });
427
+ for (const sessionFile of sessionFiles) {
428
+ await expect(stat(sessionFile.path)).resolves.toMatchObject({ isFile: expect.any(Function) });
429
+ }
430
+
431
+ const reopened = await openSession(client, sessionFiles[0].id, root);
432
+ expect(reopened.result.session.id).toBe(sessionFiles[0].id);
433
+ expect(reopened.result.messages).toHaveLength(1);
434
+ expect(reopened.result.messages[0].message.text).toBe(`hello ${sessionFiles[0].id}`);
435
+ expect(createdRuntimes).toHaveLength(sessionCount + 1);
436
+ });
437
+
438
+ it('rearms the idle timer on repeated view-only opens', async () => {
439
+ const { root, endpoint, runtimes } = await startSingleSessionDaemon(
440
+ 'pichamber-pi-daemon-idle-touch-',
441
+ 'touch-session',
442
+ 300,
443
+ );
444
+ const client = await connectAuthenticatedClient(endpoint);
445
+ await openSession(client, 'touch-session', root);
446
+ await sleep(100);
447
+ await openSession(client, 'touch-session', root);
448
+ await sleep(100);
449
+ expect(runtimes).toHaveLength(1);
450
+ expect(runtimes[0].disposed).toBe(false);
451
+ await waitFor(() => runtimes[0].disposed === true, {
452
+ message: 're-armed idle timer never disposed',
453
+ });
454
+ });
455
+
456
+ it('protects an active prompt and its retry window from idle disposal', async () => {
457
+ const root = await createTemporaryRoot('pichamber-pi-daemon-idle-active-');
458
+ const endpoint = testDaemonEndpoint(root);
459
+ const sessionFile = join(root, 'session.jsonl');
460
+ await writeFile(sessionFile, createSessionHeaderLine('active-session', root));
461
+
462
+ const session = new FakeSession('active-session', sessionFile);
463
+ const sendGate = createDeferred();
464
+ session.pendingSend = sendGate.promise;
465
+ const runtime = new FakeRuntime({ cwd: root, session });
466
+ daemon = createSessionDaemon({
467
+ endpoint,
468
+ credential,
469
+ cwd: root,
470
+ idleTimeoutMs: 200,
471
+ listSessions: async () => [{ path: sessionFile, id: 'active-session', cwd: root }],
472
+ createRuntime: async () => runtime,
473
+ });
474
+ await daemon.start();
475
+
476
+ const client = await connectAuthenticatedClient(endpoint);
477
+ await openSession(client, 'active-session', root);
478
+ await expect(
479
+ client.request('sessions.prompt', { sessionId: 'active-session', text: 'do work' }),
480
+ ).resolves.toMatchObject({ result: { accepted: true } });
481
+
482
+ session.isStreaming = true;
483
+ session.emit({ type: 'agent_start' });
484
+ await sleep(350);
485
+ expect(runtime.disposed).toBe(false);
486
+
487
+ session.emit({
488
+ type: 'auto_retry_start',
489
+ attempt: 1,
490
+ delayMs: 1_000,
491
+ errorMessage: 'transient failure',
492
+ });
493
+ await sleep(350);
494
+ expect(runtime.disposed).toBe(false);
495
+
496
+ sendGate.resolve();
497
+ session.isStreaming = false;
498
+ session.emit({ type: 'agent_settled' });
499
+ await waitFor(() => runtime.disposed === true, {
500
+ message: 'settled session was not disposed',
501
+ });
502
+ });
503
+
504
+ it('rejects an unknown session without arming disposal for it', async () => {
505
+ const root = await createTemporaryRoot('pichamber-pi-daemon-idle-failed-');
506
+ const endpoint = testDaemonEndpoint(root);
507
+ let creations = 0;
508
+ daemon = createSessionDaemon({
509
+ endpoint,
510
+ credential,
511
+ cwd: root,
512
+ idleTimeoutMs: 200,
513
+ listSessions: async () => [],
514
+ createRuntime: async () => {
515
+ creations += 1;
516
+ return new FakeRuntime({ cwd: root, session: new FakeSession('missing', undefined) });
517
+ },
518
+ });
519
+ await daemon.start();
520
+
521
+ const client = await connectAuthenticatedClient(endpoint);
522
+ await expect(openSession(client, 'missing')).rejects.toThrow();
523
+ expect(creations).toBe(0);
524
+ });
525
+
526
+ it('shares one runtime for concurrent opens and disposes it on shutdown', async () => {
527
+ const createDelayedRuntime = async (daemonOptions) => {
528
+ await sleep(20);
529
+ const runtimeCwd = typeof daemonOptions?.cwd === 'string' && daemonOptions.cwd.length > 0
530
+ ? daemonOptions.cwd
531
+ : undefined;
532
+ const sessionFile = typeof daemonOptions?.sessionFile === 'string'
533
+ ? daemonOptions.sessionFile
534
+ : join(runtimeCwd ?? '', 'session.jsonl');
535
+ return new FakeRuntime({
536
+ cwd: runtimeCwd,
537
+ session: new FakeSession('shared-session', sessionFile),
538
+ });
539
+ };
540
+ const { endpoint, root, runtimes } = await startSingleSessionDaemon(
541
+ 'pichamber-pi-daemon-idle-shutdown-',
542
+ 'shared-session',
543
+ 10_000,
544
+ createDelayedRuntime,
545
+ );
546
+
547
+ const firstClient = createPendingClient(endpoint);
548
+ await firstClient.authenticate();
549
+ const secondClient = createPendingClient(endpoint);
550
+ await secondClient.authenticate();
551
+ const [firstOpened, secondOpened] = await Promise.all([
552
+ openSession(firstClient, 'shared-session', root),
553
+ openSession(secondClient, 'shared-session', root),
554
+ ]);
555
+ expect(firstOpened.result.session.id).toBe('shared-session');
556
+ expect(secondOpened.result.session.id).toBe('shared-session');
557
+ expect(runtimes).toHaveLength(1);
558
+
559
+ for (const client of [firstClient, secondClient]) {
560
+ connectedClients.delete(client);
561
+ await client.close().catch(() => {});
562
+ }
563
+ await daemon.stop();
564
+ daemon = undefined;
565
+ expect(runtimes[0].disposed).toBe(true);
566
+ });
567
+
568
+ it('does not cancel an unrelated idle timer on a malformed open', async () => {
569
+ const { root, endpoint, runtimes } = await startSingleSessionDaemon(
570
+ 'pichamber-pi-daemon-idle-malformed-',
571
+ 'resident-a',
572
+ 250,
573
+ );
574
+ const client = await connectAuthenticatedClient(endpoint);
575
+ const opened = await openSession(client, 'resident-a', root);
576
+ expect(opened.result.session.id).toBe('resident-a');
577
+ await expectRequestFailure(client.request('sessions.open', {}));
578
+ await waitFor(() => runtimes[0]?.disposed === true, {
579
+ message: 'malformed open cancelled the unrelated idle timer',
580
+ });
581
+ });
582
+
583
+ it.each([
584
+ [
585
+ 'read',
586
+ (sessionId, directory) => [
587
+ 'sessions.messages',
588
+ { sessionId, directory, before: 'stale-cursor' },
589
+ ],
590
+ ],
591
+ [
592
+ 'model change',
593
+ (sessionId, directory) => [
594
+ 'sessions.setModel',
595
+ { sessionId, directory, model: { providerId: 'missing', modelId: 'missing' } },
596
+ ],
597
+ ],
598
+ ])('still disposes after a failed existing-session %s', async (_label, buildRequest) => {
599
+ const { root, endpoint, runtimes } = await startSingleSessionDaemon(
600
+ 'pichamber-pi-daemon-idle-failed-op-',
601
+ 'fail-session',
602
+ 250,
603
+ );
604
+ const client = await connectAuthenticatedClient(endpoint);
605
+ await openSession(client, 'fail-session', root);
606
+ const [command, payload] = buildRequest('fail-session', root);
607
+ await expectRequestFailure(client.request(command, payload));
608
+ await waitFor(() => runtimes[0]?.disposed === true, {
609
+ message: 'failed operation leaked its idle runtime',
610
+ });
611
+ });
612
+
613
+ it('holds disposal while a slow operation and a fast read overlap', async () => {
614
+ const root = await createTemporaryRoot('pichamber-pi-daemon-idle-overlap-');
615
+ const endpoint = testDaemonEndpoint(root);
616
+ const sessionFile = join(root, 'session.jsonl');
617
+ await writeFile(sessionFile, createSessionHeaderLine('overlap-session', root));
618
+
619
+ const session = new FakeSession('overlap-session', sessionFile);
620
+ const runtime = new FakeRuntime({ cwd: root, session });
621
+ daemon = createSessionDaemon({
622
+ endpoint,
623
+ credential,
624
+ cwd: root,
625
+ idleTimeoutMs: 200,
626
+ listSessions: async () => [{ path: sessionFile, id: 'overlap-session', cwd: root }],
627
+ createRuntime: async () => runtime,
628
+ });
629
+ await daemon.start();
630
+
631
+ const slowClient = createPendingClient(endpoint);
632
+ await slowClient.authenticate();
633
+ const fastClient = createPendingClient(endpoint);
634
+ await fastClient.authenticate();
635
+
636
+ const releaseSlowOperation = createDeferred();
637
+ const slowOperationEntered = createDeferred();
638
+ const originalNavigateTree = session.navigateTree.bind(session);
639
+ let navigateCalls = 0;
640
+ session.navigateTree = async (messageId) => {
641
+ navigateCalls += 1;
642
+ slowOperationEntered.resolve();
643
+ await releaseSlowOperation.promise;
644
+ return originalNavigateTree(messageId);
645
+ };
646
+
647
+ try {
648
+ await openSession(slowClient, 'overlap-session', root);
649
+ const slowOperation = slowClient.request('sessions.navigate', {
650
+ sessionId: 'overlap-session',
651
+ directory: root,
652
+ messageId: 'fake-entry',
653
+ });
654
+ await slowOperationEntered.promise;
655
+ const fastOpened = await openSession(fastClient, 'overlap-session', root);
656
+ expect(fastOpened.result.session.id).toBe('overlap-session');
657
+ await sleep(350);
658
+ expect(navigateCalls).toBe(1);
659
+ expect(runtime.disposed).toBe(false);
660
+ releaseSlowOperation.resolve();
661
+ await slowOperation;
662
+ await waitFor(() => runtime.disposed === true, {
663
+ message: 'overlapped session was not disposed',
664
+ });
665
+ } finally {
666
+ releaseSlowOperation.resolve();
667
+ }
668
+ });
669
+
670
+ it('waits for a slow disposal before reopening from JSONL', async () => {
671
+ const { root, endpoint, runtimes } = await startSingleSessionDaemon(
672
+ 'pichamber-pi-daemon-idle-racing-',
673
+ 'racing-session',
674
+ 150,
675
+ );
676
+ const client = await connectAuthenticatedClient(endpoint);
677
+ const racingClient = createPendingClient(endpoint);
678
+ await racingClient.authenticate();
679
+
680
+ await openSession(client, 'racing-session', root);
681
+ expect(runtimes).toHaveLength(1);
682
+
683
+ const firstRuntime = runtimes[0];
684
+ let disposeCalls = 0;
685
+ const originalDispose = firstRuntime.dispose.bind(firstRuntime);
686
+ const releaseDisposal = createDeferred();
687
+ const disposalStarted = createDeferred();
688
+ firstRuntime.dispose = async () => {
689
+ disposeCalls += 1;
690
+ disposalStarted.resolve();
691
+ await releaseDisposal.promise;
692
+ await originalDispose();
693
+ };
694
+
695
+ await disposalStarted.promise;
696
+ const reopening = racingClient.request('sessions.open', {
697
+ sessionId: 'racing-session',
698
+ directory: root,
699
+ });
700
+ await sleep(50);
701
+ expect(disposeCalls).toBe(1);
702
+ releaseDisposal.resolve();
703
+
704
+ const reopened = await reopening;
705
+ expect(reopened.result.session.id).toBe('racing-session');
706
+ expect(firstRuntime.disposed).toBe(true);
707
+ expect(runtimes.length).toBeGreaterThanOrEqual(2);
708
+ expect(runtimes[runtimes.length - 1].disposed).toBe(false);
709
+ });
710
+
711
+ it('stops without double-disposing a racing idle disposal', async () => {
712
+ const { root, endpoint, runtimes } = await startSingleSessionDaemon(
713
+ 'pichamber-pi-daemon-idle-stop-race-',
714
+ 'stop-race-session',
715
+ 150,
716
+ );
717
+ const client = await connectAuthenticatedClient(endpoint);
718
+ await openSession(client, 'stop-race-session', root);
719
+ expect(runtimes).toHaveLength(1);
720
+
721
+ const targetRuntime = runtimes[0];
722
+ let disposeCalls = 0;
723
+ const originalDispose = targetRuntime.dispose.bind(targetRuntime);
724
+ const releaseDisposal = createDeferred();
725
+ const disposalStarted = createDeferred();
726
+ targetRuntime.dispose = async () => {
727
+ disposeCalls += 1;
728
+ disposalStarted.resolve();
729
+ await releaseDisposal.promise;
730
+ await originalDispose();
731
+ };
732
+
733
+ await disposalStarted.promise;
734
+ const stopping = daemon.stop();
735
+ await sleep(50);
736
+ releaseDisposal.resolve();
737
+ await stopping;
738
+ daemon = undefined;
739
+ expect(disposeCalls).toBe(1);
740
+ expect(targetRuntime.disposed).toBe(true);
741
+ });
742
+ });