macro-agent 0.2.5 → 0.2.6

package/src/map/__tests__/mail-bridge.test.ts

@@ -1,321 +0,0 @@
-/**
- * Unit tests for mail-bridge — verifies that hub `mail/turn.received`
- * notifications are forwarded into the local inbox with the correct shape
- * so createAgentInboxPort.onIncoming can classify them.
- */
-
-import { describe, it, expect, beforeEach, vi } from "vitest";
-import { setupMailBridge, type MailBridgeConnection } from "../mail-bridge.js";
-
-// Minimal InboxAdapter mock that captures send() calls.
-function mockInboxAdapter() {
-  return {
-    registerAgent: vi.fn().mockResolvedValue(undefined),
-    send: vi.fn().mockResolvedValue("msg-001"),
-  };
-}
-
-// Minimal MAP connection mock.
-function mockConnection(): MailBridgeConnection & {
-  onNotification: ReturnType<typeof vi.fn>;
-  offNotification: ReturnType<typeof vi.fn>;
-  _fire: (params: unknown) => Promise<void>;
-} {
-  let registeredHandler: ((params: unknown) => void | Promise<void>) | null =
-    null;
-
-  const conn = {
-    onNotification: vi.fn((method: string, handler: (params: unknown) => void | Promise<void>) => {
-      if (method === "mail/turn.received") {
-        registeredHandler = handler;
-      }
-    }),
-    offNotification: vi.fn(),
-    _fire: async (params: unknown) => {
-      if (registeredHandler) await registeredHandler(params);
-    },
-  };
-  return conn;
-}
-
-describe("setupMailBridge", () => {
-  let conn: ReturnType<typeof mockConnection>;
-  let inbox: ReturnType<typeof mockInboxAdapter>;
-
-  beforeEach(() => {
-    conn = mockConnection();
-    inbox = mockInboxAdapter();
-  });
-
-  it("registers notification handler on 'mail/turn.received'", async () => {
-    await setupMailBridge({ connection: conn, inboxAdapter: inbox as any });
-    expect(conn.onNotification).toHaveBeenCalledWith(
-      "mail/turn.received",
-      expect.any(Function),
-    );
-  });
-
-  it("returns cleanup that calls offNotification", async () => {
-    const cleanup = await setupMailBridge({
-      connection: conn,
-      inboxAdapter: inbox as any,
-    });
-    cleanup();
-    expect(conn.offNotification).toHaveBeenCalledWith(
-      "mail/turn.received",
-      expect.any(Function),
-    );
-  });
-
-  it("delivers plain-text turns into the inbox as a text message", async () => {
-    const logs: string[] = [];
-    await setupMailBridge({
-      connection: conn,
-      inboxAdapter: inbox as any,
-      dispatcherAgentId: "dispatcher:host:1234:abc",
-      log: (m) => logs.push(m),
-    });
-
-    await conn._fire({
-      conversation_id: "conv-1",
-      turn_id: "turn-1",
-      participant_id: "some-agent",
-      content_type: "text/plain",
-      content: "hello world",
-      thread_id: "thread-xyz",
-      importance: "high",
-    });
-
-    expect(inbox.send).toHaveBeenCalledOnce();
-    const [from, to, content, opts] = inbox.send.mock.calls[0];
-    expect(from).toBe("some-agent");
-    expect(to).toBe("dispatcher:host:1234:abc");
-    // Delivered as a text message that normalizeContent passes through,
-    // carrying the conversation id for reply threading.
-    expect(content).toMatchObject({
-      type: "text",
-      text: "hello world",
-      _conversationId: "conv-1",
-    });
-    // Not shaped as a work envelope — the classifier must not match it.
-    expect(content).not.toHaveProperty("schema");
-    expect(opts?.threadTag).toBe("thread-xyz");
-    expect(opts?.importance).toBe("high");
-    expect(logs.some((l) => l.includes("Forwarded text turn"))).toBe(true);
-  });
-
-  it("skips empty / whitespace-only text turns", async () => {
-    const logs: string[] = [];
-    await setupMailBridge({
-      connection: conn,
-      inboxAdapter: inbox as any,
-      log: (m) => logs.push(m),
-    });
-
-    await conn._fire({
-      conversation_id: "conv-empty",
-      turn_id: "turn-empty",
-      participant_id: "some-agent",
-      content_type: "text/plain",
-      content: "   ",
-    });
-
-    expect(inbox.send).not.toHaveBeenCalled();
-    expect(logs.some((l) => l.includes("Skipping empty"))).toBe(true);
-  });
-
-  describe("with dispatcherAgentId", () => {
-    const DISPATCHER_ID = "dispatcher:host:1234:abc";
-
-    it("registers the dispatcher as inbox recipient", async () => {
-      await setupMailBridge({
-        connection: conn,
-        inboxAdapter: inbox as any,
-        dispatcherAgentId: DISPATCHER_ID,
-      });
-      expect(inbox.registerAgent).toHaveBeenCalledWith(
-        DISPATCHER_ID,
-        expect.objectContaining({ role: "dispatcher" }),
-      );
-    });
-
-    it("translates hub envelope { type, body } → { schema, data } and delivers to dispatcher", async () => {
-      await setupMailBridge({
-        connection: conn,
-        inboxAdapter: inbox as any,
-        dispatcherAgentId: DISPATCHER_ID,
-      });
-
-      const hubEnvelope = {
-        type: "x-dispatch/work",
-        body: { prompt: "do the thing", taskId: "task-123", role: "worker" },
-      };
-
-      await conn._fire({
-        conversation_id: "conv-1",
-        turn_id: "turn-1",
-        participant_id: "openhive:dispatcher",
-        content_type: "application/json",
-        content: JSON.stringify(hubEnvelope),
-        thread_id: "thread-abc",
-      });
-
-      expect(inbox.send).toHaveBeenCalledOnce();
-      const [from, to, content, opts] = inbox.send.mock.calls[0];
-
-      // Must deliver FROM the hub participant, TO the dispatcher
-      expect(from).toBe("openhive:dispatcher");
-      expect(to).toBe(DISPATCHER_ID);
-
-      // Content must carry top-level `schema` and `data`, plus `type: "data"`
-      // so agent-inbox's `normalizeContent` passes it through unchanged
-      // (without a `type`, the inbox wraps the payload as { type: "data",
-      // data: <original> }, burying `schema` and breaking downstream
-      // classifiers like swarm-dispatch's createAgentInboxPort).
-      expect(content).toMatchObject({
-        type: "data",
-        schema: "x-dispatch/work",
-        data: { prompt: "do the thing", taskId: "task-123", role: "worker" },
-      });
-      expect(content).not.toHaveProperty("body");
-
-      // Thread tag preserved
-      expect(opts?.threadTag).toBe("thread-abc");
-    });
-
-    it("passes through already-canonical { schema, data } payloads unchanged", async () => {
-      await setupMailBridge({
-        connection: conn,
-        inboxAdapter: inbox as any,
-        dispatcherAgentId: DISPATCHER_ID,
-      });
-
-      // Payload already in canonical shape (no 'body' key)
-      const canonical = {
-        schema: "x-dispatch/work",
-        data: { taskId: "t-99", prompt: "go", role: "worker" },
-      };
-
-      await conn._fire({
-        conversation_id: "conv-2",
-        turn_id: "turn-2",
-        participant_id: "openhive:dispatcher",
-        content_type: "application/json",
-        content: JSON.stringify(canonical),
-      });
-
-      expect(inbox.send).toHaveBeenCalledOnce();
-      const [, , content] = inbox.send.mock.calls[0];
-      expect(content).toMatchObject(canonical);
-    });
-  });
-
-  describe("importance derivation", () => {
-    const DISPATCHER_ID = "dispatcher:host:1234:abc";
-
-    it("passes through importance from hub notification params", async () => {
-      await setupMailBridge({
-        connection: conn,
-        inboxAdapter: inbox as any,
-        dispatcherAgentId: DISPATCHER_ID,
-      });
-
-      await conn._fire({
-        conversation_id: "conv-imp-1",
-        turn_id: "turn-imp-1",
-        participant_id: "user:admin",
-        content_type: "application/json",
-        content: JSON.stringify({ schema: "x-dispatch/work", data: { taskId: "t-1" } }),
-        importance: "high",
-      });
-
-      expect(inbox.send).toHaveBeenCalledOnce();
-      const [, , , opts] = inbox.send.mock.calls[0];
-      expect(opts?.importance).toBe("high");
-    });
-
-    it("passes through 'urgent' importance for orchestrator recall", async () => {
-      await setupMailBridge({
-        connection: conn,
-        inboxAdapter: inbox as any,
-        dispatcherAgentId: DISPATCHER_ID,
-      });
-
-      await conn._fire({
-        conversation_id: "conv-imp-2",
-        turn_id: "turn-imp-2",
-        participant_id: "system:dispatch-orchestrator",
-        content_type: "application/json",
-        content: JSON.stringify({ schema: "x-dispatch/work", data: { taskId: "t-2" } }),
-        importance: "urgent",
-      });
-
-      expect(inbox.send).toHaveBeenCalledOnce();
-      const [, , , opts] = inbox.send.mock.calls[0];
-      expect(opts?.importance).toBe("urgent");
-    });
-
-    it("defaults to 'normal' when importance is missing", async () => {
-      await setupMailBridge({
-        connection: conn,
-        inboxAdapter: inbox as any,
-        dispatcherAgentId: DISPATCHER_ID,
-      });
-
-      await conn._fire({
-        conversation_id: "conv-imp-3",
-        turn_id: "turn-imp-3",
-        participant_id: "user:admin",
-        content_type: "application/json",
-        content: JSON.stringify({ schema: "x-dispatch/work", data: { taskId: "t-3" } }),
-        // no importance field
-      });
-
-      expect(inbox.send).toHaveBeenCalledOnce();
-      const [, , , opts] = inbox.send.mock.calls[0];
-      expect(opts?.importance).toBe("normal");
-    });
-
-    it("ignores invalid importance values and falls back to 'normal'", async () => {
-      await setupMailBridge({
-        connection: conn,
-        inboxAdapter: inbox as any,
-        dispatcherAgentId: DISPATCHER_ID,
-      });
-
-      await conn._fire({
-        conversation_id: "conv-imp-4",
-        turn_id: "turn-imp-4",
-        participant_id: "user:admin",
-        content_type: "application/json",
-        content: JSON.stringify({ schema: "x-dispatch/work", data: { taskId: "t-4" } }),
-        importance: "critical", // invalid value
-      });
-
-      expect(inbox.send).toHaveBeenCalledOnce();
-      const [, , , opts] = inbox.send.mock.calls[0];
-      expect(opts?.importance).toBe("normal");
-    });
-  });
-
-  describe("without dispatcherAgentId (fallback mode)", () => {
-    it("delivers to BRIDGE_RECIPIENT_ID", async () => {
-      await setupMailBridge({
-        connection: conn,
-        inboxAdapter: inbox as any,
-      });
-
-      await conn._fire({
-        conversation_id: "conv-3",
-        turn_id: "turn-3",
-        participant_id: "openhive:dispatcher",
-        content_type: "application/json",
-        content: JSON.stringify({ schema: "x-dispatch/work", data: { taskId: "t-1" } }),
-      });
-
-      expect(inbox.send).toHaveBeenCalledOnce();
-      const [, to] = inbox.send.mock.calls[0];
-      expect(to).toBe("openhive-mail-bridge");
-    });
-  });
-});

package/src/map/__tests__/permission-forwarding.test.ts

@@ -1,143 +0,0 @@
-/**
- * Permission Forwarding Test
- *
- * Verifies that PermissionRequestUpdate from the agent's prompt stream
- * is correctly forwarded to the MAP client via the ACP-over-MAP bridge.
- *
- * Uses a mock agent that yields a PermissionRequestUpdate during prompt,
- * and verifies the client receives it and can respond.
- */
-
-import { describe, it, expect, vi } from "vitest";
-import {
-  createACPBridge,
-  type ACPBridge,
-} from "../acp-bridge.js";
-import type { MacroAgentSystemV2 } from "../../boot-v2.js";
-
-/**
- * Simulate the ACP-over-MAP permission flow.
- *
- * The flow:
- * 1. Client sends ACP prompt request (with permission_request callback)
- * 2. Agent processes prompt, needs permission for a tool
- * 3. acp-factory yields PermissionRequestUpdate to the prompt stream
- * 4. createMacroAgent() handler catches it, calls connection.requestPermission()
- * 5. AgentSideConnection writes the request to the stream's writable side
- * 6. ACP bridge's sendToClient routes it back to the client via MAP event
- * 7. Client's ACPStreamConnection calls requestPermission callback
- * 8. Client responds with allow/deny
- * 9. Response flows back through the bridge → agent
- *
- * This test verifies steps 5-6: that outbound messages from the writable
- * side (including permission requests) are correctly routed to sendToClient.
- */
-describe("Permission Forwarding via ACP Bridge", () => {
-  it("routes agent-to-client requests through sendToClient", () => {
-    const sentMessages: any[] = [];
-
-    const mockMapServer = {
-      eventBus: {
-        emit: vi.fn(),
-      },
-    };
-
-    const mockSystem = {} as MacroAgentSystemV2;
-
-    const bridge = createACPBridge(
-      mockSystem,
-      mockMapServer,
-      undefined, // no resolveMapId
-      (clientId, rawEvent) => {
-        sentMessages.push({ clientId, rawEvent });
-      },
-    );
-
-    // Simulate a message delivery that creates a stream
-    const handled = bridge.handleDelivery("agent-1", {
-      from: { agent: "client-1" },
-      to: { agent: "agent-1" },
-      payload: {
-        acp: {
-          jsonrpc: "2.0",
-          id: "req-1",
-          method: "initialize",
-          params: {
-            protocolVersion: 1,
-            clientInfo: { name: "test", version: "1.0" },
-          },
-        },
-        acpContext: {
-          streamId: "stream-1",
-          sessionId: null,
-          direction: "client-to-agent",
-        },
-      },
-    });
-
-    expect(handled).toBe(true);
-
-    // The bridge created a stream and AgentSideConnection.
-    // The AgentSideConnection processes the initialize request and writes
-    // a response to the writable side. This triggers sendToClient.
-
-    // Wait a tick for the async processing
-    return new Promise<void>((resolve) => {
-      setTimeout(() => {
-        // The initialize response should have been sent to the client
-        // (or an error if the mock system doesn't have agentManager)
-        // Either way, the bridge's sendToClient was called for the outbound message.
-        console.log(
-          `[perm-test] Messages sent to client: ${sentMessages.length}`,
-        );
-        for (const msg of sentMessages) {
-          console.log(
-            `[perm-test]   To: ${msg.clientId}, Event type: ${msg.rawEvent?.params?.event?.type ?? "direct"}`,
-          );
-        }
-
-        // The key assertion: outbound messages from the writable stream
-        // ARE routed through sendToClient (not swallowed silently).
-        // This proves the permission forwarding path works — when
-        // AgentSideConnection.requestPermission() writes a JSON-RPC
-        // request to the writable side, it goes through sendToClient.
-        //
-        // With a real system, the initialize response would be sent.
-        // With our mock, it may error (no agentManager), but the bridge
-        // still processes the readable side and connects the writable.
-
-        // Verify the bridge was created and is functional
-        expect(handled).toBe(true);
-
-        bridge.close();
-        resolve();
-      }, 500);
-    });
-  });
-
-  it("routes ALL writable output types through sendToClient", () => {
-    // This test verifies the architectural property that EVERY message
-    // written to the in-memory stream's writable side goes through
-    // sendToClient. This includes:
-    // - JSON-RPC responses (id, no method) — e.g., initialize response
-    // - JSON-RPC notifications (method, no id) — e.g., session/update
-    // - JSON-RPC requests (id + method) — e.g., requestPermission
-
-    const sentMessages: any[] = [];
-
-    const mockMapServer = {
-      eventBus: { emit: vi.fn() },
-    };
-
-    // The writable side's write() callback calls sendToClient for every chunk.
-    // We verify this by checking the createInMemoryStream pattern:
-    // writable = new WritableStream({ write(chunk) { onOutbound(chunk); } })
-    // onOutbound = sendToClient
-    //
-    // This means ALL three message types (response, notification, request)
-    // are routed to the client. Permission requests (JSON-RPC requests
-    // from agent to client) follow the same path as responses.
-
-    expect(true).toBe(true); // Architectural property verified by code review
-  });
-});

package/src/map/__tests__/sidecar-diff-install-smoke.test.ts

@@ -1,90 +0,0 @@
-/**
- * Structural smoke test for the sidecar's diff-server install hook.
- *
- * `sidecar.ts` wires three things together under the same
- * `if (gitCascadeAdapter)` branch:
- *
- *   1. createCascadeBridge    — outbound x-cascade/* events
- *   2. setupCascadeActionHandlers — inbound x-cascade/request.*
- *   3. setupCascadeDiffServer — inbound cascade/diff.request   ← (added in S1.11)
- *
- * Plus the capability declaration is conditional on `gitCascadeAdapter`
- * (S1.10) so the hub only gates diff requests on swarms that can serve them.
- *
- * If any of these are dropped or re-conditioned by a refactor, this test
- * fails loudly. A live integration would catch it too, but at much higher
- * setup cost.
- */
-
-import { describe, it, expect } from 'vitest';
-import { readFileSync } from 'fs';
-import { fileURLToPath } from 'url';
-import { dirname, resolve } from 'path';
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const SIDECAR_PATH = resolve(__dirname, '../sidecar.ts');
-const sidecarSource = readFileSync(SIDECAR_PATH, 'utf-8');
-
-describe('sidecar.ts cascade-diff install (structural smoke)', () => {
-  it('imports setupCascadeDiffServer under the cascade-adapter branch', () => {
-    // The import is dynamic (`await import(...)`) inside the
-    // `if (gitCascadeAdapter)` branch, like the action-handler import.
-    expect(sidecarSource).toMatch(
-      /await import\(['"]\.\/cascade-diff-server\.js['"]\)/,
-    );
-  });
-
-  it('only installs setupCascadeDiffServer when gitCascadeAdapter is present', () => {
-    // Find the cascade-adapter conditional block and make sure the diff
-    // server install lives inside it. We assert by checking that
-    // `setupCascadeDiffServer(` appears *after* `if (gitCascadeAdapter)`
-    // and *before* the matching close — proxied by checking it sits
-    // between the action-handler install and the `cascadeBridgeCleanup`
-    // assignment.
-    const guardIdx = sidecarSource.indexOf('if (gitCascadeAdapter)');
-    const actionIdx = sidecarSource.indexOf('setupCascadeActionHandlers(');
-    const diffIdx = sidecarSource.indexOf('setupCascadeDiffServer(');
-    const cleanupIdx = sidecarSource.indexOf('cascadeBridgeCleanup = () =>');
-
-    expect(guardIdx).toBeGreaterThan(-1);
-    expect(actionIdx).toBeGreaterThan(guardIdx);
-    expect(diffIdx).toBeGreaterThan(actionIdx);
-    expect(cleanupIdx).toBeGreaterThan(diffIdx);
-  });
-
-  it('adds the diff cleanup to the cascadeBridgeCleanup chain', () => {
-    // The cleanup returned by setupCascadeDiffServer must be invoked
-    // alongside the bridge.dispose + actionCleanup. Grep for the name
-    // used in S1.11: `diffCleanup`.
-    expect(sidecarSource).toMatch(/const diffCleanup\s*=\s*setupCascadeDiffServer\(/);
-    // And it's called from the composed cleanup function.
-    const cleanupBlock = sidecarSource.match(
-      /cascadeBridgeCleanup\s*=\s*\(\)\s*=>\s*{[\s\S]*?};/,
-    )?.[0];
-    expect(cleanupBlock).toBeDefined();
-    expect(cleanupBlock).toContain('diffCleanup()');
-  });
-
-  it('only declares the cascade capability when adapter is wired (S1.10)', () => {
-    // The capability declaration is a conditional spread keyed on
-    // gitCascadeAdapter. Without an adapter, no `cascade:` block is sent.
-    expect(sidecarSource).toMatch(
-      /\.\.\.\(gitCascadeAdapter\s*\?\s*\{\s*cascade:\s*cascadeCapability\s*\}\s*:\s*\{\}\)/,
-    );
-  });
-
-  it('declares the full cascade capability (canServeDiff + canAct + emitsConflicts)', () => {
-    // macro-agent is a full-control cascade runtime: it serves diffs,
-    // handles inbound x-cascade/request.* actions, and forwards conflict
-    // events. The CascadeCapability constant must reflect all three.
-    const capBlock = sidecarSource.match(
-      /const cascadeCapability:\s*CascadeCapability\s*=\s*{[\s\S]*?};/,
-    )?.[0];
-    expect(capBlock).toBeDefined();
-    expect(capBlock).toContain('canServeDiff: true');
-    expect(capBlock).toContain('canAct: true');
-    expect(capBlock).toContain('emitsConflicts: true');
-    // autoCloseOnMerge is an opt-in close policy with no wiring — not declared.
-    expect(capBlock).not.toContain('autoCloseOnMerge');
-  });
-});