macro-agent 0.1.10 → 0.1.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "macro-agent",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "description": "Interact with multiple agents as if they were a single agent.",
   "type": "module",
   "main": "dist/index.js",
@@ -49,8 +49,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.25.1",
-    "@multi-agent-protocol/sdk": "^0.1.11",
-    "@sudocode-ai/claude-code-acp": "^0.13.9",
+    "@multi-agent-protocol/sdk": "^0.1.12",
     "acp-factory": "^0.1.12",
     "agent-inbox": "^0.1.8",
     "better-sqlite3": "^12.5.0",
@@ -62,6 +61,7 @@
     "nanoid": "^5.0.0",
     "opentasks": "^0.0.3",
     "openteams": "^0.2.2",
+    "swarm-dispatch": "^0.3.0",
     "unique-names-generator": "^4.7.1",
     "ws": "^8.20.0",
     "zod": "^4.2.1"

package/src/__tests__/boot-v2.test.ts

@@ -193,4 +193,439 @@ describe("Boot V2", () => {
     // Prevent double-shutdown in afterEach
     system = null;
   });
+
+  describe("bootstrap", () => {
+    /**
+     * Wait for a coordinator to appear in the agent store. The bootstrap
+     * spawn is fired non-blocking (so boot doesn't gate on agent process
+     * startup), so direct `await bootV2(...)` returns before the coordinator
+     * exists. Poll with a short timeout to bridge the gap.
+     */
+    async function waitForCoordinator(
+      sys: MacroAgentSystemV2,
+      timeoutMs = 2000,
+    ): Promise<{ id: string; cwd?: string | null } | null> {
+      const deadline = Date.now() + timeoutMs;
+      while (Date.now() < deadline) {
+        const agents = sys.agentStore.listAgents({ role: "coordinator" });
+        if (agents.length > 0) return agents[0];
+        await new Promise((r) => setTimeout(r, 25));
+      }
+      return null;
+    }
+
+    afterEach(() => {
+      delete process.env.MACRO_BOOTSTRAP_COORDINATOR;
+      delete process.env.MACRO_BOOTSTRAP_CWD;
+      delete process.env.MACRO_BOOTSTRAP_REHYDRATE;
+    });
+
+    it("does not spawn when bootstrap is unset", async () => {
+      testDir = createTestDir();
+      system = await bootV2({
+        cwd: testDir,
+        baseDir: testDir,
+        inbox: { socketPath: path.join(testDir, "inbox.sock") },
+      });
+      // Give any rogue spawn a chance to fire before asserting absence.
+      await new Promise((r) => setTimeout(r, 250));
+      const agents = system.agentStore.listAgents({ role: "coordinator" });
+      expect(agents).toHaveLength(0);
+    });
+
+    it("spawns a coordinator when bootstrap.coordinator: true", async () => {
+      testDir = createTestDir();
+      system = await bootV2({
+        cwd: testDir,
+        baseDir: testDir,
+        inbox: { socketPath: path.join(testDir, "inbox.sock") },
+        bootstrap: { coordinator: true },
+      });
+      const agent = await waitForCoordinator(system);
+      expect(agent).not.toBeNull();
+      expect(agent!.cwd).toBe(testDir);
+    });
+
+    it("uses bootstrap.coordinator.cwd when provided", async () => {
+      testDir = createTestDir();
+      const projectDir = path.join(testDir, "project");
+      fs.mkdirSync(projectDir, { recursive: true });
+
+      system = await bootV2({
+        cwd: testDir,
+        baseDir: testDir,
+        inbox: { socketPath: path.join(testDir, "inbox.sock") },
+        bootstrap: { coordinator: { cwd: projectDir } },
+      });
+      const agent = await waitForCoordinator(system);
+      expect(agent).not.toBeNull();
+      expect(agent!.cwd).toBe(projectDir);
+    });
+
+    it("env-var bridge: MACRO_BOOTSTRAP_COORDINATOR=true triggers bootstrap", async () => {
+      testDir = createTestDir();
+      process.env.MACRO_BOOTSTRAP_COORDINATOR = "true";
+
+      system = await bootV2({
+        cwd: testDir,
+        baseDir: testDir,
+        inbox: { socketPath: path.join(testDir, "inbox.sock") },
+      });
+      const agent = await waitForCoordinator(system);
+      expect(agent).not.toBeNull();
+      expect(agent!.cwd).toBe(testDir);
+    });
+
+    it("env-var bridge: MACRO_BOOTSTRAP_CWD overrides default cwd", async () => {
+      testDir = createTestDir();
+      const projectDir = path.join(testDir, "project");
+      fs.mkdirSync(projectDir, { recursive: true });
+
+      process.env.MACRO_BOOTSTRAP_COORDINATOR = "true";
+      process.env.MACRO_BOOTSTRAP_CWD = projectDir;
+
+      system = await bootV2({
+        cwd: testDir,
+        baseDir: testDir,
+        inbox: { socketPath: path.join(testDir, "inbox.sock") },
+      });
+      const agent = await waitForCoordinator(system);
+      expect(agent!.cwd).toBe(projectDir);
+    });
+
+    it("programmatic bootstrap wins over env var", async () => {
+      testDir = createTestDir();
+      const programmaticDir = path.join(testDir, "programmatic");
+      const envDir = path.join(testDir, "env");
+      fs.mkdirSync(programmaticDir, { recursive: true });
+      fs.mkdirSync(envDir, { recursive: true });
+
+      process.env.MACRO_BOOTSTRAP_COORDINATOR = "true";
+      process.env.MACRO_BOOTSTRAP_CWD = envDir;
+
+      system = await bootV2({
+        cwd: testDir,
+        baseDir: testDir,
+        inbox: { socketPath: path.join(testDir, "inbox.sock") },
+        bootstrap: { coordinator: { cwd: programmaticDir } },
+      });
+      const agent = await waitForCoordinator(system);
+      // Programmatic value wins; env-bridge skipped because field already set.
+      expect(agent!.cwd).toBe(programmaticDir);
+    });
+
+    it("env-var bridge: MACRO_BOOTSTRAP_REHYDRATE sets rehydrate policy", async () => {
+      testDir = createTestDir();
+      process.env.MACRO_BOOTSTRAP_COORDINATOR = "true";
+      process.env.MACRO_BOOTSTRAP_REHYDRATE = "none";
+
+      // First boot creates a coordinator and persists it to agent-store.
+      const sys1 = await bootV2({
+        cwd: testDir,
+        baseDir: testDir,
+        inbox: { socketPath: path.join(testDir, "inbox.sock") },
+      });
+      const first = await waitForCoordinator(sys1);
+      expect(first).not.toBeNull();
+      await sys1.shutdown();
+
+      // Second boot with REHYDRATE=none should spawn a fresh coordinator
+      // rather than reviving the prior one — so we end up with two rows.
+      system = await bootV2({
+        cwd: testDir,
+        baseDir: testDir,
+        inbox: { socketPath: path.join(testDir, "inbox.sock") },
+      });
+      await waitForCoordinator(system);
+      const coordinators = system.agentStore
+        .listAgents({ role: "coordinator" })
+        .filter((a) => a.cwd === testDir);
+      expect(coordinators.length).toBeGreaterThanOrEqual(2);
+    });
+
+    it("rehydrate: 'none' spawns a fresh coordinator even when priors exist", async () => {
+      testDir = createTestDir();
+
+      const sys1 = await bootV2({
+        cwd: testDir,
+        baseDir: testDir,
+        inbox: { socketPath: path.join(testDir, "inbox.sock") },
+        bootstrap: { coordinator: true },
+      });
+      const first = await waitForCoordinator(sys1);
+      const firstId = first!.id;
+      await sys1.shutdown();
+
+      system = await bootV2({
+        cwd: testDir,
+        baseDir: testDir,
+        inbox: { socketPath: path.join(testDir, "inbox.sock") },
+        bootstrap: { coordinator: true, rehydrate: "none" },
+      });
+      await waitForCoordinator(system);
+      const coordinators = system.agentStore
+        .listAgents({ role: "coordinator" })
+        .filter((a) => a.cwd === testDir);
+      expect(coordinators.length).toBeGreaterThanOrEqual(2);
+      // Prior is still present (not reused), new coordinator has a
+      // different id.
+      const priorStill = coordinators.find((c) => c.id === firstId);
+      const fresh = coordinators.find((c) => c.id !== firstId);
+      expect(priorStill).toBeDefined();
+      expect(fresh).toBeDefined();
+    });
+
+    it("rehydrate: 'all' revives workers alongside the coordinator", async () => {
+      testDir = createTestDir();
+
+      // First boot — create a coordinator then a worker under it so the
+      // agent-store carries both records into the second boot.
+      const sys1 = await bootV2({
+        cwd: testDir,
+        baseDir: testDir,
+        inbox: { socketPath: path.join(testDir, "inbox.sock") },
+        bootstrap: { coordinator: true },
+      });
+      const coord = await waitForCoordinator(sys1);
+      expect(coord).not.toBeNull();
+
+      const worker = await sys1.agentManager.spawn({
+        task: "worker task",
+        role: "worker",
+        parent: coord!.id as any,
+        cwd: testDir,
+      });
+      const workerId = worker.id;
+
+      // Snapshot the worker's state before shutdown — it should still
+      // read 'running' because we never terminated it (mirrors the
+      // hosted-swarm-abrupt-restart case).
+      const preShutdown = sys1.agentStore.getAgent(workerId as any);
+      expect(preShutdown?.state).toBe("running");
+      await sys1.shutdown();
+
+      system = await bootV2({
+        cwd: testDir,
+        baseDir: testDir,
+        inbox: { socketPath: path.join(testDir, "inbox.sock") },
+        bootstrap: { coordinator: true, rehydrate: "all" },
+      });
+      // Give the non-blocking rehydration loop a chance to resume both
+      // the coordinator (depth 0) and the worker (depth 1).
+      await waitForCoordinator(system);
+      const deadline = Date.now() + 2000;
+      while (Date.now() < deadline) {
+        if (system.agentManager.hasActiveSession(workerId as any)) break;
+        await new Promise((r) => setTimeout(r, 25));
+      }
+      expect(system.agentManager.hasActiveSession(workerId as any)).toBe(true);
+    });
+
+    it("rehydrates prior coordinator instead of spawning a new one", async () => {
+      // Simulate the restart flow: boot once with bootstrap.coordinator,
+      // shut down (agent-store persists), then boot again at the same
+      // cwd/baseDir. The second boot should reuse the same agent id/name
+      // instead of creating a new one, so openhive-side "registered
+      // agents" stays stable across hosted-swarm revivals.
+      testDir = createTestDir();
+
+      const system1 = await bootV2({
+        cwd: testDir,
+        baseDir: testDir,
+        inbox: { socketPath: path.join(testDir, "inbox.sock") },
+        bootstrap: { coordinator: true },
+      });
+      const first = await waitForCoordinator(system1);
+      expect(first).not.toBeNull();
+      const firstId = first!.id;
+      await system1.shutdown();
+
+      // Second boot — same baseDir so agent-store is reused.
+      system = await bootV2({
+        cwd: testDir,
+        baseDir: testDir,
+        inbox: { socketPath: path.join(testDir, "inbox.sock") },
+        bootstrap: { coordinator: true },
+      });
+      const second = await waitForCoordinator(system);
+      expect(second).not.toBeNull();
+      // Same agent id → rehydrated, not re-spawned.
+      expect(second!.id).toBe(firstId);
+
+      // And only one coordinator for this cwd — no duplicates.
+      const coordinators = system.agentStore
+        .listAgents({ role: "coordinator" })
+        .filter((a) => a.cwd === testDir);
+      expect(coordinators).toHaveLength(1);
+    });
+  });
+
+  // ─── default baseDir isolation ─────────────────────────────────────
+  //
+  // Regression guard: without an explicit `baseDir`, macro-agent used to
+  // default to `~/.macro-agent/` — a singleton directory shared across
+  // every run on the box. Two instances in different projects would
+  // collide on `agents.db`, `inbox.db`, and `control.sock` (only one can
+  // bind the sockets). The default now compartmentalizes per-cwd via a
+  // stable hash, so sibling projects stay isolated while restarts in the
+  // same project still reuse their previous store.
+
+  describe("default baseDir (per-cwd isolation)", () => {
+    it("derives a stable cwd-hashed baseDir when none is provided", async () => {
+      testDir = createTestDir();
+      system = await bootV2({
+        cwd: testDir,
+        // baseDir omitted — want to verify the default picks a unique,
+        // stable path under ~/.macro-agent rather than the singleton.
+        inbox: { socketPath: path.join(testDir, "inbox.sock") },
+      });
+
+      // The expected path is `~/.macro-agent/inst_<12-hex>` where the hex
+      // is sha256(resolved(cwd)).slice(0, 12). Reproduce the computation
+      // here and assert the agent store landed there.
+      const crypto = await import("node:crypto");
+      const expectedId =
+        "inst_" +
+        crypto
+          .createHash("sha256")
+          .update(path.resolve(testDir))
+          .digest("hex")
+          .slice(0, 12);
+      const expectedDir = path.join(os.homedir(), ".macro-agent", expectedId);
+
+      expect(fs.existsSync(path.join(expectedDir, "agents.db"))).toBe(true);
+      expect(fs.existsSync(path.join(expectedDir, "inbox.db"))).toBe(true);
+
+      // Clean up the derived dir so repeated test runs don't leave state behind.
+      await system.shutdown();
+      system = null;
+      try { fs.rmSync(expectedDir, { recursive: true, force: true }); } catch { /* best-effort */ }
+    });
+
+    it("two instances in sibling cwds get distinct stores", async () => {
+      const a = createTestDir();
+      const b = createTestDir();
+
+      // Keep a reference to clean up afterwards; the outer afterEach only
+      // tracks `system` and a single `testDir`.
+      const sysA = await bootV2({
+        cwd: a,
+        inbox: { socketPath: path.join(a, "inbox.sock") },
+      });
+      const sysB = await bootV2({
+        cwd: b,
+        inbox: { socketPath: path.join(b, "inbox.sock") },
+      });
+
+      const crypto = await import("node:crypto");
+      const hash = (p: string) =>
+        "inst_" + crypto.createHash("sha256").update(path.resolve(p)).digest("hex").slice(0, 12);
+      const dirA = path.join(os.homedir(), ".macro-agent", hash(a));
+      const dirB = path.join(os.homedir(), ".macro-agent", hash(b));
+
+      expect(dirA).not.toBe(dirB);
+      expect(fs.existsSync(path.join(dirA, "agents.db"))).toBe(true);
+      expect(fs.existsSync(path.join(dirB, "agents.db"))).toBe(true);
+
+      await sysA.shutdown();
+      await sysB.shutdown();
+      for (const d of [dirA, dirB, a, b]) {
+        try { fs.rmSync(d, { recursive: true, force: true }); } catch { /* best-effort */ }
+      }
+    });
+
+    it("explicit baseDir still overrides the derived default", async () => {
+      testDir = createTestDir();
+      const explicit = createTestDir();
+      system = await bootV2({
+        cwd: testDir,
+        baseDir: explicit,
+        inbox: { socketPath: path.join(explicit, "inbox.sock") },
+      });
+
+      // Store landed in the explicit dir, not under ~/.macro-agent/.
+      expect(fs.existsSync(path.join(explicit, "agents.db"))).toBe(true);
+
+      const crypto = await import("node:crypto");
+      const derivedId =
+        "inst_" +
+        crypto.createHash("sha256").update(path.resolve(testDir)).digest("hex").slice(0, 12);
+      const derivedDir = path.join(os.homedir(), ".macro-agent", derivedId);
+      // Ensure the default path wasn't touched.
+      expect(fs.existsSync(path.join(derivedDir, "agents.db"))).toBe(false);
+
+      try { fs.rmSync(explicit, { recursive: true, force: true }); } catch { /* best-effort */ }
+    });
+
+    it("explicit instanceId wins over the cwd-hash fallback", async () => {
+      testDir = createTestDir();
+      // Pick an id that starts with `test-` so a stray leak is easy to spot.
+      const id = `test-inst-${Date.now().toString(36)}`;
+      system = await bootV2({
+        cwd: testDir,
+        instanceId: id,
+        inbox: { socketPath: path.join(testDir, "inbox.sock") },
+      });
+
+      const explicitDir = path.join(os.homedir(), ".macro-agent", id);
+      expect(fs.existsSync(path.join(explicitDir, "agents.db"))).toBe(true);
+
+      // The cwd-hash default should NOT have been used.
+      const crypto = await import("node:crypto");
+      const derivedId =
+        "inst_" +
+        crypto.createHash("sha256").update(path.resolve(testDir)).digest("hex").slice(0, 12);
+      const derivedDir = path.join(os.homedir(), ".macro-agent", derivedId);
+      expect(fs.existsSync(path.join(derivedDir, "agents.db"))).toBe(false);
+
+      await system.shutdown();
+      system = null;
+      try { fs.rmSync(explicitDir, { recursive: true, force: true }); } catch { /* best-effort */ }
+    });
+
+    it("falls through to map.swarmId when no instanceId is set", async () => {
+      testDir = createTestDir();
+      const swarmId = `swarm-test-${Date.now().toString(36)}`;
+      system = await bootV2({
+        cwd: testDir,
+        // No instanceId — map.swarmId should win over the cwd hash.
+        // `map.enabled: false` keeps the sidecar from actually trying
+        // to connect; we only need the id to flow into baseDir selection.
+        map: { enabled: false, swarmId },
+        inbox: { socketPath: path.join(testDir, "inbox.sock") },
+      });
+
+      const swarmDir = path.join(os.homedir(), ".macro-agent", swarmId);
+      expect(fs.existsSync(path.join(swarmDir, "agents.db"))).toBe(true);
+
+      await system.shutdown();
+      system = null;
+      try { fs.rmSync(swarmDir, { recursive: true, force: true }); } catch { /* best-effort */ }
+    });
+
+    it("prefers explicit instanceId over map.swarmId", async () => {
+      testDir = createTestDir();
+      const id = `explicit-${Date.now().toString(36)}`;
+      const swarmId = `map-${Date.now().toString(36)}`;
+      system = await bootV2({
+        cwd: testDir,
+        instanceId: id,
+        map: { enabled: false, swarmId },
+        inbox: { socketPath: path.join(testDir, "inbox.sock") },
+      });
+
+      expect(fs.existsSync(
+        path.join(os.homedir(), ".macro-agent", id, "agents.db"),
+      )).toBe(true);
+      expect(fs.existsSync(
+        path.join(os.homedir(), ".macro-agent", swarmId, "agents.db"),
+      )).toBe(false);
+
+      await system.shutdown();
+      system = null;
+      try {
+        fs.rmSync(path.join(os.homedir(), ".macro-agent", id), { recursive: true, force: true });
+      } catch { /* best-effort */ }
+    });
+  });
 });

package/src/__tests__/e2e/acp-over-map.e2e.test.ts

@@ -218,6 +218,98 @@ describe("ACP-over-MAP E2E", () => {
       // ignore
     }
   }, 15000);
+
+  // ─────────────────────────────────────────────────────────────────
+  // _macro/resumeAgent — durable resume by providerSessionId
+  // ─────────────────────────────────────────────────────────────────
+
+  it("_macro/resumeAgent returns error when providerSessionId is unknown", async () => {
+    const result = (await client!.callExtension("_macro/resumeAgent", {
+      providerSessionId: "psid-does-not-exist",
+    })) as { success: boolean; error?: string };
+
+    expect(result.success).toBe(false);
+    expect(result.error).toBeTruthy();
+  }, 10000);
+
+  it("_macro/resumeAgent returns error when neither id nor psid given", async () => {
+    const result = (await client!.callExtension("_macro/resumeAgent", {})) as {
+      success: boolean;
+      error?: string;
+    };
+
+    expect(result.success).toBe(false);
+    expect(result.error).toMatch(/providerSessionId or agentId/);
+  }, 10000);
+
+  it("_macro/resumeAgent resolves an active agent by providerSessionId (session-first)", async () => {
+    // Spawn an agent so the sessions table has a row with a provider_session_id.
+    // The mock acp-factory sets session.id = `session-mock-${Date.now()}`, which
+    // macro-agent stores as provider_session_id (see agent-manager-v2.ts:1136).
+    const spawnResult = (await client!.callExtension("_macro/spawnAgent", {
+      task: "resume target",
+      role: "worker",
+    })) as { agent: { id: string; localId?: string } };
+
+    // Give the lifecycle bridge a moment to register the agent in the store.
+    await new Promise((r) => setTimeout(r, 200));
+
+    // Read back the session record directly via the exposed AgentStore.
+    // The handler under test looks up agents by provider_session_id via the
+    // same path, so this also validates the store reverse-lookup end to end.
+    const agentStore = system.agentStore;
+    const allAgents = agentStore.listAgents();
+    const spawned = allAgents.find((a) => a.task === "resume target");
+    expect(spawned).toBeDefined();
+
+    const sessionRec = agentStore.getSession(spawned!.id);
+    expect(sessionRec).not.toBeNull();
+    expect(sessionRec!.provider_session_id).toBeTruthy();
+    const providerSessionId = sessionRec!.provider_session_id!;
+
+    // Call _macro/resumeAgent with the provider_session_id. Because the agent
+    // is still active (hasActiveSession === true), the handler takes the
+    // fast path and returns the live session info without re-spawning.
+    const result = (await client!.callExtension("_macro/resumeAgent", {
+      providerSessionId,
+    })) as {
+      success: boolean;
+      agent?: { id: string; localId: string; name?: string; role?: string };
+      acpSessionId?: string;
+      providerSessionId?: string;
+      error?: string;
+    };
+
+    expect(result.success).toBe(true);
+    expect(result.agent).toBeDefined();
+    expect(result.agent!.localId).toBe(spawned!.id);
+    expect(result.agent!.role).toBe("worker");
+    expect(result.acpSessionId).toBe(sessionRec!.session_id);
+    expect(result.providerSessionId).toBe(providerSessionId);
+    // peerMapId (agent.id) should resolve to a MAP-server ULID, not the
+    // local store id — this confirms MAPServer registration is in place.
+    expect(result.agent!.id).toBeTruthy();
+  }, 15000);
+
+  it("_macro/resumeAgent resolves by agentId (fallback path)", async () => {
+    // Use an existing agent from the previous test. Listing is stable within
+    // the same MAP server instance.
+    const agentStore = system.agentStore;
+    const agents = agentStore.listAgents();
+    expect(agents.length).toBeGreaterThan(0);
+    const target = agents[0];
+
+    const result = (await client!.callExtension("_macro/resumeAgent", {
+      agentId: target.id,
+    })) as {
+      success: boolean;
+      agent?: { id: string; localId: string };
+      error?: string;
+    };
+
+    expect(result.success).toBe(true);
+    expect(result.agent!.localId).toBe(target.id);
+  }, 15000);
 });
 
 describe("ACP-over-MAP E2E — MAP-level operations with agents", () => {