agent-relay-orchestrator 0.111.0 → 0.113.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-orchestrator",
-  "version": "0.111.0",
+  "version": "0.113.0",
   "description": "Agent Relay orchestrator — manages agent lifecycle across hosts",
   "type": "module",
   "bin": {
@@ -17,7 +17,7 @@
   },
   "dependencies": {
     "agent-relay-providers": "0.104.1",
-    "agent-relay-sdk": "0.2.95",
+    "agent-relay-sdk": "0.2.96",
     "callmux": "0.23.0"
   },
   "devDependencies": {

package/src/shared-callmux.ts

@@ -15,7 +15,6 @@ 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 = "callmux/schema.json";
 const GITHUB_TOOLS = [
@@ -44,6 +43,7 @@ export interface SharedCallmuxSupervisorDeps {
   clearInterval(timer: Timer): void;
   setTimeout(fn: () => void, ms: number): Timer;
   clearTimeout(timer: Timer): void;
+  fetch(input: string | URL | Request, init?: RequestInit): Promise<Response>;
   log(message: string): void;
   report(snapshot: SharedCallmuxHealthSnapshot): void;
 }
@@ -67,7 +67,7 @@ export function sharedCallmuxOptionsFromEnv(env: Record<string, string | undefin
     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: !envOff(env[SHARED_CALLMUX_ENABLE_ENV]),
+  enabled: !envOff(env[SHARED_CALLMUX_ENABLE_ENV]),
   };
 }
 
@@ -75,13 +75,12 @@ export function sharedMcpListenerUrl(): string {
   return sharedCallmuxOptionsFromEnv().url;
 }
 
-export function writeSharedCallmuxConfig(opts: Pick<SharedCallmuxOptions, "configPath" | "sourceConfigPath">): CallmuxConfig {
+export function writeSharedCallmuxConfig(opts: Pick<SharedCallmuxOptions, "configPath" | "sourceConfigPath"> & { registryServers?: CallmuxConfig["servers"] }): CallmuxConfig {
   const source = readJsonObject(opts.sourceConfigPath);
   const sourceServers = isRecord(source.servers) ? source.servers : {};
-  const servers: CallmuxConfig["servers"] = {
-    tokenlean: cloneServer(sourceServers.tokenlean) ?? defaultTokenleanServer(),
-    github: cloneServer(sourceServers.github) ?? defaultGithubServer(),
-  };
+  const servers = opts.registryServers && Object.keys(opts.registryServers).length > 0
+    ? cloneServers(opts.registryServers)
+    : fallbackSharedServers(sourceServers);
   const generated: CallmuxConfig = {
     servers,
     cacheTtlSeconds: numberFromRecord(source, "cacheTtlSeconds") ?? 10,
@@ -97,6 +96,36 @@ export function writeSharedCallmuxConfig(opts: Pick<SharedCallmuxOptions, "confi
   return generated;
 }
 
+export async function fetchSharedCallmuxRegistryServers(
+  config: Pick<OrchestratorConfig, "relayUrl" | "token">,
+  deps: Pick<SharedCallmuxSupervisorDeps, "fetch" | "log"> = { fetch: globalThis.fetch.bind(globalThis), log: () => {} },
+): Promise<CallmuxConfig["servers"] | undefined> {
+  try {
+    const url = new URL("/api/provisioning/capabilities?kind=mcp", config.relayUrl);
+    const headers: Record<string, string> = {};
+    if (config.token) headers.Authorization = `Bearer ${config.token}`;
+    const res = await deps.fetch(url, { headers });
+    if (!res.ok) {
+      deps.log(`[orchestrator] Shared callmux registry fetch failed: ${res.status}`);
+      return undefined;
+    }
+    const payload = await res.json().catch(() => null) as unknown;
+    const capabilities = isRecord(payload) && Array.isArray(payload.capabilities) ? payload.capabilities : [];
+    const servers: CallmuxConfig["servers"] = {};
+    for (const capability of capabilities) {
+      if (!isRecord(capability) || !Array.isArray(capability.variants)) continue;
+      for (const variant of capability.variants) {
+        const entry = callmuxServerFromProvisioningVariant(variant);
+        if (entry) servers[entry.name] = entry.server;
+      }
+    }
+    return Object.keys(servers).length > 0 ? servers : undefined;
+  } catch (err) {
+    deps.log(`[orchestrator] Shared callmux registry fetch failed: ${errMessage(err)}`);
+    return undefined;
+  }
+}
+
 export class SharedCallmuxSupervisor {
   private listener: ProgrammaticListener | null = null;
   private readonly onStatus = (snapshot: ListenerHealthSnapshot) => this.reportCallmuxHealth(snapshot);
@@ -159,8 +188,10 @@ export class SharedCallmuxSupervisor {
   private async open(): Promise<void> {
     if (this.stopping || this.listener) return;
     try {
-      const persistedConfig = writeSharedCallmuxConfig(this.opts);
+      const registryServers = await fetchSharedCallmuxRegistryServers(this.config, this.deps);
+      const persistedConfig = writeSharedCallmuxConfig({ ...this.opts, ...(registryServers ? { registryServers } : {}) });
       const config = withRuntimeEnv(persistedConfig, {
+        ...process.env,
         ...this.config.env,
         [SHARED_MCP_URL_ENV]: this.opts.url,
       });
@@ -234,6 +265,7 @@ function defaultDeps(): SharedCallmuxSupervisorDeps {
     clearInterval: (timer) => clearInterval(timer),
     setTimeout: (fn, ms) => setTimeout(fn, ms),
     clearTimeout: (timer) => clearTimeout(timer),
+    fetch: globalThis.fetch.bind(globalThis),
     log: (message) => console.error(message),
     report: (snapshot) => console.error(`[orchestrator] shared callmux status ${snapshot.state}${snapshot.reason ? `: ${snapshot.reason}` : ""}`),
   };
@@ -262,20 +294,72 @@ function cloneServer(value: unknown): CallmuxConfig["servers"][string] | undefin
   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);
+function cloneServers(value: CallmuxConfig["servers"]): CallmuxConfig["servers"] {
+  return Object.fromEntries(Object.entries(value).map(([name, server]) => [name, cloneServer(server) ?? server]));
+}
+
+function fallbackSharedServers(sourceServers: Record<string, unknown>): CallmuxConfig["servers"] {
+  return {
+    tokenlean: cloneServer(sourceServers.tokenlean) ?? defaultTokenleanServer(),
+    github: cloneServer(sourceServers.github) ?? defaultGithubServer(),
+  };
+}
+
+function callmuxServerFromProvisioningVariant(value: unknown): { name: string; server: CallmuxConfig["servers"][string] } | null {
+  if (!isRecord(value) || value.enabled === false || value.approvalStatus === "pending" || value.validationStatus === "invalid") return null;
+  if (typeof value.name !== "string" || !value.name) return null;
+  const definition = value.definition;
+  if (!isRecord(definition) || definition.kind !== "mcp" || !isRecord(definition.server)) return null;
+  const metadata = isRecord(definition.metadata) ? definition.metadata : {};
+  const provenance = isRecord(value.provenance) ? value.provenance : {};
+  if (metadata.sharedListenerEligible !== true && provenance.sharedListenerEligible !== true) return null;
+  const callmuxServer = isRecord(metadata.callmuxServer) ? metadata.callmuxServer : callmuxServerFromMcpServer(definition.server);
+  const server = cloneServer(callmuxServer);
+  return server ? { name: value.name, server } : null;
+}
+
+function callmuxServerFromMcpServer(server: Record<string, unknown>): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  if (typeof server.command === "string") {
+    out.command = server.command;
+    if (Array.isArray(server.args)) out.args = server.args.filter((arg): arg is string => typeof arg === "string");
+    if (isRecord(server.env)) out.env = server.env;
+  } else if (typeof server.url === "string") {
+    out.url = server.url;
+    if (server.type === "sse") out.transport = "sse";
+    if (isRecord(server.headers)) out.headers = server.headers;
+  }
+  return out;
+}
+
+function withRuntimeEnv(config: CallmuxConfig, env: Record<string, string | undefined>): CallmuxConfig {
+  const inheritedEnv: Record<string, string> = {};
+  for (const [key, value] of Object.entries(env)) {
+    if (typeof value === "string") inheritedEnv[key] = value;
+  }
+  if (Object.keys(inheritedEnv).length === 0) return config;
   const servers = Object.fromEntries(Object.entries(config.servers).map(([name, server]) => {
-    if (!("command" in server)) return [name, server];
+    const rawHeaders = "headers" in server && isRecord(server.headers) ? server.headers as Record<string, string> : undefined;
+    const headers = rawHeaders ? expandStringRecordPlaceholders(rawHeaders, inheritedEnv) : undefined;
+    if (!("command" in server)) return [name, { ...server, ...(headers ? { headers } : {}) }];
+    const serverEnv = isRecord(server.env) ? expandStringRecordPlaceholders(server.env as Record<string, string>, inheritedEnv) : {};
     return [name, {
       ...server,
-      env: { ...inheritedEnv, ...(isRecord(server.env) ? server.env as Record<string, string> : {}) },
+      env: { ...inheritedEnv, ...serverEnv },
+      ...(headers ? { headers } : {}),
     }];
   }));
   return { ...config, servers };
 }
 
+function expandStringRecordPlaceholders(value: Record<string, string>, env: Record<string, string>): Record<string, string> {
+  return Object.fromEntries(Object.entries(value).map(([key, raw]) => [key, expandEnvPlaceholders(raw, env)]));
+}
+
+function expandEnvPlaceholders(value: string, env: Record<string, string>): string {
+  return value.replace(/\$\{?([A-Z_][A-Z0-9_]*)\}?/g, (match, key: string) => env[key] ?? match);
+}
+
 function defaultTokenleanServer(): CallmuxConfig["servers"][string] {
   return {
     command: "tl-mcp",