agent-relay-orchestrator 0.90.0 → 0.91.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-orchestrator",
-  "version": "0.90.0",
+  "version": "0.91.1",
   "description": "Agent Relay orchestrator — manages agent lifecycle across hosts",
   "type": "module",
   "bin": {
@@ -16,7 +16,7 @@
     "test": "bun test"
   },
   "dependencies": {
-    "agent-relay-sdk": "0.2.69"
+    "agent-relay-sdk": "0.2.70"
   },
   "devDependencies": {
     "@types/bun": "latest",

package/src/index.ts

@@ -1,4 +1,5 @@
 #!/usr/bin/env bun
+import { errMessage } from "agent-relay-sdk";
 import { loadConfig, initConfigFile } from "./config";
 import { createRelayClient } from "./relay";
 import type { ManagedSessionExitDiagnostics } from "./relay";
@@ -10,6 +11,7 @@ import { ProviderProbeCache } from "./provider-probe";
 import { sweepEmptyWorkspaceContainers, workspacesRoot } from "./workspace-probe";
 import { startOrchestratorMaintenanceScheduler } from "./maintenance";
 import { OrchestratorQuotaPoller } from "./quota-poller";
+import { SharedCallmuxSupervisor } from "./shared-callmux";
 
 const args = process.argv.slice(2);
 
@@ -52,6 +54,7 @@ const probeCache = new ProviderProbeCache(config);
 const relay = createRelayClient(config, probeCache);
 const control = createControlHandler(config, relay);
 const quotaPoller = new OrchestratorQuotaPoller(config, relay);
+const sharedCallmux = new SharedCallmuxSupervisor(config);
 
 const POLL_INTERVAL_MS = 3_000;
 const REGISTER_RETRY_MS = 5_000;
@@ -84,6 +87,11 @@ async function startup(): Promise<void> {
   // Host-local maintenance must run where the agent processes and tmux sockets live.
   startOrchestratorMaintenanceScheduler();
   quotaPoller.start();
+  try {
+    sharedCallmux.start();
+  } catch (err) {
+    console.error(`[orchestrator] Shared callmux supervisor failed to start: ${errMessage(err)}`);
+  }
 
   // Sweep empty workspace container dirs left behind by prior cleanups (#280).
   const swept = sweepEmptyWorkspaceContainers(workspacesRoot(config.baseDir));
@@ -211,6 +219,7 @@ async function shutdown(): Promise<void> {
   if (guestReaperTimer) clearInterval(guestReaperTimer);
   if (apiServer) apiServer.stop();
   quotaPoller.stop();
+  sharedCallmux.stop();
   relay.stopHeartbeatLoop();
   process.exit(0);
 }

package/src/shared-callmux.ts

@@ -0,0 +1,300 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join } from "node:path";
+import { errMessage, isRecord } from "agent-relay-sdk";
+import type { OrchestratorConfig } from "./config";
+import { agentRelayHome } from "./config";
+
+export const SHARED_MCP_URL_ENV = "AGENT_RELAY_SHARED_MCP_URL";
+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 GITHUB_TOOLS = [
+  "issue_read",
+  "issue_write",
+  "list_issues",
+  "add_issue_comment",
+  "search_issues",
+  "search_code",
+  "get_file_contents",
+  "sub_issue_write",
+];
+
+export interface SharedCallmuxOptions {
+  command: string;
+  host: string;
+  port: number;
+  url: string;
+  configPath: string;
+  sourceConfigPath: string;
+  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>;
+  setInterval(fn: () => void, ms: number): Timer;
+  clearInterval(timer: Timer): void;
+  setTimeout(fn: () => void, ms: number): Timer;
+  clearTimeout(timer: Timer): void;
+  log(message: string): void;
+}
+
+export function sharedCallmuxOptionsFromEnv(env: Record<string, string | undefined> = process.env): SharedCallmuxOptions {
+  const explicitUrl = env[SHARED_MCP_URL_ENV];
+  const parsed = explicitUrl ? parseListenerUrl(explicitUrl) : undefined;
+  const host = env[SHARED_CALLMUX_HOST_ENV] ?? parsed?.hostname ?? DEFAULT_SHARED_CALLMUX_HOST;
+  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] || "callmux",
+    host,
+    port,
+    url,
+    configPath: env[SHARED_CALLMUX_CONFIG_ENV] || join(agentRelayHome(), "callmux", "shared-listener.json"),
+    sourceConfigPath: env[SHARED_CALLMUX_SOURCE_CONFIG_ENV] || env.CALLMUX_CONFIG || join(homedir(), ".config", "callmux", "config.json"),
+    enabled: env[SHARED_CALLMUX_ENABLE_ENV] === "1",
+  };
+}
+
+export function sharedMcpListenerUrl(): string {
+  return sharedCallmuxOptionsFromEnv().url;
+}
+
+export function writeSharedCallmuxConfig(opts: Pick<SharedCallmuxOptions, "configPath" | "sourceConfigPath">): Record<string, unknown> {
+  const source = readJsonObject(opts.sourceConfigPath);
+  const sourceServers = isRecord(source.servers) ? source.servers : {};
+  const servers = {
+    tokenlean: cloneServer(sourceServers.tokenlean) ?? defaultTokenleanServer(),
+    github: cloneServer(sourceServers.github) ?? defaultGithubServer(),
+  };
+  const generated: Record<string, unknown> = {
+    $schema: CONFIG_SCHEMA,
+    servers,
+    cacheTtlSeconds: numberFromRecord(source, "cacheTtlSeconds") ?? 10,
+    maxConcurrency: numberFromRecord(source, "maxConcurrency") ?? 20,
+    callTimeoutMs: numberFromRecord(source, "callTimeoutMs") ?? 180_000,
+    outputFormat: stringFromRecord(source, "outputFormat") ?? "auto",
+  };
+  mkdirSync(dirname(opts.configPath), { recursive: true });
+  writeFileSync(opts.configPath, JSON.stringify(generated, null, 2) + "\n", { mode: 0o600 });
+  return generated;
+}
+
+export class SharedCallmuxSupervisor {
+  private proc: SharedCallmuxProcess | null = null;
+  private healthTimer: Timer | null = null;
+  private restartTimer: Timer | null = null;
+  private stopping = false;
+  private backoffMs: number;
+
+  constructor(
+    private readonly config: OrchestratorConfig,
+    private readonly opts = sharedCallmuxOptionsFromEnv(),
+    private readonly deps: SharedCallmuxSupervisorDeps = defaultDeps(),
+    private readonly timing: { healthIntervalMs?: number; restartBaseMs?: number; restartMaxMs?: number } = {},
+  ) {
+    this.backoffMs = timing.restartBaseMs ?? 1_000;
+  }
+
+  start(): void {
+    if (!this.opts.enabled) {
+      this.deps.log("[orchestrator] shared callmux listener disabled (set AGENT_RELAY_SHARED_CALLMUX_ENABLE=1 to enable)");
+      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");
+      return;
+    }
+    this.spawn();
+    this.healthTimer = this.deps.setInterval(() => {
+      void this.checkHealth();
+    }, this.timing.healthIntervalMs ?? 10_000);
+  }
+
+  stop(): void {
+    this.stopping = true;
+    if (this.healthTimer) this.deps.clearInterval(this.healthTimer);
+    if (this.restartTimer) this.deps.clearTimeout(this.restartTimer);
+    this.healthTimer = null;
+    this.restartTimer = null;
+    if (this.proc) {
+      this.proc.kill("SIGTERM");
+      this.proc = null;
+    }
+  }
+
+  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) {
+      this.backoffMs = this.timing.restartBaseMs ?? 1_000;
+      return true;
+    }
+    this.deps.log(`[orchestrator] Shared callmux readiness failed at ${readyUrl}; restarting`);
+    this.restart("readiness failed");
+    return false;
+  }
+
+  private spawn(): void {
+    if (this.stopping || this.proc) return;
+    let proc: SharedCallmuxProcess;
+    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>,
+        ...this.config.env,
+        [SHARED_MCP_URL_ENV]: this.opts.url,
+      };
+      proc = this.deps.spawn(this.opts.command, args, { env, cwd: homedir() });
+    } catch (err) {
+      this.deps.log(`[orchestrator] Shared callmux listener failed to start: ${errMessage(err)}; scheduling restart`);
+      this.scheduleRestart();
+      return;
+    }
+    this.proc = proc;
+    this.deps.log(`[orchestrator] Started shared callmux listener pid=${proc.pid ?? "unknown"}`);
+    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.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.scheduleRestart();
+    });
+  }
+
+  private restart(reason: string): void {
+    if (this.proc) {
+      this.deps.log(`[orchestrator] Stopping shared callmux listener: ${reason}`);
+      this.proc.kill("SIGTERM");
+      this.proc = null;
+    }
+    this.scheduleRestart();
+  }
+
+  private scheduleRestart(): void {
+    if (this.stopping || this.restartTimer) return;
+    const delay = this.backoffMs;
+    this.backoffMs = Math.min(this.backoffMs * 2, this.timing.restartMaxMs ?? 30_000);
+    this.restartTimer = this.deps.setTimeout(() => {
+      this.restartTimer = null;
+      this.spawn();
+    }, 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,
+    setInterval: (fn, ms) => setInterval(fn, ms),
+    clearInterval: (timer) => clearInterval(timer),
+    setTimeout: (fn, ms) => setTimeout(fn, ms),
+    clearTimeout: (timer) => clearTimeout(timer),
+    log: (message) => console.error(message),
+  };
+}
+
+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 readJsonObject(path: string): Record<string, unknown> {
+  if (!existsSync(path)) return {};
+  const parsed = JSON.parse(readFileSync(path, "utf8"));
+  return isRecord(parsed) ? parsed : {};
+}
+
+function cloneServer(value: unknown): Record<string, unknown> | undefined {
+  if (!isRecord(value)) return undefined;
+  return JSON.parse(JSON.stringify(value)) as Record<string, unknown>;
+}
+
+function defaultTokenleanServer(): Record<string, unknown> {
+  return {
+    command: "tl-mcp",
+    prefix: "",
+    alwaysLoad: ["tl_symbols", "tl_snippet", "tl_pack", "tl_run", "tl_guard", "tl_lookup"],
+    requireSessionCwd: true,
+  };
+}
+
+function defaultGithubServer(): Record<string, unknown> {
+  return {
+    command: "github-mcp-server",
+    args: ["stdio"],
+    prefix: "gh",
+    callTimeoutMs: 60_000,
+    tools: GITHUB_TOOLS,
+    cachePolicy: { allowTools: ["issue_read", "list_issues", "search_issues", "search_code", "get_file_contents"] },
+  };
+}
+
+function numberEnv(value: string | undefined): number | undefined {
+  if (!value) return undefined;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
+}
+
+function numberFromRecord(value: Record<string, unknown>, key: string): number | undefined {
+  return typeof value[key] === "number" ? value[key] : undefined;
+}
+
+function stringFromRecord(value: Record<string, unknown>, key: string): string | undefined {
+  return typeof value[key] === "string" ? value[key] : undefined;
+}
+
+function parseListenerUrl(value: string): { hostname: string; port: number } | undefined {
+  try {
+    const url = new URL(value);
+    const port = Number(url.port) || (url.protocol === "https:" ? 443 : 80);
+    return { hostname: url.hostname, port };
+  } catch {
+    return undefined;
+  }
+}

package/src/spawn/command.ts

@@ -3,6 +3,7 @@ import { homedir } from "node:os";
 import { isAbsolute, join, relative, resolve } from "node:path";
 import { artifactProxyBaseUrl } from "../artifact-proxy";
 import { bunBinFromEnv, type OrchestratorConfig } from "../config";
+import { SHARED_MCP_URL_ENV, sharedMcpListenerUrl } from "../shared-callmux";
 import { sanitizeFsName } from "agent-relay-sdk/fs-name";
 import type { SpawnOptions } from "./types";
 
@@ -92,6 +93,9 @@ export function buildEnv(opts: SpawnOptions & { label: string; agentId: string }
     ...(opts.label ? { AGENT_RELAY_LABEL: opts.label } : {}),
     ...(opts.policyName ? { AGENT_RELAY_POLICY: opts.policyName } : {}),
     ...(opts.spawnRequestId ? { AGENT_RELAY_SPAWN_REQUEST_ID: opts.spawnRequestId } : {}),
+    // #673 — the orchestrator owns the shared host callmux listener; runners consume this
+    // authoritative URL through the existing #672 sharedMcpUrl seam.
+    [SHARED_MCP_URL_ENV]: sharedMcpListenerUrl(),
     AGENT_RELAY_LIFECYCLE: opts.lifecycle ?? "persistent", AGENT_RELAY_WORKSPACE_MODE: opts.workspaceMode ?? "inherit",
     ...(opts.workspace ? { AGENT_RELAY_WORKSPACE_JSON: JSON.stringify(opts.workspace) } : {}),
     ...(opts.automationId ? { AGENT_RELAY_AUTOMATION_ID: opts.automationId } : {}),