@humwick/runner 0.0.0-stage → 0.130.0

package/src/index.ts

@@ -0,0 +1,386 @@
+#!/usr/bin/env -S bun --no-env-file
+import { hostname } from "node:os";
+import { disableCoreDumps } from "@humwick/sdk/core-dumps";
+import { AgentRunner } from "./runner";
+import {
+  agentProfileJsonFromEnv,
+  harnessSubagentsFromEnv,
+  agentProfileNameFromEnv,
+  automationIdFromEnv,
+  automationRunIdFromEnv,
+  lifecycleFromEnv,
+  loadGlobalConfig,
+  loadProviderConfigFromRelay,
+  policyNameFromEnv,
+  promptFromEnv,
+  providerConfigLookupFromEnv,
+  relayInjectionEventsJsonFromEnv,
+  resolveCwd,
+  runnerId,
+  runtimeTokenExpiresAtFromEnv,
+  runtimeTokenJtiFromEnv,
+  runtimeTokenProfileFromEnv,
+  spawnRequestIdFromEnv,
+  systemPromptAppendFromEnv,
+  taskIdFromEnv,
+  tmuxSessionFromEnv,
+  workspaceJsonFromEnv,
+  projectToolchainFromEnv,
+} from "./config";
+import { createProviderAdapter } from "./providers";
+import { parseRunnerCliArgs, runnerHelp } from "./spawn-input";
+import { VERSION } from "./version";
+import type { AgentProfile, WorkspaceMetadata } from "@humwick/sdk";
+import { exitRunner } from "./runner-exit";
+import { codexConfigOverrides, errMessage, formatRunnerExitLine, isRecord, isRelayInjectionCategory, normalizeAgentLifecycle, RELAY_TOKEN_HEADER, providerArgsSelectStreamJson, startArtifactCheckoutLease } from "@humwick/sdk";
+import { supportedLaunchModesForProvider } from "@humwick/providers";
+import { installUnhandledRejectionGuard } from "./async-guard";
+import type { RunnerRelayInjectionEvent } from "./relay-injection-events";
+import { enableRunnerSubreaper } from "./subreaper";
+
+export async function main(argv = process.argv): Promise<void> {
+  disableCoreDumps();
+  // #2443 — last-resort observability, installed before anything can schedule work. Two managed
+  // OpenCode sessions died with a clean `exit(1)` and an EMPTY stderr capture: the actual cause
+  // (a terminal provider failure resolving through onProviderExit, see runner-core.ts) turned out
+  // not to be a crash at all, but this guard closes the still-real, long-documented gap (#1665)
+  // for any genuine unhandled rejection or uncaught exception elsewhere in the runner — neither
+  // currently leaves a trace beyond "exited after Ns". `unhandledRejection` mirrors the
+  // orchestrator's non-fatal "log and survive" backstop (see the SDK function's doc): nothing
+  // here respawns a dead runner (#1618), so surviving beats dying silently. `uncaughtException`
+  // stays fatal (a synchronous throw can leave a half-applied mutation behind — same ruling as
+  // the orchestrator) but is logged deterministically via multiple paths first, so a crash always
+  // leaves a stack trace regardless of whether Bun's own default reporter would have shown one.
+  // Installed inside `main()`, not at module scope: this file is imported directly by tests
+  // (config.test.ts, runner.test.ts) that never call `main()`, and a top-level `process.on(...)`
+  // would leak a real, process-fatal `uncaughtException` handler into the whole `bun test` run.
+  installUnhandledRejectionGuard();
+  process.on("uncaughtException", (error) => {
+    const detail = error instanceof Error ? (error.stack ?? error.message) : String(error);
+    try { process.stderr.write(`[runner] uncaughtException (fatal): ${detail}\n`); } catch { /* best-effort */ }
+    try { console.error(`[runner] uncaughtException (fatal): ${errMessage(error)}`); } catch { /* best-effort */ }
+    exitRunner(1, `uncaughtException: ${errMessage(error)}`);
+  });
+  if (isVersionRequest(argv)) {
+    console.log(VERSION);
+    return;
+  }
+  const opts = parseRunnerCliArgs(argv);
+  if (opts.help) {
+    console.log(runnerHelp(opts.provider));
+    return;
+  }
+  enableRunnerSubreaper();
+  // Started only once we know this is a real launch, not --version/--help: the lease holds an
+  // un-refed setInterval alive (see sdk/src/artifact-checkout-gc.ts), so starting it earlier
+  // stops --version/--help from ever exiting on a host whose runtime is a checkout symlink
+  // (e.g. the wbox self-hosted runner) — the process hangs until externally killed. #2122
+  startArtifactCheckoutLease();
+  const globalConfig = loadGlobalConfig();
+  const relayUrl = opts.relayUrl ?? globalConfig.relayUrl;
+  const providerConfig = await loadRunnerProviderConfig(opts.provider, relayUrl, opts.token ?? globalConfig.token);
+  const cwd = resolveCwd(opts.cwd, globalConfig.defaultCwd);
+  const id = runnerId(opts.provider, cwd, opts.label);
+  // Providers offering both modes always record the one they run in; raw stream-json args stay a legacy headless selector.
+  const launchMode = opts.launchMode ?? (supportedLaunchModesForProvider(opts.provider).length
+    ? (providerArgsSelectStreamJson(opts.providerArgs) ? "headless" : "interactive")
+    : undefined);
+  const adapter = createProviderAdapter(opts.provider, opts.providerArgs, launchMode);
+  // Resolved BEFORE the interactive token exchange so the mint can stamp the posture into the signed
+  // constraints (#2392): `agent.meta.approvalMode` is authz-relevant and therefore stripped at
+  // registration unless the token can prove it (src/authz-meta-keys.ts).
+  const approvalMode = opts.approvalMode
+    ?? detectApprovalModeFromArgs(opts.provider, providerConfig.defaultArgs, opts.providerArgs)
+    ?? providerConfig.defaultApprovalMode;
+  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,
+    approvalMode,
+  });
+
+  let exitResolve: (code: number) => void;
+  let exitReason: string | undefined;
+  const exitPromise = new Promise<number>((resolve) => { exitResolve = resolve; });
+
+  // Provider-owned async preload reaches registration projection before any synchronous launch
+  // assembly runs, without leaking provider-specific host config parsing into this CLI boundary.
+  const launchConfig = await adapter.preloadRunnerConfig?.();
+
+  const runner = new AgentRunner({
+    provider: opts.provider,
+    model: opts.model,
+    effort: opts.effort,
+    // #2595 — effective-catalog window resolved server-side; the OpenCode adapter prefers it
+    // over its static manifest so override-defined models (muse-spark) report context usage.
+    ...(opts.contextWindowTokens !== undefined ? { contextWindowTokens: opts.contextWindowTokens } : {}),
+    // #2599 — the full record (protocol ≥ 2); the adapter applies payload > manifest precedence.
+    ...(opts.modelRecord ? { modelRecord: opts.modelRecord } : {}),
+    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,
+    ...(launchMode ? { launchMode } : {}),
+    approvalMode,
+    label: opts.label,
+    rig: opts.rig,
+    profile: opts.profile ?? agentProfileNameFromEnv(),
+    harnessSubagents: harnessSubagentsFromEnv(),
+    agentProfile: parseAgentProfileEnv(agentProfileJsonFromEnv()),
+    workspace: parseWorkspaceEnv(workspaceJsonFromEnv()),
+    toolchain: projectToolchainFromEnv(),
+    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,
+    ...(launchConfig ? { launchConfig } : {}),
+    adapter,
+    // #2443 — printed via console.error (captured into the systemd-redirected stdout/stderr log
+    // the orchestrator tails on exit, see logFileDiagnostics/readLogTail) BEFORE process.exit runs
+    // below, so a terminal-provider-failure exit reads "model-unavailable: APIError 404 ..." in
+    // that log instead of leaving it empty.
+    onProviderExit: (code, reason) => {
+      exitReason = reason;
+      exitResolve(code ?? 1);
+    },
+  });
+  await runner.run();
+
+  const code = await Promise.race([exitPromise, signalPromise(runner)]);
+  // #2619 — the structured exit record is written before stop() can stall: the orchestrator parses
+  // it back from the log tail when systemd has already collected the unit. exitRunner then exits.
+  const reason = exitReason ?? (code === 130 || code === 143 ? `signal ${code === 130 ? "SIGINT" : "SIGTERM"}` : undefined);
+  console.error(formatRunnerExitLine(code, reason));
+  await runner.stop();
+  exitRunner(code, reason);
+}
+
+/** The runner main-path central-config bootstrap, kept callable for seam tests. */
+export function loadRunnerProviderConfig(provider: string, relayUrl: string, token?: string) {
+  return loadProviderConfigFromRelay(provider, {
+    relayUrl,
+    token,
+    ...providerConfigLookupFromEnv(),
+  });
+}
+
+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;
+  /** #2392 — the posture this interactive session actually launches with. Sent so the relay can stamp
+   * it into the signed constraints; without it the session's `meta.approvalMode` is unprovable and
+   * gets stripped at registration, silently downgrading spawned children to `guarded`. */
+  approvalMode?: 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(),
+        ...(input.approvalMode ? { approvalMode: input.approvalMode } : {}),
+      }),
+      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 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 events = parsed.flatMap((item): RunnerRelayInjectionEvent[] => {
+      if (!isRecord(item) || typeof item.summary !== "string" || !isRelayInjectionCategory(item.category)) return [];
+      const detail = isRecord(item.detail) ? item.detail : {};
+      return [{ category: item.category, summary: item.summary, detail }];
+    });
+    return events.length ? events : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+// #2414 — arm the `shuttingDown` restart-suppression latch synchronously, in the signal handler itself, BEFORE resolving this
+// promise (which only unblocks `main()`'s `await Promise.race(...)`, itself an extra tick before
+// `await runner.stop()` ever runs). See `markShuttingDown`'s doc comment in runner-core.ts for the
+// race this closes: a direct-child provider (Codex/OpenCode) dying from the SAME process-group
+// signal the orchestrator just sent this process can otherwise race `handleAdapterStatusChange`
+// ahead of `stop()` and get treated as an unexpected crash worth restarting.
+export function signalPromise(runner: Pick<AgentRunner, "markShuttingDown">): Promise<number> {
+  return new Promise<number>((resolve) => {
+    process.on("SIGINT", () => { runner.markShuttingDown(); resolve(130); });
+    process.on("SIGTERM", () => { runner.markShuttingDown(); 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 (const value of codexConfigOverrides(allArgs)) {
+      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)}`);
+    exitRunner(1, `runner fatal: ${errMessage(error)}`);
+  });
+}