agent-relay-server 0.6.0 → 0.7.0

package/src/upgrade.ts

@@ -3,7 +3,7 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import { VERSION } from "./config";
 
-export type UpgradeProvider = "auto" | "all" | "codex" | "claude";
+export type UpgradeProvider = "auto" | "all" | "codex" | "claude" | "orchestrator";
 
 type UpgradeOptions = {
   targetVersion?: string;
@@ -28,12 +28,16 @@ export type UpgradeSnapshot = {
   targetVersion: string;
   serverPackage?: InstalledPackage;
   codexPackage?: InstalledPackage;
+  orchestratorPackage?: InstalledPackage;
   codexCopiedPackage?: InstalledPackage;
   claudePluginInstalls: ClaudePluginInstall[];
   hasCodexCommand: boolean;
+  hasOrchestratorCommand: boolean;
   hasClaudeCommand: boolean;
   hasSystemdUserService: boolean;
+  hasSystemdUserOrchestratorService: boolean;
   runningServerVersion?: string;
+  runningOrchestrators?: Array<{ id: string; version?: string; protocolVersion?: number; health?: { status?: string; restartRequired?: boolean } }>;
   packageManager: "bun" | "npm" | "none";
 };
 
@@ -46,7 +50,7 @@ type UpgradeAction = {
 
 type UpgradePlan = {
   targetVersion: string;
-  providers: { codex: boolean; claude: boolean };
+  providers: { codex: boolean; claude: boolean; orchestrator: boolean };
   snapshot: UpgradeSnapshot;
   actions: UpgradeAction[];
   warnings: string[];
@@ -67,9 +71,9 @@ export async function detectUpgradeSnapshot(options: UpgradeOptions = {}): Promi
   const codexCopiedPackage = readPackageVersion(join(homeDir(), ".agent-relay", "codex", "package", "package.json"));
   const claudePluginInstalls = readClaudePluginInstalls(join(homeDir(), ".claude", "plugins", "installed_plugins.json"));
 
-  const packageManager = bunPackages.has("agent-relay-server") || bunPackages.has("agent-relay-codex")
+  const packageManager = bunPackages.has("agent-relay-server") || bunPackages.has("agent-relay-codex") || bunPackages.has("agent-relay-orchestrator")
     ? "bun"
-    : npmPackages.has("agent-relay-server") || npmPackages.has("agent-relay-codex")
+    : npmPackages.has("agent-relay-server") || npmPackages.has("agent-relay-codex") || npmPackages.has("agent-relay-orchestrator")
       ? "npm"
       : commandExists("bun")
         ? "bun"
@@ -81,14 +85,18 @@ export async function detectUpgradeSnapshot(options: UpgradeOptions = {}): Promi
     targetVersion,
     serverPackage: installedPackage("agent-relay-server", bunPackages, npmPackages),
     codexPackage: installedPackage("agent-relay-codex", bunPackages, npmPackages),
+    orchestratorPackage: installedPackage("agent-relay-orchestrator", bunPackages, npmPackages),
     codexCopiedPackage: codexCopiedPackage
       ? { version: codexCopiedPackage, source: "copied", path: join(homeDir(), ".agent-relay", "codex", "package") }
       : undefined,
     claudePluginInstalls,
     hasCodexCommand: commandExists("agent-relay-codex") || commandExists("codex-relay") || existsSync(join(homeDir(), ".agent-relay", "codex", "package")),
+    hasOrchestratorCommand: commandExists("agent-relay-orchestrator"),
     hasClaudeCommand: commandExists("claude"),
     hasSystemdUserService: hasSystemdUserService("agent-relay.service"),
+    hasSystemdUserOrchestratorService: hasSystemdUserService("agent-relay-orchestrator.service"),
     runningServerVersion: await runningServerVersion(),
+    runningOrchestrators: await runningOrchestrators(),
     packageManager,
   };
 }
@@ -99,6 +107,7 @@ export function createUpgradePlan(snapshot: UpgradeSnapshot, options: UpgradeOpt
   const providerSet = new Set(requestedProviders);
   const codexRequested = providerSet.has("all") || providerSet.has("codex") || (providerSet.has("auto") && isCodexDetected(snapshot));
   const claudeRequested = providerSet.has("all") || providerSet.has("claude") || (providerSet.has("auto") && isClaudeRelayDetected(snapshot));
+  const orchestratorRequested = providerSet.has("all") || providerSet.has("orchestrator") || (providerSet.has("auto") && isOrchestratorDetected(snapshot));
   const actions: UpgradeAction[] = [];
   const warnings: string[] = [];
 
@@ -107,13 +116,14 @@ export function createUpgradePlan(snapshot: UpgradeSnapshot, options: UpgradeOpt
   } else {
     const packages = [`agent-relay-server@${targetVersion}`];
     if (codexRequested) packages.push(`agent-relay-codex@${targetVersion}`);
+    if (orchestratorRequested) packages.push(`agent-relay-orchestrator@${targetVersion}`);
     const command = snapshot.packageManager === "bun"
       ? ["bun", "add", "-g", ...packages]
       : ["npm", "install", "-g", ...packages];
     actions.push({
       label: "Upgrade global packages",
       command,
-      reason: `Update server${codexRequested ? " and Codex integration" : ""} packages to ${targetVersion}.`,
+      reason: `Update server${codexRequested ? ", Codex integration" : ""}${orchestratorRequested ? ", and orchestrator" : ""} packages to ${targetVersion}.`,
       mutates: true,
     });
   }
@@ -148,6 +158,10 @@ export function createUpgradePlan(snapshot: UpgradeSnapshot, options: UpgradeOpt
     warnings.push("Claude Agent Relay plugin not detected; skipping Claude plugin upgrade.");
   }
 
+  if (!orchestratorRequested && providerSet.has("auto") && !isOrchestratorDetected(snapshot)) {
+    warnings.push("Agent Relay orchestrator not detected; skipping orchestrator package upgrade.");
+  }
+
   if (snapshot.hasSystemdUserService) {
     if (options.noRestart) {
       warnings.push("agent-relay.service detected but --no-restart was set; restart manually to run the upgraded server.");
@@ -163,9 +177,24 @@ export function createUpgradePlan(snapshot: UpgradeSnapshot, options: UpgradeOpt
     warnings.push("No systemd user service detected; restart any manually running Agent Relay server yourself.");
   }
 
+  if (snapshot.hasSystemdUserOrchestratorService) {
+    if (options.noRestart) {
+      warnings.push("agent-relay-orchestrator.service detected but --no-restart was set; restart manually to run the upgraded orchestrator.");
+    } else {
+      actions.push({
+        label: "Restart Agent Relay orchestrator service",
+        command: ["systemctl", "--user", "restart", "agent-relay-orchestrator.service"],
+        reason: "Restart orchestrator daemon so host lifecycle control uses the upgraded protocol.",
+        mutates: true,
+      });
+    }
+  } else if (orchestratorRequested) {
+    warnings.push("No agent-relay-orchestrator.service detected; restart any manually running orchestrator yourself.");
+  }
+
   return {
     targetVersion,
-    providers: { codex: codexRequested, claude: claudeRequested },
+    providers: { codex: codexRequested, claude: claudeRequested, orchestrator: orchestratorRequested },
     snapshot: { ...snapshot, targetVersion },
     actions,
     warnings,
@@ -194,6 +223,15 @@ export async function executeUpgradePlan(plan: UpgradePlan, options: { dryRun?:
     }
     if (serverVersion) lines.push(`Running server: ${serverVersion}`);
   }
+  if (plan.actions.some((action) => action.command.join(" ") === "systemctl --user restart agent-relay-orchestrator.service")) {
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+    const orchestrators = await runningOrchestrators() ?? [];
+    const mismatched = orchestrators.filter((orch) => orch.version && orch.version !== plan.targetVersion);
+    if (mismatched.length > 0) {
+      throw new Error(`agent-relay-orchestrator.service restarted but ${mismatched.map((orch) => `${orch.id} reports ${orch.version}`).join(", ")}, expected ${plan.targetVersion}`);
+    }
+    if (orchestrators.length > 0) lines.push(`Running orchestrator(s): ${orchestrators.map((orch) => `${orch.id}${orch.version ? ` ${orch.version}` : ""}`).join(", ")}`);
+  }
   lines.push("\nUpgrade commands completed.");
   if (plan.warnings.length > 0) {
     lines.push("\nWarnings:");
@@ -211,11 +249,14 @@ export function formatUpgradePlan(plan: UpgradePlan, options: { dryRun?: boolean
     `- running server: ${plan.snapshot.runningServerVersion ?? "unknown"}`,
     `- codex package: ${formatPackage(plan.snapshot.codexPackage)}`,
     `- codex copied package: ${formatPackage(plan.snapshot.codexCopiedPackage)}`,
+    `- orchestrator package: ${formatPackage(plan.snapshot.orchestratorPackage)}`,
+    `- running orchestrators: ${formatRunningOrchestrators(plan.snapshot.runningOrchestrators)}`,
     `- claude command: ${plan.snapshot.hasClaudeCommand ? "yes" : "no"}`,
     `- claude agent-relay plugin: ${formatClaudePlugins(plan.snapshot.claudePluginInstalls)}`,
     `- systemd user service: ${plan.snapshot.hasSystemdUserService ? "yes" : "no"}`,
+    `- orchestrator systemd user service: ${plan.snapshot.hasSystemdUserOrchestratorService ? "yes" : "no"}`,
     "",
-    `Providers: codex=${plan.providers.codex ? "yes" : "no"}, claude=${plan.providers.claude ? "yes" : "no"}`,
+    `Providers: codex=${plan.providers.codex ? "yes" : "no"}, claude=${plan.providers.claude ? "yes" : "no"}, orchestrator=${plan.providers.orchestrator ? "yes" : "no"}`,
     "",
     "Actions:",
   ];
@@ -239,6 +280,10 @@ function isClaudeRelayDetected(snapshot: UpgradeSnapshot): boolean {
   return snapshot.claudePluginInstalls.length > 0;
 }
 
+function isOrchestratorDetected(snapshot: UpgradeSnapshot): boolean {
+  return Boolean(snapshot.orchestratorPackage || snapshot.hasOrchestratorCommand || snapshot.hasSystemdUserOrchestratorService || (snapshot.runningOrchestrators?.length ?? 0) > 0);
+}
+
 function installedPackage(name: string, bunPackages: Map<string, string>, npmPackages: Map<string, string>): InstalledPackage | undefined {
   const bunVersion = bunPackages.get(name);
   if (bunVersion) return { version: bunVersion, source: "bun" };
@@ -292,6 +337,27 @@ async function runningServerVersion(): Promise<string | undefined> {
   }
 }
 
+async function runningOrchestrators(): Promise<UpgradeSnapshot["runningOrchestrators"]> {
+  try {
+    const headers: Record<string, string> = {};
+    if (process.env.AGENT_RELAY_TOKEN) headers["X-Agent-Relay-Token"] = process.env.AGENT_RELAY_TOKEN;
+    const relayUrl = (process.env.AGENT_RELAY_URL || "http://127.0.0.1:4850").replace(/\/+$/, "");
+    const response = await fetch(`${relayUrl}/api/orchestrators`, { headers });
+    if (!response.ok) return [];
+    const payload = await response.json() as Array<{ id?: string; version?: string; protocolVersion?: number; health?: { status?: string; restartRequired?: boolean } }>;
+    return payload
+      .filter((orch) => typeof orch.id === "string")
+      .map((orch) => ({
+        id: orch.id!,
+        version: orch.version,
+        protocolVersion: orch.protocolVersion,
+        health: orch.health,
+      }));
+  } catch {
+    return [];
+  }
+}
+
 function hasSystemdUserService(name: string): boolean {
   if (!commandExists("systemctl")) return false;
   const result = runCommand(["systemctl", "--user", "status", name, "--no-pager"]);
@@ -372,6 +438,13 @@ function formatClaudePlugins(installs: ClaudePluginInstall[]): string {
   return installs.map((install) => `${install.version ?? "unknown"} (${install.scope ?? "user"})`).join(", ");
 }
 
+function formatRunningOrchestrators(orchestrators: UpgradeSnapshot["runningOrchestrators"]): string {
+  if (!orchestrators?.length) return "not detected";
+  return orchestrators
+    .map((orch) => `${orch.id}: ${orch.version ?? "unknown"}${orch.health?.restartRequired ? " (restart required)" : ""}`)
+    .join(", ");
+}
+
 function shellQuote(value: string): string {
   if (/^[a-zA-Z0-9_@%+=:,./-]+$/.test(value)) return value;
   return `'${value.replaceAll("'", "'\\''")}'`;