agent-relay-server 0.4.38 → 0.5.0

package/src/agent-spawn.ts

@@ -0,0 +1,137 @@
+import { existsSync, mkdirSync, readdirSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, delimiter, dirname, join, resolve } from "node:path";
+
+export type CodexSpawnApprovalMode = "open" | "guarded" | "read-only";
+
+interface CodexSpawnInput {
+  cwd?: string;
+  approvalMode: CodexSpawnApprovalMode;
+  label?: string;
+  relayUrl: string;
+  token?: string;
+  dryRun?: boolean;
+}
+
+interface CodexSpawnResult {
+  provider: "codex";
+  pid?: number;
+  cwd: string;
+  approvalMode: CodexSpawnApprovalMode;
+  logPath: string;
+  command: string[];
+  dryRun?: boolean;
+}
+
+interface HostDirectoryEntry {
+  name: string;
+  path: string;
+}
+
+interface HostDirectoryListing {
+  path: string;
+  parent?: string;
+  home: string;
+  cwd: string;
+  entries: HostDirectoryEntry[];
+}
+
+export function normalizeCodexSpawnCwd(raw: string | undefined, fallback = process.cwd()): string {
+  const cwd = resolve(raw || fallback);
+  if (!existsSync(cwd) || !statSync(cwd).isDirectory()) {
+    throw new Error(`cwd does not exist or is not a directory: ${cwd}`);
+  }
+  return cwd;
+}
+
+export function listHostDirectories(raw: string | undefined): HostDirectoryListing {
+  const cwd = process.cwd();
+  const home = homedir();
+  const path = normalizeCodexSpawnCwd(raw || cwd, cwd);
+  const entries = readdirSync(path, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory() && !entry.name.startsWith("."))
+    .map((entry) => ({
+      name: entry.name,
+      path: join(path, entry.name),
+    }))
+    .sort((a, b) => a.name.localeCompare(b.name));
+  const parent = dirname(path);
+  return {
+    path,
+    parent: parent !== path ? parent : undefined,
+    home,
+    cwd,
+    entries,
+  };
+}
+
+export function codexSpawnCommand(): string[] {
+  const override = process.env.AGENT_RELAY_CODEX_RELAY_BIN;
+  if (override) return [override];
+
+  const repoLauncher = resolve(import.meta.dir, "../codex/bin/agent-relay-codex.ts");
+  if (existsSync(repoLauncher)) return ["bun", "run", repoLauncher, "start"];
+
+  const fromPath = findOnPath("codex-relay");
+  if (fromPath) return [fromPath];
+
+  return ["codex-relay"];
+}
+
+export function codexSpawnLogPath(cwd: string, now = Date.now()): string {
+  const project = basename(cwd).replace(/[^a-zA-Z0-9._-]+/g, "-") || "project";
+  return join(homedir(), ".agent-relay", "spawns", `codex-${project}-${now}.log`);
+}
+
+export function spawnCodexAgent(input: CodexSpawnInput): CodexSpawnResult {
+  const cwd = normalizeCodexSpawnCwd(input.cwd);
+  const command = [
+    ...codexSpawnCommand(),
+    "--headless",
+    "--relay-url",
+    input.relayUrl,
+  ];
+  const logPath = codexSpawnLogPath(cwd);
+  const env: Record<string, string | undefined> = {
+    ...process.env,
+    AGENT_RELAY_CODEX_HEADLESS: "1",
+    AGENT_RELAY_APPROVAL: input.approvalMode,
+    AGENT_RELAY_TAGS: mergeCsv(process.env.AGENT_RELAY_TAGS, ["headless", "dashboard-spawned"]),
+    AGENT_RELAY_LABEL: input.label || process.env.AGENT_RELAY_LABEL,
+    AGENT_RELAY_URL: input.relayUrl,
+    AGENT_RELAY_TOKEN: input.token || process.env.AGENT_RELAY_TOKEN,
+  };
+
+  if (input.dryRun) {
+    return { provider: "codex", cwd, approvalMode: input.approvalMode, logPath, command, dryRun: true };
+  }
+
+  mkdirSync(dirname(logPath), { recursive: true });
+  const log = Bun.file(logPath);
+  const child = Bun.spawn(command, {
+    cwd,
+    env,
+    stdin: "ignore",
+    stdout: log,
+    stderr: log,
+  });
+  child.unref();
+
+  return { provider: "codex", pid: child.pid, cwd, approvalMode: input.approvalMode, logPath, command };
+}
+
+function mergeCsv(raw: string | undefined, additions: string[]): string {
+  return [...new Set([
+    ...(raw || "").split(",").map((item) => item.trim()).filter(Boolean),
+    ...additions,
+  ])].join(",");
+}
+
+function findOnPath(command: string): string | null {
+  for (const dir of (process.env.PATH || "").split(delimiter)) {
+    if (!dir) continue;
+    const candidate = join(dir, command);
+    if (existsSync(candidate)) return candidate;
+  }
+  return null;
+}

package/src/db.ts

@@ -9,15 +9,21 @@ import type {
   CreatePairInput,
   HealthCheck,
   HealthReport,
+  ManagedAgent,
   Message,
   MessageType,
+  Orchestrator,
+  OrchestratorStatus,
   PairActionInput,
   PairMessageInput,
   PairSession,
   PairStatus,
   RegisterAgentInput,
+  RegisterOrchestratorInput,
   SendMessageInput,
   PollQuery,
+  SpawnApprovalMode,
+  SpawnProvider,
   Task,
   TaskEvent,
   TaskSeverity,
@@ -192,6 +198,20 @@ export function initDb(path: string = "agent-relay.db"): Database {
     );
     CREATE INDEX IF NOT EXISTS idx_activity_operator ON activity_events(operator_id, created_at);
     CREATE INDEX IF NOT EXISTS idx_activity_created ON activity_events(created_at);
+
+    CREATE TABLE IF NOT EXISTS orchestrators (
+      id TEXT PRIMARY KEY,
+      hostname TEXT NOT NULL,
+      status TEXT NOT NULL DEFAULT 'online',
+      agent_id TEXT NOT NULL,
+      providers TEXT NOT NULL DEFAULT '[]',
+      base_dir TEXT NOT NULL,
+      env_keys TEXT NOT NULL DEFAULT '[]',
+      meta TEXT NOT NULL DEFAULT '{}',
+      managed_agents TEXT NOT NULL DEFAULT '[]',
+      last_seen INTEGER NOT NULL,
+      created_at INTEGER NOT NULL
+    );
   `);
 
   // Migrations
@@ -1328,6 +1348,44 @@ function findMessageByIdempotencyKey(from: string, key: string): Message | null
   return row ? rowToMessage(row) : null;
 }
 
+function isDeliveryAgent(agent: AgentCard): boolean {
+  return agent.status !== "offline" &&
+    agent.id !== "user" &&
+    agent.id !== "system" &&
+    agent.meta?.kind !== "channel";
+}
+
+function matchingDeliveryAgents(target: string): AgentCard[] {
+  if (!target) return [];
+  const candidates = listAgents().filter(isDeliveryAgent);
+  if (target === "broadcast") return candidates;
+  const direct = getAgent(target);
+  if (direct) return isDeliveryAgent(direct) ? [direct] : [];
+  if (target.startsWith("tag:")) {
+    const tag = target.slice(4);
+    return candidates.filter((agent) => agent.tags.includes(tag));
+  }
+  if (target.startsWith("cap:")) {
+    const cap = target.slice(4);
+    return candidates.filter((agent) => agent.capabilities.includes(cap));
+  }
+  if (target.startsWith("label:")) {
+    const label = target.slice(6);
+    return candidates.filter((agent) => agent.label === label);
+  }
+  return [];
+}
+
+function claimableAllowedForTarget(target: string): boolean {
+  return matchingDeliveryAgents(target).length > 1;
+}
+
+function shouldStoreClaimable(input: SendMessageInput): boolean {
+  if (!input.claimable) return false;
+  if (input.type === "system" || typeof input.meta?.taskId === "number") return true;
+  return claimableAllowedForTarget(input.to);
+}
+
 export function sendMessageWithResult(input: SendMessageInput): { message: Message; created: boolean } {
   const now = Date.now();
 
@@ -1354,6 +1412,7 @@ export function sendMessageWithResult(input: SendMessageInput): { message: Messa
     VALUES ($from, $to, $type, $channel, $subject, $body, $threadId, $replyTo, $claimable, $idempotencyKey, $meta, $now)
   `);
   const setSelfThread = db.prepare("UPDATE messages SET thread_id = ? WHERE id = ?");
+  const claimable = shouldStoreClaimable(input);
 
   const id = db.transaction(() => {
     const result = insert.run({
@@ -1365,7 +1424,7 @@ export function sendMessageWithResult(input: SendMessageInput): { message: Messa
       $body: input.body,
       $threadId: threadId,
       $replyTo: input.replyTo ?? null,
-      $claimable: input.claimable ? 1 : 0,
+      $claimable: claimable ? 1 : 0,
       $idempotencyKey: input.idempotencyKey ?? null,
       $meta: JSON.stringify(input.meta ?? {}),
       $now: now,
@@ -1827,3 +1886,114 @@ export function getHealth(now: number = Date.now()): HealthReport {
       : "ok";
   return { status, version: VERSION, generatedAt: now, checks };
 }
+
+// --- Orchestrators ---
+
+function rowToOrchestrator(row: any): Orchestrator {
+  return {
+    id: row.id,
+    hostname: row.hostname,
+    status: row.status as OrchestratorStatus,
+    agentId: row.agent_id,
+    providers: parseJson<SpawnProvider[]>(row.providers, []),
+    baseDir: row.base_dir,
+    envKeys: parseJson<string[]>(row.env_keys, []),
+    meta: parseJson(row.meta, {}),
+    managedAgents: parseJson<ManagedAgent[]>(row.managed_agents, []),
+    lastSeen: row.last_seen,
+    createdAt: row.created_at,
+  };
+}
+
+export function upsertOrchestrator(input: RegisterOrchestratorInput): Orchestrator {
+  const now = Date.now();
+  const agentId = `orchestrator-${input.id}`;
+  const stmt = db.prepare(`
+    INSERT INTO orchestrators (id, hostname, status, agent_id, providers, base_dir, env_keys, meta, last_seen, created_at)
+    VALUES ($id, $hostname, 'online', $agentId, $providers, $baseDir, $envKeys, $meta, $now, $now)
+    ON CONFLICT(id) DO UPDATE SET
+      hostname = $hostname,
+      status = 'online',
+      providers = $providers,
+      base_dir = $baseDir,
+      env_keys = $envKeys,
+      meta = $meta,
+      last_seen = $now
+  `);
+  stmt.run({
+    $id: input.id,
+    $hostname: input.hostname,
+    $agentId: agentId,
+    $providers: JSON.stringify(input.providers),
+    $baseDir: input.baseDir,
+    $envKeys: JSON.stringify(input.envKeys ?? []),
+    $meta: JSON.stringify(input.meta ?? {}),
+    $now: now,
+  });
+
+  // Also register as an agent so the orchestrator can receive messages
+  upsertAgent({
+    id: agentId,
+    name: `Orchestrator (${input.hostname})`,
+    tags: ["orchestrator", input.hostname],
+    machine: input.hostname,
+    capabilities: ["orchestrator", "spawn"],
+    status: "online",
+    meta: { orchestratorId: input.id, builtin: true },
+  });
+
+  return getOrchestrator(input.id)!;
+}
+
+export function getOrchestrator(id: string): Orchestrator | null {
+  const row = db.prepare("SELECT * FROM orchestrators WHERE id = ?").get(id) as any;
+  return row ? rowToOrchestrator(row) : null;
+}
+
+export function listOrchestrators(): Orchestrator[] {
+  return (db.prepare("SELECT * FROM orchestrators ORDER BY hostname").all() as any[]).map(rowToOrchestrator);
+}
+
+export function orchestratorHeartbeat(id: string): Orchestrator | null {
+  const now = Date.now();
+  db.prepare("UPDATE orchestrators SET last_seen = ?, status = 'online' WHERE id = ?").run(now, id);
+  // Also heartbeat the agent
+  const orch = getOrchestrator(id);
+  if (orch) {
+    heartbeat(orch.agentId);
+  }
+  return orch;
+}
+
+export function setOrchestratorStatus(id: string, status: OrchestratorStatus): Orchestrator | null {
+  db.prepare("UPDATE orchestrators SET status = ?, last_seen = ? WHERE id = ?").run(status, Date.now(), id);
+  const orch = getOrchestrator(id);
+  if (orch) {
+    setStatus(orch.agentId, status === "online" ? "online" : "offline");
+  }
+  return orch;
+}
+
+export function updateManagedAgents(id: string, agents: ManagedAgent[]): Orchestrator | null {
+  db.prepare("UPDATE orchestrators SET managed_agents = ?, last_seen = ? WHERE id = ?")
+    .run(JSON.stringify(agents), Date.now(), id);
+  return getOrchestrator(id);
+}
+
+export function deleteOrchestrator(id: string): boolean {
+  const orch = getOrchestrator(id);
+  if (!orch) return false;
+  db.prepare("DELETE FROM orchestrators WHERE id = ?").run(id);
+  deleteAgent(orch.agentId);
+  return true;
+}
+
+export function reapStaleOrchestrators(): string[] {
+  const cutoff = Date.now() - STALE_TTL_MS;
+  const stale = db.prepare("SELECT id, agent_id FROM orchestrators WHERE last_seen < ? AND status = 'online'").all(cutoff) as any[];
+  for (const row of stale) {
+    db.prepare("UPDATE orchestrators SET status = 'offline' WHERE id = ?").run(row.id);
+    setStatus(row.agent_id, "offline");
+  }
+  return stale.map((row: any) => row.id);
+}