macro-agent 0.1.1 → 0.1.3

package/src/acp/__tests__/websocket-stream.test.ts

@@ -1,281 +0,0 @@
-/**
- * Tests for WebSocket Stream Adapter
- */
-
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { EventEmitter } from "events";
-import {
-  webSocketStream,
-  isWebSocketOpen,
-  isWebSocketConnecting,
-} from "../websocket-stream.js";
-import type { WebSocket } from "ws";
-
-// Mock WebSocket class
-class MockWebSocket extends EventEmitter {
-  readyState: number;
-  CONNECTING = 0;
-  OPEN = 1;
-  CLOSING = 2;
-  CLOSED = 3;
-
-  constructor(initialState: number = 1) {
-    super();
-    this.readyState = initialState;
-  }
-
-  send(data: string, callback?: (err?: Error) => void): void {
-    if (this.readyState !== this.OPEN) {
-      callback?.(new Error("WebSocket is not open"));
-      return;
-    }
-    // Simulate async send
-    setImmediate(() => callback?.());
-  }
-
-  close(code?: number, reason?: string): void {
-    this.readyState = this.CLOSED;
-    this.emit("close", code, reason);
-  }
-}
-
-describe("webSocketStream", () => {
-  let mockWs: MockWebSocket;
-
-  beforeEach(() => {
-    mockWs = new MockWebSocket();
-  });
-
-  afterEach(() => {
-    mockWs.removeAllListeners();
-  });
-
-  describe("readable stream", () => {
-    it("should enqueue parsed JSON messages", async () => {
-      const stream = webSocketStream(mockWs as unknown as WebSocket);
-      const reader = stream.readable.getReader();
-
-      // Simulate incoming message
-      const testMessage = { jsonrpc: "2.0" as const, method: "test", id: 1 };
-      mockWs.emit("message", Buffer.from(JSON.stringify(testMessage)));
-
-      const { value, done } = await reader.read();
-      expect(done).toBe(false);
-      expect(value).toEqual(testMessage);
-
-      reader.releaseLock();
-    });
-
-    it("should handle multiple messages", async () => {
-      const stream = webSocketStream(mockWs as unknown as WebSocket);
-      const reader = stream.readable.getReader();
-
-      const messages = [
-        { jsonrpc: "2.0" as const, method: "test1", id: 1 },
-        { jsonrpc: "2.0" as const, method: "test2", id: 2 },
-        { jsonrpc: "2.0" as const, method: "test3", id: 3 },
-      ];
-
-      for (const msg of messages) {
-        mockWs.emit("message", Buffer.from(JSON.stringify(msg)));
-      }
-
-      for (const expected of messages) {
-        const { value } = await reader.read();
-        expect(value).toEqual(expected);
-      }
-
-      reader.releaseLock();
-    });
-
-    it("should close stream when WebSocket closes", async () => {
-      const stream = webSocketStream(mockWs as unknown as WebSocket);
-      const reader = stream.readable.getReader();
-
-      // Close the WebSocket
-      mockWs.emit("close");
-
-      const { done } = await reader.read();
-      expect(done).toBe(true);
-
-      reader.releaseLock();
-    });
-
-    it("should error stream when WebSocket errors", async () => {
-      const stream = webSocketStream(mockWs as unknown as WebSocket);
-      const reader = stream.readable.getReader();
-
-      const testError = new Error("Connection failed");
-      mockWs.emit("error", testError);
-
-      await expect(reader.read()).rejects.toThrow("Connection failed");
-
-      reader.releaseLock();
-    });
-
-    it("should handle malformed JSON gracefully", async () => {
-      const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-      const stream = webSocketStream(mockWs as unknown as WebSocket);
-      const reader = stream.readable.getReader();
-
-      // Send malformed JSON
-      mockWs.emit("message", Buffer.from("not valid json{"));
-
-      // Send valid message after
-      const validMessage = { jsonrpc: "2.0" as const, method: "test", id: 1 };
-      mockWs.emit("message", Buffer.from(JSON.stringify(validMessage)));
-
-      // Should still receive the valid message
-      const { value } = await reader.read();
-      expect(value).toEqual(validMessage);
-
-      expect(consoleSpy).toHaveBeenCalled();
-      consoleSpy.mockRestore();
-      reader.releaseLock();
-    });
-
-    it("should handle ArrayBuffer messages", async () => {
-      const stream = webSocketStream(mockWs as unknown as WebSocket);
-      const reader = stream.readable.getReader();
-
-      const testMessage = { jsonrpc: "2.0" as const, method: "test", id: 1 };
-      const arrayBuffer = new TextEncoder().encode(
-        JSON.stringify(testMessage)
-      ).buffer;
-      mockWs.emit("message", arrayBuffer);
-
-      const { value } = await reader.read();
-      expect(value).toEqual(testMessage);
-
-      reader.releaseLock();
-    });
-  });
-
-  describe("writable stream", () => {
-    it("should send JSON stringified messages", async () => {
-      const sendSpy = vi.spyOn(mockWs, "send");
-      const stream = webSocketStream(mockWs as unknown as WebSocket);
-      const writer = stream.writable.getWriter();
-
-      const testMessage = { jsonrpc: "2.0" as const, method: "test", id: 1 };
-      await writer.write(testMessage);
-
-      expect(sendSpy).toHaveBeenCalledWith(
-        JSON.stringify(testMessage),
-        expect.any(Function)
-      );
-
-      writer.releaseLock();
-    });
-
-    it("should handle multiple writes", async () => {
-      const sendSpy = vi.spyOn(mockWs, "send");
-      const stream = webSocketStream(mockWs as unknown as WebSocket);
-      const writer = stream.writable.getWriter();
-
-      const messages = [
-        { jsonrpc: "2.0" as const, result: "ok", id: 1 },
-        { jsonrpc: "2.0" as const, result: "ok", id: 2 },
-      ];
-
-      for (const msg of messages) {
-        await writer.write(msg);
-      }
-
-      expect(sendSpy).toHaveBeenCalledTimes(2);
-      writer.releaseLock();
-    });
-
-    it("should silently drop messages when WebSocket is not open", async () => {
-      mockWs.readyState = mockWs.CLOSED;
-      const sendSpy = vi.spyOn(mockWs, "send");
-      const stream = webSocketStream(mockWs as unknown as WebSocket);
-      const writer = stream.writable.getWriter();
-
-      const testMessage = { jsonrpc: "2.0" as const, method: "test", id: 1 };
-      // Should not throw
-      await writer.write(testMessage);
-
-      expect(sendSpy).not.toHaveBeenCalled();
-      writer.releaseLock();
-    });
-
-    it("should close WebSocket when stream is closed", async () => {
-      const closeSpy = vi.spyOn(mockWs, "close");
-      const stream = webSocketStream(mockWs as unknown as WebSocket);
-      const writer = stream.writable.getWriter();
-
-      await writer.close();
-
-      expect(closeSpy).toHaveBeenCalledWith(1000, "Stream closed");
-      writer.releaseLock();
-    });
-
-    it("should abort WebSocket with error code", async () => {
-      const closeSpy = vi.spyOn(mockWs, "close");
-      const stream = webSocketStream(mockWs as unknown as WebSocket);
-      const writer = stream.writable.getWriter();
-
-      await writer.abort("Test abort reason");
-
-      expect(closeSpy).toHaveBeenCalledWith(1011, "Test abort reason");
-      writer.releaseLock();
-    });
-  });
-
-  describe("bidirectional communication", () => {
-    it("should support simultaneous read and write", async () => {
-      const stream = webSocketStream(mockWs as unknown as WebSocket);
-      const reader = stream.readable.getReader();
-      const writer = stream.writable.getWriter();
-
-      // Write a message
-      const outgoingMessage = {
-        jsonrpc: "2.0" as const,
-        method: "request",
-        id: 1,
-      };
-      await writer.write(outgoingMessage);
-
-      // Receive a message
-      const incomingMessage = {
-        jsonrpc: "2.0" as const,
-        result: "ok",
-        id: 1,
-      };
-      mockWs.emit("message", Buffer.from(JSON.stringify(incomingMessage)));
-
-      const { value } = await reader.read();
-      expect(value).toEqual(incomingMessage);
-
-      reader.releaseLock();
-      writer.releaseLock();
-    });
-  });
-});
-
-describe("utility functions", () => {
-  describe("isWebSocketOpen", () => {
-    it("should return true when WebSocket is open", () => {
-      const mockWs = new MockWebSocket(1); // OPEN
-      expect(isWebSocketOpen(mockWs as unknown as WebSocket)).toBe(true);
-    });
-
-    it("should return false when WebSocket is closed", () => {
-      const mockWs = new MockWebSocket(3); // CLOSED
-      expect(isWebSocketOpen(mockWs as unknown as WebSocket)).toBe(false);
-    });
-  });
-
-  describe("isWebSocketConnecting", () => {
-    it("should return true when WebSocket is connecting", () => {
-      const mockWs = new MockWebSocket(0); // CONNECTING
-      expect(isWebSocketConnecting(mockWs as unknown as WebSocket)).toBe(true);
-    });
-
-    it("should return false when WebSocket is open", () => {
-      const mockWs = new MockWebSocket(1); // OPEN
-      expect(isWebSocketConnecting(mockWs as unknown as WebSocket)).toBe(false);
-    });
-  });
-});

package/src/acp/__tests__/websocket.e2e.test.ts

@@ -1,390 +0,0 @@
-/**
- * WebSocket ACP End-to-End Tests
- *
- * Tests the complete flow of multiple WebSocket clients connecting to
- * the ACP server and interacting with the shared agent hierarchy.
- *
- * These tests use real services (EventStore, AgentManager, TaskManager)
- * but with mocked Claude Code processes to avoid needing API keys.
- *
- * For full E2E with real Claude Code:
- *   ANTHROPIC_API_KEY=xxx npm test -- src/acp/__tests__/websocket-e2e.test.ts
- */
-
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-import { WebSocket } from "ws";
-import { createEventStore, type EventStore } from "../../store/event-store.js";
-import {
-  createAgentManager,
-  type AgentManager,
-} from "../../agent/agent-manager.js";
-import { createTaskManager, type TaskManager } from "../../task/task-manager.js";
-import {
-  createMessageRouter,
-  type MessageRouter,
-} from "../../router/message-router.js";
-import {
-  createWebSocketACPServer,
-  type WebSocketACPServer,
-} from "../websocket-server.js";
-
-// ─────────────────────────────────────────────────────────────────
-// Test ACP Client using proper JSON-RPC format
-// ─────────────────────────────────────────────────────────────────
-
-interface JsonRpcResponse {
-  jsonrpc: "2.0";
-  id: number;
-  result?: unknown;
-  error?: { code: number; message: string; data?: unknown };
-}
-
-class TestACPClient {
-  private ws: WebSocket;
-  private waiters: Map<number, (response: JsonRpcResponse) => void> = new Map();
-  private nextId = 1;
-  private connected = false;
-  private closeResolve?: () => void;
-  private closePromise: Promise<void>;
-
-  constructor(url: string) {
-    this.ws = new WebSocket(url);
-    this.closePromise = new Promise((resolve) => {
-      this.closeResolve = resolve;
-    });
-  }
-
-  async connect(): Promise<void> {
-    return new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => {
-        reject(new Error("Connection timeout"));
-      }, 5000);
-
-      this.ws.on("open", () => {
-        clearTimeout(timeout);
-        this.connected = true;
-        resolve();
-      });
-
-      this.ws.on("error", (err) => {
-        clearTimeout(timeout);
-        reject(err);
-      });
-
-      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
-        }
-      });
-
-      this.ws.on("close", () => {
-        this.connected = false;
-        this.closeResolve?.();
-      });
-    });
-  }
-
-  async request(method: string, params?: unknown): Promise<JsonRpcResponse> {
-    const id = this.nextId++;
-    return new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => {
-        this.waiters.delete(id);
-        reject(new Error(`Timeout waiting for ${method}`));
-      }, 10000);
-
-      this.waiters.set(id, (response) => {
-        clearTimeout(timeout);
-        resolve(response);
-      });
-
-      this.ws.send(JSON.stringify({ jsonrpc: "2.0", method, params, id }));
-    });
-  }
-
-  async initialize(): Promise<JsonRpcResponse> {
-    return this.request("initialize", { protocolVersion: 1 });
-  }
-
-  close(): void {
-    if (this.ws.readyState === WebSocket.OPEN) {
-      this.ws.close();
-    }
-  }
-
-  async waitForClose(): Promise<void> {
-    return this.closePromise;
-  }
-
-  get isConnected(): boolean {
-    return this.connected && this.ws.readyState === WebSocket.OPEN;
-  }
-}
-
-// ─────────────────────────────────────────────────────────────────
-// E2E Tests with Real Services
-// ─────────────────────────────────────────────────────────────────
-
-describe("WebSocket ACP E2E with Real Services", () => {
-  let eventStore: EventStore;
-  let agentManager: AgentManager;
-  let taskManager: TaskManager;
-  let messageRouter: MessageRouter;
-  let server: WebSocketACPServer;
-  let testPort: number;
-  const clients: TestACPClient[] = [];
-
-  beforeEach(async () => {
-    // Create real services (in-memory)
-    eventStore = await createEventStore({ inMemory: true });
-    messageRouter = createMessageRouter(eventStore);
-    taskManager = createTaskManager(eventStore);
-    agentManager = createAgentManager(eventStore, messageRouter, {
-      defaultPermissionMode: "auto-approve",
-      defaultCwd: process.cwd(),
-    });
-
-    // Start WebSocket server with real services
-    testPort = 10000 + Math.floor(Math.random() * 50000);
-    server = createWebSocketACPServer(
-      { eventStore, agentManager, taskManager },
-      { port: testPort, host: "localhost", path: "/acp" }
-    );
-    await server.start();
-  });
-
-  afterEach(async () => {
-    // Close all clients
-    for (const client of clients) {
-      client.close();
-    }
-    clients.length = 0;
-
-    // Stop server and services
-    await server.stop();
-    await agentManager.close();
-    await eventStore.close();
-  });
-
-  describe("Multi-Client Connection with Real Services", () => {
-    it("should allow multiple clients to connect to server with real services", async () => {
-      const clientA = new TestACPClient(`ws://localhost:${testPort}/acp`);
-      const clientB = new TestACPClient(`ws://localhost:${testPort}/acp`);
-      clients.push(clientA, clientB);
-
-      await Promise.all([clientA.connect(), clientB.connect()]);
-
-      expect(clientA.isConnected).toBe(true);
-      expect(clientB.isConnected).toBe(true);
-      expect(server.getConnectionCount()).toBe(2);
-    });
-
-    it("should initialize multiple clients with real ACP protocol", async () => {
-      const clientA = new TestACPClient(`ws://localhost:${testPort}/acp`);
-      const clientB = new TestACPClient(`ws://localhost:${testPort}/acp`);
-      clients.push(clientA, clientB);
-
-      await Promise.all([clientA.connect(), clientB.connect()]);
-
-      const [initA, initB] = await Promise.all([
-        clientA.initialize(),
-        clientB.initialize(),
-      ]);
-
-      // Both should successfully initialize
-      expect(initA.result).toBeDefined();
-      expect(initB.result).toBeDefined();
-      expect((initA.result as any).protocolVersion).toBe(1);
-      expect((initB.result as any).protocolVersion).toBe(1);
-
-      // Should report extension methods available
-      const extensions = (initA.result as any).extensions || [];
-      expect(Array.isArray(extensions)).toBe(true);
-    });
-
-    it("should handle connection lifecycle correctly", async () => {
-      expect(server.getConnectionCount()).toBe(0);
-
-      // Connect first client
-      const clientA = new TestACPClient(`ws://localhost:${testPort}/acp`);
-      clients.push(clientA);
-      await clientA.connect();
-      await clientA.initialize();
-      expect(server.getConnectionCount()).toBe(1);
-
-      // Connect second client
-      const clientB = new TestACPClient(`ws://localhost:${testPort}/acp`);
-      clients.push(clientB);
-      await clientB.connect();
-      await clientB.initialize();
-      expect(server.getConnectionCount()).toBe(2);
-
-      // Disconnect first client
-      clientA.close();
-      await new Promise((r) => setTimeout(r, 100));
-      expect(server.getConnectionCount()).toBe(1);
-
-      // Second client should still be able to send requests
-      expect(clientB.isConnected).toBe(true);
-    });
-
-    it("should persist events across all client connections", async () => {
-      const clientA = new TestACPClient(`ws://localhost:${testPort}/acp`);
-      const clientB = new TestACPClient(`ws://localhost:${testPort}/acp`);
-      clients.push(clientA, clientB);
-
-      await Promise.all([clientA.connect(), clientB.connect()]);
-      await Promise.all([clientA.initialize(), clientB.initialize()]);
-
-      // Both clients use the same eventStore
-      // Any events appended by one client's session would be visible
-      // to the event store query from another client's session
-
-      // Verify the shared event store is functional
-      const events = eventStore.query({ type: "AGENT_LIFECYCLE" });
-      expect(Array.isArray(events)).toBe(true);
-    });
-
-    it("should handle graceful server shutdown with multiple clients", async () => {
-      const clientA = new TestACPClient(`ws://localhost:${testPort}/acp`);
-      const clientB = new TestACPClient(`ws://localhost:${testPort}/acp`);
-      const clientC = new TestACPClient(`ws://localhost:${testPort}/acp`);
-      clients.push(clientA, clientB, clientC);
-
-      await Promise.all([
-        clientA.connect(),
-        clientB.connect(),
-        clientC.connect(),
-      ]);
-
-      await Promise.all([
-        clientA.initialize(),
-        clientB.initialize(),
-        clientC.initialize(),
-      ]);
-
-      expect(server.getConnectionCount()).toBe(3);
-
-      // Collect close promises
-      const closePromises = [
-        clientA.waitForClose(),
-        clientB.waitForClose(),
-        clientC.waitForClose(),
-      ];
-
-      // Stop server - should close all connections
-      await server.stop();
-
-      // Wait for all clients to receive close
-      await Promise.all(closePromises);
-
-      expect(clientA.isConnected).toBe(false);
-      expect(clientB.isConnected).toBe(false);
-      expect(clientC.isConnected).toBe(false);
-
-      // Restart for afterEach cleanup
-      server = createWebSocketACPServer(
-        { eventStore, agentManager, taskManager },
-        { port: testPort, host: "localhost", path: "/acp" }
-      );
-      await server.start();
-    });
-  });
-
-  describe("Health Check with Real Services", () => {
-    it("should report accurate health status", async () => {
-      // Check initial health
-      let response = await fetch(`http://localhost:${testPort}/health`);
-      let data = await response.json();
-      expect(data.status).toBe("ok");
-      expect(data.connections).toBe(0);
-
-      // Connect clients
-      const clientA = new TestACPClient(`ws://localhost:${testPort}/acp`);
-      const clientB = new TestACPClient(`ws://localhost:${testPort}/acp`);
-      clients.push(clientA, clientB);
-
-      await Promise.all([clientA.connect(), clientB.connect()]);
-      await Promise.all([clientA.initialize(), clientB.initialize()]);
-
-      // Check health after connections
-      response = await fetch(`http://localhost:${testPort}/health`);
-      data = await response.json();
-      expect(data.status).toBe("ok");
-      expect(data.connections).toBe(2);
-      expect(data.timestamp).toBeDefined();
-    });
-  });
-});
-
-// ─────────────────────────────────────────────────────────────────
-// Full E2E with Real Claude Code (requires API key)
-// ─────────────────────────────────────────────────────────────────
-
-const hasApiKey = !!process.env.ANTHROPIC_API_KEY;
-const e2eFn = hasApiKey ? it : it.skip;
-
-describe("WebSocket ACP Full E2E with Real Claude Code", () => {
-  let eventStore: EventStore;
-  let agentManager: AgentManager;
-  let taskManager: TaskManager;
-  let messageRouter: MessageRouter;
-  let server: WebSocketACPServer;
-  let testPort: number;
-  const clients: TestACPClient[] = [];
-
-  beforeEach(async () => {
-    if (!hasApiKey) return;
-
-    eventStore = await createEventStore({ inMemory: true });
-    messageRouter = createMessageRouter(eventStore);
-    taskManager = createTaskManager(eventStore);
-    agentManager = createAgentManager(eventStore, messageRouter, {
-      defaultPermissionMode: "auto-approve",
-      defaultCwd: process.cwd(),
-    });
-
-    testPort = 10000 + Math.floor(Math.random() * 50000);
-    server = createWebSocketACPServer(
-      { eventStore, agentManager, taskManager },
-      { port: testPort, host: "localhost", path: "/acp" }
-    );
-    await server.start();
-  });
-
-  afterEach(async () => {
-    if (!hasApiKey) return;
-
-    for (const client of clients) {
-      client.close();
-    }
-    clients.length = 0;
-
-    await server?.stop();
-    await agentManager?.close();
-    await eventStore?.close();
-  });
-
-  e2eFn(
-    "should allow clients to interact with real agents (ANTHROPIC_API_KEY required)",
-    async () => {
-      const client = new TestACPClient(`ws://localhost:${testPort}/acp`);
-      clients.push(client);
-
-      await client.connect();
-      const initResult = await client.initialize();
-      expect(initResult.result).toBeDefined();
-
-      // This would test the full newSession -> prompt flow with real Claude Code
-      // But requires ANTHROPIC_API_KEY
-      console.log("Full E2E test with API key would go here");
-    },
-    { timeout: 60000 }
-  );
-});