agents-relay 2.0.199 → 2.0.201

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
- const file = join(process.env.TMPDIR || '/tmp', `relay-browser-pool-${randomUUID()}.json`);
67
- try {
68
- await writeFile(file, JSON.stringify(config), { mode: 0o600, flag: 'wx' });
69
- return parseEnvelope(await cliCommand(['platform', 'run', provider, action, '--session-id', sessionId, '--config', file], undefined, signal));
70
- }
71
- finally {
72
- await unlink(file).catch(() => { });
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 browserKeepAliveAt = 0, observedAt = Date.now(), lastFingerprint = '', sampled = false;
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 cliCommand(['session', 'stop', sessionId]);
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 = () => { released = true; if (!lease)
129
- return; if (verifiedSubmitted || submissionAttempted) {
130
- uncertain = true;
131
- pool.quarantine(lease);
132
- }
133
- else
134
- void stop().catch(() => { }); };
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
- // Chrome's lastAccessed may only update on tab activation. Never classify this as Worker progress.
162
- if (now - browserKeepAliveAt >= (request.heartbeatIntervalMs ?? 120_000)) {
163
- await cliCommand(['session', 'exec', sessionId], 'await activate_tab();');
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
- session = parseEnvelope(await cliCommand(['session', 'start', '--workspace', WORKSPACE], undefined, signal));
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
- // Preserve WebHelm's existing extension lifecycle. Pool capacity is six tabs total.
228
- await cliCommand(['session', 'exec', sessionId], `await workspace_resize(${JSON.stringify(WORKSPACE)},6);`);
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
- else
284
- await stop();
343
+ await stop();
285
344
  }
286
345
  throw rejection;
287
346
  }
package/dist/cli-help.js CHANGED
@@ -57,8 +57,10 @@ Example:
57
57
 
58
58
  agents-relay prompt --id JOB --plan-id PLAN --adapter codex|chatgpt|z [--output FILE]
59
59
  agents-relay prompt --id JOB --task-id TASK --adapter codex|chatgpt|z [--output FILE]
60
+ agents-relay prompt --eval-file CASE.json --adapter codex|chatgpt|z [--output FILE]
60
61
 
61
- Raw worker-facing text on stdout, no profile wrapper. --repo selects local SQLite,
62
+ A detached --eval-file returns JSON with productionPrompt and safe evaluationPrompt from the SAME managedWorkerInput Builder; it never creates or changes a Job.
63
+ Raw durable worker-facing text on stdout, no profile wrapper. --repo selects local SQLite,
62
64
  not GitHub. Old completed Plans are reconstructed from recorded IDs and prior
63
65
  Task history; their original historical prompt bytes are not persisted. Only
64
66
  Codex currently has production Planner dispatch. Web Planner variants show the
@@ -1,4 +1,4 @@
1
- import { writeFile } from 'node:fs/promises';
1
+ import { readFile, writeFile } from 'node:fs/promises';
2
2
  import { plannerInput } from './planner.js';
3
3
  import { arg, storeFor } from './cli-support.js';
4
4
  import { resolveExecutionContext } from './execution-context.js';
@@ -7,6 +7,7 @@ import { managedWorkerInput } from './managed-worker-input.js';
7
7
  import { resolveManagedProjectPath, resolveRepositoryProjectPath } from './workspace.js';
8
8
  import { taskExecutionContext } from './task-context.js';
9
9
  import { eventsBusHistoryPage } from './events-bus-runtime.js';
10
+ import { createJobEntity, createTaskEntity } from './workflow/entity-creation.js';
10
11
  /** Print the actual prompt emitted by the same production Builder entry point.
11
12
  * This is read-only: it does not start an adapter, create a Plan or mutate a Task.
12
13
  */
@@ -14,6 +15,42 @@ export async function runPromptCommand(args) {
14
15
  const adapter = arg(args, '--adapter', 'codex');
15
16
  if (!['codex', 'chatgpt', 'z'].includes(adapter))
16
17
  throw new Error('prompt --adapter must be codex|chatgpt|z');
18
+ const evalFile = arg(args, '--eval-file');
19
+ if (evalFile) {
20
+ if (arg(args, '--id') || arg(args, '--repo') || arg(args, '--plan-id') || arg(args, '--task-id'))
21
+ throw new Error('prompt --eval-file cannot bind a durable Job or Task');
22
+ // Isolated, read-only Builder invocation: no persisted Job, Task or Events Bus.
23
+ const scenario = JSON.parse(await readFile(evalFile, 'utf8'));
24
+ if (!scenario.projectPath || !scenario.agentName || !scenario.taskInput?.trim() || !/^[a-z0-9-]+$/.test(scenario.agentName))
25
+ throw new Error('prompt --eval-file requires projectPath, agentName and taskInput');
26
+ const projectPath = scenario.projectPath;
27
+ const context = await resolveExecutionContext(projectPath, 'worker');
28
+ const now = new Date().toISOString();
29
+ const caseId = scenario.caseId && /^[a-zA-Z0-9_-]+$/.test(scenario.caseId) ? scenario.caseId : 'case';
30
+ const job = createJobEntity({
31
+ id: 'EVAL_ONLY', title: 'Isolated prompt quality evaluation', repository: 'eval/isolated', prNumber: 0,
32
+ continuation: null, tasks: [], createdAt: now, updatedAt: now, projectPath,
33
+ });
34
+ const task = createTaskEntity(job, {
35
+ id: `eval-${caseId}`, jobId: 'EVAL_ONLY', title: caseId, agentName: scenario.agentName,
36
+ adapter, input: scenario.taskInput, output: { kind: 'file', path: '.evals/reports/evaluation-only.json' },
37
+ parentTaskId: null, dependencies: [], capabilities: [], attempt: 0, maxAttempts: 1,
38
+ leaseOwner: null, leaseExpiresAt: null, executionId: `eval-${caseId}-isolated`, threadId: null,
39
+ result: null, error: null, timeoutMs: 0, createdAt: now, updatedAt: now,
40
+ }, { defer: true });
41
+ job.tasks.push(task);
42
+ const productionPrompt = await managedWorkerInput(job, task, context);
43
+ const evaluationPrompt = await managedWorkerInput(job, task, context, 'evaluation');
44
+ const result = JSON.stringify({ builder: 'managedWorkerInput', mode: 'isolated-evaluation',
45
+ projectPath: context.project.path, agentName: scenario.agentName, adapter,
46
+ productionPrompt, evaluationPrompt }, null, 2);
47
+ const output = arg(args, '--output');
48
+ if (output)
49
+ await writeFile(output, result + '\n', { mode: 0o600 });
50
+ else
51
+ console.log(result);
52
+ return;
53
+ }
17
54
  const planId = arg(args, '--plan-id'), taskId = arg(args, '--task-id');
18
55
  if (!!planId === !!taskId)
19
56
  throw new Error('prompt requires exactly one of --plan-id or --task-id');
@@ -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
+ }
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "agents-relay",
3
- "version": "2.0.199",
3
+ "version": "2.0.201",
4
4
  "description": "Durable async agent jobs coordinated through GitHub pull requests",
5
5
  "repository": {
6
6
  "type": "git",