@pi-chamber/web 1.0.2 → 1.0.3
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-C3jwAdba.js → DiagramView-Bj1ZrdhI.js} +1 -1
- package/dist/assets/DiffView-D19Jps0i.js +18 -0
- package/dist/assets/{FileSaveConflictDialog-BDHl1ERM.js → FileSaveConflictDialog-2Z4V_gZU.js} +1 -1
- package/dist/assets/{FilesView-DjD5jjcd.js → FilesView-K18gBSws.js} +1 -1
- package/dist/assets/{GitView-D_TzczhS.js → GitView-Hm1KBPaD.js} +3 -3
- package/dist/assets/{JsonTreeView-BTMtZylb.js → JsonTreeView-fNsiZEIo.js} +1 -1
- package/dist/assets/{MarkdownRendererImpl-DnZhLsfY.js → MarkdownRendererImpl-DV5Xkj8N.js} +5 -5
- package/dist/assets/{PatchDiff-D4jQKTZA.js → PatchDiff-DZaJG6jj.js} +1 -1
- package/dist/assets/{SessionSwitcherContent-BX6P7l8U.js → SessionSwitcherContent-RAsmsuYk.js} +1 -1
- package/dist/assets/{SessionSwitcherDropdown-DGvRKfRw.js → SessionSwitcherDropdown-DuLPlIF_.js} +2 -2
- package/dist/assets/{SessionUnreadDot-CPTTyo0r.js → SessionUnreadDot-Dm6k5OCd.js} +1 -1
- package/dist/assets/SettingsView-Chu4zbWo.js +6 -0
- package/dist/assets/{SettingsWindow-MrdvHysy.js → SettingsWindow-CJzFmmfu.js} +1 -1
- package/dist/assets/{ToolOutputDialog-9UTlcthG.js → ToolOutputDialog-uYeXsAGc.js} +1 -1
- package/dist/assets/{ToolPartDiffPreview-D_HifNve.js → ToolPartDiffPreview-DnAHVRs-.js} +1 -1
- package/dist/assets/{VirtualizedFileDiff-CvqZNzUR.js → VirtualizedFileDiff-CJondRlh.js} +4 -4
- package/dist/assets/{collapsible-BencOwkW.js → collapsible-BH1vXEAI.js} +1 -1
- package/dist/assets/{computeVirtualFileMetrics-B1Zc3P5v.js → computeVirtualFileMetrics-DXkR5jdw.js} +2 -2
- package/dist/assets/{contextFileOpenGuard-CJZHfvjH.js → contextFileOpenGuard-CsZL8yie.js} +1 -1
- package/dist/assets/{gitStatusPredicates-C7tetvAB.js → gitStatusPredicates-BW8heN1a.js} +1 -1
- package/dist/assets/index-5fyXnZFi.css +1 -0
- package/dist/assets/{index-DYXaDVnz.js → index-BrgKwTb0.js} +1 -1
- package/dist/assets/{index-CpSdU-d4.js → index-C-sV_9sb.js} +3 -3
- package/dist/assets/{isDiffPlainText-DMMH-XmY.js → isDiffPlainText-DZFr1Tta.js} +1 -1
- package/dist/assets/{isFilePlainText-DcCgFOGI.js → isFilePlainText-KNpEMvb-.js} +1 -1
- package/dist/assets/{main-DvtT25LM.js → main-BPY2ug1A.js} +3 -3
- package/dist/assets/{main-BZu7VLeY.js → main-BRIjzIRl.js} +2 -2
- package/dist/assets/{markdownCore-D6HZ46BO.js → markdownCore-DYizLr1N.js} +2 -2
- package/dist/assets/{miniChat-CLS1HbGi.js → miniChat-Dva4MINl.js} +2 -2
- package/dist/assets/{mobile-BuCJ5Obm.js → mobile-6jNUNv_x.js} +2 -2
- package/dist/assets/{renderElectronMiniChatApp-BtREv0kE.js → renderElectronMiniChatApp-BIeBrZmO.js} +2 -2
- package/dist/assets/renderMobileApp-BDCtZpeS.js +11 -0
- package/dist/assets/runtimeEndpointReset-DqdGOWp8.js +53 -0
- package/dist/assets/{runtimeSurface-Bm6cRkok.js → runtimeSurface-BdndJV2m.js} +1 -1
- package/dist/assets/{useAppFontEffects-SHxBpd4f.js → useAppFontEffects-BABx-DxZ.js} +98 -98
- package/dist/assets/{useFilesViewSearch-CJ6yYAoc.js → useFilesViewSearch-DJ3psTKU.js} +1 -1
- package/dist/assets/{usePushVisibilityBeacon-mnTxlkQZ.js → usePushVisibilityBeacon-BciEu3HS.js} +3 -3
- package/dist/assets/{useSwitcherItems-DWUNXYMV.js → useSwitcherItems-C7_5TB_n.js} +1 -1
- package/dist/assets/{vendor-codemirror-language-data-B4enwgcI.js → vendor-codemirror-language-data-BB5mQv-R.js} +2 -2
- package/dist/assets/{web-components-ldhQxnFE.js → web-components-CCKlju0Z.js} +4 -4
- 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/lib/pi/model-config-store.js +146 -20
- package/server/lib/pi/model-config-store.test.js +153 -21
- package/server/lib/pi/routes.js +42 -1
- package/server/lib/pi/routes.test.js +104 -2
- package/server/lib/pi/session-daemon/DOCUMENTATION.md +3 -2
- package/server/lib/pi/session-daemon/session-daemon.js +322 -58
- package/server/lib/pi/session-daemon/session-daemon.test.js +335 -0
- package/server/lib/pi/session-daemon/session-failed-create-cleanup.test.js +372 -0
- package/server/lib/pi/session-persistence-gap.test.js +731 -0
- package/dist/assets/DiffView-CqPv7nw1.js +0 -18
- package/dist/assets/SettingsView-CD0EfMno.js +0 -2
- package/dist/assets/index-Dwz16owi.css +0 -1
- package/dist/assets/renderMobileApp-UF8ITb8A.js +0 -11
- package/dist/assets/runtimeEndpointReset-BcdDES-U.js +0 -53
|
@@ -0,0 +1,372 @@
|
|
|
1
|
+
import { afterEach, describe, expect, it } from 'vitest';
|
|
2
|
+
import { mkdir, mkdtemp, rm, stat, 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
|
+
import { createSessionDaemon } from './session-daemon.js';
|
|
8
|
+
import { getPiSessionDirectory } from './session-jsonl.js';
|
|
9
|
+
import { resolveSessionLeaseFile } from './session-lease.js';
|
|
10
|
+
|
|
11
|
+
/**
|
|
12
|
+
* Focused regression coverage for failed-create model/thinking cleanup:
|
|
13
|
+
*
|
|
14
|
+
* - `sessions.create` with an invalid model/thinking after lease acquisition
|
|
15
|
+
* disposes first and releases only after success.
|
|
16
|
+
* - When that first disposal rejects, the create returns the original
|
|
17
|
+
* model/thinking error (not the disposal error), retains the lease, keeps
|
|
18
|
+
* `{ runtime, cwd, sessionId }` pending without registering the runtime or
|
|
19
|
+
* installing dormant state, and leaves the session unexposed.
|
|
20
|
+
* - `sessions.delete` (per-session) and daemon stop (all sessions) retry the
|
|
21
|
+
* pending cleanup dispose-first; a failed retry stays pending without
|
|
22
|
+
* releasing ownership, a successful retry disposes exactly once and
|
|
23
|
+
* releases the lease.
|
|
24
|
+
*
|
|
25
|
+
* Seam notes (existing injection only, no new DI):
|
|
26
|
+
* - `createRuntime` fakes Pi's session surface so an unknown model
|
|
27
|
+
* (`modelRuntime.getModel` returns undefined) triggers INVALID_MODEL after
|
|
28
|
+
* the lease, and a throwing `setThinkingLevel` triggers a thinking setup
|
|
29
|
+
* error after the lease.
|
|
30
|
+
* - One-request-per-connection IPC (like production `requestSessionDaemon`)
|
|
31
|
+
* so create/delete rejections resolve as error frames with preserved codes.
|
|
32
|
+
*/
|
|
33
|
+
|
|
34
|
+
const credential = 'failed-create-cleanup-regression-secret';
|
|
35
|
+
|
|
36
|
+
const testDaemonEndpoint = (root, name = 'daemon.sock') => {
|
|
37
|
+
if (process.platform === 'win32') return `\\\\.\\pipe\\pichamber-failed-create-${process.pid}-${Math.random().toString(16).slice(2)}`;
|
|
38
|
+
return join(root, name);
|
|
39
|
+
};
|
|
40
|
+
|
|
41
|
+
const daemonRequest = (endpoint, command, payload, timeoutMs = 20_000) => new Promise((resolve, reject) => {
|
|
42
|
+
const requestId = `req-${Math.random().toString(16).slice(2)}`;
|
|
43
|
+
const socket = createConnection({ path: endpoint });
|
|
44
|
+
const decoder = new StringDecoder('utf8');
|
|
45
|
+
let buffer = '';
|
|
46
|
+
let authenticated = false;
|
|
47
|
+
let settled = false;
|
|
48
|
+
const timer = setTimeout(() => {
|
|
49
|
+
if (!settled) {
|
|
50
|
+
settled = true;
|
|
51
|
+
socket.destroy();
|
|
52
|
+
reject(new Error(`Timed out waiting for daemon ${command}`));
|
|
53
|
+
}
|
|
54
|
+
}, timeoutMs);
|
|
55
|
+
const finish = (callback, value) => {
|
|
56
|
+
if (settled) return;
|
|
57
|
+
settled = true;
|
|
58
|
+
clearTimeout(timer);
|
|
59
|
+
socket.destroy();
|
|
60
|
+
callback(value);
|
|
61
|
+
};
|
|
62
|
+
socket.once('error', (error) => finish(reject, error));
|
|
63
|
+
socket.on('connect', () => {
|
|
64
|
+
socket.write(`${JSON.stringify({ kind: 'authenticate', credential })}\n`);
|
|
65
|
+
});
|
|
66
|
+
socket.on('data', (chunk) => {
|
|
67
|
+
buffer += decoder.write(chunk);
|
|
68
|
+
for (;;) {
|
|
69
|
+
const newline = buffer.indexOf('\n');
|
|
70
|
+
if (newline === -1) return;
|
|
71
|
+
const line = buffer.slice(0, newline).replace(/\r$/, '');
|
|
72
|
+
buffer = buffer.slice(newline + 1);
|
|
73
|
+
if (!line) continue;
|
|
74
|
+
const frame = JSON.parse(line);
|
|
75
|
+
if (!authenticated) {
|
|
76
|
+
if (frame.kind !== 'authenticated') {
|
|
77
|
+
finish(reject, new Error(`Daemon authentication failed for ${command}`));
|
|
78
|
+
return;
|
|
79
|
+
}
|
|
80
|
+
authenticated = true;
|
|
81
|
+
socket.write(`${JSON.stringify({
|
|
82
|
+
protocolVersion: 1, kind: 'request', requestId, command, payload,
|
|
83
|
+
})}\n`);
|
|
84
|
+
continue;
|
|
85
|
+
}
|
|
86
|
+
if (frame.kind === 'response' && frame.requestId === requestId) {
|
|
87
|
+
finish(resolve, { ok: true, result: frame.result });
|
|
88
|
+
return;
|
|
89
|
+
}
|
|
90
|
+
if (frame.kind === 'error') {
|
|
91
|
+
finish(resolve, { ok: false, error: frame.error });
|
|
92
|
+
return;
|
|
93
|
+
}
|
|
94
|
+
}
|
|
95
|
+
});
|
|
96
|
+
socket.on('close', () => {
|
|
97
|
+
if (!settled && authenticated) finish(reject, new Error(`Daemon connection closed waiting for ${command}`));
|
|
98
|
+
});
|
|
99
|
+
});
|
|
100
|
+
|
|
101
|
+
function sleep(ms) {
|
|
102
|
+
return new Promise((resolve) => setTimeout(resolve, ms));
|
|
103
|
+
}
|
|
104
|
+
|
|
105
|
+
async function waitFor(predicate, { timeoutMs = 5_000, intervalMs = 10, message = 'Timed out' } = {}) {
|
|
106
|
+
const start = Date.now();
|
|
107
|
+
for (;;) {
|
|
108
|
+
try {
|
|
109
|
+
if (await predicate()) return true;
|
|
110
|
+
} catch {
|
|
111
|
+
// Retry until the timeout expires.
|
|
112
|
+
}
|
|
113
|
+
if (Date.now() - start > timeoutMs) throw new Error(message);
|
|
114
|
+
await sleep(intervalMs);
|
|
115
|
+
}
|
|
116
|
+
}
|
|
117
|
+
|
|
118
|
+
class FakeSession {
|
|
119
|
+
constructor(sessionId, { modelNotFound = false, thinkingShouldThrow = false } = {}) {
|
|
120
|
+
this.sessionId = sessionId;
|
|
121
|
+
this.isStreaming = false;
|
|
122
|
+
this.isCompacting = false;
|
|
123
|
+
this.listeners = new Set();
|
|
124
|
+
this.names = [];
|
|
125
|
+
this.entries = [];
|
|
126
|
+
this.model = { provider: 'test', id: 'model' };
|
|
127
|
+
this.thinkingLevel = 'low';
|
|
128
|
+
this.modelNotFound = modelNotFound;
|
|
129
|
+
this.thinkingShouldThrow = thinkingShouldThrow;
|
|
130
|
+
this.modelRuntime = {
|
|
131
|
+
getModel: (providerId, modelId) => {
|
|
132
|
+
if (this.modelNotFound) return undefined;
|
|
133
|
+
return { provider: providerId, id: modelId };
|
|
134
|
+
},
|
|
135
|
+
getModels: () => [{ provider: 'test', id: 'model', name: 'Test model', contextWindow: 128_000, reasoning: true }],
|
|
136
|
+
getProvider: (providerId) => (providerId === 'test' ? ({ name: 'Test provider' }) : undefined),
|
|
137
|
+
getProviderAuthStatus: () => ({ configured: true }),
|
|
138
|
+
};
|
|
139
|
+
this.sessionManager = {
|
|
140
|
+
getSessionFile: () => undefined,
|
|
141
|
+
getHeader: () => ({ type: 'session', id: sessionId, cwd: '/tmp', timestamp: '2026-01-01T00:00:00.000Z' }),
|
|
142
|
+
getEntries: () => this.entries,
|
|
143
|
+
getLeafId: () => 'fake-entry',
|
|
144
|
+
getTree: () => [{ entry: { id: 'fake-entry', parentId: undefined, timestamp: '2026-01-01T00:00:00.000Z' }, children: [] }],
|
|
145
|
+
appendSessionInfo: (name) => this.names.push(name),
|
|
146
|
+
getSessionName: () => this.names[this.names.length - 1],
|
|
147
|
+
};
|
|
148
|
+
}
|
|
149
|
+
|
|
150
|
+
subscribe(listener) {
|
|
151
|
+
this.listeners.add(listener);
|
|
152
|
+
return () => this.listeners.delete(listener);
|
|
153
|
+
}
|
|
154
|
+
|
|
155
|
+
async setModel(model) {
|
|
156
|
+
this.model = model;
|
|
157
|
+
}
|
|
158
|
+
|
|
159
|
+
setThinkingLevel(thinking) {
|
|
160
|
+
if (this.thinkingShouldThrow) {
|
|
161
|
+
throw Object.assign(new Error('thinking setup rejected'), { code: 'THINKING_SETUP_FAILED' });
|
|
162
|
+
}
|
|
163
|
+
this.thinkingLevel = thinking;
|
|
164
|
+
}
|
|
165
|
+
|
|
166
|
+
async abort() {
|
|
167
|
+
this.isStreaming = false;
|
|
168
|
+
}
|
|
169
|
+
|
|
170
|
+
getSteeringMessages() { return []; }
|
|
171
|
+
getFollowUpMessages() { return []; }
|
|
172
|
+
}
|
|
173
|
+
|
|
174
|
+
class FakeRuntime {
|
|
175
|
+
constructor({ cwd, session, onDispose }) {
|
|
176
|
+
this.cwd = cwd;
|
|
177
|
+
this.session = session;
|
|
178
|
+
this.disposed = false;
|
|
179
|
+
this.onDispose = onDispose;
|
|
180
|
+
}
|
|
181
|
+
|
|
182
|
+
async dispose() {
|
|
183
|
+
if (typeof this.onDispose === 'function') await this.onDispose(this);
|
|
184
|
+
this.disposed = true;
|
|
185
|
+
}
|
|
186
|
+
}
|
|
187
|
+
|
|
188
|
+
describe('failed-create model/thinking cleanup', () => {
|
|
189
|
+
let tempRoot;
|
|
190
|
+
const daemons = [];
|
|
191
|
+
|
|
192
|
+
afterEach(async () => {
|
|
193
|
+
while (daemons.length > 0) {
|
|
194
|
+
const daemon = daemons.pop();
|
|
195
|
+
await daemon.stop().catch(() => {});
|
|
196
|
+
}
|
|
197
|
+
if (tempRoot) {
|
|
198
|
+
await rm(tempRoot, { recursive: true, force: true }).catch(() => {});
|
|
199
|
+
tempRoot = null;
|
|
200
|
+
}
|
|
201
|
+
});
|
|
202
|
+
|
|
203
|
+
it('invalid model keeps the lease on dispose failure and delete retries exactly once', async () => {
|
|
204
|
+
tempRoot = await mkdtemp(join(tmpdir(), 'pichamber-failed-create-model-'));
|
|
205
|
+
const projectDir = join(tempRoot, 'project');
|
|
206
|
+
const agentDir = join(tempRoot, 'agent');
|
|
207
|
+
const endpoint = testDaemonEndpoint(tempRoot);
|
|
208
|
+
await mkdir(projectDir, { recursive: true });
|
|
209
|
+
await mkdir(agentDir, { recursive: true });
|
|
210
|
+
|
|
211
|
+
const sessionId = 'failed-create-model-session';
|
|
212
|
+
const leaseFile = resolveSessionLeaseFile({ agentDir, cwd: projectDir, sessionId }).file;
|
|
213
|
+
const sessionDir = getPiSessionDirectory({ cwd: projectDir, agentDir });
|
|
214
|
+
const assignedPath = join(sessionDir, `20260101T000000Z_${sessionId}.jsonl`);
|
|
215
|
+
|
|
216
|
+
const session = new FakeSession(sessionId, { modelNotFound: true });
|
|
217
|
+
let disposeAttempts = 0;
|
|
218
|
+
let disposeShouldFail = true;
|
|
219
|
+
const runtime = new FakeRuntime({
|
|
220
|
+
cwd: projectDir,
|
|
221
|
+
session,
|
|
222
|
+
onDispose: async () => {
|
|
223
|
+
disposeAttempts += 1;
|
|
224
|
+
if (disposeShouldFail) {
|
|
225
|
+
throw Object.assign(new Error('first dispose rejected'), { code: 'DISPOSE_REJECTED' });
|
|
226
|
+
}
|
|
227
|
+
},
|
|
228
|
+
});
|
|
229
|
+
|
|
230
|
+
// Persisted file appears only to let delete exercise its normal unlink
|
|
231
|
+
// after the pending drain; it is created after the failed create so the
|
|
232
|
+
// create itself stays ephemeral.
|
|
233
|
+
let persistedAvailable = false;
|
|
234
|
+
const daemon = createSessionDaemon({
|
|
235
|
+
endpoint,
|
|
236
|
+
credential,
|
|
237
|
+
cwd: projectDir,
|
|
238
|
+
agentDir,
|
|
239
|
+
idleTimeoutMs: 60_000,
|
|
240
|
+
profileKey: 'test-failed-create-model',
|
|
241
|
+
daemonId: 'test-daemon-model',
|
|
242
|
+
serverInstanceId: 'test-server-model',
|
|
243
|
+
serverPid: process.pid,
|
|
244
|
+
createRuntime: async () => runtime,
|
|
245
|
+
listSessions: async () => (persistedAvailable
|
|
246
|
+
? [{ path: assignedPath, id: sessionId, cwd: projectDir, created: new Date(), modified: new Date(), messageCount: 0 }]
|
|
247
|
+
: []),
|
|
248
|
+
});
|
|
249
|
+
daemons.push(daemon);
|
|
250
|
+
await daemon.start();
|
|
251
|
+
|
|
252
|
+
const created = await daemonRequest(endpoint, 'sessions.create', {
|
|
253
|
+
cwd: projectDir,
|
|
254
|
+
model: { providerId: 'test', modelId: 'missing-model' },
|
|
255
|
+
});
|
|
256
|
+
// Original model error wins over the disposal rejection.
|
|
257
|
+
expect(created.ok).toBe(false);
|
|
258
|
+
expect(created.error?.code).toBe('INVALID_MODEL');
|
|
259
|
+
expect(disposeAttempts).toBe(1);
|
|
260
|
+
|
|
261
|
+
// Dispose-first failure retains ownership: runtime not marked disposed,
|
|
262
|
+
// lease still held, failed runtime never exposed through open.
|
|
263
|
+
expect(runtime.disposed).toBe(false);
|
|
264
|
+
await expect(stat(leaseFile)).resolves.toBeDefined();
|
|
265
|
+
const openedBeforeDelete = await daemonRequest(endpoint, 'sessions.open', { sessionId, directory: projectDir });
|
|
266
|
+
expect(openedBeforeDelete.ok).toBe(false);
|
|
267
|
+
|
|
268
|
+
// Failed delete retry stays pending without releasing ownership.
|
|
269
|
+
await mkdir(sessionDir, { recursive: true });
|
|
270
|
+
await writeFile(assignedPath, `${JSON.stringify({ type: 'session', id: sessionId, version: 3, timestamp: '2026-01-01T00:00:00.000Z', cwd: projectDir })}\n`);
|
|
271
|
+
persistedAvailable = true;
|
|
272
|
+
const deleteWhileDisposeFails = await daemonRequest(endpoint, 'sessions.delete', { sessionId, directory: projectDir });
|
|
273
|
+
expect(deleteWhileDisposeFails.ok).toBe(false);
|
|
274
|
+
expect(deleteWhileDisposeFails.error?.code).toBe('RUNTIME_DISPOSAL_FAILED');
|
|
275
|
+
expect(disposeAttempts).toBe(2);
|
|
276
|
+
expect(runtime.disposed).toBe(false);
|
|
277
|
+
await expect(stat(leaseFile)).resolves.toBeDefined();
|
|
278
|
+
// Persisted file is untouched while the pending dispose keeps failing.
|
|
279
|
+
await expect(stat(assignedPath)).resolves.toBeDefined();
|
|
280
|
+
|
|
281
|
+
// Successful delete retry disposes exactly once more and releases.
|
|
282
|
+
disposeShouldFail = false;
|
|
283
|
+
const deleted = await daemonRequest(endpoint, 'sessions.delete', { sessionId, directory: projectDir });
|
|
284
|
+
expect(deleted.ok).toBe(true);
|
|
285
|
+
expect(disposeAttempts).toBe(3);
|
|
286
|
+
expect(runtime.disposed).toBe(true);
|
|
287
|
+
await waitFor(async () => (await stat(leaseFile).then(() => false).catch((error) => error?.code === 'ENOENT')) === true, {
|
|
288
|
+
message: 'failed-create lease was not released by successful delete retry',
|
|
289
|
+
});
|
|
290
|
+
await expect(stat(assignedPath)).rejects.toMatchObject({ code: 'ENOENT' });
|
|
291
|
+
|
|
292
|
+
// No double-dispose/release: stopping after a drained delete is a no-op.
|
|
293
|
+
await daemon.stop();
|
|
294
|
+
expect(disposeAttempts).toBe(3);
|
|
295
|
+
await expect(stat(leaseFile)).rejects.toMatchObject({ code: 'ENOENT' });
|
|
296
|
+
daemons.pop();
|
|
297
|
+
}, 60_000);
|
|
298
|
+
|
|
299
|
+
it('invalid thinking keeps the lease on dispose failure and stop retries exactly once', async () => {
|
|
300
|
+
tempRoot = await mkdtemp(join(tmpdir(), 'pichamber-failed-create-thinking-'));
|
|
301
|
+
const projectDir = join(tempRoot, 'project');
|
|
302
|
+
const agentDir = join(tempRoot, 'agent');
|
|
303
|
+
const endpoint = testDaemonEndpoint(tempRoot);
|
|
304
|
+
await mkdir(projectDir, { recursive: true });
|
|
305
|
+
await mkdir(agentDir, { recursive: true });
|
|
306
|
+
|
|
307
|
+
const sessionId = 'failed-create-thinking-session';
|
|
308
|
+
const leaseFile = resolveSessionLeaseFile({ agentDir, cwd: projectDir, sessionId }).file;
|
|
309
|
+
|
|
310
|
+
const session = new FakeSession(sessionId, { thinkingShouldThrow: true });
|
|
311
|
+
let disposeAttempts = 0;
|
|
312
|
+
let disposeShouldFail = true;
|
|
313
|
+
const runtime = new FakeRuntime({
|
|
314
|
+
cwd: projectDir,
|
|
315
|
+
session,
|
|
316
|
+
onDispose: async () => {
|
|
317
|
+
disposeAttempts += 1;
|
|
318
|
+
if (disposeShouldFail) {
|
|
319
|
+
throw Object.assign(new Error('first dispose rejected'), { code: 'DISPOSE_REJECTED' });
|
|
320
|
+
}
|
|
321
|
+
},
|
|
322
|
+
});
|
|
323
|
+
|
|
324
|
+
const daemon = createSessionDaemon({
|
|
325
|
+
endpoint,
|
|
326
|
+
credential,
|
|
327
|
+
cwd: projectDir,
|
|
328
|
+
agentDir,
|
|
329
|
+
idleTimeoutMs: 60_000,
|
|
330
|
+
profileKey: 'test-failed-create-thinking',
|
|
331
|
+
daemonId: 'test-daemon-thinking',
|
|
332
|
+
serverInstanceId: 'test-server-thinking',
|
|
333
|
+
serverPid: process.pid,
|
|
334
|
+
createRuntime: async () => runtime,
|
|
335
|
+
});
|
|
336
|
+
daemons.push(daemon);
|
|
337
|
+
await daemon.start();
|
|
338
|
+
|
|
339
|
+
const created = await daemonRequest(endpoint, 'sessions.create', { cwd: projectDir, thinking: 'high' });
|
|
340
|
+
// Original thinking error wins over the disposal rejection.
|
|
341
|
+
expect(created.ok).toBe(false);
|
|
342
|
+
expect(created.error?.code).toBe('THINKING_SETUP_FAILED');
|
|
343
|
+
expect(disposeAttempts).toBe(1);
|
|
344
|
+
|
|
345
|
+
// Lease remains held and the failed runtime stays unexposed.
|
|
346
|
+
expect(runtime.disposed).toBe(false);
|
|
347
|
+
await expect(stat(leaseFile)).resolves.toBeDefined();
|
|
348
|
+
const opened = await daemonRequest(endpoint, 'sessions.open', { sessionId, directory: projectDir });
|
|
349
|
+
expect(opened.ok).toBe(false);
|
|
350
|
+
|
|
351
|
+
// Stop retries the pending cleanup dispose-first. A failing retry stays
|
|
352
|
+
// pending without releasing ownership.
|
|
353
|
+
await daemon.stop();
|
|
354
|
+
expect(disposeAttempts).toBe(2);
|
|
355
|
+
expect(runtime.disposed).toBe(false);
|
|
356
|
+
await expect(stat(leaseFile)).resolves.toBeDefined();
|
|
357
|
+
|
|
358
|
+
// Successful stop retry releases the lease with exactly one more dispose.
|
|
359
|
+
// The pending record survives stop/start because it is daemon-owned.
|
|
360
|
+
disposeShouldFail = false;
|
|
361
|
+
await daemon.start();
|
|
362
|
+
await daemon.stop();
|
|
363
|
+
expect(disposeAttempts).toBe(3);
|
|
364
|
+
expect(runtime.disposed).toBe(true);
|
|
365
|
+
await waitFor(async () => (await stat(leaseFile).then(() => false).catch((error) => error?.code === 'ENOENT')) === true, {
|
|
366
|
+
message: 'failed-create lease was not released by successful stop retry',
|
|
367
|
+
});
|
|
368
|
+
await expect(stat(leaseFile)).rejects.toMatchObject({ code: 'ENOENT' });
|
|
369
|
+
expect(disposeAttempts).toBe(3);
|
|
370
|
+
daemons.pop();
|
|
371
|
+
}, 60_000);
|
|
372
|
+
});
|