macro-agent 0.1.0 → 0.1.2

package/src/__tests__/e2e/agent-spawn-visibility.e2e.test.ts

@@ -0,0 +1,761 @@
+/**
+ * E2E test: Agent Spawn Visibility
+ *
+ * Verifies that agents spawned via various paths are visible through:
+ * 1. query_index MCP bridge (agentManager.list())
+ * 2. MAP subscription events (agent_registered notifications)
+ *
+ * Tests the full pipeline from spawn → EventStore → query/subscription.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { WebSocket } from "ws";
+import { createEventStore, type EventStore } from "../../store/event-store.js";
+import {
+  createAgentManager,
+  type AgentManager,
+} from "../../agent/agent-manager.js";
+import { createTaskManager, type TaskManager } from "../../task/task-manager.js";
+import {
+  createMessageRouter,
+  type MessageRouter,
+} from "../../router/message-router.js";
+import {
+  createCombinedServer,
+  type CombinedServer,
+  type CombinedServerServices,
+} from "../../server/combined-server.js";
+import { mapCall } from "../../mcp/map-client.js";
+
+// =============================================================================
+// Helpers
+// =============================================================================
+
+function getRandomPort(): number {
+  return 10000 + Math.floor(Math.random() * 50000);
+}
+
+function agentContext(agentId: string, taskId?: string) {
+  return {
+    agent_id: agentId,
+    session_id: "sess_test",
+    task_id: taskId ?? "task_test",
+    lineage: [],
+    cwd: "/test/cwd",
+  };
+}
+
+interface JsonRpcMessage {
+  jsonrpc: "2.0";
+  id?: number;
+  method?: string;
+  params?: unknown;
+  result?: unknown;
+  error?: { code: number; message: string; data?: unknown };
+}
+
+/**
+ * WebSocket MAP client for receiving subscription events.
+ */
+class MAPTestClient {
+  private ws!: WebSocket;
+  private waiters: Map<
+    number,
+    { resolve: (r: JsonRpcMessage) => void; reject: (e: Error) => void }
+  > = new Map();
+  private nextId = 1;
+  private url: string;
+
+  readonly notifications: JsonRpcMessage[] = [];
+
+  private notificationWaiters: Array<{
+    check: (msg: JsonRpcMessage) => boolean;
+    resolve: (msg: JsonRpcMessage) => void;
+    reject: (e: Error) => void;
+    timeout: ReturnType<typeof setTimeout>;
+  }> = [];
+
+  constructor(url: string) {
+    this.url = url;
+  }
+
+  async connect(): Promise<void> {
+    this.ws = new WebSocket(this.url);
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(
+        () => reject(new Error("Connection timeout")),
+        5000,
+      );
+      this.ws.on("open", () => {
+        clearTimeout(timeout);
+        resolve();
+      });
+      this.ws.on("error", (err) => {
+        clearTimeout(timeout);
+        reject(err);
+      });
+      this.ws.on("message", (data: Buffer) => {
+        try {
+          const msg = JSON.parse(data.toString()) as JsonRpcMessage;
+          if (msg.id != null) {
+            const waiter = this.waiters.get(msg.id);
+            if (waiter) {
+              this.waiters.delete(msg.id);
+              waiter.resolve(msg);
+            }
+          } else if (msg.method) {
+            this.notifications.push(msg);
+            for (let i = this.notificationWaiters.length - 1; i >= 0; i--) {
+              const w = this.notificationWaiters[i];
+              if (w.check(msg)) {
+                clearTimeout(w.timeout);
+                this.notificationWaiters.splice(i, 1);
+                w.resolve(msg);
+              }
+            }
+          }
+        } catch {
+          // ignore
+        }
+      });
+    });
+  }
+
+  async request(method: string, params?: unknown): Promise<JsonRpcMessage> {
+    const id = this.nextId++;
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.waiters.delete(id);
+        reject(new Error(`Request timeout: ${method}`));
+      }, 30000);
+      this.waiters.set(id, {
+        resolve: (r) => {
+          clearTimeout(timeout);
+          resolve(r);
+        },
+        reject: (e) => {
+          clearTimeout(timeout);
+          reject(e);
+        },
+      });
+      this.ws.send(JSON.stringify({ jsonrpc: "2.0", method, params, id }));
+    });
+  }
+
+  waitForNotification(
+    check: (msg: JsonRpcMessage) => boolean,
+    timeoutMs = 15000,
+  ): Promise<JsonRpcMessage> {
+    const existing = this.notifications.find(check);
+    if (existing) return Promise.resolve(existing);
+
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        const idx = this.notificationWaiters.findIndex(
+          (w) => w.resolve === resolve,
+        );
+        if (idx >= 0) this.notificationWaiters.splice(idx, 1);
+        reject(
+          new Error(
+            `Timeout waiting for notification. Received ${this.notifications.length} notifications:\n` +
+              this.notifications
+                .map((n) => {
+                  const p = n.params as Record<string, unknown> | undefined;
+                  const evt = p?.event as Record<string, unknown> | undefined;
+                  return `  ${n.method} → type=${evt?.type}, data=${JSON.stringify(evt?.data)}`;
+                })
+                .join("\n"),
+          ),
+        );
+      }, timeoutMs);
+      this.notificationWaiters.push({ check, resolve, reject, timeout });
+    });
+  }
+
+  close(): void {
+    for (const w of this.notificationWaiters) {
+      clearTimeout(w.timeout);
+    }
+    this.notificationWaiters.length = 0;
+    try {
+      this.ws?.close();
+    } catch {
+      // ignore
+    }
+  }
+}
+
+function isEventOfType(type: string) {
+  return (msg: JsonRpcMessage) => {
+    if (msg.method !== "map/event") return false;
+    const params = msg.params as Record<string, unknown> | undefined;
+    const event = params?.event as Record<string, unknown> | undefined;
+    return event?.type === type;
+  };
+}
+
+function isEventForAgent(type: string, agentId: string) {
+  return (msg: JsonRpcMessage) => {
+    if (msg.method !== "map/event") return false;
+    const params = msg.params as Record<string, unknown> | undefined;
+    const event = params?.event as Record<string, unknown> | undefined;
+    if (event?.type !== type) return false;
+    const data = event?.data as Record<string, unknown> | undefined;
+    return data?.agentId === agentId;
+  };
+}
+
+// =============================================================================
+// Tests
+// =============================================================================
+
+describe("Agent Spawn Visibility E2E", () => {
+  let eventStore: EventStore;
+  let agentManager: AgentManager;
+  let taskManager: TaskManager;
+  let messageRouter: MessageRouter;
+  let server: CombinedServer;
+  let port: number;
+  let serverUrl: string;
+  const clients: MAPTestClient[] = [];
+
+  beforeEach(async () => {
+    port = getRandomPort();
+    serverUrl = `http://localhost:${port}`;
+
+    eventStore = await createEventStore({ inMemory: true });
+    messageRouter = createMessageRouter(eventStore);
+    agentManager = createAgentManager(eventStore, messageRouter, {
+      defaultPermissionMode: "auto-approve",
+      defaultCwd: "/test/cwd",
+    });
+    taskManager = createTaskManager(eventStore);
+
+    const services: CombinedServerServices = {
+      eventStore,
+      agentManager,
+      taskManager,
+      messageRouter,
+    };
+
+    server = createCombinedServer(services, { port, host: "localhost" });
+    await server.start();
+  });
+
+  afterEach(async () => {
+    for (const c of clients) {
+      c.close();
+    }
+    clients.length = 0;
+    await server.stop().catch(() => {});
+    await agentManager.close();
+    await eventStore.close();
+  });
+
+  function createClient(): MAPTestClient {
+    const client = new MAPTestClient(`ws://localhost:${port}/map`);
+    clients.push(client);
+    return client;
+  }
+
+  // ─────────────────────────────────────────────────────────────────
+  // query_index visibility
+  // ─────────────────────────────────────────────────────────────────
+
+  describe("query_index visibility", () => {
+    it("returns parent agent seeded via eventStore.emit", async () => {
+      // Seed root agent
+      eventStore.emit({
+        type: "spawn",
+        source: { agent_id: "system" },
+        payload: {
+          agent_id: "agent_root",
+          session_id: "sess_root",
+          task: "Root task",
+          task_id: "task_root",
+          parent: null,
+          config: {},
+          cwd: "/test",
+        },
+      });
+
+      const result = await mapCall<{
+        entries: Array<{ type: string; id: string; summary: string; state?: string }>;
+        total: number;
+      }>(serverUrl, "_macro/mcp/query_index", {
+        context: agentContext("agent_root"),
+        type: "agents",
+      });
+
+      expect(result.entries.length).toBeGreaterThanOrEqual(1);
+      expect(result.entries.some((e) => e.id === "agent_root")).toBe(true);
+    });
+
+    it("returns child agent after parent seeds it via eventStore.emit", async () => {
+      // Seed root agent
+      eventStore.emit({
+        type: "spawn",
+        source: { agent_id: "system" },
+        payload: {
+          agent_id: "agent_parent",
+          session_id: "sess_parent",
+          task: "Parent task",
+          task_id: "task_parent",
+          parent: null,
+          config: {},
+          cwd: "/test",
+        },
+      });
+
+      // Seed child agent (simulating what agentManager.spawn does internally)
+      eventStore.emit({
+        type: "spawn",
+        source: { agent_id: "agent_parent" },
+        payload: {
+          agent_id: "agent_child",
+          session_id: "sess_child",
+          task: "Child task",
+          task_id: "task_child",
+          parent: "agent_parent",
+          config: {},
+          cwd: "/test",
+        },
+      });
+
+      // Query from child's perspective — should see both agents
+      const result = await mapCall<{
+        entries: Array<{ type: string; id: string; summary: string; state?: string }>;
+        total: number;
+      }>(serverUrl, "_macro/mcp/query_index", {
+        context: agentContext("agent_parent"),
+        type: "agents",
+      });
+
+      expect(result.entries.length).toBeGreaterThanOrEqual(2);
+      expect(result.entries.some((e) => e.id === "agent_parent")).toBe(true);
+      expect(result.entries.some((e) => e.id === "agent_child")).toBe(true);
+
+      // Verify child has correct parent info
+      const child = result.entries.find((e) => e.id === "agent_child")!;
+      expect(child.summary).toBe("Child task");
+      expect(child.state).toBe("spawning");
+    });
+
+    it("returns agents with various states", async () => {
+      // Seed agent in spawning state
+      eventStore.emit({
+        type: "spawn",
+        source: { agent_id: "system" },
+        payload: {
+          agent_id: "agent_spawning",
+          session_id: "sess_1",
+          task: "Spawning agent",
+          task_id: "task_1",
+          parent: null,
+          config: {},
+          cwd: "/test",
+        },
+      });
+
+      // Seed another agent and transition to running via status event
+      eventStore.emit({
+        type: "spawn",
+        source: { agent_id: "system" },
+        payload: {
+          agent_id: "agent_running",
+          session_id: "sess_2",
+          task: "Running agent",
+          task_id: "task_2",
+          parent: null,
+          config: {},
+          cwd: "/test",
+        },
+      });
+      eventStore.emit({
+        type: "status",
+        source: { agent_id: "agent_running" },
+        payload: { status_type: "started", summary: "Agent started" },
+      });
+
+      // Seed a stopped agent
+      eventStore.emit({
+        type: "spawn",
+        source: { agent_id: "system" },
+        payload: {
+          agent_id: "agent_stopped",
+          session_id: "sess_3",
+          task: "Stopped agent",
+          task_id: "task_3",
+          parent: null,
+          config: {},
+          cwd: "/test",
+        },
+      });
+      eventStore.emit({
+        type: "stop",
+        source: { agent_id: "agent_stopped" },
+        payload: { reason: "completed" },
+      });
+
+      // query_index should return ALL agents (no state filter by default)
+      const result = await mapCall<{
+        entries: Array<{ type: string; id: string; state?: string }>;
+        total: number;
+      }>(serverUrl, "_macro/mcp/query_index", {
+        context: agentContext("agent_spawning"),
+        type: "agents",
+      });
+
+      expect(result.entries.length).toBe(3);
+
+      const spawning = result.entries.find((e) => e.id === "agent_spawning")!;
+      const running = result.entries.find((e) => e.id === "agent_running")!;
+      const stopped = result.entries.find((e) => e.id === "agent_stopped")!;
+
+      expect(spawning.state).toBe("spawning");
+      expect(running.state).toBe("running");
+      expect(stopped.state).toBe("stopped");
+    });
+  });
+
+  // ─────────────────────────────────────────────────────────────────
+  // MAP subscription visibility (agent_registered events)
+  // ─────────────────────────────────────────────────────────────────
+
+  describe("MAP subscription agent_registered events", () => {
+    it("subscriber receives agent_registered when agent is spawned via lifecycle", { timeout: 15_000 }, async () => {
+      // Connect a MAP subscriber
+      const subscriber = createClient();
+      await subscriber.connect();
+      const subRes = await subscriber.request("map/subscribe", {
+        filter: { eventTypes: ["agent_registered"] },
+      });
+      expect(subRes.error).toBeUndefined();
+
+      // Seed an agent via eventStore.emit — this simulates what
+      // agentManager.spawn() does internally. However, the lifecycle
+      // listener is on agentManager, not eventStore.emit.
+      // We need to trigger the lifecycle event.
+      //
+      // The lifecycle event is fired by notifyLifecycle({ type: "spawned", agent })
+      // which is called INSIDE agentManager.spawn() after the agent is created.
+      //
+      // Since we can't call agentManager.spawn() (needs real processes),
+      // we'll directly check if seeding via eventStore.emit triggers
+      // the MAP adapter's lifecycle listener.
+
+      // First, verify direct eventStore.emit does NOT trigger lifecycle
+      // (lifecycle is tied to agentManager, not eventStore)
+      eventStore.emit({
+        type: "spawn",
+        source: { agent_id: "system" },
+        payload: {
+          agent_id: "agent_direct",
+          session_id: "sess_direct",
+          task: "Direct seed",
+          task_id: "task_direct",
+          parent: null,
+          config: {},
+          cwd: "/test",
+        },
+      });
+
+      // Wait briefly to see if any notification arrives
+      await new Promise((r) => setTimeout(r, 1000));
+      const directNotifications = subscriber.notifications.filter(
+        isEventOfType("agent_registered"),
+      );
+
+      // Direct eventStore.emit bypasses agentManager lifecycle —
+      // this tells us whether agent_registered events rely on lifecycle
+      console.log(
+        `Direct seed produced ${directNotifications.length} agent_registered notifications`,
+      );
+    });
+
+    it("subscriber receives agent_registered with correct data shape for TUI", { timeout: 15_000 }, async () => {
+      // Connect subscriber
+      const subscriber = createClient();
+      await subscriber.connect();
+      const subRes = await subscriber.request("map/subscribe", {
+        filter: { eventTypes: ["agent_registered", "agent_state_changed"] },
+      });
+      expect(subRes.error).toBeUndefined();
+
+      // Use agentManager's lifecycle notification directly if available
+      // Seed an agent with proper metadata
+      eventStore.emit({
+        type: "spawn",
+        source: { agent_id: "system" },
+        payload: {
+          agent_id: "agent_tui_test",
+          session_id: "sess_tui",
+          task: "TUI visibility test",
+          task_id: "task_tui",
+          parent: null,
+          role: "worker",
+          config: {},
+          cwd: "/test",
+        },
+      });
+      eventStore.updateAgentMetadata("agent_tui_test" as any, {
+        name: "test-agent",
+      });
+
+      // Now manually trigger what the MAP adapter's lifecycle listener does
+      // by calling emitEvent on the server's MAP adapter.
+      // Since we can't access the adapter directly, we check if the
+      // onAgentChange listener on eventStore triggers it.
+
+      // The MAP adapter listens to agentManager.onLifecycleEvent,
+      // NOT eventStore.onAgentChange. So direct seeding won't emit
+      // MAP events. This is likely part of the bug.
+
+      // Let's verify by checking if there's an eventStore.onAgentChange
+      // listener that could emit agent_registered
+      await new Promise((r) => setTimeout(r, 1000));
+
+      console.log(
+        `Total notifications after seed: ${subscriber.notifications.length}`,
+      );
+      console.log(
+        `Notification types: ${subscriber.notifications.map((n) => {
+          const p = n.params as Record<string, unknown>;
+          const e = p?.event as Record<string, unknown>;
+          return e?.type;
+        }).join(", ")}`,
+      );
+
+      // If no agent_registered notification arrived, the bug is that
+      // the MAP adapter only listens to agentManager lifecycle events,
+      // but seeding via eventStore.emit (which is what the bridge handler does)
+      // doesn't trigger lifecycle events.
+    });
+  });
+
+  // ─────────────────────────────────────────────────────────────────
+  // Spawn via bridge + query visibility (critical integration test)
+  // ─────────────────────────────────────────────────────────────────
+
+  describe("spawn then query integration", () => {
+    it("spawn_agent bridge handler makes child visible in query_index", { timeout: 30_000 }, async () => {
+      // Seed a root agent (the "caller")
+      eventStore.emit({
+        type: "spawn",
+        source: { agent_id: "system" },
+        payload: {
+          agent_id: "agent_caller",
+          session_id: "sess_caller",
+          task: "Caller agent",
+          task_id: "task_caller",
+          parent: null,
+          config: {},
+          cwd: "/test/cwd",
+        },
+      });
+
+      // Try to spawn a child via the bridge
+      // NOTE: This may fail because agentManager.spawn() tries to start
+      // a real subprocess via AgentFactory. If it does, we catch and
+      // analyze where it fails.
+      let spawnedAgentId: string | undefined;
+      let spawnError: Error | undefined;
+
+      try {
+        const result = await mapCall<{
+          agent_id: string;
+          task_id: string;
+          session_id: string;
+        }>(serverUrl, "_macro/mcp/spawn_agent", {
+          context: agentContext("agent_caller", "task_caller"),
+          task: "Child task from bridge",
+        });
+        spawnedAgentId = result.agent_id;
+        console.log(`spawn_agent succeeded: ${JSON.stringify(result)}`);
+      } catch (err) {
+        spawnError = err as Error;
+        console.log(`spawn_agent failed: ${spawnError.message}`);
+      }
+
+      if (spawnedAgentId) {
+        // Spawn succeeded — verify the child appears in query_index
+        const result = await mapCall<{
+          entries: Array<{ type: string; id: string; summary: string }>;
+          total: number;
+        }>(serverUrl, "_macro/mcp/query_index", {
+          context: agentContext("agent_caller"),
+          type: "agents",
+        });
+
+        console.log(`query_index returned ${result.entries.length} agents:`);
+        for (const entry of result.entries) {
+          console.log(`  ${entry.id}: ${entry.summary}`);
+        }
+
+        expect(
+          result.entries.some((e) => e.id === spawnedAgentId),
+          `Spawned agent ${spawnedAgentId} should appear in query_index`,
+        ).toBe(true);
+      } else {
+        // Spawn failed — expected in test env without real processes.
+        // Verify the root agent still exists and no orphaned state.
+        console.log(
+          "spawn_agent requires real process — testing with direct seeding instead",
+        );
+
+        // Directly seed a child (like spawn does internally)
+        eventStore.emit({
+          type: "spawn",
+          source: { agent_id: "agent_caller" },
+          payload: {
+            agent_id: "agent_child_direct",
+            session_id: "sess_child",
+            task: "Direct child",
+            task_id: "task_child",
+            parent: "agent_caller",
+            config: {},
+            cwd: "/test/cwd",
+          },
+        });
+
+        const result = await mapCall<{
+          entries: Array<{ type: string; id: string; summary: string }>;
+          total: number;
+        }>(serverUrl, "_macro/mcp/query_index", {
+          context: agentContext("agent_caller"),
+          type: "agents",
+        });
+
+        expect(
+          result.entries.some((e) => e.id === "agent_child_direct"),
+          "Directly seeded child should appear in query_index",
+        ).toBe(true);
+      }
+    });
+
+    it("MAP subscriber receives agent_registered when spawn_agent succeeds", { timeout: 30_000 }, async () => {
+      // Set up subscriber first
+      const subscriber = createClient();
+      await subscriber.connect();
+      await subscriber.request("map/subscribe", {
+        filter: { eventTypes: ["agent_registered", "agent_state_changed"] },
+      });
+
+      // Seed root agent
+      eventStore.emit({
+        type: "spawn",
+        source: { agent_id: "system" },
+        payload: {
+          agent_id: "agent_root_sub",
+          session_id: "sess_root",
+          task: "Root for subscription test",
+          task_id: "task_root",
+          parent: null,
+          config: {},
+          cwd: "/test/cwd",
+        },
+      });
+
+      // Try spawn via bridge
+      let spawnedAgentId: string | undefined;
+      try {
+        const result = await mapCall<{ agent_id: string }>(
+          serverUrl,
+          "_macro/mcp/spawn_agent",
+          {
+            context: agentContext("agent_root_sub", "task_root"),
+            task: "Subscriber test child",
+          },
+        );
+        spawnedAgentId = result.agent_id;
+      } catch {
+        console.log("spawn_agent requires real processes — skipping subscriber verification");
+      }
+
+      if (spawnedAgentId) {
+        // Wait for the agent_registered notification
+        const notification = await subscriber.waitForNotification(
+          isEventForAgent("agent_registered", spawnedAgentId),
+          10000,
+        );
+
+        expect(notification.method).toBe("map/event");
+        const params = notification.params as Record<string, unknown>;
+        const event = params.event as Record<string, unknown>;
+        const data = event.data as Record<string, unknown>;
+
+        // Verify data shape matches what TUI sync.tsx expects
+        expect(data.agentId).toBe(spawnedAgentId);
+        expect(data).toHaveProperty("name");
+        expect(data).toHaveProperty("role");
+        expect(data.role).toBe("worker"); // Defaults to "worker" when not specified
+        expect(data).toHaveProperty("state");
+        expect(data).toHaveProperty("metadata");
+
+        console.log("agent_registered event data shape:", JSON.stringify(data, null, 2));
+      }
+    });
+  });
+
+  // ─────────────────────────────────────────────────────────────────
+  // Event shape verification
+  // ─────────────────────────────────────────────────────────────────
+
+  describe("event shape verification for TUI compatibility", () => {
+    it("agent_registered notification has SDK format expected by streamEvents", async () => {
+      // Connect subscriber
+      const subscriber = createClient();
+      await subscriber.connect();
+      await subscriber.request("map/subscribe", {
+        filter: { eventTypes: ["agent_registered"] },
+      });
+
+      // We can't spawn real agents, so let's use the map/replay endpoint
+      // to check historical events. First, seed an agent.
+      eventStore.emit({
+        type: "spawn",
+        source: { agent_id: "system" },
+        payload: {
+          agent_id: "agent_shape_test",
+          session_id: "sess_shape",
+          task: "Shape test",
+          task_id: "task_shape",
+          parent: null,
+          config: {},
+          cwd: "/test",
+        },
+      });
+
+      // Use map/replay to see if the spawn was recorded as an agent_registered event
+      const replayRes = await subscriber.request("map/replay", {
+        filter: { eventTypes: ["agent_registered"] },
+        limit: 100,
+      });
+
+      console.log("replay response:", JSON.stringify(replayRes.result, null, 2));
+
+      // The replay result tells us whether agent_registered events are
+      // being recorded. If replay returns empty, the lifecycle listener
+      // isn't firing for eventStore.emit-based spawns.
+      const result = replayRes.result as {
+        events: Array<{ event: { type: string; data: Record<string, unknown> } }>;
+      } | null;
+
+      if (result?.events?.length) {
+        // Verify the event shape matches TUI expectations
+        const event = result.events[0].event;
+        expect(event.type).toBe("agent_registered");
+
+        // TUI sync.tsx expects data.agentId (line 232-247 of sync.tsx)
+        expect(event.data.agentId).toBeDefined();
+        console.log("Event data shape:", JSON.stringify(event.data, null, 2));
+      } else {
+        console.log(
+          "No agent_registered events in replay — " +
+            "eventStore.emit('spawn') does NOT trigger lifecycle → " +
+            "MAP adapter never emits agent_registered for directly seeded agents",
+        );
+      }
+    });
+  });
+});