agents-relay 2.0.33 → 2.0.34

package/dist/adapters.js

@@ -120,6 +120,8 @@ export class CodexAdapter {
         return execution;
     }
 }
+export const CHATGPT_BROWSER_WORKSPACE = 'agents-replay';
+export const CHATGPT_BROWSER_WORKSPACE_POOL_SIZE = 6;
 export function chatGptTabClosePolicy(value, fallback = 'after-start') {
     const policy = value || fallback;
     if (!['after-start', 'never', 'after-terminal'].includes(policy))
@@ -163,62 +165,129 @@ function parseDriverJson(output) {
     }
     throw new Error('browser-worker driver returned no submitted receipt');
 }
-function directBrowserWorkerRunner(root) {
-    return (_definition, request, _route, signal) => {
-        const releaseFile = join(process.env.TMPDIR ?? '/tmp', `agents-relay-chatgpt-release-${randomUUID()}`);
-        const args = [join(root, 'scripts', 'temporary_bh.py'), '--prompt', request.prompt, '--release-file', releaseFile, '--close-policy', request.tabClosePolicy ?? 'after-start'];
-        for (const file of request.files ?? [])
-            args.push('--file', file);
-        const child = spawn('python3', args, { shell: false, stdio: ['ignore', 'pipe', 'pipe'] });
+function browserWorkspaceCommand(command, args, stdin) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, [...args], { shell: false, stdio: [stdin === undefined ? 'ignore' : 'pipe', 'pipe', 'pipe'] });
         let stdout = '';
         let stderr = '';
-        let submitted = false;
+        child.stdout?.on('data', (chunk) => { stdout += chunk.toString(); });
+        child.stderr?.on('data', (chunk) => { stderr = appendTail(stderr, chunk.toString()); });
+        child.on('error', reject);
+        child.on('close', code => {
+            if (code === 0)
+                resolve(stdout.trim());
+            else
+                reject(new Error(stderr.trim() || stdout.trim() || `browser-workspace exited ${code}`));
+        });
+        if (stdin !== undefined) {
+            child.stdin?.end(stdin);
+        }
+    });
+}
+function parseWorkspaceJson(output) {
+    const lines = output.trim().split(/\r?\n/).filter(Boolean);
+    for (let index = lines.length - 1; index >= 0; index -= 1) {
+        try {
+            return JSON.parse(lines[index]);
+        }
+        catch { /* diagnostics may precede JSON */ }
+    }
+    throw new Error('browser-workspace returned no JSON result');
+}
+export async function ensureChatGptBrowserWorkspace(command = process.env.AGENTS_RELAY_BROWSER_WORKSPACE_COMMAND ?? 'browser-workspace') {
+    await browserWorkspaceCommand(command, ['create', CHATGPT_BROWSER_WORKSPACE, String(CHATGPT_BROWSER_WORKSPACE_POOL_SIZE)]);
+}
+function sessionBrowserWorkerRunner(root) {
+    const command = process.env.AGENTS_RELAY_BROWSER_WORKSPACE_COMMAND ?? 'browser-workspace';
+    return (_definition, request, _route, signal) => {
+        const policy = request.tabClosePolicy ?? 'after-start';
+        let activeSessionId;
+        let released = false;
+        let releaseResolve;
+        const releaseBarrier = new Promise(resolve => { releaseResolve = resolve; });
+        const release = () => {
+            if (released)
+                return;
+            released = true;
+            releaseResolve();
+        };
         let submittedResolve;
         let submittedReject;
-        const submittedPromise = new Promise((resolve, reject) => { submittedResolve = resolve; submittedReject = reject; });
-        child.stdout?.on('data', (chunk) => {
-            stdout += chunk.toString();
-            if (!submitted) {
-                try {
-                    const response = parseDriverJson(stdout);
-                    submitted = true;
-                    submittedResolve?.(JSON.stringify(response));
-                }
-                catch { /* receipt may be split across chunks */ }
-            }
+        const submitted = new Promise((resolve, reject) => {
+            submittedResolve = resolve;
+            submittedReject = reject;
         });
-        child.stderr?.on('data', (chunk) => {
-            stderr = appendTail(stderr, chunk.toString());
-        });
-        const promise = new Promise((resolve, reject) => {
-            child.on('error', reject);
-            child.on('close', code => {
-                if (code !== 0) {
-                    const error = new Error(stderr.trim() || stdout.trim() || `browser-worker driver exited ${code}`);
-                    submittedReject?.(error);
-                    reject(error);
-                    return;
+        const promise = (async () => {
+            const configFile = join(process.env.TMPDIR ?? '/tmp', `agents-relay-chatgpt-${randomUUID()}.json`);
+            try {
+                const [readiness, submitSource, temporarySource] = await Promise.all([
+                    readFile(join(root, 'scripts', '_submit_readiness.py'), 'utf8'),
+                    readFile(join(root, 'scripts', '_submit_bh.py'), 'utf8'),
+                    readFile(join(root, 'scripts', '_temporary_bh.py'), 'utf8'),
+                ]);
+                await writeFile(configFile, JSON.stringify({
+                    prompt: request.prompt,
+                    file: request.files ?? [],
+                    close_policy: policy,
+                    release_file: '',
+                }));
+                const startOutput = await browserWorkspaceCommand(command, ['session', 'start', '--workspace', CHATGPT_BROWSER_WORKSPACE]);
+                const started = parseWorkspaceJson(startOutput);
+                if (typeof started.session_id !== 'string') {
+                    throw new Error('browser-workspace session start returned no session_id');
                 }
-                try {
-                    const result = JSON.stringify(parseDriverJson(stdout));
-                    if (!submitted) {
-                        submitted = true;
-                        submittedResolve?.(result);
-                    }
-                    resolve(result);
+                activeSessionId = started.session_id;
+                if (signal.aborted)
+                    throw new Error('browser-worker execution aborted');
+                const escapedConfig = configFile.replaceAll('\\', '\\\\').replaceAll('"', '\\"');
+                const source = [
+                    readiness,
+                    submitSource.replace(/^from browser_harness import \*\s*$/m, ''),
+                    temporarySource.replace(/^_wait_for_release\(\)\s*$/m, ''),
+                ].join('\n\n').replaceAll('__CFG_PATH__', escapedConfig);
+                const execOutput = await browserWorkspaceCommand(command, ['session', 'exec', activeSessionId], source);
+                const wrapper = parseWorkspaceJson(execOutput);
+                if (wrapper.ok !== true) {
+                    throw new Error(typeof wrapper.error === 'string' ? wrapper.error : 'browser-workspace session exec failed');
                 }
-                catch (error) {
-                    reject(error);
+                const receipt = parseDriverJson(typeof wrapper.stdout === 'string' ? wrapper.stdout : '');
+                const result = JSON.stringify(receipt);
+                submittedResolve(result);
+                if (policy === 'never') {
+                    await unlink(configFile).catch(() => { });
+                    activeSessionId = undefined;
+                    return result;
                 }
-            });
-            if (signal.aborted)
-                child.kill('SIGTERM');
-            else
-                signal.addEventListener('abort', () => child.kill('SIGTERM'), { once: true });
-        });
-        const release = () => { void writeFile(releaseFile, 'release').catch(() => { }); };
-        promise.finally(() => { void unlink(releaseFile).catch(() => { }); }).catch(() => { });
-        return { promise, submitted: submittedPromise, release, cancel: () => { release(); child.kill('SIGTERM'); } };
+                await releaseBarrier;
+                if (activeSessionId) {
+                    await browserWorkspaceCommand(command, ['session', 'stop', activeSessionId]);
+                    activeSessionId = undefined;
+                }
+                return result;
+            }
+            catch (failure) {
+                if (activeSessionId) {
+                    await browserWorkspaceCommand(command, ['session', 'stop', activeSessionId]).catch(() => { });
+                    activeSessionId = undefined;
+                }
+                await unlink(configFile).catch(() => { });
+                const error = failure instanceof Error ? failure : new Error(String(failure));
+                submittedReject(error);
+                throw error;
+            }
+        })();
+        const cancel = () => {
+            release();
+            if (activeSessionId) {
+                void browserWorkspaceCommand(command, ['session', 'stop', activeSessionId]);
+                activeSessionId = undefined;
+            }
+        };
+        if (signal.aborted)
+            cancel();
+        else
+            signal.addEventListener('abort', cancel, { once: true });
+        return { promise, submitted, release, cancel };
     };
 }
 function parseBrowserWorkerResponse(output) {
@@ -243,7 +312,7 @@ function parseBrowserWorkerResponse(output) {
 export class ChatGptAdapter {
     name = 'chatgpt';
     id = 'chatgpt/browser-worker';
-    capabilities = ['model', 'chatgpt', 'browser-harness'];
+    capabilities = ['model', 'chatgpt', 'browser-workspace'];
     agentPath;
     runner;
     tabClosePolicy;
@@ -276,7 +345,7 @@ export class ChatGptAdapter {
             if (controller.signal.aborted)
                 throw new Error('browser-worker execution aborted');
             const policy = chatGptTabClosePolicy(task.chatgptTabClosePolicy, this.tabClosePolicy);
-            const run = (this.runner ?? directBrowserWorkerRunner(runtime.root))(runtime.definition, { prompt: task.input, ...(task.attachments?.length ? { files: task.attachments } : {}), tabClosePolicy: policy }, route, controller.signal);
+            const run = (this.runner ?? sessionBrowserWorkerRunner(runtime.root))(runtime.definition, { prompt: task.input, ...(task.attachments?.length ? { files: task.attachments } : {}), tabClosePolicy: policy }, route, controller.signal);
             try {
                 const output = await (run.submitted ?? run.promise);
                 const response = parseBrowserWorkerResponse(output);

package/dist/relayd.js

@@ -3,7 +3,7 @@ import { once } from 'node:events';
 import { readFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
-import { ChatGptAdapter, CodexAdapter } from './adapters.js';
+import { ChatGptAdapter, CodexAdapter, ensureChatGptBrowserWorkspace } from './adapters.js';
 import { CodexThreadContinuation, CommandContinuation, WebhookContinuation } from './continuation.js';
 import { serveDashboard } from './dashboard.js';
 import { RepositoryWorkerPool, aggregateManagedGitHubJobs } from './pool.js';
@@ -35,6 +35,15 @@ export async function overlayOperationalOverviews(overviews, storeFor) {
         return { ...item, job };
     }));
 }
+function managedOverviewKey(item) {
+    return item.job.repository + '#' + item.job.prNumber + ':' + item.job.id;
+}
+export function mergeOperationalInventory(current, discovered) {
+    const merged = new Map(current.map(item => [managedOverviewKey(item), item]));
+    for (const item of discovered)
+        merged.set(managedOverviewKey(item), item);
+    return [...merged.values()];
+}
 const PR_REFRESH_COALESCE_MS = 1000;
 export const SCHEDULE_HEARTBEAT_MS = 600_000;
 export function dueScheduledOverviews(overviews, now = new Date()) {
@@ -120,6 +129,7 @@ export async function runDaemon(argv) {
         return;
     }
     configureExecutionRouterRulesPath(argv);
+    await ensureChatGptBrowserWorkspace();
     const normalized = normalizeDaemonArguments(argv);
     if (normalized.pullRequest && normalized.jobId) {
         await startService([...argv]);
@@ -183,9 +193,8 @@ export async function runDaemon(argv) {
         try {
             githubReadPaths.workspaceScans += 1;
             const refreshed = await withGitHubRequestContext(client, 'relayd.workspace-refresh', () => aggregateManagedGitHubJobs(client, scanRepositories, trusted));
-            const scanned = new Set(scanRepositories);
-            const merged = dashboardManagedJobs([...cachedOverviews.filter(item => !scanned.has(item.job.repository)), ...refreshed]);
-            cachedOverviews = await overlayOperationalOverviews(merged, (repository, prNumber) => runtimeStore(repository, prNumber));
+            const merged = mergeOperationalInventory(cachedOverviews, refreshed);
+            cachedOverviews = dashboardManagedJobs(await overlayOperationalOverviews(merged, (repository, prNumber) => runtimeStore(repository, prNumber)));
             return cachedOverviews;
         }
         catch (error) {
@@ -382,7 +391,7 @@ export async function runDaemon(argv) {
         const runtime = summarizeRuntime(cachedOverviews.map(item => item.job));
         const workers = workerCandidates([
             { name: 'codex', id: 'codex', capabilities: ['model', 'codex'] },
-            { name: 'chatgpt', id: 'chatgpt/browser-worker', capabilities: ['model', 'chatgpt', 'browser-harness'] },
+            { name: 'chatgpt', id: 'chatgpt/browser-worker', capabilities: ['model', 'chatgpt', 'browser-workspace'] },
         ], [], usage);
         const result = await routeExecution(workers, task.workerRequirements ?? { capabilities: task.capabilities ?? [] }, {
             decisionEngine: new LayaCliDecisionEngine(),

package/dist/store.js

@@ -70,7 +70,7 @@ export async function loadManagedGitHubJobGraphql(client, repository, prNumber,
     return (await loadManagedGitHubPullRequestGraphql(client, repository, prNumber, trustedAuthors)).find(item => item.job.id === jobId) ?? null;
 }
 const COMPLETED_JOB_HISTORY_LIMIT = 10;
-function isCompletedManagedJob(item) { return ['COMPLETED', 'CANCELLED'].includes(item.job.state) || item.githubState !== 'OPEN'; }
+function isCompletedManagedJob(item) { return ['COMPLETED', 'CANCELLED'].includes(item.job.state); }
 function completedAt(item) {
     return [item.job.updatedAt, item.mergedAt, item.closedAt].filter((value) => typeof value === 'string' && value.length > 0).sort().at(-1) ?? '';
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agents-relay",
-  "version": "2.0.33",
+  "version": "2.0.34",
   "description": "Durable async agent jobs coordinated through GitHub pull requests",
   "type": "module",
   "bin": {