agent-relay-server 0.78.8 → 0.79.0

package/src/routes/provider-quotas.ts

@@ -1,5 +1,6 @@
 import { isRecord } from "agent-relay-sdk";
 import { acquireProviderQuotaLease, getOrchestrator, listProviderQuotas, releaseProviderQuotaLease, upsertProviderQuota } from "../db";
+import { emitRelayEvent } from "../events";
 import { quotaStateFromUnknown, providerQuotaErrorFromUnknown } from "../quota";
 import { cleanString } from "../validation";
 import { authorizeRoute, error, json, parseBody, parseQueryInt, type Handler } from "./_shared";
@@ -44,7 +45,9 @@ export const postProviderQuotaRoute: Handler = async (req) => {
   if (!parsed.ok) return error(parsed.error, parsed.status);
   const input = cleanProviderQuotaUpdate(parsed.body);
   if (typeof input === "string") return error(input);
-  return json(upsertProviderQuota(input), 201);
+  const record = upsertProviderQuota(input);
+  emitRelayEvent({ type: "provider-quota.updated", source: "server", subject: `${record.provider}:${record.accountKey}`, data: {} });
+  return json(record, 201);
 };
 
 function cleanLeaseBody(body: unknown): {

package/src/routes/workspaces.ts

@@ -10,7 +10,7 @@ import { createCommand } from "../commands-db";
 import { LAND_STRATEGIES, isOwnerAlive, withOwnerOnline } from "../workspace-merge";
 import { isPathWithinBase } from "../utils";
 import { resolve } from "node:path";
-import { type WorkspaceAutoMergePolicy, type WorkspaceDiagnostics, type WorkspaceGitState, type WorkspaceMergeStrategy, type WorkspaceRecord, type WorkspaceStatus } from "../types";
+import { type WorkspaceAutoMergePolicy, type WorkspaceDiagnostics, type WorkspaceGitState, type WorkspaceMergeStrategy, type WorkspaceRecoveryBranch, type WorkspaceRecord, type WorkspaceStatus } from "../types";
 import { AUTO_MERGE_POLICIES } from "../workspace-merge";
 import { workspaceActiveClaim } from "../workspace-claim";
 import { relayToken } from "../config";
@@ -82,6 +82,149 @@ export const getWorkspaceOrphans: Handler = async () => {
   return json(reason ? { orphans, missingWorktrees, reason } : { orphans, missingWorktrees });
 };
 
+function workspaceCleanupResult(workspace: WorkspaceRecord): Record<string, unknown> | undefined {
+  const result = workspace.metadata.cleanupResult;
+  return isRecord(result) ? result : undefined;
+}
+
+function workspaceBranchKey(repoRoot: string, branch: string): string {
+  return `${repoRoot}\0${branch}`;
+}
+
+function latestWorkspaceByBranch(workspaces: WorkspaceRecord[]): Map<string, WorkspaceRecord> {
+  const byBranch = new Map<string, WorkspaceRecord>();
+  for (const workspace of [...workspaces].sort((a, b) => b.updatedAt - a.updatedAt)) {
+    if (!workspace.branch) continue;
+    const key = workspaceBranchKey(workspace.repoRoot, workspace.branch);
+    if (byBranch.has(key)) continue;
+    byBranch.set(key, workspace);
+  }
+  return byBranch;
+}
+
+function owningOrchestratorForRepo(repoRoot: string) {
+  return listOrchestrators().find((candidate) => candidate.status === "online" && candidate.apiUrl && isPathWithinBase(repoRoot, candidate.baseDir));
+}
+
+async function fetchRecoveryBranchesForRepo(repoRoot: string, opts: { baseRef?: string; baseSha?: string } = {}): Promise<{ branches: WorkspaceRecoveryBranch[]; unavailable?: string }> {
+  const orch = owningOrchestratorForRepo(repoRoot);
+  if (!orch?.apiUrl) return { branches: [], unavailable: "owning orchestrator offline" };
+  const query = new URLSearchParams({ repoRoot });
+  if (opts.baseRef) query.set("baseRef", opts.baseRef);
+  if (opts.baseSha) query.set("baseSha", opts.baseSha);
+  const headers: Record<string, string> = {};
+  const token = relayToken();
+  if (token) headers[RELAY_TOKEN_HEADER] = token;
+  try {
+    const res = await fetch(`${orch.apiUrl}/api/workspace/recovery-branches?${query.toString()}`, { headers, signal: AbortSignal.timeout(10_000) });
+    if (!res.ok) return { branches: [], unavailable: `host returned ${res.status}` };
+    const payload = await res.json() as unknown;
+    if (!isRecord(payload) || !Array.isArray(payload.branches)) return { branches: [], unavailable: "host returned malformed recovery branch list" };
+    return { branches: payload.branches.filter(isRecord) as unknown as WorkspaceRecoveryBranch[] };
+  } catch (e) {
+    return { branches: [], unavailable: `orchestrator unreachable: ${(e as Error).message}` };
+  }
+}
+
+export const getWorkspaceRecoveryBranches: Handler = async (req) => {
+  try {
+    const url = new URL(req.url);
+    const repoRoot = cleanString(url.searchParams.get("repoRoot") ?? undefined, "repoRoot", { max: 1000 });
+    const baseRef = cleanString(url.searchParams.get("baseRef") ?? undefined, "baseRef", { max: 240 });
+    const baseSha = cleanString(url.searchParams.get("baseSha") ?? undefined, "baseSha", { max: 80 });
+    const includeActive = url.searchParams.get("includeActive") === "1";
+    const allWorkspaces = listWorkspaces(repoRoot ? { repoRoot } : {});
+    const repoRoots = repoRoot ? [repoRoot] : [...new Set(allWorkspaces.map((workspace) => workspace.repoRoot))];
+    const byBranch = latestWorkspaceByBranch(allWorkspaces);
+    const branches: WorkspaceRecoveryBranch[] = [];
+    const unavailable: Record<string, string> = {};
+
+    for (const repo of repoRoots) {
+      const fetched = await fetchRecoveryBranchesForRepo(repo, { baseRef, baseSha });
+      if (fetched.unavailable) {
+        unavailable[repo] = fetched.unavailable;
+        continue;
+      }
+      for (const branch of fetched.branches) {
+        const workspace = byBranch.get(workspaceBranchKey(repo, branch.branch));
+        const activeWorkspace = Boolean(workspace && !TERMINAL_WORKSPACE_STATUSES.has(workspace.status));
+        if (activeWorkspace && !includeActive) continue;
+        const owner = workspace?.ownerAgentId ? getAgent(workspace.ownerAgentId) : null;
+        const cleanupResult = workspace ? workspaceCleanupResult(workspace) : undefined;
+        const cleanupPreservedReason = cleanString(cleanupResult?.branchPreservedReason, "branchPreservedReason", { max: 400 });
+        const cleanupCommandId = cleanString(workspace?.metadata.cleanupCommandId, "cleanupCommandId", { max: 160 });
+        branches.push({
+          ...branch,
+          ...(workspace ? { workspaceId: workspace.id } : {}),
+          ...(workspace?.ownerAgentId ? { ownerAgentId: workspace.ownerAgentId } : {}),
+          ...(owner?.status ? { ownerStatus: owner.status } : {}),
+          ...(cleanupCommandId ? { cleanupCommandId } : {}),
+          ...(cleanupPreservedReason ? { cleanupPreservedReason, preservedByCleanup: true } : {}),
+          ...(activeWorkspace ? { activeWorkspace: true } : {}),
+          baseRef: workspace?.baseRef ?? branch.baseRef,
+          baseSha: workspace?.baseSha ?? branch.baseSha,
+        });
+      }
+    }
+
+    branches.sort((a, b) => (b.ageMs ?? 0) - (a.ageMs ?? 0) || a.branch.localeCompare(b.branch));
+    return json({ repoRoot, scannedRepos: repoRoots, branches, ...(Object.keys(unavailable).length ? { unavailable } : {}) });
+  } catch (e) {
+    if (e instanceof ValidationError) return error(e.message, 400);
+    throw e;
+  }
+};
+
+export const postWorkspaceRecoveryBranchDiscard: Handler = async (req) => {
+  const denied = authorizeRoute(req, { scope: "command:write" });
+  if (denied) return denied;
+  const parsed = await parseBody<unknown>(req);
+  if (!parsed.ok) return error(parsed.error, parsed.status);
+  try {
+    if (!isRecord(parsed.body)) return error("body required");
+    const repoRoot = cleanString(parsed.body.repoRoot, "repoRoot", { max: 1000 });
+    const branch = cleanString(parsed.body.branch, "branch", { max: 240 });
+    const baseRef = cleanString(parsed.body.baseRef, "baseRef", { max: 240 });
+    const baseSha = cleanString(parsed.body.baseSha, "baseSha", { max: 80 });
+    const reason = cleanString(parsed.body.reason, "reason", { max: 1000 });
+    const force = parsed.body.force === true;
+    if (!repoRoot || !branch) return error("repoRoot and branch required", 400);
+    if (!branch.startsWith("agent/")) return error("only agent/* branches can be discarded through recovery cleanup", 400);
+    if (force && !reason) return error("reason required for forced recovery branch discard", 400);
+    const orch = owningOrchestratorForRepo(repoRoot);
+    if (!orch?.agentId) return error("no online orchestrator owns this repo", 409);
+    const fetched = await fetchRecoveryBranchesForRepo(repoRoot, { baseRef, baseSha });
+    if (fetched.unavailable) return error(fetched.unavailable, 409);
+    const target = fetched.branches.find((item) => item.branch === branch);
+    if (!target) return error("recovery branch not found", 404);
+    if (target.safeToDelete !== true && !force) {
+      return error(`branch holds work or cannot be proven safe (${target.preserveReason ?? `${target.unmergedAhead ?? target.ahead ?? "?"} unlanded commit(s)`}); land it first or pass force:true with reason to discard`, 409);
+    }
+    const command = createCommand({
+      type: "workspace.recovery-branch-discard",
+      source: "system",
+      target: orch.agentId,
+      correlationId: branch,
+      params: { action: "recovery-branch-discard", repoRoot, branch, baseRef: baseRef ?? target.baseRef, baseSha: baseSha ?? target.baseSha, force, reason, requestedBy: "steward", requestedAt: Date.now() },
+    });
+    emitCommand(command);
+    auditEvent({
+      clientId: `workspace-recovery-branch-discard-${Date.now()}`,
+      kind: "state",
+      title: "Recovery branch discard requested",
+      body: force ? `${branch} — forced discard after review: ${reason}` : `${branch} — confirmed empty/superseded`,
+      meta: repoRoot,
+      icon: "ti-trash",
+      view: "orchestrators",
+      metadata: { repoRoot, branch, commandId: command.id, force, reason, safeToDelete: target.safeToDelete, preserveReason: target.preserveReason, ...authAuditMetadata(req) },
+    });
+    return json({ command, branch: target }, 202);
+  } catch (e) {
+    if (e instanceof ValidationError) return error(e.message, 400);
+    throw e;
+  }
+};
+
 export const postWorkspaceOrphanReclaim: Handler = async (req) => {
   const denied = authorizeRoute(req, { scope: "command:write" });
   if (denied) return denied;