agent-relay-server 0.32.2 → 0.32.4

package/src/validation.ts

@@ -1,4 +1,6 @@
 import { ValidationError } from "./db";
+import { type TokenConstraints, type WorkspaceMetadata, type WorkspaceMode, type WorkspaceProbe, type WorkspaceStatus } from "./types";
+import { VALID_WORKSPACE_MODES, isRecord } from "agent-relay-sdk";
 
 /**
  * Trim + validate an optional string input. Throws `ValidationError` when the
@@ -78,3 +80,135 @@ export function cleanStringArray(
   }
   return [...new Set(cleaned)];
 }
+
+// ---- generic validators relocated from routes.ts (#299) ----
+export const VALID_WORKSPACE_STATUSES = ["active", "ready", "conflict", "review_requested", "merge_planned", "merged", "abandoned", "cleanup_requested", "cleaned"] as const;
+
+export function cleanNullableString(value: unknown, field: string, max: number): string | null | undefined {
+  if (value === undefined) return undefined;
+  if (value === null) return null;
+  return cleanString(value, field, { max }) ?? null;
+}
+
+function cleanConstraintStringArray(value: unknown, field: string): string[] | undefined {
+  if (value === undefined || value === null) return undefined;
+  if (!Array.isArray(value)) throw new ValidationError(`${field} must be an array of strings`);
+  const cleaned = value.map((item) => cleanString(item, `${field} item`, { max: 500 })).filter(Boolean) as string[];
+  if (cleaned.length > 100) throw new ValidationError(`${field} can contain at most 100 values`);
+  return [...new Set(cleaned)];
+}
+
+export function cleanTokenConstraints(value: unknown): TokenConstraints | undefined {
+  if (value === undefined || value === null) return undefined;
+  if (!isRecord(value)) throw new ValidationError("constraints must be an object");
+  const constraints: TokenConstraints = {};
+  const arrayKeys = [
+    "agents",
+    "policies",
+    "parentAgents",
+    "targets",
+    "channels",
+    "orchestrators",
+    "hosts",
+    "cwdPrefixes",
+    "taskIds",
+    "memoryScopes",
+    "integrationNames",
+    "spawnRequestIds",
+  ] as const;
+  for (const key of arrayKeys) {
+    const cleaned = cleanConstraintStringArray(value[key], `constraints.${key}`);
+    if (cleaned?.length) constraints[key] = cleaned;
+  }
+  const cwd = cleanString(value.cwd, "constraints.cwd", { max: 500 });
+  if (cwd) constraints.cwd = cwd;
+  for (const key of ["terminalAttach", "logsRead", "canDelegate"] as const) {
+    if (value[key] !== undefined) {
+      if (typeof value[key] !== "boolean") throw new ValidationError(`constraints.${key} must be a boolean`);
+      constraints[key] = value[key];
+    }
+  }
+  return constraints;
+}
+
+export function cleanMeta(value: unknown): Record<string, unknown> | undefined {
+  if (value === undefined || value === null) return undefined;
+  if (!isRecord(value)) throw new ValidationError("meta must be an object");
+  if (JSON.stringify(value).length > 8192) throw new ValidationError("meta is too large");
+  return value;
+}
+
+export function cleanParams(value: unknown, field = "params"): Record<string, unknown> | undefined {
+  if (value === undefined || value === null) return undefined;
+  if (!isRecord(value)) throw new ValidationError(`${field} must be an object`);
+  if (JSON.stringify(value).length > 65_536) throw new ValidationError(`${field} is too large`);
+  return value;
+}
+
+export function cleanWorkspaceMetadata(value: unknown, field: string): WorkspaceMetadata | undefined {
+  if (value === undefined || value === null) return undefined;
+  if (!isRecord(value)) throw new ValidationError(`${field} must be an object`);
+  return {
+    id: cleanString(value.id, `${field}.id`, { max: 160 }),
+    mode: optionalEnum(value.mode, `${field}.mode`, VALID_WORKSPACE_MODES, "shared") as WorkspaceMode,
+    requestedMode: optionalEnum(value.requestedMode, `${field}.requestedMode`, VALID_WORKSPACE_MODES) as WorkspaceMode | undefined,
+    repoRoot: cleanString(value.repoRoot, `${field}.repoRoot`, { max: 1000 }),
+    sourceCwd: cleanString(value.sourceCwd, `${field}.sourceCwd`, { max: 1000 }),
+    worktreePath: cleanString(value.worktreePath, `${field}.worktreePath`, { max: 1000 }),
+    branch: cleanString(value.branch, `${field}.branch`, { max: 240 }),
+    baseRef: cleanString(value.baseRef, `${field}.baseRef`, { max: 240 }),
+    baseSha: cleanString(value.baseSha, `${field}.baseSha`, { max: 80 }),
+    status: optionalEnum(value.status, `${field}.status`, VALID_WORKSPACE_STATUSES) as WorkspaceStatus | undefined,
+    stewardAgentId: cleanString(value.stewardAgentId, `${field}.stewardAgentId`, { max: 240 }),
+    probe: isRecord(value.probe) ? value.probe as unknown as WorkspaceProbe : undefined,
+  };
+}
+
+export function cleanPositiveId(value: unknown, field: string): number | undefined {
+  if (value === undefined || value === null) return undefined;
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0) {
+    throw new ValidationError(`${field} must be a positive integer`);
+  }
+  return value;
+}
+
+export function cleanNullablePositiveId(value: unknown, field: string): number | null | undefined {
+  if (value === undefined) return undefined;
+  if (value === null) return null;
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0) {
+    throw new ValidationError(`${field} must be a positive integer or null`);
+  }
+  return value;
+}
+
+export function cleanEpoch(value: unknown, field: string): number | undefined {
+  if (value === undefined || value === null) return undefined;
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+    throw new ValidationError(`${field} must be a non-negative integer`);
+  }
+  return value;
+}
+
+export function cleanTtlMs(value: unknown): number | undefined {
+  if (value === undefined || value === null) return undefined;
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0) {
+    throw new ValidationError("ttlMs must be a positive integer");
+  }
+  return value;
+}
+
+export function cleanOperatorId(value: unknown): string {
+  return cleanString(value, "operatorId", { max: 200 }) || "user";
+}
+
+export function cleanPositiveIdArray(value: unknown, field: string, max = 500): number[] {
+  if (!Array.isArray(value)) throw new ValidationError(`${field} must be an array`);
+  if (value.length === 0) throw new ValidationError(`${field} required`);
+  if (value.length > max) throw new ValidationError(`${field} max ${max}`);
+  return value.map((item, index) => {
+    if (typeof item !== "number" || !Number.isSafeInteger(item) || item <= 0) {
+      throw new ValidationError(`${field}[${index}] must be a positive integer`);
+    }
+    return item;
+  });
+}

package/src/workspace-actions.ts

@@ -20,6 +20,9 @@ import {
 } from "./db";
 import { emitActivityEvent } from "./sse";
 import { isOwnerAlive, requestWorkspaceMerge } from "./workspace-merge";
+// Re-export the land-strategy contract so the MCP land tool validates against the same
+// tuple as the HTTP route without a second import hop (one source: workspace-merge, #304).
+export { LAND_STRATEGIES, DEFAULT_MERGE_STRATEGY } from "./workspace-merge";
 import { claimMetadataPatch, workspaceActiveClaim } from "./workspace-claim";
 import { TERMINAL_WORKSPACE_STATUSES } from "./workspace-phase";
 import type { Command, WorkspaceMergeStrategy, WorkspaceRecord, WorkspaceStatus } from "./types";
@@ -161,7 +164,10 @@ export function applyWorkspaceAction(workspace: WorkspaceRecord, input: ApplyWor
   if (action === "merge") {
     const result = requestWorkspaceMerge(workspace, {
       requestedBy: agentId ?? "dashboard",
-      strategy: input.strategy ?? "auto",
+      // Pass the strategy through verbatim (undefined when unset) — the single
+      // default lives in requestWorkspaceMerge, so both land surfaces resolve it
+      // identically instead of each applying its own fallback (#304).
+      strategy: input.strategy,
       deleteBranch: input.deleteBranch !== false,
       prTitle: input.prTitle,
       prBody: input.prBody,

package/src/workspace-merge.ts

@@ -10,6 +10,17 @@ import {
 import type { Command, WorkspaceMergeStrategy, WorkspaceRecord } from "./types";
 import { isPathWithinBase } from "./utils";
 
+// One home for the land-strategy contract, shared by BOTH land surfaces — the HTTP
+// route (`POST /api/workspaces/:id/actions`, driven by `agent-relay workspace land`)
+// and the `relay_workspace_land` MCP tool. They validate against the same tuple and
+// fall back to the same default, so the effective strategy can't drift by surface
+// (#304: the CLI used to omit the strategy and let the server default while MCP
+// passed its own — two encodings of one rule). The default is applied ONCE, in
+// `requestWorkspaceMerge` below; callers pass `strategy` through verbatim (undefined
+// when unset) so there is a single resolution point, not one per entrypoint.
+export const LAND_STRATEGIES = ["pr", "rebase-ff", "auto"] as const;
+export const DEFAULT_MERGE_STRATEGY: WorkspaceMergeStrategy = "auto";
+
 interface RequestWorkspaceMergeOptions {
   /** Who asked for the merge (lease holder + audit). e.g. an agent id, "dashboard", "auto-merge". */
   requestedBy: string;
@@ -103,7 +114,7 @@ export function requestWorkspaceMerge(workspace: WorkspaceRecord, opts: RequestW
         branch: workspace.branch,
         baseRef: workspace.baseRef,
         baseSha: workspace.baseSha,
-        strategy: opts.strategy ?? "auto",
+        strategy: opts.strategy ?? DEFAULT_MERGE_STRATEGY,
         deleteBranch,
         push: opts.push !== false,
         prTitle: opts.prTitle,