agent-relay-server 0.10.13 → 0.10.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-server",
-  "version": "0.10.13",
+  "version": "0.10.15",
   "description": "Lightweight HTTP message relay for inter-agent communication across machines",
   "module": "src/index.ts",
   "type": "module",

package/src/bus.ts

@@ -234,6 +234,7 @@ function handleRegister(ws: BusWebSocket, frame: RegisterFrame): void {
     getLifecycleManager().onAgentRegistered(agent.id, {
       policyName: stringMeta(payload.meta, "policyName"),
       spawnRequestId: stringMeta(payload.meta, "spawnRequestId"),
+      tmuxSession: stringMeta(payload.meta, "tmuxSession"),
     });
     emitAgentStatusEvent(agent.id);
   }
@@ -359,6 +360,7 @@ function messageMatchesAgent(msg: Message, agentId: string): boolean {
   const agent = getAgent(agentId);
   if (!agent) return false;
   if (msg.claimable && msg.claimedBy && msg.claimedBy !== agentId) return false;
+  if (msg.resolvedToAgent === agentId) return true;
   if (msg.to === agentId || msg.from === agentId) return true;
   return targetMatchesAgent(msg.to, agentId, agent);
 }

package/src/lifecycle-manager.ts

@@ -7,7 +7,7 @@ import {
   upsertManagedAgentState,
 } from "./config-store";
 import { emitRelayEvent } from "./events";
-import type { Command, ManagedAgentState, SpawnPolicy } from "./types";
+import type { Command, ManagedAgent, ManagedAgentState, SpawnPolicy } from "./types";
 
 const DEFAULT_TICK_MS = 10_000;
 const DAY_MS = 24 * 60 * 60 * 1000;
@@ -58,13 +58,14 @@ export class LifecycleManager {
     this.spawnAgent(policy, "message-trigger");
   }
 
-  onAgentRegistered(agentId: string, meta: { policyName?: string; spawnRequestId?: string }): void {
+  onAgentRegistered(agentId: string, meta: { policyName?: string; spawnRequestId?: string; tmuxSession?: string | null }): void {
     if (!meta.policyName || !meta.spawnRequestId) return;
     const state = getManagedAgentState(meta.policyName);
     if (!state || state.spawnRequestId !== meta.spawnRequestId) return;
     const next = updateManagedAgentState(meta.policyName, {
       status: "running",
       agentId,
+      tmuxSession: meta.tmuxSession ?? state.tmuxSession,
       healthySince: this.now(),
       backoffUntil: undefined,
       lastError: undefined,
@@ -81,6 +82,42 @@ export class LifecycleManager {
     }
   }
 
+  onOrchestratorManagedAgentsReported(orchestratorId: string, agents: ManagedAgent[]): void {
+    for (const agent of agents) {
+      if (!agent.policyName || !agent.spawnRequestId) continue;
+      const state = getManagedAgentState(agent.policyName);
+      if (!state || state.spawnRequestId !== agent.spawnRequestId) continue;
+      const next = updateManagedAgentState(agent.policyName, {
+        agentId: agent.agentId || state.agentId,
+        tmuxSession: agent.tmuxSession,
+      });
+      if (next) this.emitState(next);
+    }
+
+    for (const policy of this.loadPolicies()) {
+      if (policy.orchestratorId !== orchestratorId) continue;
+      const state = getManagedAgentState(policy.name);
+      if (!state) continue;
+      const reported = agents.some((agent) => (
+        (state.spawnRequestId && agent.spawnRequestId === state.spawnRequestId) ||
+        (state.agentId && agent.agentId === state.agentId) ||
+        (state.tmuxSession && agent.tmuxSession === state.tmuxSession) ||
+        (agent.policyName === policy.name && (!state.spawnRequestId || agent.spawnRequestId === state.spawnRequestId))
+      ));
+      if (state.status === "running" && !reported) {
+        this.markBackoff(policy, state, "orchestrator session disappeared");
+      } else if (state.status === "stopping" && !reported) {
+        const next = updateManagedAgentState(policy.name, {
+          status: "stopped",
+          agentId: undefined,
+          tmuxSession: undefined,
+          lastStopAt: this.now(),
+        });
+        if (next) this.emitState(next);
+      }
+    }
+  }
+
   onAgentDisappeared(agentId: string): void {
     const policy = this.loadPolicies().find((item) => getManagedAgentState(item.name)?.agentId === agentId);
     if (!policy) return;

package/src/routes.ts

@@ -81,6 +81,7 @@ import {
   updateManagedAgentState,
 } from "./config-store";
 import { createCommand, deleteCommand, expireCommands, getCommand, listCommands, updateCommand } from "./commands-db";
+import { getLifecycleManager } from "./lifecycle-manager";
 import { getRecipe, listRecipes } from "./recipe-loader";
 import { applyCommandToRecipe, getRecipeInstance, listRecipeInstances, startRecipe, stopRecipe } from "./recipe-runner";
 import { createToken, getToken, listTokens, revokeToken } from "./token-db";
@@ -959,12 +960,14 @@ const postAgent: Handler = async (req) => {
     const agent = upsertAgent(input);
     const policyName = metaString(agent.meta, "policyName");
     const spawnRequestId = metaString(agent.meta, "spawnRequestId");
+    const tmuxSession = metaString(agent.meta, "tmuxSession");
     if (policyName && spawnRequestId) {
       const state = getManagedAgentState(policyName);
       if (state?.spawnRequestId === spawnRequestId) {
         const updatedState = updateManagedAgentState(policyName, {
           status: "running",
           agentId: agent.id,
+          tmuxSession: tmuxSession ?? state.tmuxSession,
           healthySince: Date.now(),
           lastError: undefined,
         });
@@ -1454,11 +1457,14 @@ const patchOrchestratorAgents: Handler = async (req, params) => {
         cwd: cleanString(a.cwd, "cwd", { required: true, max: 500 })!,
         label: cleanString(a.label, "label", { max: 120 }),
         approvalMode: (cleanEnum(a.approvalMode, "approvalMode", VALID_SPAWN_APPROVALS, "guarded") ?? "guarded") as SpawnApprovalMode,
+        policyName: cleanString(a.policyName, "policyName", { max: 120 }),
+        spawnRequestId: cleanString(a.spawnRequestId, "spawnRequestId", { max: 160 }),
         pid: typeof a.pid === "number" && Number.isSafeInteger(a.pid) ? a.pid : undefined,
         startedAt: typeof a.startedAt === "number" ? a.startedAt : Date.now(),
       };
     });
     const updated = updateManagedAgents(params.id!, cleaned);
+    getLifecycleManager().onOrchestratorManagedAgentsReported(params.id!, cleaned);
     if (updated) emitOrchestratorStatus(params.id!);
     return json(updated);
   } catch (e) {