agent-relay-server 0.19.0 → 0.19.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-server",
-  "version": "0.19.0",
+  "version": "0.19.1",
   "description": "Lightweight HTTP message relay for inter-agent communication across machines",
   "module": "src/index.ts",
   "type": "module",

package/src/cli.ts

@@ -39,13 +39,14 @@ import {
   detectUpgradeSnapshot,
   executeUpgradePlan,
   formatUpgradePlan,
+  resolveLocalOrchestratorId,
   type UpgradeProvider,
 } from "./upgrade";
 import { formatMemoryBrokerSmokeResult, runMemoryBrokerSmoke } from "./memory-broker-smoke";
 import { MAX_BODY_BYTES, VERSION } from "./config";
 import { DEFAULT_CONTEXT_PROBE_STATE_DIR, runContextProbe } from "agent-relay-sdk/context-probe";
 import { shellQuote } from "agent-relay-sdk/shell-utils";
-import { RELAY_TOKEN_HEADER } from "agent-relay-sdk";
+import { errMessage, RELAY_TOKEN_HEADER } from "agent-relay-sdk";
 import type { WorkspaceDepsRefreshResult } from "agent-relay-sdk";
 
 const HELP = `
@@ -55,6 +56,8 @@ Usage:
   agent-relay [start]
   agent-relay setup [--yes] [--dry-run] [--force] [--env-file PATH] [--runtime-prefix DIR] [--host HOST] [--port PORT] [--db-path PATH] [--token TOKEN|--no-token]
   agent-relay upgrade [--dry-run] [--version VERSION] [--runtime-prefix DIR] [--providers auto|all|codex|claude|orchestrator] [--no-restart] [--yes]
+  agent-relay upgrade --host ID [--host ID2 ...] [--version VERSION] [--providers ...]   (upgrade remote orchestrator hosts over the relay)
+  agent-relay upgrade --all-hosts [...]                                                  (upgrade this host, then every behind remote host)
   agent-relay setup upgrade [same options as upgrade]
   agent-relay daemon <install|uninstall|start|stop|restart|enable|disable|status|logs> [options]
   agent-relay orchestrator install [options]
@@ -135,6 +138,8 @@ Upgrade options:
   --version VERSION Target version (default: latest published server version)
   --runtime-prefix DIR  Isolated Agent Relay npm prefix (default: ~/.agent-relay/runtime)
   --providers LIST  Provider integrations to upgrade: auto, all, codex, claude, orchestrator
+  --host ID         Upgrade a remote orchestrator host over the relay (repeatable). Skips the local upgrade
+  --all-hosts       Upgrade this host, then fan out to every connected remote host that is behind
   --no-restart      Do not restart agent-relay.service
   --dry-run         Print detected state and planned commands
   --yes             Skip confirmation prompts
@@ -391,6 +396,8 @@ async function handleUpgradeCommand(args: string[]): Promise<void> {
   let runtimePrefix: string | undefined;
   const pathPrefix: string[] = [];
   const providers: UpgradeProvider[] = [];
+  const hosts: string[] = [];
+  let allHosts = false;
 
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
@@ -399,6 +406,8 @@ async function handleUpgradeCommand(args: string[]): Promise<void> {
     else if (arg === "--providers" && i + 1 < args.length) {
       for (const provider of args[++i]!.split(",")) providers.push(parseUpgradeProvider(provider));
     } else if (arg === "--provider" && i + 1 < args.length) providers.push(parseUpgradeProvider(args[++i]!));
+    else if (arg === "--host" && i + 1 < args.length) hosts.push(args[++i]!);
+    else if (arg === "--all-hosts") allHosts = true;
     else if (arg === "--codex") providers.push("codex");
     else if (arg === "--claude") providers.push("claude");
     else if (arg === "--orchestrator") providers.push("orchestrator");
@@ -410,6 +419,14 @@ async function handleUpgradeCommand(args: string[]): Promise<void> {
     else throw new Error(`Unknown upgrade option "${arg}"`);
   }
 
+  // Remote-only: drive named hosts' self-upgrade over the relay command bus and
+  // skip the local upgrade entirely (#210). `--all-hosts` instead upgrades this
+  // host first, then fans out to every behind remote (handled after the local run).
+  if (hosts.length && !allHosts) {
+    await runRemoteOrchestratorUpgrades({ hosts, targetVersion, providers, json, dryRun, yes });
+    return;
+  }
+
   const snapshot = await detectUpgradeSnapshot({
     ...(targetVersion ? { targetVersion } : {}),
     ...(runtimePrefix ? { runtimePrefix } : {}),
@@ -425,11 +442,13 @@ async function handleUpgradeCommand(args: string[]): Promise<void> {
 
   if (json) {
     console.log(JSON.stringify({ plan }, null, 2));
+    if (allHosts) await runRemoteOrchestratorUpgrades({ allBehind: true, targetVersion: plan.targetVersion, providers, json, dryRun: true });
     return;
   }
 
   if (dryRun) {
     console.log(formatUpgradePlan(plan, { dryRun: true }));
+    if (allHosts) await runRemoteOrchestratorUpgrades({ allBehind: true, targetVersion: plan.targetVersion, providers, dryRun: true });
     return;
   }
 
@@ -443,6 +462,101 @@ async function handleUpgradeCommand(args: string[]): Promise<void> {
   }
 
   console.log(await executeUpgradePlan(plan));
+
+  if (allHosts) {
+    await runRemoteOrchestratorUpgrades({ allBehind: true, targetVersion: plan.targetVersion, providers, json, yes: true });
+  }
+}
+
+/**
+ * Trigger orchestrator self-upgrade on remote hosts via the relay command bus
+ * (#210). Each host installs its own runtime + self-restarts; the relay settles
+ * the version when it re-registers. Replaces the manual ssh + npm install dance.
+ */
+async function runRemoteOrchestratorUpgrades(opts: {
+  hosts?: string[];
+  allBehind?: boolean;
+  targetVersion?: string;
+  providers: UpgradeProvider[];
+  json?: boolean;
+  dryRun?: boolean;
+  yes?: boolean;
+}): Promise<void> {
+  const targetVersion = opts.targetVersion ?? VERSION;
+  const orchestrators = (await apiRequest("GET", "/api/orchestrators")) as Array<{
+    id: string;
+    version?: string;
+  }>;
+  const byId = new Map(orchestrators.map((orch) => [orch.id, orch]));
+  const localId = resolveLocalOrchestratorId();
+  // Default to "all" so a remote host's provider runner is upgraded too, not just
+  // the orchestrator package (matters for hosts running claude/codex agents).
+  const remoteProviders: UpgradeProvider[] = opts.providers.length ? opts.providers : ["all"];
+
+  let targets: string[];
+  if (opts.allBehind) {
+    targets = orchestrators
+      .filter((orch) => orch.id !== localId && orch.version && orch.version !== targetVersion)
+      .map((orch) => orch.id);
+    if (!targets.length) {
+      if (opts.json) console.log(JSON.stringify({ remoteUpgrades: [] }, null, 2));
+      else console.log(`No remote orchestrators behind ${targetVersion}.`);
+      return;
+    }
+  } else {
+    targets = opts.hosts ?? [];
+  }
+
+  if (opts.dryRun) {
+    const lines = targets.map((id) => {
+      const orch = byId.get(id);
+      const from = orch ? orch.version ?? "unknown" : "(not connected)";
+      return `  ${id}: ${from} → ${targetVersion} (providers: ${remoteProviders.join(",")})`;
+    });
+    if (opts.json) console.log(JSON.stringify({ remoteUpgrades: targets.map((id) => ({ id, targetVersion, providers: remoteProviders, dryRun: true })) }, null, 2));
+    else console.log(`Remote orchestrator upgrade plan → ${targetVersion}:\n${lines.join("\n")}`);
+    return;
+  }
+
+  if (!opts.yes && !opts.json) {
+    console.log(`Trigger remote orchestrator upgrade → ${targetVersion} for: ${targets.join(", ")}`);
+    const ok = await confirm("Send remote upgrade command(s)?");
+    if (!ok) {
+      console.log("Remote upgrade cancelled.");
+      return;
+    }
+  }
+
+  const results: Array<{ id: string; ok: boolean; message: string }> = [];
+  for (const id of targets) {
+    if (!byId.has(id)) {
+      results.push({ id, ok: false, message: "not connected to the relay" });
+      continue;
+    }
+    try {
+      const res = (await apiRequest("POST", `/api/orchestrators/${encodeURIComponent(id)}/action`, {
+        action: "upgrade",
+        targetVersion,
+        providers: remoteProviders,
+      })) as { command?: { id?: string } };
+      const from = byId.get(id)?.version;
+      results.push({ id, ok: true, message: `queued ${from ?? "?"} → ${targetVersion} (command ${res?.command?.id ?? "?"})` });
+    } catch (err) {
+      results.push({ id, ok: false, message: errMessage(err) });
+    }
+  }
+
+  if (opts.json) {
+    console.log(JSON.stringify({ remoteUpgrades: results }, null, 2));
+    return;
+  }
+  console.log(`\nRemote orchestrator upgrades → ${targetVersion}:`);
+  for (const result of results) console.log(`  ${result.ok ? "✓" : "✗"} ${result.id}: ${result.message}`);
+  console.log("\nEach host installs and self-restarts; the relay reconciles the version when it re-registers.");
+  console.log("Track progress in the dashboard Orchestrators view or via GET /api/orchestrators.");
+  if (results.some((result) => !result.ok)) {
+    process.exitCode = 1;
+  }
 }
 
 function parseUpgradeProvider(value: string): UpgradeProvider {

package/src/upgrade.ts

@@ -1,5 +1,5 @@
 import { existsSync, readFileSync } from "node:fs";
-import { homedir } from "node:os";
+import { homedir, hostname as osHostname } from "node:os";
 import { join, resolve } from "node:path";
 import { VERSION } from "./config";
 import type { RuntimeContracts, RuntimePackageMetadata } from "./contracts";
@@ -256,6 +256,8 @@ export type ExecuteUpgradeOptions = {
   sleep?: (ms: number) => Promise<void>;
   probeServerVersion?: () => Promise<string | undefined>;
   probeOrchestrators?: () => Promise<UpgradeSnapshot["runningOrchestrators"]>;
+  /** Override the local orchestrator id (defaults to the resolved host id). */
+  localOrchestratorId?: string;
 };
 
 export async function executeUpgradePlan(plan: UpgradePlan, options: ExecuteUpgradeOptions = {}): Promise<string> {
@@ -297,15 +299,35 @@ export async function executeUpgradePlan(plan: UpgradePlan, options: ExecuteUpgr
     if (serverVersion) lines.push(`Running server: ${serverVersion}`);
   }
   if (plan.actions.some((action) => action.command.join(" ") === "systemctl --user restart agent-relay-orchestrator.service")) {
+    // This command only upgrades the LOCAL runtime. Remote hosts run their own
+    // orchestrator runtime and upgrade separately, so the success check asserts
+    // the local orchestrator only — a behind remote host is advisory, never a
+    // failure (#210). Wait for the local one to re-register at the target.
+    const localId = options.localOrchestratorId ?? resolveLocalOrchestratorId();
     const orchestrators = await pollUntil(
       async () => (await probeOrchestrators()) ?? [],
-      (list) => list.length > 0 && list.every((orch) => !orch.version || orch.version === plan.targetVersion),
+      (list) => {
+        const local = list.find((orch) => orch.id === localId);
+        return Boolean(local && (!local.version || local.version === plan.targetVersion));
+      },
     );
-    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}`);
+    const local = orchestrators.find((orch) => orch.id === localId);
+    if (local?.version && local.version !== plan.targetVersion) {
+      throw new Error(`agent-relay-orchestrator.service restarted but ${local.id} reports ${local.version}, expected ${plan.targetVersion}`);
+    }
+    if (local) {
+      lines.push(`Running orchestrator: ${local.id}${local.version ? ` ${local.version}` : ""}`);
+    } else {
+      lines.push(`Local orchestrator ${localId} has not re-registered with the relay yet; it should appear shortly.`);
+    }
+    const remoteBehind = orchestrators.filter((orch) => orch.id !== localId && orch.version && orch.version !== plan.targetVersion);
+    if (remoteBehind.length > 0) {
+      lines.push("");
+      lines.push(`Remote orchestrator(s) behind ${plan.targetVersion} (each host upgrades its own runtime):`);
+      for (const orch of remoteBehind) {
+        lines.push(`- ${orch.id} ${orch.version} → upgrade with: agent-relay upgrade --host ${orch.id}`);
+      }
     }
-    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) {
@@ -534,6 +556,29 @@ function homeDir(): string {
   return process.env.HOME || process.env.USERPROFILE || homedir();
 }
 
+/**
+ * Resolve the LOCAL host's orchestrator id the same way the orchestrator runtime
+ * does (orchestrator/src/config.ts): explicit config id, then
+ * AGENT_RELAY_ORCHESTRATOR_ID, then the hostname with dots hyphenated. The
+ * upgrade command only ever touches the local runtime, so this is the only
+ * orchestrator whose post-restart version it can legitimately assert (#210).
+ */
+export function resolveLocalOrchestratorId(homeDirOverride?: string): string {
+  const home = homeDirOverride ?? homeDir();
+  const configPath = join(home, ".agent-relay", "orchestrator.json");
+  if (existsSync(configPath)) {
+    try {
+      const parsed = JSON.parse(readFileSync(configPath, "utf8")) as { id?: string };
+      if (typeof parsed.id === "string" && parsed.id.trim()) return parsed.id.trim();
+    } catch {
+      // Unparsable config — fall through to env/hostname.
+    }
+  }
+  const envId = process.env.AGENT_RELAY_ORCHESTRATOR_ID?.trim();
+  if (envId) return envId;
+  return osHostname().replace(/\./g, "-");
+}
+
 function uniqueStrings(values: string[]): string[] {
   return [...new Set(values.filter(Boolean))];
 }