agents-relay 2.0.199 → 2.0.200
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.
|
@@ -1,11 +1,23 @@
|
|
|
1
|
-
import { randomUUID } from 'node:crypto';
|
|
2
|
-
import { writeFile, unlink } from 'node:fs/promises';
|
|
3
1
|
import { join } from 'node:path';
|
|
4
2
|
import { homedir } from 'node:os';
|
|
5
3
|
import { spawnOwnedProcess } from './owned-process.js';
|
|
6
4
|
import { BrowserWorkerPoolManager, BrowserPoolAdmissionError } from './browser-worker-pool.js';
|
|
7
5
|
import { monitorPoolDecision, progressPoolDecision } from './browser-worker-pool-graph.js';
|
|
6
|
+
import { webHelmDaemonRequest } from './webhelm-daemon-client.js';
|
|
8
7
|
const WORKSPACE = 'Neo';
|
|
8
|
+
const WORKSPACE_CAPACITY = 6;
|
|
9
|
+
let pendingWorkspaceProvision;
|
|
10
|
+
async function ensureNeoWorkspace() {
|
|
11
|
+
if (!pendingWorkspaceProvision) {
|
|
12
|
+
pendingWorkspaceProvision = (async () => {
|
|
13
|
+
// Shared setup must outlive cancellation by one waiting Worker.
|
|
14
|
+
await cliCommand(['ensure']);
|
|
15
|
+
await webHelmDaemonRequest({ op: 'workspace-create', name: WORKSPACE, pool_size: WORKSPACE_CAPACITY });
|
|
16
|
+
})();
|
|
17
|
+
void pendingWorkspaceProvision.finally(() => { pendingWorkspaceProvision = undefined; }).catch(() => { });
|
|
18
|
+
}
|
|
19
|
+
await pendingWorkspaceProvision;
|
|
20
|
+
}
|
|
9
21
|
const OUTPUT_LIMIT = 2_000_000;
|
|
10
22
|
let manager;
|
|
11
23
|
export const browserWorkerPool = () => manager ??= new BrowserWorkerPoolManager();
|
|
@@ -63,14 +75,39 @@ function parseEnvelope(value) {
|
|
|
63
75
|
throw Error('WebHelm returned no structured result');
|
|
64
76
|
}
|
|
65
77
|
async function configRun(provider, action, sessionId, config, signal) {
|
|
66
|
-
|
|
67
|
-
|
|
68
|
-
|
|
69
|
-
|
|
70
|
-
|
|
71
|
-
|
|
72
|
-
|
|
78
|
+
return parseEnvelope(JSON.stringify(await webHelmDaemonRequest({
|
|
79
|
+
op: 'platform-run', platform: provider, action, session_id: sessionId, config,
|
|
80
|
+
auto_session: false, workspace: WORKSPACE,
|
|
81
|
+
}, { signal, timeoutMs: 150_000 })));
|
|
82
|
+
}
|
|
83
|
+
/** Verify release by exact Session ID; a transient navigation error may
|
|
84
|
+
* already have returned the Tab to helm.html but left daemon ownership active.
|
|
85
|
+
* Never free the Relay lease without stop/read-back evidence. */
|
|
86
|
+
async function stopWebHelmSessionVerified(sessionId) {
|
|
87
|
+
let lastError = new Error('WebHelm Session release was not verified');
|
|
88
|
+
for (let attempt = 0; attempt < 2; attempt++) {
|
|
89
|
+
try {
|
|
90
|
+
const result = await webHelmDaemonRequest({ op: 'stop', session_id: sessionId }, { timeoutMs: 45_000 });
|
|
91
|
+
if (result.returned_to_idle === true || result.already_closed === true)
|
|
92
|
+
return;
|
|
93
|
+
lastError = new Error('WebHelm stop returned no verified idle tab receipt');
|
|
94
|
+
}
|
|
95
|
+
catch (error) {
|
|
96
|
+
lastError = error instanceof Error ? error : new Error(String(error));
|
|
97
|
+
}
|
|
98
|
+
// Idempotent recovery: a lost response is not a failed stop if the
|
|
99
|
+
// daemon independently confirms this exact Session is no longer owned.
|
|
100
|
+
try {
|
|
101
|
+
const state = await webHelmDaemonRequest({ op: 'list' }, { timeoutMs: 15_000 });
|
|
102
|
+
const sessions = state.sessions;
|
|
103
|
+
if (Array.isArray(sessions) && !sessions.some(row => typeof row === 'object' && row !== null && row.session_id === sessionId))
|
|
104
|
+
return;
|
|
105
|
+
}
|
|
106
|
+
catch { /* no proof: keep the original lease */ }
|
|
107
|
+
if (attempt === 0)
|
|
108
|
+
await new Promise(resolve => setTimeout(resolve, 250));
|
|
73
109
|
}
|
|
110
|
+
throw lastError;
|
|
74
111
|
}
|
|
75
112
|
/** Poll only real assistant output, not page uptime or the browser keepalive. */
|
|
76
113
|
const OBSERVE = `const url=(await page_info()).url;
|
|
@@ -84,10 +121,12 @@ export function pooledWebHelmRun(request, signal) {
|
|
|
84
121
|
let released = false;
|
|
85
122
|
let stopped = false;
|
|
86
123
|
let monitor;
|
|
124
|
+
let heartbeatTimer;
|
|
125
|
+
let pendingHeartbeat;
|
|
87
126
|
let completionRecoveryTimer;
|
|
88
127
|
let pendingProbe, pendingCompletionRecovery;
|
|
89
128
|
let stopping;
|
|
90
|
-
let
|
|
129
|
+
let observedAt = Date.now(), lastFingerprint = '', sampled = false;
|
|
91
130
|
let recoveries = 0, monitoring = false, threadId;
|
|
92
131
|
let submissionAttempted = false, verifiedSubmitted = false, uncertain = false, recoveryOutcomeUncertain = false;
|
|
93
132
|
let providerPreflightFailed = false;
|
|
@@ -97,12 +136,14 @@ export function pooledWebHelmRun(request, signal) {
|
|
|
97
136
|
stopped = true;
|
|
98
137
|
if (monitor)
|
|
99
138
|
clearInterval(monitor);
|
|
139
|
+
if (heartbeatTimer)
|
|
140
|
+
clearInterval(heartbeatTimer);
|
|
100
141
|
if (completionRecoveryTimer)
|
|
101
142
|
clearTimeout(completionRecoveryTimer);
|
|
102
143
|
stopping = (async () => {
|
|
103
144
|
// Clearing the interval does not cancel an already running WebHelm
|
|
104
145
|
// command. Drain it before closing the session or releasing the slot.
|
|
105
|
-
await Promise.allSettled([pendingProbe, pendingCompletionRecovery]);
|
|
146
|
+
await Promise.allSettled([pendingProbe, pendingCompletionRecovery, pendingHeartbeat]);
|
|
106
147
|
if (!lease)
|
|
107
148
|
return;
|
|
108
149
|
if (uncertain) {
|
|
@@ -114,7 +155,7 @@ export function pooledWebHelmRun(request, signal) {
|
|
|
114
155
|
return;
|
|
115
156
|
}
|
|
116
157
|
try {
|
|
117
|
-
await
|
|
158
|
+
await stopWebHelmSessionVerified(sessionId);
|
|
118
159
|
pool.release(lease);
|
|
119
160
|
}
|
|
120
161
|
catch {
|
|
@@ -125,13 +166,19 @@ export function pooledWebHelmRun(request, signal) {
|
|
|
125
166
|
};
|
|
126
167
|
const release = async () => { released = true; if (lease)
|
|
127
168
|
await stop(); };
|
|
128
|
-
const cancel = () => {
|
|
129
|
-
|
|
130
|
-
|
|
131
|
-
|
|
132
|
-
|
|
133
|
-
|
|
134
|
-
|
|
169
|
+
const cancel = () => {
|
|
170
|
+
released = true;
|
|
171
|
+
if (!lease)
|
|
172
|
+
return;
|
|
173
|
+
if (verifiedSubmitted || submissionAttempted) {
|
|
174
|
+
uncertain = true;
|
|
175
|
+
pool.quarantine(lease);
|
|
176
|
+
}
|
|
177
|
+
// Cancel must halt keepalives and probes even when delivery is uncertain.
|
|
178
|
+
// Leave the quarantined Session open; WebHelm can reclaim it on demand
|
|
179
|
+
// after its last_used_at expires without falsely freeing the Relay slot.
|
|
180
|
+
void stop().catch(() => { });
|
|
181
|
+
};
|
|
135
182
|
const sendRecovery = async () => {
|
|
136
183
|
if (stopped || released || uncertain || recoveryOutcomeUncertain || !sessionId || !threadId || !request.recover || recoveries >= 2)
|
|
137
184
|
return;
|
|
@@ -158,12 +205,9 @@ export function pooledWebHelmRun(request, signal) {
|
|
|
158
205
|
monitoring = true;
|
|
159
206
|
try {
|
|
160
207
|
const now = Date.now();
|
|
161
|
-
|
|
162
|
-
|
|
163
|
-
|
|
164
|
-
browserKeepAliveAt = now;
|
|
165
|
-
}
|
|
166
|
-
const observation = parseEnvelope(await cliCommand(['session', 'exec', sessionId], OBSERVE));
|
|
208
|
+
const observation = parseEnvelope(JSON.stringify(await webHelmDaemonRequest({
|
|
209
|
+
op: 'exec', session_id: sessionId, code: OBSERVE,
|
|
210
|
+
}, { timeoutMs: 45_000 })));
|
|
167
211
|
if (observation.url && observation.url.split('?')[0].replace(/\/$/, '') !== lease.threadUrl.replace(/\/$/, ''))
|
|
168
212
|
return;
|
|
169
213
|
const current = fingerprint(observation);
|
|
@@ -214,7 +258,8 @@ export function pooledWebHelmRun(request, signal) {
|
|
|
214
258
|
throw Error(`WebHelm platform ${request.provider} missing`);
|
|
215
259
|
let session;
|
|
216
260
|
try {
|
|
217
|
-
|
|
261
|
+
await ensureNeoWorkspace();
|
|
262
|
+
session = await webHelmDaemonRequest({ op: 'start', workspace: WORKSPACE }, { signal, timeoutMs: 60_000 });
|
|
218
263
|
}
|
|
219
264
|
catch (error) {
|
|
220
265
|
providerPreflightFailed = true;
|
|
@@ -224,8 +269,23 @@ export function pooledWebHelmRun(request, signal) {
|
|
|
224
269
|
throw Error('No WebHelm session ID');
|
|
225
270
|
sessionId = session.session_id;
|
|
226
271
|
pool.bindSession(lease, sessionId);
|
|
227
|
-
|
|
228
|
-
|
|
272
|
+
if (session.workspace !== WORKSPACE || session.workspace_supported !== true) {
|
|
273
|
+
throw Error('WebHelm returned a Session outside the provisioned Neo Workspace');
|
|
274
|
+
}
|
|
275
|
+
// Keep session last_used_at fresh without mutating the worker's model progress.
|
|
276
|
+
const heartbeatPeriod = Math.max(1000, Math.min(request.heartbeatIntervalMs ?? 45_000, 60_000));
|
|
277
|
+
heartbeatTimer = setInterval(() => {
|
|
278
|
+
if (stopped || !sessionId || pendingHeartbeat)
|
|
279
|
+
return;
|
|
280
|
+
const active = webHelmDaemonRequest({ op: 'heartbeat', session_id: sessionId }, { timeoutMs: 15_000 })
|
|
281
|
+
.then(reply => { if (reply.alive !== true)
|
|
282
|
+
throw Error('WebHelm rejected Session heartbeat'); })
|
|
283
|
+
.catch(() => { })
|
|
284
|
+
.finally(() => { if (pendingHeartbeat === active)
|
|
285
|
+
pendingHeartbeat = undefined; });
|
|
286
|
+
pendingHeartbeat = active;
|
|
287
|
+
}, heartbeatPeriod);
|
|
288
|
+
heartbeatTimer.unref();
|
|
229
289
|
if (released || signal.aborted)
|
|
230
290
|
throw Error('Browser worker cancelled before submission');
|
|
231
291
|
const cfg = await request.build();
|
|
@@ -280,8 +340,7 @@ export function pooledWebHelmRun(request, signal) {
|
|
|
280
340
|
uncertain = true;
|
|
281
341
|
pool.quarantine(lease);
|
|
282
342
|
}
|
|
283
|
-
|
|
284
|
-
await stop();
|
|
343
|
+
await stop();
|
|
285
344
|
}
|
|
286
345
|
throw rejection;
|
|
287
346
|
}
|
|
@@ -0,0 +1,57 @@
|
|
|
1
|
+
import { createConnection } from 'node:net';
|
|
2
|
+
import { join } from 'node:path';
|
|
3
|
+
import { homedir } from 'node:os';
|
|
4
|
+
const daemonSocket = () => process.env.WEBHELM_SOCKET ||
|
|
5
|
+
join(process.env.WEBHELM_RUNTIME_DIR ||
|
|
6
|
+
join(process.env.WEBHELM_CONFIG_ROOT || join(homedir(), '.config', 'webhelm'), 'runtime'), 'session-node.sock');
|
|
7
|
+
/** Application-owned WebHelm IPC: never provision custom Workspaces via the agent CLI. */
|
|
8
|
+
export function webHelmDaemonRequest(payload, options = {}) {
|
|
9
|
+
return new Promise((resolve, reject) => {
|
|
10
|
+
const socket = createConnection({ path: daemonSocket() });
|
|
11
|
+
const timeoutMs = options.timeoutMs ?? 45_000;
|
|
12
|
+
let buffer = '';
|
|
13
|
+
let settled = false;
|
|
14
|
+
const settle = (error, value) => {
|
|
15
|
+
if (settled)
|
|
16
|
+
return;
|
|
17
|
+
settled = true;
|
|
18
|
+
options.signal?.removeEventListener('abort', onAbort);
|
|
19
|
+
socket.destroy();
|
|
20
|
+
if (error)
|
|
21
|
+
reject(error);
|
|
22
|
+
else
|
|
23
|
+
resolve(value ?? {});
|
|
24
|
+
};
|
|
25
|
+
const onAbort = () => settle(new Error('WebHelm daemon request aborted'));
|
|
26
|
+
if (options.signal?.aborted) {
|
|
27
|
+
onAbort();
|
|
28
|
+
return;
|
|
29
|
+
}
|
|
30
|
+
options.signal?.addEventListener('abort', onAbort, { once: true });
|
|
31
|
+
socket.setEncoding('utf8');
|
|
32
|
+
socket.setTimeout(timeoutMs, () => settle(new Error('WebHelm daemon ' + payload.op + ' timed out')));
|
|
33
|
+
socket.once('connect', () => socket.write(JSON.stringify(payload) + '\n'));
|
|
34
|
+
socket.on('data', (chunk) => {
|
|
35
|
+
buffer += chunk;
|
|
36
|
+
if (buffer.length > 2_000_000)
|
|
37
|
+
return settle(new Error('WebHelm daemon response exceeds limit'));
|
|
38
|
+
const delimiter = buffer.indexOf('\n');
|
|
39
|
+
if (delimiter < 0)
|
|
40
|
+
return;
|
|
41
|
+
try {
|
|
42
|
+
const result = JSON.parse(buffer.slice(0, delimiter));
|
|
43
|
+
if (result.error || result.ok === false)
|
|
44
|
+
return settle(new Error(String(result.error || 'WebHelm daemon rejected request')));
|
|
45
|
+
settle(undefined, result);
|
|
46
|
+
}
|
|
47
|
+
catch (error) {
|
|
48
|
+
settle(error instanceof Error ? error : new Error(String(error)));
|
|
49
|
+
}
|
|
50
|
+
});
|
|
51
|
+
socket.once('error', (error) => settle(error));
|
|
52
|
+
socket.once('end', () => {
|
|
53
|
+
if (!settled)
|
|
54
|
+
settle(new Error('WebHelm daemon closed without a response'));
|
|
55
|
+
});
|
|
56
|
+
});
|
|
57
|
+
}
|