agents-relay 1.0.177 → 2.0.1

package/dist/relay-store.js

@@ -0,0 +1,380 @@
+import { DatabaseSync } from 'node:sqlite';
+import { dirname } from 'node:path';
+import { mkdirSync } from 'node:fs';
+import { readdir } from 'node:fs/promises';
+const SCHEMA_VERSION = 4;
+function newerRecord(local, remote) {
+    if (!local)
+        return structuredClone(remote);
+    return remote.updatedAt > local.updatedAt ? structuredClone(remote) : structuredClone(local);
+}
+function mergeRecords(local, remote) {
+    const remoteById = new Map(remote.map(item => [item.id, item]));
+    const merged = local.map(item => newerRecord(item, remoteById.get(item.id) ?? item));
+    const localIds = new Set(local.map(item => item.id));
+    for (const item of remote)
+        if (!localIds.has(item.id))
+            merged.push(structuredClone(item));
+    return merged;
+}
+export function mergeInboundJobSnapshot(local, remote) {
+    const base = remote.updatedAt > local.updatedAt ? structuredClone(remote) : structuredClone(local);
+    base.tasks = mergeRecords(local.tasks, remote.tasks);
+    const localPlans = local.plans ?? [];
+    const remotePlans = remote.plans ?? [];
+    if (localPlans.length > 0 || remotePlans.length > 0) {
+        base.plans = mergeRecords(localPlans, remotePlans).sort((a, b) => a.round - b.round);
+    }
+    else {
+        delete base.plans;
+    }
+    return base;
+}
+function rowToProjection(row) {
+    return {
+        id: Number(row.id),
+        idempotencyKey: row.idempotency_key,
+        coalesceKey: row.coalesce_key,
+        operation: row.operation,
+        payload: JSON.parse(row.payload_json),
+        priority: Number(row.priority),
+        attempts: Number(row.attempts),
+        nextAttemptAt: row.next_attempt_at,
+        lastError: row.last_error,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+export class SQLiteRelayStore {
+    path;
+    db;
+    constructor(path) {
+        this.path = path;
+        if (path !== ':memory:')
+            mkdirSync(dirname(path), { recursive: true });
+        this.db = new DatabaseSync(path);
+        this.db.exec('PRAGMA journal_mode=WAL; PRAGMA synchronous=NORMAL; PRAGMA busy_timeout=5000; PRAGMA foreign_keys=ON;');
+        this.migrate();
+        this.db.prepare("UPDATE projection_outbox SET status='pending', updated_at=? WHERE status='processing'")
+            .run(new Date().toISOString());
+    }
+    migrate() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS relay_meta (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS job_snapshot (
+        job_id TEXT PRIMARY KEY,
+        json TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS pull_request_facts (
+        id INTEGER PRIMARY KEY CHECK(id=1),
+        state TEXT NOT NULL CHECK(state IN ('OPEN','MERGED','CLOSED')),
+        head_ref TEXT,
+        head_sha TEXT,
+        observed_at TEXT NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS agent_snapshot (
+        agent_id TEXT PRIMARY KEY,
+        json TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS event_receipt (
+        event_id TEXT PRIMARY KEY,
+        stream TEXT,
+        sequence INTEGER,
+        received_at TEXT NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS projection_outbox (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        idempotency_key TEXT NOT NULL UNIQUE,
+        coalesce_key TEXT,
+        operation TEXT NOT NULL,
+        payload_json TEXT NOT NULL,
+        priority INTEGER NOT NULL DEFAULT 0,
+        status TEXT NOT NULL DEFAULT 'pending' CHECK(status IN ('pending','processing','dead')),
+        attempts INTEGER NOT NULL DEFAULT 0,
+        next_attempt_at TEXT,
+        last_error TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS projection_due_idx
+        ON projection_outbox(status, next_attempt_at, priority DESC, id);
+      CREATE INDEX IF NOT EXISTS projection_coalesce_idx
+        ON projection_outbox(coalesce_key, status);
+    `);
+        const current = this.db.prepare("SELECT value FROM relay_meta WHERE key='schema_version'").get();
+        const version = current?.value ? Number(current.value) : 0;
+        if (version > SCHEMA_VERSION)
+            throw new Error(`Relay store schema ${version} is newer than supported ${SCHEMA_VERSION}`);
+        if (version < 4) {
+            const schema = this.db.prepare("SELECT sql FROM sqlite_master WHERE type='table' AND name='projection_outbox'").get();
+            if (schema?.sql && !schema.sql.includes("'dead'")) {
+                this.db.exec(`
+          BEGIN IMMEDIATE;
+          DROP INDEX IF EXISTS projection_due_idx;
+          DROP INDEX IF EXISTS projection_coalesce_idx;
+          ALTER TABLE projection_outbox RENAME TO projection_outbox_v3;
+          CREATE TABLE projection_outbox (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            idempotency_key TEXT NOT NULL UNIQUE,
+            coalesce_key TEXT,
+            operation TEXT NOT NULL,
+            payload_json TEXT NOT NULL,
+            priority INTEGER NOT NULL DEFAULT 0,
+            status TEXT NOT NULL DEFAULT 'pending' CHECK(status IN ('pending','processing','dead')),
+            attempts INTEGER NOT NULL DEFAULT 0,
+            next_attempt_at TEXT,
+            last_error TEXT,
+            created_at TEXT NOT NULL,
+            updated_at TEXT NOT NULL
+          );
+          INSERT INTO projection_outbox(id,idempotency_key,coalesce_key,operation,payload_json,priority,status,attempts,next_attempt_at,last_error,created_at,updated_at)
+          SELECT id,idempotency_key,coalesce_key,operation,payload_json,priority,status,attempts,next_attempt_at,last_error,created_at,updated_at FROM projection_outbox_v3;
+          DROP TABLE projection_outbox_v3;
+          CREATE INDEX projection_due_idx ON projection_outbox(status, next_attempt_at, priority DESC, id);
+          CREATE INDEX projection_coalesce_idx ON projection_outbox(coalesce_key, status);
+          COMMIT;
+        `);
+            }
+        }
+        this.db.prepare("INSERT INTO relay_meta(key,value) VALUES('schema_version',?) ON CONFLICT(key) DO UPDATE SET value=excluded.value")
+            .run(String(SCHEMA_VERSION));
+    }
+    async loadJob(jobId) {
+        const row = this.db.prepare('SELECT json FROM job_snapshot WHERE job_id=?').get(jobId);
+        return row?.json ? JSON.parse(row.json) : null;
+    }
+    async listJobs() {
+        const rows = this.db.prepare('SELECT json FROM job_snapshot ORDER BY job_id').all();
+        return rows.map(row => JSON.parse(row.json));
+    }
+    async saveJob(job) {
+        this.writeJobSnapshot(job, new Date().toISOString());
+    }
+    async ingestJobSnapshot(job) {
+        const now = new Date().toISOString();
+        this.db.exec('BEGIN IMMEDIATE');
+        try {
+            const row = this.db.prepare('SELECT json FROM job_snapshot WHERE job_id=?').get(job.id);
+            const local = row?.json ? JSON.parse(row.json) : null;
+            const merged = local ? mergeInboundJobSnapshot(local, job) : structuredClone(job);
+            this.writeJobSnapshot(merged, now);
+            this.db.exec('COMMIT');
+            return structuredClone(merged);
+        }
+        catch (error) {
+            this.db.exec('ROLLBACK');
+            throw error;
+        }
+    }
+    async saveJobWithProjection(job, request) {
+        const now = new Date().toISOString();
+        this.db.exec('BEGIN IMMEDIATE');
+        try {
+            this.writeJobSnapshot(job, now);
+            this.enqueueProjectionInTransaction(request, now);
+            this.db.exec('COMMIT');
+        }
+        catch (error) {
+            this.db.exec('ROLLBACK');
+            throw error;
+        }
+    }
+    writeJobSnapshot(job, now) {
+        this.db.prepare(`
+      INSERT INTO job_snapshot(job_id,json,updated_at) VALUES(?,?,?)
+      ON CONFLICT(job_id) DO UPDATE SET json=excluded.json, updated_at=excluded.updated_at
+    `).run(job.id, JSON.stringify(job), now);
+    }
+    async loadAgents() {
+        const observed = this.db.prepare("SELECT value FROM relay_meta WHERE key='agent_registry_observed_at'").get();
+        if (!observed?.value)
+            return null;
+        const rows = this.db.prepare('SELECT json FROM agent_snapshot ORDER BY agent_id').all();
+        return rows.map(row => JSON.parse(row.json));
+    }
+    async saveAgents(agents) {
+        const now = new Date().toISOString();
+        this.db.exec('BEGIN IMMEDIATE');
+        try {
+            this.db.prepare('DELETE FROM agent_snapshot').run();
+            const insert = this.db.prepare('INSERT INTO agent_snapshot(agent_id,json,updated_at) VALUES(?,?,?)');
+            for (const agent of agents)
+                insert.run(agent.id, JSON.stringify(agent), now);
+            this.markAgentRegistryObserved(now);
+            this.db.exec('COMMIT');
+        }
+        catch (error) {
+            this.db.exec('ROLLBACK');
+            throw error;
+        }
+    }
+    async saveAgentWithProjection(agent, request) {
+        const now = new Date().toISOString();
+        this.db.exec('BEGIN IMMEDIATE');
+        try {
+            this.writeAgentSnapshot(agent, now);
+            this.markAgentRegistryObserved(now);
+            this.enqueueProjectionInTransaction(request, now);
+            this.db.exec('COMMIT');
+        }
+        catch (error) {
+            this.db.exec('ROLLBACK');
+            throw error;
+        }
+    }
+    writeAgentSnapshot(agent, now) {
+        this.db.prepare(`
+      INSERT INTO agent_snapshot(agent_id,json,updated_at) VALUES(?,?,?)
+      ON CONFLICT(agent_id) DO UPDATE SET json=excluded.json, updated_at=excluded.updated_at
+    `).run(agent.id, JSON.stringify(agent), now);
+    }
+    markAgentRegistryObserved(now) {
+        this.db.prepare(`
+      INSERT INTO relay_meta(key,value) VALUES('agent_registry_observed_at',?)
+      ON CONFLICT(key) DO UPDATE SET value=excluded.value
+    `).run(now);
+    }
+    async loadPullRequestFacts() {
+        const row = this.db.prepare('SELECT state,head_ref,head_sha,observed_at FROM pull_request_facts WHERE id=1').get();
+        if (!row?.state || !row.observed_at)
+            return null;
+        return { state: row.state, head: row.head_ref && row.head_sha ? { ref: row.head_ref, sha: row.head_sha } : null, observedAt: row.observed_at };
+    }
+    async savePullRequestFacts(facts) {
+        this.db.prepare(`
+      INSERT INTO pull_request_facts(id,state,head_ref,head_sha,observed_at) VALUES(1,?,?,?,?)
+      ON CONFLICT(id) DO UPDATE SET state=excluded.state,head_ref=excluded.head_ref,head_sha=excluded.head_sha,observed_at=excluded.observed_at
+    `).run(facts.state, facts.head?.ref ?? null, facts.head?.sha ?? null, facts.observedAt);
+    }
+    async markEventProcessed(eventId, stream = null, sequence = null) {
+        const result = this.db.prepare(`
+      INSERT OR IGNORE INTO event_receipt(event_id,stream,sequence,received_at) VALUES(?,?,?,?)
+    `).run(eventId, stream, sequence, new Date().toISOString());
+        return Number(result.changes) === 1;
+    }
+    async enqueueProjection(request) {
+        const now = new Date().toISOString();
+        this.db.exec('BEGIN IMMEDIATE');
+        try {
+            this.enqueueProjectionInTransaction(request, now);
+            this.db.exec('COMMIT');
+        }
+        catch (error) {
+            this.db.exec('ROLLBACK');
+            throw error;
+        }
+    }
+    enqueueProjectionInTransaction(request, now) {
+        if (request.coalesceKey) {
+            this.db.prepare(`
+        DELETE FROM projection_outbox
+        WHERE coalesce_key=? AND status='pending' AND idempotency_key<>?
+      `).run(request.coalesceKey, request.idempotencyKey);
+        }
+        const existing = this.db.prepare('SELECT status FROM projection_outbox WHERE idempotency_key=?').get(request.idempotencyKey);
+        // A writer may be applying this key outside the transaction. Never rewrite its
+        // payload: its completion must only remove its own row, not a newer mutation.
+        const nextId = Number(this.db.prepare('SELECT COALESCE(MAX(id),0)+1 AS next_id FROM projection_outbox').get().next_id ?? 1);
+        const idempotencyKey = existing?.status === 'processing' || existing?.status === 'dead'
+            ? `${request.idempotencyKey}:queued:${nextId}`
+            : request.idempotencyKey;
+        this.db.prepare(`
+      INSERT INTO projection_outbox(
+        idempotency_key,coalesce_key,operation,payload_json,priority,status,
+        attempts,next_attempt_at,last_error,created_at,updated_at
+      ) VALUES(?,?,?,?,?,'pending',0,NULL,NULL,?,?)
+      ON CONFLICT(idempotency_key) DO UPDATE SET
+        coalesce_key=excluded.coalesce_key,
+        operation=excluded.operation,
+        payload_json=excluded.payload_json,
+        priority=MAX(projection_outbox.priority,excluded.priority),
+        status='pending',
+        next_attempt_at=NULL,
+        last_error=NULL,
+        updated_at=excluded.updated_at
+    `).run(idempotencyKey, request.coalesceKey ?? null, request.operation, JSON.stringify(request.payload), request.priority ?? 0, now, now);
+    }
+    async claimDueProjections(limit = 50, now = new Date()) {
+        const observedAt = now.toISOString();
+        this.db.exec('BEGIN IMMEDIATE');
+        try {
+            const rows = this.db.prepare(`
+        SELECT id,idempotency_key,coalesce_key,operation,payload_json,priority,
+               attempts,next_attempt_at,last_error,created_at,updated_at
+        FROM projection_outbox
+        WHERE status='pending' AND (next_attempt_at IS NULL OR next_attempt_at<=?)
+        ORDER BY priority DESC, id ASC
+        LIMIT ?
+      `).all(observedAt, Math.max(1, Math.floor(limit)));
+            const mark = this.db.prepare("UPDATE projection_outbox SET status='processing', updated_at=? WHERE id=? AND status='pending'");
+            const claimed = [];
+            for (const row of rows) {
+                const result = mark.run(observedAt, row.id);
+                if (Number(result.changes) === 1)
+                    claimed.push({ ...row, updated_at: observedAt });
+            }
+            this.db.exec('COMMIT');
+            return claimed.map(rowToProjection);
+        }
+        catch (error) {
+            this.db.exec('ROLLBACK');
+            throw error;
+        }
+    }
+    async completeProjection(id) {
+        this.db.prepare('DELETE FROM projection_outbox WHERE id=?').run(id);
+    }
+    async retryProjection(id, error, nextAttemptAt) {
+        this.db.prepare(`
+      UPDATE projection_outbox
+      SET status='pending', attempts=attempts+1, next_attempt_at=?, last_error=?, updated_at=?
+      WHERE id=?
+    `).run(nextAttemptAt.toISOString(), error, new Date().toISOString(), id);
+    }
+    async deadLetterProjection(id, error) {
+        this.db.prepare(`
+      UPDATE projection_outbox
+      SET status='dead', attempts=attempts+1, next_attempt_at=NULL, last_error=?, updated_at=?
+      WHERE id=?
+    `).run(error, new Date().toISOString(), id);
+    }
+    async pendingProjectionCount() {
+        const row = this.db.prepare("SELECT COUNT(*) AS count FROM projection_outbox WHERE status IN ('pending','processing')").get();
+        return Number(row?.count ?? 0);
+    }
+    async terminalProjectionCount() {
+        const row = this.db.prepare("SELECT COUNT(*) AS count FROM projection_outbox WHERE status='dead'").get();
+        return Number(row?.count ?? 0);
+    }
+    close() { this.db.close(); }
+}
+export async function discoverLocalRelayStoreSnapshots(directory) {
+    let names;
+    try {
+        names = await readdir(directory);
+    }
+    catch {
+        return [];
+    }
+    const snapshots = [];
+    for (const name of names.filter(item => item.endsWith('.db')).sort()) {
+        const path = directory + '/' + name;
+        let store;
+        try {
+            store = new SQLiteRelayStore(path);
+            snapshots.push({ path, jobs: await store.listJobs(), facts: await store.loadPullRequestFacts() });
+        }
+        catch {
+            // Ignore unrelated/corrupt files so one bad file cannot block daemon startup.
+        }
+        finally {
+            store?.close();
+        }
+    }
+    return snapshots;
+}

package/dist/relayd-main.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+import { runDaemon } from './relayd.js';
+runDaemon(process.argv.slice(2)).catch(error => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+});