agents-relay 2.0.15 → 2.0.17

package/dist/cli-support.js

@@ -4,6 +4,7 @@ import { githubAuthContext } from './github-auth.js';
 import { NatsEventBus, eventFor } from './events.js';
 import { parseJobSchedule } from './scheduler.js';
 import { parseJobTagJson } from './task-tag.js';
+import { resolveEventsBusRuntime } from './events-bus-runtime.js';
 export const SERVICE_DEFAULTS = { port: 8787, watchdogMs: 300000, webhookWatchdogMs: 300000, dashboardRefreshMs: 300000, projectionFlushMs: 1000 };
 export class ServiceEventBus {
     upstream;
@@ -101,23 +102,30 @@ export async function relayTaskCommand(args, body) {
 export async function resolveEventBus(args, probe) {
     const explicit = hasArg(args, '--events');
     const requested = arg(args, '--events');
-    const natsUrl = arg(args, '--nats-url', process.env.NEO_NATS_URL || 'nats://127.0.0.1:4222');
+    const runtime = resolveEventsBusRuntime();
+    const natsUrl = arg(args, '--nats-url', runtime.natsUrl);
+    if (!explicit && hasArg(args, '--file'))
+        return { bus: undefined, transport: 'none', source: 'local', natsUrl };
     if (explicit && requested !== 'nats')
         return { bus: undefined, transport: 'none', source: 'explicit', natsUrl };
-    const bus = new NatsEventBus(natsUrl, arg(args, '--subject-prefix', 'neo.events.job'));
+    const subjectPrefix = arg(args, '--subject-prefix', runtime.subjectPrefix);
+    const bus = new NatsEventBus(natsUrl, subjectPrefix);
     if (explicit)
         return { bus, transport: 'nats', source: 'explicit', natsUrl };
     const reachable = probe ? await probe(bus) : await bus.ping().then(() => true, () => false);
-    if (!reachable) {
-        await bus.close().catch(() => undefined);
+    await bus.close().catch(() => undefined);
+    if (!reachable)
         return { bus: undefined, transport: 'none', source: 'unavailable', natsUrl };
-    }
-    return { bus, transport: 'nats', source: 'auto', natsUrl };
+    return { bus: new NatsEventBus(natsUrl, subjectPrefix), transport: 'nats', source: 'auto', natsUrl };
 }
 export function eventBusResolutionMessage(resolution) {
     if (resolution.transport === 'nats')
         return `event transport: nats (${resolution.source === 'auto' ? 'auto-detected' : 'explicit'})`;
-    return resolution.source === 'explicit' ? 'event transport: none (explicit)' : 'event transport: none (NATS unavailable)';
+    if (resolution.source === 'explicit')
+        return 'event transport: none (explicit)';
+    if (resolution.source === 'local')
+        return 'event transport: none (local mode)';
+    return 'event transport: none (NATS unavailable)';
 }
 export async function eventBus(args) {
     const resolution = await resolveEventBus(args);

package/dist/dashboard.js

@@ -1,6 +1,5 @@
 import { createServer } from 'node:http';
 import { readFile, readdir } from 'node:fs/promises';
-import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { readUsageSnapshot } from './usage.js';
@@ -8,9 +7,9 @@ import { deriveJobRuntimeStatus } from './runtime-status.js';
 import { DeliveryDeduper, parseGitHubWebhook, verifyGitHubWebhook } from './github-webhook.js';
 import { loadExecutionRouterRules, saveExecutionRouterRules } from './routing-policy.js';
 import { summarizeRuntime } from './runtime-summary.js';
+import { eventsBusHistory } from './events-bus-runtime.js';
 const GITHUB_REPOSITORY_PATTERN = /^([A-Za-z0-9](?:[A-Za-z0-9-]{0,36}[A-Za-z0-9])?)\/([A-Za-z0-9._-]{1,100})$/;
 const SSE_HEARTBEAT_MS = 15000;
-const EVENTS_HISTORY_FILE = process.env.EVENTS_BUS_DATA_DIR ? join(process.env.EVENTS_BUS_DATA_DIR, 'events.jsonl') : join(homedir(), 'Library', 'Application Support', 'EventsBus', 'events.jsonl');
 const WORKFLOW_DIR = fileURLToPath(new URL('../workflow/', import.meta.url));
 export async function dashboardWorkflowGraphs() {
     const names = (await readdir(WORKFLOW_DIR)).filter(name => name.endsWith('.mmd')).sort();
@@ -49,30 +48,12 @@ export function githubPrUrl(repository, prNumber) {
     return `https://github.com/${owner}/${repo}/pull/${prNumber}`;
 }
 async function eventHistory(jobId, taskId, limit) {
-    const boundedLimit = Math.max(1, Math.min(60, limit));
-    let content = '';
     try {
-        content = await readFile(EVENTS_HISTORY_FILE, 'utf8');
+        return await eventsBusHistory(jobId, taskId, limit);
     }
     catch {
         return [];
     }
-    const output = [];
-    const lines = content.split(/\r?\n/);
-    for (let index = lines.length - 1; index >= 0 && output.length < boundedLimit; index -= 1) {
-        const line = lines[index];
-        if (!line)
-            continue;
-        try {
-            const row = JSON.parse(line);
-            const event = row.event;
-            if (!event || event.job_id !== jobId || (taskId && event.task_id !== taskId))
-                continue;
-            output.push(event);
-        }
-        catch { /* ignore malformed historical rows */ }
-    }
-    return output;
 }
 export { dashboardHtml, dashboardVersion } from './dashboard-html.js';
 import { dashboardHtml, dashboardVersion } from './dashboard-html.js';

package/dist/events-bus-runtime.js

@@ -0,0 +1,39 @@
+import { readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+export function eventsBusConfigPath(env = process.env) {
+    if (env.NEO_EVENTS_BUS_CONFIG)
+        return env.NEO_EVENTS_BUS_CONFIG;
+    const dataDir = env.EVENTS_BUS_DATA_DIR || join(homedir(), 'Library', 'Application Support', 'EventsBus');
+    return join(dataDir, 'runtime.json');
+}
+export function resolveEventsBusRuntime(env = process.env) {
+    const configPath = eventsBusConfigPath(env);
+    let saved = {};
+    try {
+        saved = JSON.parse(readFileSync(configPath, 'utf8'));
+    }
+    catch { /* fall through to protocol defaults */ }
+    return {
+        configPath,
+        natsUrl: env.NEO_NATS_URL || String(saved.natsUrl || 'nats://127.0.0.1:4222'),
+        apiUrl: env.NEO_EVENTS_API_URL || String(saved.apiUrl || 'http://127.0.0.1:4223'),
+        subjectPrefix: env.NEO_EVENTS_SUBJECT_PREFIX || String(saved.subjectPrefix || 'neo.events.job'),
+    };
+}
+export async function eventsBusHistory(jobId, taskId, limit, env = process.env) {
+    const runtime = resolveEventsBusRuntime(env);
+    const url = new URL('/events', runtime.apiUrl);
+    url.searchParams.set('job', jobId);
+    if (taskId)
+        url.searchParams.set('task', taskId);
+    const boundedLimit = Math.max(1, Math.min(60, limit));
+    url.searchParams.set('limit', String(boundedLimit));
+    url.searchParams.set('order', 'desc');
+    const response = await fetch(url);
+    if (!response.ok)
+        throw new Error(`events-bus history unavailable: HTTP ${response.status}`);
+    const body = await response.json();
+    const rows = Array.isArray(body.events) ? body.events : [];
+    return rows.map(row => row.event).filter((event) => Boolean(event));
+}

package/package.json

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

package/skills/agents-relay/SKILL.md

@@ -41,7 +41,7 @@ A running agent MUST use the canonical Neo `events-bus` protocol and publish exa
 - `task.failed` when the task cannot complete;
 - `task.blocked` when external or human action is required.
 
-Event publishing is not an Agents Relay CLI responsibility. Sandboxed Codex and hosted ChatGPT workers use the federated `events__publish` MCP tool from `events-bus`; direct non-sandbox local workers may use the caller-provided `NEO_EVENTS_EMIT`. Agents Relay subscribes to the canonical `neo.events.job.<job_id>.>` stream and maps terminal events into durable task state.
+Event publishing is not an Agents Relay CLI responsibility. Sandboxed Codex and hosted ChatGPT workers use the federated `events__publish` MCP tool from `events-bus`; direct non-sandbox local workers may use the caller-provided `NEO_EVENTS_EMIT`. Agents Relay subscribes to the canonical `neo.events.job.<job_id>.>` stream and maps terminal events into durable task state. Relay resolves its native NATS endpoint and subject prefix from the canonical events-bus runtime configuration (with explicit Relay CLI flags remaining authoritative). The same runtime configuration supplies the events-bus HTTP API used for replay/history. Relay and its dashboard must not read the events-bus private history file or maintain a second event-history backend.
 
 The event must carry the exact durable `job_id` and `task_id`. Progress events are optional.