macro-agent 0.2.4 → 0.2.6

package/src/acp/map-bridge.ts

@@ -1,193 +0,0 @@
-/**
- * MAP Protocol Bridge
- *
- * Exposes MAP-compatible JSON-RPC methods on top of InboxAdapter,
- * allowing external MAP clients to interact with the macro-agent
- * messaging system.
- *
- * Since agent-inbox already speaks MAP natively (via MapClient),
- * this bridge translates MAP send/inbox/thread commands to
- * InboxAdapter calls and returns messages in MAP-compatible format.
- *
- * @module acp/map-bridge
- */
-
-import type { InboxAdapter } from "../adapters/types.js";
-import type { AgentStore } from "../agent/agent-store.js";
-
-// ─────────────────────────────────────────────────────────────────
-// Types
-// ─────────────────────────────────────────────────────────────────
-
-export interface MAPBridgeConfig {
-  /** Default scope for MAP messages. */
-  scope?: string;
-}
-
-export interface MAPBridgeDeps {
-  inboxAdapter: InboxAdapter;
-  agentStore: AgentStore;
-}
-
-/**
- * MAP-compatible message format returned by the bridge.
- */
-export interface MAPMessage {
-  id: string;
-  from: string;
-  to: string | string[];
-  payload: unknown;
-  timestamp: string;
-  meta?: Record<string, unknown>;
-}
-
-/**
- * MAP Bridge instance exposing JSON-RPC-style method handlers.
- */
-export interface MAPBridge {
-  /**
-   * Handle a MAP JSON-RPC request.
-   * Supports methods: mail/send, mail/inbox, mail/thread, mail/agents
-   */
-  handleRequest(method: string, params: Record<string, unknown>): Promise<unknown>;
-
-  /** List supported MAP methods. */
-  listMethods(): string[];
-}
-
-// ─────────────────────────────────────────────────────────────────
-// Factory
-// ─────────────────────────────────────────────────────────────────
-
-/**
- * Create a MAP protocol bridge that translates MAP JSON-RPC methods
- * to InboxAdapter calls.
- *
- * Supported methods:
- * - `mail/send` — Send a message via InboxAdapter
- * - `mail/inbox` — Check an agent's inbox
- * - `mail/thread` — Read a message thread
- * - `mail/agents` — List registered agents
- *
- * TODO: Full MAP SDK integration when @multi-agent-protocol/sdk
- * is available as a peer dependency. Currently this is a lightweight
- * compatibility layer for basic MAP interop.
- */
-export function createMAPBridge(
-  deps: MAPBridgeDeps,
-  config: MAPBridgeConfig = {}
-): MAPBridge {
-  const { inboxAdapter, agentStore } = deps;
-  const scope = config.scope ?? "default";
-
-  const methods: Record<string, (params: Record<string, unknown>) => Promise<unknown>> = {
-    "mail/send": async (params) => {
-      const from = params.from as string;
-      const to = params.to as string | string[];
-      const payload = params.payload;
-      const meta = params.meta as Record<string, unknown> | undefined;
-
-      if (!from || !to) {
-        throw new Error("mail/send requires 'from' and 'to' parameters");
-      }
-
-      const content = typeof payload === "string"
-        ? { type: "text" as const, text: payload }
-        : payload as { type: string; text: string };
-
-      const messageId = await inboxAdapter.send(from, to, content, {
-        scope: (meta?.scope as string) ?? scope,
-        importance: meta?.priority === "high" ? "high" : "normal",
-        subject: meta?.subject as string | undefined,
-        threadTag: meta?.threadTag as string | undefined,
-        inReplyTo: meta?.inReplyTo as string | undefined,
-      });
-
-      return { messageId, success: true };
-    },
-
-    "mail/inbox": async (params) => {
-      const agentId = params.agentId as string;
-      if (!agentId) {
-        throw new Error("mail/inbox requires 'agentId' parameter");
-      }
-
-      const limit = params.limit as number | undefined;
-      const unreadOnly = params.unreadOnly as boolean | undefined;
-
-      const messages = await inboxAdapter.checkInbox(agentId, {
-        limit,
-        unreadOnly,
-      });
-
-      return {
-        messages: messages.map((msg) => toMAPMessage(msg)),
-        count: messages.length,
-      };
-    },
-
-    "mail/thread": async (params) => {
-      const threadTag = params.threadTag as string;
-      if (!threadTag) {
-        throw new Error("mail/thread requires 'threadTag' parameter");
-      }
-
-      const threadScope = (params.scope as string) ?? scope;
-      const messages = await inboxAdapter.readThread(threadTag, threadScope);
-
-      return {
-        messages: messages.map((msg) => toMAPMessage(msg)),
-        count: messages.length,
-      };
-    },
-
-    "mail/agents": async (_params) => {
-      const agents = agentStore.listAgents({ state: "running" });
-      return {
-        agents: agents.map((a) => ({
-          agentId: a.id,
-          name: a.name,
-          role: a.role,
-          scope: a.scope,
-          state: a.state,
-        })),
-        count: agents.length,
-      };
-    },
-  };
-
-  function toMAPMessage(msg: {
-    id?: string;
-    sender_id?: string;
-    recipients?: Array<{ agent_id: string }>;
-    content?: unknown;
-    created_at?: string | number;
-    metadata?: Record<string, unknown>;
-  }): MAPMessage {
-    const recipients = msg.recipients?.map((r) => r.agent_id) ?? [];
-    return {
-      id: msg.id ?? "",
-      from: msg.sender_id ?? "",
-      to: recipients.length === 1 ? recipients[0] : recipients,
-      payload: msg.content,
-      timestamp: typeof msg.created_at === "number"
-        ? new Date(msg.created_at).toISOString()
-        : (msg.created_at as string) ?? new Date().toISOString(),
-      meta: msg.metadata,
-    };
-  }
-
-  return {
-    async handleRequest(method: string, params: Record<string, unknown>): Promise<unknown> {
-      const handler = methods[method];
-      if (!handler) {
-        throw new Error(`Unknown MAP method: ${method}. Supported: ${Object.keys(methods).join(", ")}`);
-      }
-      return handler(params);
-    },
-
-    listMethods(): string[] {
-      return Object.keys(methods);
-    },
-  };
-}

package/src/acp/session-mapper.ts

@@ -1,116 +0,0 @@
-/**
- * SessionMapper — In-memory ACP session ↔ agent mapping.
- *
- * Tracks which macro-agent agent each ACP session is currently
- * pointing at. Supports mount/unmount for switching between
- * the head manager and child agents within a single session.
- *
- * No persistence needed — mappings are ephemeral per-connection.
- *
- * @module acp/session-mapper
- */
-
-import type { ACPSessionId, SessionMapping } from "./types.js";
-
-export class SessionMapper {
-  private readonly mappings = new Map<ACPSessionId, SessionMapping>();
-
-  /**
-   * Create a new session mapping.
-   * Initially points at the head manager.
-   */
-  createMapping(acpSessionId: ACPSessionId, headManagerId: string): SessionMapping {
-    const mapping: SessionMapping = {
-      acpSessionId,
-      agentId: headManagerId,
-      headManagerId,
-      isMounted: false,
-      createdAt: Date.now(),
-      isProcessing: false,
-    };
-    this.mappings.set(acpSessionId, mapping);
-    return mapping;
-  }
-
-  /**
-   * Get the full mapping for a session.
-   */
-  getMapping(acpSessionId: ACPSessionId): SessionMapping | undefined {
-    return this.mappings.get(acpSessionId);
-  }
-
-  /**
-   * Get the currently active agent ID for a session.
-   */
-  getAgentId(acpSessionId: ACPSessionId): string | undefined {
-    return this.mappings.get(acpSessionId)?.agentId;
-  }
-
-  /**
-   * Get the head manager ID for a session.
-   */
-  getHeadManagerId(acpSessionId: ACPSessionId): string | undefined {
-    return this.mappings.get(acpSessionId)?.headManagerId;
-  }
-
-  /**
-   * Mount a different agent onto this session.
-   * Returns the previous agent ID (for logging/debugging).
-   */
-  mount(acpSessionId: ACPSessionId, agentId: string): string | undefined {
-    const mapping = this.mappings.get(acpSessionId);
-    if (!mapping) return undefined;
-
-    const previousAgentId = mapping.agentId;
-    mapping.agentId = agentId;
-    mapping.isMounted = true;
-    return previousAgentId;
-  }
-
-  /**
-   * Unmount the current agent, restoring the head manager.
-   * Returns the agent ID that was unmounted.
-   */
-  unmount(acpSessionId: ACPSessionId): string | undefined {
-    const mapping = this.mappings.get(acpSessionId);
-    if (!mapping) return undefined;
-
-    const unmountedAgentId = mapping.agentId;
-    mapping.agentId = mapping.headManagerId;
-    mapping.isMounted = false;
-    return unmountedAgentId;
-  }
-
-  /**
-   * Remove a session mapping entirely.
-   */
-  removeMapping(acpSessionId: ACPSessionId): boolean {
-    return this.mappings.delete(acpSessionId);
-  }
-
-  /**
-   * Set the processing (prompting) status for a session.
-   */
-  setProcessing(acpSessionId: ACPSessionId, isProcessing: boolean): void {
-    const mapping = this.mappings.get(acpSessionId);
-    if (mapping) {
-      mapping.isProcessing = isProcessing;
-    }
-  }
-
-  /**
-   * Get all active session mappings.
-   */
-  getAllMappings(): SessionMapping[] {
-    return Array.from(this.mappings.values());
-  }
-
-  /**
-   * Get all sessions currently pointing at a given agent ID.
-   */
-  getSessionsForAgent(agentId: string): SessionMapping[] {
-    return Array.from(this.mappings.values()).filter(
-      (m) => m.agentId === agentId,
-    );
-  }
-}

package/src/acp/types.ts

@@ -1,99 +0,0 @@
-/**
- * ACP (Agent Communication Protocol) types for macro-agent.
- *
- * Lean type definitions for session mapping, configuration,
- * and error handling in the ACP WebSocket layer.
- *
- * @module acp/types
- */
-
-// ─────────────────────────────────────────────────────────────────
-// Session Types
-// ─────────────────────────────────────────────────────────────────
-
-export type ACPSessionId = string;
-
-/**
- * Maps an ACP session to an underlying macro-agent agent.
- * Each ACP connection can have multiple sessions, each pointing
- * to a different agent (with a head manager as the default).
- */
-export interface SessionMapping {
-  /** ACP protocol session ID */
-  acpSessionId: ACPSessionId;
-
-  /** Currently active agent ID (changes on mount/unmount) */
-  agentId: string;
-
-  /** The root head manager ID (restored on unmount) */
-  headManagerId: string;
-
-  /** Whether a non-head agent is mounted */
-  isMounted: boolean;
-
-  /** When the session was created (epoch ms) */
-  createdAt: number;
-
-  /** Whether a prompt is currently in-flight */
-  isProcessing: boolean;
-}
-
-// ─────────────────────────────────────────────────────────────────
-// Configuration
-// ─────────────────────────────────────────────────────────────────
-
-/**
- * Configuration passed to the macro-agent ACP handler.
- */
-export interface MacroAgentInitConfig {
-  /** Default working directory for new sessions */
-  defaultCwd?: string;
-
-  /** Prefix prepended to system prompts */
-  systemPromptPrefix?: string;
-
-  /** Suffix appended to system prompts */
-  systemPromptSuffix?: string;
-
-  /**
-   * Local agent ID this ACP stream is bound to. When set, `session/new` binds
-   * the new session to this specific agent (any role) instead of falling back
-   * to cwd-based head-manager lookup. Set by the ACP-over-MAP bridge so that
-   * MAP-level routing (which already targets a specific agent) is preserved
-   * end-to-end through the ACP layer — important when multiple coordinators
-   * share the same cwd.
-   */
-  targetAgentId?: string;
-}
-
-// ─────────────────────────────────────────────────────────────────
-// Errors
-// ─────────────────────────────────────────────────────────────────
-
-export type ACPErrorCode =
-  | "SESSION_NOT_FOUND"
-  | "AGENT_NOT_FOUND"
-  | "MOUNT_FAILED"
-  | "FORK_FAILED"
-  | "INVALID_EXTENSION"
-  | "PERMISSION_DENIED"
-  | "NO_PEER_MANAGER";
-
-/**
- * Typed error for ACP operations.
- */
-export class ACPError extends Error {
-  public readonly code: ACPErrorCode;
-  public readonly details?: Record<string, unknown>;
-
-  constructor(
-    message: string,
-    code: ACPErrorCode,
-    details?: Record<string, unknown>,
-  ) {
-    super(message);
-    this.name = "ACPError";
-    this.code = code;
-    this.details = details;
-  }
-}

package/src/acp/websocket-server.ts

@@ -1,213 +0,0 @@
-/**
- * WebSocket ACP Server — Multi-client WebSocket transport for the ACP protocol.
- *
- * Accepts WebSocket connections, creates a bidirectional Stream for each,
- * and wires up an AgentSideConnection with the macro-agent ACP handler.
- *
- * Also provides a /health HTTP endpoint.
- *
- * @module acp/websocket-server
- */
-
-import { WebSocketServer, WebSocket } from "ws";
-import * as http from "node:http";
-import {
-  AgentSideConnection,
-  type Stream,
-  type AnyMessage,
-} from "@agentclientprotocol/sdk";
-import { createMacroAgent } from "./macro-agent.js";
-import type { MacroAgentSystemV2 } from "../boot-v2.js";
-import type { MacroAgentInitConfig } from "./types.js";
-
-// ─────────────────────────────────────────────────────────────────
-// Public Interface
-// ─────────────────────────────────────────────────────────────────
-
-export interface WebSocketACPServer {
-  /** Start listening for connections */
-  start(): Promise<void>;
-
-  /** Stop the server and close all connections */
-  stop(): Promise<void>;
-
-  /** Number of active WebSocket connections */
-  getConnectionCount(): number;
-
-  /** The URL the server is listening on */
-  getUrl(): string;
-}
-
-export interface WebSocketACPServerConfig {
-  port?: number;
-  host?: string;
-  path?: string;
-  initConfig?: MacroAgentInitConfig;
-}
-
-// ─────────────────────────────────────────────────────────────────
-// Stream Adapter
-// ─────────────────────────────────────────────────────────────────
-
-/**
- * Adapt a WebSocket into an ACP Stream (readable + writable).
- */
-function webSocketStream(ws: WebSocket): Stream {
-  const readable = new ReadableStream<AnyMessage>({
-    start(controller) {
-      ws.on("message", (data: Buffer | string) => {
-        try {
-          const parsed = JSON.parse(data.toString()) as AnyMessage;
-          controller.enqueue(parsed);
-        } catch {
-          // Ignore malformed messages
-        }
-      });
-      ws.on("close", () => {
-        try {
-          controller.close();
-        } catch {
-          // Already closed
-        }
-      });
-      ws.on("error", (err) => {
-        try {
-          controller.error(err);
-        } catch {
-          // Already errored
-        }
-      });
-    },
-  });
-
-  const writable = new WritableStream<AnyMessage>({
-    write(chunk) {
-      if (ws.readyState === WebSocket.OPEN) {
-        ws.send(JSON.stringify(chunk));
-      }
-    },
-  });
-
-  return { readable, writable };
-}
-
-// ─────────────────────────────────────────────────────────────────
-// Factory
-// ─────────────────────────────────────────────────────────────────
-
-export function createWebSocketACPServer(
-  system: MacroAgentSystemV2,
-  config?: WebSocketACPServerConfig,
-): WebSocketACPServer {
-  const port = config?.port ?? 3001;
-  const host = config?.host ?? "127.0.0.1";
-  const wsPath = config?.path ?? "/acp";
-  const initConfig = config?.initConfig;
-
-  let httpServer: http.Server | null = null;
-  let wss: WebSocketServer | null = null;
-  const connections = new Set<AgentSideConnection>();
-  const webSockets = new Set<WebSocket>();
-  let resolvedUrl = "";
-
-  return {
-    async start(): Promise<void> {
-      httpServer = http.createServer((req, res) => {
-        if (req.url === "/health" && req.method === "GET") {
-          res.writeHead(200, { "Content-Type": "application/json" });
-          res.end(
-            JSON.stringify({
-              status: "ok",
-              connections: webSockets.size,
-              timestamp: new Date().toISOString(),
-            }),
-          );
-          return;
-        }
-        res.writeHead(404);
-        res.end("Not Found");
-      });
-
-      wss = new WebSocketServer({
-        server: httpServer,
-        path: wsPath,
-      });
-
-      wss.on("connection", (ws: WebSocket) => {
-        webSockets.add(ws);
-
-        const stream = webSocketStream(ws);
-
-        const conn = new AgentSideConnection(
-          (agentConn) =>
-            createMacroAgent(agentConn, {
-              system,
-              initConfig,
-            }),
-          stream,
-        );
-        connections.add(conn);
-
-        ws.on("close", () => {
-          webSockets.delete(ws);
-          connections.delete(conn);
-        });
-
-        ws.on("error", () => {
-          webSockets.delete(ws);
-          connections.delete(conn);
-        });
-      });
-
-      await new Promise<void>((resolve, reject) => {
-        httpServer!.on("error", reject);
-        httpServer!.listen(port, host, () => {
-          const addr = httpServer!.address();
-          if (addr && typeof addr === "object") {
-            resolvedUrl = `ws://${addr.address}:${addr.port}${wsPath}`;
-          } else {
-            resolvedUrl = `ws://${host}:${port}${wsPath}`;
-          }
-          resolve();
-        });
-      });
-    },
-
-    async stop(): Promise<void> {
-      // Close all WebSocket connections
-      for (const ws of webSockets) {
-        try {
-          ws.close(1001, "Server shutting down");
-        } catch {
-          // Best effort
-        }
-      }
-      webSockets.clear();
-      connections.clear();
-
-      // Close WebSocket server
-      if (wss) {
-        await new Promise<void>((resolve) => {
-          wss!.close(() => resolve());
-        });
-        wss = null;
-      }
-
-      // Close HTTP server
-      if (httpServer) {
-        await new Promise<void>((resolve) => {
-          httpServer!.close(() => resolve());
-        });
-        httpServer = null;
-      }
-    },
-
-    getConnectionCount(): number {
-      return webSockets.size;
-    },
-
-    getUrl(): string {
-      return resolvedUrl;
-    },
-  };
-}