macro-agent 0.1.0 → 0.1.2

package/src/server/combined-server.ts

@@ -26,15 +26,32 @@ import {
   createMAPAdapter,
   createMAPWebSocketHandler,
   registerWorkspaceFileExtensions,
+  registerUpdateMetadataExtension,
+  registerMCPBridgeExtensions,
+  registerTaskExtensions,
+  registerResumeExtension,
+  registerAgentLifecycleExtensions,
+  registerStreamExtensions,
   type MAPAdapter,
   type MAPAdapterServices,
   type MAPWebSocketHandler,
+  type StreamExtensionServices,
 } from "../map/adapter/index.js";
 import type { Agent, AgentId } from "../store/types/index.js";
 import type { Address, SendOptions } from "../map/types.js";
 import { createMailService, type MailService } from "../mail/mail-service.js";
-import { createConversationMap, type ConversationMap } from "../mail/conversation-map.js";
+import {
+  createConversationMap,
+  type ConversationMap,
+} from "../mail/conversation-map.js";
 import { createTurnRecorder } from "../mail/turn-recorder.js";
+import {
+  AgentTokenManager,
+  generateToken as generateTokenFn,
+  secureCompare,
+} from "../auth/token.js";
+import { TaskBackend, TaskToolProvider } from "../task/backend/types.js";
+import type { TeamManager } from "../teams/team-manager.js";
 
 // ─────────────────────────────────────────────────────────────────
 // Types
@@ -49,6 +66,22 @@ export interface CombinedServerServices {
   capabilityManager?: CapabilityManager;
   /** Optional activity watcher for event-driven waking */
   activityWatcher?: ActivityWatcher;
+  /** Optional task backend for task tool bridge extensions */
+  taskBackend?: TaskBackend;
+  /** Optional task tool provider for dynamic task tools in thin-client mode */
+  taskToolProvider?: TaskToolProvider;
+  /** Mutable context holder for task tool provider agent_id injection */
+  taskToolContext?: { agent_id: string };
+  /** Per-agent token manager for MCP bridge authentication */
+  agentTokenManager?: AgentTokenManager;
+  /** Get connected opentasks project paths (for health endpoint) */
+  getConnectedProjects?: () => string[];
+  /** Optional stream extension services for git-cascade stream/checkpoint/merge-queue features */
+  streamExtensions?: StreamExtensionServices;
+  /** Optional team manager for dynamic team management */
+  teamManager?: TeamManager;
+  /** Optional workspace manager for workspace isolation and merge queue */
+  workspaceManager?: import("../workspace/types.js").WorkspaceManager;
 }
 
 export interface CombinedServerConfig {
@@ -69,6 +102,12 @@ export interface CombinedServerConfig {
 
   /** Disable MAP protocol (default: false - MAP is enabled) */
   disableMap?: boolean;
+
+  /** Server token for authentication. Auto-generated if not provided (unless noAuth is true). */
+  serverToken?: string;
+
+  /** Disable authentication entirely (for local development/testing) */
+  noAuth?: boolean;
 }
 
 export interface CombinedServer {
@@ -101,6 +140,9 @@ export interface CombinedServer {
 
   /** Conversation map (for agent-to-conversation tracking) */
   readonly conversationMap?: ConversationMap;
+
+  /** Server token used for authentication (exposed for tests). Undefined when auth is disabled. */
+  readonly serverToken?: string;
 }
 
 // ─────────────────────────────────────────────────────────────────
@@ -110,7 +152,10 @@ export interface CombinedServer {
 /**
  * Get all descendants of an agent recursively.
  */
-function getDescendantsRecursive(agentId: AgentId, agentManager: AgentManager): AgentId[] {
+function getDescendantsRecursive(
+  agentId: AgentId,
+  agentManager: AgentManager,
+): AgentId[] {
   const descendants: AgentId[] = [];
   const children = agentManager.getChildren(agentId);
   for (const child of children) {
@@ -124,7 +169,9 @@ function getDescendantsRecursive(agentId: AgentId, agentManager: AgentManager):
  * Create MAPAdapterServices from CombinedServerServices.
  * Wires the internal services to the MAP adapter interface.
  */
-function createMAPServices(services: CombinedServerServices): MAPAdapterServices {
+function createMAPServices(
+  services: CombinedServerServices,
+): MAPAdapterServices {
   // Create agent source for getAncestors (needs lineage lookup)
   // RelevanceAgentSource expects getAgent to return null (not undefined) when not found
   const agentSource: RelevanceAgentSource = {
@@ -137,10 +184,12 @@ function createMAPServices(services: CombinedServerServices): MAPAdapterServices
     agent
       ? {
           id: agent.id,
+          name: agent.name,
           role: agent.role,
           state: agent.state,
           parent: agent.parent ?? undefined,
           createdAt: agent.created_at,
+          metadata: agent.metadata,
         }
       : undefined;
 
@@ -152,7 +201,7 @@ function createMAPServices(services: CombinedServerServices): MAPAdapterServices
       from: AgentId,
       to: Address,
       content: string,
-      options?: SendOptions
+      options?: SendOptions,
     ) => {
       const result = await services.messageRouter.sendToAddress({
         from,
@@ -178,7 +227,7 @@ function createMAPServices(services: CombinedServerServices): MAPAdapterServices
 
 export function createCombinedServer(
   services: CombinedServerServices,
-  config: CombinedServerConfig = {}
+  config: CombinedServerConfig = {},
 ): CombinedServer {
   const {
     port = 3001,
@@ -187,8 +236,15 @@ export function createCombinedServer(
     cors = true,
     mapPath = "/map",
     disableMap = false,
+    serverToken: configToken,
+    noAuth = false,
   } = config;
 
+  // Resolve server token: disabled > config > env > none (no auth by default)
+  const resolvedServerToken = noAuth
+    ? undefined
+    : (configToken ?? process.env.MACRO_SERVER_SECRET ?? undefined);
+
   // Set up mail service and conversation map (always created, independent of MAP)
   const mailService = createMailService({ eventStore: services.eventStore });
   const conversationMap = createConversationMap();
@@ -211,7 +267,7 @@ export function createCombinedServer(
   // Create Express app with API routes (include mail services)
   const app = createAPIApp(
     { ...services, mailService, conversationMap },
-    { cors }
+    { cors, serverToken: resolvedServerToken, defaultCwd },
   );
 
   // Create HTTP server with Express
@@ -239,50 +295,149 @@ export function createCombinedServer(
     };
     mapAdapter = createMAPAdapter(
       { name: "macro-agent", version: "1.0.0" },
-      mapServices
+      mapServices,
     );
 
     // Register workspace file extensions for TUI file attachment.
     // Uses defaultCwd (project root) as the workspace path for all agents,
     // since the head manager doesn't have an isolated worktree.
     registerWorkspaceFileExtensions(mapAdapter, {
-      getWorkspace: () => ({ path: defaultCwd } as any),
+      getWorkspace: () => ({ path: defaultCwd }) as any,
       agentExists: () => true,
     });
 
+    // Register generic metadata update extension
+    registerUpdateMetadataExtension(mapAdapter, {
+      getAgent: (id) => services.agentManager.get(id),
+      updateAgentMetadata: (id, updates) =>
+        services.eventStore.updateAgentMetadata(id, updates),
+    });
+
+    // Register task extensions for direct MAP task management
+    if (services.taskBackend) {
+      registerTaskExtensions(mapAdapter, {
+        taskBackend: services.taskBackend,
+        sendMessage: async (from, to, content, options) => {
+          const result = await services.messageRouter.sendToAddress({
+            from: from as AgentId,
+            to,
+            content: typeof content === "string" ? content : JSON.stringify(content),
+            options: options ? { priority: options.priority as any } : undefined,
+          });
+          return { delivered: result.delivered };
+        },
+      });
+    }
+
+    // Register resume extension for restarting stopped agents
+    registerResumeExtension(mapAdapter, {
+      getAgent: (id) => {
+        const agent = services.agentManager.get(id);
+        if (!agent) return undefined;
+        return { id: agent.id, state: agent.state, session_id: agent.session_id };
+      },
+      resume: (id) => services.agentManager.resume(id),
+    });
+
+    // Register agent lifecycle extensions (spawn, fork, permission management)
+    registerAgentLifecycleExtensions(mapAdapter, {
+      getAgent: (id) => services.agentManager.get(id),
+      spawn: (opts) => services.agentManager.spawn(opts),
+      forkAgent: (id, opts) => services.agentManager.forkAgent(id, opts),
+      prompt: (id, msg) => services.agentManager.prompt(id, msg),
+      setPermissionMode: (id, mode) =>
+        services.agentManager.setPermissionMode(id, mode as any),
+      getPermissionMode: (id) => services.agentManager.getPermissionMode(id),
+      respondToPermission: (id, reqId, optId) =>
+        services.agentManager.respondToPermission(id, reqId, optId),
+      onAgentRegistered: (agent) => {
+        // Emit agent_registered event to all MAP subscribers
+        // mapAdapter is guaranteed non-null here (inside if (!disableMap) block)
+        mapAdapter!.emitEvent({
+          eventId: `agent-reg-${agent.id}-${Date.now()}`,
+          type: "agent_registered" as any,
+          timestamp: Date.now(),
+          data: agent,
+        });
+      },
+      listHeadManagers: () => services.agentManager.listHeadManagers(),
+      defaultCwd,
+    });
+
+    // Register MCP bridge extensions for thin-client MCP subprocesses
+    registerMCPBridgeExtensions(mapAdapter, {
+      eventStore: services.eventStore,
+      agentManager: services.agentManager,
+      taskManager: services.taskManager,
+      messageRouter: services.messageRouter,
+      peerManager: services.peerManager,
+      activityWatcher: services.activityWatcher,
+      taskBackend: services.taskBackend,
+      taskToolProvider: services.taskToolProvider,
+      taskToolContext: services.taskToolContext,
+      agentTokenManager: services.agentTokenManager,
+    });
+
+    // Register stream/checkpoint/diffStack/mergeQueue extensions
+    if (services.streamExtensions) {
+      registerStreamExtensions(mapAdapter, services.streamExtensions);
+    }
+
     mapHandler = createMAPWebSocketHandler(mapAdapter);
   }
 
   // Handle upgrade requests - route by path
-  httpServer.on("upgrade", (request: IncomingMessage, socket: Duplex, head: Buffer) => {
-    const pathname = new URL(request.url ?? "/", `http://${request.headers.host}`).pathname;
-
-    if (pathname === "/acp") {
-      acpWss.handleUpgrade(request, socket, head, (ws) => {
-        acpWss.emit("connection", ws, request);
-      });
-    } else if (pathname === "/api/ws") {
-      apiWss.handleUpgrade(request, socket, head, (ws) => {
-        apiWss.emit("connection", ws, request);
-      });
-    } else if (pathname === mapPath && mapHandler) {
-      // MAP protocol connection
-      acpWss.handleUpgrade(request, socket, head, (ws) => {
-        mapHandler.handleConnection(ws, request);
-      });
-    } else {
-      // Unknown WebSocket path
-      socket.write("HTTP/1.1 404 Not Found\r\n\r\n");
-      socket.destroy();
-    }
-  });
+  httpServer.on(
+    "upgrade",
+    (request: IncomingMessage, socket: Duplex, head: Buffer) => {
+      const parsedUrl = new URL(
+        request.url ?? "/",
+        `http://${request.headers.host}`,
+      );
+      const pathname = parsedUrl.pathname;
+
+      // Validate server token on WebSocket upgrade (skip when auth disabled)
+      if (resolvedServerToken) {
+        const urlToken = parsedUrl.searchParams.get("token");
+        if (!urlToken || !secureCompare(urlToken, resolvedServerToken)) {
+          socket.write("HTTP/1.1 401 Unauthorized\r\n\r\n");
+          socket.destroy();
+          return;
+        }
+      }
+
+      if (pathname === "/acp") {
+        acpWss.handleUpgrade(request, socket, head, (ws) => {
+          acpWss.emit("connection", ws, request);
+        });
+      } else if (pathname === "/api/ws") {
+        apiWss.handleUpgrade(request, socket, head, (ws) => {
+          apiWss.emit("connection", ws, request);
+        });
+      } else if (pathname === mapPath && mapHandler) {
+        // MAP protocol connection
+        acpWss.handleUpgrade(request, socket, head, (ws) => {
+          mapHandler.handleConnection(ws, request);
+        });
+      } else {
+        // Unknown WebSocket path
+        socket.write("HTTP/1.1 404 Not Found\r\n\r\n");
+        socket.destroy();
+      }
+    },
+  );
 
   // Add health endpoint
   app.get("/health", (_req, res) => {
+    const connectedProjects = services.getConnectedProjects?.() ?? [];
     res.json({
       status: "ok",
       acp_connections: acpHandler.getConnectionCount(),
       map_connections: mapHandler?.getConnectionCount() ?? 0,
+      opentasks: {
+        connected_projects: connectedProjects,
+        project_count: connectedProjects.length,
+      },
       timestamp: Date.now(),
     });
   });
@@ -301,13 +456,23 @@ export function createCombinedServer(
       httpServer.on("error", reject);
       httpServer.listen(port, host, () => {
         httpServer.removeListener("error", reject);
+        const tokenParam = resolvedServerToken ? `?token=${resolvedServerToken}` : "";
         console.error(`[combined] Server listening on http://${host}:${port}`);
-        console.error(`[combined]   ACP WebSocket: ws://${host}:${port}/acp`);
+        console.error(`[combined]   ACP WebSocket: ws://${host}:${port}/acp${tokenParam}`);
         if (mapHandler) {
-          console.error(`[combined]   MAP WebSocket: ws://${host}:${port}${mapPath}`);
+          console.error(
+            `[combined]   MAP WebSocket: ws://${host}:${port}${mapPath}${tokenParam}`,
+          );
         }
-        console.error(`[combined]   API WebSocket: ws://${host}:${port}/api/ws`);
+        console.error(
+          `[combined]   API WebSocket: ws://${host}:${port}/api/ws${tokenParam}`,
+        );
         console.error(`[combined]   REST API: http://${host}:${port}/api/*`);
+        if (resolvedServerToken) {
+          console.error(`[combined]   Server token: ${resolvedServerToken.substring(0, 8)}...`);
+        } else {
+          console.error(`[combined]   Auth: disabled`);
+        }
         resolve();
       });
     });
@@ -348,6 +513,10 @@ export function createCombinedServer(
   }
 
   function getUrl(): string {
+    const addr = httpServer.address();
+    if (addr && typeof addr === "object") {
+      return `http://${host}:${addr.port}`;
+    }
     return `http://${host}:${port}`;
   }
 
@@ -370,5 +539,6 @@ export function createCombinedServer(
     mapAdapter,
     mailService,
     conversationMap,
+    serverToken: resolvedServerToken,
   };
 }

package/src/steering/__tests__/steering-integration.test.ts

@@ -671,7 +671,7 @@ describe("Steering Integration", () => {
         payload: { status_type: "started" },
       });
       eventStore.emit({
-        type: "terminate",
+        type: "stop",
         source: { agent_id: "stopped-agent" },
         payload: { agent_id: "stopped-agent", reason: "completed" },
       });

package/src/store/__tests__/event-store-oob.test.ts

@@ -0,0 +1,109 @@
+/**
+ * EventStore Out-of-Band Field Preservation Tests
+ *
+ * Tests that fields written via updateAgentMetadata() (out-of-band,
+ * not through events) survive the rebuildViews() cycle that occurs
+ * on every auto-load (every 1 second) and on reload().
+ *
+ * The preservation relies on OUT_OF_BAND_FIELDS in rebuildViews()
+ * which saves these values before clearing views, replays all events,
+ * then restores the saved values.
+ *
+ * @module store/__tests__/event-store-oob
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { createEventStore, type EventStore } from "../event-store.js";
+import type { AgentId } from "../types/index.js";
+
+describe("EventStore — Out-of-Band Field Preservation", () => {
+  let eventStore: EventStore;
+
+  const AGENT_ID = "oob-test-001" as AgentId;
+
+  beforeEach(async () => {
+    eventStore = await createEventStore({ instanceId: `oob-test-${Date.now()}` });
+
+    // Create an agent via spawn event
+    eventStore.emit({
+      type: "spawn",
+      source: { agent_id: AGENT_ID },
+      payload: {
+        agent_id: AGENT_ID,
+        task: "Test task",
+        role: "worker",
+        cwd: "/original/path",
+      },
+    });
+    await eventStore.persist();
+  });
+
+  afterEach(async () => {
+    try { await eventStore.close(); } catch { /* ignore */ }
+  });
+
+  it("cwd survives rebuildViews after updateAgentMetadata", async () => {
+    // Verify initial cwd from spawn event
+    expect(eventStore.getAgent(AGENT_ID)?.cwd).toBe("/original/path");
+
+    // Update cwd out-of-band
+    eventStore.updateAgentMetadata(AGENT_ID, { cwd: "/workspace/worktree-001" });
+    expect(eventStore.getAgent(AGENT_ID)?.cwd).toBe("/workspace/worktree-001");
+
+    // Persist and reload (triggers rebuildViews)
+    await eventStore.persist();
+    await eventStore.reload();
+
+    // cwd should survive the rebuild
+    const agent = eventStore.getAgent(AGENT_ID);
+    expect(agent).not.toBeNull();
+    expect(agent!.cwd).toBe("/workspace/worktree-001");
+  });
+
+  it("team_instance survives rebuildViews", async () => {
+    // Set team_instance out-of-band
+    eventStore.updateAgentMetadata(AGENT_ID, { team_instance: "team-alpha-001" });
+    expect(eventStore.getAgent(AGENT_ID)?.team_instance).toBe("team-alpha-001");
+
+    // Persist and reload
+    await eventStore.persist();
+    await eventStore.reload();
+
+    // team_instance should survive
+    expect(eventStore.getAgent(AGENT_ID)?.team_instance).toBe("team-alpha-001");
+  });
+
+  it("all OUT_OF_BAND_FIELDS preserved together", async () => {
+    // Set all out-of-band fields simultaneously
+    eventStore.updateAgentMetadata(AGENT_ID, {
+      name: "Developer Alpha",
+      plan: [{ content: "Step 1: do the thing", priority: "high", status: "pending" }],
+      metadata: { custom_key: "custom_value" },
+      cwd: "/workspace/worktree-002",
+      team_instance: "team-beta-002",
+    });
+
+    // Verify all set correctly
+    const before = eventStore.getAgent(AGENT_ID)!;
+    expect(before.name).toBe("Developer Alpha");
+    expect(before.cwd).toBe("/workspace/worktree-002");
+    expect(before.team_instance).toBe("team-beta-002");
+
+    // Persist and reload (triggers rebuildViews)
+    await eventStore.persist();
+    await eventStore.reload();
+
+    // All fields should survive
+    const after = eventStore.getAgent(AGENT_ID)!;
+    expect(after.name).toBe("Developer Alpha");
+    expect(after.cwd).toBe("/workspace/worktree-002");
+    expect(after.team_instance).toBe("team-beta-002");
+
+    // plan and metadata may be stored as JSON strings or objects depending on TinyBase internals
+    const plan = typeof after.plan === "string" ? JSON.parse(after.plan) : after.plan;
+    expect(plan).toEqual([{ content: "Step 1: do the thing", priority: "high", status: "pending" }]);
+
+    const metadata = typeof after.metadata === "string" ? JSON.parse(after.metadata) : after.metadata;
+    expect(metadata).toEqual({ custom_key: "custom_value" });
+  });
+});