agent-relay-server 0.62.3 → 0.63.1

package/runner/src/config.ts

@@ -1,11 +1,26 @@
 import { execFileSync } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir, hostname } from "node:os";
-import { join, resolve } from "node:path";
+import { dirname, join, resolve } from "node:path";
 import { DEFAULT_RELAY_URL, RELAY_TOKEN_HEADER, errMessage, stringValue } from "agent-relay-sdk";
 import type { SettingEntry, WorkspaceMetadata } from "agent-relay-sdk";
 import { sanitizeFsName } from "agent-relay-sdk/fs-name";
-import type { ProviderConfig } from "./adapter";
+
+interface ProviderConfig {
+  command: string;
+  defaultArgs: string[];
+  env: Record<string, string>;
+  pluginDirs: string[];
+  defaultCapabilities: string[];
+  defaultApprovalMode: string;
+  defaultTags: string[];
+  chatCaptureMode: "final" | "full";
+  reasoningCapture?: boolean;
+  headless: {
+    tmuxPrefix: string;
+    shutdownTimeoutMs: number;
+  };
+}
 
 interface GlobalRunnerConfig {
   relayUrl: string;
@@ -17,7 +32,7 @@ interface LoadedProviderConfig extends ProviderConfig {
   path: string;
 }
 
-function agentRelayHome(): string {
+export function agentRelayHome(): string {
   return process.env.AGENT_RELAY_HOME || join(homedir(), ".agent-relay");
 }
 
@@ -48,12 +63,135 @@ export function loadGlobalConfig(home = agentRelayHome()): GlobalRunnerConfig {
   const path = join(home, "config.json");
   const parsed = readJson(path);
   return {
-    relayUrl: stringValue(parsed.relayUrl) ?? process.env.AGENT_RELAY_URL ?? DEFAULT_RELAY_URL,
-    token: stringValue(parsed.token) ?? process.env.AGENT_RELAY_TOKEN,
+    relayUrl: stringValue(parsed.relayUrl) ?? relayUrlFromEnv() ?? DEFAULT_RELAY_URL,
+    token: stringValue(parsed.token) ?? relayTokenFromEnv(),
     defaultCwd: stringValue(parsed.defaultCwd) ?? process.cwd(),
   };
 }
 
+function relayUrlFromEnv(): string | undefined {
+  return process.env.AGENT_RELAY_URL;
+}
+
+export function relayTokenFromEnv(): string | undefined {
+  return process.env.AGENT_RELAY_TOKEN;
+}
+
+export function runtimeTokenProfileFromEnv(): string | undefined {
+  return process.env.AGENT_RELAY_TOKEN_PROFILE;
+}
+
+export function runtimeTokenJtiFromEnv(): string | undefined {
+  return process.env.AGENT_RELAY_TOKEN_JTI;
+}
+
+export function runtimeTokenExpiresAtFromEnv(): string | undefined {
+  return process.env.AGENT_RELAY_TOKEN_EXPIRES_AT;
+}
+
+export function agentProfileNameFromEnv(): string | undefined {
+  return process.env.AGENT_RELAY_AGENT_PROFILE;
+}
+
+export function agentProfileJsonFromEnv(): string | undefined {
+  return process.env.AGENT_RELAY_AGENT_PROFILE_JSON;
+}
+
+export function workspaceJsonFromEnv(): string | undefined {
+  return process.env.AGENT_RELAY_WORKSPACE_JSON;
+}
+
+export function tmuxSessionFromEnv(): string | undefined {
+  return process.env.AGENT_RELAY_TMUX_SESSION;
+}
+
+export function policyNameFromEnv(): string | undefined {
+  return process.env.AGENT_RELAY_POLICY;
+}
+
+export function spawnRequestIdFromEnv(): string | undefined {
+  return process.env.AGENT_RELAY_SPAWN_REQUEST_ID;
+}
+
+export function automationIdFromEnv(): string | undefined {
+  return process.env.AGENT_RELAY_AUTOMATION_ID;
+}
+
+export function automationRunIdFromEnv(): string | undefined {
+  return process.env.AGENT_RELAY_AUTOMATION_RUN_ID;
+}
+
+export function lifecycleFromEnv(): string | undefined {
+  return process.env.AGENT_RELAY_LIFECYCLE;
+}
+
+export function sessionDebugEnabled(): boolean {
+  return process.env.AGENT_RELAY_SESSION_DEBUG === "1";
+}
+
+export function logLevelFromEnv(): string | undefined {
+  return process.env.AGENT_RELAY_LOG_LEVEL;
+}
+
+export function mcpProxyEnabledFromEnv(): boolean {
+  return !["0", "false", "off"].includes((process.env.AGENT_RELAY_MCP_PROXY ?? "").trim().toLowerCase());
+}
+
+export function runnerInfoFileFromEnv(): string | undefined {
+  return process.env.AGENT_RELAY_RUNNER_INFO_FILE;
+}
+
+export function runnerOutboxDirFromEnv(): string | undefined {
+  return process.env.AGENT_RELAY_RUNNER_OUTBOX_DIR;
+}
+
+export function runnerOutboxDirWithInfoFallback(): string | undefined {
+  const dir = runnerOutboxDirFromEnv();
+  if (dir) return dir;
+  const infoFile = runnerInfoFileFromEnv();
+  return infoFile ? join(dirname(infoFile), "outbox") : undefined;
+}
+
+export function capsFromEnv(): string | undefined {
+  return process.env.AGENT_RELAY_CAPS;
+}
+
+export function tagsFromEnv(): string | undefined {
+  return process.env.AGENT_RELAY_TAGS;
+}
+
+export function workspaceModeFromEnv(): string | undefined {
+  return process.env.AGENT_RELAY_WORKSPACE_MODE;
+}
+
+export function orchestratorBaseDirFromEnv(): string | undefined {
+  return process.env.AGENT_RELAY_ORCHESTRATOR_BASE_DIR;
+}
+
+export function runnerLogFileFromEnv(): string | undefined {
+  return typeof process.env.AGENT_RELAY_LOG_FILE === "string" ? process.env.AGENT_RELAY_LOG_FILE : undefined;
+}
+
+export function orchestratorUrlFromEnv(): string | undefined {
+  return process.env.AGENT_RELAY_ORCHESTRATOR_URL;
+}
+
+export function contextStateDirFromEnv(): string | undefined {
+  return process.env.AGENT_RELAY_CONTEXT_STATE_DIR;
+}
+
+export function attachmentCacheDirFromEnv(): string | undefined {
+  return process.env.AGENT_RELAY_ATTACHMENT_CACHE_DIR;
+}
+
+export function providerHomeRootFromEnv(): string {
+  return process.env.AGENT_RELAY_PROVIDER_HOME_ROOT || join(homedir(), ".agent-relay", "provider-homes");
+}
+
+export function messageBodyMaxCharsFromEnv(): string | undefined {
+  return process.env.AGENT_RELAY_MESSAGE_BODY_MAX_CHARS;
+}
+
 export function loadProviderConfig(provider: string, home = agentRelayHome()): LoadedProviderConfig {
   const path = join(providersDir(home), `${provider}.json`);
   const raw = readJson(path);

package/src/agent-ref.ts

@@ -13,6 +13,7 @@
 
 import { STALE_TTL_MS } from "./config";
 import type { AgentCard, Message, TokenConstraints } from "./types";
+import { targetMatchesAgentIdentity } from "agent-relay-sdk/agent-target";
 
 interface ResolveOptions {
   /** Exclude this agent id from matches (e.g. the requester, when pairing). */
@@ -150,12 +151,13 @@ export function resolveAgentRef(ref: string, agents: AgentCard[], opts: ResolveO
 
 export function targetMatchesAgent(target: string, agentId: string, agent?: AgentCard | null): boolean {
   if (!agent) return false;
-  if (target === agentId || target === "broadcast") return true;
-  if (target.startsWith("tag:") && agent.tags.includes(target.slice(4))) return true;
-  if (target.startsWith("cap:") && agent.capabilities.includes(target.slice(4))) return true;
-  if (target.startsWith("label:") && agent.label === target.slice(6)) return true;
-  if (target.startsWith("team:") && agent.teamId === target.slice(5)) return true;
-  return false;
+  return targetMatchesAgentIdentity(target, {
+    id: agentId,
+    label: agent.label,
+    tags: agent.tags,
+    capabilities: agent.capabilities,
+    teamId: agent.teamId,
+  });
 }
 
 export function messageMatchesAgent(msg: Message, agentId: string, agent?: AgentCard | null): boolean {

package/src/artifact-storage.ts

@@ -4,6 +4,7 @@ import { tmpdir } from "node:os";
 import { dirname, join, relative, resolve } from "node:path";
 import { Readable } from "node:stream";
 import { expandTilde } from "./utils";
+import { artifactsDir, maxArtifactBytesFromEnv } from "./config";
 
 interface ArtifactStorageBackend {
   readonly scheme: string;
@@ -20,14 +21,11 @@ interface ArtifactStorageBackend {
 const DEFAULT_MAX_ARTIFACT_BYTES = 50 * 1024 * 1024;
 
 function artifactRoot(): string {
-  return expandTilde(process.env.AGENT_RELAY_ARTIFACTS_DIR || "~/.agent-relay/artifacts");
+  return expandTilde(artifactsDir());
 }
 
 export function maxArtifactBytes(): number {
-  const raw = process.env.AGENT_RELAY_MAX_ARTIFACT_BYTES;
-  if (!raw) return DEFAULT_MAX_ARTIFACT_BYTES;
-  const parsed = Number(raw);
-  return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : DEFAULT_MAX_ARTIFACT_BYTES;
+  return maxArtifactBytesFromEnv(DEFAULT_MAX_ARTIFACT_BYTES);
 }
 
 export function normalizeDigest(digest: string): string {

package/src/automations/constants.ts

@@ -0,0 +1,12 @@
+import type { AutomationCatchUpPolicy, AutomationConcurrencyPolicy, AutomationRunStatus } from "../types";
+
+export const AUTOMATION_KIND = "scheduled_task";
+export const DEFAULT_TIMEZONE = "UTC";
+export const DEFAULT_CATCH_UP: AutomationCatchUpPolicy = "skip";
+export const DEFAULT_CONCURRENCY: AutomationConcurrencyPolicy = "skip";
+export const BLOCKING_RUN_STATUSES = new Set<AutomationRunStatus>(["dispatching", "waiting_agent", "running"]);
+export const OPEN_RUN_STATUSES = new Set<AutomationRunStatus>(["scheduled", "dispatching", "waiting_agent", "running"]);
+export const CLOSED_TASK_STATUS = new Set(["done", "failed", "canceled"]);
+export const MAX_CRON_SCAN_MINUTES = 366 * 24 * 60;
+export const MIN_RUNTIME_BUDGET_MS = 60_000;
+export const MAX_RUNTIME_BUDGET_MS = 24 * 60 * 60 * 1000;

package/src/automations/cron.ts

@@ -0,0 +1,129 @@
+import { ValidationError } from "../db";
+import { MAX_CRON_SCAN_MINUTES } from "./constants";
+
+export function validateCron(expression: string, timezone: string): void {
+  parseCron(expression);
+  localParts(Date.now(), timezone);
+}
+
+export function nextScheduledAt(expression: string, timezone: string, afterMs: number): number {
+  const cron = parseCron(expression);
+  let cursor = Math.floor(afterMs / 60_000) * 60_000 + 60_000;
+  for (let i = 0; i < MAX_CRON_SCAN_MINUTES; i += 1) {
+    const parts = localParts(cursor, timezone);
+    if (cronMatches(cron, parts)) return cursor;
+    cursor += 60_000;
+  }
+  throw new ValidationError("schedule has no matching time in the next year");
+}
+
+interface CronSpec {
+  minute: Set<number>;
+  hour: Set<number>;
+  dayOfMonth: Set<number>;
+  month: Set<number>;
+  dayOfWeek: Set<number>;
+  domAny: boolean;
+  dowAny: boolean;
+}
+
+interface LocalTimeParts {
+  minute: number;
+  hour: number;
+  dayOfMonth: number;
+  month: number;
+  dayOfWeek: number;
+}
+
+function parseCron(expression: string): CronSpec {
+  const parts = expression.trim().split(/\s+/);
+  if (parts.length !== 5) throw new ValidationError("schedule must be a 5-field cron expression");
+  const [minute, hour, dom, month, dow] = parts as [string, string, string, string, string];
+  return {
+    minute: parseCronField(minute, 0, 59, "minute"),
+    hour: parseCronField(hour, 0, 23, "hour"),
+    dayOfMonth: parseCronField(dom, 1, 31, "dayOfMonth"),
+    month: parseCronField(month, 1, 12, "month"),
+    dayOfWeek: parseCronField(dow.replace(/\b7\b/g, "0"), 0, 6, "dayOfWeek"),
+    domAny: dom === "*",
+    dowAny: dow === "*",
+  };
+}
+
+function parseCronField(field: string, min: number, max: number, name: string): Set<number> {
+  const values = new Set<number>();
+  for (const rawPart of field.split(",")) {
+    const part = rawPart.trim();
+    if (!part) throw new ValidationError(`${name} cron field is empty`);
+    const [rangePart, stepRaw] = part.split("/");
+    const step = stepRaw === undefined ? 1 : Number(stepRaw);
+    if (!Number.isInteger(step) || step <= 0) throw new ValidationError(`${name} cron step must be a positive integer`);
+    let start: number;
+    let end: number;
+    if (rangePart === "*") {
+      start = min;
+      end = max;
+    } else if (rangePart?.includes("-")) {
+      const [startRaw, endRaw] = rangePart.split("-");
+      start = Number(startRaw);
+      end = Number(endRaw);
+    } else {
+      start = Number(rangePart);
+      end = start;
+    }
+    if (!Number.isInteger(start) || !Number.isInteger(end) || start < min || end > max || start > end) {
+      throw new ValidationError(`${name} cron field is out of range`);
+    }
+    for (let value = start; value <= end; value += step) values.add(value);
+  }
+  return values;
+}
+
+// Authoritative localized run date for a dispatched automation task (#480). Formats the
+// scheduled instant in the automation's timezone via the same Intl machinery as cron eval, so
+// scheduled output ("today is ...") never depends on a long-lived agent's stale session context.
+export function formatRunDate(timestamp: number, timezone: string): { iso: string; weekday: string; line: string } {
+  const dtf = new Intl.DateTimeFormat("en-US", {
+    timeZone: timezone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    weekday: "long",
+  });
+  const parts = Object.fromEntries(dtf.formatToParts(new Date(timestamp)).map((part) => [part.type, part.value]));
+  const iso = `${parts.year}-${parts.month}-${parts.day}`;
+  const weekday = parts.weekday ?? "";
+  return { iso, weekday, line: `${weekday}, ${iso} (${timezone})` };
+}
+
+function localParts(timestamp: number, timezone: string): LocalTimeParts {
+  const dtf = new Intl.DateTimeFormat("en-US", {
+    timeZone: timezone,
+    minute: "numeric",
+    hour: "numeric",
+    hourCycle: "h23",
+    day: "numeric",
+    month: "numeric",
+    weekday: "short",
+  });
+  const parts = Object.fromEntries(dtf.formatToParts(new Date(timestamp)).map((part) => [part.type, part.value]));
+  const dow = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"].indexOf(parts.weekday ?? "");
+  if (dow < 0) throw new ValidationError(`invalid timezone: ${timezone}`);
+  return {
+    minute: Number(parts.minute),
+    hour: Number(parts.hour),
+    dayOfMonth: Number(parts.day),
+    month: Number(parts.month),
+    dayOfWeek: dow,
+  };
+}
+
+function cronMatches(cron: CronSpec, parts: LocalTimeParts): boolean {
+  if (!cron.minute.has(parts.minute) || !cron.hour.has(parts.hour) || !cron.month.has(parts.month)) return false;
+  const domMatch = cron.dayOfMonth.has(parts.dayOfMonth);
+  const dowMatch = cron.dayOfWeek.has(parts.dayOfWeek);
+  if (cron.domAny && cron.dowAny) return true;
+  if (cron.domAny) return dowMatch;
+  if (cron.dowAny) return domMatch;
+  return domMatch || dowMatch;
+}

package/src/automations/crud.ts

@@ -0,0 +1,84 @@
+import { randomUUID } from "node:crypto";
+import { getOrchestrator, ValidationError } from "../db";
+import { AUTOMATION_KIND } from "./constants";
+import { nextScheduledAt } from "./cron";
+import { db, ensureAutomationTables, getAutomation } from "./storage";
+import { normalizeCreateInput } from "./validation";
+import type { Automation, CreateAutomationInput, UpdateAutomationInput } from "../types";
+
+export function createAutomation(input: CreateAutomationInput, now = Date.now()): Automation {
+  ensureAutomationTables();
+  const normalized = normalizeCreateInput(input);
+  if (!getOrchestrator(normalized.orchestratorId)) throw new ValidationError(`orchestrator ${normalized.orchestratorId} not found`);
+  const id = randomUUID();
+  const nextRunAt = normalized.enabled ? nextScheduledAt(normalized.schedule, normalized.timezone, now) : undefined;
+  db().query(`
+    INSERT INTO automations (id, kind, name, description, enabled, schedule, timezone, next_run_at, catch_up_policy, concurrency_policy, orchestrator_id, target_policy, task_template, created_at, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(
+    id,
+    AUTOMATION_KIND,
+    normalized.name,
+    normalized.description ?? null,
+    normalized.enabled ? 1 : 0,
+    normalized.schedule,
+    normalized.timezone,
+    nextRunAt ?? null,
+    normalized.catchUpPolicy,
+    normalized.concurrencyPolicy,
+    normalized.orchestratorId,
+    JSON.stringify(normalized.targetPolicy),
+    JSON.stringify(normalized.taskTemplate),
+    now,
+    now,
+  );
+  return getAutomation(id)!;
+}
+
+export function updateAutomation(id: string, input: UpdateAutomationInput, now = Date.now()): Automation | null {
+  ensureAutomationTables();
+  const existing = getAutomation(id);
+  if (!existing) return null;
+  const next: CreateAutomationInput = {
+    kind: AUTOMATION_KIND,
+    name: input.name ?? existing.name,
+    description: input.description === null ? undefined : input.description ?? existing.description,
+    enabled: input.enabled ?? existing.enabled,
+    schedule: input.schedule ?? existing.schedule,
+    timezone: input.timezone ?? existing.timezone,
+    catchUpPolicy: input.catchUpPolicy ?? existing.catchUpPolicy,
+    concurrencyPolicy: input.concurrencyPolicy ?? existing.concurrencyPolicy,
+    orchestratorId: input.orchestratorId ?? existing.orchestratorId,
+    targetPolicy: input.targetPolicy ?? existing.targetPolicy,
+    taskTemplate: input.taskTemplate ?? existing.taskTemplate,
+  };
+  const normalized = normalizeCreateInput(next);
+  if (!getOrchestrator(normalized.orchestratorId)) throw new ValidationError(`orchestrator ${normalized.orchestratorId} not found`);
+  const nextRunAt = normalized.enabled ? nextScheduledAt(normalized.schedule, normalized.timezone, now) : undefined;
+  db().query(`
+    UPDATE automations
+    SET name = ?, description = ?, enabled = ?, schedule = ?, timezone = ?, next_run_at = ?,
+        catch_up_policy = ?, concurrency_policy = ?, orchestrator_id = ?, target_policy = ?, task_template = ?, updated_at = ?
+    WHERE id = ?
+  `).run(
+    normalized.name,
+    normalized.description ?? null,
+    normalized.enabled ? 1 : 0,
+    normalized.schedule,
+    normalized.timezone,
+    nextRunAt ?? null,
+    normalized.catchUpPolicy,
+    normalized.concurrencyPolicy,
+    normalized.orchestratorId,
+    JSON.stringify(normalized.targetPolicy),
+    JSON.stringify(normalized.taskTemplate),
+    now,
+    id,
+  );
+  return getAutomation(id)!;
+}
+
+export function deleteAutomation(id: string): boolean {
+  ensureAutomationTables();
+  return db().query("DELETE FROM automations WHERE id = ?").run(id).changes > 0;
+}