macro-agent 0.2.4 → 0.2.6

package/src/__tests__/e2e/acp-over-map.e2e.test.ts

@@ -1,457 +0,0 @@
-/**
- * ACP-over-MAP E2E Tests
- *
- * Tests the full ACP-over-MAP flow:
- * 1. Boot macro-agent with MAP server
- * 2. Connect as MAP client
- * 3. Create ACP stream to a local agent
- * 4. Initialize, create session, prompt
- * 5. Receive session updates
- *
- * Uses mocked acp-factory (no real Claude Code) unless RUN_FULL_AGENT_TESTS=true.
- *
- * Run:
- *   npx vitest run --config vitest.e2e.config.ts src/__tests__/e2e/acp-over-map.e2e.test.ts
- */
-
-import { describe, it, expect, beforeAll, afterAll, vi } from "vitest";
-import * as fs from "fs";
-import * as path from "path";
-import * as os from "os";
-import { bootV2, type MacroAgentSystemV2 } from "../../boot-v2.js";
-import { ClientConnection, createACPStream } from "@multi-agent-protocol/sdk";
-
-const IS_LIVE = process.env.RUN_FULL_AGENT_TESTS === "true";
-
-// Mock acp-factory for non-live tests
-if (!IS_LIVE) {
-  vi.mock("acp-factory", () => ({
-    AgentFactory: {
-      spawn: vi.fn().mockResolvedValue({
-        createSession: vi.fn().mockResolvedValue({
-          id: `session-mock-${Date.now()}`,
-          prompt: vi.fn().mockReturnValue({
-            [Symbol.asyncIterator]: () => ({
-              next: () =>
-                Promise.resolve({ done: true, value: undefined }),
-            }),
-          }),
-          close: vi.fn().mockResolvedValue(undefined),
-        }),
-        loadSession: vi.fn().mockResolvedValue({
-          id: `loaded-${Date.now()}`,
-        }),
-        close: vi.fn().mockResolvedValue(undefined),
-        isRunning: vi.fn().mockReturnValue(true),
-      }),
-    },
-  }));
-}
-
-// Mock opentasks
-vi.mock("opentasks", () => ({
-  OpenTasksClient: vi.fn().mockImplementation(() => ({
-    connect: vi.fn().mockRejectedValue(new Error("No daemon")),
-    disconnect: vi.fn(),
-    query: vi.fn().mockResolvedValue({ items: [] }),
-    link: vi.fn().mockResolvedValue({ success: true }),
-    task: vi.fn().mockResolvedValue({ id: "t-1" }),
-  })),
-}));
-
-const TEST_DIR = fs.mkdtempSync(
-  path.join(os.tmpdir(), "acp-over-map-e2e-"),
-);
-
-describe("ACP-over-MAP E2E", () => {
-  let system: MacroAgentSystemV2;
-  let client: ClientConnection | null = null;
-  let mapUrl: string;
-
-  beforeAll(async () => {
-    system = await bootV2({
-      cwd: TEST_DIR,
-      baseDir: TEST_DIR,
-      defaultPermissionMode: "auto-approve",
-      inbox: {
-        socketPath: path.join(TEST_DIR, "inbox.sock"),
-      },
-      mapServer: {
-        enabled: true,
-        port: 0, // OS picks port
-        host: "127.0.0.1",
-      },
-    });
-
-    mapUrl = system.mapServerInstance!.getUrl();
-  }, 15000);
-
-  afterAll(async () => {
-    if (client) {
-      try {
-        await client.disconnect();
-      } catch {
-        // ignore
-      }
-    }
-    if (system) {
-      await system.shutdown();
-    }
-    try {
-      fs.rmSync(TEST_DIR, { recursive: true, force: true });
-    } catch {
-      // cleanup
-    }
-  });
-
-  it("connects MAP client to MAP server", async () => {
-    client = await ClientConnection.connect(mapUrl, {
-      name: "ACP-over-MAP E2E Client",
-      capabilities: {
-        observation: { canObserve: true, canQuery: true },
-        messaging: { canSend: true, canReceive: true },
-        lifecycle: { canSpawn: true, canStop: true },
-      },
-    });
-
-    expect(client.isConnected).toBe(true);
-  }, 10000);
-
-  it("spawns an agent via extension and sees it in agent list", async () => {
-    // Spawn via _macro/spawnAgent extension
-    const result = (await client!.callExtension("_macro/spawnAgent", {
-      task: "ACP-over-MAP test task",
-      role: "worker",
-    })) as { agent: { id: string } };
-
-    expect(result.agent).toBeDefined();
-    expect(result.agent.id).toBeTruthy();
-
-    // Wait for agent registry sync
-    await new Promise((r) => setTimeout(r, 200));
-
-    // Should appear in listAgents
-    const agents = await client!.listAgents();
-    const found = agents.agents.find(
-      (a: any) => a.id === result.agent.id,
-    );
-    expect(found).toBeDefined();
-  }, 10000);
-
-  it("creates ACP stream targeting local agent", async () => {
-    // Get the first agent
-    const agents = await client!.listAgents();
-    expect(agents.agents.length).toBeGreaterThan(0);
-
-    const targetAgent = agents.agents[0].id;
-
-    // Create ACP stream
-    const acpStream = createACPStream(client!, {
-      targetAgent,
-      client: {
-        requestPermission: async () =>
-          ({
-            outcome: { outcome: "allow" },
-          }) as any,
-        sessionUpdate: async () => {},
-      },
-    });
-
-    expect(acpStream).toBeDefined();
-    expect(acpStream.streamId).toBeTruthy();
-    expect(acpStream.targetAgent).toBe(targetAgent);
-
-    // Initialize the ACP stream
-    // This sends an ACP initialize request over MAP to the target agent.
-    // The ACPStreamConnection has a 30s timeout by default — use a shorter one.
-    const shortTimeoutStream = createACPStream(client!, {
-      targetAgent,
-      timeout: 5000, // 5s timeout for E2E
-      client: {
-        requestPermission: async () =>
-          ({
-            outcome: { outcome: "allow" },
-          }) as any,
-        sessionUpdate: async (update: any) => {
-          console.log(
-            "[acp-over-map e2e] Session update:",
-            JSON.stringify(update).slice(0, 200),
-          );
-        },
-      },
-    });
-
-    try {
-      const initResult = await shortTimeoutStream.initialize({
-        protocolVersion: 1,
-        clientInfo: { name: "E2E Test", version: "1.0.0" },
-      });
-
-      expect(initResult).toBeDefined();
-      console.log(
-        "[acp-over-map e2e] Initialize succeeded:",
-        JSON.stringify(initResult),
-      );
-
-      // If initialize worked, try creating a session
-      const sessionResult = await shortTimeoutStream.newSession({
-        mcpServers: [],
-        cwd: process.cwd(),
-      });
-      console.log(
-        "[acp-over-map e2e] New session:",
-        JSON.stringify(sessionResult),
-      );
-    } catch (err) {
-      // Log the error — this helps debug the ACP-over-MAP bridge
-      console.log(
-        "[acp-over-map e2e] ACP operation failed:",
-        (err as Error).message,
-      );
-      // Don't fail the test — we're testing whether the bridge works at all
-    }
-
-    // Clean up
-    try {
-      await shortTimeoutStream.close();
-    } catch {
-      // ignore
-    }
-  }, 15000);
-
-  // ─────────────────────────────────────────────────────────────────
-  // _macro/resumeAgent — durable resume by providerSessionId
-  // ─────────────────────────────────────────────────────────────────
-
-  it("_macro/resumeAgent returns error when providerSessionId is unknown", async () => {
-    const result = (await client!.callExtension("_macro/resumeAgent", {
-      providerSessionId: "psid-does-not-exist",
-    })) as { success: boolean; error?: string };
-
-    expect(result.success).toBe(false);
-    expect(result.error).toBeTruthy();
-  }, 10000);
-
-  it("_macro/resumeAgent returns error when neither id nor psid given", async () => {
-    const result = (await client!.callExtension("_macro/resumeAgent", {})) as {
-      success: boolean;
-      error?: string;
-    };
-
-    expect(result.success).toBe(false);
-    expect(result.error).toMatch(/providerSessionId or agentId/);
-  }, 10000);
-
-  it("_macro/resumeAgent resolves an active agent by providerSessionId (session-first)", async () => {
-    // Spawn an agent so the sessions table has a row with a provider_session_id.
-    // The mock acp-factory sets session.id = `session-mock-${Date.now()}`, which
-    // macro-agent stores as provider_session_id (see agent-manager-v2.ts:1136).
-    const spawnResult = (await client!.callExtension("_macro/spawnAgent", {
-      task: "resume target",
-      role: "worker",
-    })) as { agent: { id: string; localId?: string } };
-
-    // Give the lifecycle bridge a moment to register the agent in the store.
-    await new Promise((r) => setTimeout(r, 200));
-
-    // Read back the session record directly via the exposed AgentStore.
-    // The handler under test looks up agents by provider_session_id via the
-    // same path, so this also validates the store reverse-lookup end to end.
-    const agentStore = system.agentStore;
-    const allAgents = agentStore.listAgents();
-    const spawned = allAgents.find((a) => a.task === "resume target");
-    expect(spawned).toBeDefined();
-
-    const sessionRec = agentStore.getSession(spawned!.id);
-    expect(sessionRec).not.toBeNull();
-    expect(sessionRec!.provider_session_id).toBeTruthy();
-    const providerSessionId = sessionRec!.provider_session_id!;
-
-    // Call _macro/resumeAgent with the provider_session_id. Because the agent
-    // is still active (hasActiveSession === true), the handler takes the
-    // fast path and returns the live session info without re-spawning.
-    const result = (await client!.callExtension("_macro/resumeAgent", {
-      providerSessionId,
-    })) as {
-      success: boolean;
-      agent?: { id: string; localId: string; name?: string; role?: string };
-      acpSessionId?: string;
-      providerSessionId?: string;
-      error?: string;
-    };
-
-    expect(result.success).toBe(true);
-    expect(result.agent).toBeDefined();
-    expect(result.agent!.localId).toBe(spawned!.id);
-    expect(result.agent!.role).toBe("worker");
-    expect(result.acpSessionId).toBe(sessionRec!.session_id);
-    expect(result.providerSessionId).toBe(providerSessionId);
-    // peerMapId (agent.id) should resolve to a MAP-server ULID, not the
-    // local store id — this confirms MAPServer registration is in place.
-    expect(result.agent!.id).toBeTruthy();
-  }, 15000);
-
-  it("_macro/resumeAgent resolves by agentId (fallback path)", async () => {
-    // Use an existing agent from the previous test. Listing is stable within
-    // the same MAP server instance.
-    const agentStore = system.agentStore;
-    const agents = agentStore.listAgents();
-    expect(agents.length).toBeGreaterThan(0);
-    const target = agents[0];
-
-    const result = (await client!.callExtension("_macro/resumeAgent", {
-      agentId: target.id,
-    })) as {
-      success: boolean;
-      agent?: { id: string; localId: string };
-      error?: string;
-    };
-
-    expect(result.success).toBe(true);
-    expect(result.agent!.localId).toBe(target.id);
-  }, 15000);
-});
-
-describe("ACP-over-MAP E2E — MAP-level operations with agents", () => {
-  let system: MacroAgentSystemV2;
-  let client: ClientConnection | null = null;
-
-  const dir = fs.mkdtempSync(
-    path.join(os.tmpdir(), "acp-map-ops-e2e-"),
-  );
-
-  beforeAll(async () => {
-    system = await bootV2({
-      cwd: dir,
-      baseDir: dir,
-      defaultPermissionMode: "auto-approve",
-      inbox: {
-        socketPath: path.join(dir, "inbox.sock"),
-      },
-      mapServer: {
-        enabled: true,
-        port: 0,
-        host: "127.0.0.1",
-      },
-    });
-
-    const mapUrl = system.mapServerInstance!.getUrl();
-    client = await ClientConnection.connect(mapUrl, {
-      name: "MAP Ops E2E",
-      capabilities: {
-        observation: { canObserve: true, canQuery: true },
-        messaging: { canSend: true, canReceive: true },
-        lifecycle: { canSpawn: true, canStop: true },
-      },
-    });
-  }, 15000);
-
-  afterAll(async () => {
-    // Shut down system first — this closes WebSocket connections,
-    // which unblocks any pending subscription iterators.
-    if (system) {
-      await system.shutdown();
-    }
-    if (client) {
-      try {
-        await Promise.race([
-          client.disconnect(),
-          new Promise((r) => setTimeout(r, 2000)),
-        ]);
-      } catch {
-        // ignore — connection likely already closed by system.shutdown()
-      }
-    }
-    try {
-      fs.rmSync(dir, { recursive: true, force: true });
-    } catch {
-      // cleanup
-    }
-  });
-
-  it("subscribes to events and receives agent lifecycle notifications", async () => {
-    const events: any[] = [];
-
-    // Subscribe to agent lifecycle events
-    const subscription = await client!.subscribe({
-      eventTypes: ["agent.registered", "agent.unregistered"],
-    });
-
-    // Collect events in background (don't await — may block on iterator)
-    let collecting: Promise<void> | null = null;
-    collecting = (async () => {
-      for await (const event of subscription) {
-        events.push(event);
-        if (events.length >= 1) break; // Stop after first event
-      }
-    })();
-
-    // Spawn an agent to trigger an event
-    await client!.callExtension("_macro/spawnAgent", {
-      task: "Subscription test",
-      role: "worker",
-    });
-
-    // Wait for event (with timeout)
-    await Promise.race([
-      collecting,
-      new Promise((r) => setTimeout(r, 3000)),
-    ]);
-
-    // Should have received the agent.registered event
-    console.log(
-      `[acp-over-map e2e] Received ${events.length} subscription events`,
-    );
-    for (const event of events) {
-      console.log(`  Event: ${event.type}`);
-    }
-
-    expect(events.length).toBeGreaterThan(0);
-    expect(events[0].type).toBe("agent.registered");
-
-    // Unsubscribe with timeout to prevent hanging
-    await Promise.race([
-      subscription.unsubscribe().catch(() => {}),
-      new Promise((r) => setTimeout(r, 1000)),
-    ]);
-  }, 10000);
-
-  it("sends messages to agents via MAP", async () => {
-    // Use a fresh client to avoid connection state issues from subscription test
-    const mapUrl = system.mapServerInstance!.getUrl();
-    const freshClient = await ClientConnection.connect(mapUrl, {
-      name: "MAP Messages E2E",
-      capabilities: {
-        messaging: { canSend: true, canReceive: true },
-      },
-    });
-
-    try {
-      const agents = await freshClient.listAgents();
-      if (agents.agents.length === 0) {
-        console.log("[acp-over-map e2e] No agents to message, skipping");
-        return;
-      }
-
-      const targetAgent = agents.agents[0].id;
-
-      // Send a regular MAP message (not ACP) to the agent
-      const result = await freshClient.send(
-        { agent: targetAgent },
-        { type: "test.ping", data: "hello from e2e" },
-      );
-
-      expect(result).toBeDefined();
-      console.log(
-        "[acp-over-map e2e] Message sent to agent:",
-        targetAgent,
-      );
-    } finally {
-      try {
-        await freshClient.disconnect();
-      } catch {
-        // ignore
-      }
-    }
-  });
-});