opencode-swarm-plugin 0.12.15 → 0.12.17

package/dist/plugin.js

@@ -21765,6 +21765,42 @@ var SwarmStatusSchema = exports_external.object({
   last_update: exports_external.string().datetime({ offset: true })
 });
 // src/beads.ts
+var beadsWorkingDirectory = null;
+function setBeadsWorkingDirectory(directory) {
+  beadsWorkingDirectory = directory;
+}
+function getBeadsWorkingDirectory() {
+  return beadsWorkingDirectory || process.cwd();
+}
+async function runBdCommand(args) {
+  const cwd = getBeadsWorkingDirectory();
+  const proc = Bun.spawn(["bd", ...args], {
+    cwd,
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const [stdout, stderr] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text()
+  ]);
+  const exitCode = await proc.exited;
+  return { exitCode, stdout, stderr };
+}
+async function runGitCommand(args) {
+  const cwd = getBeadsWorkingDirectory();
+  const proc = Bun.spawn(["git", ...args], {
+    cwd,
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const [stdout, stderr] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text()
+  ]);
+  const exitCode = await proc.exited;
+  return { exitCode, stdout, stderr };
+}
+
 class BeadError extends Error {
   command;
   exitCode;
@@ -21844,11 +21880,18 @@ var beads_create = tool({
   async execute(args, ctx) {
     const validated = BeadCreateArgsSchema.parse(args);
     const cmdParts = buildCreateCommand(validated);
-    const result = await Bun.$`${cmdParts}`.quiet().nothrow();
+    const result = await runBdCommand(cmdParts.slice(1));
     if (result.exitCode !== 0) {
-      throw new BeadError(`Failed to create bead: ${result.stderr.toString()}`, cmdParts.join(" "), result.exitCode, result.stderr.toString());
+      throw new BeadError(`Failed to create bead: ${result.stderr}`, cmdParts.join(" "), result.exitCode, result.stderr);
+    }
+    const stdout = result.stdout.trim();
+    if (!stdout) {
+      throw new BeadError("bd create returned empty output", cmdParts.join(" "), 0, "Empty stdout");
+    }
+    if (stdout.startsWith("error:") || stdout.startsWith("Error:")) {
+      throw new BeadError(`bd create failed: ${stdout}`, cmdParts.join(" "), 0, stdout);
     }
-    const bead = parseBead(result.stdout.toString());
+    const bead = parseBead(stdout);
     return JSON.stringify(bead, null, 2);
   }
 });
@@ -21873,11 +21916,11 @@ var beads_create_epic = tool({
         priority: 1,
         description: validated.epic_description
       });
-      const epicResult = await Bun.$`${epicCmd}`.quiet().nothrow();
+      const epicResult = await runBdCommand(epicCmd.slice(1));
       if (epicResult.exitCode !== 0) {
-        throw new BeadError(`Failed to create epic: ${epicResult.stderr.toString()}`, epicCmd.join(" "), epicResult.exitCode);
+        throw new BeadError(`Failed to create epic: ${epicResult.stderr}`, epicCmd.join(" "), epicResult.exitCode);
       }
-      const epic = parseBead(epicResult.stdout.toString());
+      const epic = parseBead(epicResult.stdout);
       created.push(epic);
       for (const subtask of validated.subtasks) {
         const subtaskCmd = buildCreateCommand({
@@ -21886,11 +21929,11 @@ var beads_create_epic = tool({
           priority: subtask.priority ?? 2,
           parent_id: epic.id
         });
-        const subtaskResult = await Bun.$`${subtaskCmd}`.quiet().nothrow();
+        const subtaskResult = await runBdCommand(subtaskCmd.slice(1));
         if (subtaskResult.exitCode !== 0) {
-          throw new BeadError(`Failed to create subtask: ${subtaskResult.stderr.toString()}`, subtaskCmd.join(" "), subtaskResult.exitCode);
+          throw new BeadError(`Failed to create subtask: ${subtaskResult.stderr}`, subtaskCmd.join(" "), subtaskResult.exitCode);
         }
-        const subtaskBead = parseBead(subtaskResult.stdout.toString());
+        const subtaskBead = parseBead(subtaskResult.stdout);
         created.push(subtaskBead);
       }
       const result = {
@@ -21901,30 +21944,49 @@ var beads_create_epic = tool({
       return JSON.stringify(result, null, 2);
     } catch (error45) {
       const rollbackCommands = [];
+      const rollbackErrors = [];
       for (const bead of created) {
         try {
-          const closeCmd = [
-            "bd",
+          const closeArgs = [
             "close",
             bead.id,
             "--reason",
             "Rollback partial epic",
             "--json"
           ];
-          await Bun.$`${closeCmd}`.quiet().nothrow();
-          rollbackCommands.push(`bd close ${bead.id} --reason "Rollback partial epic"`);
+          const rollbackResult = await runBdCommand(closeArgs);
+          if (rollbackResult.exitCode === 0) {
+            rollbackCommands.push(`bd close ${bead.id} --reason "Rollback partial epic"`);
+          } else {
+            rollbackErrors.push(`${bead.id}: exit ${rollbackResult.exitCode} - ${rollbackResult.stderr.trim()}`);
+          }
         } catch (rollbackError) {
+          const errMsg = rollbackError instanceof Error ? rollbackError.message : String(rollbackError);
           console.error(`Failed to rollback bead ${bead.id}:`, rollbackError);
+          rollbackErrors.push(`${bead.id}: ${errMsg}`);
         }
       }
       const errorMsg = error45 instanceof Error ? error45.message : String(error45);
-      const rollbackInfo = rollbackCommands.length > 0 ? `
+      let rollbackInfo = "";
+      if (rollbackCommands.length > 0) {
+        rollbackInfo += `
 
 Rolled back ${rollbackCommands.length} bead(s):
 ${rollbackCommands.join(`
-`)}` : `
+`)}`;
+      }
+      if (rollbackErrors.length > 0) {
+        rollbackInfo += `
+
+Rollback failures (${rollbackErrors.length}):
+${rollbackErrors.join(`
+`)}`;
+      }
+      if (!rollbackInfo) {
+        rollbackInfo = `
 
 No beads to rollback.`;
+      }
       throw new BeadError(`Epic creation failed: ${errorMsg}${rollbackInfo}`, "beads_create_epic", 1);
     }
   }
@@ -21951,11 +22013,11 @@ var beads_query = tool({
         cmd.push("--type", validated.type);
       }
     }
-    const result = await Bun.$`${cmd}`.quiet().nothrow();
+    const result = await runBdCommand(cmd.slice(1));
     if (result.exitCode !== 0) {
-      throw new BeadError(`Failed to query beads: ${result.stderr.toString()}`, cmd.join(" "), result.exitCode);
+      throw new BeadError(`Failed to query beads: ${result.stderr}`, cmd.join(" "), result.exitCode);
     }
-    const beads = parseBeads(result.stdout.toString());
+    const beads = parseBeads(result.stdout);
     const limited = beads.slice(0, validated.limit);
     return JSON.stringify(limited, null, 2);
   }
@@ -21981,11 +22043,11 @@ var beads_update = tool({
       cmd.push("-p", validated.priority.toString());
     }
     cmd.push("--json");
-    const result = await Bun.$`${cmd}`.quiet().nothrow();
+    const result = await runBdCommand(cmd.slice(1));
     if (result.exitCode !== 0) {
-      throw new BeadError(`Failed to update bead: ${result.stderr.toString()}`, cmd.join(" "), result.exitCode);
+      throw new BeadError(`Failed to update bead: ${result.stderr}`, cmd.join(" "), result.exitCode);
     }
-    const bead = parseBead(result.stdout.toString());
+    const bead = parseBead(result.stdout);
     return JSON.stringify(bead, null, 2);
   }
 });
@@ -22005,11 +22067,11 @@ var beads_close = tool({
       validated.reason,
       "--json"
     ];
-    const result = await Bun.$`${cmd}`.quiet().nothrow();
+    const result = await runBdCommand(cmd.slice(1));
     if (result.exitCode !== 0) {
-      throw new BeadError(`Failed to close bead: ${result.stderr.toString()}`, cmd.join(" "), result.exitCode);
+      throw new BeadError(`Failed to close bead: ${result.stderr}`, cmd.join(" "), result.exitCode);
     }
-    const bead = parseBead(result.stdout.toString());
+    const bead = parseBead(result.stdout);
     return `Closed ${bead.id}: ${validated.reason}`;
   }
 });
@@ -22019,12 +22081,17 @@ var beads_start = tool({
     id: tool.schema.string().describe("Bead ID")
   },
   async execute(args, ctx) {
-    const cmd = ["bd", "update", args.id, "--status", "in_progress", "--json"];
-    const result = await Bun.$`${cmd}`.quiet().nothrow();
+    const result = await runBdCommand([
+      "update",
+      args.id,
+      "--status",
+      "in_progress",
+      "--json"
+    ]);
     if (result.exitCode !== 0) {
-      throw new BeadError(`Failed to start bead: ${result.stderr.toString()}`, cmd.join(" "), result.exitCode);
+      throw new BeadError(`Failed to start bead: ${result.stderr}`, `bd update ${args.id} --status in_progress --json`, result.exitCode);
     }
-    const bead = parseBead(result.stdout.toString());
+    const bead = parseBead(result.stdout);
     return `Started: ${bead.id}`;
   }
 });
@@ -22032,12 +22099,11 @@ var beads_ready = tool({
   description: "Get the next ready bead (unblocked, highest priority)",
   args: {},
   async execute(args, ctx) {
-    const cmd = ["bd", "ready", "--json"];
-    const result = await Bun.$`${cmd}`.quiet().nothrow();
+    const result = await runBdCommand(["ready", "--json"]);
     if (result.exitCode !== 0) {
-      throw new BeadError(`Failed to get ready beads: ${result.stderr.toString()}`, cmd.join(" "), result.exitCode);
+      throw new BeadError(`Failed to get ready beads: ${result.stderr}`, "bd ready --json", result.exitCode);
     }
-    const beads = parseBeads(result.stdout.toString());
+    const beads = parseBeads(result.stdout);
     if (beads.length === 0) {
       return "No ready beads";
     }
@@ -22054,25 +22120,34 @@ var beads_sync = tool({
     const autoPull = args.auto_pull ?? true;
     const TIMEOUT_MS = 30000;
     const withTimeout = async (promise2, timeoutMs, operation) => {
-      const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new BeadError(`Operation timed out after ${timeoutMs}ms`, operation)), timeoutMs));
-      return Promise.race([promise2, timeoutPromise]);
+      let timeoutId;
+      const timeoutPromise = new Promise((_, reject) => {
+        timeoutId = setTimeout(() => reject(new BeadError(`Operation timed out after ${timeoutMs}ms`, operation)), timeoutMs);
+      });
+      try {
+        return await Promise.race([promise2, timeoutPromise]);
+      } finally {
+        if (timeoutId !== undefined) {
+          clearTimeout(timeoutId);
+        }
+      }
     };
     if (autoPull) {
-      const pullResult = await withTimeout(Bun.$`git pull --rebase`.quiet().nothrow(), TIMEOUT_MS, "git pull --rebase");
+      const pullResult = await withTimeout(runGitCommand(["pull", "--rebase"]), TIMEOUT_MS, "git pull --rebase");
       if (pullResult.exitCode !== 0) {
-        throw new BeadError(`Failed to pull: ${pullResult.stderr.toString()}`, "git pull --rebase", pullResult.exitCode);
+        throw new BeadError(`Failed to pull: ${pullResult.stderr}`, "git pull --rebase", pullResult.exitCode);
       }
     }
-    const syncResult = await withTimeout(Bun.$`bd sync`.quiet().nothrow(), TIMEOUT_MS, "bd sync");
+    const syncResult = await withTimeout(runBdCommand(["sync"]), TIMEOUT_MS, "bd sync");
     if (syncResult.exitCode !== 0) {
-      throw new BeadError(`Failed to sync beads: ${syncResult.stderr.toString()}`, "bd sync", syncResult.exitCode);
+      throw new BeadError(`Failed to sync beads: ${syncResult.stderr}`, "bd sync", syncResult.exitCode);
     }
-    const pushResult = await withTimeout(Bun.$`git push`.quiet().nothrow(), TIMEOUT_MS, "git push");
+    const pushResult = await withTimeout(runGitCommand(["push"]), TIMEOUT_MS, "git push");
     if (pushResult.exitCode !== 0) {
-      throw new BeadError(`Failed to push: ${pushResult.stderr.toString()}`, "git push", pushResult.exitCode);
+      throw new BeadError(`Failed to push: ${pushResult.stderr}`, "git push", pushResult.exitCode);
     }
-    const statusResult = await Bun.$`git status --porcelain`.quiet().nothrow();
-    const status = statusResult.stdout.toString().trim();
+    const statusResult = await runGitCommand(["status", "--porcelain"]);
+    const status = statusResult.stdout.trim();
     if (status !== "") {
       return `Beads synced and pushed, but working directory not clean:
 ${status}`;
@@ -22087,11 +22162,11 @@ var beads_link_thread = tool({
     thread_id: tool.schema.string().describe("Agent Mail thread ID")
   },
   async execute(args, ctx) {
-    const queryResult = await Bun.$`bd show ${args.bead_id} --json`.quiet().nothrow();
+    const queryResult = await runBdCommand(["show", args.bead_id, "--json"]);
     if (queryResult.exitCode !== 0) {
-      throw new BeadError(`Failed to get bead: ${queryResult.stderr.toString()}`, `bd show ${args.bead_id} --json`, queryResult.exitCode);
+      throw new BeadError(`Failed to get bead: ${queryResult.stderr}`, `bd show ${args.bead_id} --json`, queryResult.exitCode);
     }
-    const bead = parseBead(queryResult.stdout.toString());
+    const bead = parseBead(queryResult.stdout);
     const existingDesc = bead.description || "";
     const threadMarker = `[thread:${args.thread_id}]`;
     if (existingDesc.includes(threadMarker)) {
@@ -22100,9 +22175,15 @@ var beads_link_thread = tool({
     const newDesc = existingDesc ? `${existingDesc}
 
 ${threadMarker}` : threadMarker;
-    const updateResult = await Bun.$`bd update ${args.bead_id} -d ${newDesc} --json`.quiet().nothrow();
+    const updateResult = await runBdCommand([
+      "update",
+      args.bead_id,
+      "-d",
+      newDesc,
+      "--json"
+    ]);
     if (updateResult.exitCode !== 0) {
-      throw new BeadError(`Failed to update bead: ${updateResult.stderr.toString()}`, `bd update ${args.bead_id} -d ...`, updateResult.exitCode);
+      throw new BeadError(`Failed to update bead: ${updateResult.stderr}`, `bd update ${args.bead_id} -d ...`, updateResult.exitCode);
     }
     return `Linked bead ${args.bead_id} to thread ${args.thread_id}`;
   }
@@ -26075,7 +26156,8 @@ class InMemoryMaturityStorage {
 
 // src/index.ts
 var SwarmPlugin = async (input) => {
-  const { $ } = input;
+  const { $, directory } = input;
+  setBeadsWorkingDirectory(directory);
   let activeAgentMailState = null;
   async function releaseReservations() {
     if (!activeAgentMailState || activeAgentMailState.reservations.length === 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-swarm-plugin",
-  "version": "0.12.15",
+  "version": "0.12.17",
   "description": "Multi-agent swarm coordination for OpenCode with learning capabilities, beads integration, and Agent Mail",
   "type": "module",
   "main": "dist/index.js",