agent-relay-server 0.122.0 → 0.123.0

package/runner/src/index.ts

@@ -0,0 +1,396 @@
+#!/usr/bin/env bun
+import { hostname } from "node:os";
+import { basename } from "node:path";
+import { isatty } from "node:tty";
+import { AgentRunner } from "./runner";
+import {
+  agentProfileJsonFromEnv,
+  agentProfileNameFromEnv,
+  automationIdFromEnv,
+  automationRunIdFromEnv,
+  lifecycleFromEnv,
+  loadGlobalConfig,
+  loadProviderConfigFromRelay,
+  policyNameFromEnv,
+  promptFromEnv,
+  relayInjectionEventsJsonFromEnv,
+  resolveCwd,
+  runnerId,
+  runtimeTokenExpiresAtFromEnv,
+  runtimeTokenJtiFromEnv,
+  runtimeTokenProfileFromEnv,
+  spawnRequestIdFromEnv,
+  systemPromptAppendFromEnv,
+  taskIdFromEnv,
+  tmuxSessionFromEnv,
+  workspaceJsonFromEnv,
+} from "./config";
+import { createProviderAdapter } from "./providers";
+import { VERSION } from "./version";
+import type { AgentProfile, RelayInjectionCategory, SpawnProvider, WorkspaceMetadata } from "agent-relay-sdk";
+import { errMessage, isRecord, normalizeAgentLifecycle, RELAY_TOKEN_HEADER } from "agent-relay-sdk";
+import { getAllManifests } from "agent-relay-providers";
+import type { RunnerRelayInjectionEvent } from "./relay-injection-events";
+
+interface CliOptions {
+  provider: SpawnProvider;
+  model?: string;
+  effort?: string;
+  headless: boolean;
+  interactive: boolean;
+  cwd?: string;
+  rig?: string;
+  profile?: string;
+  relayUrl?: string;
+  token?: string;
+  approvalMode?: string;
+  label?: string;
+  agentId?: string;
+  prompt?: string;
+  systemPromptAppend?: string;
+  relayInjectionEvents?: RunnerRelayInjectionEvent[];
+  tags: string[];
+  caps: string[];
+  providerArgs: string[];
+}
+
+export async function main(argv = process.argv): Promise<void> {
+  if (isVersionRequest(argv)) {
+    console.log(VERSION);
+    return;
+  }
+  const opts = parseArgs(argv);
+  const globalConfig = loadGlobalConfig();
+  const relayUrl = opts.relayUrl ?? globalConfig.relayUrl;
+  const providerConfig = await loadProviderConfigFromRelay(opts.provider, {
+    relayUrl,
+    token: opts.token ?? globalConfig.token,
+  });
+  const cwd = resolveCwd(opts.cwd, globalConfig.defaultCwd);
+  const id = runnerId(opts.provider, cwd, opts.label);
+  const adapter = createProviderAdapter(opts.provider);
+  const runtimeAuth = await resolveRunnerToken({
+    interactive: opts.interactive,
+    relayUrl,
+    token: opts.token ?? globalConfig.token,
+    runtimeTokenProfile: runtimeTokenProfileFromEnv(),
+    runtimeTokenJti: runtimeTokenJtiFromEnv(),
+    runtimeTokenExpiresAt: parseTokenExpiresAt(runtimeTokenExpiresAtFromEnv()),
+    provider: opts.provider,
+    cwd,
+    runnerId: id,
+    agentId: opts.agentId ?? id,
+    label: opts.label,
+  });
+
+  let exitResolve: (code: number) => void;
+  const exitPromise = new Promise<number>((resolve) => { exitResolve = resolve; });
+
+  const approvalMode = opts.approvalMode
+    ?? detectApprovalModeFromArgs(opts.provider, providerConfig.defaultArgs, opts.providerArgs)
+    ?? providerConfig.defaultApprovalMode;
+
+  const runner = new AgentRunner({
+    provider: opts.provider,
+    model: opts.model,
+    effort: opts.effort,
+    runnerId: id,
+    instanceId: crypto.randomUUID(),
+    agentId: opts.agentId,
+    relayUrl,
+    token: runtimeAuth.token,
+    tokenJti: runtimeAuth.jti,
+    tokenProfileId: runtimeAuth.profileId,
+    tokenExpiresAt: runtimeAuth.expiresAt,
+    rootTokenFallback: runtimeAuth.rootFallback,
+    cwd,
+    headless: opts.headless,
+    approvalMode,
+    label: opts.label,
+    rig: opts.rig,
+    profile: opts.profile ?? agentProfileNameFromEnv(),
+    agentProfile: parseAgentProfileEnv(agentProfileJsonFromEnv()),
+    workspace: parseWorkspaceEnv(workspaceJsonFromEnv()),
+    prompt: opts.prompt ?? promptFromEnv(),
+    systemPromptAppend: opts.systemPromptAppend ?? systemPromptAppendFromEnv(),
+    relayInjectionEvents: parseRelayInjectionEventsEnv(relayInjectionEventsJsonFromEnv()),
+    tmuxSession: tmuxSessionFromEnv(),
+    tags: opts.tags,
+    capabilities: opts.caps,
+    providerArgs: opts.providerArgs,
+    policyName: policyNameFromEnv(),
+    spawnRequestId: spawnRequestIdFromEnv(),
+    taskId: taskIdFromEnv(),
+    automationId: automationIdFromEnv(),
+    automationRunId: automationRunIdFromEnv(),
+    lifecycle: normalizeAgentLifecycle(lifecycleFromEnv()) ?? "persistent",
+    startedAt: Date.now(),
+    providerConfig,
+    adapter,
+    onProviderExit: (code) => exitResolve(code ?? 1),
+  });
+  await runner.run();
+
+  const code = await Promise.race([exitPromise, signalPromise()]);
+  await runner.stop();
+  process.exit(code);
+}
+
+export async function resolveRunnerToken(input: {
+  interactive: boolean;
+  relayUrl: string;
+  token?: string;
+  runtimeTokenProfile?: string;
+  runtimeTokenJti?: string;
+  runtimeTokenExpiresAt?: number;
+  provider: string;
+  cwd: string;
+  runnerId: string;
+  agentId: string;
+  label?: string;
+}): Promise<{ token?: string; jti?: string; profileId?: string; expiresAt?: number; rootFallback?: boolean }> {
+  if (!input.token) return {};
+  const claims = decodeComponentTokenClaims(input.token);
+  if (input.runtimeTokenProfile) {
+    return {
+      token: input.token,
+      jti: input.runtimeTokenJti ?? claims?.jti,
+      profileId: input.runtimeTokenProfile,
+      expiresAt: input.runtimeTokenExpiresAt ?? claims?.exp,
+    };
+  }
+  const inferredRuntime = inferRuntimeTokenMetadata(claims);
+  if (!input.interactive && inferredRuntime) return { token: input.token, ...inferredRuntime };
+  if (!input.interactive) return { token: input.token };
+
+  try {
+    const url = new URL("/api/runtime-tokens/interactive-runner", input.relayUrl);
+    const res = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        [RELAY_TOKEN_HEADER]: input.token,
+      },
+      body: JSON.stringify({
+        provider: input.provider,
+        cwd: input.cwd,
+        runnerId: input.runnerId,
+        agentId: input.agentId,
+        label: input.label,
+        host: hostname(),
+      }),
+      signal: AbortSignal.timeout(5_000),
+    });
+    const body = await res.json().catch(() => null) as { token?: string; record?: { jti?: string; profileId?: string; expiresAt?: number }; error?: string } | null;
+    if (res.ok && body?.token) return { token: body.token, jti: body.record?.jti, profileId: body.record?.profileId ?? "provider-interactive", expiresAt: body.record?.expiresAt };
+    const detail = body?.error ? `: ${body.error}` : "";
+    console.warn(`[agent-relay] interactive scoped-token exchange failed (${res.status}${detail}); continuing with existing token. Root-token runtime fallback is deprecated.`);
+  } catch (error) {
+    console.warn(`[agent-relay] interactive scoped-token exchange failed (${errMessage(error)}); continuing with existing token. Root-token runtime fallback is deprecated.`);
+  }
+  return { token: input.token, rootFallback: true };
+}
+
+function decodeComponentTokenClaims(token: string | undefined): { sub?: string; role?: string; exp?: number; jti?: string } | undefined {
+  const payload = token?.split(".")[1];
+  if (!payload) return undefined;
+  try {
+    const normalized = payload.replace(/-/g, "+").replace(/_/g, "/");
+    const decoded = JSON.parse(Buffer.from(normalized, "base64").toString("utf8")) as Record<string, unknown>;
+    const exp = typeof decoded.exp === "number" && Number.isSafeInteger(decoded.exp) && decoded.exp > 0 ? decoded.exp : undefined;
+    return {
+      ...(typeof decoded.sub === "string" ? { sub: decoded.sub } : {}),
+      ...(typeof decoded.role === "string" ? { role: decoded.role } : {}),
+      ...(typeof decoded.jti === "string" ? { jti: decoded.jti } : {}),
+      ...(exp ? { exp } : {}),
+    };
+  } catch {
+    return undefined;
+  }
+}
+
+function inferRuntimeTokenMetadata(claims: { sub?: string; role?: string; exp?: number; jti?: string } | undefined): { jti?: string; profileId?: string; expiresAt?: number } | undefined {
+  if (claims?.role !== "provider" || !claims.exp) return undefined;
+  const sub = claims.sub ?? "";
+  const profileId = sub.startsWith("runner:interactive:")
+    ? "provider-interactive"
+    : sub.startsWith("runner:spawn:") || sub.startsWith("runner:policy:") || /^runner:(codex|claude|provider):/.test(sub)
+      ? "provider-agent"
+      : undefined;
+  if (!profileId) return undefined;
+  return {
+    ...(claims.jti ? { jti: claims.jti } : {}),
+    profileId,
+    expiresAt: claims.exp,
+  };
+}
+
+function parseTokenExpiresAt(value: string | undefined): number | undefined {
+  if (!value) return undefined;
+  const parsed = Number(value);
+  return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : undefined;
+}
+
+export function isVersionRequest(argv: string[]): boolean {
+  const relayArgs = argv.slice(2);
+  const providerSep = relayArgs.indexOf("--");
+  const ownArgs = providerSep >= 0 ? relayArgs.slice(0, providerSep) : relayArgs;
+  return ownArgs.some((arg) => arg === "--version" || arg === "-v");
+}
+
+function detectProviderFromBin(argv: string[]): SpawnProvider {
+  const bin = [argv[1], process.env._].map((s) => basename(s || "")).join(" ");
+  for (const manifest of getAllManifests()) {
+    if (bin.includes(manifest.id)) return manifest.id as SpawnProvider;
+  }
+  return getAllManifests()[0]?.id as SpawnProvider ?? "claude";
+}
+
+function isRegisteredProvider(value: string): value is SpawnProvider {
+  return getAllManifests().some((m) => m.id === value);
+}
+
+function parseArgs(argv: string[]): CliOptions {
+  let provider = detectProviderFromBin(argv);
+  const relayArgs = argv.slice(2);
+  const providerSep = relayArgs.indexOf("--");
+  const ownArgs = providerSep >= 0 ? relayArgs.slice(0, providerSep) : relayArgs;
+  const providerArgs = providerSep >= 0 ? relayArgs.slice(providerSep + 1) : [];
+  let headless = false;
+  let model: string | undefined;
+  let effort: string | undefined;
+  let cwd: string | undefined;
+  let rig: string | undefined;
+  let profile: string | undefined;
+  let relayUrl: string | undefined;
+  let token: string | undefined;
+  let approvalMode: string | undefined;
+  let label: string | undefined;
+  let agentId: string | undefined;
+  let prompt: string | undefined;
+  let systemPromptAppend: string | undefined;
+  let tags: string[] = [];
+  let caps: string[] = [];
+
+  for (let i = 0; i < ownArgs.length; i++) {
+    const arg = ownArgs[i];
+    if (arg && isRegisteredProvider(arg)) provider = arg;
+    else if (arg === "--headless") headless = true;
+    else if (arg === "--model" && ownArgs[i + 1]) model = ownArgs[++i];
+    else if (arg === "--effort" && ownArgs[i + 1]) effort = ownArgs[++i];
+    else if (arg === "--cwd" && ownArgs[i + 1]) cwd = ownArgs[++i];
+    else if (arg === "--rig" && ownArgs[i + 1]) rig = ownArgs[++i];
+    else if (arg === "--profile" && ownArgs[i + 1]) profile = ownArgs[++i];
+    else if (arg === "--relay-url" && ownArgs[i + 1]) relayUrl = ownArgs[++i];
+    else if (arg === "--token" && ownArgs[i + 1]) token = ownArgs[++i];
+    else if ((arg === "--approval" || arg === "--approval-mode") && ownArgs[i + 1]) approvalMode = ownArgs[++i];
+    else if (arg === "--label" && ownArgs[i + 1]) label = ownArgs[++i];
+    else if (arg === "--agent-id" && ownArgs[i + 1]) agentId = ownArgs[++i];
+    else if (arg === "--prompt" && ownArgs[i + 1]) prompt = ownArgs[++i];
+    else if ((arg === "--system-prompt-append" || arg === "--append-system-prompt") && ownArgs[i + 1]) systemPromptAppend = ownArgs[++i];
+    else if (arg === "--tags" && ownArgs[i + 1]) tags = csvSplit(ownArgs[++i]!);
+    else if (arg === "--caps" && ownArgs[i + 1]) caps = csvSplit(ownArgs[++i]!);
+    else if (arg === "--help" || arg === "-h") {
+      printHelp(provider);
+      process.exit(0);
+    } else {
+      providerArgs.push(arg!);
+    }
+  }
+
+  const interactive = !headless && isatty(0);
+  return { provider, model, effort, headless, interactive, cwd, rig, profile, relayUrl, token, approvalMode, label, agentId, prompt, systemPromptAppend, tags, caps, providerArgs };
+}
+
+function csvSplit(value: string): string[] {
+  return value.split(",").map((s) => s.trim()).filter(Boolean);
+}
+
+function parseAgentProfileEnv(raw: string | undefined): AgentProfile | undefined {
+  if (!raw) return undefined;
+  try {
+    const parsed = JSON.parse(raw) as Partial<AgentProfile>;
+    return parsed && typeof parsed === "object" && typeof parsed.name === "string" ? parsed as AgentProfile : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function parseWorkspaceEnv(raw: string | undefined): WorkspaceMetadata | undefined {
+  if (!raw) return undefined;
+  try {
+    const parsed = JSON.parse(raw) as Partial<WorkspaceMetadata>;
+    return parsed && typeof parsed === "object" && typeof parsed.mode === "string" ? parsed as WorkspaceMetadata : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function parseRelayInjectionEventsEnv(raw: string | undefined): RunnerRelayInjectionEvent[] | undefined {
+  if (!raw) return undefined;
+  try {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return undefined;
+    const categories = new Set(["memory", "instructions", "tools", "comms", "knowledge", "context"]);
+    const events = parsed.flatMap((item): RunnerRelayInjectionEvent[] => {
+      if (!isRecord(item) || typeof item.summary !== "string" || !categories.has(String(item.category))) return [];
+      const detail = isRecord(item.detail) ? item.detail : {};
+      return [{ category: item.category as RelayInjectionCategory, summary: item.summary, detail }];
+    });
+    return events.length ? events : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function printHelp(provider: string): void {
+  console.log(`${provider}-relay [--headless] [--model ALIAS] [--effort LEVEL] [--rig NAME] [--profile NAME] [--cwd PATH] [--relay-url URL] [--approval MODE] [--label NAME] [--agent-id ID] [--prompt TEXT] [--system-prompt-append TEXT] [--tags a,b] [--caps x,y] [-- provider-args...]`);
+}
+
+function signalPromise(): Promise<number> {
+  return new Promise<number>((resolve) => {
+    process.on("SIGINT", () => resolve(130));
+    process.on("SIGTERM", () => resolve(143));
+  });
+}
+
+type ApprovalModeDetector = (allArgs: string[]) => string | undefined;
+
+const APPROVAL_MODE_DETECTORS: Record<string, ApprovalModeDetector> = {
+  claude(allArgs) {
+    if (allArgs.includes("--dangerously-skip-permissions")) return "open";
+    const modeIdx = allArgs.lastIndexOf("--permission-mode");
+    if (modeIdx >= 0) {
+      const mode = allArgs[modeIdx + 1];
+      if (mode === "dontAsk") return "read-only";
+      if (mode === "default") return "guarded";
+    }
+    return undefined;
+  },
+  codex(allArgs) {
+    if (allArgs.includes("--yolo")) return "open";
+    for (let i = 0; i < allArgs.length; i++) {
+      if (allArgs[i] === "-c" || allArgs[i] === "--config") {
+        const value = allArgs[i + 1] ?? "";
+        if (/sandbox_mode\s*=\s*"?danger-full-access"?/.test(value)) return "open";
+        if (/sandbox_mode\s*=\s*"?read-only"?/.test(value)) return "read-only";
+      }
+    }
+    return undefined;
+  },
+};
+
+export function detectApprovalModeFromArgs(provider: string, defaultArgs: string[], providerArgs: string[]): string | undefined {
+  const detector = APPROVAL_MODE_DETECTORS[provider];
+  return detector ? detector([...defaultArgs, ...providerArgs]) : undefined;
+}
+
+if (import.meta.main) {
+  main().catch((error) => {
+    // A fatal startup failure (e.g. the runner could not register with the relay within the
+    // deadline) must exit non-zero, not hang or swallow — the orchestrator's exit detection
+    // then reports it and the spawn-parent is notified instead of waiting on a silent zombie.
+    console.error(`[agent-relay] runner fatal: ${errMessage(error)}`);
+    process.exit(1);
+  });
+}