agents-relay 1.0.0

package/dist/planner.js

@@ -0,0 +1,172 @@
+import { spawn } from 'node:child_process';
+import { readFile } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+function record(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error('Planner result must be an object');
+    return value;
+}
+function optionalString(value, field) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value !== 'string' || value.length === 0)
+        throw new Error(`Planner ${field} must be a non-empty string`);
+    return value;
+}
+function stringArray(value, field, fallback = []) {
+    if (value === undefined)
+        return fallback;
+    if (!Array.isArray(value) || value.some(item => typeof item !== 'string' || item.length === 0))
+        throw new Error(`Planner ${field} must be an array of non-empty strings`);
+    return [...value];
+}
+function routing(value, field) {
+    if (value === undefined || value === null)
+        return undefined;
+    const route = record(value);
+    for (const key of ['provider', 'model', 'decidedBy', 'decidedAt'])
+        if (typeof route[key] !== 'string' || String(route[key]).length === 0)
+            throw new Error(`Planner ${field}.${key} is required`);
+    return { provider: route.provider, model: route.model, profile: optionalString(route.profile, `${field}.profile`), reasoning: optionalString(route.reasoning, `${field}.reasoning`), cwd: optionalString(route.cwd, `${field}.cwd`), projectId: optionalString(route.projectId, `${field}.projectId`), decidedBy: route.decidedBy, decidedAt: route.decidedAt };
+}
+export function parsePlannerResult(value) {
+    const root = record(value);
+    const status = root.objective_status;
+    if (status !== 'in_progress' && status !== 'satisfied')
+        throw new Error('Planner objective_status must be in_progress or satisfied');
+    if (typeof root.assessment !== 'string')
+        throw new Error('Planner assessment must be a string');
+    if (!Array.isArray(root.next_tasks))
+        throw new Error('Planner next_tasks must be an array');
+    const ids = new Set();
+    const next_tasks = root.next_tasks.map((item, index) => {
+        const task = record(item);
+        const id = task.id;
+        if (typeof id !== 'string' || id.length === 0)
+            throw new Error(`Planner next_tasks[${index}].id is required`);
+        if (ids.has(id))
+            throw new Error(`Planner next_tasks contains duplicate id ${id}`);
+        ids.add(id);
+        if (typeof task.input !== 'string' || task.input.length === 0)
+            throw new Error(`Planner next_tasks[${index}].input is required`);
+        const adapter = task.adapter === undefined ? 'shell' : task.adapter;
+        if (!['shell', 'codex', 'chatgpt', 'orchestrator'].includes(String(adapter)))
+            throw new Error(`Planner next_tasks[${index}].adapter is invalid`);
+        if (task.priority !== undefined && !['P0', 'P1', 'P2', 'P3'].includes(String(task.priority)))
+            throw new Error(`Planner next_tasks[${index}].priority is invalid`);
+        const maxAttempts = task.maxAttempts === undefined ? 3 : task.maxAttempts;
+        const timeoutMs = task.timeoutMs === undefined ? 300000 : task.timeoutMs;
+        if (typeof maxAttempts !== 'number' || !Number.isInteger(maxAttempts) || maxAttempts < 1)
+            throw new Error(`Planner next_tasks[${index}].maxAttempts is invalid`);
+        if (typeof timeoutMs !== 'number' || !Number.isFinite(timeoutMs) || timeoutMs < 0)
+            throw new Error(`Planner next_tasks[${index}].timeoutMs is invalid`);
+        return {
+            id, input: task.input, priority: task.priority,
+            projectName: optionalString(task.projectName, 'projectName'), agentName: optionalString(task.agentName, 'agentName'),
+            dependencies: stringArray(task.dependencies, 'dependencies'), capabilities: stringArray(task.capabilities, 'capabilities'),
+            adapter: adapter, routing: routing(task.routing, `next_tasks[${index}].routing`),
+            continuation: task.continuation, maxAttempts, timeoutMs
+        };
+    });
+    return { objective_status: status, assessment: root.assessment, next_tasks };
+}
+export function parsePlannerOutput(output) {
+    const trimmed = output.trim();
+    const candidate = trimmed.replace(/^```(?:json)?\s*/i, '').replace(/\s*```$/, '').trim();
+    return parsePlannerResult(JSON.parse(candidate));
+}
+export function plannerInput(context) {
+    return JSON.stringify({ objective: context.objective, previous_planner_task_id: context.previousPlannerTaskId, tasks: context.tasks.map(task => ({ id: task.id, kind: task.kind ?? 'work', parent_task_id: task.parentTaskId, state: task.state, input: task.input, result: task.result, planner_result: task.plannerResult, error: task.error })) });
+}
+export class CommandObjectivePlanner {
+    command;
+    constructor(command) {
+        this.command = command;
+        if (!command)
+            throw new Error('Planner command is required');
+    }
+    async plan(context, signal) {
+        return await new Promise((resolve, reject) => {
+            const child = spawn(this.command, [], { stdio: ['pipe', 'pipe', 'pipe'] });
+            let stdout = '';
+            let stderr = '';
+            child.stdout.on('data', (chunk) => { stdout += chunk.toString(); });
+            child.stderr.on('data', (chunk) => { stderr += chunk.toString(); });
+            child.on('error', reject);
+            child.on('close', code => code === 0 ? (() => { try {
+                resolve(parsePlannerOutput(stdout));
+            }
+            catch (error) {
+                reject(error);
+            } })() : reject(new Error(stderr.trim() || `Planner exited ${code}`)));
+            signal.addEventListener('abort', () => child.kill('SIGTERM'), { once: true });
+            child.stdin.end(plannerInput(context));
+        });
+    }
+}
+const DEFAULT_PLANNER_AGENT = join(dirname(fileURLToPath(import.meta.url)), '..', 'skills', 'agents-relay', 'agents', 'planner.agent.md');
+function parsePlannerAgentMessage(line) {
+    try {
+        const value = JSON.parse(line);
+        const item = value.item;
+        if (value.type === 'item.completed' && item?.type === 'agent_message' && typeof item.text === 'string')
+            return item.text.trim() || undefined;
+        const payload = value.payload;
+        if (value.type === 'event_msg' && payload?.type === 'task_complete' && typeof payload.last_agent_message === 'string')
+            return payload.last_agent_message.trim() || undefined;
+    }
+    catch { /* ignore non-JSON runtime diagnostics */ }
+    return undefined;
+}
+export class AgentObjectivePlanner {
+    command;
+    agentFile;
+    constructor(command = 'codex', agentFile = DEFAULT_PLANNER_AGENT) {
+        this.command = command;
+        this.agentFile = agentFile;
+    }
+    async plan(context, signal) {
+        const instructions = await readFile(this.agentFile, 'utf8');
+        const prompt = instructions.trim() + '\n\n## Durable planner input\n\n' + plannerInput(context);
+        return await new Promise((resolve, reject) => {
+            const child = spawn(this.command, ['exec', '--json', '--', prompt], { stdio: ['ignore', 'pipe', 'pipe'] });
+            let stdoutBuffer = '';
+            let finalMessage = '';
+            let stderrTail = '';
+            const consume = (line) => {
+                const message = parsePlannerAgentMessage(line);
+                if (message)
+                    finalMessage = message;
+            };
+            child.stdout.on('data', (chunk) => {
+                stdoutBuffer += chunk.toString();
+                const lines = stdoutBuffer.split(/\r?\n/);
+                stdoutBuffer = lines.pop() ?? '';
+                for (const line of lines)
+                    consume(line);
+            });
+            child.stderr.on('data', (chunk) => { stderrTail = (stderrTail + chunk.toString()).slice(-16384); });
+            child.on('error', reject);
+            child.on('close', code => {
+                if (stdoutBuffer)
+                    consume(stdoutBuffer);
+                if (code !== 0) {
+                    reject(new Error(stderrTail.trim() || 'Planner agent runtime exited ' + code));
+                    return;
+                }
+                if (!finalMessage) {
+                    reject(new Error('Planner agent returned no final message'));
+                    return;
+                }
+                try {
+                    resolve(parsePlannerOutput(finalMessage));
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+            signal.addEventListener('abort', () => child.kill('SIGTERM'), { once: true });
+        });
+    }
+}

package/dist/pool.js

@@ -0,0 +1,98 @@
+import { GitHubStore, listManagedGitHubJobs } from './store.js';
+import { eventFor } from './events.js';
+const RANK = { P0: 0, P1: 1, P2: 2, P3: 3 };
+export function compareJobPriority(a, b) { return RANK[a.priority ?? 'P2'] - RANK[b.priority ?? 'P2'] || a.createdAt.localeCompare(b.createdAt) || a.id.localeCompare(b.id); }
+export function runnableManagedJobs(items) { return items.filter(item => item.githubState === 'OPEN' && !item.draft && !['COMPLETED', 'CANCELLED'].includes(item.job.state)).map(item => item.job).sort(compareJobPriority); }
+export function needsLifecycleReconciliation(job, now = Date.now()) {
+    if (job.tasks.some(task => ['READY', 'QUEUED', 'WAITING'].includes(task.state)))
+        return true;
+    return job.tasks.some(task => task.state === 'RUNNING' && task.leaseExpiresAt !== null && new Date(task.leaseExpiresAt).getTime() <= now);
+}
+export function terminalManagedJobs(items) { return items.filter(item => item.githubState !== 'OPEN' && ((item.githubState === 'MERGED' && item.job.state !== 'COMPLETED') || (item.githubState === 'CLOSED' && item.job.state !== 'CANCELLED'))).map(item => item.job).sort(compareJobPriority); }
+export async function aggregateManagedGitHubJobs(client, repositories, trustedAuthors) {
+    const uniqueRepositories = [...new Set(repositories)];
+    const groups = await Promise.all(uniqueRepositories.map(repository => listManagedGitHubJobs(client, repository, trustedAuthors)));
+    return groups.flat().sort((a, b) => b.job.updatedAt.localeCompare(a.job.updatedAt) || b.job.prNumber - a.job.prNumber);
+}
+export class RepositoryWorkerPool {
+    client;
+    trustedAuthors;
+    concurrency;
+    makeReconciler;
+    running = false;
+    pending = false;
+    constructor(client, repository, trustedAuthors, concurrency, makeReconciler) {
+        this.client = client;
+        this.trustedAuthors = trustedAuthors;
+        this.concurrency = concurrency;
+        this.makeReconciler = makeReconciler;
+        this.repositories = [...new Set(typeof repository === 'string' ? [repository] : repository)];
+    }
+    repositories;
+    async reconcileDiscovered(discovered) {
+        // Terminal PRs must be reconciled before OPEN-job scheduling. Otherwise the
+        // OPEN-only runnable filter can strand durable jobs after GitHub merges/closes them.
+        for (const job of terminalManagedJobs(discovered)) {
+            const store = new GitHubStore(this.client, job.repository, job.prNumber, this.trustedAuthors);
+            await this.makeReconciler(store, 0).reconcile(job.id);
+        }
+        const jobs = runnableManagedJobs(discovered);
+        let capacity = Math.max(1, this.concurrency);
+        for (const job of jobs) {
+            if (capacity <= 0)
+                break;
+            const store = new GitHubStore(this.client, job.repository, job.prNumber, this.trustedAuthors);
+            const ready = job.tasks.filter(task => ['READY', 'QUEUED', 'WAITING'].includes(task.state)).length;
+            const expiredRunning = job.tasks.some(task => task.state === 'RUNNING' && task.leaseExpiresAt !== null && new Date(task.leaseExpiresAt).getTime() <= Date.now());
+            if (!needsLifecycleReconciliation(job) && job.tasks.length > 0)
+                continue;
+            const allowance = Math.max(1, Math.min(capacity, ready || (expiredRunning ? 1 : 0) || 1));
+            await this.makeReconciler(store, allowance).reconcile(job.id);
+            capacity -= allowance;
+        }
+    }
+    async reconcileKnown(discovered) { await this.reconcileDiscovered(discovered); }
+    async reconcile() {
+        if (this.running) {
+            this.pending = true;
+            return;
+        }
+        this.running = true;
+        try {
+            do {
+                this.pending = false;
+                await this.reconcileDiscovered(await aggregateManagedGitHubJobs(this.client, this.repositories, this.trustedAuthors));
+            } while (this.pending);
+        }
+        finally {
+            this.running = false;
+        }
+    }
+    async reconcileTarget(repository, prNumber, jobId) {
+        if (!this.repositories.includes(repository))
+            return;
+        const store = new GitHubStore(this.client, repository, prNumber, this.trustedAuthors);
+        await this.makeReconciler(store, Math.max(1, this.concurrency)).reconcile(jobId);
+    }
+    async watch(bus) {
+        return bus.subscribeAll(async (event) => {
+            if (event.type === 'job.wake' || event.type === 'github.webhook') {
+                const repository = typeof event.data?.repository === 'string' ? event.data.repository : '';
+                const prNumber = Number(event.data?.prNumber);
+                if (repository && Number.isInteger(prNumber) && prNumber > 0) {
+                    await this.reconcileTarget(repository, prNumber, event.job_id);
+                    return;
+                }
+            }
+            if (event.type === 'job.wake' || event.type === 'github.webhook')
+                await this.reconcile();
+        });
+    }
+    async webhookWake(bus, job, deliveryId, event, action) {
+        if (bus) {
+            await bus.publish(eventFor(job.id, 'github', null, 'github.webhook', 'queued', `GitHub webhook ${event}${action ? ':' + action : ''}`, 'orchestrator', { deliveryId, event, action, repository: job.repository, prNumber: job.prNumber }));
+            return;
+        }
+        await this.reconcileTarget(job.repository, job.prNumber, job.id);
+    }
+}