agent-relay-server 0.18.0 → 0.19.1

package/src/daemon.ts

@@ -1,4 +1,5 @@
 import { execFile } from "node:child_process";
+import { shellQuote } from "agent-relay-sdk/shell-utils";
 import { constants, existsSync } from "node:fs";
 import { access, mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
@@ -460,10 +461,6 @@ function quoteSystemdArg(value: string): string {
   return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
 }
 
-function shellQuote(value: string): string {
-  return `'${value.replace(/'/g, "'\\''")}'`;
-}
-
 function xmlEscape(value: string): string {
   return value
     .replace(/&/g, "&")

package/src/db.ts

@@ -5079,14 +5079,21 @@ function upsertWorkspaceFromManagedAgent(agent: ManagedAgent): WorkspaceRecord |
     // preserved and metadata is merged, not replaced.
     const existing = getWorkspace(workspace.id);
     const preserveStatus = existing != null && existing.status !== "active";
+    // The branch (and advanced base) change ONLY via the relay's own land-and-continue
+    // recycle (setWorkspaceBranch repoints to `<branch>-N` and bumps base_sha). The
+    // runner keeps re-reporting its spawn-time branch on every heartbeat, and the
+    // recycle returns status to "active" — so without this the next heartbeat clobbers
+    // the repoint back to the original branch, and the next land targets a deleted
+    // branch and strands the work (vent #62 follow-up). Trust the existing row's
+    // branch/base over registration; only a brand-new row takes the runner's values.
     return upsertWorkspace({
       id: workspace.id,
       repoRoot: workspace.repoRoot,
       sourceCwd: workspace.sourceCwd ?? agent.cwd,
       worktreePath: workspace.worktreePath,
-      branch: workspace.branch,
+      branch: existing?.branch ?? workspace.branch,
       baseRef: workspace.baseRef,
-      baseSha: workspace.baseSha,
+      baseSha: existing?.baseSha ?? workspace.baseSha,
       mode: workspace.mode,
       requestedMode: workspace.requestedMode,
       status: preserveStatus ? existing!.status : (workspace.status ?? "active"),

package/src/dev.ts

@@ -1,4 +1,5 @@
 import { execFile } from "node:child_process";
+import { shellQuote } from "agent-relay-sdk/shell-utils";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { mkdir, rm, writeFile } from "node:fs/promises";
 import { homedir, hostname as osHostname } from "node:os";
@@ -504,7 +505,3 @@ function quote(value: string): string {
   if (/^[A-Za-z0-9_@%+=:,./-]+$/.test(value)) return value;
   return `"${value.replace(/(["\\$`])/g, "\\$1")}"`;
 }
-
-function shellQuote(value: string): string {
-  return `'${value.replace(/'/g, "'\\''")}'`;
-}

package/src/http-body.ts

@@ -0,0 +1,49 @@
+/** Concatenate body chunks into a single contiguous Uint8Array. */
+export function concatBytes(chunks: Uint8Array[]): Uint8Array {
+  const total = chunks.reduce((sum, chunk) => sum + chunk.byteLength, 0);
+  const output = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    output.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return output;
+}
+
+/** Wrap bytes in a single-chunk ReadableStream (e.g. for artifact `storage.store`). */
+export function bytesToStream(bytes: Uint8Array): ReadableStream<Uint8Array> {
+  return new ReadableStream<Uint8Array>({
+    start(controller) {
+      controller.enqueue(bytes);
+      controller.close();
+    },
+  });
+}
+
+/**
+ * Drain a request body stream into a single Uint8Array, enforcing a byte cap.
+ * Returns a 413 result the moment the running total exceeds `maxBytes` (cancels
+ * the reader). Single home for the read-loop that `parseBody` (routes) and
+ * `parseJsonRpcRequest` (mcp) each open-coded — they differed only in the cap.
+ * Callers handle body-absence and decoding.
+ */
+export async function readBodyBytes(
+  body: ReadableStream<Uint8Array>,
+  maxBytes: number,
+): Promise<{ ok: true; bytes: Uint8Array } | { ok: false; status: 413; error: string }> {
+  const reader = body.getReader();
+  const chunks: Uint8Array[] = [];
+  let total = 0;
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    if (!value) continue;
+    total += value.byteLength;
+    if (total > maxBytes) {
+      await reader.cancel().catch(() => {});
+      return { ok: false, status: 413, error: `request body exceeds ${maxBytes} bytes` };
+    }
+    chunks.push(value);
+  }
+  return { ok: true, bytes: concatBytes(chunks) };
+}

package/src/index.ts

@@ -30,6 +30,7 @@ import {
 } from "./security";
 import { handleCli } from "./cli";
 import { startMaintenanceScheduler } from "./maintenance";
+import { errMessage } from "agent-relay-sdk";
 
 async function main(): Promise<void> {
   const result = await handleCli(process.argv.slice(2));
@@ -393,7 +394,7 @@ function staticContentType(pathname: string): string | undefined {
 
 if (import.meta.main) {
   main().catch((error) => {
-    console.error(error instanceof Error ? error.message : String(error));
+    console.error(errMessage(error));
     process.exit(1);
   });
 }

package/src/maintenance.ts

@@ -34,7 +34,7 @@ import {
 import type { WorkspaceMergePreview, WorkspaceRecord, WorkspaceStatus } from "./types";
 import { requestWorkspaceMerge } from "./workspace-merge";
 import { workspaceActiveClaim } from "./workspace-claim";
-import { RELAY_TOKEN_HEADER } from "agent-relay-sdk";
+import { errMessage, RELAY_TOKEN_HEADER } from "agent-relay-sdk";
 import { getStewardConfig } from "./config-store";
 import { ensureRepoSteward } from "./steward";
 import { emitRelayEvent } from "./events";
@@ -931,7 +931,7 @@ async function runDueMaintenanceJobs(): Promise<void> {
   for (const row of rows) {
     const definition = definitions.find((job) => job.id === row.id);
     if (definition) void runJob(definition).catch((error) => {
-      console.warn(`maintenance job ${definition.id} failed: ${error instanceof Error ? error.message : String(error)}`);
+      console.warn(`maintenance job ${definition.id} failed: ${errMessage(error)}`);
     });
   }
 }
@@ -999,7 +999,7 @@ async function runJob(definition: MaintenanceJobDefinition, options: { force?: b
   } catch (error) {
     const finishedAt = Date.now();
     const durationMs = finishedAt - startedAt;
-    const message = error instanceof Error ? error.message : String(error);
+    const message = errMessage(error);
     db.query(`
       UPDATE maintenance_jobs
       SET last_run_at = ?, next_run_at = ?, last_duration_ms = ?, last_status = 'failed',

package/src/mcp.ts

@@ -3,6 +3,9 @@ import { getArtifactStorage, maxArtifactBytes, normalizeDigest } from "./artifac
 import { createCommand } from "./commands-db";
 import { buildSpawnCommand, generateSpawnRequestId, resolveSpawnModelParams, type SpawnModelParams } from "./spawn-command";
 import { isPathWithinBase } from "./utils";
+import { optionalEnum } from "./validation";
+import { listManagedOrchestratorsForAgent } from "./orchestrator-lookup";
+import { bytesToStream, readBodyBytes } from "./http-body";
 import { MAX_BODY_BYTES, VERSION } from "./config";
 import { getManagedAgentState, getSpawnPolicy, listSpawnPolicies } from "./config-store";
 import {
@@ -34,7 +37,7 @@ import {
 } from "./security";
 import type { ActivityKind, AgentCard, ArtifactKind, ArtifactSensitivity, AttachmentRef, Command, SendMessageInput, Message, SpawnApprovalMode, SpawnProvider } from "./types";
 import { type ProviderEffort } from "agent-relay-sdk/provider-catalog";
-import { isRecord, SPAWN_PROVIDERS, APPROVAL_MODES, VALID_EFFORTS } from "agent-relay-sdk";
+import { errMessage, isRecord, SPAWN_PROVIDERS, APPROVAL_MODES, VALID_EFFORTS } from "agent-relay-sdk";
 import { childRunnerRuntimeTokenEnv, runnerRuntimeTokenEnv } from "./runtime-tokens";
 
 type JsonRpcId = string | number | null;
@@ -272,7 +275,7 @@ export async function postMcp(req: Request): Promise<Response> {
     }
     return Response.json(jsonRpcError(id, -32601, `unknown MCP method: ${method}`));
   } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
+    const message = errMessage(error);
     const status = error instanceof McpAuthError ? 403 : error instanceof McpNotFoundError ? 404 : 400;
     const code = error instanceof McpAuthError ? -32001 : error instanceof McpNotFoundError ? -32004 : -32602;
     return Response.json(jsonRpcError(id, code, message, { status }));
@@ -284,23 +287,11 @@ async function parseJsonRpcRequest(req: Request): Promise<
   | { ok: false; status: number; error: string }
 > {
   if (!req.body) return { ok: false, status: 400, error: "JSON-RPC body required" };
-  const reader = req.body.getReader();
-  const chunks: Uint8Array[] = [];
-  let total = 0;
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done) break;
-    if (!value) continue;
-    total += value.byteLength;
-    const maxBodyBytes = Math.max(MAX_BODY_BYTES, maxArtifactBytes() + MCP_BODY_OVERHEAD_BYTES);
-    if (total > maxBodyBytes) {
-      await reader.cancel().catch(() => {});
-      return { ok: false, status: 413, error: `request body exceeds ${maxBodyBytes} bytes` };
-    }
-    chunks.push(value);
-  }
+  const maxBodyBytes = Math.max(MAX_BODY_BYTES, maxArtifactBytes() + MCP_BODY_OVERHEAD_BYTES);
+  const read = await readBodyBytes(req.body, maxBodyBytes);
+  if (!read.ok) return read;
   try {
-    const body = JSON.parse(new TextDecoder().decode(concatBytes(chunks))) as unknown;
+    const body = JSON.parse(new TextDecoder().decode(read.bytes)) as unknown;
     if (!isRecord(body)) return { ok: false, status: 400, error: "JSON-RPC body must be an object" };
     return { ok: true, request: body as JsonRpcRequest };
   } catch {
@@ -308,17 +299,6 @@ async function parseJsonRpcRequest(req: Request): Promise<
   }
 }
 
-function concatBytes(chunks: Uint8Array[]): Uint8Array {
-  const total = chunks.reduce((sum, chunk) => sum + chunk.byteLength, 0);
-  const output = new Uint8Array(total);
-  let offset = 0;
-  for (const chunk of chunks) {
-    output.set(chunk, offset);
-    offset += chunk.byteLength;
-  }
-  return output;
-}
-
 function mcpAuthContext(req: Request): McpAuthContext {
   const component = getComponentAuth(req);
   if (component) return { actor: component.sub, kind: "component", scopes: component.scope, component };
@@ -354,7 +334,7 @@ async function callTool(auth: McpAuthContext, params: unknown): Promise<Record<s
     auditToolCall(auth, name, "ok", result);
     return toolResult(result);
   } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
+    const message = errMessage(error);
     auditToolCall(auth, name, error instanceof McpAuthError ? "denied" : "error", undefined, message);
     throw error;
   }
@@ -732,7 +712,7 @@ function selectControlOrchestrator(input: {
     return orchestrator;
   }
   const agent = input.agentId ? getAgent(input.agentId) : null;
-  const orchestrator = agent ? managedControlOrchestrator(agent, input) : findManagedOrchestrator(input);
+  const orchestrator = agent ? managedControlOrchestrator(agent, input) : (listManagedOrchestratorsForAgent(input)[0] ?? null);
   if (!orchestrator) throw new McpNotFoundError("no orchestrator found for agent control target");
   if (orchestrator.status !== "online") throw new ValidationError("orchestrator is offline");
   return orchestrator;
@@ -742,29 +722,13 @@ function managedControlOrchestrator(
   agent: AgentCard,
   input: { policyName?: string; spawnRequestId?: string; tmuxSession?: string },
 ): NonNullable<ReturnType<typeof getOrchestrator>> | null {
-  const metaTmuxSession = typeof agent.meta?.tmuxSession === "string" ? agent.meta.tmuxSession : "";
-  const metaPolicyName = input.policyName ?? (typeof agent.meta?.policyName === "string" ? agent.meta.policyName : "");
-  const metaSpawnRequestId = input.spawnRequestId ?? (typeof agent.meta?.spawnRequestId === "string" ? agent.meta.spawnRequestId : "");
-  return findManagedOrchestrator({
+  const str = (v: unknown): string | undefined => (typeof v === "string" ? v : undefined);
+  return listManagedOrchestratorsForAgent({
     agentId: agent.id,
-    policyName: metaPolicyName,
-    spawnRequestId: metaSpawnRequestId,
-    tmuxSession: input.tmuxSession ?? metaTmuxSession,
-  }) ?? (agent.machine ? getOrchestrator(agent.machine) : null);
-}
-
-function findManagedOrchestrator(input: {
-  agentId?: string;
-  policyName?: string;
-  spawnRequestId?: string;
-  tmuxSession?: string;
-}): NonNullable<ReturnType<typeof getOrchestrator>> | null {
-  return listOrchestrators().find((orchestrator) => orchestrator.managedAgents.some((managed) =>
-    (!!input.agentId && managed.agentId === input.agentId) ||
-    (!!input.tmuxSession && managed.tmuxSession === input.tmuxSession) ||
-    (!!input.policyName && managed.policyName === input.policyName) ||
-    (!!input.spawnRequestId && managed.spawnRequestId === input.spawnRequestId)
-  )) ?? null;
+    policyName: input.policyName ?? str(agent.meta?.policyName),
+    spawnRequestId: input.spawnRequestId ?? str(agent.meta?.spawnRequestId),
+    tmuxSession: input.tmuxSession ?? str(agent.meta?.tmuxSession),
+  })[0] ?? (agent.machine ? getOrchestrator(agent.machine) : null);
 }
 
 function providerSelection(provider: SpawnProvider, args: Record<string, unknown>): SpawnModelParams {
@@ -773,15 +737,6 @@ function providerSelection(provider: SpawnProvider, args: Record<string, unknown
   return resolveSpawnModelParams(provider, model, effort);
 }
 
-function bytesToStream(bytes: Uint8Array): ReadableStream<Uint8Array> {
-  return new ReadableStream<Uint8Array>({
-    start(controller) {
-      controller.enqueue(bytes);
-      controller.close();
-    },
-  });
-}
-
 function artifactBytes(args: Record<string, unknown>): Uint8Array {
   const hasContent = args.content !== undefined && args.content !== null;
   const hasBase64 = args.base64 !== undefined && args.base64 !== null;
@@ -956,12 +911,6 @@ function optionalBoolean(value: unknown, field: string): boolean | undefined {
   return value;
 }
 
-function optionalEnum<T extends readonly string[]>(value: unknown, field: string, valid: T): T[number] | undefined {
-  if (value === undefined || value === null) return undefined;
-  if (typeof value !== "string" || !valid.includes(value as T[number])) throw new ValidationError(`${field} must be one of: ${valid.join(", ")}`);
-  return value as T[number];
-}
-
 function enumField<T extends readonly string[]>(value: unknown, field: string, valid: T): T[number] {
   const cleaned = optionalEnum(value, field, valid);
   if (!cleaned) throw new ValidationError(`${field} required`);

package/src/memory-broker-smoke.ts

@@ -1,4 +1,4 @@
-import { RELAY_TOKEN_HEADER } from "agent-relay-sdk";
+import { errMessage, RELAY_TOKEN_HEADER } from "agent-relay-sdk";
 
 interface MemoryBrokerSmokeOptions {
   baseUrl?: string;
@@ -137,7 +137,7 @@ async function step<T>(steps: MemoryBrokerSmokeStep[], name: string, detail: str
     steps.push({ name, ok: true, detail });
     return result;
   } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
+    const message = errMessage(error);
     steps.push({ name, ok: false, detail: message });
     throw error;
   }

package/src/memory-command-broker.ts

@@ -20,7 +20,7 @@ import {
   normalizeMemorySearchResult,
 } from "./memory-broker-contract";
 import { normalizeContextPackage } from "./memory-http-broker";
-import { isRecord } from "agent-relay-sdk";
+import { errMessage, isRecord } from "agent-relay-sdk";
 
 const DEFAULT_TIMEOUT_MS = 10_000;
 
@@ -105,7 +105,7 @@ export class CommandMemoryBroker implements MemoryBroker {
       return unwrapResult(parseJson(stdout, operation));
     } catch (error) {
       if (error instanceof MemoryBrokerContractError) throw error;
-      throw new MemoryBrokerContractError(`command memory broker ${operation} failed: ${error instanceof Error ? error.message : String(error)}`);
+      throw new MemoryBrokerContractError(`command memory broker ${operation} failed: ${errMessage(error)}`);
     } finally {
       clearTimeout(timer);
     }

package/src/memory-http-broker.ts

@@ -19,7 +19,7 @@ import {
   normalizeMemoryBrokerCapabilities,
   normalizeMemorySearchResult,
 } from "./memory-broker-contract";
-import { isRecord } from "agent-relay-sdk";
+import { errMessage, isRecord } from "agent-relay-sdk";
 
 const DEFAULT_TIMEOUT_MS = 10_000;
 
@@ -99,7 +99,7 @@ export class HttpMemoryBroker implements MemoryBroker {
       if (error instanceof DOMException && error.name === "AbortError") {
         throw new MemoryBrokerContractError(`http memory broker ${operation} timed out after ${this.timeoutMs}ms`);
       }
-      throw new MemoryBrokerContractError(`http memory broker ${operation} failed: ${error instanceof Error ? error.message : String(error)}`);
+      throw new MemoryBrokerContractError(`http memory broker ${operation} failed: ${errMessage(error)}`);
     } finally {
       clearTimeout(timer);
     }

package/src/orchestrator-lookup.ts

@@ -0,0 +1,29 @@
+import { listOrchestrators } from "./db";
+
+export interface ManagedAgentMatch {
+  agentId?: string;
+  sessionName?: string;
+  tmuxSession?: string;
+  policyName?: string;
+  spawnRequestId?: string;
+}
+
+/**
+ * Every orchestrator that owns a managed agent matching ANY provided identity
+ * key. Single home for the managed-agent→orchestrator lookup that routes.ts and
+ * mcp.ts each open-coded. routes also matches `sessionName`; mcp never passed it,
+ * so leaving the key undefined reproduces mcp's behavior exactly. Callers layer
+ * their own online / runner-managed / machine-fallback policy on top — routes
+ * picks the first online candidate, mcp takes the first match.
+ */
+export function listManagedOrchestratorsForAgent(match: ManagedAgentMatch): ReturnType<typeof listOrchestrators> {
+  return listOrchestrators().filter((orch) =>
+    orch.managedAgents.some((managed) =>
+      (!!match.agentId && managed.agentId === match.agentId) ||
+      (!!match.sessionName && managed.sessionName === match.sessionName) ||
+      (!!match.tmuxSession && managed.tmuxSession === match.tmuxSession) ||
+      (!!match.policyName && managed.policyName === match.policyName) ||
+      (!!match.spawnRequestId && managed.spawnRequestId === match.spawnRequestId),
+    ),
+  );
+}

package/src/recipe-validator.ts

@@ -1,6 +1,6 @@
 import type { MemoryType, Recipe, RecipeAgent, RecipeMemoryPolicy } from "./types";
 import { resolveProviderSelection, type ProviderEffort } from "agent-relay-sdk/provider-catalog";
-import { isRecord } from "agent-relay-sdk";
+import { errMessage, isRecord } from "agent-relay-sdk";
 
 class RecipeValidationError extends Error {}
 
@@ -52,7 +52,7 @@ function validateAgent(value: unknown): RecipeAgent {
   try {
     resolveProviderSelection({ provider, model, effort });
   } catch (error) {
-    throw new RecipeValidationError(error instanceof Error ? error.message : String(error));
+    throw new RecipeValidationError(errMessage(error));
   }
   return {
     role: requiredString(value.role, "agent.role"),