agents-relay 1.0.0

package/src/relayd.ts

@@ -0,0 +1,137 @@
+#!/usr/bin/env node
+import { once } from 'node:events';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { ChatGptAdapter, CodexAdapter, ShellAdapter } from './adapters.js';
+import { CodexThreadContinuation, CommandContinuation, WebhookContinuation } from './continuation.js';
+import { serveDashboard } from './dashboard.js';
+import { NatsEventBus } from './events.js';
+import { RepositoryWorkerPool, aggregateManagedGitHubJobs } from './pool.js';
+import { Reconciler } from './reconciler.js';
+import { dashboardManagedJobs, GitHubStore, InMemoryStore, ManagedJobOverview, loadManagedGitHubPullRequestGraphql } from './store.js';
+import { githubAuthContext } from './github-auth.js';
+import { isEntrypoint, startService, SERVICE_DEFAULTS } from './cli.js';
+import { codexAndZaiUsageRegistry } from './usage.js';
+import { defaultWorkspaceRoot, discoverWorkspaceRepositories } from './workspace.js';
+import { GitHubWebhookWake } from './github-webhook.js';
+
+export interface DaemonArguments { repository: string | null; workspaceRoot: string | null; pullRequest: number | null; jobId: string | null; serviceArguments: string[]; }
+export const daemonHelp = `Agents Relay daemon runs the dashboard and worker pool.
+
+Usage:
+  npx agents-relayd [options]
+
+Options:
+  --repo OWNER/REPO       Watch one repository
+  --workspace PATH        Discover repositories below PATH (default: ~/Workspace)
+  --port PORT             Dashboard port (default: 8787)
+  --concurrency N         Maximum concurrent workers (default: 4)
+  --interval MS           Recovery interval
+  --events nats            Enable event wakeups
+
+Legacy single-job mode also accepts --repo OWNER/REPO --pr NUMBER --id JOB_ID.
+
+Examples:
+  npx agents-relayd --repo OWNER/REPO
+  npx agents-relayd --workspace ~/Workspace`;
+function value(args: readonly string[], name: string, fallback = ''): string { const index = args.indexOf(name); return index >= 0 ? args[index + 1] ?? fallback : fallback; }
+export function normalizeDaemonArguments(argv: readonly string[]): DaemonArguments {
+  const repository = value(argv, '--repo') || null;
+  const workspaceRoot = value(argv, '--workspace', defaultWorkspaceRoot()) || null;
+  const prValue = value(argv, '--pr'); const id = value(argv, '--id');
+  if ((prValue && !id) || (!prValue && id)) throw new Error('--pr and --id must be supplied together for legacy single-job mode');
+  if ((prValue || id) && !repository) throw new Error('--repo is required for legacy single-job mode');
+  if (repository && argv.includes('--workspace')) throw new Error('--repo and --workspace are mutually exclusive');
+  const pullRequest = prValue ? Number(prValue) : null; if (pullRequest !== null && (!Number.isInteger(pullRequest) || pullRequest <= 0)) throw new Error('--pr must be positive');
+  return { repository, workspaceRoot: repository ? null : workspaceRoot, pullRequest, jobId: id || null, serviceArguments: [...argv] };
+}
+export async function runDaemon(argv: readonly string[]): Promise<void> {
+  if (argv.includes('--help') || argv.includes('-h')) { console.log(daemonHelp); return; }
+  const normalized = normalizeDaemonArguments(argv);
+  if (normalized.pullRequest && normalized.jobId) { await startService([...argv]); return; }
+  const auth = await githubAuthContext(argv); const client = auth.client;
+  const trusted = auth.trustedAuthors;
+  const concurrency = Number(value(argv,'--concurrency','4'));
+  const bus = value(argv,'--events') === 'nats' ? new NatsEventBus(value(argv,'--nats-url','nats://127.0.0.1:4222'), value(argv,'--subject-prefix','agents-relay.events.job')) : undefined;
+  const makeReconciler = (store: GitHubStore, maxConcurrent: number) => new Reconciler(store,{ owner:`relayd-${process.pid}`, maxConcurrent, leaseMs:Number(value(argv,'--lease-ms','300000')), adapters:[new ShellAdapter(),new CodexAdapter(value(argv,'--codex','codex')),new ChatGptAdapter({endpoint:value(argv,'--macbridge-url')||undefined,tokenFile:value(argv,'--macbridge-token-file')||undefined})], continuations:[new CodexThreadContinuation(value(argv,'--codex','codex')),new CommandContinuation(),new WebhookContinuation()], eventBus:bus });
+  const repositories = normalized.repository
+    ? [normalized.repository]
+    : (await discoverWorkspaceRepositories(normalized.workspaceRoot ?? defaultWorkspaceRoot())).map(item => item.repository);
+  if (repositories.length === 0) throw new Error(`No Git repositories with GitHub origins found under ${normalized.workspaceRoot ?? defaultWorkspaceRoot()}`);
+  const pool = new RepositoryWorkerPool(client, repositories, trusted, concurrency, makeReconciler);
+  const cacheDirectory = join(homedir(), '.agents-relay');
+  const cacheFile = join(cacheDirectory, 'dashboard-jobs.json');
+  let cachedOverviews: ManagedJobOverview[] = [];
+  try {
+    const parsed = JSON.parse(await readFile(cacheFile, 'utf8')) as ManagedJobOverview[];
+    if (Array.isArray(parsed)) cachedOverviews = parsed;
+  } catch { /* first run or invalid cache */ }
+  const refreshAll = async (): Promise<ManagedJobOverview[]> => {
+    if (client.rateLimitStatus().limited) return cachedOverviews;
+    try {
+      cachedOverviews = dashboardManagedJobs(await aggregateManagedGitHubJobs(client, repositories, trusted));
+      try { await mkdir(cacheDirectory, { recursive: true }); await writeFile(cacheFile, JSON.stringify(cachedOverviews), 'utf8'); } catch { /* cache is best effort */ }
+      return cachedOverviews;
+    } catch (error) {
+      process.stderr.write(`warning: workspace job refresh unavailable: ${error instanceof Error ? error.message : String(error)}\n`);
+      return cachedOverviews;
+    }
+  };
+  const overviews = async (forceRefresh = false): Promise<ManagedJobOverview[]> => forceRefresh ? refreshAll() : cachedOverviews;
+  const persistCache = async (): Promise<void> => {
+    try { await mkdir(cacheDirectory, { recursive: true }); await writeFile(cacheFile, JSON.stringify(cachedOverviews), 'utf8'); } catch { /* cache is best effort */ }
+  };
+  const refreshPullRequest = async (repository: string, prNumber: number): Promise<ManagedJobOverview[]> => {
+    const refreshed = await loadManagedGitHubPullRequestGraphql(client, repository, prNumber, trusted);
+    cachedOverviews = cachedOverviews.filter(item => item.job.repository !== repository || item.job.prNumber !== prNumber);
+    cachedOverviews.push(...refreshed);
+    cachedOverviews = dashboardManagedJobs(cachedOverviews);
+    await persistCache();
+    return refreshed;
+  };
+  const initial = await refreshAll(); const fallback = initial[0]?.job;
+  const dashboardStore = fallback ? new GitHubStore(client, fallback.repository, fallback.prNumber, trusted) : new InMemoryStore();
+  const secretFile = value(argv,'--github-webhook-secret-file');
+  const secret = value(argv,'--github-webhook-secret') || process.env.AGENTS_RELAY_GITHUB_WEBHOOK_SECRET || (secretFile ? (await readFile(secretFile,'utf8')).trim() : '');
+  const webhook = secret ? {
+    secret,
+    repositories: new Set(repositories),
+    wake: async (event: GitHubWebhookWake): Promise<void> => {
+      if (!event.repository || !event.pullRequest) return;
+      try {
+        const refreshed = await refreshPullRequest(event.repository, event.pullRequest);
+        for (const item of refreshed) await pool.webhookWake(bus, item.job, event.deliveryId, event.event, event.action);
+      } catch (error) {
+        process.stderr.write(`warning: webhook PR refresh unavailable: ${error instanceof Error ? error.message : String(error)}\n`);
+      }
+    }
+  } : undefined;
+  const exactJob = async (jobId: string) => {
+    const cached = cachedOverviews.find(item => item.job.id === jobId);
+    if (!cached) return null;
+    try {
+      const refreshed = (await refreshPullRequest(cached.job.repository, cached.job.prNumber)).find(item => item.job.id === jobId);
+      if (!refreshed) return null;
+      return { ...refreshed.job, githubState: refreshed.githubState, mergedAt: refreshed.mergedAt, closedAt: refreshed.closedAt, draft: refreshed.draft };
+    } catch (error) {
+      process.stderr.write(`warning: selected job refresh unavailable: ${error instanceof Error ? error.message : String(error)}\n`);
+      return null;
+    }
+  };
+  const usageRegistry = codexAndZaiUsageRegistry();
+  const server = serveDashboard(dashboardStore,Number(value(argv,'--port',String(SERVICE_DEFAULTS.port))),bus,Number(value(argv,'--refresh-ms',String(SERVICE_DEFAULTS.dashboardRefreshMs))),fallback?.id,usageRegistry,overviews,webhook,()=>client.rateLimitStatus(),exactJob);
+  await once(server,'listening');
+  const reconcileSafely = async (): Promise<void> => {
+    if (client.rateLimitStatus().limited) return;
+    try { await pool.reconcile(); }
+    catch (error) { process.stderr.write(`warning: workspace reconcile unavailable: ${error instanceof Error ? error.message : String(error)}\n`); }
+  };
+  const watchdogDefault = webhook ? SERVICE_DEFAULTS.webhookWatchdogMs : SERVICE_DEFAULTS.watchdogMs;
+  const interval=setInterval(()=>void reconcileSafely(),Number(value(argv,'--interval',String(watchdogDefault)))); interval.unref();
+  const stopWatch = bus ? await pool.watch(bus) : async()=>{};
+  const stop=()=>{clearInterval(interval);void stopWatch().finally(()=>server.close(()=>process.exit(0)));}; process.once('SIGINT',stop);process.once('SIGTERM',stop);
+  console.log('Dashboard listening; repository worker pool active');
+  if (!client.rateLimitStatus().limited) void pool.reconcileKnown(initial).catch(error=>process.stderr.write(`warning: startup reconciliation unavailable: ${error instanceof Error ? error.message : String(error)}\n`));
+}
+if (isEntrypoint(import.meta.url)) runDaemon(process.argv.slice(2)).catch(error=>{console.error(error instanceof Error?error.message:String(error));process.exitCode=1;});

package/src/scheduler.ts

@@ -0,0 +1,27 @@
+import { Job, Task, TaskState, assertJobTransition, assertTaskTransition } from './types.js';
+export function dependencyReady(task: Task, tasks: Map<string, Task>): boolean { return task.dependencies.every(id => tasks.get(id)?.state === 'SUCCEEDED'); }
+export function detectCycles(tasks: Task[]): void { const map = new Map(tasks.map(t => [t.id, t])); const visiting = new Set<string>(); const done = new Set<string>(); const visit = (id: string): void => { if (visiting.has(id)) throw new Error(`Dependency cycle at ${id}`); if (done.has(id)) return; visiting.add(id); for (const dep of map.get(id)?.dependencies ?? []) visit(dep); visiting.delete(id); done.add(id); }; for (const task of tasks) visit(task.id); }
+export function completionGateSatisfied(job: Job): boolean {
+  if (job.executionMode !== 'autonomous') return true;
+  const planners = job.tasks.filter(task => task.kind === 'planner');
+  return planners.some(task => task.state === 'SUCCEEDED' && task.plannerResult?.objective_status === 'satisfied') && job.tasks.every(task => task.state === 'SUCCEEDED');
+}
+export function schedule(job: Job): Job {
+  detectCycles(job.tasks);
+  if (job.tasks.length === 0) {
+    if (job.executionMode === 'autonomous' && job.state !== 'WAITING') { assertJobTransition(job.state, 'WAITING'); job.state = 'WAITING'; job.updatedAt = new Date().toISOString(); }
+    return job;
+  }
+  const map = new Map(job.tasks.map(t => [t.id, t]));
+  for (const task of job.tasks) { if (['QUEUED', 'WAITING'].includes(task.state) && dependencyReady(task, map)) transitionTask(task, 'READY'); }
+  const active = job.tasks.some(t => ['READY', 'RUNNING'].includes(t.state)); const blocked = job.tasks.some(t => t.state === 'BLOCKED'); const waiting = job.tasks.some(t => ['QUEUED', 'WAITING'].includes(t.state)); const failed = job.tasks.some(t => t.state === 'FAILED'); const cancelled = job.tasks.every(t => t.state === 'CANCELLED');
+  const next = failed ? 'FAILED' : active ? 'RUNNING' : blocked ? 'BLOCKED' : waiting ? 'WAITING' : cancelled ? 'CANCELLED' : completionGateSatisfied(job) ? 'COMPLETED' : 'WAITING';
+  if (job.state !== next) { assertJobTransition(job.state, next); job.state = next; job.updatedAt = new Date().toISOString(); }
+  return job;
+}
+export function extendRetryBudget(task: Pick<Task, 'attempt' | 'maxAttempts'>, windowSize = 3): number {
+  if (!Number.isInteger(windowSize) || windowSize < 1) throw new Error('Retry window size must be a positive integer');
+  const usedOrBudgeted = Math.max(task.maxAttempts, task.attempt);
+  return Math.max(windowSize, (Math.floor(usedOrBudgeted / windowSize) + 1) * windowSize);
+}
+export function transitionTask(task: Task, state: TaskState): void { assertTaskTransition(task.state, state); task.state = state; if (['READY', 'RUNNING', 'SUCCEEDED'].includes(state)) task.error = null; task.updatedAt = new Date().toISOString(); }