macro-agent 0.2.5 → 0.2.6

package/src/__tests__/e2e/trajectory-tracking.e2e.test.ts

@@ -1,258 +0,0 @@
-/**
- * Trajectory Tracking E2E Test
- *
- * Verifies that macro-agent emits trajectory checkpoints after each prompt:
- *   1. Boot with MAP server + MAP sidecar (sidecar to unreachable hub — graceful degradation)
- *   2. Connect via MAP, create ACP session, prompt agent
- *   3. Verify trajectory/checkpoint extension call works
- *   4. Verify checkpoint contains expected fields (files_touched, toolCallCount, etc.)
- *
- * Also tests with live agents (RUN_FULL_AGENT_TESTS=true) to verify
- * real tool calls populate files_touched.
- *
- * Run:
- *   npx vitest run --config vitest.e2e.config.ts src/__tests__/e2e/trajectory-tracking.e2e.test.ts
- *   RUN_FULL_AGENT_TESTS=true npx vitest run --config vitest.e2e.config.ts src/__tests__/e2e/trajectory-tracking.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]: () => {
-              let yielded = false;
-              return {
-                next: () => {
-                  if (!yielded) {
-                    yielded = true;
-                    // Yield a tool_call update with a file path
-                    return Promise.resolve({
-                      done: false,
-                      value: {
-                        sessionUpdate: "tool_call",
-                        title: "Write",
-                        rawInput: { file_path: "/tmp/test.txt" },
-                      },
-                    });
-                  }
-                  return 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),
-      }),
-    },
-  }));
-}
-
-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(), "trajectory-e2e-"),
-);
-
-describe("Trajectory Tracking E2E", () => {
-  let system: MacroAgentSystemV2;
-  let client: ClientConnection;
-  let mapUrl: string;
-
-  // Collect checkpoints received by the trajectory/checkpoint handler
-  const receivedCheckpoints: any[] = [];
-
-  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,
-        host: "127.0.0.1",
-      },
-      // Sidecar to unreachable hub — tests graceful degradation
-      map: {
-        enabled: true,
-        server: "ws://127.0.0.1:1",
-        reconnection: { enabled: false },
-        reconnectIntervalMs: 999999,
-      },
-    });
-
-    mapUrl = system.mapServerInstance!.getUrl();
-
-    client = await ClientConnection.connect(mapUrl, {
-      name: "Trajectory E2E",
-      capabilities: {
-        observation: { canObserve: true, canQuery: true },
-        messaging: { canSend: true, canReceive: true },
-        lifecycle: { canSpawn: true, canStop: true },
-      },
-    });
-  }, 30000);
-
-  afterAll(async () => {
-    try { await client?.disconnect(); } catch { /* ignore */ }
-    try { await system?.shutdown(); } catch { /* ignore */ }
-    try { fs.rmSync(TEST_DIR, { recursive: true, force: true }); } catch { /* ignore */ }
-  });
-
-  it("trajectory/checkpoint handler accepts checkpoints", async () => {
-    const result = await client.callExtension("trajectory/checkpoint", {
-      checkpoint: {
-        id: "test-checkpoint-1",
-        session_id: "test-session",
-        agent: "test-agent",
-        branch: "main",
-        files_touched: ["src/index.ts", "README.md"],
-        checkpoints_count: 1,
-        token_usage: { input_tokens: 100, output_tokens: 200 },
-        metadata: { project: "test-project", phase: "active" },
-      },
-    });
-
-    expect((result as any).ok).toBe(true);
-  });
-
-  it("trajectory/checkpoint handler accepts minimal checkpoints", async () => {
-    const result = await client.callExtension("trajectory/checkpoint", {
-      checkpoint: {
-        id: "minimal-1",
-        session_id: "s1",
-        agent: "a1",
-        branch: null,
-        files_touched: [],
-        checkpoints_count: 0,
-      },
-    });
-
-    expect((result as any).ok).toBe(true);
-  });
-
-  it("trajectory/checkpoint handler rejects missing checkpoint", async () => {
-    const result = await client.callExtension("trajectory/checkpoint", {});
-    expect((result as any).ok).toBe(false);
-  });
-
-  it("emits trajectory checkpoint after ACP prompt", async () => {
-    // Spawn an agent
-    await client.callExtension("_macro/spawnAgent", {
-      task: "Trajectory test agent",
-      role: "coordinator",
-    });
-    await new Promise((r) => setTimeout(r, 1000));
-
-    const agents = await client.listAgents();
-    expect(agents.agents.length).toBeGreaterThan(0);
-    const targetAgent = agents.agents[0].id;
-
-    // Create ACP stream and prompt
-    const updates: any[] = [];
-    const acpStream = createACPStream(client, {
-      targetAgent,
-      timeout: IS_LIVE ? 60000 : 10000,
-      client: {
-        requestPermission: async () =>
-          ({ outcome: { outcome: "allow" } }) as any,
-        sessionUpdate: async (update: any) => {
-          updates.push(update);
-        },
-      },
-    });
-
-    await acpStream.initialize({
-      protocolVersion: 1,
-      clientInfo: { name: "Trajectory E2E", version: "1.0.0" },
-    });
-
-    const session = await acpStream.newSession({
-      mcpServers: [],
-      cwd: TEST_DIR,
-    });
-
-    const sessionId = (session as any).sessionId;
-    expect(sessionId).toBeTruthy();
-
-    // Prompt — this should trigger trajectory checkpoint after completion
-    const result = await acpStream.prompt({
-      sessionId,
-      prompt: [
-        {
-          type: "text",
-          text: IS_LIVE
-            ? "Write 'hello' to /tmp/trajectory-test.txt using the Write tool."
-            : "Test prompt",
-        },
-      ],
-    });
-
-    expect(result.stopReason).toBeTruthy();
-
-    // Wait a moment for the async checkpoint emission
-    await new Promise((r) => setTimeout(r, 500));
-
-    // Verify we received session updates
-    expect(updates.length).toBeGreaterThan(0);
-
-    // The trajectory checkpoint was emitted via sidecar.reportCheckpoint()
-    // Since our sidecar is connected to an unreachable hub, the checkpoint
-    // goes through reportCheckpoint → trajectoryReporter → callExtension
-    // → fails silently (hub unreachable). But the data was collected.
-    //
-    // To verify the checkpoint DATA, we can check via the trajectory/checkpoint
-    // extension call directly.
-    const manualCheckpoint = await client.callExtension(
-      "trajectory/checkpoint",
-      {
-        checkpoint: {
-          id: `${sessionId}-manual`,
-          session_id: sessionId,
-          agent: "trajectory-test",
-          branch: null,
-          files_touched: IS_LIVE ? ["/tmp/trajectory-test.txt"] : [],
-          checkpoints_count: 1,
-          metadata: {
-            project: TEST_DIR.split("/").pop(),
-            phase: "active",
-            toolCallCount: IS_LIVE ? 1 : 0,
-          },
-        },
-      },
-    );
-
-    expect((manualCheckpoint as any).ok).toBe(true);
-    console.log(
-      `[trajectory-e2e] Session updates: ${updates.length}, checkpoint accepted: ${(manualCheckpoint as any).ok}`,
-    );
-
-    await acpStream.close();
-  }, IS_LIVE ? 120000 : 30000);
-});

package/src/__tests__/e2e/trigger-wake.e2e.test.ts

@@ -1,257 +0,0 @@
-/**
- * Trigger & Wake E2E Tests (V2)
- *
- * Tests that verify the trigger system delivers inbox messages
- * to agents and correctly maps importance to wake actions.
- *
- * REQUIRES: RUN_FULL_AGENT_TESTS=true
- *
- * Run with:
- *   RUN_FULL_AGENT_TESTS=true npx vitest run --config vitest.e2e.config.ts src/__tests__/e2e/trigger-wake.e2e.test.ts
- */
-
-import {
-  describe,
-  it,
-  expect,
-  beforeEach,
-  afterEach,
-} from "vitest";
-import * as path from "path";
-import * as os from "os";
-import * as fs from "fs";
-import { execSync } from "child_process";
-import { bootV2, type MacroAgentSystemV2 } from "../../boot-v2.js";
-
-// ─────────────────────────────────────────────────────────────────
-// Configuration
-// ─────────────────────────────────────────────────────────────────
-
-const RUN_FULL_AGENT = !!process.env.RUN_FULL_AGENT_TESTS;
-const describeFn = RUN_FULL_AGENT ? describe : describe.skip;
-
-const TIMEOUT = {
-  SPAWN: 60_000,
-  PROMPT: 90_000,
-  MULTI: 180_000,
-};
-
-// ─────────────────────────────────────────────────────────────────
-// Helpers
-// ─────────────────────────────────────────────────────────────────
-
-function createTestRepo(prefix: string): { path: string; cleanup: () => void } {
-  const tmpDir = fs.mkdtempSync(
-    path.join(os.tmpdir(), `trigger-wake-${prefix}-`)
-  );
-  const repoPath = path.join(tmpDir, "test-repo");
-  fs.mkdirSync(repoPath);
-  execSync("git init", { cwd: repoPath, stdio: "pipe" });
-  execSync('git config user.email "test@test.com"', { cwd: repoPath, stdio: "pipe" });
-  execSync('git config user.name "Test User"', { cwd: repoPath, stdio: "pipe" });
-  fs.writeFileSync(path.join(repoPath, "README.md"), "# Test Repo\n");
-  execSync("git add -A", { cwd: repoPath, stdio: "pipe" });
-  execSync('git commit -m "Initial commit"', { cwd: repoPath, stdio: "pipe" });
-
-  return {
-    path: repoPath,
-    cleanup: () => fs.rmSync(tmpDir, { recursive: true, force: true }),
-  };
-}
-
-function log(msg: string): void {
-  console.log(`[TRIGGER-E2E] ${msg}`);
-}
-
-function getTextContent(updates: any[]): string {
-  const parts: string[] = [];
-  for (const u of updates) {
-    const uAny = u as any;
-    if (uAny.sessionUpdate === "agent_message_chunk" && uAny.content?.text) {
-      parts.push(uAny.content.text);
-    }
-  }
-  return parts.join("");
-}
-
-// ─────────────────────────────────────────────────────────────────
-// Tests
-// ─────────────────────────────────────────────────────────────────
-
-describeFn("Trigger & Wake E2E (V2)", () => {
-  let system: MacroAgentSystemV2;
-  let testRepo: { path: string; cleanup: () => void };
-  let baseDir: string;
-
-  beforeEach(async () => {
-    testRepo = createTestRepo("v2");
-    baseDir = path.join(testRepo.path, ".macro-agent");
-    fs.mkdirSync(baseDir, { recursive: true });
-
-    system = await bootV2({
-      cwd: testRepo.path,
-      baseDir,
-      defaultPermissionMode: "auto-approve",
-      inbox: {
-        socketPath: path.join(baseDir, "inbox.sock"),
-      },
-    });
-    log("System booted");
-  });
-
-  afterEach(async () => {
-    if (system) {
-      try {
-        const running = system.agentManager.list({ state: "running" });
-        for (const agent of running) {
-          try {
-            await system.agentManager.terminate(agent.id, "cancelled");
-          } catch {
-            // Best effort
-          }
-        }
-        await system.shutdown();
-      } catch {
-        // Best effort
-      }
-    }
-    testRepo?.cleanup();
-    log("Cleanup complete");
-  });
-
-  // ── Inbox message reaches agent via trigger system ────────────
-
-  it(
-    "should deliver an urgent inbox message to a real agent via the trigger system",
-    async () => {
-      log("Spawning agent...");
-      const agent = await system.agentManager.spawn({
-        task: "You are a message-checking agent. When prompted, check your inbox messages and report what you find.",
-        role: "worker",
-        cwd: testRepo.path,
-      });
-
-      log(`Agent spawned: ${agent.id}`);
-
-      // Send an urgent message via inbox from "system"
-      const messageContent = "URGENT_DEPLOY_ROLLBACK_REQUIRED";
-      log("Sending urgent inbox message from system...");
-      const msgId = await system.inboxAdapter.send(
-        "system",
-        agent.id,
-        {
-          type: "text",
-          text: messageContent,
-        },
-        {
-          importance: "urgent",
-          subject: "Deploy rollback",
-          threadTag: `trigger-test:${agent.id}`,
-        }
-      );
-      expect(msgId).toBeTruthy();
-      log(`Message sent: ${msgId}`);
-
-      // Allow trigger system to process the delivery event
-      await new Promise((r) => setTimeout(r, 2000));
-
-      // Verify the message is in the agent's inbox
-      const inbox = await system.inboxAdapter.checkInbox(agent.id);
-      const urgentMsg = inbox.find((m) => m.id === msgId);
-      expect(urgentMsg).toBeDefined();
-      expect(urgentMsg!.importance).toBe("urgent");
-      log(`Message verified in inbox: importance=${urgentMsg!.importance}`);
-
-      // Verify the trigger system enqueued the message for wake delivery
-      const agentsWithEvents = system.triggerSystem.queue.getAgentsWithEvents();
-      log(`Agents with trigger events: ${agentsWithEvents.length}`);
-
-      // The urgent message should have been enqueued in the system event queue
-      // because the agent has an active session (importance=urgent -> interrupt action)
-      const agentQueued = agentsWithEvents.includes(agent.id);
-      log(`Agent ${agent.id} has queued events: ${agentQueued}`);
-
-      // Prompt the agent to check its messages
-      log("Prompting agent to check messages...");
-      const updates: any[] = [];
-      for await (const update of system.agentManager.prompt(
-        agent.id,
-        "Check your inbox for any messages you have received. What messages are in your inbox? Report any content you find."
-      )) {
-        updates.push(update);
-      }
-
-      const responseText = getTextContent(updates);
-      log(`Agent response: ${responseText.slice(0, 300)}`);
-
-      // The agent may or may not have an inbox-reading tool, but the message
-      // should be accessible. Verify the side effect: message exists in inbox.
-      expect(inbox.length).toBeGreaterThanOrEqual(1);
-
-      log("Urgent inbox message delivery verified!");
-    },
-    TIMEOUT.MULTI
-  );
-
-  // ── Low importance message queued without waking ──────────────
-
-  it(
-    "should queue a low-priority message without waking the agent",
-    async () => {
-      log("Spawning agent...");
-      const agent = await system.agentManager.spawn({
-        task: "You are a background worker. Wait for instructions.",
-        role: "worker",
-        cwd: testRepo.path,
-      });
-
-      log(`Agent spawned: ${agent.id}`);
-      expect(system.agentManager.hasActiveSession(agent.id)).toBe(true);
-
-      // Send a low-priority message
-      const messageContent = "Low priority background update: metrics collected";
-      log("Sending low-priority inbox message...");
-      const msgId = await system.inboxAdapter.send(
-        "system",
-        agent.id,
-        messageContent,
-        {
-          importance: "low",
-          threadTag: `low-priority-test:${agent.id}`,
-        }
-      );
-      expect(msgId).toBeTruthy();
-      log(`Low-priority message sent: ${msgId}`);
-
-      // Allow trigger system to process the delivery event
-      await new Promise((r) => setTimeout(r, 1000));
-
-      // Verify message is in the agent's inbox
-      const inbox = await system.inboxAdapter.checkInbox(agent.id);
-      const lowMsg = inbox.find((m) => m.id === msgId);
-      expect(lowMsg).toBeDefined();
-      expect(lowMsg!.importance).toBe("low");
-      log("Low-priority message found in inbox");
-
-      // Verify the message was enqueued in the trigger queue
-      // (low importance -> always "queue" action, never "wake" or "interrupt")
-      const agentsWithEvents = system.triggerSystem.queue.getAgentsWithEvents();
-      const agentHasEvents = agentsWithEvents.includes(agent.id);
-      log(`Agent has queued trigger events: ${agentHasEvents}`);
-
-      // The key assertion: low-priority messages get queued (not delivered immediately)
-      // This is verified by the message being in the system event queue
-      if (agentHasEvents) {
-        log("Low-priority message correctly queued in trigger system");
-      }
-
-      // Also verify the inbox still has the message (it wasn't consumed by wake)
-      const inboxAfter = await system.inboxAdapter.checkInbox(agent.id);
-      expect(inboxAfter.find((m) => m.id === msgId)).toBeDefined();
-      log("Message still in inbox (not consumed by wake delivery)");
-
-      log("Low-priority message queue behavior verified!");
-    },
-    TIMEOUT.MULTI
-  );
-});