@pi-chamber/web 0.9.5 → 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-BvrCkm_z.js +1 -0
- package/dist/assets/{DiffView-BmIVvheE.js → DiffView-DMvRLRN1.js} +1 -1
- package/dist/assets/FileSaveConflictDialog-DGa9u43J.js +3 -0
- package/dist/assets/FilesView-CNHu4RnC.js +6 -0
- package/dist/assets/{GitView-BNkzec7G.js → GitView-Cbepz-bR.js} +3 -3
- package/dist/assets/{JsonTreeView-C1Kzaybf.js → JsonTreeView-C2X5oXQm.js} +1 -1
- package/dist/assets/{MarkdownRendererImpl-qmKiFVpO.js → MarkdownRendererImpl-BanSCkPy.js} +2 -2
- package/dist/assets/{PatchDiff-D9JesZL1.js → PatchDiff-i_9BIlgo.js} +1 -1
- package/dist/assets/{SessionSwitcherContent-DplV_ApH.js → SessionSwitcherContent-DxS_rFuS.js} +1 -1
- package/dist/assets/{SessionSwitcherDropdown-DdgDKT6K.js → SessionSwitcherDropdown-AVghToww.js} +2 -2
- package/dist/assets/{SessionUnreadDot-BdSDgvhC.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-DaF1xcM0.js → ToolOutputDialog-CJ87b80H.js} +5 -5
- package/dist/assets/{ToolPartDiffPreview-Di6Uo0Dt.js → ToolPartDiffPreview-bF486Lz1.js} +1 -1
- package/dist/assets/{VirtualizedFileDiff-wqcrY0yr.js → VirtualizedFileDiff-CFpvcZ1g.js} +1 -1
- package/dist/assets/{collapsible-DBQnXTNm.js → collapsible-DesjbW8a.js} +1 -1
- package/dist/assets/{computeVirtualFileMetrics-Cr3jh0d6.js → computeVirtualFileMetrics-CsAu9rOt.js} +2 -2
- package/dist/assets/{contextFileOpenGuard-C_AOTYQD.js → contextFileOpenGuard-rILslsBJ.js} +1 -1
- package/dist/assets/{gitStatusPredicates-BvPOjeOy.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-B8Wt2aN3.js → index-CXLVW_GG.js} +1 -1
- package/dist/assets/{isDiffPlainText-L9uvgz2F.js → isDiffPlainText-BX609Lau.js} +1 -1
- package/dist/assets/{isFilePlainText-C4yk5BOo.js → isFilePlainText-FgBWqu9b.js} +1 -1
- package/dist/assets/{main-DCK6lLCo.js → main-C_pL2r_k.js} +2 -2
- package/dist/assets/{main-C1OSzD-E.js → main-tv2uysSs.js} +7 -7
- package/dist/assets/{markdownCore-Czb_lINQ.js → markdownCore-D3Ibaffd.js} +1 -1
- package/dist/assets/{miniChat-CXiSlptL.js → miniChat-B0xQlBzZ.js} +2 -2
- package/dist/assets/{mobile-D0HVxiyJ.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-vilE4xyj.js → runtimeSurface-egSD9pqj.js} +1 -1
- package/dist/assets/{useAppFontEffects-BP07Vl6M.js → useAppFontEffects-C9QQrBIx.js} +104 -104
- package/dist/assets/useFilesViewSearch-BTZutbn-.js +7 -0
- package/dist/assets/{usePushVisibilityBeacon-CChMvoTL.js → usePushVisibilityBeacon-BZcHxSo-.js} +1 -1
- package/dist/assets/useSwitcherItems-Dw5tHQh8.js +1 -0
- package/dist/assets/{vendor-codemirror-language-data-BJrrV83E.js → vendor-codemirror-language-data-0f_rLdj_.js} +2 -2
- package/dist/assets/{web-components-B5sMa_kC.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/fs/DOCUMENTATION.md +15 -3
- package/server/lib/fs/routes.js +369 -51
- package/server/lib/fs/routes.test.js +565 -3
- package/server/lib/fs/search.js +74 -29
- 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 +132 -28
- package/server/lib/pi/routes.test.js +213 -4
- package/server/lib/pi/session-daemon/DOCUMENTATION.md +6 -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/prompt-operations.test.js +9 -3
- package/server/lib/pi/session-daemon/prompt-preflight.test.js +556 -0
- package/server/lib/pi/session-daemon/send-operation-dedup.test.js +331 -0
- package/server/lib/pi/session-daemon/send-operation-registry.js +264 -0
- package/server/lib/pi/session-daemon/send-operation-registry.test.js +205 -0
- package/server/lib/pi/session-daemon/session-daemon-epoch.test.js +349 -0
- package/server/lib/pi/session-daemon/session-daemon-extensions.e2e.test.js +16 -5
- package/server/lib/pi/session-daemon/session-daemon-extensions.test.js +3 -1
- package/server/lib/pi/session-daemon/session-daemon.js +339 -37
- package/server/lib/pi/session-daemon/session-daemon.test.js +47 -17
- package/server/lib/pi/session-daemon/session-idle-residency.test.js +8 -1
- package/server/lib/pi/session-daemon/session-replay.test.js +11 -4
- 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/server/cors.js +6 -0
- package/server/lib/server/cors.test.js +3 -0
- 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 +9 -3
- package/server/lib/workspace/host.test.js +15 -0
- package/dist/assets/DiagramEditor-BPDkGHsj.js +0 -1
- package/dist/assets/DiagramView-D_EfDz2d.js +0 -1
- package/dist/assets/FilesView-CJytSUAX.js +0 -6
- package/dist/assets/SettingsView-z8uf0XyM.js +0 -2
- package/dist/assets/SettingsWindow-CPDmgNg2.js +0 -1
- package/dist/assets/index-DIF8b4bh.css +0 -1
- package/dist/assets/index-jrfQYSvP.js +0 -8
- package/dist/assets/renderElectronMiniChatApp-BcG209a4.js +0 -2
- package/dist/assets/renderMobileApp-B5x_PWlc.js +0 -11
- package/dist/assets/runtimeEndpointReset-CUiPe6dQ.js +0 -53
- package/dist/assets/useFilesViewSearch-oxIKk-ea.js +0 -7
- package/dist/assets/useSwitcherItems-_RSo3F-A.js +0 -1
|
@@ -0,0 +1,556 @@
|
|
|
1
|
+
import { afterEach, describe, expect, it } from 'vitest';
|
|
2
|
+
import { mkdtemp, rm, writeFile } 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 as createSessionDaemonImpl } from './session-daemon.js';
|
|
9
|
+
|
|
10
|
+
const credential = 'a-private-daemon-credential';
|
|
11
|
+
|
|
12
|
+
function createSessionDaemon(options) {
|
|
13
|
+
return createSessionDaemonImpl({ ...options, agentDir: options.agentDir ?? options.cwd });
|
|
14
|
+
}
|
|
15
|
+
|
|
16
|
+
function testDaemonEndpoint(root) {
|
|
17
|
+
if (process.platform === 'win32') return `\\\\.\\pipe\\pichamber-preflight-${Date.now()}-${Math.random().toString(16).slice(2)}`;
|
|
18
|
+
return join(root, 'daemon.sock');
|
|
19
|
+
}
|
|
20
|
+
|
|
21
|
+
class FakeSession {
|
|
22
|
+
constructor(sessionId, sessionFile) {
|
|
23
|
+
this.sessionId = sessionId;
|
|
24
|
+
this.sessionFile = sessionFile;
|
|
25
|
+
this.isStreaming = false;
|
|
26
|
+
this.listeners = new Set();
|
|
27
|
+
this.names = [];
|
|
28
|
+
this.entries = [];
|
|
29
|
+
this.promptCalls = [];
|
|
30
|
+
this.sent = [];
|
|
31
|
+
this.aborted = 0;
|
|
32
|
+
this.model = { provider: 'test', id: 'model' };
|
|
33
|
+
this.thinkingLevel = 'low';
|
|
34
|
+
this.promptImpl = null;
|
|
35
|
+
this.sessionManager = {
|
|
36
|
+
getSessionFile: () => sessionFile,
|
|
37
|
+
getHeader: () => ({ timestamp: '2026-01-01T00:00:00.000Z' }),
|
|
38
|
+
getEntries: () => this.entries,
|
|
39
|
+
getEntry: (id) => this.entries.find((entry) => entry.id === id),
|
|
40
|
+
getLeafId: () => 'fake-entry',
|
|
41
|
+
getTree: () => [{ entry: { id: 'fake-entry', parentId: undefined, timestamp: '2026-01-01T00:00:00.000Z' }, children: [] }],
|
|
42
|
+
appendSessionInfo: (name) => this.names.push(name),
|
|
43
|
+
getSessionName: () => this.names[this.names.length - 1],
|
|
44
|
+
};
|
|
45
|
+
}
|
|
46
|
+
|
|
47
|
+
subscribe(listener) {
|
|
48
|
+
this.listeners.add(listener);
|
|
49
|
+
return () => this.listeners.delete(listener);
|
|
50
|
+
}
|
|
51
|
+
|
|
52
|
+
emit(event) {
|
|
53
|
+
for (const listener of this.listeners) listener(event);
|
|
54
|
+
}
|
|
55
|
+
|
|
56
|
+
async prompt(text, options) {
|
|
57
|
+
this.promptCalls.push({ text, options });
|
|
58
|
+
if (this.promptImpl) return this.promptImpl(text, options);
|
|
59
|
+
options?.preflightResult?.(true);
|
|
60
|
+
}
|
|
61
|
+
|
|
62
|
+
async sendUserMessage(text, options) {
|
|
63
|
+
this.sent.push({ text, options });
|
|
64
|
+
}
|
|
65
|
+
|
|
66
|
+
async setModel(model) {
|
|
67
|
+
this.model = { provider: model.providerId ?? model.provider, id: model.modelId ?? model.id };
|
|
68
|
+
}
|
|
69
|
+
|
|
70
|
+
setThinkingLevel(thinking) { this.thinkingLevel = thinking; }
|
|
71
|
+
|
|
72
|
+
async abort() { this.aborted += 1; this.isStreaming = false; }
|
|
73
|
+
|
|
74
|
+
getSteeringMessages() { return []; }
|
|
75
|
+
|
|
76
|
+
getFollowUpMessages() { return []; }
|
|
77
|
+
}
|
|
78
|
+
|
|
79
|
+
class FakeRuntime {
|
|
80
|
+
constructor({ cwd, session }) {
|
|
81
|
+
this.cwd = cwd;
|
|
82
|
+
this.session = session;
|
|
83
|
+
this.disposed = false;
|
|
84
|
+
}
|
|
85
|
+
|
|
86
|
+
async dispose() { this.disposed = true; }
|
|
87
|
+
}
|
|
88
|
+
|
|
89
|
+
function connectClient(endpoint) {
|
|
90
|
+
const socket = createConnection({ path: endpoint });
|
|
91
|
+
const decoder = new StringDecoder('utf8');
|
|
92
|
+
let buffer = '';
|
|
93
|
+
const waiters = [];
|
|
94
|
+
|
|
95
|
+
const publish = (message) => {
|
|
96
|
+
for (let index = waiters.length - 1; index >= 0; index -= 1) {
|
|
97
|
+
const waiter = waiters[index];
|
|
98
|
+
if (waiter.predicate(message)) {
|
|
99
|
+
waiters.splice(index, 1);
|
|
100
|
+
waiter.resolve(message);
|
|
101
|
+
}
|
|
102
|
+
}
|
|
103
|
+
};
|
|
104
|
+
|
|
105
|
+
socket.on('data', (chunk) => {
|
|
106
|
+
buffer += decoder.write(chunk);
|
|
107
|
+
while (true) {
|
|
108
|
+
const newline = buffer.indexOf('\n');
|
|
109
|
+
if (newline === -1) break;
|
|
110
|
+
const line = buffer.slice(0, newline).replace(/\r$/, '');
|
|
111
|
+
buffer = buffer.slice(newline + 1);
|
|
112
|
+
if (line) publish(JSON.parse(line));
|
|
113
|
+
}
|
|
114
|
+
});
|
|
115
|
+
socket.on('close', () => {
|
|
116
|
+
for (const waiter of waiters.splice(0)) waiter.reject(new Error('Daemon connection closed'));
|
|
117
|
+
});
|
|
118
|
+
|
|
119
|
+
const next = (predicate) => new Promise((resolve, reject) => {
|
|
120
|
+
const timer = setTimeout(() => {
|
|
121
|
+
const index = waiters.findIndex((waiter) => waiter.resolve === resolve);
|
|
122
|
+
if (index !== -1) waiters.splice(index, 1);
|
|
123
|
+
reject(new Error('Timed out waiting for daemon message'));
|
|
124
|
+
}, 2_000);
|
|
125
|
+
waiters.push({
|
|
126
|
+
predicate,
|
|
127
|
+
reject,
|
|
128
|
+
resolve: (message) => {
|
|
129
|
+
clearTimeout(timer);
|
|
130
|
+
resolve(message);
|
|
131
|
+
},
|
|
132
|
+
});
|
|
133
|
+
});
|
|
134
|
+
|
|
135
|
+
return {
|
|
136
|
+
async authenticate() {
|
|
137
|
+
await new Promise((resolve, reject) => {
|
|
138
|
+
socket.once('connect', resolve);
|
|
139
|
+
socket.once('error', reject);
|
|
140
|
+
});
|
|
141
|
+
socket.write(`${JSON.stringify({ kind: 'authenticate', credential })}\n`);
|
|
142
|
+
await next((message) => message.kind === 'authenticated');
|
|
143
|
+
},
|
|
144
|
+
request(command, payload = {}) {
|
|
145
|
+
const requestId = `request-${Math.random()}`;
|
|
146
|
+
socket.write(`${JSON.stringify({ protocolVersion: 1, kind: 'request', requestId, command, payload })}\n`);
|
|
147
|
+
return new Promise((resolve, reject) => {
|
|
148
|
+
next((message) => {
|
|
149
|
+
if (message.kind === 'error') {
|
|
150
|
+
const code = message.error?.code ?? 'DAEMON_REQUEST_FAILED';
|
|
151
|
+
reject(Object.assign(new Error(code), { code, detail: message.error }));
|
|
152
|
+
return true;
|
|
153
|
+
}
|
|
154
|
+
return message.kind === 'response' && message.requestId === requestId;
|
|
155
|
+
}).then(resolve, reject);
|
|
156
|
+
});
|
|
157
|
+
},
|
|
158
|
+
next,
|
|
159
|
+
async close() {
|
|
160
|
+
if (!socket.destroyed) socket.destroy();
|
|
161
|
+
if (socket.destroyed) return;
|
|
162
|
+
await new Promise((resolve) => socket.once('close', resolve));
|
|
163
|
+
},
|
|
164
|
+
};
|
|
165
|
+
}
|
|
166
|
+
|
|
167
|
+
describe('prompt preflight acceptance', () => {
|
|
168
|
+
const roots = [];
|
|
169
|
+
const daemons = [];
|
|
170
|
+
let client;
|
|
171
|
+
let currentEndpoint;
|
|
172
|
+
|
|
173
|
+
const send = async (command, payload) => {
|
|
174
|
+
const connection = connectClient(currentEndpoint);
|
|
175
|
+
await connection.authenticate();
|
|
176
|
+
try {
|
|
177
|
+
return await connection.request(command, payload);
|
|
178
|
+
} finally {
|
|
179
|
+
await connection.close().catch(() => {});
|
|
180
|
+
}
|
|
181
|
+
};
|
|
182
|
+
|
|
183
|
+
afterEach(async () => {
|
|
184
|
+
client = undefined;
|
|
185
|
+
await Promise.all(daemons.splice(0).map((daemon) => daemon.stop().catch(() => {})));
|
|
186
|
+
await Promise.all(roots.splice(0).map((root) => rm(root, { recursive: true, force: true })));
|
|
187
|
+
});
|
|
188
|
+
|
|
189
|
+
const startDaemonWithSession = async ({ openSession = true } = {}) => {
|
|
190
|
+
const root = await mkdtemp(join(tmpdir(), 'pichamber-preflight-'));
|
|
191
|
+
roots.push(root);
|
|
192
|
+
const endpoint = testDaemonEndpoint(root);
|
|
193
|
+
const sessionFile = join(root, 'session-1.jsonl');
|
|
194
|
+
await writeFile(sessionFile, `{"type":"session","id":"session-1","cwd":"${root}"}\n`);
|
|
195
|
+
const session = new FakeSession('session-1', sessionFile);
|
|
196
|
+
const daemon = createSessionDaemon({
|
|
197
|
+
endpoint,
|
|
198
|
+
credential,
|
|
199
|
+
cwd: root,
|
|
200
|
+
createRuntime: async () => new FakeRuntime({ cwd: root, session }),
|
|
201
|
+
listSessions: async () => [
|
|
202
|
+
{ path: sessionFile, id: 'session-1', cwd: root, created: new Date(), modified: new Date(), messageCount: 0 },
|
|
203
|
+
],
|
|
204
|
+
});
|
|
205
|
+
daemons.push(daemon);
|
|
206
|
+
await daemon.start();
|
|
207
|
+
currentEndpoint = endpoint;
|
|
208
|
+
client = connectClient(endpoint);
|
|
209
|
+
await client.authenticate();
|
|
210
|
+
if (openSession) await client.request('sessions.open', { sessionId: 'session-1' });
|
|
211
|
+
return { session, endpoint, root, sessionFile };
|
|
212
|
+
};
|
|
213
|
+
|
|
214
|
+
it('preflight rejection is propagated, not cached as accepted, and id is reusable', async () => {
|
|
215
|
+
const { session } = await startDaemonWithSession();
|
|
216
|
+
let calls = 0;
|
|
217
|
+
session.promptImpl = async (text, options) => {
|
|
218
|
+
calls += 1;
|
|
219
|
+
if (calls === 1) {
|
|
220
|
+
options?.preflightResult?.(false);
|
|
221
|
+
throw new Error('Cannot submit a prompt while compaction is in progress.');
|
|
222
|
+
}
|
|
223
|
+
options?.preflightResult?.(true);
|
|
224
|
+
};
|
|
225
|
+
|
|
226
|
+
const payload = { sessionId: 'session-1', text: 'hello preflight', operationId: 'op-preflight-reuse' };
|
|
227
|
+
// Generic SDK preflight errors surface as INVALID_REQUEST over IPC today;
|
|
228
|
+
// the contract is rejection (not accepted) with a reusable id.
|
|
229
|
+
await expect(send('sessions.prompt', payload)).rejects.toMatchObject({ code: 'INVALID_REQUEST' });
|
|
230
|
+
expect(session.promptCalls).toHaveLength(1);
|
|
231
|
+
|
|
232
|
+
const retry = await send('sessions.prompt', payload);
|
|
233
|
+
expect(retry.result).toMatchObject({ accepted: true });
|
|
234
|
+
expect(retry.result.deduplicated).toBeUndefined();
|
|
235
|
+
expect(session.promptCalls).toHaveLength(2);
|
|
236
|
+
});
|
|
237
|
+
|
|
238
|
+
it('concurrent duplicates share one pending preflight outcome without double execution', async () => {
|
|
239
|
+
const { session } = await startDaemonWithSession();
|
|
240
|
+
let releasePreflight;
|
|
241
|
+
const preflightGate = new Promise((resolve) => { releasePreflight = resolve; });
|
|
242
|
+
let releaseTurn;
|
|
243
|
+
const turnGate = new Promise((resolve) => { releaseTurn = resolve; });
|
|
244
|
+
session.promptImpl = async (text, options) => {
|
|
245
|
+
await preflightGate;
|
|
246
|
+
options?.preflightResult?.(true);
|
|
247
|
+
await turnGate;
|
|
248
|
+
};
|
|
249
|
+
|
|
250
|
+
const payload = { sessionId: 'session-1', text: 'shared preflight', operationId: 'op-preflight-shared' };
|
|
251
|
+
const first = send('sessions.prompt', payload);
|
|
252
|
+
// Let the first claim reach the daemon before the duplicate arrives.
|
|
253
|
+
await new Promise((resolve) => setTimeout(resolve, 20));
|
|
254
|
+
const duplicate = send('sessions.prompt', payload);
|
|
255
|
+
// Still waiting on preflight: Pi must have been invoked once, and neither
|
|
256
|
+
// caller has an acceptance yet.
|
|
257
|
+
await new Promise((resolve) => setTimeout(resolve, 20));
|
|
258
|
+
expect(session.promptCalls).toHaveLength(1);
|
|
259
|
+
let settled = 0;
|
|
260
|
+
first.then(() => { settled += 1; }, () => { settled += 1; });
|
|
261
|
+
duplicate.then(() => { settled += 1; }, () => { settled += 1; });
|
|
262
|
+
await new Promise((resolve) => setTimeout(resolve, 10));
|
|
263
|
+
expect(settled).toBe(0);
|
|
264
|
+
|
|
265
|
+
releasePreflight();
|
|
266
|
+
// Preflight acceptance resolves both callers before the long turn finishes.
|
|
267
|
+
const [firstResult, duplicateResult] = await Promise.all([first, duplicate]);
|
|
268
|
+
expect(firstResult.result).toMatchObject({ accepted: true, messageId: 'fake-entry' });
|
|
269
|
+
expect(duplicateResult.result).toMatchObject({ accepted: true, messageId: 'fake-entry' });
|
|
270
|
+
expect([firstResult.result.deduplicated, duplicateResult.result.deduplicated]).toContain(true);
|
|
271
|
+
expect(session.promptCalls).toHaveLength(1);
|
|
272
|
+
releaseTurn();
|
|
273
|
+
});
|
|
274
|
+
|
|
275
|
+
it('acceptance returns after preflight but before the long turn finishes, with plain/rpc prompt shapes', async () => {
|
|
276
|
+
const { session } = await startDaemonWithSession();
|
|
277
|
+
let finishPlain;
|
|
278
|
+
const plainGate = new Promise((resolve) => { finishPlain = resolve; });
|
|
279
|
+
session.promptImpl = async (text, options) => {
|
|
280
|
+
options?.preflightResult?.(true);
|
|
281
|
+
await plainGate;
|
|
282
|
+
};
|
|
283
|
+
|
|
284
|
+
const plainResponse = await client.request('sessions.prompt', {
|
|
285
|
+
sessionId: 'session-1',
|
|
286
|
+
text: 'plain hello',
|
|
287
|
+
messageId: 'msg-plain',
|
|
288
|
+
});
|
|
289
|
+
expect(plainResponse.result).toEqual({ accepted: true, messageId: 'msg-plain' });
|
|
290
|
+
expect(session.promptCalls).toHaveLength(1);
|
|
291
|
+
expect(session.promptCalls[0].text).toBe('plain hello');
|
|
292
|
+
expect(session.promptCalls[0].options).toMatchObject({
|
|
293
|
+
expandPromptTemplates: false,
|
|
294
|
+
source: 'extension',
|
|
295
|
+
});
|
|
296
|
+
expect(session.promptCalls[0].options.preflightResult).toEqual(expect.any(Function));
|
|
297
|
+
finishPlain();
|
|
298
|
+
|
|
299
|
+
let finishSlash;
|
|
300
|
+
const slashGate = new Promise((resolve) => { finishSlash = resolve; });
|
|
301
|
+
session.promptImpl = async (text, options) => {
|
|
302
|
+
options?.preflightResult?.(true);
|
|
303
|
+
await slashGate;
|
|
304
|
+
};
|
|
305
|
+
// A second prompt needs a fresh generation; the first turn already settled
|
|
306
|
+
// via the gate above, so the daemon accepts the slash command as a new turn.
|
|
307
|
+
// Note: the fake never sets isStreaming, so no deliverAs is required.
|
|
308
|
+
const slashResponse = await client.request('sessions.prompt', {
|
|
309
|
+
sessionId: 'session-1',
|
|
310
|
+
text: '/help arg',
|
|
311
|
+
messageId: 'msg-slash',
|
|
312
|
+
});
|
|
313
|
+
expect(slashResponse.result).toEqual({ accepted: true, messageId: 'msg-slash' });
|
|
314
|
+
const slashCall = session.promptCalls[session.promptCalls.length - 1];
|
|
315
|
+
expect(slashCall.text).toBe('/help arg');
|
|
316
|
+
expect(slashCall.options).toMatchObject({ source: 'rpc' });
|
|
317
|
+
expect(slashCall.options.expandPromptTemplates).not.toBe(false);
|
|
318
|
+
expect(slashCall.options.preflightResult).toEqual(expect.any(Function));
|
|
319
|
+
finishSlash();
|
|
320
|
+
});
|
|
321
|
+
|
|
322
|
+
it('queued attachment metadata survives prompt resolution until the actual user start', async () => {
|
|
323
|
+
const { session, root } = await startDaemonWithSession();
|
|
324
|
+
const imageFile = join(root, 'queued.png');
|
|
325
|
+
await writeFile(imageFile, Buffer.from('queued-png-data'));
|
|
326
|
+
session.isStreaming = true;
|
|
327
|
+
session.promptImpl = async (text, options) => {
|
|
328
|
+
// SDK queued sends resolve immediately after preflight acceptance,
|
|
329
|
+
// long before the queued user message starts.
|
|
330
|
+
options?.preflightResult?.(true);
|
|
331
|
+
};
|
|
332
|
+
|
|
333
|
+
const response = await client.request('sessions.followUp', {
|
|
334
|
+
sessionId: 'session-1',
|
|
335
|
+
text: 'queued with image',
|
|
336
|
+
attachments: [{ name: 'queued.png', mime: 'image/png', path: imageFile, size: 15 }],
|
|
337
|
+
messageId: 'msg-queued',
|
|
338
|
+
});
|
|
339
|
+
expect(response.result).toEqual({ accepted: true, messageId: 'msg-queued' });
|
|
340
|
+
expect(session.promptCalls).toHaveLength(1);
|
|
341
|
+
expect(session.promptCalls[0].text).toBe('queued with image');
|
|
342
|
+
expect(session.promptCalls[0].options).toMatchObject({
|
|
343
|
+
expandPromptTemplates: false,
|
|
344
|
+
source: 'extension',
|
|
345
|
+
streamingBehavior: 'followUp',
|
|
346
|
+
});
|
|
347
|
+
expect(session.promptCalls[0].options.images).toEqual([
|
|
348
|
+
{ type: 'image', mimeType: 'image/png', data: Buffer.from('queued-png-data').toString('base64') },
|
|
349
|
+
]);
|
|
350
|
+
|
|
351
|
+
// The queued prompt promise already resolved, but the file metadata must
|
|
352
|
+
// still attach to the later user start (per-delivery preserved).
|
|
353
|
+
const userStart = client.next((frame) => frame.event === 'assistant.message.start'
|
|
354
|
+
&& frame.payload?.role === 'user'
|
|
355
|
+
&& frame.payload?.text === 'queued with image');
|
|
356
|
+
session.emit({ type: 'message_start', message: { role: 'user', content: 'queued with image', timestamp: 2_000 } });
|
|
357
|
+
await expect(userStart).resolves.toMatchObject({
|
|
358
|
+
payload: {
|
|
359
|
+
role: 'user',
|
|
360
|
+
text: 'queued with image',
|
|
361
|
+
files: [{ type: 'file', mime: 'image/png', filename: 'queued.png' }],
|
|
362
|
+
},
|
|
363
|
+
});
|
|
364
|
+
});
|
|
365
|
+
|
|
366
|
+
it('rejects invalid send operation ttl with INVALID_SEND_OPERATION_TTL', async () => {
|
|
367
|
+
const root = await mkdtemp(join(tmpdir(), 'pichamber-preflight-'));
|
|
368
|
+
roots.push(root);
|
|
369
|
+
const endpoint = testDaemonEndpoint(root);
|
|
370
|
+
expect(() => createSessionDaemon({ endpoint, credential, cwd: root, sendOperationTtlMs: 0 }))
|
|
371
|
+
.toThrowError(expect.objectContaining({ code: 'INVALID_SEND_OPERATION_TTL' }));
|
|
372
|
+
expect(() => createSessionDaemon({ endpoint, credential, cwd: root, sendOperationTtlMs: -5 }))
|
|
373
|
+
.toThrowError(expect.objectContaining({ code: 'INVALID_SEND_OPERATION_TTL' }));
|
|
374
|
+
});
|
|
375
|
+
|
|
376
|
+
it('idle followUp that turns busy during prepare still carries streamingBehavior', async () => {
|
|
377
|
+
const { session } = await startDaemonWithSession();
|
|
378
|
+
session.modelRuntime = {
|
|
379
|
+
getModel: (providerId, modelId) => ({ provider: providerId, id: modelId }),
|
|
380
|
+
getModels: () => [{ provider: 'test', id: 'model' }],
|
|
381
|
+
};
|
|
382
|
+
let releaseModel;
|
|
383
|
+
const modelGate = new Promise((resolve) => { releaseModel = resolve; });
|
|
384
|
+
let enteredModel = false;
|
|
385
|
+
const originalSetModel = session.setModel.bind(session);
|
|
386
|
+
session.setModel = async (model) => {
|
|
387
|
+
enteredModel = true;
|
|
388
|
+
await modelGate;
|
|
389
|
+
return originalSetModel(model);
|
|
390
|
+
};
|
|
391
|
+
session.promptImpl = async (text, options) => {
|
|
392
|
+
// Faithful SDK edge: streaming without an explicit behavior rejects.
|
|
393
|
+
if (session.isStreaming && !options?.streamingBehavior) {
|
|
394
|
+
options?.preflightResult?.(false);
|
|
395
|
+
throw new Error("Agent is already processing. Specify streamingBehavior ('steer' or 'followUp') to queue the message.");
|
|
396
|
+
}
|
|
397
|
+
options?.preflightResult?.(true);
|
|
398
|
+
};
|
|
399
|
+
// Arrives idle, so the early guard does not reject; it then blocks in
|
|
400
|
+
// setModel while another sender starts the turn.
|
|
401
|
+
const pending = send('sessions.followUp', {
|
|
402
|
+
sessionId: 'session-1',
|
|
403
|
+
text: 'racing followUp',
|
|
404
|
+
model: { providerId: 'test', modelId: 'model' },
|
|
405
|
+
messageId: 'msg-race-follow',
|
|
406
|
+
});
|
|
407
|
+
while (!enteredModel) await new Promise((resolve) => setTimeout(resolve, 5));
|
|
408
|
+
expect(session.isStreaming).toBe(false);
|
|
409
|
+
session.isStreaming = true;
|
|
410
|
+
releaseModel();
|
|
411
|
+
const response = await pending;
|
|
412
|
+
expect(response.result).toEqual({ accepted: true, messageId: 'msg-race-follow' });
|
|
413
|
+
expect(session.promptCalls).toHaveLength(1);
|
|
414
|
+
expect(session.promptCalls[0].options.streamingBehavior).toBe('followUp');
|
|
415
|
+
});
|
|
416
|
+
|
|
417
|
+
it('idle steer that turns busy during prepare still carries streamingBehavior', async () => {
|
|
418
|
+
const { session } = await startDaemonWithSession();
|
|
419
|
+
session.modelRuntime = {
|
|
420
|
+
getModel: (providerId, modelId) => ({ provider: providerId, id: modelId }),
|
|
421
|
+
getModels: () => [{ provider: 'test', id: 'model' }],
|
|
422
|
+
};
|
|
423
|
+
let releaseModel;
|
|
424
|
+
const modelGate = new Promise((resolve) => { releaseModel = resolve; });
|
|
425
|
+
let enteredModel = false;
|
|
426
|
+
const originalSetModel = session.setModel.bind(session);
|
|
427
|
+
session.setModel = async (model) => {
|
|
428
|
+
enteredModel = true;
|
|
429
|
+
await modelGate;
|
|
430
|
+
return originalSetModel(model);
|
|
431
|
+
};
|
|
432
|
+
session.promptImpl = async (text, options) => {
|
|
433
|
+
if (session.isStreaming && !options?.streamingBehavior) {
|
|
434
|
+
options?.preflightResult?.(false);
|
|
435
|
+
throw new Error("Agent is already processing. Specify streamingBehavior ('steer' or 'followUp') to queue the message.");
|
|
436
|
+
}
|
|
437
|
+
options?.preflightResult?.(true);
|
|
438
|
+
};
|
|
439
|
+
const pending = send('sessions.steer', {
|
|
440
|
+
sessionId: 'session-1',
|
|
441
|
+
text: 'racing steer',
|
|
442
|
+
model: { providerId: 'test', modelId: 'model' },
|
|
443
|
+
messageId: 'msg-race-steer',
|
|
444
|
+
});
|
|
445
|
+
while (!enteredModel) await new Promise((resolve) => setTimeout(resolve, 5));
|
|
446
|
+
session.isStreaming = true;
|
|
447
|
+
releaseModel();
|
|
448
|
+
const response = await pending;
|
|
449
|
+
expect(response.result).toEqual({ accepted: true, messageId: 'msg-race-steer' });
|
|
450
|
+
expect(session.promptCalls).toHaveLength(1);
|
|
451
|
+
expect(session.promptCalls[0].options.streamingBehavior).toBe('steer');
|
|
452
|
+
});
|
|
453
|
+
|
|
454
|
+
it('followUp then steer overtake keeps attachment footers per delivery queue', async () => {
|
|
455
|
+
const { session, root } = await startDaemonWithSession();
|
|
456
|
+
const followFile = join(root, 'follow.png');
|
|
457
|
+
const steerFile = join(root, 'steer.png');
|
|
458
|
+
await writeFile(followFile, Buffer.from('follow-png-data'));
|
|
459
|
+
await writeFile(steerFile, Buffer.from('steer-png-data'));
|
|
460
|
+
session.isStreaming = true;
|
|
461
|
+
session.promptImpl = async (text, options) => {
|
|
462
|
+
options?.preflightResult?.(true);
|
|
463
|
+
};
|
|
464
|
+
const followResponse = await client.request('sessions.followUp', {
|
|
465
|
+
sessionId: 'session-1',
|
|
466
|
+
text: 'follow text',
|
|
467
|
+
attachments: [{ name: 'follow.png', mime: 'image/png', path: followFile, size: 14 }],
|
|
468
|
+
messageId: 'msg-follow',
|
|
469
|
+
});
|
|
470
|
+
expect(followResponse.result).toEqual({ accepted: true, messageId: 'msg-follow' });
|
|
471
|
+
const steerResponse = await client.request('sessions.steer', {
|
|
472
|
+
sessionId: 'session-1',
|
|
473
|
+
text: 'steer text',
|
|
474
|
+
attachments: [{ name: 'steer.png', mime: 'image/png', path: steerFile, size: 13 }],
|
|
475
|
+
messageId: 'msg-steer',
|
|
476
|
+
});
|
|
477
|
+
expect(steerResponse.result).toEqual({ accepted: true, messageId: 'msg-steer' });
|
|
478
|
+
expect(session.promptCalls).toHaveLength(2);
|
|
479
|
+
expect(session.promptCalls[0].options.streamingBehavior).toBe('followUp');
|
|
480
|
+
expect(session.promptCalls[1].options.streamingBehavior).toBe('steer');
|
|
481
|
+
// SDK enqueue order then steering-first drain order. The daemon learns
|
|
482
|
+
// ownership only from authoritative `queue_update` shrinks, never text.
|
|
483
|
+
session.emit({ type: 'queue_update', steering: [], followUp: ['follow text'] });
|
|
484
|
+
session.emit({ type: 'queue_update', steering: ['steer text'], followUp: ['follow text'] });
|
|
485
|
+
// Steering overtakes: it starts first even though it was sent second.
|
|
486
|
+
session.emit({ type: 'queue_update', steering: [], followUp: ['follow text'] });
|
|
487
|
+
const steerStart = client.next((frame) => frame.event === 'assistant.message.start'
|
|
488
|
+
&& frame.payload?.role === 'user' && frame.payload?.text === 'steer text');
|
|
489
|
+
session.emit({ type: 'message_start', message: { role: 'user', content: 'steer text', timestamp: 3_000 } });
|
|
490
|
+
await expect(steerStart).resolves.toMatchObject({
|
|
491
|
+
payload: {
|
|
492
|
+
role: 'user',
|
|
493
|
+
text: 'steer text',
|
|
494
|
+
files: [{ type: 'file', mime: 'image/png', filename: 'steer.png' }],
|
|
495
|
+
},
|
|
496
|
+
});
|
|
497
|
+
session.emit({ type: 'queue_update', steering: [], followUp: [] });
|
|
498
|
+
const followStart = client.next((frame) => frame.event === 'assistant.message.start'
|
|
499
|
+
&& frame.payload?.role === 'user' && frame.payload?.text === 'follow text');
|
|
500
|
+
session.emit({ type: 'message_start', message: { role: 'user', content: 'follow text', timestamp: 3_001 } });
|
|
501
|
+
await expect(followStart).resolves.toMatchObject({
|
|
502
|
+
payload: {
|
|
503
|
+
role: 'user',
|
|
504
|
+
text: 'follow text',
|
|
505
|
+
files: [{ type: 'file', mime: 'image/png', filename: 'follow.png' }],
|
|
506
|
+
},
|
|
507
|
+
});
|
|
508
|
+
});
|
|
509
|
+
|
|
510
|
+
it('idle handled extension followUp does not leave stale metadata for the next prompt', async () => {
|
|
511
|
+
const { session, root } = await startDaemonWithSession();
|
|
512
|
+
const extFile = join(root, 'ext.png');
|
|
513
|
+
const nextFile = join(root, 'next.png');
|
|
514
|
+
await writeFile(extFile, Buffer.from('ext-png-data'));
|
|
515
|
+
await writeFile(nextFile, Buffer.from('next-png-data'));
|
|
516
|
+
session.extensionRunner = { getRegisteredCommands: () => [{ invocationName: 'mycmd' }] };
|
|
517
|
+
let finishNext;
|
|
518
|
+
const nextGate = new Promise((resolve) => { finishNext = resolve; });
|
|
519
|
+
session.promptImpl = async (text, options) => {
|
|
520
|
+
options?.preflightResult?.(true);
|
|
521
|
+
// Handled extension commands resolve without a user start; ordinary
|
|
522
|
+
// new-turn prompts stay pending until their start arrives.
|
|
523
|
+
if (typeof text === 'string' && text.startsWith('/mycmd')) return;
|
|
524
|
+
await nextGate;
|
|
525
|
+
};
|
|
526
|
+
const extResponse = await client.request('sessions.followUp', {
|
|
527
|
+
sessionId: 'session-1',
|
|
528
|
+
text: '/mycmd arg',
|
|
529
|
+
attachments: [{ name: 'ext.png', mime: 'image/png', path: extFile, size: 12 }],
|
|
530
|
+
messageId: 'msg-ext',
|
|
531
|
+
});
|
|
532
|
+
expect(extResponse.result).toEqual({ accepted: true, messageId: 'msg-ext' });
|
|
533
|
+
// Let the handled resolution clean its still-pending entry before the
|
|
534
|
+
// next send enqueues.
|
|
535
|
+
await new Promise((resolve) => setTimeout(resolve, 20));
|
|
536
|
+
const pendingNext = client.request('sessions.prompt', {
|
|
537
|
+
sessionId: 'session-1',
|
|
538
|
+
text: 'next hello',
|
|
539
|
+
attachments: [{ name: 'next.png', mime: 'image/png', path: nextFile, size: 13 }],
|
|
540
|
+
messageId: 'msg-next',
|
|
541
|
+
});
|
|
542
|
+
await new Promise((resolve) => setTimeout(resolve, 20));
|
|
543
|
+
const nextStart = client.next((frame) => frame.event === 'assistant.message.start'
|
|
544
|
+
&& frame.payload?.role === 'user' && frame.payload?.text === 'next hello');
|
|
545
|
+
session.emit({ type: 'message_start', message: { role: 'user', content: 'next hello', timestamp: 4_000 } });
|
|
546
|
+
await expect(nextStart).resolves.toMatchObject({
|
|
547
|
+
payload: {
|
|
548
|
+
role: 'user',
|
|
549
|
+
text: 'next hello',
|
|
550
|
+
files: [{ type: 'file', mime: 'image/png', filename: 'next.png' }],
|
|
551
|
+
},
|
|
552
|
+
});
|
|
553
|
+
finishNext();
|
|
554
|
+
await expect(pendingNext).resolves.toMatchObject({ result: { accepted: true, messageId: 'msg-next' } });
|
|
555
|
+
});
|
|
556
|
+
});
|