macro-agent 0.1.0 → 0.1.1

package/src/server/combined-server.ts

@@ -26,6 +26,11 @@ import {
   createMAPAdapter,
   createMAPWebSocketHandler,
   registerWorkspaceFileExtensions,
+  registerUpdateMetadataExtension,
+  registerMCPBridgeExtensions,
+  registerTaskExtensions,
+  registerResumeExtension,
+  registerAgentLifecycleExtensions,
   type MAPAdapter,
   type MAPAdapterServices,
   type MAPWebSocketHandler,
@@ -33,8 +38,17 @@ import {
 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";
 
 // ─────────────────────────────────────────────────────────────────
 // Types
@@ -49,6 +63,16 @@ 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[];
 }
 
 export interface CombinedServerConfig {
@@ -69,6 +93,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 +131,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 +143,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 +160,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 +175,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 +192,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 +218,7 @@ function createMAPServices(services: CombinedServerServices): MAPAdapterServices
 
 export function createCombinedServer(
   services: CombinedServerServices,
-  config: CombinedServerConfig = {}
+  config: CombinedServerConfig = {},
 ): CombinedServer {
   const {
     port = 3001,
@@ -187,8 +227,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 +258,7 @@ export function createCombinedServer(
   // Create Express app with API routes (include mail services)
   const app = createAPIApp(
     { ...services, mailService, conversationMap },
-    { cors }
+    { cors, serverToken: resolvedServerToken },
   );
 
   // Create HTTP server with Express
@@ -239,50 +286,144 @@ 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,
+    });
+
     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 +442,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 +499,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 +525,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.test.ts

@@ -170,7 +170,7 @@ describe('EventStore', () => {
       });
 
       store.emit({
-        type: 'terminate',
+        type: 'stop',
         source: { agent_id: 'agent_1' },
         payload: { reason: 'completed' },
       });
@@ -1096,6 +1096,201 @@ describe('Event Archival', () => {
 
       await planStore.close();
     });
+
+    it('should update agent name via updateAgentMetadata', async () => {
+      const metaStore = await createEventStore({ inMemory: true });
+
+      metaStore.emit({
+        type: 'spawn',
+        source: { agent_id: 'agent_meta' },
+        payload: {
+          agent_id: 'agent_meta',
+          session_id: 'sess_meta',
+          task: 'test metadata',
+        },
+      });
+
+      // Name starts undefined
+      expect(metaStore.getAgent('agent_meta')?.name).toBeUndefined();
+
+      // Set name via updateAgentMetadata
+      metaStore.updateAgentMetadata('agent_meta', { name: 'MyAgent' });
+      expect(metaStore.getAgent('agent_meta')?.name).toBe('MyAgent');
+
+      await metaStore.close();
+    });
+
+    it('should update agent metadata via updateAgentMetadata', async () => {
+      const metaStore = await createEventStore({ inMemory: true });
+
+      metaStore.emit({
+        type: 'spawn',
+        source: { agent_id: 'agent_meta2' },
+        payload: {
+          agent_id: 'agent_meta2',
+          session_id: 'sess_meta2',
+          task: 'test metadata field',
+        },
+      });
+
+      // Metadata starts undefined
+      expect(metaStore.getAgent('agent_meta2')?.metadata).toBeUndefined();
+
+      // Set metadata
+      metaStore.updateAgentMetadata('agent_meta2', {
+        metadata: { color: 'blue', priority: 1 },
+      });
+      const after = metaStore.getAgent('agent_meta2');
+      expect(after?.metadata).toEqual({ color: 'blue', priority: 1 });
+
+      await metaStore.close();
+    });
+
+    it('should shallow-merge metadata with existing values', async () => {
+      const metaStore = await createEventStore({ inMemory: true });
+
+      metaStore.emit({
+        type: 'spawn',
+        source: { agent_id: 'agent_merge' },
+        payload: {
+          agent_id: 'agent_merge',
+          session_id: 'sess_merge',
+          task: 'test metadata merge',
+        },
+      });
+
+      // Set initial metadata
+      metaStore.updateAgentMetadata('agent_merge', {
+        metadata: { color: 'blue', size: 'large' },
+      });
+      expect(metaStore.getAgent('agent_merge')?.metadata).toEqual({
+        color: 'blue',
+        size: 'large',
+      });
+
+      // Merge with new metadata — existing keys preserved, new keys added
+      metaStore.updateAgentMetadata('agent_merge', {
+        metadata: { color: 'red', shape: 'circle' },
+      });
+      expect(metaStore.getAgent('agent_merge')?.metadata).toEqual({
+        color: 'red',
+        size: 'large',
+        shape: 'circle',
+      });
+
+      await metaStore.close();
+    });
+
+    it('should update multiple fields in a single updateAgentMetadata call', async () => {
+      const metaStore = await createEventStore({ inMemory: true });
+
+      metaStore.emit({
+        type: 'spawn',
+        source: { agent_id: 'agent_multi' },
+        payload: {
+          agent_id: 'agent_multi',
+          session_id: 'sess_multi',
+          task: 'test multi-field update',
+        },
+      });
+
+      const plan = [
+        { content: 'Step 1', priority: 'high', status: 'pending' },
+      ];
+
+      metaStore.updateAgentMetadata('agent_multi', {
+        name: 'MultiAgent',
+        plan,
+        metadata: { tag: 'test' },
+      });
+
+      const agent = metaStore.getAgent('agent_multi');
+      expect(agent?.name).toBe('MultiAgent');
+      expect(agent?.plan).toEqual(plan);
+      expect(agent?.metadata).toEqual({ tag: 'test' });
+
+      await metaStore.close();
+    });
+
+    it('should notify agent change listeners on metadata update', async () => {
+      const metaStore = await createEventStore({ inMemory: true });
+
+      metaStore.emit({
+        type: 'spawn',
+        source: { agent_id: 'agent_notify' },
+        payload: {
+          agent_id: 'agent_notify',
+          session_id: 'sess_notify',
+          task: 'test notify',
+        },
+      });
+
+      const changes: string[] = [];
+      metaStore.onAgentChange((agentId) => {
+        changes.push(agentId);
+      });
+
+      metaStore.updateAgentMetadata('agent_notify', { name: 'Notified' });
+      expect(changes).toContain('agent_notify');
+
+      await metaStore.close();
+    });
+
+    it('should preserve all out-of-band fields across reload', async () => {
+      const metaStore = await createEventStore({
+        baseDir: testDir,
+        instanceId: 'metadata-reload-test',
+      });
+
+      metaStore.emit({
+        type: 'spawn',
+        source: { agent_id: 'agent_reload' },
+        payload: {
+          agent_id: 'agent_reload',
+          session_id: 'sess_reload',
+          task: 'test reload persistence',
+        },
+      });
+
+      // Set all out-of-band fields
+      const plan = [
+        { content: 'Research', priority: 'high', status: 'completed' },
+      ];
+      metaStore.updateAgentMetadata('agent_reload', {
+        name: 'ReloadAgent',
+        plan,
+        metadata: { version: 2, env: 'test' },
+      });
+
+      // Verify before reload
+      const before = metaStore.getAgent('agent_reload');
+      expect(before?.name).toBe('ReloadAgent');
+      expect(before?.plan).toEqual(plan);
+      expect(before?.metadata).toEqual({ version: 2, env: 'test' });
+
+      // Persist and reload (rebuildViews)
+      await metaStore.persist();
+      await metaStore.reload();
+
+      // All fields should survive
+      const after = metaStore.getAgent('agent_reload');
+      expect(after).toBeDefined();
+      expect(after?.name).toBe('ReloadAgent');
+      expect(after?.plan).toEqual(plan);
+      expect(after?.metadata).toEqual({ version: 2, env: 'test' });
+
+      await metaStore.close();
+    });
+
+    it('should no-op when agent does not exist', async () => {
+      const metaStore = await createEventStore({ inMemory: true });
+
+      // Should not throw
+      metaStore.updateAgentMetadata('nonexistent', { name: 'Ghost' });
+      expect(metaStore.getAgent('nonexistent')).toBeNull();
+
+      await metaStore.close();
+    });
   });
 });
 

package/src/store/__tests__/instance.test.ts

@@ -467,10 +467,10 @@ describe('Peer Visibility', () => {
     it('should filter by whitelist when visibleEventTypes is specified', () => {
       const visibility: PeerVisibilityConfig = {
         exportEvents: true,
-        visibleEventTypes: ['spawn', 'terminate'],
+        visibleEventTypes: ['spawn', 'stop'],
       };
       expect(isEventTypeVisibleToPeers('spawn', visibility)).toBe(true);
-      expect(isEventTypeVisibleToPeers('terminate', visibility)).toBe(true);
+      expect(isEventTypeVisibleToPeers('stop', visibility)).toBe(true);
       expect(isEventTypeVisibleToPeers('message', visibility)).toBe(false);
     });
   });
@@ -503,7 +503,7 @@ describe('Peer Visibility', () => {
       { type: 'spawn', source: { agent_id: 'agent-1' }, payload: {} },
       { type: 'message', source: { agent_id: 'agent-1' }, payload: {} },
       { type: 'spawn', source: { agent_id: 'agent-2' }, payload: {} },
-      { type: 'terminate', source: { agent_id: 'agent-2' }, payload: {} },
+      { type: 'stop', source: { agent_id: 'agent-2' }, payload: {} },
     ];
 
     it('should return empty array when export is disabled', () => {