agent-relay-orchestrator 0.104.2 → 0.104.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-orchestrator",
-  "version": "0.104.2",
+  "version": "0.104.5",
   "description": "Agent Relay orchestrator — manages agent lifecycle across hosts",
   "type": "module",
   "bin": {
@@ -9,7 +9,6 @@
   "files": [
     "src/**/*.ts",
     "!src/**/*.test.ts",
-    "vendor/**",
     "README.md"
   ],
   "scripts": {
@@ -18,7 +17,8 @@
   },
   "dependencies": {
     "agent-relay-providers": "0.104.0",
-    "agent-relay-sdk": "0.2.88"
+    "agent-relay-sdk": "0.2.90",
+    "callmux": "0.23.0"
   },
   "devDependencies": {
     "@types/bun": "latest",

package/src/shared-callmux.ts

@@ -1,7 +1,8 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { dirname, isAbsolute, join, resolve } from "node:path";
+import { dirname, join } from "node:path";
 import { errMessage, isRecord } from "agent-relay-sdk";
+import { createListener, type CallmuxConfig, type CreateListenerOptions, type ListenerHealthSnapshot, type ProgrammaticListener } from "callmux";
 import type { OrchestratorConfig } from "./config";
 import { agentRelayHome } from "./config";
 
@@ -10,14 +11,13 @@ export const SHARED_CALLMUX_HOST_ENV = "AGENT_RELAY_SHARED_CALLMUX_HOST";
 export const SHARED_CALLMUX_PORT_ENV = "AGENT_RELAY_SHARED_CALLMUX_PORT";
 export const SHARED_CALLMUX_CONFIG_ENV = "AGENT_RELAY_SHARED_CALLMUX_CONFIG";
 export const SHARED_CALLMUX_SOURCE_CONFIG_ENV = "AGENT_RELAY_SHARED_CALLMUX_SOURCE_CONFIG";
-export const SHARED_CALLMUX_COMMAND_ENV = "AGENT_RELAY_SHARED_CALLMUX_COMMAND";
 export const SHARED_CALLMUX_ENABLE_ENV = "AGENT_RELAY_SHARED_CALLMUX_ENABLE";
 
 export const DEFAULT_SHARED_CALLMUX_HOST = "127.0.0.1";
 export const DEFAULT_SHARED_CALLMUX_PORT = 4861;
 export const SHARED_CALLMUX_SERVER_NAMES = ["tokenlean", "github"] as const;
 
-const CONFIG_SCHEMA = "https://raw.githubusercontent.com/edimuj/callmux/main/schema.json";
+const CONFIG_SCHEMA = "callmux/schema.json";
 const GITHUB_TOOLS = [
   "issue_read",
   "issue_write",
@@ -30,7 +30,6 @@ const GITHUB_TOOLS = [
 ];
 
 export interface SharedCallmuxOptions {
-  command: string;
   host: string;
   port: number;
   url: string;
@@ -39,16 +38,8 @@ export interface SharedCallmuxOptions {
   enabled: boolean;
 }
 
-export interface SharedCallmuxProcess {
-  pid?: number;
-  exited: Promise<number | null>;
-  kill(signal?: NodeJS.Signals): void;
-}
-
 export interface SharedCallmuxSupervisorDeps {
-  which(command: string): string | null | undefined;
-  spawn(command: string, args: string[], opts: { env: Record<string, string>; cwd: string }): SharedCallmuxProcess;
-  fetch(url: string, init?: RequestInit): Promise<Response>;
+  createListener(options: CreateListenerOptions): Promise<ProgrammaticListener>;
   setInterval(fn: () => void, ms: number): Timer;
   clearInterval(timer: Timer): void;
   setTimeout(fn: () => void, ms: number): Timer;
@@ -58,11 +49,10 @@ export interface SharedCallmuxSupervisorDeps {
 }
 
 export interface SharedCallmuxHealthSnapshot {
-  state: "disabled" | "missing" | "starting" | "running" | "unhealthy" | "restarting" | "stopped";
+  state: "disabled" | "starting" | "running" | "unhealthy" | "restarting" | "stopped";
   url: string;
-  command?: string;
   reason?: string;
-  pid?: number;
+  downstream?: ListenerHealthSnapshot["downstream"];
 }
 
 export function sharedCallmuxOptionsFromEnv(env: Record<string, string | undefined> = process.env): SharedCallmuxOptions {
@@ -72,7 +62,6 @@ export function sharedCallmuxOptionsFromEnv(env: Record<string, string | undefin
   const port = numberEnv(env[SHARED_CALLMUX_PORT_ENV]) ?? parsed?.port ?? DEFAULT_SHARED_CALLMUX_PORT;
   const url = explicitUrl ?? `http://${host}:${port}/mcp`;
   return {
-    command: env[SHARED_CALLMUX_COMMAND_ENV] || bundledCallmuxCommand() || "callmux",
     host,
     port,
     url,
@@ -86,30 +75,31 @@ export function sharedMcpListenerUrl(): string {
   return sharedCallmuxOptionsFromEnv().url;
 }
 
-export function writeSharedCallmuxConfig(opts: Pick<SharedCallmuxOptions, "configPath" | "sourceConfigPath">): Record<string, unknown> {
+export function writeSharedCallmuxConfig(opts: Pick<SharedCallmuxOptions, "configPath" | "sourceConfigPath">): CallmuxConfig {
   const source = readJsonObject(opts.sourceConfigPath);
   const sourceServers = isRecord(source.servers) ? source.servers : {};
-  const servers = {
+  const servers: CallmuxConfig["servers"] = {
     tokenlean: cloneServer(sourceServers.tokenlean) ?? defaultTokenleanServer(),
     github: cloneServer(sourceServers.github) ?? defaultGithubServer(),
   };
-  const generated: Record<string, unknown> = {
-    $schema: CONFIG_SCHEMA,
+  const generated: CallmuxConfig = {
     servers,
     cacheTtlSeconds: numberFromRecord(source, "cacheTtlSeconds") ?? 10,
     maxConcurrency: numberFromRecord(source, "maxConcurrency") ?? 20,
     callTimeoutMs: numberFromRecord(source, "callTimeoutMs") ?? 180_000,
-    outputFormat: stringFromRecord(source, "outputFormat") ?? "auto",
+    outputFormat: outputFormatFromRecord(source, "outputFormat") ?? "auto",
     // Relay workers consume only proxied tokenlean+github tools; suppress callmux meta-tools.
     exposeMetaTools: false,
   };
+  const persisted = { $schema: CONFIG_SCHEMA, ...generated };
   mkdirSync(dirname(opts.configPath), { recursive: true });
-  writeFileSync(opts.configPath, JSON.stringify(generated, null, 2) + "\n", { mode: 0o600 });
+  writeFileSync(opts.configPath, JSON.stringify(persisted, null, 2) + "\n", { mode: 0o600 });
   return generated;
 }
 
 export class SharedCallmuxSupervisor {
-  private proc: SharedCallmuxProcess | null = null;
+  private listener: ProgrammaticListener | null = null;
+  private readonly onStatus = (snapshot: ListenerHealthSnapshot) => this.reportCallmuxHealth(snapshot);
   private healthTimer: Timer | null = null;
   private restartTimer: Timer | null = null;
   private stopping = false;
@@ -131,13 +121,8 @@ export class SharedCallmuxSupervisor {
       return;
     }
     this.deps.log(`[orchestrator] Shared callmux listener: ${this.opts.url}`);
-    if (!this.deps.which(this.opts.command)) {
-      this.deps.log("[orchestrator] shared callmux not found — shared listener dormant");
-      this.report("missing", "command not found");
-      return;
-    }
     this.report("starting");
-    this.spawn();
+    void this.open();
     this.healthTimer = this.deps.setInterval(() => {
       void this.checkHealth();
     }, this.timing.healthIntervalMs ?? 10_000);
@@ -149,86 +134,85 @@ export class SharedCallmuxSupervisor {
     if (this.restartTimer) this.deps.clearTimeout(this.restartTimer);
     this.healthTimer = null;
     this.restartTimer = null;
-    if (this.proc) {
-      this.proc.kill("SIGTERM");
-      this.proc = null;
+    if (this.listener) {
+      const listener = this.listener;
+      this.listener = null;
+      listener.off("status", this.onStatus);
+      void listener.stop().catch((err) => this.deps.log(`[orchestrator] Shared callmux listener stop failed: ${errMessage(err)}`));
     }
   }
 
   async checkHealth(): Promise<boolean> {
     if (!this.opts.enabled) return true;
-    const readyUrl = new URL("/ready", this.opts.url).toString();
-    let ok = false;
-    try {
-      const response = await this.deps.fetch(readyUrl, { signal: AbortSignal.timeout(2_000) });
-      ok = response.ok;
-    } catch {
-      ok = false;
-    }
-    if (ok) {
+    const snapshot = this.listener?.health();
+    if (!snapshot) return false;
+    this.reportCallmuxHealth(snapshot);
+    if (snapshot.state === "running" || snapshot.state === "degraded" || snapshot.state === "reloading") {
       this.backoffMs = this.timing.restartBaseMs ?? 1_000;
-      this.report("running", undefined, this.proc?.pid);
-      return true;
+      return snapshot.state === "running";
     }
-    this.deps.log(`[orchestrator] Shared callmux readiness failed at ${readyUrl}; restarting`);
-    this.report("unhealthy", "readiness failed", this.proc?.pid);
-    this.restart("readiness failed");
+    this.deps.log(`[orchestrator] Shared callmux listener is ${snapshot.state}; restarting`);
+    this.restart(`listener ${snapshot.state}`);
     return false;
   }
 
-  private spawn(): void {
-    if (this.stopping || this.proc) return;
-    let proc: SharedCallmuxProcess;
+  private async open(): Promise<void> {
+    if (this.stopping || this.listener) return;
     try {
-      writeSharedCallmuxConfig(this.opts);
-      const args = ["--listen", String(this.opts.port), "--host", this.opts.host, "--config", this.opts.configPath];
-      const env = {
-        ...process.env as Record<string, string>,
+      const persistedConfig = writeSharedCallmuxConfig(this.opts);
+      const config = withRuntimeEnv(persistedConfig, {
         ...this.config.env,
         [SHARED_MCP_URL_ENV]: this.opts.url,
-      };
-      proc = this.deps.spawn(this.opts.command, args, { env, cwd: homedir() });
+      });
+      const listener = await this.deps.createListener({
+        host: this.opts.host,
+        port: this.opts.port,
+        config,
+        configPath: this.opts.configPath,
+      });
+      if (this.stopping) {
+        await listener.stop();
+        return;
+      }
+      this.listener = listener;
+      listener.on("status", this.onStatus);
+      this.deps.log(`[orchestrator] Started shared callmux listener at ${listener.mcpUrl}`);
+      this.reportCallmuxHealth(listener.health());
     } catch (err) {
       this.deps.log(`[orchestrator] Shared callmux listener failed to start: ${errMessage(err)}; scheduling restart`);
       this.report("restarting", errMessage(err));
       this.scheduleRestart();
-      return;
     }
-    this.proc = proc;
-    this.deps.log(`[orchestrator] Started shared callmux listener pid=${proc.pid ?? "unknown"}`);
-    this.report("running", undefined, proc.pid);
-    proc.exited.then((code) => {
-      if (this.proc !== proc || this.stopping) return;
-      this.proc = null;
-      this.deps.log(`[orchestrator] Shared callmux listener exited (${code ?? "signal"}); scheduling restart`);
-      this.report("restarting", `exited ${code ?? "signal"}`);
-      this.scheduleRestart();
-    }).catch((err) => {
-      if (this.proc !== proc || this.stopping) return;
-      this.proc = null;
-      this.deps.log(`[orchestrator] Shared callmux listener exit watcher failed: ${err}`);
-      this.report("restarting", errMessage(err));
-      this.scheduleRestart();
-    });
   }
 
   private restart(reason: string): void {
-    if (this.proc) {
+    if (this.listener) {
+      const listener = this.listener;
       this.deps.log(`[orchestrator] Stopping shared callmux listener: ${reason}`);
-      this.proc.kill("SIGTERM");
-      this.proc = null;
+      this.listener = null;
+      listener.off("status", this.onStatus);
+      void listener.stop().catch((err) => this.deps.log(`[orchestrator] Shared callmux listener stop failed: ${errMessage(err)}`));
     }
     this.report("restarting", reason);
     this.scheduleRestart();
   }
 
-  private report(state: SharedCallmuxHealthSnapshot["state"], reason?: string, pid?: number): void {
+  private report(state: SharedCallmuxHealthSnapshot["state"], reason?: string, downstream?: ListenerHealthSnapshot["downstream"]): void {
     this.deps.report({
       state,
       url: this.opts.url,
-      command: this.opts.command,
       ...(reason ? { reason } : {}),
-      ...(pid ? { pid } : {}),
+      ...(downstream ? { downstream } : {}),
+    });
+  }
+
+  private reportCallmuxHealth(snapshot: ListenerHealthSnapshot): void {
+    const state = mapCallmuxState(snapshot);
+    this.deps.report({
+      state,
+      url: snapshot.mcpUrl,
+      ...(snapshot.reason ? { reason: snapshot.reason } : state === "unhealthy" && snapshot.downstream.failed > 0 ? { reason: `${snapshot.downstream.failed} downstream server(s) failed` } : {}),
+      downstream: snapshot.downstream,
     });
   }
 
@@ -238,29 +222,14 @@ export class SharedCallmuxSupervisor {
     this.backoffMs = Math.min(this.backoffMs * 2, this.timing.restartMaxMs ?? 30_000);
     this.restartTimer = this.deps.setTimeout(() => {
       this.restartTimer = null;
-      this.spawn();
+      void this.open();
     }, delay);
   }
 }
 
 function defaultDeps(): SharedCallmuxSupervisorDeps {
   return {
-    which: resolveCommand,
-    spawn(command, args, opts) {
-      const proc = Bun.spawn([command, ...args], {
-        cwd: opts.cwd,
-        env: opts.env,
-        stdin: "ignore",
-        stdout: "inherit",
-        stderr: "inherit",
-      });
-      return {
-        pid: proc.pid,
-        exited: proc.exited,
-        kill: (signal?: NodeJS.Signals) => proc.kill(signal),
-      };
-    },
-    fetch,
+    createListener,
     setInterval: (fn, ms) => setInterval(fn, ms),
     clearInterval: (timer) => clearInterval(timer),
     setTimeout: (fn, ms) => setTimeout(fn, ms),
@@ -270,15 +239,11 @@ function defaultDeps(): SharedCallmuxSupervisorDeps {
   };
 }
 
-export function bundledCallmuxCommand(): string | null {
-  const candidate = resolve(import.meta.dir, "../vendor/callmux/bin/callmux.js");
-  return existsSync(candidate) ? candidate : null;
-}
-
-function resolveCommand(command: string): string | null {
-  if (isAbsolute(command)) return existsSync(command) ? command : null;
-  if (command.includes("/")) return existsSync(command) ? command : null;
-  return Bun.which(command);
+function mapCallmuxState(snapshot: ListenerHealthSnapshot): SharedCallmuxHealthSnapshot["state"] {
+  if (snapshot.state === "running") return "running";
+  if (snapshot.state === "starting" || snapshot.state === "reloading") return "starting";
+  if (snapshot.state === "stopped") return "stopped";
+  return "unhealthy";
 }
 
 function envOff(value: string | undefined): boolean {
@@ -292,12 +257,26 @@ function readJsonObject(path: string): Record<string, unknown> {
   return isRecord(parsed) ? parsed : {};
 }
 
-function cloneServer(value: unknown): Record<string, unknown> | undefined {
+function cloneServer(value: unknown): CallmuxConfig["servers"][string] | undefined {
   if (!isRecord(value)) return undefined;
-  return JSON.parse(JSON.stringify(value)) as Record<string, unknown>;
+  return JSON.parse(JSON.stringify(value)) as CallmuxConfig["servers"][string];
+}
+
+function withRuntimeEnv(config: CallmuxConfig, env: Record<string, string>): CallmuxConfig {
+  const envEntries = Object.entries(env).filter(([, value]) => typeof value === "string");
+  if (envEntries.length === 0) return config;
+  const inheritedEnv = Object.fromEntries(envEntries);
+  const servers = Object.fromEntries(Object.entries(config.servers).map(([name, server]) => {
+    if (!("command" in server)) return [name, server];
+    return [name, {
+      ...server,
+      env: { ...inheritedEnv, ...(isRecord(server.env) ? server.env as Record<string, string> : {}) },
+    }];
+  }));
+  return { ...config, servers };
 }
 
-function defaultTokenleanServer(): Record<string, unknown> {
+function defaultTokenleanServer(): CallmuxConfig["servers"][string] {
   return {
     command: "tl-mcp",
     prefix: "",
@@ -306,7 +285,7 @@ function defaultTokenleanServer(): Record<string, unknown> {
   };
 }
 
-function defaultGithubServer(): Record<string, unknown> {
+function defaultGithubServer(): CallmuxConfig["servers"][string] {
   return {
     command: "github-mcp-server",
     args: ["stdio"],
@@ -331,6 +310,11 @@ function stringFromRecord(value: Record<string, unknown>, key: string): string |
   return typeof value[key] === "string" ? value[key] : undefined;
 }
 
+function outputFormatFromRecord(value: Record<string, unknown>, key: string): CallmuxConfig["outputFormat"] | undefined {
+  const outputFormat = stringFromRecord(value, key);
+  return outputFormat === "auto" || outputFormat === "json" || outputFormat === "toon" ? outputFormat : undefined;
+}
+
 function parseListenerUrl(value: string): { hostname: string; port: number } | undefined {
   try {
     const url = new URL(value);