agent-relay-orchestrator 0.10.7 → 0.10.9

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "agent-relay-orchestrator",
-  "version": "0.10.7",
+  "version": "0.10.9",
   "description": "Agent Relay orchestrator — manages agent lifecycle across hosts",
   "type": "module",
   "bin": {
-    "agent-relay-orchestrator": "./src/index.ts"
+    "agent-relay-orchestrator": "src/index.ts"
   },
   "files": [
     "src/**/*.ts",

package/src/api.ts

@@ -1,6 +1,8 @@
 import { readdirSync, statSync } from "node:fs";
-import { dirname, join, resolve } from "node:path";
+import { dirname, join, relative, resolve } from "node:path";
 import type { OrchestratorConfig } from "./config";
+import { captureSession, listTmuxSessions } from "./tmux";
+import { VERSION } from "./version";
 
 interface DirectoryEntry {
   name: string;
@@ -15,9 +17,11 @@ interface DirectoryListing {
 }
 
 function listDirectories(requestedPath: string | undefined, baseDir: string): DirectoryListing {
-  const target = resolve(requestedPath || baseDir);
+  const base = resolve(baseDir);
+  const target = resolve(requestedPath || base);
+  const rel = relative(base, target);
 
-  if (!target.startsWith(baseDir) && target !== baseDir) {
+  if (rel && (rel.startsWith("..") || rel.startsWith("/"))) {
     throw new Error(`Path must be within baseDir: ${baseDir}`);
   }
 
@@ -31,10 +35,11 @@ function listDirectories(requestedPath: string | undefined, baseDir: string): Di
     .sort((a, b) => a.name.localeCompare(b.name));
 
   const parent = dirname(target);
+  const parentRel = relative(base, parent);
   return {
     path: target,
-    parent: parent.startsWith(baseDir) && parent !== target ? parent : undefined,
-    baseDir,
+    parent: parentRel && !parentRel.startsWith("..") && !parentRel.startsWith("/") && parent !== target ? parent : undefined,
+    baseDir: base,
     entries,
   };
 }
@@ -50,6 +55,24 @@ function error(message: string, status = 400): Response {
   return json({ error: message }, status);
 }
 
+function authorized(req: Request, config: OrchestratorConfig): boolean {
+  if (!config.token) return true;
+  return req.headers.get("x-agent-relay-token") === config.token;
+}
+
+async function commandVersion(command: string): Promise<string | undefined> {
+  try {
+    const proc = Bun.spawn(["bash", "-lc", `command -v ${command} >/dev/null && ${command} --version | head -n 1`], {
+      stdout: "pipe",
+      stderr: "ignore",
+    });
+    const out = await new Response(proc.stdout).text();
+    return (await proc.exited) === 0 ? out.trim() || undefined : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
 export function startApiServer(config: OrchestratorConfig): { stop(): void; url: string } {
   const server = Bun.serve({
     port: config.apiPort,
@@ -76,6 +99,45 @@ export function startApiServer(config: OrchestratorConfig): { stop(): void; url:
         }
       }
 
+      if (req.method === "GET" && url.pathname === "/api/providers") {
+        return (async () => {
+          const providers = await Promise.all(config.providers.map(async (provider) => {
+            const version = await commandVersion(provider);
+            return { name: provider, available: Boolean(version), version, runnerVersion: VERSION };
+          }));
+          return json({ providers });
+        })();
+      }
+
+      if (req.method === "GET" && url.pathname === "/api/sessions") {
+        return (async () => {
+          const sessions = await listTmuxSessions(config.tmuxPrefix);
+          return json({ sessions });
+        })();
+      }
+
+      if (req.method === "GET" && url.pathname === "/api/version") {
+        return json({
+          orchestrator: VERSION,
+          runner: VERSION,
+          adapters: Object.fromEntries(config.providers.map((provider) => [provider, VERSION])),
+        });
+      }
+
+      const logMatch = url.pathname.match(/^\/api\/logs\/([^/]+)$/);
+      if (req.method === "GET" && logMatch) {
+        if (!authorized(req, config)) return error("unauthorized", 401);
+        return (async () => {
+          try {
+            const session = decodeURIComponent(logMatch[1]!);
+            const lines = Number(url.searchParams.get("lines") || "100");
+            return json(await captureSession(session, config, Number.isFinite(lines) ? lines : 100));
+          } catch (e) {
+            return error((e as Error).message, 400);
+          }
+        })();
+      }
+
       if (req.method === "GET" && url.pathname === "/api/health") {
         return json({ ok: true, id: config.id, hostname: config.hostname });
       }

package/src/control.ts

@@ -1,6 +1,6 @@
 import type { OrchestratorConfig } from "./config";
 import type { ManagedAgentReport, RelayClient, RelayCommand } from "./relay";
-import { spawnAgent, type SpawnOptions } from "./tmux";
+import { spawnAgent, stopSession, type SpawnOptions } from "./tmux";
 
 interface ControlHandler {
   handleCommand(command: RelayCommand): Promise<boolean>;
@@ -21,6 +21,11 @@ export function createControlHandler(
       label: ctrl.label,
       approvalMode: ctrl.approvalMode || "guarded",
       prompt: ctrl.prompt,
+      tags: Array.isArray(ctrl.tags) ? ctrl.tags.filter((item): item is string => typeof item === "string") : undefined,
+      capabilities: Array.isArray(ctrl.capabilities) ? ctrl.capabilities.filter((item): item is string => typeof item === "string") : undefined,
+      providerArgs: Array.isArray(ctrl.providerArgs) ? ctrl.providerArgs.filter((item): item is string => typeof item === "string") : undefined,
+      policyName: typeof ctrl.policyName === "string" ? ctrl.policyName : undefined,
+      spawnRequestId: typeof ctrl.spawnRequestId === "string" ? ctrl.spawnRequestId : undefined,
     };
 
     try {
@@ -34,14 +39,36 @@ export function createControlHandler(
     }
   }
 
+  async function handleShutdown(ctrl: Record<string, any>, restart = false): Promise<Record<string, unknown>> {
+    const session = typeof ctrl.tmuxSession === "string"
+      ? ctrl.tmuxSession
+      : managedAgents.find((agent) => agent.agentId === ctrl.agentId || (ctrl.policyName && agent.policyName === ctrl.policyName))?.tmuxSession;
+    if (!session) return { stopped: false, wasRunning: false };
+    const result = await stopSession(session, config, typeof ctrl.reason === "string" ? ctrl.reason : restart ? "restart" : "shutdown", ctrl.graceful !== false);
+    managedAgents = managedAgents.filter((agent) => agent.tmuxSession !== session);
+    return {
+      ...result,
+      restart,
+      policyName: ctrl.policyName,
+      spawnRequestId: ctrl.spawnRequestId,
+      tmuxSession: session,
+    };
+  }
+
   async function handleCommand(command: RelayCommand): Promise<boolean> {
     await relay.updateCommand(command.id, "accepted");
     await relay.updateCommand(command.id, "running");
     try {
-      if (command.type !== "agent.spawn") throw new Error(`unsupported orchestrator command: ${command.type}`);
-      const handled = await handleSpawn(command.params);
-      if (!handled) throw new Error("spawn failed");
-      await relay.updateCommand(command.id, "succeeded", { managedAgents });
+      if (command.type === "agent.spawn") {
+        const handled = await handleSpawn(command.params);
+        if (!handled) throw new Error("spawn failed");
+        await relay.updateCommand(command.id, "succeeded", { managedAgents });
+      } else if (command.type === "agent.shutdown" || command.type === "agent.restart") {
+        const result = await handleShutdown(command.params, command.type === "agent.restart");
+        await relay.updateCommand(command.id, "succeeded", result);
+      } else {
+        throw new Error(`unsupported orchestrator command: ${command.type}`);
+      }
       await relay.updateManagedAgents(managedAgents);
       return true;
     } catch (error) {

package/src/relay.ts

@@ -20,6 +20,8 @@ export interface ManagedAgentReport {
   cwd: string;
   label?: string;
   approvalMode: string;
+  policyName?: string;
+  spawnRequestId?: string;
   pid?: number;
   startedAt: number;
 }

package/src/tmux.ts

@@ -1,6 +1,6 @@
 import { existsSync } from "node:fs";
 import { homedir } from "node:os";
-import { join, resolve } from "node:path";
+import { isAbsolute, join, relative, resolve } from "node:path";
 import type { OrchestratorConfig } from "./config";
 import type { ManagedAgentReport } from "./relay";
 
@@ -12,20 +12,33 @@ export interface SpawnOptions {
   approvalMode: string;
   prompt?: string;
   env?: Record<string, string>;
+  tags?: string[];
+  capabilities?: string[];
+  providerArgs?: string[];
+  policyName?: string;
+  spawnRequestId?: string;
+  tmuxSession?: string;
 }
 
-interface TmuxSession {
+export interface TmuxSession {
   name: string;
   pid: number;
   attached: boolean;
 }
 
+export function isWithinBaseDir(path: string, baseDir: string): boolean {
+  const base = resolve(baseDir);
+  const target = resolve(path);
+  const rel = relative(base, target);
+  return rel === "" || (!!rel && !rel.startsWith("..") && !isAbsolute(rel));
+}
+
 export function sessionName(config: OrchestratorConfig, provider: string, label: string): string {
   const clean = label.replace(/[^a-zA-Z0-9._-]+/g, "-").toLowerCase();
   return `${config.tmuxPrefix}-${provider}-${clean}`;
 }
 
-async function listTmuxSessions(prefix: string): Promise<TmuxSession[]> {
+export async function listTmuxSessions(prefix: string): Promise<TmuxSession[]> {
   try {
     const proc = Bun.spawn(["tmux", "list-sessions", "-F", "#{session_name}\t#{pid}\t#{session_attached}"], {
       stdout: "pipe",
@@ -56,7 +69,7 @@ export function buildRunnerCommand(opts: SpawnOptions, config: OrchestratorConfi
   const repoLauncher = resolve(import.meta.dir, "../../runner/src/index.ts");
   const launcher = existsSync(repoLauncher)
     ? ["bun", "run", repoLauncher, opts.provider]
-    : [`${opts.provider}-relay`];
+    : [`${opts.provider}-relay`, opts.provider];
   const args = [
     ...launcher,
     "--headless",
@@ -67,6 +80,9 @@ export function buildRunnerCommand(opts: SpawnOptions, config: OrchestratorConfi
   if (opts.label) args.push("--label", opts.label);
   if (opts.agentId) args.push("--agent-id", opts.agentId);
   if (opts.prompt) args.push("--prompt", opts.prompt);
+  if (opts.tags?.length) args.push("--tags", opts.tags.join(","));
+  if (opts.capabilities?.length) args.push("--caps", opts.capabilities.join(","));
+  if (opts.providerArgs?.length) args.push("--", ...opts.providerArgs);
   return [
     ...args,
   ];
@@ -90,9 +106,14 @@ function buildEnv(opts: SpawnOptions, config: OrchestratorConfig): Record<string
     PATH: fullPath,
     AGENT_RELAY_URL: config.relayUrl,
     AGENT_RELAY_APPROVAL: opts.approvalMode || "guarded",
-    AGENT_RELAY_TAGS: ["headless", "dashboard-spawned", config.hostname].join(","),
+    AGENT_RELAY_TAGS: [...new Set(["headless", "dashboard-spawned", config.hostname, ...(opts.tags ?? [])])].join(","),
+    AGENT_RELAY_CAPS: [...new Set(opts.capabilities ?? [])].join(","),
+    AGENT_RELAY_CAPABILITIES: [...new Set(opts.capabilities ?? [])].join(","),
     AGENT_RELAY_HEADLESS: "1",
     ...(opts.label ? { AGENT_RELAY_LABEL: opts.label } : {}),
+    ...(opts.policyName ? { AGENT_RELAY_POLICY: opts.policyName } : {}),
+    ...(opts.spawnRequestId ? { AGENT_RELAY_SPAWN_REQUEST_ID: opts.spawnRequestId } : {}),
+    ...(opts.tmuxSession ? { AGENT_RELAY_TMUX_SESSION: opts.tmuxSession } : {}),
     ...(config.token ? { AGENT_RELAY_TOKEN: config.token } : {}),
   };
 }
@@ -103,13 +124,13 @@ export async function spawnAgent(
 ): Promise<ManagedAgentReport> {
   const label = opts.label || `${opts.provider}-${Date.now()}`;
   const agentId = opts.agentId || managedAgentId(config, opts.provider, label);
-  const spawnOpts: SpawnOptions = { ...opts, label, agentId };
   const name = sessionName(config, opts.provider, label);
+  const spawnOpts: SpawnOptions = { ...opts, label, agentId, tmuxSession: name };
 
   if (!existsSync(opts.cwd)) {
     throw new Error(`cwd does not exist: ${opts.cwd}`);
   }
-  if (!opts.cwd.startsWith(config.baseDir)) {
+  if (!isWithinBaseDir(opts.cwd, config.baseDir)) {
     throw new Error(`cwd must be within base directory: ${config.baseDir}`);
   }
 
@@ -159,11 +180,49 @@ export async function spawnAgent(
     cwd: spawnOpts.cwd,
     label,
     approvalMode: spawnOpts.approvalMode || "guarded",
+    policyName: spawnOpts.policyName,
+    spawnRequestId: spawnOpts.spawnRequestId,
     pid: pid ?? undefined,
     startedAt: Date.now(),
   };
 }
 
+export async function stopSession(name: string, config: OrchestratorConfig, reason: string, graceful = true): Promise<{ stopped: boolean; wasRunning: boolean }> {
+  if (!name.startsWith(`${config.tmuxPrefix}-`)) throw new Error("session is not managed by this orchestrator");
+  const wasRunning = await hasSession(name);
+  if (!wasRunning) return { stopped: false, wasRunning: false };
+  if (graceful) {
+    await Bun.spawn(["tmux", "send-keys", "-t", name, "C-c"], { stdout: "ignore", stderr: "ignore" }).exited;
+    await new Promise((resolve) => setTimeout(resolve, 500));
+  }
+  if (await hasSession(name)) {
+    await Bun.spawn(["tmux", "kill-session", "-t", name], {
+      stdout: "ignore",
+      stderr: "ignore",
+      env: { ...process.env, AGENT_RELAY_STOP_REASON: reason },
+    }).exited;
+  }
+  return { stopped: true, wasRunning };
+}
+
+export async function captureSession(name: string, config: OrchestratorConfig, lines = 100): Promise<{ session: string; lines: string[]; running: boolean }> {
+  if (!name.startsWith(`${config.tmuxPrefix}-`)) throw new Error("session is not managed by this orchestrator");
+  const running = await hasSession(name);
+  if (!running) return { session: name, lines: [], running };
+  const safeLines = Math.min(Math.max(lines, 1), 1000);
+  const proc = Bun.spawn(["tmux", "capture-pane", "-p", "-t", name, "-S", `-${safeLines}`], {
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  const out = await new Response(proc.stdout).text();
+  const code = await proc.exited;
+  if (code !== 0) {
+    const err = await new Response(proc.stderr).text();
+    throw new Error(err.trim() || "tmux capture failed");
+  }
+  return { session: name, lines: out.split("\n").filter(Boolean), running };
+}
+
 function managedAgentId(config: OrchestratorConfig, provider: string, label: string): string {
   const cleanHost = config.hostname.replace(/[^a-zA-Z0-9._-]+/g, "-").toLowerCase();
   const cleanLabel = label.replace(/[^a-zA-Z0-9._-]+/g, "-").toLowerCase();