macro-agent 0.1.0 → 0.1.1

package/src/roles/capabilities.ts

@@ -117,10 +117,20 @@ export const ALL_CAPABILITIES: Set<Capability> = new Set([
 ]);
 
 /**
- * Check if a capability string is known
+ * Check if a capability string is known.
+ * Accepts exact matches from ALL_CAPABILITIES, plus dynamic `agent.spawn.*`
+ * patterns generated by team-defined spawn rules (e.g., "agent.spawn.grinder").
  */
 export function isKnownCapability(capability: string): capability is Capability {
-  return ALL_CAPABILITIES.has(capability as Capability);
+  if (ALL_CAPABILITIES.has(capability as Capability)) {
+    return true;
+  }
+  // Team-defined roles generate dynamic agent.spawn.<role> capabilities
+  // via TeamLoader spawn_rules translation (RD3). These are valid at runtime.
+  if (capability.startsWith("agent.spawn.")) {
+    return true;
+  }
+  return false;
 }
 
 // =============================================================================
@@ -156,11 +166,11 @@ export const CAPABILITY_TOOL_MAP: CapabilityToolMap = {
   // Lifecycle operations
   [LIFECYCLE_CAPABILITIES.DONE]: ["done"],
 
-  // Task operations (via sudocode integration or TaskBackend)
-  [TASK_CAPABILITIES.CREATE]: ["sudocode_upsert_issue", "create_task"],
-  [TASK_CAPABILITIES.ASSIGN]: ["sudocode_upsert_issue", "assign_task"],
-  [TASK_CAPABILITIES.UPDATE]: ["sudocode_upsert_issue", "update_task"],
-  [TASK_CAPABILITIES.CLOSE]: ["sudocode_upsert_issue", "close_task"],
+  // Task operations (via TaskBackend + OpenTasks tools)
+  [TASK_CAPABILITIES.CREATE]: ["create_task"],
+  [TASK_CAPABILITIES.ASSIGN]: ["assign_task", "task"],
+  [TASK_CAPABILITIES.UPDATE]: ["update_task", "task", "link", "annotate"],
+  [TASK_CAPABILITIES.CLOSE]: ["close_task", "task"],
   [TASK_CAPABILITIES.CLAIM]: ["claim_task", "unclaim_task", "list_claimable_tasks"],
 
   // Execution operations

package/src/roles/config-loader.ts

@@ -2,8 +2,8 @@
  * Role Configuration File Loader
  *
  * Loads role configurations from:
- * - Project-level: .macro-agent/roles.json
- * - User-level: ~/.macro-agent/roles.json
+ * - Project-level: .multiagent/roles.json
+ * - User-level: ~/.multiagent/roles.json
  *
  * Supports layered override with project > user > built-in precedence.
  *
@@ -103,10 +103,10 @@ export interface LoadResult {
 export const CONFIG_FILE_NAME = "roles.json";
 
 /** Project-level config directory */
-export const PROJECT_CONFIG_DIR = ".macro-agent";
+export const PROJECT_CONFIG_DIR = ".multiagent";
 
 /** User-level config directory */
-export const USER_CONFIG_DIR = ".macro-agent";
+export const USER_CONFIG_DIR = ".multiagent";
 
 // =============================================================================
 // Path Resolution
@@ -116,7 +116,7 @@ export const USER_CONFIG_DIR = ".macro-agent";
  * Get the project-level config file path
  *
  * @param projectPath - Project root directory (default: process.cwd())
- * @returns Path to .macro-agent/roles.json
+ * @returns Path to .multiagent/roles.json
  */
 export function getProjectConfigPath(projectPath?: string): string {
   const root = projectPath ?? process.cwd();
@@ -126,7 +126,7 @@ export function getProjectConfigPath(projectPath?: string): string {
 /**
  * Get the user-level config file path
  *
- * @returns Path to ~/.macro-agent/roles.json
+ * @returns Path to ~/.multiagent/roles.json
  */
 export function getUserConfigPath(): string {
   return path.join(os.homedir(), USER_CONFIG_DIR, CONFIG_FILE_NAME);

package/src/roles/registry.ts

@@ -2,8 +2,8 @@
  * Role Registry Implementation
  *
  * Manages role definitions with layered resolution:
- * - Project-level (.macro-agent/roles)
- * - User-level (~/.macro-agent/roles)
+ * - Project-level (.multiagent/roles)
+ * - User-level (~/.multiagent/roles)
  * - Built-in (framework)
  */
 

package/src/server/__tests__/combined-server.test.ts

@@ -19,6 +19,13 @@ function getRandomPort(): number {
   return 10000 + Math.floor(Math.random() * 50000);
 }
 
+const TEST_TOKEN = "test-server-token-for-unit-tests";
+
+/** Build a WebSocket URL with auth token query param */
+function wsUrl(port: number, path: string): string {
+  return `ws://localhost:${port}${path}?token=${TEST_TOKEN}`;
+}
+
 describe("createCombinedServer with MAP", () => {
   let server: CombinedServer;
   let services: CombinedServerServices;
@@ -33,6 +40,7 @@ describe("createCombinedServer with MAP", () => {
         get: vi.fn().mockReturnValue(null),
         list: vi.fn().mockReturnValue([]),
         getChildren: vi.fn().mockReturnValue([]),
+        onLifecycleEvent: vi.fn(),
       } as unknown as AgentManager,
       eventStore: {
         append: vi.fn(),
@@ -64,7 +72,7 @@ describe("createCombinedServer with MAP", () => {
 
   describe("MAP protocol integration", () => {
     it("starts with MAP adapter enabled by default", async () => {
-      server = createCombinedServer(services, { port });
+      server = createCombinedServer(services, { port, serverToken: TEST_TOKEN });
       await server.start();
 
       expect(server.mapAdapter).toBeDefined();
@@ -72,10 +80,10 @@ describe("createCombinedServer with MAP", () => {
     });
 
     it("accepts MAP connections on /map", async () => {
-      server = createCombinedServer(services, { port });
+      server = createCombinedServer(services, { port, serverToken: TEST_TOKEN });
       await server.start();
 
-      const ws = new WebSocket(`ws://localhost:${port}/map`);
+      const ws = new WebSocket(wsUrl(port, "/map"));
 
       await new Promise<void>((resolve, reject) => {
         const timeout = setTimeout(() => reject(new Error("Connection timeout")), 2000);
@@ -98,10 +106,10 @@ describe("createCombinedServer with MAP", () => {
     }, 5000);
 
     it("uses custom MAP path", async () => {
-      server = createCombinedServer(services, { port, mapPath: "/custom-map" });
+      server = createCombinedServer(services, { port, mapPath: "/custom-map", serverToken: TEST_TOKEN });
       await server.start();
 
-      const ws = new WebSocket(`ws://localhost:${port}/custom-map`);
+      const ws = new WebSocket(wsUrl(port, "/custom-map"));
 
       await new Promise<void>((resolve, reject) => {
         const timeout = setTimeout(() => reject(new Error("Connection timeout")), 2000);
@@ -124,14 +132,14 @@ describe("createCombinedServer with MAP", () => {
     }, 5000);
 
     it("can disable MAP protocol", async () => {
-      server = createCombinedServer(services, { port, disableMap: true });
+      server = createCombinedServer(services, { port, disableMap: true, serverToken: TEST_TOKEN });
       await server.start();
 
       expect(server.mapAdapter).toBeUndefined();
       expect(server.getMAPConnectionCount()).toBe(0);
 
-      // Connection to /map should fail
-      const ws = new WebSocket(`ws://localhost:${port}/map`);
+      // Connection to /map should fail (either 401 without token or 404)
+      const ws = new WebSocket(wsUrl(port, "/map"));
 
       await new Promise<void>((resolve) => {
         ws.on("error", () => resolve());
@@ -142,7 +150,7 @@ describe("createCombinedServer with MAP", () => {
     }, 5000);
 
     it("stops MAP adapter on shutdown", async () => {
-      server = createCombinedServer(services, { port });
+      server = createCombinedServer(services, { port, serverToken: TEST_TOKEN });
       await server.start();
 
       expect(server.mapAdapter?.isRunning()).toBe(true);
@@ -155,7 +163,7 @@ describe("createCombinedServer with MAP", () => {
 
   describe("health endpoint", () => {
     it("includes map_connections in health response", async () => {
-      server = createCombinedServer(services, { port });
+      server = createCombinedServer(services, { port, serverToken: TEST_TOKEN });
       await server.start();
 
       const response = await fetch(`http://localhost:${port}/health`);
@@ -169,7 +177,7 @@ describe("createCombinedServer with MAP", () => {
     });
 
     it("shows 0 map_connections when MAP is disabled", async () => {
-      server = createCombinedServer(services, { port, disableMap: true });
+      server = createCombinedServer(services, { port, disableMap: true, serverToken: TEST_TOKEN });
       await server.start();
 
       const response = await fetch(`http://localhost:${port}/health`);
@@ -179,16 +187,81 @@ describe("createCombinedServer with MAP", () => {
     });
   });
 
+  describe("authentication", () => {
+    it("rejects WebSocket connections without token", async () => {
+      server = createCombinedServer(services, { port, serverToken: TEST_TOKEN });
+      await server.start();
+
+      const ws = new WebSocket(`ws://localhost:${port}/map`);
+
+      await new Promise<void>((resolve) => {
+        ws.on("error", () => resolve());
+        ws.on("close", () => resolve());
+      });
+
+      expect(server.getMAPConnectionCount()).toBe(0);
+    }, 5000);
+
+    it("rejects WebSocket connections with wrong token", async () => {
+      server = createCombinedServer(services, { port, serverToken: TEST_TOKEN });
+      await server.start();
+
+      const ws = new WebSocket(`ws://localhost:${port}/map?token=wrong-token`);
+
+      await new Promise<void>((resolve) => {
+        ws.on("error", () => resolve());
+        ws.on("close", () => resolve());
+      });
+
+      expect(server.getMAPConnectionCount()).toBe(0);
+    }, 5000);
+
+    it("exposes serverToken on the server object", () => {
+      server = createCombinedServer(services, { port, serverToken: TEST_TOKEN });
+      expect(server.serverToken).toBe(TEST_TOKEN);
+    });
+
+    it("has no serverToken when not provided (auth disabled by default)", () => {
+      server = createCombinedServer(services, { port });
+      expect(server.serverToken).toBeUndefined();
+    });
+
+    it("allows connections without token when noAuth is true", async () => {
+      server = createCombinedServer(services, { port, noAuth: true });
+      await server.start();
+
+      expect(server.serverToken).toBeUndefined();
+
+      // Should connect without any token
+      const ws = new WebSocket(`ws://localhost:${port}/map`);
+
+      await new Promise<void>((resolve, reject) => {
+        const timeout = setTimeout(() => reject(new Error("Connection timeout")), 2000);
+        ws.on("open", () => {
+          clearTimeout(timeout);
+          resolve();
+        });
+        ws.on("error", (err) => {
+          clearTimeout(timeout);
+          reject(err);
+        });
+      });
+
+      expect(server.getMAPConnectionCount()).toBe(1);
+      ws.close();
+    }, 5000);
+  });
+
   describe("connection counts", () => {
     it("tracks MAP connections separately", async () => {
-      server = createCombinedServer(services, { port });
+      server = createCombinedServer(services, { port, serverToken: TEST_TOKEN });
       await server.start();
 
       expect(server.getACPConnectionCount()).toBe(0);
       expect(server.getMAPConnectionCount()).toBe(0);
 
       // Open MAP connection
-      const mapWs = new WebSocket(`ws://localhost:${port}/map`);
+      const mapWs = new WebSocket(wsUrl(port, "/map"));
       await new Promise<void>((resolve, reject) => {
         const timeout = setTimeout(() => reject(new Error("Timeout")), 2000);
         mapWs.on("open", () => {
@@ -212,10 +285,10 @@ describe("createCombinedServer with MAP", () => {
 
   describe("existing functionality preserved", () => {
     it("accepts ACP connections on /acp", async () => {
-      server = createCombinedServer(services, { port });
+      server = createCombinedServer(services, { port, serverToken: TEST_TOKEN });
       await server.start();
 
-      const ws = new WebSocket(`ws://localhost:${port}/acp`);
+      const ws = new WebSocket(wsUrl(port, "/acp"));
 
       await new Promise<void>((resolve, reject) => {
         const timeout = setTimeout(() => reject(new Error("Connection timeout")), 2000);
@@ -237,10 +310,10 @@ describe("createCombinedServer with MAP", () => {
     }, 5000);
 
     it("accepts API WebSocket connections on /api/ws", async () => {
-      server = createCombinedServer(services, { port });
+      server = createCombinedServer(services, { port, serverToken: TEST_TOKEN });
       await server.start();
 
-      const ws = new WebSocket(`ws://localhost:${port}/api/ws`);
+      const ws = new WebSocket(wsUrl(port, "/api/ws"));
 
       await new Promise<void>((resolve, reject) => {
         const timeout = setTimeout(() => reject(new Error("Connection timeout")), 2000);
@@ -258,10 +331,10 @@ describe("createCombinedServer with MAP", () => {
     }, 5000);
 
     it("rejects connections on unknown paths", async () => {
-      server = createCombinedServer(services, { port });
+      server = createCombinedServer(services, { port, serverToken: TEST_TOKEN });
       await server.start();
 
-      const ws = new WebSocket(`ws://localhost:${port}/unknown`);
+      const ws = new WebSocket(wsUrl(port, "/unknown"));
 
       await new Promise<void>((resolve) => {
         ws.on("error", () => resolve());
@@ -275,12 +348,12 @@ describe("createCombinedServer with MAP", () => {
 
   describe("server properties", () => {
     it("exposes mapAdapter when enabled", () => {
-      server = createCombinedServer(services, { port });
+      server = createCombinedServer(services, { port, serverToken: TEST_TOKEN });
       expect(server.mapAdapter).toBeDefined();
     });
 
     it("mapAdapter is undefined when disabled", () => {
-      server = createCombinedServer(services, { port, disableMap: true });
+      server = createCombinedServer(services, { port, disableMap: true, serverToken: TEST_TOKEN });
       expect(server.mapAdapter).toBeUndefined();
     });
   });