agent-relay-server 0.38.0 → 0.40.0

package/src/reviewer-pipeline.ts

@@ -0,0 +1,197 @@
+import { isRecord } from "agent-relay-sdk";
+import { planSend } from "./agent-ref";
+import { createCommand } from "./commands-db";
+import { getSpawnPolicy } from "./config-store";
+import { getLifecycleManager } from "./lifecycle-manager";
+import { notifySystemMessage } from "./notify";
+import { getWorkspace, listAgents, patchWorkspaceMetadata, updateWorkspaceStatus } from "./db";
+import type { Command, WorkspaceMergePreview, WorkspaceRecord } from "./types";
+
+type ReviewDecision = "APPROVED" | "CHANGES_REQUESTED" | "REVIEW_REQUIRED";
+
+export function parsePrNumber(prUrl: string | undefined): number | undefined {
+  if (!prUrl) return undefined;
+  const match = prUrl.match(/\/pull\/(\d+)(?:\D|$)/);
+  if (!match) return undefined;
+  const num = Number(match[1]);
+  return Number.isSafeInteger(num) && num > 0 ? num : undefined;
+}
+
+function text(value: unknown): string | undefined {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+function reviewerTarget(reviewer: string): { target: string; policyName?: string } {
+  if (reviewer.startsWith("policy:")) {
+    const policyName = reviewer.slice("policy:".length).trim();
+    return policyName ? { target: reviewer, policyName } : { target: reviewer };
+  }
+  const policy = getSpawnPolicy(reviewer);
+  if (policy) return { target: `policy:${policy.value.name}`, policyName: policy.value.name };
+  const plan = planSend(reviewer, listAgents(), { excludeId: "system" });
+  if (plan.kind === "direct" || plan.kind === "fanout" || plan.kind === "passthrough") {
+    return { target: plan.to };
+  }
+  return { target: reviewer };
+}
+
+export function handleReviewerMergeResult(command: Command, result: Record<string, unknown>): boolean {
+  if (result.awaitingApproval !== true || !isRecord(command.params)) return false;
+  const reviewer = text(command.params.reviewer);
+  if (!reviewer) return false;
+  const workspaceId = text(result.workspaceId) ?? command.correlationId;
+  if (!workspaceId) return false;
+  const workspace = getWorkspace(workspaceId);
+  if (!workspace) return false;
+
+  const prUrl = text(result.prUrl);
+  const prNumber = parsePrNumber(prUrl);
+  const { target, policyName } = reviewerTarget(reviewer);
+  const compareRef = workspace.baseRef && workspace.branch ? `${workspace.baseRef}...${workspace.branch}` : workspace.branch;
+  const updated = updateWorkspaceStatus(workspace.id, "review_requested", {
+    mergeResult: result,
+    mergeCommandId: command.id,
+    prUrl,
+    prNumber,
+    awaitingApproval: true,
+    reviewer: target,
+    reviewRequestedAt: Date.now(),
+    compareRef,
+  });
+  if (!updated) return false;
+
+  notifySystemMessage(target, {
+    subject: `Review requested: ${workspace.branch ?? workspace.id}`,
+    body: [
+      `Review PR ${prUrl ?? `#${prNumber ?? "unknown"}`} for workspace \`${workspace.id}\`.`,
+      `Repo: ${workspace.repoRoot}`,
+      workspace.branch ? `Branch: ${workspace.branch}` : undefined,
+      workspace.baseRef ? `Base: ${workspace.baseRef}` : undefined,
+      compareRef ? `Compare: ${compareRef}` : undefined,
+      "Approve the PR to let Relay arm GitHub auto-merge, or request changes to send it back to the workspace owner.",
+    ].filter(Boolean).join("\n"),
+    payload: {
+      kind: "workspace.review-request",
+      workspaceId: workspace.id,
+      repoRoot: workspace.repoRoot,
+      worktreePath: workspace.worktreePath,
+      branch: workspace.branch,
+      baseRef: workspace.baseRef,
+      prUrl,
+      prNumber,
+      compareRef,
+    },
+  });
+  if (policyName) getLifecycleManager().onMessageForPolicy(policyName);
+  return true;
+}
+
+export function isAwaitingReviewerApproval(workspace: WorkspaceRecord): boolean {
+  return workspace.status === "review_requested" && workspace.metadata.awaitingApproval === true;
+}
+
+function previewReviewDecision(preview: WorkspaceMergePreview): ReviewDecision | undefined {
+  const decision = preview.reviewDecision;
+  return decision === "APPROVED" || decision === "CHANGES_REQUESTED" || decision === "REVIEW_REQUIRED" ? decision : undefined;
+}
+
+export function handleReviewerPipelineScan(
+  workspace: WorkspaceRecord,
+  preview: WorkspaceMergePreview,
+  orchestratorAgentId: string,
+): { armCommand?: Command; notifiedOwner?: string; skipped?: string } {
+  if (!isAwaitingReviewerApproval(workspace)) return { skipped: "not-awaiting-approval" };
+  if (workspaceActiveArm(workspace)) return { skipped: "auto-merge-already-armed" };
+
+  const decision = previewReviewDecision(preview);
+  const prNumber = preview.prNumber ?? (typeof workspace.metadata.prNumber === "number" ? workspace.metadata.prNumber : undefined);
+  const prUrl = preview.prUrl ?? text(workspace.metadata.prUrl);
+  const now = Date.now();
+
+  if (decision === "APPROVED") {
+    if (!prNumber && !prUrl) return { skipped: "missing-pr" };
+    const command = createCommand({
+      type: "workspace.pr-arm-auto-merge",
+      source: "system",
+      target: orchestratorAgentId,
+      correlationId: workspace.id,
+      params: {
+        action: "pr-arm-auto-merge",
+        workspaceId: workspace.id,
+        repoRoot: workspace.repoRoot,
+        worktreePath: workspace.worktreePath,
+        branch: workspace.branch,
+        baseRef: workspace.baseRef,
+        prNumber,
+        prUrl,
+        requestedBy: "reviewer-pipeline",
+        requestedAt: now,
+      },
+    });
+    patchWorkspaceMetadata(workspace.id, {
+      autoMergeArmed: true,
+      autoMergeArmCommandId: command.id,
+      autoMergeArmedAt: now,
+      lastReviewDecision: decision,
+      reviewDecisionAt: now,
+    });
+    return { armCommand: command };
+  }
+
+  if (decision === "CHANGES_REQUESTED") {
+    const last = text(workspace.metadata.lastReviewDecision);
+    if (last === "CHANGES_REQUESTED") return { skipped: "changes-requested-already-notified" };
+    const notifiedOwner = workspace.ownerAgentId
+      ? notifyReviewChangesRequested(workspace, preview, prUrl, prNumber)
+      : undefined;
+    patchWorkspaceMetadata(workspace.id, {
+      lastReviewDecision: decision,
+      reviewDecisionAt: now,
+      changesRequestedNotifiedAt: now,
+      changesRequestedPrUrl: prUrl,
+      changesRequestedPrNumber: prNumber,
+    });
+    return { notifiedOwner };
+  }
+
+  if (decision && workspace.metadata.lastReviewDecision !== decision) {
+    patchWorkspaceMetadata(workspace.id, { lastReviewDecision: decision, reviewDecisionAt: now });
+  }
+  return { skipped: decision ?? "review-not-ready" };
+}
+
+function workspaceActiveArm(workspace: WorkspaceRecord): boolean {
+  return workspace.metadata.autoMergeArmed === true || typeof workspace.metadata.autoMergeArmCommandId === "string";
+}
+
+function notifyReviewChangesRequested(
+  workspace: WorkspaceRecord,
+  preview: WorkspaceMergePreview,
+  prUrl: string | undefined,
+  prNumber: number | undefined,
+): string | undefined {
+  const target = workspace.ownerAgentId;
+  if (!target) return undefined;
+  notifySystemMessage(target, {
+    subject: `Changes requested: ${workspace.branch ?? workspace.id}`,
+    body: [
+      `The reviewer requested changes on ${prUrl ?? `PR #${prNumber ?? "unknown"}`}.`,
+      `Workspace \`${workspace.id}\` remains in review_requested.`,
+      preview.baseRef ? `Base: ${preview.baseRef}` : undefined,
+    ].filter(Boolean).join("\n"),
+    payload: {
+      kind: "workspace.review-changes-requested",
+      workspaceId: workspace.id,
+      repoRoot: workspace.repoRoot,
+      worktreePath: workspace.worktreePath,
+      branch: workspace.branch,
+      baseRef: workspace.baseRef,
+      prUrl,
+      prNumber,
+      reviewDecision: preview.reviewDecision,
+      statusCheckRollup: preview.statusCheckRollup,
+    },
+    replyExpected: false,
+  });
+  return target;
+}

package/src/routes/commands.ts

@@ -14,6 +14,7 @@ import { commandAuthorizationResource as dispatchCommandAuthorizationResource, d
 import { ServiceAuthError } from "../services/errors";
 import { notifyBranchLanded } from "../branch-landed";
 import { notifyAgentSpawnFailed } from "../agent-lifecycle-events";
+import { handleReviewerMergeResult } from "../reviewer-pipeline";
 import { type Command, type CommandStatus, type CreateCommandInput, type WorkspaceStatus } from "../types";
 
 const VALID_COMMAND_STATUSES = ["pending", "accepted", "running", "succeeded", "failed", "timed_out", "rejected", "canceled"] as const;
@@ -188,6 +189,11 @@ export const patchCommand: Handler = async (req, params) => {
         releaseMergeLease({ commandId: command.id });
       }
       if (command.status === "succeeded" && isRecord(command.result)) {
+        if (handleReviewerMergeResult(command, command.result)) {
+          emitCommand(command);
+          auditCommandOutcome(command);
+          return json(command);
+        }
         const workspaceId = cleanString(command.result.workspaceId, "result.workspaceId", { max: 160 });
         const resultStatus = optionalEnum(command.result.status, "result.status", VALID_WORKSPACE_STATUSES) as WorkspaceStatus | undefined;
         if (workspaceId && resultStatus) {
@@ -279,6 +285,28 @@ export const patchCommand: Handler = async (req, params) => {
         }
       }
     }
+    if (command.type === "workspace.pr-merge") {
+      const resultWorkspaceId = isRecord(command.result) ? cleanString(command.result.workspaceId, "result.workspaceId", { max: 160 }) : undefined;
+      const workspaceId = resultWorkspaceId ?? command.correlationId;
+      if (workspaceId && command.status === "succeeded" && isRecord(command.result) && command.result.relayMerged === true) {
+        patchWorkspaceMetadata(workspaceId, {
+          relayMerged: true,
+          relayMergeCommandId: command.id,
+          relayMergedAt: Date.now(),
+          relayMergeResult: command.result,
+          relayMergeError: undefined,
+          relayMergeFailedAt: undefined,
+        });
+      } else if (workspaceId && (command.status === "failed" || command.status === "timed_out" || command.status === "rejected" || command.status === "canceled")) {
+        patchWorkspaceMetadata(workspaceId, {
+          relayMerged: false,
+          relayMergeCommandId: undefined,
+          relayMergeError: command.error ?? "PR merge failed",
+          relayMergeFailedAt: Date.now(),
+          relayMergeResult: command.result,
+        });
+      }
+    }
     if (command.type === "workspace.deps-refresh" && command.status === "succeeded" && isRecord(command.result)) {
       // Record the outcome on the row without touching status (#51) — observability
       // for the dashboard; the CLI reads the result straight off the command.

package/src/services/managed-running.ts

@@ -51,6 +51,7 @@ export function markManagedAgentRunning(
   if (!input.policyName || !input.spawnRequestId) return;
   const state = getManagedAgentState(input.policyName);
   if (!state || state.spawnRequestId !== input.spawnRequestId) return;
+  if (state.status === "failed") return;
   const now = opts.now ?? (() => Date.now());
 
   const fromState = state.status;

package/src/services/send-message.ts

@@ -172,6 +172,10 @@ export function sendMessageService(
     } else {
       emitNewMessage(result.message);
     }
+  } else if (result.updated) {
+    // Session-step upsert (#parity): the row changed in place (same DB id). Re-emit so the
+    // dashboard's id-keyed merge replaces the existing step live — no duplicate row.
+    emitNewMessage(result.message);
   }
   return { message: result.message, created: result.created, receipt };
 }

package/src/workspace-pr-completion.ts

@@ -0,0 +1,121 @@
+import { isRecord } from "agent-relay-sdk";
+import { createCommand, getCommand } from "./commands-db";
+import { patchWorkspaceMetadata } from "./db";
+import { handleReviewerPipelineScan, isAwaitingReviewerApproval } from "./reviewer-pipeline";
+import type { Command, WorkspaceAutoMergePolicy, WorkspaceMergePreview, WorkspaceRecord } from "./types";
+
+const ACTIVE_COMMAND_STATUSES = new Set(["pending", "accepted", "running"]);
+const PASSING_CONCLUSIONS = new Set(["SUCCESS", "NEUTRAL", "SKIPPED"]);
+const PASSING_STATES = new Set(["SUCCESS"]);
+const READY_MERGE_STATES = new Set(["CLEAN", "HAS_HOOKS"]);
+
+function relayPrMergeAlreadyHandled(workspace: WorkspaceRecord): boolean {
+  const commandId = text(workspace.metadata.relayMergeCommandId);
+  if (commandId) {
+    const command = getCommand(commandId);
+    if (command && ACTIVE_COMMAND_STATUSES.has(command.status)) return true;
+    if (command?.status === "succeeded" && command.result?.relayMerged === true) return true;
+  }
+  return workspace.metadata.relayMerged === true && !commandId;
+}
+
+function nativeAutoMergeArmed(workspace: WorkspaceRecord): boolean {
+  if (isRecord(workspace.metadata.mergeResult) && workspace.metadata.mergeResult.autoMergeArmed === true) return true;
+  const commandId = text(workspace.metadata.autoMergeArmCommandId);
+  if (!commandId) return false;
+  const command = getCommand(commandId);
+  return command?.status === "succeeded" && command.result?.autoMergeArmed === true;
+}
+
+function prAutoMergePolicy(workspace: WorkspaceRecord, preview: WorkspaceMergePreview): WorkspaceAutoMergePolicy {
+  const commandId = text(workspace.metadata.mergeCommandId);
+  if (commandId) {
+    const command = getCommand(commandId);
+    const autoMerge = text(command?.params.autoMerge);
+    if (autoMerge === "on-green" || autoMerge === "on-approval" || autoMerge === "manual") return autoMerge;
+  }
+  if (workspace.metadata.awaitingApproval === true || (isRecord(workspace.metadata.mergeResult) && workspace.metadata.mergeResult.awaitingApproval === true)) return "on-approval";
+  return "on-green";
+}
+
+function prReadyForRelayMerge(workspace: WorkspaceRecord, preview: WorkspaceMergePreview): { ok: true; policy: WorkspaceAutoMergePolicy } | { ok: false; reason: string; policy?: WorkspaceAutoMergePolicy } {
+  if (preview.strategy !== "pr") return { ok: false, reason: "not-pr-strategy" };
+  if (preview.prMerged === true || preview.prState === "merged") return { ok: false, reason: "already-merged" };
+  if (!preview.prNumber && !preview.prUrl) return { ok: false, reason: "missing-pr" };
+  if (nativeAutoMergeArmed(workspace)) return { ok: false, reason: "native-auto-merge-armed" };
+  if (relayPrMergeAlreadyHandled(workspace)) return { ok: false, reason: "relay-merge-already-dispatched" };
+
+  const policy = prAutoMergePolicy(workspace, preview);
+  if (policy === "manual") return { ok: false, reason: "manual", policy };
+  if (policy === "on-approval" && preview.reviewDecision !== "APPROVED") return { ok: false, reason: "approval-required", policy };
+  if (!prMergeable(preview)) return { ok: false, reason: "not-mergeable", policy };
+  if (!statusChecksGreen(preview.statusCheckRollup)) return { ok: false, reason: "checks-not-green", policy };
+  return { ok: true, policy };
+}
+
+export function preparePrCompletionScan(workspace: WorkspaceRecord, preview: WorkspaceMergePreview, orchestratorAgentId: string): {
+  armCommand?: Command;
+  notifiedOwner?: string;
+  mergeCommand?: Command;
+  waitReason?: string;
+  stop?: boolean;
+} {
+  if (isAwaitingReviewerApproval(workspace)) {
+    const action = handleReviewerPipelineScan(workspace, preview, orchestratorAgentId);
+    if (action.armCommand) return { armCommand: action.armCommand, stop: true };
+    if (action.notifiedOwner) return { notifiedOwner: action.notifiedOwner, stop: true };
+  }
+  const relayPr = prReadyForRelayMerge(workspace, preview);
+  if (relayPr.ok) return { mergeCommand: dispatchRelayPrMergeCommand(workspace, preview, orchestratorAgentId, relayPr.policy), stop: true };
+  return {
+    waitReason: preview.strategy === "pr" && relayPr.reason !== "not-pr-strategy" ? relayPr.reason : undefined,
+    stop: isAwaitingReviewerApproval(workspace),
+  };
+}
+
+function dispatchRelayPrMergeCommand(workspace: WorkspaceRecord, preview: WorkspaceMergePreview, orchestratorAgentId: string, policy: WorkspaceAutoMergePolicy): Command {
+  const now = Date.now();
+  const prNumber = preview.prNumber ?? (typeof workspace.metadata.prNumber === "number" ? workspace.metadata.prNumber : undefined);
+  const prUrl = preview.prUrl ?? text(workspace.metadata.prUrl);
+  const command = createCommand({
+    type: "workspace.pr-merge",
+    source: "system",
+    target: orchestratorAgentId,
+    correlationId: workspace.id,
+    params: {
+      action: "pr-merge", workspaceId: workspace.id, repoRoot: workspace.repoRoot, worktreePath: workspace.worktreePath,
+      branch: workspace.branch, baseRef: workspace.baseRef, prNumber, prUrl, policy,
+      requestedBy: "relay-pr-completion", requestedAt: now,
+    },
+  });
+  patchWorkspaceMetadata(workspace.id, {
+    relayMerged: true, relayMergeCommandId: command.id, relayMergeDispatchedAt: now, relayMergePolicy: policy,
+    relayMergeError: undefined, relayMergeFailedAt: undefined,
+  });
+  return command;
+}
+
+function statusChecksGreen(rollup: unknown): boolean {
+  if (!Array.isArray(rollup) || rollup.length === 0) return false;
+  return rollup.every(statusNodeGreen);
+}
+
+function prMergeable(preview: WorkspaceMergePreview): boolean {
+  const mergeable = text(preview.mergeable)?.toUpperCase();
+  if (mergeable !== "MERGEABLE") return false;
+  const state = text(preview.mergeStateStatus)?.toUpperCase();
+  return state ? READY_MERGE_STATES.has(state) : true;
+}
+
+function statusNodeGreen(node: unknown): boolean {
+  if (!isRecord(node)) return false;
+  const conclusion = text(node.conclusion)?.toUpperCase();
+  if (conclusion) return PASSING_CONCLUSIONS.has(conclusion);
+  const state = text(node.state)?.toUpperCase();
+  if (state) return PASSING_STATES.has(state);
+  return false;
+}
+
+function text(value: unknown): string | undefined {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}