agents-relay 2.0.68 → 2.0.70

package/dist/relayd-control.js

@@ -0,0 +1,184 @@
+export function createWorkspaceControl(deps) {
+    const { client, trusted, noGitHub, repositories, refreshAll, requireLocalJobBinding, makeReconciler, concurrency, pool, bus, isEffectivelyBlocked, unblockAutonomousTasks, unblockTask, publishTaskUnblocked, dispatchTaskAction, registerBlockerDependency, discoverAgents, ensureManagedGitHubJob } = deps;
+    const workspaceControl = async (body) => {
+        const command = typeof body.command === 'string' ? body.command : '';
+        const jobId = typeof body.jobId === 'string' ? body.jobId : '';
+        if (!command)
+            throw new Error('control command is required');
+        if (command === 'job.create') {
+            const repository = typeof body.repository === 'string' ? body.repository : '';
+            const options = (body.options && typeof body.options === 'object' ? body.options : {});
+            if (!repository || typeof options.id !== 'string' || !options.id)
+                throw new Error('job.create requires repository and id');
+            const result = await ensureManagedGitHubJob(client, repository, trusted, {
+                id: options.id,
+                title: typeof options.title === 'string' ? options.title : undefined,
+                objective: typeof options.objective === 'string' ? options.objective : undefined,
+                projectPath: typeof options.projectPath === 'string' ? options.projectPath : undefined,
+                priority: options.priority,
+                executionMode: options.executionMode,
+                schedule: options.schedule,
+                tag: options.tag,
+                reviewEnabled: typeof options.reviewEnabled === 'boolean' ? options.reviewEnabled : undefined,
+                continuation: options.continuation,
+                prNumber: typeof options.prNumber === 'number' ? options.prNumber : undefined,
+                head: typeof options.head === 'string' ? options.head : undefined,
+                base: typeof options.base === 'string' ? options.base : undefined,
+                body: typeof options.body === 'string' ? options.body : undefined,
+                reviewerThreadId: typeof options.reviewerThreadId === 'string' ? options.reviewerThreadId : undefined,
+                creatorThreadId: typeof options.creatorThreadId === 'string' ? options.creatorThreadId : undefined,
+                noGitHub,
+                localMergeSource: typeof options.localMergeSource === 'string' ? options.localMergeSource : undefined,
+                localMergeTarget: typeof options.localMergeTarget === 'string' ? options.localMergeTarget : undefined,
+            });
+            if (!repositories.includes(repository))
+                repositories.push(repository);
+            await refreshAll();
+            if (body.initialPlan === true) {
+                const binding = await requireLocalJobBinding(result.job.id);
+                const reconciler = makeReconciler(binding.store, concurrency);
+                try {
+                    const planned = await reconciler.planJob(result.job.id);
+                    await pool.reconcileLocalJob(result.job.id, 'control.job.create.initial-plan');
+                    return { repository, pr: result.pr.number, job: result.job.id, executionMode: result.job.executionMode, state: result.job.state, initialPlan: planned.round.id };
+                }
+                finally {
+                    await reconciler.close();
+                }
+            }
+            return { repository, pr: result.pr.number, job: result.job.id, executionMode: result.job.executionMode, state: result.job.state };
+        }
+        if (!jobId)
+            throw new Error(command + ' requires jobId');
+        const binding = await requireLocalJobBinding(jobId);
+        const store = binding.store;
+        const job = await store.load(jobId);
+        if (command === 'job.update') {
+            const patch = (body.patch && typeof body.patch === 'object' ? body.patch : {});
+            const mutable = ['title', 'objective', 'projectPath', 'priority', 'executionMode', 'schedule', 'tag', 'autoMerge', 'reviewEnabled', 'reviewerThreadId', 'creatorThreadId', 'continuation', 'localMerge'];
+            for (const key of mutable)
+                if (Object.prototype.hasOwnProperty.call(patch, key))
+                    job[key] = patch[key];
+            job.updatedAt = new Date().toISOString();
+            await store.saveJob(job);
+            await refreshAll();
+            return await store.load(jobId);
+        }
+        if (command === 'job.plan') {
+            const reconciler = makeReconciler(store, concurrency);
+            try {
+                const planned = await reconciler.planJob(jobId, typeof body.guidance === 'string' && body.guidance.trim() ? body.guidance : undefined);
+                await pool.reconcileLocalJob(jobId, 'control.job.plan');
+                return planned.round;
+            }
+            finally {
+                await reconciler.close();
+            }
+        }
+        if (command === 'job.unblock') {
+            const reason = typeof body.reason === 'string' ? body.reason : '';
+            if (!reason.trim())
+                throw new Error('job unblock requires reason');
+            const blocked = job.tasks.filter(isEffectivelyBlocked);
+            if (!blocked.length)
+                throw new Error(`Job ${job.id} has no effective BLOCKED work task`);
+            if (job.executionMode === 'autonomous')
+                await unblockAutonomousTasks({ store, job, tasks: blocked, trigger: { source: 'cli', reason } });
+            else
+                for (const task of blocked)
+                    await unblockTask({ store, job, task, trigger: { source: 'cli', reason } });
+            const refreshed = await store.load(jobId);
+            for (const task of blocked)
+                await publishTaskUnblocked(bus, refreshed, task.id, reason);
+            await pool.reconcileLocalJob(jobId, 'control.job.unblock');
+            return await store.load(jobId);
+        }
+        if (command === 'task.recover') {
+            const taskId = typeof body.taskId === 'string' ? body.taskId : '';
+            const recoveryTaskId = typeof body.recoveryTaskId === 'string' ? body.recoveryTaskId : '';
+            if (!taskId || !recoveryTaskId)
+                throw new Error('task recover requires taskId and recoveryTaskId');
+            await dispatchTaskAction(store, { id: 'task.recover', jobId, taskId, recoveryTaskId });
+            await pool.reconcileLocalJob(jobId, 'control.task.recover');
+            return await store.load(jobId);
+        }
+        if (command === 'task.unblock') {
+            const taskId = typeof body.taskId === 'string' ? body.taskId : '';
+            const reason = typeof body.reason === 'string' ? body.reason : '';
+            const task = job.tasks.find((item) => item.id === taskId);
+            if (!task)
+                throw new Error(`Task ${taskId} not found`);
+            await unblockTask({ store, job, task, trigger: { source: 'cli', reason } });
+            const refreshed = await store.load(jobId);
+            await publishTaskUnblocked(bus, refreshed, taskId, reason);
+            await pool.reconcileLocalJob(jobId, 'control.task.unblock');
+            return await store.load(jobId);
+        }
+        if (command === 'review.request') {
+            if (job.state === 'CANCELLED' || job.state === 'COMPLETED')
+                throw new Error('Cannot request review for terminal Job');
+            if (!job.reviewEnabled)
+                throw new Error('Review disabled for this Job');
+            if (typeof body.threadId === 'string') {
+                job.reviewerThreadId = body.threadId;
+                job.updatedAt = new Date().toISOString();
+                await store.saveJob(job);
+            }
+            await pool.reconcileLocalJob(jobId, 'control.review.request');
+            return await store.load(jobId);
+        }
+        if (command === 'blocker.add') {
+            const dependentJobId = typeof body.dependentJobId === 'string' ? body.dependentJobId : '';
+            const dependentTaskId = typeof body.dependentTaskId === 'string' ? body.dependentTaskId : '';
+            const dependent = await requireLocalJobBinding(dependentJobId);
+            const relation = await registerBlockerDependency({ blockerStore: store, blockerJobId: jobId, dependentStore: dependent.store, dependentJobId, dependentTaskId, resolutionMode: body.resolutionMode === 'verified' ? 'verified' : 'merge' });
+            await refreshAll();
+            return relation;
+        }
+        if (command === 'blocker.resolve') {
+            if (!store.resolveBlockerDependents)
+                throw new Error('Blocker resolution unavailable');
+            const summary = await store.resolveBlockerDependents(jobId, body.resolution === 'merge' ? 'merge' : 'verified');
+            for (const target of summary.unblocked)
+                await pool.reconcileLocalJob(target.jobId, 'control.blocker.resolve');
+            await refreshAll();
+            return summary;
+        }
+        if (command === 'projection.conflicts')
+            return await binding.relay.listProjectionConflicts();
+        if (command === 'job.reconcile') {
+            await pool.reconcileLocalJob(jobId, 'control.job.reconcile');
+            return await store.load(jobId);
+        }
+        if (command === 'agent.discover') {
+            return discoverAgents(await store.listAgents(), (body.requirements && typeof body.requirements === 'object' ? body.requirements : {}));
+        }
+        if (command === 'projection.resolve') {
+            const id = Number(body.projectionId);
+            const action = body.action === 'discard_local' ? 'discard_local' : 'requeue';
+            if (!Number.isInteger(id) || id <= 0)
+                throw new Error('projection resolve requires projectionId');
+            const resolved = await binding.relay.resolveProjectionConflict(id, { action, ...(typeof body.note === 'string' && body.note ? { note: body.note } : {}) });
+            if (!resolved)
+                throw new Error(`Projection ${id} is not in a resolvable conflict state`);
+            return { resolved: id, action };
+        }
+        if (command === 'record') {
+            const task = body.task;
+            if (!task || task.jobId !== jobId)
+                throw new Error('record requires a task for this Job');
+            await store.appendTask(task);
+            await pool.reconcileLocalJob(jobId, 'control.record');
+            return await store.load(jobId);
+        }
+        if (command === 'agent.register') {
+            const agent = body.agent;
+            if (!agent)
+                throw new Error('agent.register requires agent');
+            await store.saveAgent(agent);
+            return agent;
+        }
+        throw new Error('Unsupported control command ' + command);
+    };
+    return workspaceControl;
+}

package/dist/relayd-dashboard-actions.js

@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+export function createDashboardActions(deps) {
+    const { cachedOverviews, requireLocalJobBinding, pool, dashboardJobAction, makeReconciler, concurrency, dashboardJobSetState, refreshAll, applyJobActivateAction, applyOrchestratorStartAction, applyOrchestratorCompleteAction, publishOrchestratorTaskStarted, publishOrchestratorTaskCompletion, bus, dashboardTaskAction, dashboardTaskSetState } = deps;
+    const dashboardOverview = (jobId, target) => cachedOverviews.find((item) => item.job.id === jobId
+        && (!target?.repository || item.job.repository === target.repository)
+        && (!target?.prNumber || (item.job.externalPrNumber ?? item.job.prNumber) === target.prNumber));
+    const workspaceJobAction = (action) => async (jobId) => {
+        const overview = cachedOverviews.find((item) => item.job.id === jobId);
+        if (!overview)
+            throw new Error(`Managed job ${jobId} not found`);
+        const store = (await requireLocalJobBinding(jobId)).store;
+        if (action === 'reconcile') {
+            await pool.reconcileLocalJob(jobId, 'control.job.reconcile');
+            return await store.load(jobId);
+        }
+        return await dashboardJobAction(store, makeReconciler(store, concurrency), action)(jobId);
+    };
+    const workspaceJobSetState = async (jobId, state, target) => {
+        const overview = dashboardOverview(jobId, target);
+        if (!overview)
+            throw new Error(`Managed job ${jobId} not found`);
+        const store = (await requireLocalJobBinding(jobId)).store;
+        const result = await dashboardJobSetState(store)(jobId, state);
+        await refreshAll();
+        return result;
+    };
+    const workspaceTaskCreate = async (jobId, task) => {
+        const overview = cachedOverviews.find((item) => item.job.id === jobId);
+        if (!overview)
+            throw new Error(`Managed job ${jobId} not found`);
+        if (task.jobId !== jobId)
+            throw new Error(`Task ${task.id} belongs to ${task.jobId}, not ${jobId}`);
+        const store = (await requireLocalJobBinding(jobId)).store;
+        const job = await store.load(jobId);
+        if (['COMPLETED', 'CANCELLED'].includes(job.state))
+            throw new Error(`Cannot create task on terminal job ${job.id} (${job.state})`);
+        if (store.mutateJob) {
+            await store.mutateJob(jobId, (current) => {
+                if (['COMPLETED', 'CANCELLED'].includes(current.state))
+                    throw new Error(`Cannot create task on terminal job ${current.id}`);
+                if (current.tasks.some((item) => item.id === task.id))
+                    throw new Error(`Task ${task.id} already exists`);
+                current.tasks.push(structuredClone(task));
+                if (current.state === 'DRAFT')
+                    applyJobActivateAction(current);
+                current.updatedAt = new Date().toISOString();
+                return current;
+            });
+        }
+        else {
+            await store.appendTask(task);
+            const refreshed = await store.load(jobId);
+            if (refreshed.state === 'DRAFT') {
+                await applyJobActivateAction(refreshed);
+                await store.saveJob(refreshed);
+            }
+        }
+        await pool.reconcileLocalJob(jobId, 'control.task.create');
+        return await store.load(jobId);
+    };
+    const workspaceTaskStart = async (jobId, taskId) => {
+        const overview = cachedOverviews.find((item) => item.job.id === jobId);
+        if (!overview)
+            throw new Error(`Managed job ${jobId} not found`);
+        const store = (await requireLocalJobBinding(jobId)).store;
+        const job = await store.load(jobId);
+        const task = job.tasks.find((item) => item.id === taskId);
+        if (!task)
+            throw new Error(`Task ${taskId} not found`);
+        await applyOrchestratorStartAction(task);
+        await store.saveTask(task);
+        await publishOrchestratorTaskStarted(bus, job, task);
+        await pool.reconcileLocalJob(jobId, 'control.task.start');
+        return await store.load(jobId);
+    };
+    const workspaceTaskComplete = async (jobId, taskId, summary) => {
+        const overview = cachedOverviews.find((item) => item.job.id === jobId);
+        if (!overview)
+            throw new Error(`Managed job ${jobId} not found`);
+        const store = (await requireLocalJobBinding(jobId)).store;
+        const job = await store.load(jobId);
+        const task = job.tasks.find((item) => item.id === taskId);
+        if (!task)
+            throw new Error(`Task ${taskId} not found`);
+        await applyOrchestratorCompleteAction(task, summary);
+        await store.saveTask(task);
+        await publishOrchestratorTaskCompletion(bus, job, task, summary);
+        await pool.reconcileLocalJob(jobId, 'control.task.complete');
+        return await store.load(jobId);
+    };
+    const workspaceTaskAction = (action) => async (jobId, taskId) => {
+        const overview = cachedOverviews.find((item) => item.job.id === jobId);
+        if (!overview)
+            throw new Error(`Managed job ${jobId} not found`);
+        const store = (await requireLocalJobBinding(jobId)).store;
+        return await dashboardTaskAction(store, makeReconciler(store, concurrency), action)(jobId, taskId);
+    };
+    const workspaceTaskSetState = async (jobId, taskId, state, target) => {
+        const overview = dashboardOverview(jobId, target);
+        if (!overview)
+            throw new Error(`Managed job ${jobId} not found`);
+        const store = (await requireLocalJobBinding(jobId)).store;
+        const result = await dashboardTaskSetState(store)(jobId, taskId, state);
+        await refreshAll();
+        return result;
+    };
+    return { dashboardOverview, workspaceJobAction, workspaceJobSetState, workspaceTaskCreate, workspaceTaskStart, workspaceTaskComplete, workspaceTaskAction, workspaceTaskSetState };
+}

package/dist/relayd-utilities.js

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+import { defaultWorkspaceRoot } from './workspace.js';
+import { executionRouterRulesPath } from './routing-policy.js';
+import { RelayObservability, setObservability } from './observability.js';
+/** Initialize the process-wide structured observability sink once, from environment. */
+export function configureDaemonObservability(env = process.env) {
+    const configured = RelayObservability.fromEnvironment(env);
+    setObservability(configured);
+    return configured;
+}
+export async function overlayOperationalOverviews(overviews, storeFor) {
+    return await Promise.all(overviews.map(async (item) => {
+        const store = storeFor(item.job.repository, item.job.prNumber);
+        await store.hydrate?.(item.job);
+        const job = await store.load(item.job.id);
+        return { ...item, job };
+    }));
+}
+function managedOverviewKey(item) {
+    return item.job.repository + '#' + item.job.prNumber + ':' + item.job.id;
+}
+export function mergeOperationalInventory(current, discovered) {
+    const merged = new Map(current.map(item => [managedOverviewKey(item), item]));
+    for (const item of discovered)
+        merged.set(managedOverviewKey(item), item);
+    return [...merged.values()];
+}
+const PR_REFRESH_COALESCE_MS = 1000;
+export const SCHEDULE_HEARTBEAT_MS = 600_000;
+export function dueScheduledOverviews(overviews, now = new Date()) {
+    return overviews.filter(item => item.job.state === 'ACTIVE' && item.job.executionMode === 'autonomous' && item.job.schedule && Date.parse(item.job.schedule.nextRunAt) <= now.getTime());
+}
+export function shouldCoalescePullRequestRefresh(completedAt, now = Date.now(), force = false) {
+    return !force && completedAt !== null && now >= completedAt && now - completedAt < PR_REFRESH_COALESCE_MS;
+}
+export const daemonHelp = `Agents Relay daemon runs the dashboard and worker pool.
+
+Usage:
+  npx agents-relayd [options]
+
+Options:
+  --no-github             Local-only mode: no GitHub auth, transport, PR, merge, or fetch
+  --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
+  --projection-ms MS      GitHub projection flush interval (default: 1000)
+  --execution-router-rules PATH
+                         Router Rules file (default: ~/.agents-relay/execution-router-rules.md)
+  --events nats            Require NATS event wakeups (otherwise auto-detect reachable NATS)
+
+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`;
+export function firstStageChoices(decisionInput) {
+    const stages = decisionInput?.stages;
+    if (!Array.isArray(stages) || stages.length === 0)
+        return [];
+    const contract = stages[0].contract;
+    return Array.isArray(contract?.choices) ? contract.choices.filter((item) => typeof item === 'string') : [];
+}
+export function value(args, name, fallback = '') { const index = args.indexOf(name); return index >= 0 ? args[index + 1] ?? fallback : fallback; }
+export function normalizeDaemonArguments(argv) {
+    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 function recoveryScanRepositories(repositories, cached, dormantProbeIndex = 0) {
+    const byRepository = new Map();
+    for (const item of cached) {
+        const values = byRepository.get(item.job.repository) ?? [];
+        values.push(item);
+        byRepository.set(item.job.repository, values);
+    }
+    const activeOrUnknown = [];
+    const dormant = [];
+    for (const repository of repositories) {
+        const values = byRepository.get(repository);
+        if (!values || values.length === 0 || values.some(item => !['COMPLETED', 'CANCELLED'].includes(item.job.state)))
+            activeOrUnknown.push(repository);
+        else
+            dormant.push(repository);
+    }
+    if (dormant.length === 0)
+        return activeOrUnknown;
+    return [...activeOrUnknown, dormant[Math.abs(dormantProbeIndex) % dormant.length]];
+}
+export function configureExecutionRouterRulesPath(argv) {
+    const explicitRulesPath = value(argv, '--execution-router-rules') || undefined;
+    if (explicitRulesPath)
+        process.env.AGENTS_RELAY_EXECUTION_ROUTER_RULES = executionRouterRulesPath(explicitRulesPath);
+    return executionRouterRulesPath();
+}