macro-agent 0.1.2 → 0.1.4

package/src/acp/__tests__/multi-client-mounting.test.ts

@@ -1,303 +0,0 @@
-/**
- * Multi-Client Mounting Test
- *
- * Tests that multiple WebSocket clients can connect and the WebSocket transport
- * layer correctly handles multiple connections. The actual multi-session agent
- * mounting logic is tested in integration.test.ts with mocked services.
- *
- * This test verifies:
- * 1. Multiple WebSocket connections share the same services
- * 2. Connection tracking works correctly
- * 3. Each connection gets independent MacroAgent instances
- *
- * Note: The ACP SDK routes methods internally, so we test at the transport level
- * here. Full agent mounting workflows are tested in integration.test.ts.
- */
-
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-import { WebSocket } from "ws";
-import {
-  createWebSocketACPServer,
-  type WebSocketACPServer,
-  type ACPServices,
-} from "../websocket-server.js";
-
-// ─────────────────────────────────────────────────────────────────
-// Test Client
-// ─────────────────────────────────────────────────────────────────
-
-interface JsonRpcResponse {
-  jsonrpc: "2.0";
-  id: number;
-  result?: unknown;
-  error?: { code: number; message: string; data?: unknown };
-}
-
-class ACPTestClient {
-  private ws: WebSocket | null = null;
-  private waiters: Map<number, (response: JsonRpcResponse) => void> = new Map();
-  private nextId = 1;
-  private _connected = false;
-
-  constructor(private url: string) {
-    // Don't connect in constructor - wait for connect() to be called
-  }
-
-  async connect(): Promise<void> {
-    this.ws = new WebSocket(this.url);
-    return new Promise((resolve, reject) => {
-      this.ws!.on("open", () => {
-        this._connected = true;
-        resolve();
-      });
-      this.ws!.on("error", reject);
-      this.ws!.on("message", (data: Buffer) => {
-        try {
-          const message = JSON.parse(data.toString()) as JsonRpcResponse;
-          const waiter = this.waiters.get(message.id);
-          if (waiter) {
-            this.waiters.delete(message.id);
-            waiter(message);
-          }
-        } catch {
-          // Ignore parse errors
-        }
-      });
-    });
-  }
-
-  async send(method: string, params?: unknown): Promise<JsonRpcResponse> {
-    if (!this.ws) {
-      throw new Error("Not connected");
-    }
-    const id = this.nextId++;
-    return new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => {
-        this.waiters.delete(id);
-        reject(new Error(`Timeout waiting for ${method}`));
-      }, 5000);
-
-      this.waiters.set(id, (response) => {
-        clearTimeout(timeout);
-        resolve(response);
-      });
-
-      this.ws!.send(JSON.stringify({ jsonrpc: "2.0", method, params, id }));
-    });
-  }
-
-  close(): void {
-    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
-      this.ws.close();
-    }
-  }
-
-  get isConnected(): boolean {
-    return this._connected && this.ws !== null && this.ws.readyState === WebSocket.OPEN;
-  }
-}
-
-// ─────────────────────────────────────────────────────────────────
-// Mock Services with State Tracking
-// ─────────────────────────────────────────────────────────────────
-
-function createStatefulMockServices() {
-  // Shared state across all connections
-  const agents = new Map<string, { id: string; session_id: string; cwd: string }>();
-  let agentCounter = 0;
-  let sessionCounter = 0;
-
-  const services: ACPServices = {
-    agentManager: {
-      getOrCreateHeadManager: vi.fn().mockImplementation(async (opts: { cwd: string }) => {
-        const id = `agent_${++agentCounter}`;
-        const session_id = `session_${++sessionCounter}`;
-        const agent = { id, session_id, cwd: opts.cwd, state: "running", lineage: [], created_at: Date.now() };
-        agents.set(id, agent);
-        return agent;
-      }),
-      get: vi.fn().mockImplementation((id: string) => agents.get(id)),
-      list: vi.fn().mockImplementation(() => Array.from(agents.values())),
-      listHeadManagers: vi.fn().mockImplementation(() =>
-        Array.from(agents.values()).filter(a => !a.id.includes("child"))
-      ),
-      getChildren: vi.fn().mockReturnValue([]),
-      getHierarchy: vi.fn().mockImplementation(() => ({
-        agents: Array.from(agents.values()),
-        relationships: [],
-      })),
-      spawn: vi.fn().mockImplementation(async () => {
-        const id = `agent_child_${++agentCounter}`;
-        const agent = { id, session_id: "", cwd: "/", state: "running", lineage: [], created_at: Date.now() };
-        agents.set(id, agent);
-        return agent;
-      }),
-      prompt: vi.fn(),
-      resume: vi.fn(),
-      close: vi.fn(),
-      hasActiveSession: vi.fn().mockReturnValue(false),
-    } as any,
-    eventStore: {
-      append: vi.fn(),
-      query: vi.fn().mockReturnValue([]),
-      persist: vi.fn(),
-      close: vi.fn(),
-    } as any,
-    taskManager: {
-      create: vi.fn().mockImplementation((opts) => ({ id: `task_${Date.now()}`, ...opts })),
-      get: vi.fn(),
-      list: vi.fn().mockReturnValue([]),
-      update: vi.fn(),
-    } as any,
-  };
-
-  return { services, agents };
-}
-
-// ─────────────────────────────────────────────────────────────────
-// Multi-Client Connection Tests
-// ─────────────────────────────────────────────────────────────────
-
-describe("Multi-Client WebSocket Connections", () => {
-  let server: WebSocketACPServer;
-  let mockData: ReturnType<typeof createStatefulMockServices>;
-  let testPort: number;
-  const clients: ACPTestClient[] = [];
-
-  beforeEach(async () => {
-    testPort = 10000 + Math.floor(Math.random() * 50000);
-    mockData = createStatefulMockServices();
-    server = createWebSocketACPServer(mockData.services, {
-      port: testPort,
-      host: "localhost",
-      path: "/acp",
-    });
-    await server.start();
-  });
-
-  afterEach(async () => {
-    for (const client of clients) {
-      client.close();
-    }
-    clients.length = 0;
-    await server.stop();
-  });
-
-  it("should allow multiple clients to connect and initialize", async () => {
-    const clientA = new ACPTestClient(`ws://localhost:${testPort}/acp`);
-    const clientB = new ACPTestClient(`ws://localhost:${testPort}/acp`);
-    clients.push(clientA, clientB);
-
-    await Promise.all([clientA.connect(), clientB.connect()]);
-
-    // Both clients can initialize independently
-    const [initA, initB] = await Promise.all([
-      clientA.send("initialize", { protocolVersion: 1 }),
-      clientB.send("initialize", { protocolVersion: 1 }),
-    ]);
-
-    expect(initA.result).toBeDefined();
-    expect(initB.result).toBeDefined();
-    expect((initA.result as any).protocolVersion).toBe(1);
-    expect((initB.result as any).protocolVersion).toBe(1);
-  });
-
-  it("should track connection count accurately", async () => {
-    const initialCount = server.getConnectionCount();
-
-    const clientA = new ACPTestClient(`ws://localhost:${testPort}/acp`);
-    const clientB = new ACPTestClient(`ws://localhost:${testPort}/acp`);
-    const clientC = new ACPTestClient(`ws://localhost:${testPort}/acp`);
-    clients.push(clientA, clientB, clientC);
-
-    await clientA.connect();
-    expect(server.getConnectionCount()).toBe(initialCount + 1);
-
-    await clientB.connect();
-    expect(server.getConnectionCount()).toBe(initialCount + 2);
-
-    await clientC.connect();
-    expect(server.getConnectionCount()).toBe(initialCount + 3);
-
-    // Disconnect one client
-    clientB.close();
-    await new Promise((r) => setTimeout(r, 50));
-    expect(server.getConnectionCount()).toBe(initialCount + 2);
-  });
-
-  it("should share services across all connections", async () => {
-    // The point: all WebSocket connections get MacroAgent instances
-    // that reference the SAME agentManager, eventStore, taskManager
-    // This is verified by the fact that we pass shared mock services
-    // and they would be called by any connection's MacroAgent
-
-    const clientA = new ACPTestClient(`ws://localhost:${testPort}/acp`);
-    const clientB = new ACPTestClient(`ws://localhost:${testPort}/acp`);
-    clients.push(clientA, clientB);
-
-    await Promise.all([clientA.connect(), clientB.connect()]);
-
-    // Initialize both
-    await Promise.all([
-      clientA.send("initialize", { protocolVersion: 1 }),
-      clientB.send("initialize", { protocolVersion: 1 }),
-    ]);
-
-    // Both are connected and using the same server
-    expect(clientA.isConnected).toBe(true);
-    expect(clientB.isConnected).toBe(true);
-    expect(server.getConnectionCount()).toBe(2);
-
-    // The shared services object is passed to both MacroAgent instances
-    // This is the key architectural feature - shared state
-    expect(mockData.services.agentManager).toBeDefined();
-    expect(mockData.services.eventStore).toBeDefined();
-    expect(mockData.services.taskManager).toBeDefined();
-  });
-
-  it("should create independent MacroAgent per connection", async () => {
-    // Each connection gets its own MacroAgent instance with its own SessionMapper
-    // This means session state is isolated per connection
-
-    const clientA = new ACPTestClient(`ws://localhost:${testPort}/acp`);
-    const clientB = new ACPTestClient(`ws://localhost:${testPort}/acp`);
-    clients.push(clientA, clientB);
-
-    await Promise.all([clientA.connect(), clientB.connect()]);
-
-    const [initA, initB] = await Promise.all([
-      clientA.send("initialize", { protocolVersion: 1 }),
-      clientB.send("initialize", { protocolVersion: 1 }),
-    ]);
-
-    // Both initialized successfully with independent responses
-    expect(initA.id).toBeDefined();
-    expect(initB.id).toBeDefined();
-
-    // Response IDs are tracked independently per client
-    // (our test client uses sequential IDs starting at 1)
-    expect(initA.id).toBe(1);
-    expect(initB.id).toBe(1); // Each client has its own ID sequence
-  });
-});
-
-/**
- * Note on Multi-Session Agent Mounting:
- *
- * The actual agent mounting functionality (newSession, mountAgent, etc.)
- * is tested in integration.test.ts with direct MacroAgent method calls.
- *
- * Those tests verify:
- * - Session 1 creates head manager, spawns child
- * - Session 2 creates its own head manager
- * - Session 2 can mount to Session 1's child
- * - Sessions are isolated from each other
- *
- * The WebSocket transport tests here verify:
- * - Multiple WebSocket connections work correctly
- * - Each gets independent MacroAgent instance
- * - All share the same services (AgentManager, EventStore, etc.)
- *
- * Combined, these tests verify the full feature:
- * WebSocket transport -> MacroAgent -> Shared Services
- */

package/src/acp/__tests__/session-persistence.test.ts

@@ -1,276 +0,0 @@
-/**
- * Session persistence and recovery tests
- *
- * Tests that session lifecycle events are persisted to the EventStore
- * and that SessionMapper can recover its state from persisted sessions.
- */
-
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { SessionMapper } from "../session-mapper.js";
-import { createEventStore, type EventStore } from "../../store/event-store.js";
-
-describe("Session Persistence", () => {
-  let eventStore: EventStore;
-  let mapper: SessionMapper;
-
-  beforeEach(async () => {
-    eventStore = await createEventStore({ inMemory: true });
-    mapper = new SessionMapper(eventStore);
-  });
-
-  afterEach(async () => {
-    await eventStore.close();
-  });
-
-  describe("session lifecycle events", () => {
-    it("should emit session created event on createMapping", () => {
-      mapper.createMapping("session-1", "agent-head");
-
-      const session = eventStore.getSession("session-1");
-      expect(session).not.toBeNull();
-      expect(session!.id).toBe("session-1");
-      expect(session!.head_manager_id).toBe("agent-head");
-      expect(session!.current_agent_id).toBe("agent-head");
-      expect(session!.state).toBe("active");
-      expect(session!.created_at).toBeGreaterThan(0);
-    });
-
-    it("should emit session mounted event on mount", () => {
-      mapper.createMapping("session-1", "agent-head");
-      mapper.mount("session-1", "agent-child");
-
-      const session = eventStore.getSession("session-1");
-      expect(session!.state).toBe("mounted");
-      expect(session!.current_agent_id).toBe("agent-child");
-      expect(session!.head_manager_id).toBe("agent-head");
-    });
-
-    it("should emit session unmounted event on unmount", () => {
-      mapper.createMapping("session-1", "agent-head");
-      mapper.mount("session-1", "agent-child");
-      mapper.unmount("session-1");
-
-      const session = eventStore.getSession("session-1");
-      expect(session!.state).toBe("active");
-      expect(session!.current_agent_id).toBe("agent-head");
-    });
-
-    it("should emit unmounted when mounting back to head manager", () => {
-      mapper.createMapping("session-1", "agent-head");
-      mapper.mount("session-1", "agent-child");
-      mapper.mount("session-1", "agent-head");
-
-      const session = eventStore.getSession("session-1");
-      expect(session!.state).toBe("active");
-      expect(session!.current_agent_id).toBe("agent-head");
-    });
-
-    it("should emit session closed event on removeMapping", () => {
-      mapper.createMapping("session-1", "agent-head");
-      mapper.removeMapping("session-1");
-
-      const session = eventStore.getSession("session-1");
-      expect(session!.state).toBe("closed");
-      expect(session!.closed_at).toBeGreaterThan(0);
-    });
-
-    it("should not emit close for non-existent session", () => {
-      mapper.removeMapping("non-existent");
-
-      const session = eventStore.getSession("non-existent");
-      expect(session).toBeNull();
-    });
-
-    it("should track multiple sessions independently", () => {
-      mapper.createMapping("session-1", "agent-1");
-      mapper.createMapping("session-2", "agent-2");
-      mapper.mount("session-1", "agent-child");
-
-      const s1 = eventStore.getSession("session-1");
-      const s2 = eventStore.getSession("session-2");
-
-      expect(s1!.state).toBe("mounted");
-      expect(s2!.state).toBe("active");
-    });
-  });
-
-  describe("listSessions", () => {
-    it("should list sessions by state", () => {
-      mapper.createMapping("session-1", "agent-1");
-      mapper.createMapping("session-2", "agent-2");
-      mapper.mount("session-1", "agent-child");
-
-      const active = eventStore.listSessions({ state: "active" });
-      const mounted = eventStore.listSessions({ state: "mounted" });
-
-      expect(active).toHaveLength(1);
-      expect(active[0].id).toBe("session-2");
-      expect(mounted).toHaveLength(1);
-      expect(mounted[0].id).toBe("session-1");
-    });
-
-    it("should list sessions by agent", () => {
-      mapper.createMapping("session-1", "agent-1");
-      mapper.createMapping("session-2", "agent-2");
-
-      const sessions = eventStore.listSessions({ agent_id: "agent-1" });
-      expect(sessions).toHaveLength(1);
-      expect(sessions[0].id).toBe("session-1");
-    });
-
-    it("should filter closed sessions", () => {
-      mapper.createMapping("session-1", "agent-1");
-      mapper.createMapping("session-2", "agent-2");
-      mapper.removeMapping("session-1");
-
-      const active = eventStore.listSessions({ state: "active" });
-      const closed = eventStore.listSessions({ state: "closed" });
-
-      expect(active).toHaveLength(1);
-      expect(active[0].id).toBe("session-2");
-      expect(closed).toHaveLength(1);
-      expect(closed[0].id).toBe("session-1");
-    });
-  });
-
-  describe("session events in event log", () => {
-    it("should persist session events that can be queried", () => {
-      mapper.createMapping("session-1", "agent-head");
-      mapper.mount("session-1", "agent-child");
-      mapper.unmount("session-1");
-      mapper.removeMapping("session-1");
-
-      const events = eventStore.query({ type: "session" });
-      expect(events).toHaveLength(4);
-      expect(events[0].payload.action).toBe("created");
-      expect(events[1].payload.action).toBe("mounted");
-      expect(events[2].payload.action).toBe("unmounted");
-      expect(events[3].payload.action).toBe("closed");
-    });
-  });
-});
-
-describe("Session Recovery", () => {
-  let eventStore: EventStore;
-
-  beforeEach(async () => {
-    eventStore = await createEventStore({ inMemory: true });
-  });
-
-  afterEach(async () => {
-    await eventStore.close();
-  });
-
-  it("should recover active sessions from EventStore", () => {
-    // Create sessions with original mapper
-    const original = new SessionMapper(eventStore);
-    original.createMapping("session-1", "agent-1");
-    original.createMapping("session-2", "agent-2");
-
-    // Create new mapper and recover
-    const recovered = new SessionMapper(eventStore);
-    const count = recovered.recoverFromStore();
-
-    expect(count).toBe(2);
-    expect(recovered.size).toBe(2);
-    expect(recovered.getAgentId("session-1")).toBe("agent-1");
-    expect(recovered.getAgentId("session-2")).toBe("agent-2");
-  });
-
-  it("should recover mounted sessions with correct state", () => {
-    const original = new SessionMapper(eventStore);
-    original.createMapping("session-1", "agent-head");
-    original.mount("session-1", "agent-child");
-
-    const recovered = new SessionMapper(eventStore);
-    const count = recovered.recoverFromStore();
-
-    expect(count).toBe(1);
-    expect(recovered.getAgentId("session-1")).toBe("agent-child");
-    expect(recovered.getHeadManagerId("session-1")).toBe("agent-head");
-    expect(recovered.isMounted("session-1")).toBe(true);
-  });
-
-  it("should not recover closed sessions", () => {
-    const original = new SessionMapper(eventStore);
-    original.createMapping("session-1", "agent-1");
-    original.createMapping("session-2", "agent-2");
-    original.removeMapping("session-1");
-
-    const recovered = new SessionMapper(eventStore);
-    const count = recovered.recoverFromStore();
-
-    expect(count).toBe(1);
-    expect(recovered.getAgentId("session-1")).toBeUndefined();
-    expect(recovered.getAgentId("session-2")).toBe("agent-2");
-  });
-
-  it("should recover after unmount returns to active state", () => {
-    const original = new SessionMapper(eventStore);
-    original.createMapping("session-1", "agent-head");
-    original.mount("session-1", "agent-child");
-    original.unmount("session-1");
-
-    const recovered = new SessionMapper(eventStore);
-    const count = recovered.recoverFromStore();
-
-    expect(count).toBe(1);
-    expect(recovered.getAgentId("session-1")).toBe("agent-head");
-    expect(recovered.isMounted("session-1")).toBe(false);
-  });
-
-  it("should reset isProcessing to false on recovery", () => {
-    const original = new SessionMapper(eventStore);
-    original.createMapping("session-1", "agent-1");
-    original.setProcessing("session-1", true);
-
-    const recovered = new SessionMapper(eventStore);
-    recovered.recoverFromStore();
-
-    const status = recovered.getSessionStatus("agent-1");
-    expect(status).toBeDefined();
-    expect(status!.isProcessing).toBe(false);
-  });
-
-  it("should return 0 when no EventStore is configured", () => {
-    const mapper = new SessionMapper();
-    const count = mapper.recoverFromStore();
-    expect(count).toBe(0);
-  });
-
-  it("should survive view rebuild", () => {
-    const original = new SessionMapper(eventStore);
-    original.createMapping("session-1", "agent-1");
-    original.createMapping("session-2", "agent-2");
-    original.mount("session-1", "agent-child");
-    original.removeMapping("session-2");
-
-    // Simulate reload (which rebuilds views from events)
-    // We don't need to call reload() since in-memory; just verify
-    // the view state matches after rebuilding
-    const session1 = eventStore.getSession("session-1");
-    const session2 = eventStore.getSession("session-2");
-
-    expect(session1!.state).toBe("mounted");
-    expect(session1!.current_agent_id).toBe("agent-child");
-    expect(session2!.state).toBe("closed");
-  });
-});
-
-describe("SessionMapper backward compatibility", () => {
-  it("should work without EventStore (original behavior)", () => {
-    const mapper = new SessionMapper();
-
-    const mapping = mapper.createMapping("session-1", "agent-head");
-    expect(mapping.agentId).toBe("agent-head");
-
-    mapper.mount("session-1", "agent-child");
-    expect(mapper.getAgentId("session-1")).toBe("agent-child");
-
-    mapper.unmount("session-1");
-    expect(mapper.getAgentId("session-1")).toBe("agent-head");
-
-    mapper.removeMapping("session-1");
-    expect(mapper.getMapping("session-1")).toBeUndefined();
-  });
-});