macro-agent 0.2.0 → 0.2.1

package/src/dispatch/__tests__/mail-inbound-consumer.test.ts

@@ -586,4 +586,215 @@ describe("createMailInboundConsumer", () => {
     expect(consumer.stats().seenTaskIds).toBe(1);
     expect(consumer.stats().droppedMalformed).toBe(2);
   });
+
+  // ── Pre-spawn repo mount ──────────────────────────────────────────
+
+  describe("pre-spawn repo mount", () => {
+    function workEnvelopeWithRepo(
+      taskId: string,
+      prompt: string,
+      repoMeta: Record<string, unknown>,
+      conversationId?: string,
+    ): InboxMessageEvent {
+      return {
+        agentId: DISPATCHER_ID,
+        message: {
+          id: `msg-${taskId}`,
+          content: {
+            schema: "x-dispatch/work",
+            data: {
+              taskId,
+              prompt,
+              role: "worker",
+              metadata: repoMeta,
+            },
+            ...(conversationId ? { _conversationId: conversationId } : {}),
+          },
+        },
+      };
+    }
+
+    function makeRepoManager(existingRepos: Array<{ canonicalUrl: string; localPath: string }> = []) {
+      const attached: Array<{ remoteUrl: string; localPath: string }> = [];
+      return {
+        manager: {
+          list: () =>
+            [
+              ...existingRepos.map((r) => ({
+                identity: { canonicalUrl: r.canonicalUrl },
+                localPath: r.localPath,
+              })),
+              ...attached.map((r) => ({
+                identity: { canonicalUrl: r.remoteUrl },
+                localPath: r.localPath,
+              })),
+            ],
+          attach: vi.fn(async (config: { remoteUrl: string; localPath: string }) => {
+            attached.push(config);
+            return { localPath: config.localPath };
+          }),
+        },
+        attached,
+      };
+    }
+
+    it("passes cwd from already-attached repo to spawn", async () => {
+      const repo = makeRepoManager([
+        { canonicalUrl: "https://github.com/org/repo.git", localPath: "/repos/repo" },
+      ]);
+      const logs: string[] = [];
+
+      createMailInboundConsumer({
+        dispatcherAgentId: DISPATCHER_ID,
+        inboxEvents,
+        agentManager: am.manager as AgentManager,
+        agentStore: store as AgentStore,
+        getSidecar: () => sidecar,
+        getRepoManager: () => repo.manager,
+        log: (m) => logs.push(m),
+      });
+
+      inboxEvents.fire(
+        workEnvelopeWithRepo("task-repo-1", "work on repo", {
+          repo_id: "repo_abc",
+          canonical_url: "https://github.com/org/repo.git",
+        }),
+      );
+
+      await new Promise((r) => setTimeout(r, 30));
+
+      expect(am.spawnFn).toHaveBeenCalledOnce();
+      expect(am.spawnFn).toHaveBeenCalledWith(
+        expect.objectContaining({ cwd: "/repos/repo" }),
+      );
+      expect(logs.some((l) => l.includes("already attached"))).toBe(true);
+    });
+
+    it("spawns without cwd when clone_policy is not 'allowed' and repo not attached", async () => {
+      const repo = makeRepoManager([]);
+      const logs: string[] = [];
+
+      createMailInboundConsumer({
+        dispatcherAgentId: DISPATCHER_ID,
+        inboxEvents,
+        agentManager: am.manager as AgentManager,
+        agentStore: store as AgentStore,
+        getSidecar: () => sidecar,
+        getRepoManager: () => repo.manager,
+        log: (m) => logs.push(m),
+      });
+
+      inboxEvents.fire(
+        workEnvelopeWithRepo("task-repo-2", "work", {
+          repo_id: "repo_xyz",
+          canonical_url: "https://github.com/org/other.git",
+        }),
+      );
+
+      await new Promise((r) => setTimeout(r, 30));
+
+      expect(am.spawnFn).toHaveBeenCalledOnce();
+      // No cwd passed — clone_policy defaults to 'none'
+      const spawnArgs = am.spawnFn.mock.calls[0]![0] as Record<string, unknown>;
+      expect(spawnArgs.cwd).toBeUndefined();
+      expect(logs.some((l) => l.includes("skipping mount"))).toBe(true);
+    });
+
+    it("spawns without cwd when no repo metadata in envelope", async () => {
+      const repo = makeRepoManager([]);
+
+      createMailInboundConsumer({
+        dispatcherAgentId: DISPATCHER_ID,
+        inboxEvents,
+        agentManager: am.manager as AgentManager,
+        agentStore: store as AgentStore,
+        getSidecar: () => sidecar,
+        getRepoManager: () => repo.manager,
+      });
+
+      // Standard envelope without repo metadata
+      inboxEvents.fire(workEnvelope("task-no-repo", "plain work"));
+
+      await new Promise((r) => setTimeout(r, 30));
+
+      expect(am.spawnFn).toHaveBeenCalledOnce();
+      const spawnArgs = am.spawnFn.mock.calls[0]![0] as Record<string, unknown>;
+      expect(spawnArgs.cwd).toBeUndefined();
+    });
+
+    it("spawns without cwd when getRepoManager is not provided", async () => {
+      createMailInboundConsumer({
+        dispatcherAgentId: DISPATCHER_ID,
+        inboxEvents,
+        agentManager: am.manager as AgentManager,
+        agentStore: store as AgentStore,
+        getSidecar: () => sidecar,
+        // no getRepoManager
+      });
+
+      inboxEvents.fire(
+        workEnvelopeWithRepo("task-no-mgr", "work", {
+          repo_id: "repo_abc",
+          canonical_url: "https://github.com/org/repo.git",
+          clone_policy: "allowed",
+        }),
+      );
+
+      await new Promise((r) => setTimeout(r, 30));
+
+      expect(am.spawnFn).toHaveBeenCalledOnce();
+      const spawnArgs = am.spawnFn.mock.calls[0]![0] as Record<string, unknown>;
+      expect(spawnArgs.cwd).toBeUndefined();
+    });
+
+    it("spawns without cwd when canonical_url is missing from repo metadata", async () => {
+      const repo = makeRepoManager([]);
+
+      createMailInboundConsumer({
+        dispatcherAgentId: DISPATCHER_ID,
+        inboxEvents,
+        agentManager: am.manager as AgentManager,
+        agentStore: store as AgentStore,
+        getSidecar: () => sidecar,
+        getRepoManager: () => repo.manager,
+      });
+
+      inboxEvents.fire(
+        workEnvelopeWithRepo("task-no-url", "work", {
+          repo_id: "repo_abc",
+          // no canonical_url
+        }),
+      );
+
+      await new Promise((r) => setTimeout(r, 30));
+
+      expect(am.spawnFn).toHaveBeenCalledOnce();
+      const spawnArgs = am.spawnFn.mock.calls[0]![0] as Record<string, unknown>;
+      expect(spawnArgs.cwd).toBeUndefined();
+    });
+
+    it("logs repo_id in the received message log line", async () => {
+      const logs: string[] = [];
+
+      createMailInboundConsumer({
+        dispatcherAgentId: DISPATCHER_ID,
+        inboxEvents,
+        agentManager: am.manager as AgentManager,
+        agentStore: store as AgentStore,
+        getSidecar: () => sidecar,
+        log: (m) => logs.push(m),
+      });
+
+      inboxEvents.fire(
+        workEnvelopeWithRepo("task-log", "work", {
+          repo_id: "repo_visible",
+          canonical_url: "https://github.com/org/visible.git",
+        }),
+      );
+
+      await new Promise((r) => setTimeout(r, 20));
+
+      expect(logs.some((l) => l.includes("repo=repo_visible"))).toBe(true);
+    });
+  });
 });

package/src/dispatch/mail-inbound-consumer.ts

@@ -61,6 +61,38 @@ export interface MailInboundSidecar {
   ): Promise<void>;
 }
 
+/** Repo metadata surfaced by the hub's enrichWithRepo → mail port injection. */
+export interface DispatchRepoMetadata {
+  repo_id?: string;
+  canonical_url?: string;
+  branch?: string;
+  commit_sha?: string;
+  clone_policy?: string;
+  clone_path?: string;
+}
+
+/**
+ * Narrow interface for the sidecar's RepoManager — keeps the consumer
+ * testable without importing the full agent-workspace concrete type.
+ */
+export interface RepoManagerLike {
+  list(): Array<{ identity: { canonicalUrl: string }; localPath: string }>;
+  attach(config: {
+    remoteUrl: string;
+    localPath: string;
+    currentBranch?: string;
+  }): Promise<{ localPath: string }>;
+}
+
+/**
+ * Narrow interface for the sidecar's RepoClient transport — used to
+ * declare newly-attached repos to the hub after clone.
+ */
+export interface RepoClientTransportLike {
+  notify(method: string, params: unknown): Promise<void>;
+  request(method: string, params: unknown): Promise<unknown>;
+}
+
 export interface MailInboundConsumerOptions {
   /**
    * The inbox agent ID that mail-bridge delivers envelopes to.
@@ -85,6 +117,19 @@ export interface MailInboundConsumerOptions {
    */
   getSidecar: () => MailInboundSidecar | null | undefined;
 
+  /**
+   * Optional repo manager for pre-spawn mount. When provided, the consumer
+   * can clone/attach repos before spawning workers and set the worker's cwd
+   * to the repo path. Populated lazily from the sidecar's workspace manager.
+   */
+  getRepoManager?: () => RepoManagerLike | null | undefined;
+
+  /**
+   * Optional repo client transport for declaring newly-cloned repos to the
+   * hub after a pre-spawn clone. Uses the sidecar's MAP connection transport.
+   */
+  getRepoTransport?: () => RepoClientTransportLike | null | undefined;
+
   /** Optional logger (default: console.log). */
   log?: (msg: string) => void;
 }
@@ -121,6 +166,8 @@ export function createMailInboundConsumer(
     agentManager,
     agentStore,
     getSidecar,
+    getRepoManager,
+    getRepoTransport,
     log = (msg: string) => console.log(msg),
   } = opts;
 
@@ -158,6 +205,102 @@ export function createMailInboundConsumer(
       `(recipient=${dispatcherAgentId})`,
   );
 
+  // ── Pre-spawn repo mount ─────────────────────────────────────
+  // Resolves the worker's cwd from the dispatch envelope's repo metadata.
+  // When clone_policy is 'allowed' and the repo isn't already attached,
+  // clones to clone_path (or a default under cwd) then attaches+declares.
+  // Best-effort: failures log a warning and return undefined (worker
+  // spawns without a repo-specific cwd).
+  async function resolveRepoCwd(
+    repoMeta: DispatchRepoMetadata,
+    taskId: string,
+  ): Promise<string | undefined> {
+    const manager = getRepoManager?.();
+    if (!manager) return undefined;
+
+    const canonicalUrl = repoMeta.canonical_url;
+    if (!canonicalUrl) return undefined;
+
+    // Check if the repo is already attached (by canonical URL match).
+    const existing = manager.list().find(
+      (h) => h.identity.canonicalUrl === canonicalUrl,
+    );
+    if (existing) {
+      log(`[mail-inbound] Repo already attached at ${existing.localPath} for taskId=${taskId}`);
+      return existing.localPath;
+    }
+
+    // Not attached — clone only if explicitly allowed.
+    if (repoMeta.clone_policy !== 'allowed') {
+      log(
+        `[mail-inbound] Repo ${canonicalUrl} not attached and clone_policy=${repoMeta.clone_policy ?? 'none'} — ` +
+          `skipping mount for taskId=${taskId}`,
+      );
+      return undefined;
+    }
+
+    const clonePath = repoMeta.clone_path ?? `/tmp/openhive-repos/${repoMeta.repo_id}`;
+    try {
+      const { execSync } = await import("node:child_process");
+
+      // Clone if the directory doesn't exist yet.
+      const fs = await import("node:fs");
+      if (!fs.existsSync(clonePath)) {
+        log(`[mail-inbound] Cloning ${canonicalUrl} → ${clonePath} for taskId=${taskId}`);
+        execSync(`git clone --depth 1 ${canonicalUrl} ${clonePath}`, {
+          stdio: "pipe",
+          timeout: 120_000,
+        });
+      }
+
+      // Checkout target branch if specified.
+      if (repoMeta.branch) {
+        try {
+          execSync(`git -C ${clonePath} fetch origin ${repoMeta.branch} --depth 1`, {
+            stdio: "pipe",
+            timeout: 60_000,
+          });
+          execSync(`git -C ${clonePath} checkout ${repoMeta.branch}`, {
+            stdio: "pipe",
+            timeout: 30_000,
+          });
+        } catch {
+          log(`[mail-inbound] Branch checkout failed for ${repoMeta.branch} — continuing on default branch`);
+        }
+      }
+
+      // Attach to the repo manager so future dispatches find it.
+      const handle = await manager.attach({
+        remoteUrl: canonicalUrl,
+        localPath: clonePath,
+        currentBranch: repoMeta.branch,
+      });
+
+      // Declare the new workspace to the hub (best-effort).
+      const transport = getRepoTransport?.();
+      if (transport) {
+        try {
+          const bindings = manager.list().map((h) => ({
+            canonical_url: h.identity.canonicalUrl,
+            local_path: h.localPath,
+          }));
+          await transport.notify("x-workspace/repo.declare", { bindings });
+        } catch {
+          // Non-fatal — the hub may not support workspace declarations.
+        }
+      }
+
+      log(`[mail-inbound] Mounted repo at ${handle.localPath} for taskId=${taskId}`);
+      return handle.localPath;
+    } catch (err) {
+      log(
+        `[mail-inbound] Pre-spawn repo mount failed for taskId=${taskId}: ` +
+          `${(err as Error).message ?? String(err)}`,
+      );
+      return undefined;
+    }
+  }
+
   // ── Inbox message listener ───────────────────────────────────
   const onMessage = (event: InboxMessageEvent): void => {
     // Only handle messages delivered to our dispatcher recipient.
@@ -258,17 +401,36 @@ export function createMailInboundConsumer(
       fullAutonomous: true,
     });
 
+    // Extract repo metadata from the envelope for pre-spawn mount.
+    const repoMeta: DispatchRepoMetadata = {
+      repo_id: data.metadata?.repo_id as string | undefined,
+      canonical_url: data.metadata?.canonical_url as string | undefined,
+      branch: data.metadata?.branch as string | undefined,
+      commit_sha: data.metadata?.commit_sha as string | undefined,
+      clone_policy: data.metadata?.clone_policy as string | undefined,
+      clone_path: data.metadata?.clone_path as string | undefined,
+    };
+
     log(
       `[mail-inbound] Received x-dispatch/work taskId=${taskId} ` +
         `conv=${conversationId ?? "(none)"} role=${role}` +
+        (repoMeta.repo_id ? ` repo=${repoMeta.repo_id}` : "") +
         (spawnLoadoutOpts.permissions
           ? ` permissions=${JSON.stringify(spawnLoadoutOpts.permissions)}`
           : ""),
     );
 
     // Spawn is async — fire and forget. Errors are logged, not thrown.
-    agentManager
-      .spawn({
+    // Pre-spawn mount resolves the worker's cwd from the repo metadata
+    // before spawning. Best-effort: mount failures proceed without a
+    // repo-specific cwd.
+    (async () => {
+      let repoCwd: string | undefined;
+      if (repoMeta.repo_id) {
+        repoCwd = await resolveRepoCwd(repoMeta, taskId);
+      }
+
+      const spawned = await agentManager.spawn({
         task: prompt,
         task_id: taskId,
         role,
@@ -278,40 +440,41 @@ export function createMailInboundConsumer(
         // (claude-code-swarm, oh-my-claudecode, …) don't auto-load and hang
         // session/new on environments where the host services aren't reachable.
         isolatedSettings: true,
+        ...(repoCwd ? { cwd: repoCwd } : {}),
         ...spawnLoadoutOpts,
-      })
-      .then(async (spawned) => {
-        log(
-          `[mail-inbound] Spawned worker agentId=${spawned.id} for taskId=${taskId}`,
-        );
-        if (conversationId) {
-          agentConversationMap.set(spawned.id, conversationId);
-        }
+      });
 
-        // Spawn only creates an idle ACP session — the task lives in the
-        // system prompt as instructions. To get the model to actually do
-        // the work, send the prompt as a user message via promptUntilDone.
-        // This drives the worker to completion (done() called) so the
-        // lifecycle stopped listener below fires and posts the reply
-        // back to the hub. Fire-and-forget; errors are logged.
-        try {
-          await agentManager.promptUntilDone(spawned.id, prompt, {
-            maxFollowUps: 0,
-          });
-        } catch (err) {
-          log(
-            `[mail-inbound] promptUntilDone failed for agentId=${spawned.id}: ` +
-              `${(err as Error).message ?? String(err)}`,
-          );
-        }
-      })
-      .catch((err: unknown) => {
+      log(
+        `[mail-inbound] Spawned worker agentId=${spawned.id} for taskId=${taskId}` +
+          (repoCwd ? ` cwd=${repoCwd}` : ""),
+      );
+      if (conversationId) {
+        agentConversationMap.set(spawned.id, conversationId);
+      }
+
+      // Spawn only creates an idle ACP session — the task lives in the
+      // system prompt as instructions. To get the model to actually do
+      // the work, send the prompt as a user message via promptUntilDone.
+      // This drives the worker to completion (done() called) so the
+      // lifecycle stopped listener below fires and posts the reply
+      // back to the hub. Fire-and-forget; errors are logged.
+      try {
+        await agentManager.promptUntilDone(spawned.id, prompt, {
+          maxFollowUps: 0,
+        });
+      } catch (err) {
         log(
-          `[mail-inbound] Spawn failed for taskId=${taskId}: ${
-            (err as Error).message ?? String(err)
-          }`,
+          `[mail-inbound] promptUntilDone failed for agentId=${spawned.id}: ` +
+            `${(err as Error).message ?? String(err)}`,
         );
-      });
+      }
+    })().catch((err: unknown) => {
+      log(
+        `[mail-inbound] Spawn failed for taskId=${taskId}: ${
+          (err as Error).message ?? String(err)
+        }`,
+      );
+    });
   };
 
   inboxEvents.on("inbox.message", onMessage);

package/src/map/repo-workspace.ts

@@ -0,0 +1,82 @@
+export const REPO_PROTOCOL_VERSION = "0.1.0";
+
+export interface WorkspaceCapability {
+  protocolVersion: string;
+  declare: {
+    enabled: boolean;
+    defaultVisibility: "private" | "hub_local" | "federated";
+  };
+  list: {
+    enabled: boolean;
+  };
+}
+
+export interface RepoClientTransport {
+  notify(method: string, params: unknown): Promise<void>;
+  request(method: string, params: unknown): Promise<unknown>;
+}
+
+export interface RepoAttachConfig {
+  remoteUrl: string;
+  localPath: string;
+  currentBranch?: string;
+}
+
+export interface RepoHandle {
+  identity: {
+    canonicalUrl: string;
+  };
+  localPath: string;
+  currentBranch?: string;
+}
+
+export interface RepoDeclaration {
+  bindings: Array<{
+    canonical_url: string;
+    local_path: string;
+    current_branch?: string;
+  }>;
+}
+
+export class RepoManager {
+  private readonly repos: RepoHandle[] = [];
+
+  async attach(config: RepoAttachConfig): Promise<RepoHandle> {
+    const existing = this.repos.find(
+      (repo) =>
+        repo.identity.canonicalUrl === config.remoteUrl ||
+        repo.localPath === config.localPath,
+    );
+    if (existing) return existing;
+
+    const handle: RepoHandle = {
+      identity: { canonicalUrl: config.remoteUrl },
+      localPath: config.localPath,
+      ...(config.currentBranch ? { currentBranch: config.currentBranch } : {}),
+    };
+    this.repos.push(handle);
+    return handle;
+  }
+
+  list(): RepoHandle[] {
+    return [...this.repos];
+  }
+}
+
+export class RepoClient {
+  constructor(private readonly transport: RepoClientTransport) {}
+
+  static snapshot(manager: RepoManager): RepoDeclaration {
+    return {
+      bindings: manager.list().map((repo) => ({
+        canonical_url: repo.identity.canonicalUrl,
+        local_path: repo.localPath,
+        ...(repo.currentBranch ? { current_branch: repo.currentBranch } : {}),
+      })),
+    };
+  }
+
+  async declare(declaration: RepoDeclaration): Promise<void> {
+    await this.transport.notify("x-workspace/repo.declare", declaration);
+  }
+}

package/src/map/server.ts

@@ -108,6 +108,7 @@ export function createMAPServerInstance(
         cwd: params.cwd,
         role: params.role ?? "worker",
         permissionMode: params.permissionMode,
+        askForAllTools: params.askForAllTools,
         agentType: params.agentType,
         customPrompt: params.customPrompt,
         topics: params.topics,