agent-relay-orchestrator 0.102.2 → 0.103.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-orchestrator",
-  "version": "0.102.2",
+  "version": "0.103.4",
   "description": "Agent Relay orchestrator — manages agent lifecycle across hosts",
   "type": "module",
   "bin": {
@@ -17,7 +17,8 @@
     "test": "bun test"
   },
   "dependencies": {
-    "agent-relay-sdk": "0.2.83"
+    "agent-relay-providers": "0.102.2",
+    "agent-relay-sdk": "0.2.87"
   },
   "devDependencies": {
     "@types/bun": "latest",

package/src/config.ts

@@ -1,14 +1,15 @@
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
 import { homedir, hostname as osHostname } from "node:os";
 import { join, dirname } from "node:path";
-import { DEFAULT_RELAY_URL } from "agent-relay-sdk";
+import { getAllManifests, getManifest } from "agent-relay-providers";
+import { DEFAULT_RELAY_URL, type SpawnProvider } from "agent-relay-sdk";
 
 export interface OrchestratorConfig {
   id: string;
   hostname: string;
   relayUrl: string;
   token?: string;
-  providers: ("claude" | "codex")[];
+  providers: SpawnProvider[];
   baseDir: string;
   env: Record<string, string>;
   heartbeatIntervalMs: number;
@@ -17,6 +18,7 @@ export interface OrchestratorConfig {
 }
 
 const DEFAULT_CONFIG_PATH = join(homedir(), ".agent-relay", "orchestrator.json");
+const DEFAULT_PROVIDER_IDS = getAllManifests().map((manifest) => manifest.id as SpawnProvider);
 
 function envNumberOrDefault(name: string, fallback: number): number {
   return Number(process.env[name]) || fallback;
@@ -42,8 +44,9 @@ export function bunBinFromEnv(): string | undefined {
   return process.env.AGENT_RELAY_BUN_BIN;
 }
 
-export function codexCommandFromEnv(): string | undefined {
-  return process.env.AGENT_RELAY_CODEX_COMMAND;
+export function providerCommandFromEnv(provider: string): string | undefined {
+  const prefix = getManifest(provider)?.home?.envPrefix ?? provider.toUpperCase().replace(/[^A-Z0-9]+/g, "_");
+  return process.env[`AGENT_RELAY_${prefix}_COMMAND`];
 }
 
 export function providerHomeRootFromEnv(): string {
@@ -104,6 +107,13 @@ interface RawConfig {
   apiPort?: number;
 }
 
+function normalizeProviders(values: string[] | undefined): SpawnProvider[] {
+  const requested = values?.map((value) => value.trim()).filter(Boolean) ?? [];
+  const allowed = new Set(DEFAULT_PROVIDER_IDS);
+  const normalized = requested.filter((value): value is SpawnProvider => allowed.has(value as SpawnProvider));
+  return normalized.length > 0 ? normalized : [...DEFAULT_PROVIDER_IDS];
+}
+
 export function loadConfig(path?: string): OrchestratorConfig {
   const configPath = path || process.env.AGENT_RELAY_ORCHESTRATOR_CONFIG || DEFAULT_CONFIG_PATH;
 
@@ -116,7 +126,7 @@ export function loadConfig(path?: string): OrchestratorConfig {
   const hostname = raw.hostname || process.env.AGENT_RELAY_ORCHESTRATOR_HOSTNAME || osHostname();
   const relayUrl = raw.relayUrl || process.env.AGENT_RELAY_URL || DEFAULT_RELAY_URL;
   const token = raw.token || process.env.AGENT_RELAY_TOKEN || undefined;
-  const providers = (raw.providers || process.env.AGENT_RELAY_ORCHESTRATOR_PROVIDERS?.split(",") || ["claude", "codex"]) as ("claude" | "codex")[];
+  const providers = normalizeProviders(raw.providers || process.env.AGENT_RELAY_ORCHESTRATOR_PROVIDERS?.split(","));
   const baseDir = raw.baseDir || process.env.AGENT_RELAY_ORCHESTRATOR_BASE_DIR || join(homedir(), "projects");
   const env = raw.env || {};
   const heartbeatIntervalMs = raw.heartbeatIntervalMs || 30_000;
@@ -133,7 +143,7 @@ export function initConfigFile(config: Partial<RawConfig>): string {
     id: osHostname().replace(/\./g, "-"),
     hostname: osHostname(),
     relayUrl: DEFAULT_RELAY_URL,
-    providers: ["claude", "codex"],
+    providers: [...DEFAULT_PROVIDER_IDS],
     baseDir: join(homedir(), "projects"),
     apiPort: 4860,
     env: {},

package/src/control.ts

@@ -1,4 +1,5 @@
 import { errMessage, isRecord, normalizeAgentLifecycle, normalizeWorkspaceMode } from "agent-relay-sdk";
+import { getAllManifests, getManifest } from "agent-relay-providers";
 import type { OrchestratorConfig } from "./config";
 import type { ManagedAgentReport, RelayClient, RelayCommand } from "./relay";
 import { handleSelfUpgrade } from "./self-upgrade";
@@ -264,17 +265,13 @@ function shutdownTimeoutMs(ctrl: Record<string, any>): number | undefined {
   return Number.isSafeInteger(ctrl.timeoutMs) && ctrl.timeoutMs > 0 ? Math.min(ctrl.timeoutMs, 60_000) : undefined;
 }
 
-// Both the control-spawn and restart-source paths build SpawnOptions from a
-// loose record in the same way. The two prior copies differed only in two
-// immaterial spots, unified here to the safer form:
-//   - provider: `=== "codex" ? "codex" : "claude"` (SPAWN_PROVIDERS is exactly
-//     claude|codex, so this matches control's `|| "claude"` for every valid
-//     input and stays defensive against junk).
-//   - cwd: `source.cwd || baseDir` — an empty-string cwd now falls back to
-//     baseDir on the restart path too (was a latent bug; empty cwd is invalid).
 function spawnOptionsFromRecord(source: Record<string, any>, config: OrchestratorConfig): SpawnOptions {
+  const fallbackProvider = config.providers[0] ?? (getAllManifests()[0]?.id ?? "claude");
+  const provider = typeof source.provider === "string" && getManifest(source.provider)
+    ? source.provider
+    : fallbackProvider;
   return {
-    provider: source.provider === "codex" ? "codex" : "claude",
+    provider,
     cwd: source.cwd || config.baseDir,
     rig: typeof source.rig === "string" ? source.rig : undefined,
     model: modelFromControl(source),

package/src/provider-probe.ts

@@ -1,8 +1,9 @@
 import { accessSync, constants, existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { delimiter, join, resolve } from "node:path";
+import { getManifest, type ProviderProbeFeatureCheck } from "agent-relay-providers";
 import { providerCatalogList, type ProviderCatalogEntry } from "agent-relay-sdk/provider-catalog";
-import { errMessage } from "agent-relay-sdk";
+import { errMessage, type SpawnProvider } from "agent-relay-sdk";
 import type { OrchestratorConfig } from "./config";
 import { VERSION } from "./version";
 
@@ -15,7 +16,7 @@ interface ProviderProbeDetail {
 }
 
 interface ProviderProbeResult {
-  name: "claude" | "codex";
+  name: SpawnProvider;
   available: boolean;
   checkedAt: number;
   reason?: string;
@@ -27,7 +28,7 @@ interface ProviderProbeResult {
 }
 
 interface ProviderProbeSnapshot {
-  providers: ("claude" | "codex")[];
+  providers: SpawnProvider[];
   providerStatus: ProviderProbeResult[];
   providerCatalog: ProviderCatalogEntry[];
   checkedAt: number;
@@ -62,11 +63,14 @@ export class ProviderProbeCache {
   }
 }
 
-export async function probeProvider(provider: "claude" | "codex", timeoutMs = DEFAULT_TIMEOUT_MS): Promise<ProviderProbeResult> {
-  const cli = await probeCommand(provider, ["--version"], timeoutMs, provider, (path) => isRelayProviderShim(path, provider));
+export async function probeProvider(provider: SpawnProvider, timeoutMs = DEFAULT_TIMEOUT_MS): Promise<ProviderProbeResult> {
+  const manifest = getManifest(provider);
+  const cliCommand = manifest?.probe?.command ?? provider;
+  const cliArgs = manifest?.probe?.args ?? ["--version"];
+  const cli = await probeCommand(cliCommand, cliArgs, timeoutMs, cliCommand, (path) => isRelayProviderShim(path, provider));
   const runner = await probeRunner(provider, timeoutMs);
   const available = cli.ok && runner.ok;
-  const features = probeProviderFeatures(provider);
+  const features = probeProviderFeatures(manifest?.probe?.featureChecks ?? []);
   return {
     name: provider,
     available,
@@ -80,17 +84,19 @@ export async function probeProvider(provider: "claude" | "codex", timeoutMs = DE
   };
 }
 
-function probeProviderFeatures(provider: "claude" | "codex"): Record<string, boolean> {
+function probeProviderFeatures(checks: ProviderProbeFeatureCheck[]): Record<string, boolean> {
   const features: Record<string, boolean> = {};
-  if (provider === "claude") {
-    const hasRigBinary = !!resolveExecutable("claude-rig");
-    const hasRigDir = existsSync(join(homedir(), ".claude-rig"));
-    if (hasRigBinary || hasRigDir) features.rig = true;
+  for (const check of checks) {
+    const hasCommand = check.command ? !!resolveExecutable(check.command) : false;
+    const hasHomeDir = check.homeDir ? existsSync(join(homedir(), check.homeDir)) : false;
+    if (hasCommand || hasHomeDir) {
+      features[check.name] = true;
+    }
   }
   return features;
 }
 
-async function probeRunner(provider: "claude" | "codex", timeoutMs: number): Promise<ProviderProbeDetail> {
+async function probeRunner(provider: SpawnProvider, timeoutMs: number): Promise<ProviderProbeDetail> {
   const repoLauncher = resolve(import.meta.dir, "../../runner/src/index.ts");
   if (existsSync(repoLauncher)) {
     const bun = resolveExecutable("bun");
@@ -175,7 +181,7 @@ function isExecutable(path: string): boolean {
   }
 }
 
-function isRelayProviderShim(path: string, provider: "claude" | "codex"): boolean {
+function isRelayProviderShim(path: string, provider: SpawnProvider): boolean {
   try {
     const content = readFileSync(path, "utf8").slice(0, 1024);
     return content.includes(`${provider}-relay ${provider}`);

package/src/quota-poller.ts

@@ -2,6 +2,7 @@ import { homedir } from "node:os";
 import { existsSync, readdirSync } from "node:fs";
 import { createServer } from "node:net";
 import { join } from "node:path";
+import { getManifest, type ProviderQuotaPollDescriptor } from "agent-relay-providers";
 import {
   DEFAULT_PROVIDER_QUOTA_CONFIG,
   QUOTA_FAILURE_LOG_INTERVAL_MS,
@@ -17,7 +18,7 @@ import {
 } from "agent-relay-sdk/provider-quota";
 import type { ProviderQuotaConfig, ProviderQuotaConfigMap, ProviderQuotaLeaseAcquireInput, ProviderQuotaUpdateInput } from "agent-relay-sdk";
 import { errMessage } from "agent-relay-sdk";
-import { codexCommandFromEnv, providerHomeRootFromEnv, type OrchestratorConfig } from "./config";
+import { providerCommandFromEnv, providerHomeRootFromEnv, type OrchestratorConfig } from "./config";
 
 const QUOTA_LEASE_TTL_MS = 90_000;
 const QUOTA_LEASE_RENEW_MS = 30_000;
@@ -173,10 +174,11 @@ export class OrchestratorQuotaPoller {
     // A disabled provider (#605) is collected from at all: no discovery → no
     // polling/API calls, leases released by releaseRemovedCandidates, and no
     // skip-marker row (disabled is intentional, not a credential failure).
-    if (this.config.providers.includes("codex") && this.configFor("codex").enabled) {
-      const found = await this.discoverCodexCandidates();
+    for (const provider of this.config.providers) {
+      if (!this.configFor(provider).enabled) continue;
+      const found = await this.discoverProviderCandidates(provider);
       candidates.push(...found.candidates);
-      if (found.skipReason) skips.push({ provider: "codex", reason: found.skipReason });
+      if (found.skipReason) skips.push({ provider, reason: found.skipReason });
     }
     const deduped = new Map<string, QuotaCandidate>();
     for (const candidate of candidates) {
@@ -185,20 +187,32 @@ export class OrchestratorQuotaPoller {
     return { candidates: [...deduped.values()], skips };
   }
 
-  private async discoverCodexCandidates(): Promise<{ candidates: QuotaCandidate[]; skipReason?: string }> {
+  private async discoverProviderCandidates(provider: string): Promise<{ candidates: QuotaCandidate[]; skipReason?: string }> {
+    const manifest = getManifest(provider);
+    const quotaPoll = manifest?.quotaPoll;
+    if (!quotaPoll || quotaPoll.strategy === "none") return { candidates: [] };
+    if (quotaPoll.strategy === "codex-app-server") return this.discoverCodexCandidates(provider, quotaPoll);
+    return { candidates: [] };
+  }
+
+  private async discoverCodexCandidates(provider: string, _quotaPoll: ProviderQuotaPollDescriptor): Promise<{ candidates: QuotaCandidate[]; skipReason?: string }> {
+    const manifest = getManifest(provider);
+    const providerLabel = manifest?.label ?? provider;
+    const markerFile = manifest?.home?.quotaCredentialFile ?? "auth.json";
     const homes = [
-      this.config.env.CODEX_HOME || process.env.CODEX_HOME || join(homedir(), ".codex"),
-      ...providerHomeConfigDirs("codex", "auth.json"),
+      this.providerHomeDir(provider),
+      ...providerHomeConfigDirs(provider, markerFile),
     ];
-    const appServerUrl = this.config.env.CODEX_APP_SERVER_URL || process.env.CODEX_APP_SERVER_URL;
+    const envPrefix = manifest?.home?.envPrefix ?? provider.toUpperCase().replace(/[^A-Z0-9]+/g, "_");
+    const appServerUrl = this.config.env[`${envPrefix}_APP_SERVER_URL`] || process.env[`${envPrefix}_APP_SERVER_URL`];
     const candidates: QuotaCandidate[] = [];
     for (const codexHome of homes) {
       const identity = await resolveStableCodexQuotaIdentityFromHome({ codexHome });
       if (identity) candidates.push({ ...identity, codexHome, ...(appServerUrl ? { appServerUrl } : {}) });
     }
     if (candidates.length === 0) {
-      const reason = "no Codex account id found in auth.json";
-      this.logOnce("codex:no-stable-auth", `quota refresh skipped for codex: ${reason}`);
+      const reason = `no ${providerLabel} account id found in ${markerFile}`;
+      this.logOnce(`${provider}:no-stable-auth`, `quota refresh skipped for ${provider}: ${reason}`);
       return { candidates, skipReason: reason };
     }
     return { candidates };
@@ -319,14 +333,15 @@ export class OrchestratorQuotaPoller {
   }
 
   private async collect(candidate: QuotaCandidate): Promise<ProviderQuotaSample> {
-    if (candidate.provider === "codex") {
+    const strategy = getManifest(candidate.provider)?.quotaPoll?.strategy;
+    if (strategy === "codex-app-server") {
       return collectCodexQuotaSample({
         agentId: this.sourceAgentId(),
         rateLimitsRead: () => this.options.codexRateLimitsRead
           ? this.options.codexRateLimitsRead(candidate.appServerUrl ?? "")
           : candidate.appServerUrl
             ? codexRateLimitsRead(candidate.appServerUrl)
-            : codexRateLimitsReadFromHome(candidate.codexHome),
+            : codexRateLimitsReadFromHome(candidate.provider, candidate.codexHome),
       });
     }
     return {};
@@ -370,6 +385,12 @@ export class OrchestratorQuotaPoller {
     this.logStates.set(key, { key, at: now });
     this.log(message);
   }
+
+  private providerHomeDir(provider: string): string {
+    const manifest = getManifest(provider);
+    const envPrefix = manifest?.home?.envPrefix ?? provider.toUpperCase().replace(/[^A-Z0-9]+/g, "_");
+    return this.config.env[`${envPrefix}_HOME`] || process.env[`${envPrefix}_HOME`] || join(homedir(), manifest?.home?.configDir ?? `.${provider}`);
+  }
 }
 
 async function codexRateLimitsRead(appServerUrl: string, attempts = 1): Promise<unknown> {
@@ -387,10 +408,10 @@ async function codexRateLimitsRead(appServerUrl: string, attempts = 1): Promise<
   }
 }
 
-async function codexRateLimitsReadFromHome(codexHome: string | undefined): Promise<unknown> {
-  if (!codexHome) throw new QuotaCollectionError("creds_not_ready", "Codex home is not configured");
+async function codexRateLimitsReadFromHome(provider: string, codexHome: string | undefined): Promise<unknown> {
+  if (!codexHome) throw new QuotaCollectionError("creds_not_ready", `${provider} home is not configured`);
   const appServerUrl = await freeLoopbackWsUrl();
-  const command = codexCommandFromEnv() || "codex";
+  const command = providerCommandFromEnv(provider) || getManifest(provider)?.probe?.command || provider;
   const proc = Bun.spawn([command, "app-server", "--listen", appServerUrl], {
     env: {
       ...process.env,
@@ -440,7 +461,7 @@ function providerHomeRoot(): string {
   return providerHomeRootFromEnv();
 }
 
-function providerHomeConfigDirs(provider: "claude" | "codex", markerFile: string): string[] {
+function providerHomeConfigDirs(provider: string, markerFile: string): string[] {
   const root = join(providerHomeRoot(), provider);
   const dirs: string[] = [];
   for (const profile of safeReadDir(root)) {

package/src/relay.ts

@@ -2,7 +2,7 @@ import type { OrchestratorConfig } from "./config";
 import type { ProviderProbeCache } from "./provider-probe";
 import { detectSelfSupervision } from "./self-supervision";
 import { GIT_SHA, ORCHESTRATOR_PROTOCOL_VERSION, VERSION, runtimeMetadata } from "./version";
-import type { AgentLifecycle, ProviderQuotaConfigMap, ProviderQuotaLeaseAcquireInput, ProviderQuotaLeaseAcquireResult, ProviderQuotaUpdateInput, WorkspaceMetadata, WorkspaceMode, ManagedSessionExitDiagnostics as SdkManagedSessionExitDiagnostics } from "agent-relay-sdk";
+import type { AgentLifecycle, ProviderQuotaConfigMap, ProviderQuotaLeaseAcquireInput, ProviderQuotaLeaseAcquireResult, ProviderQuotaUpdateInput, WorkspaceMetadata, WorkspaceMode, ManagedSessionExitDiagnostics as SdkManagedSessionExitDiagnostics, SpawnProvider } from "agent-relay-sdk";
 import { ReconnectionManager, RelayHttpClient } from "agent-relay-sdk";
 
 export interface RelayClient {
@@ -29,7 +29,7 @@ interface RunnerTokenRemint {
 
 export interface ManagedAgentReport {
   agentId: string;
-  provider: "claude" | "codex";
+  provider: SpawnProvider;
   model?: string;
   effort?: string;
   profile?: string;

package/src/self-upgrade.ts

@@ -1,12 +1,13 @@
 import { join } from "node:path";
 import { existsSync } from "node:fs";
 import { homedir } from "node:os";
+import { getAllManifests } from "agent-relay-providers";
 import { runInstallWithRetry } from "agent-relay-sdk";
 import type { OrchestratorConfig } from "./config";
 import type { RelayClient, RelayCommand } from "./relay";
 import { detectSelfSupervision, type SelfSupervision } from "./self-supervision";
 
-const VALID_PROVIDERS = new Set(["auto", "all", "codex", "claude", "orchestrator"]);
+const VALID_PROVIDERS = new Set(["auto", "all", "orchestrator", ...getAllManifests().map((manifest) => manifest.id)]);
 const SEMVER_RE = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/;
 
 interface SelfUpgradeOptions {
@@ -213,13 +214,10 @@ function packagesForProviders(targetVersion: string, providers: string[]): strin
   if (includeAll || includeAuto || selected.has("orchestrator")) {
     packages.add("agent-relay-orchestrator");
   }
-  if (includeAll || selected.has("codex")) {
-    packages.add("agent-relay-runner");
-    packages.add("agent-relay-codex");
-  }
-  if (includeAll || selected.has("claude")) {
-    packages.add("agent-relay-runner");
-    packages.add("agent-relay-plugin");
+  for (const manifest of getAllManifests()) {
+    if (!manifest.upgrade?.packages?.length) continue;
+    if (!includeAll && !selected.has(manifest.id)) continue;
+    for (const providerPackage of manifest.upgrade.packages) packages.add(providerPackage);
   }
 
   if (packages.size === 0) packages.add("agent-relay-orchestrator");

package/src/spawn/types.ts

@@ -1,9 +1,9 @@
 import type { OrchestratorConfig } from "../config";
-import type { AgentLifecycle, WorkspaceMetadata, WorkspaceMode } from "agent-relay-sdk";
+import type { AgentLifecycle, SpawnProvider, WorkspaceMetadata, WorkspaceMode } from "agent-relay-sdk";
 import type { ResumeWorkspaceTarget } from "../workspace-probe/types";
 
 export interface SpawnOptions {
-  provider: "claude" | "codex";
+  provider: SpawnProvider;
   cwd: string;
   rig?: string;
   model?: string;