agent-relay-server 0.32.2 → 0.32.3

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;
+  });
+}