npm - agent-relay-server - Versions diffs - 0.4.25 → 0.4.26 - Mend

agent-relay-server 0.4.25 → 0.4.26

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4) hide show

package/README.md CHANGED Viewed

@@ -115,7 +115,7 @@ Launch with `AGENT_RELAY_PROFILE=backend-tester codex` or
 `AGENT_RELAY_PROFILE=backend-tester claude`. Explicit env vars override the
 profile where they overlap.
-Codex has additional tuning vars documented in [codex/README.md](codex/README.md).
+Codex has additional tuning vars documented in [codex/README.md](codex/README.md). The interactive `codex-relay` launcher starts `codex app-server` and connects the TUI with `codex --remote`; `codex-relay --headless` starts a relay-only session and prints a `codex resume --remote` attach command.
 Agent IDs are deterministic: `{hostname}-{project}-{session-hash}`.
@@ -270,11 +270,21 @@ Lifecycle: `agent-relay daemon status|logs|restart|stop|start|enable|disable|uni
 ### Version compatibility
-The plugin checks the server version on startup and warns if they diverge. Both packages share version numbers. Update them together:
+The provider integrations check the server version on startup and warn if they diverge. Server, Claude plugin, and Codex packages share version numbers. Upgrade a host with:
 ```bash
-systemctl --user restart agent-relay    # server pulls latest on restart
-claude plugin update agent-relay@agent-relay  # Claude plugin
+agent-relay upgrade --dry-run
+agent-relay upgrade --yes
+```
+`agent-relay upgrade` detects optional providers. It refreshes Codex when `codex-relay` is installed, updates the Claude plugin when `claude` has `agent-relay@agent-relay` installed, and restarts the managed `agent-relay.service` unless `--no-restart` is passed.
+Provider-specific aliases are available when you know what you want:
+```bash
+agent-relay upgrade --providers codex
+agent-relay upgrade --providers claude
+agent-relay-codex upgrade --dry-run
 ```
 ## API Reference

package/package.json CHANGED Viewed

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

package/src/cli.ts CHANGED Viewed

@@ -16,6 +16,13 @@ import {
   formatSetupPlan,
   pathExists,
 } from "./setup";
+import {
+  createUpgradePlan,
+  detectUpgradeSnapshot,
+  executeUpgradePlan,
+  formatUpgradePlan,
+  type UpgradeProvider,
+} from "./upgrade";
 import { VERSION } from "./config";
 const HELP = `
@@ -24,6 +31,8 @@ agent-relay ${VERSION}
 Usage:
   agent-relay [start]
   agent-relay setup [--yes] [--dry-run] [--force] [--env-file PATH] [--host HOST] [--port PORT] [--db-path PATH] [--token TOKEN|--no-token]
+  agent-relay upgrade [--dry-run] [--version VERSION] [--providers auto|all|codex|claude] [--no-restart] [--yes]
+  agent-relay setup upgrade [same options as upgrade]
   agent-relay daemon <install|uninstall|start|stop|restart|enable|disable|status|logs> [options]
   agent-relay pair <target|create|status|accept|reject|hangup|send> [options]
   agent-relay message <target> <body> [options]
@@ -62,6 +71,13 @@ Daemon options:
   --yes             Skip confirmation prompts
   --force           Overwrite/remove managed-file guardrails
   --json            Print structured output
+Upgrade options:
+  --version VERSION Target version (default: latest published server version)
+  --providers LIST  Provider integrations to upgrade: auto, all, codex, claude
+  --no-restart      Do not restart agent-relay.service
+  --dry-run         Print detected state and planned commands
+  --yes             Skip confirmation prompts
 `.trim();
 const DAEMON_ACTIONS = new Set<DaemonAction>([
@@ -87,6 +103,10 @@ export async function handleCli(args: string[]): Promise<"start" | "handled"> {
     console.log(VERSION);
     return "handled";
   }
+  if (command === "upgrade" || (command === "setup" && args[1] === "upgrade")) {
+    await handleUpgradeCommand(command === "setup" ? args.slice(2) : args.slice(1));
+    return "handled";
+  }
   if (command === "setup" || command === "init") {
     await handleSetupCommand(args.slice(1));
     return "handled";
@@ -122,6 +142,68 @@ export async function handleCli(args: string[]): Promise<"start" | "handled"> {
   throw new Error(`Unknown command "${command}". Run agent-relay --help.`);
 }
+async function handleUpgradeCommand(args: string[]): Promise<void> {
+  let targetVersion: string | undefined;
+  let dryRun = false;
+  let noRestart = false;
+  let yes = false;
+  let json = false;
+  const providers: UpgradeProvider[] = [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--version" && i + 1 < args.length) targetVersion = args[++i];
+    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 === "--codex") providers.push("codex");
+    else if (arg === "--claude") providers.push("claude");
+    else if (arg === "--all") providers.push("all");
+    else if (arg === "--dry-run") dryRun = true;
+    else if (arg === "--no-restart") noRestart = true;
+    else if (arg === "--yes" || arg === "-y") yes = true;
+    else if (arg === "--json") json = true;
+    else throw new Error(`Unknown upgrade option "${arg}"`);
+  }
+  const snapshot = await detectUpgradeSnapshot({
+    ...(targetVersion ? { targetVersion } : {}),
+    providers,
+    noRestart,
+  });
+  const plan = createUpgradePlan(snapshot, {
+    ...(targetVersion ? { targetVersion } : {}),
+    providers,
+    noRestart,
+  });
+  if (json) {
+    console.log(JSON.stringify({ plan }, null, 2));
+    return;
+  }
+  if (dryRun) {
+    console.log(formatUpgradePlan(plan, { dryRun: true }));
+    return;
+  }
+  if (!yes) {
+    console.log(formatUpgradePlan(plan));
+    const ok = await confirm("Run this upgrade plan?");
+    if (!ok) {
+      console.log("Upgrade cancelled.");
+      return;
+    }
+  }
+  console.log(await executeUpgradePlan(plan));
+}
+function parseUpgradeProvider(value: string): UpgradeProvider {
+  if (value === "auto" || value === "all" || value === "codex" || value === "claude") return value;
+  throw new Error(`Unknown upgrade provider "${value}". Expected auto, all, codex, or claude.`);
+}
 async function handleSlashOrPairCommand(command: string, args: string[]): Promise<void> {
   if (command === "/disconnect") {
     await handlePairCommand(["hangup", ...args]);

package/src/upgrade.ts ADDED Viewed

@@ -0,0 +1,378 @@
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { VERSION } from "./config";
+export type UpgradeProvider = "auto" | "all" | "codex" | "claude";
+export type UpgradeOptions = {
+  targetVersion?: string;
+  providers?: UpgradeProvider[];
+  noRestart?: boolean;
+};
+export type InstalledPackage = {
+  version?: string;
+  source: "bun" | "npm" | "copied" | "claude-plugin";
+  path?: string;
+};
+export type ClaudePluginInstall = {
+  id: string;
+  version?: string;
+  scope?: string;
+  installPath?: string;
+};
+export type UpgradeSnapshot = {
+  targetVersion: string;
+  serverPackage?: InstalledPackage;
+  codexPackage?: InstalledPackage;
+  codexCopiedPackage?: InstalledPackage;
+  claudePluginInstalls: ClaudePluginInstall[];
+  hasCodexCommand: boolean;
+  hasClaudeCommand: boolean;
+  hasSystemdUserService: boolean;
+  runningServerVersion?: string;
+  packageManager: "bun" | "npm" | "none";
+};
+export type UpgradeAction = {
+  label: string;
+  command: string[];
+  reason: string;
+  mutates: boolean;
+};
+export type UpgradePlan = {
+  targetVersion: string;
+  providers: { codex: boolean; claude: boolean };
+  snapshot: UpgradeSnapshot;
+  actions: UpgradeAction[];
+  warnings: string[];
+};
+type CommandResult = {
+  exitCode: number;
+  stdout: string;
+  stderr: string;
+};
+type Runner = (command: string[]) => CommandResult;
+export async function detectUpgradeSnapshot(options: UpgradeOptions = {}): Promise<UpgradeSnapshot> {
+  const targetVersion = options.targetVersion ?? await npmViewVersion("agent-relay-server@latest") ?? VERSION;
+  const bunPackages = commandExists("bun") ? bunGlobalPackages() : new Map<string, string>();
+  const npmPackages = commandExists("npm") ? npmGlobalPackages() : new Map<string, string>();
+  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")
+    ? "bun"
+    : npmPackages.has("agent-relay-server") || npmPackages.has("agent-relay-codex")
+      ? "npm"
+      : commandExists("bun")
+        ? "bun"
+        : commandExists("npm")
+          ? "npm"
+          : "none";
+  return {
+    targetVersion,
+    serverPackage: installedPackage("agent-relay-server", bunPackages, npmPackages),
+    codexPackage: installedPackage("agent-relay-codex", 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")),
+    hasClaudeCommand: commandExists("claude"),
+    hasSystemdUserService: hasSystemdUserService("agent-relay.service"),
+    runningServerVersion: await runningServerVersion(),
+    packageManager,
+  };
+}
+export function createUpgradePlan(snapshot: UpgradeSnapshot, options: UpgradeOptions = {}): UpgradePlan {
+  const targetVersion = options.targetVersion ?? snapshot.targetVersion;
+  const requestedProviders = options.providers?.length ? options.providers : ["auto"];
+  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 actions: UpgradeAction[] = [];
+  const warnings: string[] = [];
+  if (snapshot.packageManager === "none") {
+    warnings.push("No supported global package manager found. Install Bun or npm, then rerun `agent-relay upgrade`.");
+  } else {
+    const packages = [`agent-relay-server@${targetVersion}`];
+    if (codexRequested) packages.push(`agent-relay-codex@${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}.`,
+      mutates: true,
+    });
+  }
+  if (codexRequested) {
+    actions.push({
+      label: "Refresh Codex relay install",
+      command: ["agent-relay-codex", "install", "--alias"],
+      reason: "Refresh copied Codex package, launcher shims, hooks, and plugin marketplace files.",
+      mutates: true,
+    });
+  } else if (providerSet.has("auto") && !isCodexDetected(snapshot)) {
+    warnings.push("Codex provider not detected; skipping Codex integration upgrade.");
+  }
+  if (claudeRequested) {
+    if (snapshot.hasClaudeCommand && snapshot.claudePluginInstalls.length > 0) {
+      for (const scope of uniqueStrings(snapshot.claudePluginInstalls.map((install) => install.scope || "user"))) {
+        actions.push({
+          label: `Update Claude plugin (${scope})`,
+          command: ["claude", "plugin", "update", "agent-relay@agent-relay", "--scope", scope],
+          reason: "Update installed Claude Code Agent Relay plugin.",
+          mutates: true,
+        });
+      }
+    } else if (!snapshot.hasClaudeCommand) {
+      warnings.push("Claude Code command not detected; skipping Claude plugin upgrade.");
+    } else {
+      warnings.push("Claude Code detected, but agent-relay@agent-relay plugin is not installed; skipping Claude plugin upgrade.");
+    }
+  } else if (providerSet.has("auto") && !isClaudeRelayDetected(snapshot)) {
+    warnings.push("Claude Agent Relay plugin not detected; skipping Claude plugin 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.");
+    } else {
+      actions.push({
+        label: "Restart Agent Relay service",
+        command: ["systemctl", "--user", "restart", "agent-relay.service"],
+        reason: "Restart managed server so /api/stats reports the upgraded version.",
+        mutates: true,
+      });
+    }
+  } else {
+    warnings.push("No systemd user service detected; restart any manually running Agent Relay server yourself.");
+  }
+  return {
+    targetVersion,
+    providers: { codex: codexRequested, claude: claudeRequested },
+    snapshot: { ...snapshot, targetVersion },
+    actions,
+    warnings,
+  };
+}
+export async function executeUpgradePlan(plan: UpgradePlan, options: { dryRun?: boolean; runner?: Runner } = {}): Promise<string> {
+  if (options.dryRun) return formatUpgradePlan(plan, { dryRun: true });
+  const runner = options.runner ?? runCommand;
+  const lines = [`Upgrading Agent Relay to ${plan.targetVersion}`];
+  for (const action of plan.actions) {
+    lines.push(`\n${action.label}`);
+    lines.push(`$ ${action.command.map(shellQuote).join(" ")}`);
+    const result = runner(action.command);
+    if (result.stdout.trim()) lines.push(result.stdout.trim());
+    if (result.stderr.trim()) lines.push(result.stderr.trim());
+    if (result.exitCode !== 0) {
+      throw new Error(`${action.label} failed with exit code ${result.exitCode}`);
+    }
+  }
+  if (plan.actions.some((action) => action.command.join(" ") === "systemctl --user restart agent-relay.service")) {
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+    const serverVersion = await runningServerVersion();
+    if (serverVersion && serverVersion !== plan.targetVersion) {
+      throw new Error(`agent-relay.service restarted but /api/stats reports ${serverVersion}, expected ${plan.targetVersion}`);
+    }
+    if (serverVersion) lines.push(`Running server: ${serverVersion}`);
+  }
+  lines.push("\nUpgrade commands completed.");
+  if (plan.warnings.length > 0) {
+    lines.push("\nWarnings:");
+    for (const warning of plan.warnings) lines.push(`- ${warning}`);
+  }
+  return lines.join("\n");
+}
+export function formatUpgradePlan(plan: UpgradePlan, options: { dryRun?: boolean } = {}): string {
+  const lines = [
+    `${options.dryRun ? "Upgrade dry run" : "Upgrade plan"}: Agent Relay ${plan.targetVersion}`,
+    "",
+    "Detected:",
+    `- server package: ${formatPackage(plan.snapshot.serverPackage)}`,
+    `- running server: ${plan.snapshot.runningServerVersion ?? "unknown"}`,
+    `- codex package: ${formatPackage(plan.snapshot.codexPackage)}`,
+    `- codex copied package: ${formatPackage(plan.snapshot.codexCopiedPackage)}`,
+    `- claude command: ${plan.snapshot.hasClaudeCommand ? "yes" : "no"}`,
+    `- claude agent-relay plugin: ${formatClaudePlugins(plan.snapshot.claudePluginInstalls)}`,
+    `- systemd user service: ${plan.snapshot.hasSystemdUserService ? "yes" : "no"}`,
+    "",
+    `Providers: codex=${plan.providers.codex ? "yes" : "no"}, claude=${plan.providers.claude ? "yes" : "no"}`,
+    "",
+    "Actions:",
+  ];
+  if (plan.actions.length === 0) lines.push("- none");
+  for (const action of plan.actions) {
+    lines.push(`- ${action.label}: ${action.reason}`);
+    lines.push(`  ${action.command.map(shellQuote).join(" ")}`);
+  }
+  if (plan.warnings.length > 0) {
+    lines.push("", "Warnings:");
+    for (const warning of plan.warnings) lines.push(`- ${warning}`);
+  }
+  return lines.join("\n");
+}
+function isCodexDetected(snapshot: UpgradeSnapshot): boolean {
+  return Boolean(snapshot.codexPackage || snapshot.codexCopiedPackage || snapshot.hasCodexCommand);
+}
+function isClaudeRelayDetected(snapshot: UpgradeSnapshot): boolean {
+  return snapshot.claudePluginInstalls.length > 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" };
+  const npmVersion = npmPackages.get(name);
+  if (npmVersion) return { version: npmVersion, source: "npm" };
+  return undefined;
+}
+function bunGlobalPackages(): Map<string, string> {
+  const result = runCommand(["bun", "pm", "ls", "-g"]);
+  const packages = new Map<string, string>();
+  for (const line of result.stdout.split("\n")) {
+    const match = line.match(/(?:├──|└──)\s+(@?[^@\s]+(?:\/[^@\s]+)?)@([^\s]+)/);
+    if (match?.[1] && match[2]) packages.set(match[1], match[2]);
+  }
+  return packages;
+}
+function npmGlobalPackages(): Map<string, string> {
+  const result = runCommand(["npm", "list", "-g", "--depth=0", "--json"]);
+  const packages = new Map<string, string>();
+  if (result.exitCode !== 0 && !result.stdout.trim()) return packages;
+  try {
+    const parsed = JSON.parse(result.stdout) as { dependencies?: Record<string, { version?: string }> };
+    for (const [name, dep] of Object.entries(parsed.dependencies ?? {})) {
+      if (dep.version) packages.set(name, dep.version);
+    }
+  } catch {
+    // Ignore unparsable npm output; the plan can still use other signals.
+  }
+  return packages;
+}
+async function npmViewVersion(spec: string): Promise<string | undefined> {
+  if (!commandExists("npm")) return undefined;
+  const result = runCommand(["npm", "view", spec, "version"]);
+  return result.exitCode === 0 ? result.stdout.trim() || undefined : undefined;
+}
+async function runningServerVersion(): Promise<string | undefined> {
+  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/stats`, { headers });
+    if (!response.ok) return undefined;
+    const payload = await response.json() as { version?: string };
+    return payload.version;
+  } catch {
+    return undefined;
+  }
+}
+function hasSystemdUserService(name: string): boolean {
+  if (!commandExists("systemctl")) return false;
+  const result = runCommand(["systemctl", "--user", "status", name, "--no-pager"]);
+  return result.exitCode === 0 || result.stdout.includes("Loaded: loaded") || result.stderr.includes("Loaded: loaded");
+}
+function readPackageVersion(path: string): string | undefined {
+  if (!existsSync(path)) return undefined;
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8")) as { version?: string };
+    return parsed.version;
+  } catch {
+    return undefined;
+  }
+}
+function readClaudePluginInstalls(path: string): ClaudePluginInstall[] {
+  if (!existsSync(path)) return [];
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8")) as {
+      plugins?: Record<string, Array<{ scope?: string; installPath?: string; version?: string }>>;
+    };
+    return (parsed.plugins?.["agent-relay@agent-relay"] ?? []).map((install) => ({
+      id: "agent-relay@agent-relay",
+      version: install.version,
+      scope: install.scope,
+      installPath: install.installPath,
+    }));
+  } catch {
+    return [];
+  }
+}
+function commandExists(command: string): boolean {
+  const result = runCommand(["which", command]);
+  if (result.exitCode === 0) return true;
+  return [
+    join(homeDir(), ".local", "bin", command),
+    join(homeDir(), ".bun", "bin", command),
+    join(homeDir(), ".npm-global", "bin", command),
+    join(homeDir(), ".agent-relay", "codex", "bin", command),
+  ].some((path) => existsSync(path));
+}
+function runCommand(command: string[]): CommandResult {
+  try {
+    const result = Bun.spawnSync(command, { stdout: "pipe", stderr: "pipe" });
+    return {
+      exitCode: result.exitCode,
+      stdout: result.stdout?.toString() ?? "",
+      stderr: result.stderr?.toString() ?? "",
+    };
+  } catch (error) {
+    return {
+      exitCode: 127,
+      stdout: "",
+      stderr: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+function homeDir(): string {
+  return process.env.HOME || process.env.USERPROFILE || homedir();
+}
+function uniqueStrings(values: string[]): string[] {
+  return [...new Set(values.filter(Boolean))];
+}
+function formatPackage(pkg: InstalledPackage | undefined): string {
+  if (!pkg) return "not detected";
+  const path = pkg.path ? ` at ${pkg.path}` : "";
+  return `${pkg.version ?? "unknown"} (${pkg.source}${path})`;
+}
+function formatClaudePlugins(installs: ClaudePluginInstall[]): string {
+  if (installs.length === 0) return "not detected";
+  return installs.map((install) => `${install.version ?? "unknown"} (${install.scope ?? "user"})`).join(", ");
+}
+function shellQuote(value: string): string {
+  if (/^[a-zA-Z0-9_@%+=:,./-]+$/.test(value)) return value;
+  return `'${value.replaceAll("'", "'\\''")}'`;
+}