@pi-chamber/web 0.9.6 → 0.9.7
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.
- package/dist/assets/{DiagramView-0Iq1ak1I.js → DiagramView-BvrCkm_z.js} +1 -1
- package/dist/assets/{DiffView-DD1AFRi3.js → DiffView-DMvRLRN1.js} +1 -1
- package/dist/assets/{FileSaveConflictDialog-CoKwDovb.js → FileSaveConflictDialog-DGa9u43J.js} +1 -1
- package/dist/assets/{FilesView-B_BF39ef.js → FilesView-CNHu4RnC.js} +4 -4
- package/dist/assets/{GitView-LFEpCasf.js → GitView-Cbepz-bR.js} +3 -3
- package/dist/assets/{JsonTreeView-Cwjgvh4g.js → JsonTreeView-C2X5oXQm.js} +1 -1
- package/dist/assets/{MarkdownRendererImpl-_7kV1yNw.js → MarkdownRendererImpl-BanSCkPy.js} +2 -2
- package/dist/assets/{PatchDiff-DG43C1HW.js → PatchDiff-i_9BIlgo.js} +1 -1
- package/dist/assets/{SessionSwitcherContent-DCFXPY3d.js → SessionSwitcherContent-DxS_rFuS.js} +1 -1
- package/dist/assets/{SessionSwitcherDropdown-QY7FKuEQ.js → SessionSwitcherDropdown-AVghToww.js} +2 -2
- package/dist/assets/{SessionUnreadDot-DGT31A3z.js → SessionUnreadDot-CDRZswx-.js} +1 -1
- package/dist/assets/SettingsView-hyAGp836.js +2 -0
- package/dist/assets/SettingsWindow-BfPUzBbq.js +1 -0
- package/dist/assets/{ToolOutputDialog-IlCrS6BR.js → ToolOutputDialog-CJ87b80H.js} +5 -5
- package/dist/assets/{ToolPartDiffPreview-D68JV0rR.js → ToolPartDiffPreview-bF486Lz1.js} +1 -1
- package/dist/assets/{VirtualizedFileDiff-Bl-rAYeh.js → VirtualizedFileDiff-CFpvcZ1g.js} +1 -1
- package/dist/assets/{collapsible-BjniCdZ5.js → collapsible-DesjbW8a.js} +1 -1
- package/dist/assets/{computeVirtualFileMetrics-FSOm2VrW.js → computeVirtualFileMetrics-CsAu9rOt.js} +1 -1
- package/dist/assets/{contextFileOpenGuard-Bxb6AIPa.js → contextFileOpenGuard-rILslsBJ.js} +1 -1
- package/dist/assets/{gitStatusPredicates-DxolDpMd.js → gitStatusPredicates-D_31YElh.js} +1 -1
- package/dist/assets/index-BXgR2dKM.css +1 -0
- package/dist/assets/index-BZpvAhrX.js +8 -0
- package/dist/assets/{index-Dh58uD3I.js → index-CXLVW_GG.js} +1 -1
- package/dist/assets/{isDiffPlainText-D3_04XCh.js → isDiffPlainText-BX609Lau.js} +1 -1
- package/dist/assets/{isFilePlainText-CHouYQhH.js → isFilePlainText-FgBWqu9b.js} +1 -1
- package/dist/assets/{main-CH3EqGJI.js → main-C_pL2r_k.js} +2 -2
- package/dist/assets/{main-HzTrVvbB.js → main-tv2uysSs.js} +7 -7
- package/dist/assets/{markdownCore-DJU4KvHP.js → markdownCore-D3Ibaffd.js} +1 -1
- package/dist/assets/{miniChat-Ca3TpaaA.js → miniChat-B0xQlBzZ.js} +2 -2
- package/dist/assets/{mobile-lj4gpGsO.js → mobile-BmSlVuhn.js} +2 -2
- package/dist/assets/renderElectronMiniChatApp-C4xZzAnn.js +2 -0
- package/dist/assets/renderMobileApp-Bi8wTGd5.js +11 -0
- package/dist/assets/runtimeEndpointReset-B6_gFvBD.js +53 -0
- package/dist/assets/{runtimeSurface-CE_VNjdH.js → runtimeSurface-egSD9pqj.js} +1 -1
- package/dist/assets/{useAppFontEffects-BvFAP9zG.js → useAppFontEffects-C9QQrBIx.js} +104 -104
- package/dist/assets/{useFilesViewSearch-BD79p3A2.js → useFilesViewSearch-BTZutbn-.js} +2 -2
- package/dist/assets/{usePushVisibilityBeacon-CWg0j-Wg.js → usePushVisibilityBeacon-BZcHxSo-.js} +1 -1
- package/dist/assets/useSwitcherItems-Dw5tHQh8.js +1 -0
- package/dist/assets/{vendor-codemirror-language-data-CP3j3-xu.js → vendor-codemirror-language-data-0f_rLdj_.js} +2 -2
- package/dist/assets/{web-components-DWuadqra.js → web-components-CYngz9Ml.js} +1 -1
- package/dist/index.html +4 -4
- package/dist/mini-chat.html +3 -3
- package/dist/mobile.html +3 -3
- package/package.json +1 -1
- package/server/index.js +17 -3
- package/server/lib/client-auth/DOCUMENTATION.md +184 -0
- package/server/lib/client-auth/live-revocation.test.js +567 -0
- package/server/lib/client-auth/principal-tracker.js +383 -0
- package/server/lib/client-auth/principal-tracker.test.js +321 -0
- package/server/lib/client-auth/remote-clients.js +31 -0
- package/server/lib/client-auth/remote-clients.test.js +44 -0
- package/server/lib/pi/event-stream.js +269 -0
- package/server/lib/pi/event-stream.test.js +776 -0
- package/server/lib/pi/routes.js +76 -25
- package/server/lib/pi/routes.test.js +48 -4
- package/server/lib/pi/session-daemon/DOCUMENTATION.md +5 -4
- package/server/lib/pi/session-daemon/ipc-client.js +19 -15
- package/server/lib/pi/session-daemon/ipc-client.test.js +113 -1
- package/server/lib/pi/session-daemon/session-daemon-epoch.test.js +349 -0
- package/server/lib/pi/session-daemon/session-daemon.js +55 -6
- package/server/lib/pi/session-daemon/session-daemon.test.js +10 -4
- package/server/lib/pi/session-daemon/session-replay.test.js +8 -3
- package/server/lib/pi/session-daemon/supervisor.js +30 -5
- package/server/lib/pi/session-daemon/supervisor.test.js +4 -3
- package/server/lib/pi/ui-settings-store.js +1 -1
- package/server/lib/pi/ui-settings-store.test.js +3 -1
- package/server/lib/server/core-routes.js +11 -1
- package/server/lib/stt/DOCUMENTATION.md +2 -0
- package/server/lib/stt/runtime.js +39 -2
- package/server/lib/stt/runtime.test.js +53 -0
- package/server/lib/terminal/DOCUMENTATION.md +2 -0
- package/server/lib/terminal/runtime.js +48 -2
- package/server/lib/terminal/runtime.test.js +35 -0
- package/server/lib/ui-auth/DOCUMENTATION.md +13 -4
- package/server/lib/ui-auth/ui-auth.js +98 -0
- package/server/lib/ui-auth/ui-auth.test.js +249 -0
- package/server/lib/workspace/host.js +3 -1
- package/dist/assets/SettingsView-eG-wN-yY.js +0 -2
- package/dist/assets/SettingsWindow-Dvnp8YrA.js +0 -1
- package/dist/assets/index-BpmGBboM.css +0 -1
- package/dist/assets/index-DZnzXhTs.js +0 -8
- package/dist/assets/renderElectronMiniChatApp-rUFfaD-T.js +0 -2
- package/dist/assets/renderMobileApp-CcWQ1sCf.js +0 -11
- package/dist/assets/runtimeEndpointReset-D2MmSbDk.js +0 -53
- package/dist/assets/useSwitcherItems-CazJ6Yox.js +0 -1
|
@@ -0,0 +1,349 @@
|
|
|
1
|
+
import { afterEach, describe, expect, it } from 'vitest';
|
|
2
|
+
import { mkdir, mkdtemp } from 'node:fs/promises';
|
|
3
|
+
import { createConnection } from 'node:net';
|
|
4
|
+
import { tmpdir } from 'node:os';
|
|
5
|
+
import { join } from 'node:path';
|
|
6
|
+
import { StringDecoder } from 'node:string_decoder';
|
|
7
|
+
|
|
8
|
+
import { createSessionDaemon } from './session-daemon.js';
|
|
9
|
+
|
|
10
|
+
const credential = 'a-private-daemon-credential';
|
|
11
|
+
|
|
12
|
+
class FakeSession {
|
|
13
|
+
constructor(sessionId = 'pi-session-1') {
|
|
14
|
+
this.sessionId = sessionId;
|
|
15
|
+
this.isStreaming = false;
|
|
16
|
+
this.listeners = new Set();
|
|
17
|
+
this.entries = [];
|
|
18
|
+
this.model = { provider: 'test', id: 'model' };
|
|
19
|
+
this.thinkingLevel = 'low';
|
|
20
|
+
this.sessionManager = {
|
|
21
|
+
getSessionFile: () => undefined,
|
|
22
|
+
getHeader: () => ({ timestamp: '2026-01-01T00:00:00.000Z' }),
|
|
23
|
+
getEntries: () => this.entries,
|
|
24
|
+
getEntry: (id) => this.entries.find((entry) => entry.id === id),
|
|
25
|
+
getLeafId: () => 'fake-entry',
|
|
26
|
+
getTree: () => [],
|
|
27
|
+
appendSessionInfo: () => undefined,
|
|
28
|
+
getSessionName: () => undefined,
|
|
29
|
+
};
|
|
30
|
+
}
|
|
31
|
+
|
|
32
|
+
subscribe(listener) {
|
|
33
|
+
this.listeners.add(listener);
|
|
34
|
+
return () => this.listeners.delete(listener);
|
|
35
|
+
}
|
|
36
|
+
|
|
37
|
+
emit(event) {
|
|
38
|
+
for (const listener of this.listeners) listener(event);
|
|
39
|
+
}
|
|
40
|
+
|
|
41
|
+
async prompt() {}
|
|
42
|
+
|
|
43
|
+
async sendUserMessage() {}
|
|
44
|
+
|
|
45
|
+
async abort() {}
|
|
46
|
+
|
|
47
|
+
async compact() {}
|
|
48
|
+
|
|
49
|
+
getSteeringMessages() { return []; }
|
|
50
|
+
|
|
51
|
+
getFollowUpMessages() { return []; }
|
|
52
|
+
}
|
|
53
|
+
|
|
54
|
+
function testDaemonEndpoint(root) {
|
|
55
|
+
return process.platform === 'win32'
|
|
56
|
+
? `\\\\.\\pipe\\pichamber-pi-daemon-epoch-test-${Math.random().toString(36).slice(2)}`
|
|
57
|
+
: join(root, 'daemon.sock');
|
|
58
|
+
}
|
|
59
|
+
|
|
60
|
+
function connectClient(endpoint) {
|
|
61
|
+
const socket = createConnection(endpoint);
|
|
62
|
+
const decoder = new StringDecoder('utf8');
|
|
63
|
+
let buffer = '';
|
|
64
|
+
const messages = [];
|
|
65
|
+
const waiters = [];
|
|
66
|
+
|
|
67
|
+
socket.on('data', (chunk) => {
|
|
68
|
+
buffer += decoder.write(chunk);
|
|
69
|
+
while (true) {
|
|
70
|
+
const newline = buffer.indexOf('\n');
|
|
71
|
+
if (newline === -1) break;
|
|
72
|
+
const line = buffer.slice(0, newline).replace(/\r$/, '');
|
|
73
|
+
buffer = buffer.slice(newline + 1);
|
|
74
|
+
if (!line) continue;
|
|
75
|
+
const message = JSON.parse(line);
|
|
76
|
+
messages.push(message);
|
|
77
|
+
for (let index = waiters.length - 1; index >= 0; index -= 1) {
|
|
78
|
+
const waiter = waiters[index];
|
|
79
|
+
if (waiter.predicate(message)) {
|
|
80
|
+
waiters.splice(index, 1);
|
|
81
|
+
waiter.resolve(message);
|
|
82
|
+
}
|
|
83
|
+
}
|
|
84
|
+
}
|
|
85
|
+
});
|
|
86
|
+
|
|
87
|
+
const next = (predicate) => {
|
|
88
|
+
const existing = messages.find(predicate);
|
|
89
|
+
if (existing) return Promise.resolve(existing);
|
|
90
|
+
return new Promise((resolve, reject) => {
|
|
91
|
+
const timer = setTimeout(() => {
|
|
92
|
+
const index = waiters.findIndex((waiter) => waiter.resolve === resolve);
|
|
93
|
+
if (index !== -1) waiters.splice(index, 1);
|
|
94
|
+
reject(new Error('Timed out waiting for daemon message'));
|
|
95
|
+
}, 2_000);
|
|
96
|
+
waiters.push({ predicate, reject, resolve: (message) => { clearTimeout(timer); resolve(message); } });
|
|
97
|
+
});
|
|
98
|
+
};
|
|
99
|
+
|
|
100
|
+
let closed = false;
|
|
101
|
+
return {
|
|
102
|
+
socket,
|
|
103
|
+
async authenticate({ fromSequence, streamEpoch } = {}) {
|
|
104
|
+
await new Promise((resolve, reject) => {
|
|
105
|
+
socket.once('connect', resolve);
|
|
106
|
+
socket.once('error', reject);
|
|
107
|
+
});
|
|
108
|
+
socket.write(`${JSON.stringify({
|
|
109
|
+
kind: 'authenticate',
|
|
110
|
+
credential,
|
|
111
|
+
...(fromSequence !== undefined ? { fromSequence } : {}),
|
|
112
|
+
...(streamEpoch ? { streamEpoch } : {}),
|
|
113
|
+
})}\n`);
|
|
114
|
+
await next((message) => message.kind === 'authenticated');
|
|
115
|
+
},
|
|
116
|
+
request(command, payload = {}) {
|
|
117
|
+
const requestId = `request-${Math.random()}`;
|
|
118
|
+
socket.write(`${JSON.stringify({ protocolVersion: 1, kind: 'request', requestId, command, payload })}\n`);
|
|
119
|
+
return next((message) => message.kind === 'response' && message.requestId === requestId);
|
|
120
|
+
},
|
|
121
|
+
next,
|
|
122
|
+
async close() {
|
|
123
|
+
if (closed) return;
|
|
124
|
+
closed = true;
|
|
125
|
+
socket.end();
|
|
126
|
+
await new Promise((resolve) => {
|
|
127
|
+
if (socket.destroyed) { resolve(); return; }
|
|
128
|
+
socket.once('close', resolve);
|
|
129
|
+
setTimeout(resolve, 250);
|
|
130
|
+
});
|
|
131
|
+
},
|
|
132
|
+
};
|
|
133
|
+
}
|
|
134
|
+
|
|
135
|
+
const startDaemon = async (root, session) => {
|
|
136
|
+
const endpoint = testDaemonEndpoint(root);
|
|
137
|
+
const daemon = createSessionDaemon({
|
|
138
|
+
endpoint,
|
|
139
|
+
credential,
|
|
140
|
+
cwd: root,
|
|
141
|
+
agentDir: join(root, 'agent'),
|
|
142
|
+
createRuntime: async () => ({ session, async dispose() {} }),
|
|
143
|
+
});
|
|
144
|
+
await daemon.start();
|
|
145
|
+
return { daemon, endpoint };
|
|
146
|
+
};
|
|
147
|
+
|
|
148
|
+
describe('session daemon stream epoch', () => {
|
|
149
|
+
const daemons = [];
|
|
150
|
+
const sockets = [];
|
|
151
|
+
|
|
152
|
+
const track = async (root, session) => {
|
|
153
|
+
const started = await startDaemon(root, session);
|
|
154
|
+
daemons.push(started.daemon);
|
|
155
|
+
return started;
|
|
156
|
+
};
|
|
157
|
+
|
|
158
|
+
afterEach(async () => {
|
|
159
|
+
for (const socket of sockets.splice(0)) await socket.close().catch(() => {});
|
|
160
|
+
for (const daemon of daemons.splice(0)) await daemon.stop().catch(() => {});
|
|
161
|
+
});
|
|
162
|
+
|
|
163
|
+
it('stamps a stable opaque streamEpoch on health, snapshots, events, and session reads', async () => {
|
|
164
|
+
const root = await mkdtemp(join(tmpdir(), 'pichamber-pi-daemon-epoch-'));
|
|
165
|
+
await mkdir(join(root, 'agent'), { recursive: true });
|
|
166
|
+
const session = new FakeSession();
|
|
167
|
+
const { endpoint } = await track(root, session);
|
|
168
|
+
|
|
169
|
+
const client = connectClient(endpoint);
|
|
170
|
+
sockets.push(client);
|
|
171
|
+
await client.authenticate();
|
|
172
|
+
const snapshot = await client.next((message) => message.kind === 'event' && message.event === 'session.snapshot');
|
|
173
|
+
// Register the injected runtime so live session events are published.
|
|
174
|
+
await client.request('sessions.create', { cwd: root });
|
|
175
|
+
|
|
176
|
+
expect(typeof snapshot.streamEpoch).toBe('string');
|
|
177
|
+
expect(snapshot.streamEpoch.length).toBeGreaterThanOrEqual(16);
|
|
178
|
+
expect(snapshot.streamEpoch).not.toMatch(/pi-session|credential|agent/);
|
|
179
|
+
expect(snapshot.payload.resync).toBeUndefined();
|
|
180
|
+
|
|
181
|
+
const health = await client.request('runtime.health');
|
|
182
|
+
expect(health.result.streamEpoch).toBe(snapshot.streamEpoch);
|
|
183
|
+
expect(health.result.capabilities).toContain('events.streamEpoch');
|
|
184
|
+
|
|
185
|
+
const eventPromise = client.next((message) => message.kind === 'event' && message.event === 'session.updated');
|
|
186
|
+
session.emit({ type: 'session_info_changed', name: 'renamed' });
|
|
187
|
+
const event = await eventPromise;
|
|
188
|
+
expect(event.streamEpoch).toBe(snapshot.streamEpoch);
|
|
189
|
+
|
|
190
|
+
const opened = await client.request('sessions.open', { sessionId: session.sessionId, cwd: root });
|
|
191
|
+
expect(opened.result.streamEpoch).toBe(snapshot.streamEpoch);
|
|
192
|
+
});
|
|
193
|
+
|
|
194
|
+
it('replays contiguously at the same epoch without a resync snapshot', async () => {
|
|
195
|
+
const root = await mkdtemp(join(tmpdir(), 'pichamber-pi-daemon-epoch-'));
|
|
196
|
+
await mkdir(join(root, 'agent'), { recursive: true });
|
|
197
|
+
const session = new FakeSession();
|
|
198
|
+
const { endpoint } = await track(root, session);
|
|
199
|
+
|
|
200
|
+
const first = connectClient(endpoint);
|
|
201
|
+
sockets.push(first);
|
|
202
|
+
await first.authenticate();
|
|
203
|
+
const snapshot = await first.next((message) => message.kind === 'event' && message.event === 'session.snapshot');
|
|
204
|
+
await first.request('sessions.create', { cwd: root });
|
|
205
|
+
const renamed = first.next((message) => message.kind === 'event' && message.event === 'session.updated');
|
|
206
|
+
session.emit({ type: 'session_info_changed', name: 'one' });
|
|
207
|
+
const renameEvent = await renamed;
|
|
208
|
+
|
|
209
|
+
// Reconnect from the rename cursor, stamping the cursor's stream epoch:
|
|
210
|
+
// the retained suffix replays without a snapshot, and the epoch is
|
|
211
|
+
// unchanged.
|
|
212
|
+
const second = connectClient(endpoint);
|
|
213
|
+
sockets.push(second);
|
|
214
|
+
await second.authenticate({ fromSequence: renameEvent.sequence, streamEpoch: snapshot.streamEpoch });
|
|
215
|
+
session.emit({ type: 'session_info_changed', name: 'two' });
|
|
216
|
+
const replayed = await second.next((message) => message.kind === 'event');
|
|
217
|
+
expect(replayed.event).toBe('session.updated');
|
|
218
|
+
expect(replayed.payload.title).toBe('two');
|
|
219
|
+
expect(replayed.streamEpoch).toBe(snapshot.streamEpoch);
|
|
220
|
+
expect(replayed.sequence).toBeGreaterThan(renameEvent.sequence);
|
|
221
|
+
});
|
|
222
|
+
|
|
223
|
+
it('a restart changes the epoch and a stale cursor resyncs from a lower snapshot baseline', async () => {
|
|
224
|
+
const root = await mkdtemp(join(tmpdir(), 'pichamber-pi-daemon-epoch-'));
|
|
225
|
+
await mkdir(join(root, 'agent'), { recursive: true });
|
|
226
|
+
const firstSession = new FakeSession();
|
|
227
|
+
const first = await track(root, firstSession);
|
|
228
|
+
|
|
229
|
+
const oldClient = connectClient(first.endpoint);
|
|
230
|
+
sockets.push(oldClient);
|
|
231
|
+
await oldClient.authenticate();
|
|
232
|
+
const oldSnapshot = await oldClient.next((message) => message.kind === 'event' && message.event === 'session.snapshot');
|
|
233
|
+
await oldClient.request('sessions.create', { cwd: root });
|
|
234
|
+
const renameWait = oldClient.next((message) => message.kind === 'event' && message.event === 'session.updated');
|
|
235
|
+
firstSession.emit({ type: 'session_info_changed', name: 'before restart' });
|
|
236
|
+
const renameEvent = await renameWait;
|
|
237
|
+
expect(renameEvent.sequence).toBeGreaterThan(oldSnapshot.sequence);
|
|
238
|
+
const oldEpoch = renameEvent.streamEpoch;
|
|
239
|
+
|
|
240
|
+
// Restart: a brand new daemon process owns the endpoint's role. Its
|
|
241
|
+
// sequence space starts over, so the old epoch must differ and the old
|
|
242
|
+
// cursor must be unreplayable.
|
|
243
|
+
await oldClient.close();
|
|
244
|
+
await first.daemon.stop();
|
|
245
|
+
const secondSession = new FakeSession();
|
|
246
|
+
const second = await startDaemon(root, secondSession);
|
|
247
|
+
daemons.push(second.daemon);
|
|
248
|
+
|
|
249
|
+
const newClient = connectClient(second.endpoint);
|
|
250
|
+
sockets.push(newClient);
|
|
251
|
+
// The client stamps its cursor with the retired epoch, so the daemon can
|
|
252
|
+
// tell the sequence space reset even before looking at the numbers.
|
|
253
|
+
await newClient.authenticate({ fromSequence: renameEvent.sequence, streamEpoch: oldEpoch });
|
|
254
|
+
const resyncSnapshot = await newClient.next((message) => message.kind === 'event');
|
|
255
|
+
expect(resyncSnapshot.event).toBe('session.snapshot');
|
|
256
|
+
expect(resyncSnapshot.payload.resync).toBe(true);
|
|
257
|
+
expect(resyncSnapshot.streamEpoch).toBeTruthy();
|
|
258
|
+
expect(resyncSnapshot.streamEpoch).not.toBe(oldEpoch);
|
|
259
|
+
expect(resyncSnapshot.sequence).toBeLessThan(renameEvent.sequence);
|
|
260
|
+
expect(resyncSnapshot.payload.lastSequence).toBeLessThan(renameEvent.sequence);
|
|
261
|
+
|
|
262
|
+
// Register the restarted runtime so live session events are published.
|
|
263
|
+
await newClient.request('sessions.create', { cwd: root });
|
|
264
|
+
|
|
265
|
+
// Live events after the resync share the new epoch and grow from the
|
|
266
|
+
// lower baseline.
|
|
267
|
+
const liveWait = newClient.next((message) => message.kind === 'event' && message.event === 'session.updated');
|
|
268
|
+
secondSession.emit({ type: 'session_info_changed', name: 'after restart' });
|
|
269
|
+
const live = await liveWait;
|
|
270
|
+
expect(live.streamEpoch).toBe(resyncSnapshot.streamEpoch);
|
|
271
|
+
expect(live.sequence).toBeGreaterThan(resyncSnapshot.sequence);
|
|
272
|
+
});
|
|
273
|
+
|
|
274
|
+
it('rejects a replay cursor without its stream epoch as a protocol mismatch', async () => {
|
|
275
|
+
const root = await mkdtemp(join(tmpdir(), 'pichamber-pi-daemon-epoch-'));
|
|
276
|
+
await mkdir(join(root, 'agent'), { recursive: true });
|
|
277
|
+
const session = new FakeSession();
|
|
278
|
+
const { endpoint } = await track(root, session);
|
|
279
|
+
|
|
280
|
+
const first = connectClient(endpoint);
|
|
281
|
+
sockets.push(first);
|
|
282
|
+
await first.authenticate();
|
|
283
|
+
const snapshot = await first.next((message) => message.kind === 'event' && message.event === 'session.snapshot');
|
|
284
|
+
await first.request('sessions.create', { cwd: root });
|
|
285
|
+
const renameWait = first.next((message) => message.kind === 'event' && message.event === 'session.updated');
|
|
286
|
+
session.emit({ type: 'session_info_changed', name: 'one' });
|
|
287
|
+
const renameEvent = await renameWait;
|
|
288
|
+
|
|
289
|
+
// An old client reconnects with a replayable cursor but cannot epoch-
|
|
290
|
+
// verify it (no streamEpoch marker). The daemon must reject the resume
|
|
291
|
+
// rather than silently replaying or substituting a snapshot.
|
|
292
|
+
const legacy = connectClient(endpoint);
|
|
293
|
+
sockets.push(legacy);
|
|
294
|
+
await legacy.authenticate({ fromSequence: renameEvent.sequence });
|
|
295
|
+
const legacyFrame = await legacy.next((message) => message.kind === 'error');
|
|
296
|
+
expect(legacyFrame.error).toEqual({ code: 'DAEMON_PROTOCOL_MISMATCH' });
|
|
297
|
+
expect(snapshot.streamEpoch).toBeTruthy();
|
|
298
|
+
});
|
|
299
|
+
|
|
300
|
+
it('a new daemon whose sequence overtook the old cursor resyncs instead of replaying the wrong window', async () => {
|
|
301
|
+
const root = await mkdtemp(join(tmpdir(), 'pichamber-pi-daemon-epoch-'));
|
|
302
|
+
await mkdir(join(root, 'agent'), { recursive: true });
|
|
303
|
+
const firstSession = new FakeSession();
|
|
304
|
+
const first = await track(root, firstSession);
|
|
305
|
+
|
|
306
|
+
const oldClient = connectClient(first.endpoint);
|
|
307
|
+
sockets.push(oldClient);
|
|
308
|
+
await oldClient.authenticate();
|
|
309
|
+
await oldClient.next((message) => message.kind === 'event' && message.event === 'session.snapshot');
|
|
310
|
+
await oldClient.request('sessions.create', { cwd: root });
|
|
311
|
+
const renameWait = oldClient.next((message) => message.kind === 'event' && message.event === 'session.updated');
|
|
312
|
+
firstSession.emit({ type: 'session_info_changed', name: 'before restart' });
|
|
313
|
+
const renameEvent = await renameWait;
|
|
314
|
+
const oldEpoch = renameEvent.streamEpoch;
|
|
315
|
+
const oldCursor = renameEvent.sequence;
|
|
316
|
+
await oldClient.close();
|
|
317
|
+
await first.daemon.stop();
|
|
318
|
+
|
|
319
|
+
// The restarted daemon emits several events, so its new sequence space
|
|
320
|
+
// numerically OVERTAKES the old client's cursor before it reconnects.
|
|
321
|
+
const secondSession = new FakeSession();
|
|
322
|
+
const second = await startDaemon(root, secondSession);
|
|
323
|
+
daemons.push(second.daemon);
|
|
324
|
+
const warmup = connectClient(second.endpoint);
|
|
325
|
+
sockets.push(warmup);
|
|
326
|
+
await warmup.authenticate();
|
|
327
|
+
await warmup.request('sessions.create', { cwd: root });
|
|
328
|
+
for (let index = 0; index < Math.max(4, oldCursor + 2); index += 1) {
|
|
329
|
+
const wait = warmup.next((message) => message.kind === 'event' && message.event === 'session.updated');
|
|
330
|
+
secondSession.emit({ type: 'session_info_changed', name: `warmup-${index}` });
|
|
331
|
+
await wait;
|
|
332
|
+
}
|
|
333
|
+
const warmupState = await warmup.request('runtime.health');
|
|
334
|
+
const newEpoch = warmupState.result.streamEpoch;
|
|
335
|
+
expect(newEpoch).not.toBe(oldEpoch);
|
|
336
|
+
|
|
337
|
+
// The old cursor is numerically replayable on the new daemon, but the
|
|
338
|
+
// epoch marker proves it belongs to the retired sequence space: the
|
|
339
|
+
// daemon must resync rather than replay events 1..cursor of the new
|
|
340
|
+
// epoch the client never saw.
|
|
341
|
+
const returning = connectClient(second.endpoint);
|
|
342
|
+
sockets.push(returning);
|
|
343
|
+
await returning.authenticate({ fromSequence: oldCursor, streamEpoch: oldEpoch });
|
|
344
|
+
const resync = await returning.next((message) => message.kind === 'event');
|
|
345
|
+
expect(resync.event).toBe('session.snapshot');
|
|
346
|
+
expect(resync.payload.resync).toBe(true);
|
|
347
|
+
expect(resync.streamEpoch).toBe(newEpoch);
|
|
348
|
+
});
|
|
349
|
+
});
|
|
@@ -257,6 +257,13 @@ export function createSessionDaemon({
|
|
|
257
257
|
let idleDisposeTimer;
|
|
258
258
|
let dormantSession;
|
|
259
259
|
let sequence = 0;
|
|
260
|
+
// Opaque, random, public stream-lifetime identifier. It regenerates on every
|
|
261
|
+
// daemon process start (restart, crash, or replacement), so clients can
|
|
262
|
+
// distinguish "same daemon, contiguous sequence" from "new daemon, sequence
|
|
263
|
+
// restarted from zero". It is deliberately NOT derived from the daemon id,
|
|
264
|
+
// profile key, pid, or any other private identity: it exists only to be
|
|
265
|
+
// compared for equality on the public wire.
|
|
266
|
+
const streamEpoch = randomUUID().replace(/-/g, '');
|
|
260
267
|
let started = false;
|
|
261
268
|
let stopping = false;
|
|
262
269
|
const knownDirectories = new Set([cwd]);
|
|
@@ -531,6 +538,7 @@ export function createSessionDaemon({
|
|
|
531
538
|
protocolVersion: PROTOCOL_VERSION,
|
|
532
539
|
kind: 'event',
|
|
533
540
|
event,
|
|
541
|
+
streamEpoch,
|
|
534
542
|
sequence: ++sequence,
|
|
535
543
|
payload: {
|
|
536
544
|
sessionId,
|
|
@@ -607,7 +615,7 @@ export function createSessionDaemon({
|
|
|
607
615
|
};
|
|
608
616
|
};
|
|
609
617
|
|
|
610
|
-
const publishSnapshot = (socket, requestedSessionId) => {
|
|
618
|
+
const publishSnapshot = (socket, requestedSessionId, { resync = false } = {}) => {
|
|
611
619
|
const targetRuntime = requestedSessionId ? runtimeRegistry?.findBySessionId(requestedSessionId) : runtime;
|
|
612
620
|
const session = targetRuntime?.session
|
|
613
621
|
? { sessionId: targetRuntime.session.sessionId, isStreaming: targetRuntime.session.isStreaming }
|
|
@@ -629,10 +637,15 @@ export function createSessionDaemon({
|
|
|
629
637
|
protocolVersion: PROTOCOL_VERSION,
|
|
630
638
|
kind: 'event',
|
|
631
639
|
event: 'session.snapshot',
|
|
640
|
+
streamEpoch,
|
|
632
641
|
sequence: snapshotSequence,
|
|
633
642
|
payload: {
|
|
634
643
|
...(session.sessionId ? { sessionId: session.sessionId } : {}),
|
|
635
644
|
directory: targetDirectory,
|
|
645
|
+
// `resync` tells the client the requested cursor could not be replayed
|
|
646
|
+
// (replay window expired or a daemon restart reset the sequence), so
|
|
647
|
+
// this snapshot is a recovery baseline rather than a routine attach.
|
|
648
|
+
...(resync ? { resync: true } : {}),
|
|
636
649
|
isStreaming: session.isStreaming ?? false,
|
|
637
650
|
lifecycle: retry ? 'retry' : session.isStreaming ? 'busy' : 'idle',
|
|
638
651
|
...(retry ? { retry } : {}),
|
|
@@ -1564,7 +1577,10 @@ export function createSessionDaemon({
|
|
|
1564
1577
|
protocolVersion: PROTOCOL_VERSION,
|
|
1565
1578
|
kind: 'response',
|
|
1566
1579
|
requestId,
|
|
1567
|
-
|
|
1580
|
+
// Stamp the stream lifetime so a client can reject a detail response
|
|
1581
|
+
// that was generated by a previous daemon process (stale sequence
|
|
1582
|
+
// space) after observing an epoch change.
|
|
1583
|
+
result: { ...detail, streamEpoch },
|
|
1568
1584
|
};
|
|
1569
1585
|
if (Buffer.byteLength(JSON.stringify(frame)) > MAX_FRAME_BYTES) {
|
|
1570
1586
|
throw new SessionDaemonProtocolError(
|
|
@@ -3069,7 +3085,10 @@ export function createSessionDaemon({
|
|
|
3069
3085
|
latestAssistantMessageIds.delete(sessionId);
|
|
3070
3086
|
toolInputBySession.delete(sessionId);
|
|
3071
3087
|
clearToolTimingsForSession(sessionId);
|
|
3072
|
-
|
|
3088
|
+
// Explicit typed deletion: every connected and replaying client drops
|
|
3089
|
+
// catalog, transcript, activity, and caches. Archive and directory moves
|
|
3090
|
+
// keep the session id and never publish this event.
|
|
3091
|
+
publish('session.deleted', {}, sessionId, targetDir);
|
|
3073
3092
|
};
|
|
3074
3093
|
|
|
3075
3094
|
const publishSessionEvent = (sessionId, event, directory = activeDirectory || cwd) => {
|
|
@@ -3433,7 +3452,12 @@ export function createSessionDaemon({
|
|
|
3433
3452
|
state: 'ready',
|
|
3434
3453
|
sessionId: getSessionState().sessionId,
|
|
3435
3454
|
lastSequence: sequence,
|
|
3455
|
+
streamEpoch,
|
|
3436
3456
|
capabilities: [
|
|
3457
|
+
// Public stream-lifetime identification: every event, snapshot,
|
|
3458
|
+
// and health result carries `streamEpoch`, and session read
|
|
3459
|
+
// responses stamp it so clients can reject stale-epoch data.
|
|
3460
|
+
'events.streamEpoch',
|
|
3437
3461
|
'runtime.claim', 'runtime.shutdown',
|
|
3438
3462
|
'projects.list', 'projects.select', 'sessions.list', 'sessions.create', 'sessions.open', 'sessions.messages', 'sessions.rename', 'sessions.delete',
|
|
3439
3463
|
'sessions.tree', 'sessions.navigate', 'sessions.fork', 'sessions.clone', 'sessions.prompt',
|
|
@@ -3654,7 +3678,9 @@ export function createSessionDaemon({
|
|
|
3654
3678
|
protocolVersion: PROTOCOL_VERSION,
|
|
3655
3679
|
kind: 'response',
|
|
3656
3680
|
requestId: message.requestId,
|
|
3657
|
-
|
|
3681
|
+
// Stamp the stream lifetime so clients can reject a listing that a
|
|
3682
|
+
// previous daemon process generated after an epoch change.
|
|
3683
|
+
result: { sessions, streamEpoch },
|
|
3658
3684
|
});
|
|
3659
3685
|
return;
|
|
3660
3686
|
}
|
|
@@ -3902,14 +3928,37 @@ export function createSessionDaemon({
|
|
|
3902
3928
|
writeFrame(socket, { protocolVersion: PROTOCOL_VERSION, kind: 'authenticated' });
|
|
3903
3929
|
const requestedSessionId = typeof message.sessionId === 'string' && message.sessionId.length > 0 ? message.sessionId : undefined;
|
|
3904
3930
|
const fromSequence = Number.isSafeInteger(message.fromSequence) && message.fromSequence >= 0 ? message.fromSequence : undefined;
|
|
3931
|
+
// Stream-lifetime identity the client's cursor was established
|
|
3932
|
+
// under (capability negotiation). A cursor stamped with a
|
|
3933
|
+
// different epoch belongs to a retired sequence space: even when
|
|
3934
|
+
// this daemon's sequence numerically overtook it, replaying from
|
|
3935
|
+
// it would silently skip the head of the new sequence space.
|
|
3936
|
+
// Subscribers without the marker cannot prove which sequence
|
|
3937
|
+
// space their cursor belongs to. Reject that shape instead of
|
|
3938
|
+
// silently treating it as a valid resume.
|
|
3939
|
+
const requestedEpoch = typeof message.streamEpoch === 'string' && message.streamEpoch.length > 0 && message.streamEpoch.length <= 128
|
|
3940
|
+
? message.streamEpoch
|
|
3941
|
+
: undefined;
|
|
3942
|
+
if (fromSequence !== undefined && requestedEpoch === undefined) {
|
|
3943
|
+
throw new SessionDaemonProtocolError(
|
|
3944
|
+
'DAEMON_PROTOCOL_MISMATCH',
|
|
3945
|
+
'A replay cursor requires its stream epoch.',
|
|
3946
|
+
);
|
|
3947
|
+
}
|
|
3948
|
+
const epochMismatch = requestedEpoch !== undefined && requestedEpoch !== streamEpoch;
|
|
3905
3949
|
// Contiguity is judged on the global retained suffix while delivery
|
|
3906
3950
|
// stays session-filtered, so a filtered client never replays through
|
|
3907
3951
|
// a gap left by eviction, an oversized event, an empty ring, or a
|
|
3908
3952
|
// future cursor: all of those take the snapshot fallback below.
|
|
3909
|
-
|
|
3953
|
+
// Replay additionally requires the epoch marker. The validation
|
|
3954
|
+
// above rejects a cursor that cannot be tied to an epoch.
|
|
3955
|
+
if (fromSequence !== undefined && requestedEpoch !== undefined && !epochMismatch && replayLog.canReplay(fromSequence, sequence)) {
|
|
3910
3956
|
for (const cachedLine of replayLog.linesAfter(fromSequence, requestedSessionId)) writeLine(socket, cachedLine);
|
|
3911
3957
|
} else {
|
|
3912
|
-
|
|
3958
|
+
// A supplied cursor that cannot be replayed is a resync: the
|
|
3959
|
+
// snapshot is the client's recovery baseline for a missed replay
|
|
3960
|
+
// window, a daemon restart, or a cursor from a retired epoch.
|
|
3961
|
+
publishSnapshot(socket, requestedSessionId, { resync: fromSequence !== undefined || epochMismatch === true });
|
|
3913
3962
|
}
|
|
3914
3963
|
continue;
|
|
3915
3964
|
}
|
|
@@ -195,12 +195,12 @@ function connectClient(endpoint) {
|
|
|
195
195
|
|
|
196
196
|
return {
|
|
197
197
|
socket,
|
|
198
|
-
async authenticate(value = credential, { sessionId, fromSequence } = {}) {
|
|
198
|
+
async authenticate(value = credential, { sessionId, fromSequence, streamEpoch } = {}) {
|
|
199
199
|
await new Promise((resolve, reject) => {
|
|
200
200
|
socket.once('connect', resolve);
|
|
201
201
|
socket.once('error', reject);
|
|
202
202
|
});
|
|
203
|
-
socket.write(`${JSON.stringify({ kind: 'authenticate', credential: value, ...(sessionId ? { sessionId } : {}), ...(fromSequence !== undefined ? { fromSequence } : {}) })}\n`);
|
|
203
|
+
socket.write(`${JSON.stringify({ kind: 'authenticate', credential: value, ...(sessionId ? { sessionId } : {}), ...(fromSequence !== undefined ? { fromSequence } : {}), ...(streamEpoch ? { streamEpoch } : {}) })}\n`);
|
|
204
204
|
await next((message) => message.kind === 'authenticated');
|
|
205
205
|
if (fromSequence !== undefined) return undefined;
|
|
206
206
|
return next((message) => message.kind === 'event' && message.event === 'session.snapshot');
|
|
@@ -378,12 +378,12 @@ describe('Pi session daemon spike', () => {
|
|
|
378
378
|
await first.close();
|
|
379
379
|
|
|
380
380
|
const replay = connectClient(endpoint);
|
|
381
|
-
await replay.authenticate(credential, { sessionId: 'pi-session-1', fromSequence: snapshot.sequence });
|
|
381
|
+
await replay.authenticate(credential, { sessionId: 'pi-session-1', fromSequence: snapshot.sequence, streamEpoch: snapshot.streamEpoch });
|
|
382
382
|
await expect(replay.next((frame) => frame.event === 'assistant.message.delta')).resolves.toMatchObject({ sequence: delta.sequence, payload: { delta: 'replay' } });
|
|
383
383
|
await replay.close();
|
|
384
384
|
|
|
385
385
|
const stale = connectClient(endpoint);
|
|
386
|
-
await stale.authenticate(credential, { sessionId: 'pi-session-1', fromSequence: 0 });
|
|
386
|
+
await stale.authenticate(credential, { sessionId: 'pi-session-1', fromSequence: 0, streamEpoch: snapshot.streamEpoch });
|
|
387
387
|
await expect(stale.next((frame) => frame.event === 'session.snapshot')).resolves.toMatchObject({ payload: { lastSequence: expect.any(Number) } });
|
|
388
388
|
await stale.close();
|
|
389
389
|
});
|
|
@@ -418,6 +418,7 @@ describe('Pi session daemon spike', () => {
|
|
|
418
418
|
await late.authenticate(credential, {
|
|
419
419
|
sessionId: 'pi-session-1',
|
|
420
420
|
fromSequence: detail.result.lastSequence,
|
|
421
|
+
streamEpoch: detail.result.streamEpoch,
|
|
421
422
|
});
|
|
422
423
|
const firstDelta = first.next((frame) => frame.event === 'assistant.message.delta');
|
|
423
424
|
const lateDelta = late.next((frame) => frame.event === 'assistant.message.delta');
|
|
@@ -447,6 +448,7 @@ describe('Pi session daemon spike', () => {
|
|
|
447
448
|
await resumed.authenticate(credential, {
|
|
448
449
|
sessionId: 'pi-session-1',
|
|
449
450
|
fromSequence: lateDeltaFrame.sequence,
|
|
451
|
+
streamEpoch: detail.result.streamEpoch,
|
|
450
452
|
});
|
|
451
453
|
const resumedEndFrame = await resumed.next((frame) => frame.event === 'assistant.message.end');
|
|
452
454
|
expect(resumedEndFrame.sequence).toBe(firstEndFrame.sequence);
|
|
@@ -1229,7 +1231,11 @@ describe('Pi session daemon spike', () => {
|
|
|
1229
1231
|
await expect(client.request('sessions.abort', { sessionId: 'pi-session-forked' })).resolves.toMatchObject({ result: {} });
|
|
1230
1232
|
expect(runtime.session.aborted).toBe(1);
|
|
1231
1233
|
runtime.session.isStreaming = false;
|
|
1234
|
+
const deletedEvent = client.next((frame) => frame.event === 'session.deleted');
|
|
1232
1235
|
await expect(client.request('sessions.delete', { sessionId: 'pi-session-forked' })).resolves.toMatchObject({ result: {} });
|
|
1236
|
+
await expect(deletedEvent).resolves.toMatchObject({
|
|
1237
|
+
payload: { sessionId: 'pi-session-forked', directory: root },
|
|
1238
|
+
});
|
|
1233
1239
|
await client.close();
|
|
1234
1240
|
});
|
|
1235
1241
|
|
|
@@ -155,7 +155,7 @@ function connectDaemonClient(endpoint) {
|
|
|
155
155
|
socket,
|
|
156
156
|
messages,
|
|
157
157
|
waitForMessage,
|
|
158
|
-
async authenticate(credentialOverride = credential, { sessionId, fromSequence } = {}) {
|
|
158
|
+
async authenticate(credentialOverride = credential, { sessionId, fromSequence, streamEpoch } = {}) {
|
|
159
159
|
await new Promise((resolve, reject) => {
|
|
160
160
|
if (socket.connecting === false && socket.pending === false) {
|
|
161
161
|
return resolve();
|
|
@@ -168,6 +168,7 @@ function connectDaemonClient(endpoint) {
|
|
|
168
168
|
credential: credentialOverride,
|
|
169
169
|
...(sessionId ? { sessionId } : {}),
|
|
170
170
|
...(fromSequence !== undefined ? { fromSequence } : {}),
|
|
171
|
+
...(streamEpoch ? { streamEpoch } : {}),
|
|
171
172
|
};
|
|
172
173
|
socket.write(`${JSON.stringify(frame)}\n`);
|
|
173
174
|
await waitForMessage((message) => message.kind === 'authenticated');
|
|
@@ -327,20 +328,24 @@ describe('session replay log bounds', () => {
|
|
|
327
328
|
|
|
328
329
|
describe('daemon byte-bounded reconnect', () => {
|
|
329
330
|
let daemon;
|
|
331
|
+
let latestEpoch;
|
|
330
332
|
const temporaryRoots = [];
|
|
331
333
|
const connectedClients = new Set();
|
|
332
334
|
|
|
333
335
|
const connectLiveClient = async (endpoint) => {
|
|
334
336
|
const client = connectDaemonClient(endpoint);
|
|
335
337
|
connectedClients.add(client);
|
|
336
|
-
await client.authenticate();
|
|
338
|
+
const snapshot = await client.authenticate();
|
|
339
|
+
// Track the live daemon epoch so resuming clients can stamp their cursor
|
|
340
|
+
// (replay requires the stream-epoch marker).
|
|
341
|
+
latestEpoch = snapshot.streamEpoch;
|
|
337
342
|
return client;
|
|
338
343
|
};
|
|
339
344
|
|
|
340
345
|
const connectResumingClient = async (endpoint, fromSequence) => {
|
|
341
346
|
const client = connectDaemonClient(endpoint);
|
|
342
347
|
connectedClients.add(client);
|
|
343
|
-
await client.authenticate(credential, { sessionId: 'pi-session-1', fromSequence });
|
|
348
|
+
await client.authenticate(credential, { sessionId: 'pi-session-1', fromSequence, streamEpoch: latestEpoch });
|
|
344
349
|
return client;
|
|
345
350
|
};
|
|
346
351
|
|
|
@@ -495,7 +495,15 @@ export const createPiSessionDaemonSupervisor = ({
|
|
|
495
495
|
const claimed = await claimDaemonOwnership(credential);
|
|
496
496
|
if (isCompatibleBuild && claimed) {
|
|
497
497
|
const ready = await probe(credential);
|
|
498
|
-
return {
|
|
498
|
+
return {
|
|
499
|
+
state: 'ready',
|
|
500
|
+
reused: true,
|
|
501
|
+
protocolVersion: PROTOCOL_VERSION,
|
|
502
|
+
capabilities: ready.health.capabilities ?? [],
|
|
503
|
+
...(typeof ready.health.streamEpoch === 'string' && ready.health.streamEpoch.length > 0
|
|
504
|
+
? { streamEpoch: ready.health.streamEpoch }
|
|
505
|
+
: {}),
|
|
506
|
+
};
|
|
499
507
|
}
|
|
500
508
|
// Replace an older protocol/build, and always replace a development
|
|
501
509
|
// daemon so a source restart cannot keep running stale module code.
|
|
@@ -571,7 +579,15 @@ export const createPiSessionDaemonSupervisor = ({
|
|
|
571
579
|
while (Date.now() < deadline) {
|
|
572
580
|
try {
|
|
573
581
|
const started = await probe(credential);
|
|
574
|
-
return {
|
|
582
|
+
return {
|
|
583
|
+
state: 'ready',
|
|
584
|
+
reused: false,
|
|
585
|
+
protocolVersion: PROTOCOL_VERSION,
|
|
586
|
+
capabilities: started.health.capabilities ?? [],
|
|
587
|
+
...(typeof started.health.streamEpoch === 'string' && started.health.streamEpoch.length > 0
|
|
588
|
+
? { streamEpoch: started.health.streamEpoch }
|
|
589
|
+
: {}),
|
|
590
|
+
};
|
|
575
591
|
} catch (error) {
|
|
576
592
|
if (error instanceof PiSessionDaemonUnavailableError && isPermanentStartupFailure(error.code)) throw error;
|
|
577
593
|
await wait(RETRY_DELAY_MS);
|
|
@@ -627,10 +643,12 @@ export const createPiSessionDaemonSupervisor = ({
|
|
|
627
643
|
}
|
|
628
644
|
};
|
|
629
645
|
|
|
630
|
-
const subscribe = async ({ sessionId, fromSequence, onEvent, onError }) => {
|
|
646
|
+
const subscribe = async ({ sessionId, fromSequence, streamEpoch, onEvent, onError, signal }) => {
|
|
631
647
|
try {
|
|
648
|
+
if (signal?.aborted) return () => {};
|
|
632
649
|
const { credential } = await ensureReady();
|
|
633
|
-
|
|
650
|
+
if (signal?.aborted) return () => {};
|
|
651
|
+
return await subscribeSessionDaemon({ endpoint: paths.endpoint, credential, sessionId, fromSequence, streamEpoch, onEvent, onError, signal });
|
|
634
652
|
} catch (error) {
|
|
635
653
|
throw new PiSessionDaemonUnavailableError(
|
|
636
654
|
error instanceof SessionDaemonClientError && error.code !== 'DAEMON_CONNECTION_REFUSED'
|
|
@@ -643,7 +661,14 @@ export const createPiSessionDaemonSupervisor = ({
|
|
|
643
661
|
const health = async () => {
|
|
644
662
|
try {
|
|
645
663
|
const { ready } = await ensureReady();
|
|
646
|
-
return {
|
|
664
|
+
return {
|
|
665
|
+
state: 'ready',
|
|
666
|
+
protocolVersion: PROTOCOL_VERSION,
|
|
667
|
+
capabilities: ready.health.capabilities ?? [],
|
|
668
|
+
...(typeof ready.health.streamEpoch === 'string' && ready.health.streamEpoch.length > 0
|
|
669
|
+
? { streamEpoch: ready.health.streamEpoch }
|
|
670
|
+
: {}),
|
|
671
|
+
};
|
|
647
672
|
} catch (error) {
|
|
648
673
|
return {
|
|
649
674
|
state: 'unavailable',
|
|
@@ -87,12 +87,13 @@ describe('Pi session daemon supervisor', () => {
|
|
|
87
87
|
};
|
|
88
88
|
|
|
89
89
|
supervisor = createPiSessionDaemonSupervisor({ env, cwd });
|
|
90
|
-
await expect(supervisor.start()).resolves.toMatchObject({ state: 'ready', reused: false, protocolVersion: 1 });
|
|
91
|
-
await expect(supervisor.start()).resolves.toMatchObject({ state: 'ready', reused: true, protocolVersion: 1 });
|
|
90
|
+
await expect(supervisor.start()).resolves.toMatchObject({ state: 'ready', reused: false, protocolVersion: 1, streamEpoch: expect.stringMatching(/^[0-9a-f]{32}$/) });
|
|
91
|
+
await expect(supervisor.start()).resolves.toMatchObject({ state: 'ready', reused: true, protocolVersion: 1, streamEpoch: expect.stringMatching(/^[0-9a-f]{32}$/) });
|
|
92
92
|
await expect(supervisor.health()).resolves.toEqual({
|
|
93
93
|
state: 'ready',
|
|
94
94
|
protocolVersion: 1,
|
|
95
|
-
capabilities: expect.arrayContaining(['projects.list', 'projects.select', 'sessions.list', 'sessions.create', 'sessions.open', 'sessions.rename', 'sessions.delete', 'sessions.tree', 'sessions.navigate', 'sessions.fork', 'sessions.clone', 'sessions.prompt', 'sessions.steer', 'sessions.followUp', 'sessions.abort', 'sessions.setModel', 'sessions.setThinking', 'sessions.compact', 'providers.list', 'providers.config.get', 'providers.models.set', 'providers.status', 'providers.login', 'providers.login.respond', 'providers.login.status', 'providers.logout', 'settings.get', 'settings.set', 'resources.list', 'resources.update', 'resources.prompts.create', 'resources.prompts.update', 'resources.prompts.delete']),
|
|
95
|
+
capabilities: expect.arrayContaining(['projects.list', 'projects.select', 'sessions.list', 'sessions.create', 'sessions.open', 'sessions.rename', 'sessions.delete', 'sessions.tree', 'sessions.navigate', 'sessions.fork', 'sessions.clone', 'sessions.prompt', 'sessions.steer', 'sessions.followUp', 'sessions.abort', 'sessions.setModel', 'sessions.setThinking', 'sessions.compact', 'providers.list', 'providers.config.get', 'providers.models.set', 'providers.status', 'providers.login', 'providers.login.respond', 'providers.login.status', 'providers.logout', 'settings.get', 'settings.set', 'resources.list', 'resources.update', 'resources.prompts.create', 'resources.prompts.update', 'resources.prompts.delete', 'events.streamEpoch']),
|
|
96
|
+
streamEpoch: expect.stringMatching(/^[0-9a-f]{32}$/),
|
|
96
97
|
});
|
|
97
98
|
await expect(supervisor.request('sessions.list')).resolves.toMatchObject({ sessions: expect.any(Array) });
|
|
98
99
|
|