agents-relay 1.0.177 → 2.0.1

package/dist/pool.js

@@ -1,5 +1,7 @@
 import { GitHubStore, listManagedGitHubJobs, withGitHubRequestContext } from './store.js';
 import { eventFor } from './events.js';
+import { runScheduledBucket } from './scheduled-jobs.js';
+import { scheduleBucket } from './scheduler.js';
 import { ReconcileCoordinator } from './reconcile-coordinator.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); }
@@ -25,27 +27,31 @@ export class RepositoryWorkerPool {
     makeReconciler;
     isRateLimited;
     refreshWebhookSnapshot;
+    makeStore;
     running = false;
     pending = false;
     reconcileLocks = new Map();
     coordinator;
     githubSignalCoordinator;
+    scheduleSignalCoordinator;
     watchedBus;
     jobTargets = new Map();
     targetSeeds = new Map();
-    constructor(client, repository, trustedAuthors, concurrency, makeReconciler, isRateLimited = () => false, refreshWebhookSnapshot) {
+    constructor(client, repository, trustedAuthors, concurrency, makeReconciler, isRateLimited = () => false, refreshWebhookSnapshot, makeStore = (repository, prNumber, seed) => new GitHubStore(this.client, repository, prNumber, this.trustedAuthors, seed)) {
         this.client = client;
         this.trustedAuthors = trustedAuthors;
         this.concurrency = concurrency;
         this.makeReconciler = makeReconciler;
         this.isRateLimited = isRateLimited;
         this.refreshWebhookSnapshot = refreshWebhookSnapshot;
+        this.makeStore = makeStore;
         this.repositories = [...new Set(typeof repository === 'string' ? [repository] : repository)];
         const reportCoordinatorError = (error, signal) => {
             process.stderr.write(`warning: reconcile coordinator failed for ${signal.jobId} (${signal.reason}): ${error instanceof Error ? error.message : String(error)}\n`);
         };
         this.coordinator = new ReconcileCoordinator((jobId, signals) => this.consumeSignals(jobId, signals), reportCoordinatorError);
         this.githubSignalCoordinator = new ReconcileCoordinator((_key, signals) => this.consumeGitHubSignals(signals), reportCoordinatorError);
+        this.scheduleSignalCoordinator = new ReconcileCoordinator((jobId, signals) => this.consumeScheduleSignals(jobId, signals), reportCoordinatorError);
     }
     repositories;
     async reconcileExclusive(jobId, work) {
@@ -71,6 +77,21 @@ export class RepositoryWorkerPool {
         }
         return `event.${event.type}`;
     }
+    async consumeScheduleSignals(jobId, signals) {
+        if (this.isRateLimited() || signals.length === 0)
+            return;
+        const signal = [...signals].reverse().find(item => item.event?.type === 'schedule.tick');
+        const event = signal?.event;
+        const repository = signal?.repository ?? (typeof event?.data?.repository === 'string' ? event.data.repository : undefined);
+        const prValue = signal?.prNumber ?? Number(event?.data?.prNumber);
+        const prNumber = Number.isInteger(prValue) && Number(prValue) > 0 ? Number(prValue) : undefined;
+        const bucket = typeof event?.data?.bucket === 'string' ? event.data.bucket : undefined;
+        const tickAt = typeof event?.data?.tickAt === 'string' ? new Date(event.data.tickAt) : new Date(event?.timestamp ?? Date.now());
+        if (!repository || !prNumber || !bucket || !this.repositories.includes(repository) || Number.isNaN(tickAt.getTime()))
+            return;
+        this.jobTargets.set(jobId, { repository, prNumber });
+        await runScheduledBucket(this.client, repository, this.trustedAuthors, { prNumber, jobId, bucket }, { reconcile: async () => { await this.reconcileTarget(repository, prNumber, jobId, 'schedule.tick'); }, idle: async () => { } }, tickAt, () => this.makeStore(repository, prNumber));
+    }
     async consumeGitHubSignals(signals) {
         if (this.isRateLimited() || signals.length === 0)
             return;
@@ -111,8 +132,6 @@ export class RepositoryWorkerPool {
         }
     }
     async consumeSignals(jobId, signals) {
-        if (this.isRateLimited())
-            return;
         for (const signal of signals) {
             if (signal.repository && signal.prNumber && this.repositories.includes(signal.repository)) {
                 this.jobTargets.set(jobId, { repository: signal.repository, prNumber: signal.prNumber });
@@ -128,7 +147,7 @@ export class RepositoryWorkerPool {
         const seed = mayConsumeSeed ? this.targetSeeds.get(seedKey) ?? null : null;
         if (mayConsumeSeed)
             this.targetSeeds.delete(seedKey);
-        const store = new GitHubStore(this.client, target.repository, target.prNumber, this.trustedAuthors, seed);
+        const store = this.makeStore(target.repository, target.prNumber, seed);
         const reconciler = this.makeReconciler(store, Math.max(1, this.concurrency));
         let shouldReconcile = false;
         const reasons = [];
@@ -155,7 +174,8 @@ export class RepositoryWorkerPool {
         // OPEN-only runnable filter can strand durable jobs after GitHub merges/closes them.
         for (const job of terminalManagedJobs(discovered)) {
             await this.reconcileExclusive(job.id, async () => {
-                const store = new GitHubStore(this.client, job.repository, job.prNumber, this.trustedAuthors);
+                const store = this.makeStore(job.repository, job.prNumber);
+                await store.hydrate?.(job);
                 await withGitHubRequestContext(this.client, 'pool.terminal-reconcile', () => this.makeReconciler(store, 0).reconcile(job.id));
             });
         }
@@ -164,7 +184,8 @@ export class RepositoryWorkerPool {
         for (const job of jobs) {
             if (capacity <= 0)
                 break;
-            const store = new GitHubStore(this.client, job.repository, job.prNumber, this.trustedAuthors);
+            const store = this.makeStore(job.repository, job.prNumber);
+            await store.hydrate?.(job);
             const ready = job.tasks.filter(task => (task.state === 'QUEUED' && task.executionId === null) || (task.state === 'DRAFT' && task.dependencies.length > 0)).length;
             const expiredRunning = job.tasks.some(task => ['RUNNING', 'QUEUED'].includes(task.state) && task.executionId !== null && task.leaseExpiresAt !== null && new Date(task.leaseExpiresAt).getTime() <= Date.now());
             if (!needsLifecycleReconciliation(job))
@@ -177,16 +198,24 @@ export class RepositoryWorkerPool {
         }
     }
     async reconcileKnown(discovered) {
-        for (const item of discovered.filter(value => value.githubState === 'OPEN' && value.job.state === 'ACTIVE')) {
+        const recovered = [];
+        for (const item of discovered) {
+            if (item.githubState !== 'OPEN' || item.job.state !== 'ACTIVE') {
+                recovered.push(item);
+                continue;
+            }
             this.jobTargets.set(item.job.id, { repository: item.job.repository, prNumber: item.job.prNumber });
-            const store = new GitHubStore(this.client, item.job.repository, item.job.prNumber, this.trustedAuthors);
+            const store = this.makeStore(item.job.repository, item.job.prNumber);
+            await store.hydrate?.(item.job);
             const reconciler = this.makeReconciler(store, 0);
+            let recoveredJob = item.job;
             if (typeof reconciler.recoverStartupOrphans === 'function')
                 await this.reconcileExclusive(item.job.id, async () => {
-                    await withGitHubRequestContext(this.client, 'pool.startup-orphan-recovery', () => reconciler.recoverStartupOrphans(item.job.id));
+                    recoveredJob = await withGitHubRequestContext(this.client, 'pool.startup-orphan-recovery', () => reconciler.recoverStartupOrphans(item.job.id));
                 });
+            recovered.push({ ...item, job: recoveredJob });
         }
-        await this.reconcileDiscovered(discovered);
+        await this.reconcileDiscovered(recovered);
     }
     async reconcile() {
         if (this.isRateLimited())
@@ -225,6 +254,10 @@ export class RepositoryWorkerPool {
             const prNumber = Number.isInteger(prValue) && prValue > 0 ? prValue : undefined;
             const routedWebhook = event.type === 'github.webhook' && event.data?.coordinatorRouted === true;
             const ingressWebhook = event.type === 'github.webhook' && event.data?.coordinatorIngress === true && !routedWebhook;
+            if (event.type === 'schedule.tick' && repository && prNumber) {
+                await this.scheduleSignalCoordinator.acceptTransport({ jobId: event.job_id, reason: this.signalReason(event), event, repository, prNumber });
+                return;
+            }
             if (ingressWebhook && repository && prNumber) {
                 await this.githubSignalCoordinator.acceptTransport({
                     jobId: `${repository}#${prNumber}`,
@@ -257,6 +290,17 @@ export class RepositoryWorkerPool {
                 this.watchedBus = undefined;
         };
     }
+    async scheduleTickSignal(bus, job, now = new Date()) {
+        if (!job.schedule)
+            return;
+        const event = eventFor(job.id, 'scheduler', null, 'schedule.tick', 'queued', `Schedule tick for ${job.schedule.nextRunAt}`, 'orchestrator', { repository: job.repository, prNumber: job.prNumber, bucket: scheduleBucket(new Date(job.schedule.nextRunAt)), tickAt: now.toISOString() }, { agent: 'relay', component: 'scheduler-timer' });
+        // Use the same coordinator-owned schedule path whether transport is available or not.
+        if (bus) {
+            await bus.publish(event);
+            return;
+        }
+        await this.scheduleSignalCoordinator.accept({ jobId: job.id, reason: this.signalReason(event), event, repository: job.repository, prNumber: job.prNumber });
+    }
     async webhookSignal(bus, wake) {
         if (!wake.repository || !wake.pullRequest)
             return;

package/dist/projected-store.js

@@ -0,0 +1,314 @@
+import { registerBlockerDependency, resolveBlockerDependencies } from './blockers.js';
+import { sameTaskDefinition } from './store-task-definition.js';
+function taskKey(task) { return `task:${task.jobId ?? ''}:${task.id}`; }
+function planKey(plan) { return `plan:${plan.jobId}:${plan.id}`; }
+function retryHeader(error, name) {
+    if (!error || typeof error !== 'object')
+        return null;
+    const value = error;
+    if (name === 'retry-after' && value.retryAfter !== undefined)
+        return String(value.retryAfter);
+    const headers = value.response?.headers ?? value.headers;
+    if (!headers)
+        return null;
+    if (typeof headers.get === 'function')
+        return headers.get(name);
+    const record = headers;
+    const hit = Object.entries(record).find(([key]) => key.toLowerCase() === name);
+    return hit && hit[1] !== undefined ? String(hit[1]) : null;
+}
+export function githubProjectionRetryAt(error, attempt, now = new Date()) {
+    const retryAfter = Number(retryHeader(error, 'retry-after'));
+    if (Number.isFinite(retryAfter) && retryAfter > 0)
+        return new Date(now.getTime() + retryAfter * 1000);
+    const reset = Number(retryHeader(error, 'x-ratelimit-reset'));
+    if (Number.isFinite(reset) && reset > now.getTime() / 1000)
+        return new Date(reset * 1000 + 1000);
+    const backoffMs = Math.min(300_000, 1_000 * (2 ** Math.min(8, Math.max(0, attempt))));
+    return new Date(now.getTime() + backoffMs);
+}
+export function isTerminalProjectionFailure(item, error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return (item.operation === 'append_task' || item.operation === 'append_plan')
+        && /already exists with a different definition$/.test(message);
+}
+export class GitHubProjectionWriter {
+    relay;
+    github;
+    constructor(relay, github) {
+        this.relay = relay;
+        this.github = github;
+    }
+    async flushOnce(limit = 50, now = new Date()) {
+        const items = await this.relay.claimDueProjections(limit, now);
+        let projected = 0;
+        let deferred = 0;
+        for (const item of items) {
+            try {
+                await this.apply(item);
+                await this.relay.completeProjection(item.id);
+                projected += 1;
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                if (isTerminalProjectionFailure(item, error))
+                    await this.relay.deadLetterProjection(item.id, message);
+                else {
+                    await this.relay.retryProjection(item.id, message, githubProjectionRetryAt(error, item.attempts, now));
+                    deferred += 1;
+                }
+            }
+        }
+        return { projected, deferred };
+    }
+    async apply(item) {
+        const payload = item.payload;
+        switch (payload.operation) {
+            case 'save_job':
+                await this.github.saveJob(payload.value);
+                return;
+            case 'append_plan':
+                await this.github.appendPlan(payload.value);
+                return;
+            case 'save_plan':
+                await this.github.savePlan(payload.value);
+                return;
+            case 'append_task':
+                await this.github.appendTask(payload.value);
+                return;
+            case 'save_task':
+                await this.github.saveTask(payload.value);
+                return;
+            case 'save_agent':
+                await this.github.saveAgent(payload.value);
+                return;
+            case 'update_pr_body':
+                if (!this.github.updatePullRequestBody)
+                    throw new Error('GitHub projection target cannot update PR body');
+                await this.github.updatePullRequestBody(payload.value);
+                return;
+            case 'merge_pull_request':
+                if (!this.github.mergePullRequest)
+                    throw new Error('GitHub projection target cannot merge pull request');
+                await this.github.mergePullRequest(payload.expectedHeadSha);
+                return;
+            case 'close_pull_request':
+                if (!this.github.closePullRequest)
+                    throw new Error('GitHub projection target cannot close pull request');
+                await this.github.closePullRequest();
+                return;
+        }
+    }
+}
+export class ProjectedDurableStore {
+    relay;
+    github;
+    relatedStore;
+    projection;
+    seededFacts;
+    constructor(relay, github, seed = null, relatedStore) {
+        this.relay = relay;
+        this.github = github;
+        this.relatedStore = relatedStore;
+        this.projection = new GitHubProjectionWriter(relay, github);
+        this.seededFacts = pullRequestFactsFromSeed(seed);
+        if (this.seededFacts)
+            void this.relay.savePullRequestFacts(this.seededFacts).catch(() => { });
+    }
+    /** Ingest trusted GitHub records without echoing them back through the projection outbox. */
+    async hydrate(job) {
+        await this.relay.ingestJobSnapshot(structuredClone(job));
+    }
+    async load(jobId) {
+        const local = await this.relay.loadJob(jobId);
+        if (local)
+            return structuredClone(local);
+        const remote = await this.github.load(jobId);
+        await this.relay.saveJob(remote);
+        return structuredClone(remote);
+    }
+    async saveJob(job) {
+        const value = structuredClone(job);
+        await this.relay.saveJobWithProjection(value, {
+            idempotencyKey: `save_job:${job.id}`,
+            coalesceKey: `job:${job.id}`,
+            operation: 'save_job',
+            payload: { operation: 'save_job', value },
+            priority: ['COMPLETED', 'CANCELLED'].includes(job.state) ? 100 : 20,
+        });
+    }
+    async appendPlan(plan) {
+        const job = await this.load(plan.jobId);
+        const existing = (job.plans ?? []).find(item => item.id === plan.id);
+        if (existing) {
+            if (JSON.stringify({ ...existing, planUrl: undefined }) === JSON.stringify({ ...plan, planUrl: undefined }))
+                return;
+            throw new Error(`Plan ${plan.id} already exists with a different definition`);
+        }
+        job.plans = [...(job.plans ?? []), structuredClone(plan)].sort((a, b) => a.round - b.round);
+        await this.relay.saveJobWithProjection(job, {
+            idempotencyKey: `append_plan:${plan.jobId}:${plan.id}`,
+            operation: 'append_plan',
+            payload: { operation: 'append_plan', value: plan },
+            priority: 30,
+        });
+    }
+    async savePlan(plan) {
+        const job = await this.load(plan.jobId);
+        const plans = [...(job.plans ?? [])];
+        const index = plans.findIndex(item => item.id === plan.id);
+        if (index >= 0)
+            plans[index] = structuredClone(plan);
+        else
+            plans.push(structuredClone(plan));
+        job.plans = plans.sort((a, b) => a.round - b.round);
+        await this.relay.saveJobWithProjection(job, {
+            idempotencyKey: `save_plan:${plan.jobId}:${plan.id}`,
+            coalesceKey: planKey(plan),
+            operation: 'save_plan',
+            payload: { operation: 'save_plan', value: plan },
+            priority: 30,
+        });
+    }
+    async appendTask(task) {
+        if (!task.jobId)
+            throw new Error('Projected task requires jobId');
+        const job = await this.load(task.jobId);
+        const existing = job.tasks.find(item => item.id === task.id);
+        if (existing) {
+            if (sameTaskDefinition(existing, task))
+                return;
+            throw new Error(`Task ${task.id} already exists with a different definition`);
+        }
+        job.tasks = [...job.tasks, structuredClone(task)];
+        await this.relay.saveJobWithProjection(job, {
+            idempotencyKey: `append_task:${task.jobId}:${task.id}`,
+            operation: 'append_task',
+            payload: { operation: 'append_task', value: task },
+            priority: 40,
+        });
+    }
+    async saveTask(task) {
+        if (!task.jobId)
+            throw new Error('Projected task requires jobId');
+        const job = await this.load(task.jobId);
+        const tasks = [...job.tasks];
+        const index = tasks.findIndex(item => item.id === task.id);
+        if (index >= 0)
+            tasks[index] = structuredClone(task);
+        else
+            tasks.push(structuredClone(task));
+        job.tasks = tasks;
+        const value = structuredClone(task);
+        const terminal = ['SUCCEEDED', 'FAILED', 'BLOCKED', 'UNBLOCKED', 'CANCELLED'].includes(task.state);
+        await this.relay.saveJobWithProjection(job, {
+            idempotencyKey: `save_task:${task.jobId}:${task.id}`,
+            coalesceKey: taskKey(task),
+            operation: 'save_task',
+            payload: { operation: 'save_task', value },
+            priority: terminal ? 100 : 50,
+        });
+    }
+    async listAgents() {
+        const local = await this.relay.loadAgents();
+        if (local !== null)
+            return structuredClone(local);
+        const remote = await this.github.listAgents();
+        await this.relay.saveAgents(remote);
+        return structuredClone(remote);
+    }
+    async saveAgent(agent) {
+        if (await this.relay.loadAgents() === null) {
+            await this.relay.saveAgents(await this.github.listAgents());
+        }
+        const value = structuredClone(agent);
+        await this.relay.saveAgentWithProjection(value, {
+            idempotencyKey: `save_agent:${agent.id}`,
+            coalesceKey: `agent:${agent.id}`,
+            operation: 'save_agent',
+            payload: { operation: 'save_agent', value },
+            priority: 10,
+        });
+    }
+    async comments() { return this.github.comments(); }
+    async pullRequestState() {
+        return (await this.ensurePullRequestFacts()).state;
+    }
+    async pullRequestHead() {
+        return (await this.ensurePullRequestFacts()).head;
+    }
+    async headSha() { return (await this.pullRequestHead())?.sha ?? null; }
+    async mergePullRequest(expectedHeadSha) {
+        await this.relay.enqueueProjection({
+            idempotencyKey: `merge_pull_request:${expectedHeadSha ?? 'current'}`,
+            operation: 'merge_pull_request',
+            payload: { operation: 'merge_pull_request', expectedHeadSha },
+            priority: 200,
+        });
+    }
+    async closePullRequest() {
+        await this.relay.enqueueProjection({
+            idempotencyKey: 'close_pull_request',
+            operation: 'close_pull_request',
+            payload: { operation: 'close_pull_request' },
+            priority: 200,
+        });
+    }
+    async updatePullRequestBody(body) {
+        await this.relay.enqueueProjection({
+            idempotencyKey: 'update_pr_body',
+            coalesceKey: 'pr_body',
+            operation: 'update_pr_body',
+            payload: { operation: 'update_pr_body', value: body },
+            priority: 80,
+        });
+    }
+    async registerBlockerDependent(jobId, dependent) {
+        if (!this.relatedStore)
+            throw new Error('Projected store requires a related-store factory for blocker dependencies');
+        await registerBlockerDependency({
+            blockerStore: this,
+            blockerJobId: jobId,
+            dependentStore: this.relatedStore(dependent.repository, dependent.prNumber),
+            dependentJobId: dependent.jobId,
+            dependentTaskId: dependent.taskId,
+            resolutionMode: dependent.resolutionMode,
+        });
+    }
+    async resolveBlockerDependents(jobId, resolution) {
+        if (!this.relatedStore)
+            throw new Error('Projected store requires a related-store factory for blocker dependencies');
+        return resolveBlockerDependencies({
+            blockerStore: this,
+            blockerJobId: jobId,
+            resolution,
+            dependentStore: (repository, prNumber) => this.relatedStore(repository, prNumber),
+        });
+    }
+    async ensurePullRequestFacts() {
+        const local = await localPullRequestFacts(this.relay, this.seededFacts);
+        if (local)
+            return local;
+        if (!this.github.pullRequestState || !this.github.pullRequestHead)
+            throw new Error('Pull request facts have not been observed locally');
+        const [state, head] = await Promise.all([this.github.pullRequestState(), this.github.pullRequestHead()]);
+        const facts = { state, head, observedAt: new Date().toISOString() };
+        await this.relay.savePullRequestFacts(facts);
+        return facts;
+    }
+}
+function pullRequestFactsFromSeed(seed) {
+    const pr = seed?.prNode;
+    if (!pr || Object.keys(pr).length === 0)
+        return null;
+    const rawState = typeof pr.state === 'string' ? pr.state.toUpperCase() : '';
+    const state = pr.merged === true || rawState === 'MERGED' ? 'MERGED' : rawState === 'CLOSED' ? 'CLOSED' : rawState === 'OPEN' ? 'OPEN' : null;
+    if (!state)
+        return null;
+    const ref = typeof pr.headRefName === 'string' ? pr.headRefName : '';
+    const sha = typeof pr.headRefOid === 'string' ? pr.headRefOid : '';
+    return { state, head: ref && sha ? { ref, sha } : null, observedAt: new Date().toISOString() };
+}
+async function localPullRequestFacts(relay, seededFacts) {
+    return await relay.loadPullRequestFacts() ?? seededFacts;
+}