macro-agent 0.2.4 → 0.2.6

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');
-  });
-});

package/src/map/__tests__/sidecar-integration.test.ts

@@ -1,190 +0,0 @@
-/**
- * Integration test for MAP Sidecar
- *
- * Tests the sidecar's connection lifecycle and graceful degradation.
- * Full protocol integration is tested via E2E tests with a real OpenHive instance.
- *
- * @vitest-environment node
- */
-
-import { describe, it, expect, vi } from "vitest";
-import { createMAPSidecar } from "../sidecar.js";
-import type { MAPSidecar, MAPSidecarConfig } from "../types.js";
-import type { AgentManager } from "../../agent/agent-manager.js";
-import type { AgentStore } from "../../agent/agent-store.js";
-import type { InboxAdapter, TasksAdapter } from "../../adapters/types.js";
-
-// =============================================================================
-// Mock Dependencies
-// =============================================================================
-
-function mockDeps() {
-  const lifecycleCallbacks: Array<(event: any) => void> = [];
-
-  const agentManager = {
-    onLifecycleEvent: vi.fn((cb: any) => {
-      lifecycleCallbacks.push(cb);
-      return () => {
-        const idx = lifecycleCallbacks.indexOf(cb);
-        if (idx >= 0) lifecycleCallbacks.splice(idx, 1);
-      };
-    }),
-    list: vi.fn(() => []),
-    get: vi.fn(() => null),
-    spawn: vi.fn().mockResolvedValue({ agent: { id: "spawned-1" } }),
-    close: vi.fn().mockResolvedValue(undefined),
-  } as unknown as AgentManager;
-
-  const agentStore = {
-    getAgent: vi.fn(() => null),
-    listAgents: vi.fn(() => []),
-  } as unknown as AgentStore;
-
-  const inboxAdapter = {
-    onDelivery: vi.fn(),
-    offDelivery: vi.fn(),
-    send: vi.fn().mockResolvedValue("msg-1"),
-  } as unknown as InboxAdapter;
-
-  const tasksAdapter = {
-    createTask: vi.fn().mockResolvedValue("task-1"),
-    transitionTask: vi.fn().mockResolvedValue(undefined),
-    listTasks: vi.fn().mockResolvedValue([]),
-    connected: true,
-  } as unknown as TasksAdapter;
-
-  return {
-    agentManager,
-    agentStore,
-    inboxAdapter,
-    tasksAdapter,
-    lifecycleCallbacks,
-  };
-}
-
-// =============================================================================
-// Tests
-// =============================================================================
-
-describe("MAP Sidecar — graceful degradation", () => {
-  it("starts without error when server is unreachable", async () => {
-    const deps = mockDeps();
-
-    const config: MAPSidecarConfig = {
-      server: "ws://127.0.0.1:1",
-      scope: "swarm:test",
-      reconnection: { enabled: false },
-      reconnectIntervalMs: 999999,
-    };
-
-    const sidecar = createMAPSidecar(deps, config);
-
-    // Should not throw
-    await expect(sidecar.start()).resolves.toBeUndefined();
-    expect(sidecar.connected).toBe(false);
-
-    await sidecar.stop();
-  }, 10000);
-
-  it("reportCheckpoint returns null when disconnected", async () => {
-    const deps = mockDeps();
-
-    const config: MAPSidecarConfig = {
-      server: "ws://127.0.0.1:1",
-      reconnection: { enabled: false },
-      reconnectIntervalMs: 999999,
-    };
-
-    const sidecar = createMAPSidecar(deps, config);
-    await sidecar.start();
-
-    const result = await sidecar.reportCheckpoint({
-      id: "test",
-      session_id: "s1",
-      agent: "test",
-      branch: null,
-      files_touched: [],
-      checkpoints_count: 0,
-    });
-
-    expect(result).toBeNull();
-    await sidecar.stop();
-  });
-
-  it("stop is idempotent", async () => {
-    const deps = mockDeps();
-
-    const config: MAPSidecarConfig = {
-      server: "ws://127.0.0.1:1",
-      reconnection: { enabled: false },
-      reconnectIntervalMs: 999999,
-    };
-
-    const sidecar = createMAPSidecar(deps, config);
-    await sidecar.start();
-
-    await sidecar.stop();
-    await sidecar.stop(); // Should not throw
-    expect(sidecar.connected).toBe(false);
-  });
-});
-
-describe("MAP Sidecar — config handling", () => {
-  it("appends /ws/map to server URL if missing", async () => {
-    const deps = mockDeps();
-
-    // Mock the import to capture the URL
-    const config: MAPSidecarConfig = {
-      server: "ws://127.0.0.1:1",
-      token: "test-token",
-      scope: "swarm:custom",
-      agentName: "custom-sidecar",
-      trajectorySyncLevel: "full",
-      reconnection: { enabled: false },
-      reconnectIntervalMs: 999999,
-    };
-
-    const sidecar = createMAPSidecar(deps, config);
-    await sidecar.start();
-    // Connection will fail but that's expected — we're testing config handling
-    expect(sidecar.connected).toBe(false);
-    await sidecar.stop();
-  });
-
-  it("uses default scope and agent name", async () => {
-    const deps = mockDeps();
-
-    const config: MAPSidecarConfig = {
-      server: "ws://127.0.0.1:1",
-      reconnection: { enabled: false },
-      reconnectIntervalMs: 999999,
-    };
-
-    const sidecar = createMAPSidecar(deps, config);
-    await sidecar.start();
-    // Just verify it doesn't crash with minimal config
-    expect(sidecar.connected).toBe(false);
-    await sidecar.stop();
-  });
-});
-
-describe("MAP Sidecar — module wiring", () => {
-  it("does not wire sub-modules when connection fails", async () => {
-    const deps = mockDeps();
-
-    const config: MAPSidecarConfig = {
-      server: "ws://127.0.0.1:1",
-      reconnection: { enabled: false },
-      reconnectIntervalMs: 999999,
-    };
-
-    const sidecar = createMAPSidecar(deps, config);
-    await sidecar.start();
-
-    // onLifecycleEvent should NOT have been called since connection failed
-    // (sub-modules are only wired after successful connection)
-    expect(deps.agentManager.onLifecycleEvent).not.toHaveBeenCalled();
-
-    await sidecar.stop();
-  });
-});

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

@@ -1,153 +0,0 @@
-/**
- * Tests for Task Bridge — task lifecycle → MAP observability.
- */
-
-import { describe, it, expect, beforeEach, vi } from "vitest";
-import {
-  createTaskBridge,
-  type TaskBridgeConnection,
-} from "../task-bridge.js";
-
-function mockConnection(): TaskBridgeConnection & {
-  send: ReturnType<typeof vi.fn>;
-} {
-  return {
-    send: vi.fn().mockResolvedValue({}),
-    get isConnected() {
-      return true;
-    },
-  };
-}
-
-describe("TaskBridge", () => {
-  let conn: ReturnType<typeof mockConnection>;
-  const scope = "swarm:test";
-
-  beforeEach(() => {
-    conn = mockConnection();
-  });
-
-  it("emits task.created event", async () => {
-    const bridge = createTaskBridge(conn, scope);
-
-    await bridge.taskCreated({
-      id: "task-1",
-      title: "Implement feature",
-      status: "open",
-      assignee: "agent-1",
-    });
-
-    expect(conn.send).toHaveBeenCalledWith(
-      { scope },
-      expect.objectContaining({
-        type: "task.created",
-        task: expect.objectContaining({
-          id: "task-1",
-          title: "Implement feature",
-          status: "open",
-          assignee: "agent-1",
-        }),
-        _origin: "macro-agent",
-      }),
-    );
-  });
-
-  it("emits task.status event", async () => {
-    const bridge = createTaskBridge(conn, scope);
-
-    await bridge.taskStatusChanged("task-1", "open", "in_progress", "agent-1");
-
-    expect(conn.send).toHaveBeenCalledWith(
-      { scope },
-      expect.objectContaining({
-        type: "task.status",
-        taskId: "task-1",
-        previous: "open",
-        current: "in_progress",
-        agentId: "agent-1",
-      }),
-    );
-  });
-
-  it("emits task.completed on terminal status", async () => {
-    const bridge = createTaskBridge(conn, scope);
-
-    await bridge.taskStatusChanged("task-1", "in_progress", "completed", "agent-1");
-
-    // Should emit both task.status and task.completed
-    expect(conn.send).toHaveBeenCalledTimes(2);
-    expect(conn.send).toHaveBeenCalledWith(
-      { scope },
-      expect.objectContaining({ type: "task.status", current: "completed" }),
-    );
-    expect(conn.send).toHaveBeenCalledWith(
-      { scope },
-      expect.objectContaining({ type: "task.completed", taskId: "task-1" }),
-    );
-  });
-
-  it("emits task.completed on closed status", async () => {
-    const bridge = createTaskBridge(conn, scope);
-
-    await bridge.taskStatusChanged("task-1", "in_progress", "closed");
-
-    expect(conn.send).toHaveBeenCalledWith(
-      { scope },
-      expect.objectContaining({ type: "task.completed" }),
-    );
-  });
-
-  it("does not emit task.completed on non-terminal status", async () => {
-    const bridge = createTaskBridge(conn, scope);
-
-    await bridge.taskStatusChanged("task-1", "open", "in_progress");
-
-    expect(conn.send).toHaveBeenCalledTimes(1);
-    expect(conn.send).toHaveBeenCalledWith(
-      { scope },
-      expect.objectContaining({ type: "task.status" }),
-    );
-  });
-
-  it("emits task.assigned event", async () => {
-    const bridge = createTaskBridge(conn, scope);
-
-    await bridge.taskAssigned("task-1", "agent-2");
-
-    expect(conn.send).toHaveBeenCalledWith(
-      { scope },
-      expect.objectContaining({
-        type: "task.assigned",
-        taskId: "task-1",
-        assignee: "agent-2",
-      }),
-    );
-  });
-
-  it("does nothing when disconnected", async () => {
-    const disconnected = {
-      ...conn,
-      get isConnected() {
-        return false;
-      },
-    };
-    const bridge = createTaskBridge(disconnected, scope);
-
-    await bridge.taskCreated({ id: "t", title: "t", status: "open" });
-    await bridge.taskStatusChanged("t", "open", "closed");
-    await bridge.taskAssigned("t", "a");
-
-    expect(conn.send).not.toHaveBeenCalled();
-  });
-
-  it("silently handles send failures", async () => {
-    conn.send.mockRejectedValue(new Error("network error"));
-
-    const bridge = createTaskBridge(conn, scope);
-
-    // Should not throw
-    await expect(
-      bridge.taskCreated({ id: "t", title: "t", status: "open" }),
-    ).resolves.toBeUndefined();
-  });
-});