opencode-swarm 7.144.4 → 7.144.6

package/dist/cli/{index-8j0va7jp.js → index-tq89td7b.js}

@@ -1,15 +1,19 @@
 // @bun
-import {
-  advisoryWarn,
-  init_warning_buffer
-} from "./index-4rhhvd1a.js";
 import {
   SWARM_WORKTREE_DIR_NAME,
   init_constants
 } from "./index-v3y3qg48.js";
+import {
+  init_git_executable,
+  resolveGitExecutable
+} from "./index-9e6fdz2h.js";
+import {
+  advisoryWarn,
+  init_warning_buffer
+} from "./index-4rhhvd1a.js";
 import {
   bunSpawn
-} from "./index-4nt52yr9.js";
+} from "./index-zj6t9zgx.js";
 import {
   log
 } from "./index-zgwm4ryv.js";
@@ -66,8 +70,10 @@ function matchSwarmLaneBranch(branch) {
 
 // src/worktree/core.ts
 init_warning_buffer();
+init_git_executable();
 var _internals = {
   bunSpawn,
+  resolveGitExecutable,
   platform: process.platform,
   sleep: (ms) => new Promise((resolve2) => setTimeout(resolve2, ms)),
   osTmpdir: () => os.tmpdir(),
@@ -86,7 +92,7 @@ var _internals = {
     symlinkSync: fs.symlinkSync
   },
   writeScopeToDisk: async (directory, taskId, files) => {
-    const { writeScopeToDisk: realWrite } = await import("./scope-persistence-0bkaxawa.js");
+    const { writeScopeToDisk: realWrite } = await import("./scope-persistence-mjg4we75.js");
     return realWrite(directory, taskId, files);
   },
   writeLaneProfileToDisk: async (_worktreePath, _laneIndex, _envOverrides) => {
@@ -134,15 +140,25 @@ async function removeLaneProfileFromDiskReal(worktreePath, laneIndex) {
 }
 var WORKTREE_TIMEOUT_MS = 30000;
 var WIN_PATH_BUDGET = 250;
+var GIT_SPAWN_FAILURE_EXIT_CODE = 1;
 async function runGit(args, cwd, timeoutMs = WORKTREE_TIMEOUT_MS) {
-  const proc = _internals.bunSpawn(["git", ...args], {
-    cwd,
-    timeout: timeoutMs,
-    stdin: "ignore",
-    stdout: "pipe",
-    stderr: "pipe",
-    env: { ...process.env, LC_ALL: "C" }
-  });
+  let proc;
+  try {
+    proc = _internals.bunSpawn([_internals.resolveGitExecutable(), ...args], {
+      cwd,
+      timeout: timeoutMs,
+      stdin: "ignore",
+      stdout: "pipe",
+      stderr: "pipe",
+      env: { ...process.env, LC_ALL: "C" }
+    });
+  } catch (error) {
+    return {
+      exitCode: GIT_SPAWN_FAILURE_EXIT_CODE,
+      stdout: "",
+      stderr: `git ${args[0] ?? "command"} could not start in ${cwd}: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
   try {
     const exitCode = await proc.exited;
     const stdout = await proc.stdout.text();
@@ -165,14 +181,19 @@ async function checkPathBudget(worktreeRoot, directory) {
   if (longPaths === "true") {
     return { ok: true };
   }
-  const proc = _internals.bunSpawn(["git", "ls-files"], {
-    cwd: directory,
-    timeout: WORKTREE_TIMEOUT_MS,
-    stdin: "ignore",
-    stdout: "pipe",
-    stderr: "ignore",
-    env: { ...process.env, LC_ALL: "C" }
-  });
+  let proc;
+  try {
+    proc = _internals.bunSpawn([_internals.resolveGitExecutable(), "ls-files"], {
+      cwd: directory,
+      timeout: WORKTREE_TIMEOUT_MS,
+      stdin: "ignore",
+      stdout: "pipe",
+      stderr: "ignore",
+      env: { ...process.env, LC_ALL: "C" }
+    });
+  } catch {
+    return { ok: true };
+  }
   try {
     const exitCode = await proc.exited;
     const stdout = await proc.stdout.text();

package/dist/cli/{index-dty5qgk2.js → index-vdha477y.js}

@@ -7,7 +7,7 @@ import {
   readLinkPointer,
   resolveKnowledgeStoreDir,
   resolveLinkDir
-} from "./index-ywn7vtxp.js";
+} from "./index-h1p08s3n.js";
 
 // src/knowledge/curation-policy.ts
 import { appendFile, mkdir as mkdir2, readFile as readFile2 } from "fs/promises";

package/dist/cli/{index-zb0xcz9t.js → index-vngs0meh.js}

@@ -2,18 +2,18 @@
 import {
   ALLOWED_SKILL_PATH_PREFIXES,
   validateSkillPath
-} from "./index-yts89pqg.js";
+} from "./index-bac12jpv.js";
 import {
   computeOutcomeSignal,
   readKnowledge,
   resolveHiveKnowledgePath,
   resolveSwarmKnowledgePath,
   transactKnowledge
-} from "./index-03pv47h2.js";
+} from "./index-ec1kywxg.js";
 import {
   effectiveRetrievalOutcomes,
   readAuthoritativeKnowledgeCounterRollups
-} from "./index-4w5qdbk7.js";
+} from "./index-zde2mkmg.js";
 import {
   advisoryWarn,
   init_warning_buffer

package/dist/cli/{index-fqcjragy.js → index-wknz5c8q.js}

@@ -9,7 +9,7 @@ import {
 } from "./index-y8552snf.js";
 import {
   atomicWriteFile
-} from "./index-mazgg5s2.js";
+} from "./index-9s8drsf9.js";
 import {
   assertProjectRoot,
   withEvidenceLock

package/dist/cli/{index-9qq7c18c.js → index-ytzz6pq1.js}

@@ -6,7 +6,11 @@ import {
   PluginConfigSchema,
   init_schema,
   resolveExternalSkillsConfig
-} from "./index-y8j8ehc8.js";
+} from "./index-68mqwvf5.js";
+import {
+  GIT_BINARY_ENV_VAR,
+  init_git_executable
+} from "./index-9e6fdz2h.js";
 import {
   advisoryWarn,
   init_warning_buffer
@@ -437,11 +441,41 @@ function rawFullAutoLocked(raw) {
   }
   return fullAuto.locked === true;
 }
+function exposedGitBinary(raw) {
+  if (!raw || typeof raw !== "object")
+    return;
+  const git = raw.git;
+  if (!git || typeof git !== "object" || Array.isArray(git))
+    return;
+  return git.binary;
+}
+function enforceGitBinaryProvenance(mergedRaw, rawUserConfig) {
+  const userBinary = exposedGitBinary(rawUserConfig);
+  const exposedBinary = exposedGitBinary(mergedRaw);
+  if (Object.is(exposedBinary, userBinary))
+    return mergedRaw;
+  advisoryWarn(`[opencode-swarm] \u26A0\uFE0F SECURITY: Ignoring "git.binary" supplied by the project config (.opencode/${CONFIG_FILENAME}). ` + 'That file lives inside the repository, so it is untrusted content, and "git.binary" selects the executable this plugin spawns for every git command. ' + `Set it in your user config (<config dir>/opencode/${CONFIG_FILENAME}) or the ${GIT_BINARY_ENV_VAR} environment variable instead.`);
+  const exposedGit = mergedRaw.git;
+  const nextGit = exposedGit && typeof exposedGit === "object" && !Array.isArray(exposedGit) ? { ...exposedGit } : {};
+  const rebuilt = { ...mergedRaw };
+  if (userBinary === undefined) {
+    delete nextGit.binary;
+    if (Object.keys(nextGit).length === 0) {
+      delete rebuilt.git;
+      return rebuilt;
+    }
+  } else {
+    nextGit.binary = userBinary;
+  }
+  rebuilt.git = nextGit;
+  return rebuilt;
+}
 function buildConfigWithMeta(rawUserConfig, rawProjectConfig, loadedFromFile, configHadErrors) {
   let mergedRaw = rawUserConfig ?? {};
   if (rawProjectConfig) {
     mergedRaw = deepMerge(mergedRaw, rawProjectConfig);
   }
+  mergedRaw = enforceGitBinaryProvenance(mergedRaw, rawUserConfig);
   if (rawFullAutoLocked(rawUserConfig) || rawFullAutoLocked(rawProjectConfig)) {
     const fa = mergedRaw.full_auto && typeof mergedRaw.full_auto === "object" && !Array.isArray(mergedRaw.full_auto) ? mergedRaw.full_auto : {};
     mergedRaw = { ...mergedRaw, full_auto: { ...fa, locked: true } };
@@ -682,6 +716,7 @@ function loadAgentPrompt(agentName) {
 var CONFIG_FILENAME = "opencode-swarm.json", PROMPTS_DIR_NAME = "opencode-swarm", MAX_CONFIG_FILE_BYTES = 102400;
 var init_loader = __esm(() => {
   init_warning_buffer();
+  init_git_executable();
   init_sanitize_malformed_values();
   init_schema();
   init_merge();

package/dist/cli/{index-4w5qdbk7.js → index-zde2mkmg.js}

@@ -1,23 +1,23 @@
 // @bun
 import {
   validateSwarmPath
-} from "./index-rn0eq85g.js";
+} from "./index-fv0s19g9.js";
 import {
   loadPluginConfigWithMeta
-} from "./index-9qq7c18c.js";
+} from "./index-ytzz6pq1.js";
 import {
   KnowledgeConfigSchema,
   init_schema
-} from "./index-y8j8ehc8.js";
+} from "./index-68mqwvf5.js";
 import {
   resolveHiveEventsPath
 } from "./index-ae75rja9.js";
 import {
   resolveKnowledgeStoreDir
-} from "./index-ywn7vtxp.js";
+} from "./index-h1p08s3n.js";
 import {
   atomicWriteFile
-} from "./index-mazgg5s2.js";
+} from "./index-9s8drsf9.js";
 import {
   assertProjectRoot
 } from "./index-f9vvg5xb.js";
@@ -2545,7 +2545,7 @@ async function applyKnowledgeVerdictFeedback(directory, options) {
     }
     let bumps = 0;
     if (deltas.length > 0) {
-      const { bumpKnowledgeConfidenceBatch } = await import("./knowledge-store-vh3nhtg2.js");
+      const { bumpKnowledgeConfidenceBatch } = await import("./knowledge-store-qf8t25sw.js");
       bumps = await bumpKnowledgeConfidenceBatch(directory, deltas, options?.floorOptions);
     }
     return {

package/dist/cli/{index-4nt52yr9.js → index-zj6t9zgx.js}

@@ -175,8 +175,85 @@ var _internals = {
   platform: () => process.platform,
   cwd: () => process.cwd(),
   spawnTaskkill: (args, options) => nodeSpawn("taskkill", args, options),
-  createProcessTreeKiller
+  createProcessTreeKiller,
+  statSync: (target) => fsSync.statSync(target)
 };
+
+class SpawnCwdMissingError extends Error {
+  name = "SpawnCwdMissingError";
+  code = "ENOENT";
+  cwd;
+  reason;
+  executable;
+  constructor(cwd, reason, executable, options) {
+    super(reason === "missing" ? `cannot start "${executable}": working directory no longer exists: ${cwd}` : `cannot start "${executable}": working directory is not a directory: ${cwd}`, options);
+    this.cwd = cwd;
+    this.reason = reason;
+    this.executable = executable;
+  }
+}
+function inspectSpawnCwd(cwd) {
+  try {
+    return _internals.statSync(cwd).isDirectory() ? "directory" : "not-directory";
+  } catch (err) {
+    const code = typeof err === "object" && err !== null && "code" in err ? err.code : undefined;
+    if (code === "ENOENT" || code === "ENOTDIR")
+      return "missing";
+    if (code === "EACCES" || code === "EPERM")
+      return "unreadable";
+    return "unknown";
+  }
+}
+function describeSpawnCwdFailure(cwd, executable, cause) {
+  const state = inspectSpawnCwd(cwd);
+  if (state === "missing") {
+    return new SpawnCwdMissingError(cwd, "missing", executable, { cause });
+  }
+  if (state === "not-directory") {
+    return new SpawnCwdMissingError(cwd, "not-directory", executable, {
+      cause
+    });
+  }
+  return null;
+}
+var AMBIGUOUS_SPAWN_CODES = new Set(["ENOENT", "ENOTDIR", "EACCES", "EPERM"]);
+function spawnErrorCode(err) {
+  if (typeof err !== "object" || err === null || !("code" in err)) {
+    return;
+  }
+  const code = err.code;
+  return typeof code === "string" ? code : undefined;
+}
+function classifySpawnFailure(err, cwd) {
+  if (err instanceof SpawnCwdMissingError)
+    return "cwd-missing";
+  const code = spawnErrorCode(err);
+  if (code === undefined || !AMBIGUOUS_SPAWN_CODES.has(code))
+    return "other";
+  if (cwd === undefined || cwd === "") {
+    return code === "ENOENT" ? "binary-missing" : "other";
+  }
+  switch (inspectSpawnCwd(cwd)) {
+    case "missing":
+    case "not-directory":
+      return "cwd-missing";
+    case "unreadable":
+    case "unknown":
+      return "cwd-unreadable";
+    default:
+      return code === "ENOENT" ? "binary-missing" : "other";
+  }
+}
+function wrapSpawnFailure(error, cwd, executable) {
+  const err = asError(error);
+  if (err instanceof SpawnCwdMissingError)
+    return err;
+  if (cwd === undefined || cwd === "")
+    return err;
+  if (classifySpawnFailure(err, cwd) !== "cwd-missing")
+    return err;
+  return describeSpawnCwdFailure(cwd, executable, err) ?? err;
+}
 function streamFromNode(pipe) {
   let collected;
   let readerClaimed = false;
@@ -321,6 +398,42 @@ function mergeEnvForChild(baseEnv, envOverrides) {
   }
   return merged;
 }
+var SPAWN_CREATION_FAILURE_EXIT_CODE = 1;
+function asError(value) {
+  return value instanceof Error ? value : new Error(String(value));
+}
+function staticStream(text) {
+  const bytes = new TextEncoder().encode(text);
+  return {
+    async text() {
+      return text;
+    },
+    async bytes() {
+      return bytes;
+    },
+    getReader() {
+      return new ReadableStream({
+        start(controller) {
+          if (bytes.byteLength > 0)
+            controller.enqueue(bytes);
+          controller.close();
+        }
+      }).getReader();
+    }
+  };
+}
+function spawnCreationFailure(error) {
+  return {
+    stdout: streamFromBun(undefined),
+    stderr: staticStream(error.message),
+    exited: Promise.resolve(SPAWN_CREATION_FAILURE_EXIT_CODE),
+    exitCode: null,
+    signalCode: null,
+    spawnError: error,
+    kill() {},
+    killTree: () => Promise.resolve()
+  };
+}
 function bunSpawn(cmd, options) {
   const bun = getBun();
   if (bun?.spawn) {
@@ -337,7 +450,13 @@ function bunSpawn(cmd, options) {
       delete spawnOpts.killSignal;
       spawnOpts.detached = true;
     }
-    const proc2 = bun.spawn(cmd, spawnOpts);
+    let spawned;
+    try {
+      spawned = bun.spawn(cmd, spawnOpts);
+    } catch (error) {
+      return spawnCreationFailure(wrapSpawnFailure(error, options?.cwd, cmd[0] ?? ""));
+    }
+    const proc2 = spawned;
     const killBunTree = createProcessTreeKiller(proc2.pid, (sig) => proc2.kill(sig), true);
     const killBunProcess = (sig) => options?.killProcessTree ? killBunTree(sig) : Promise.resolve(proc2.kill(sig));
     let timeoutHandle2;
@@ -377,18 +496,23 @@ function bunSpawn(cmd, options) {
   const [file, ...args] = cmd;
   const detached = options?.killProcessTree === true;
   const mergedEnv = mergeEnvForChild(options?.env, options?.envOverrides);
-  const proc = nodeSpawn(file, args, {
-    cwd: options?.cwd,
-    env: mergedEnv,
-    detached,
-    windowsHide: true,
-    windowsVerbatimArguments: options?.windowsVerbatimArguments,
-    stdio: [
-      mapStdio(options?.stdin),
-      mapStdio(options?.stdout),
-      mapStdio(options?.stderr)
-    ]
-  });
+  let proc;
+  try {
+    proc = nodeSpawn(file, args, {
+      cwd: options?.cwd,
+      env: mergedEnv,
+      detached,
+      windowsHide: true,
+      windowsVerbatimArguments: options?.windowsVerbatimArguments,
+      stdio: [
+        mapStdio(options?.stdin),
+        mapStdio(options?.stdout),
+        mapStdio(options?.stderr)
+      ]
+    });
+  } catch (error) {
+    return spawnCreationFailure(wrapSpawnFailure(error, options?.cwd, file));
+  }
   const killChildTree = createProcessTreeKiller(proc.pid, (signal) => proc.kill(signal), true);
   const killChild = (signal) => {
     if (detached)
@@ -405,7 +529,7 @@ function bunSpawn(cmd, options) {
       resolve(code ?? -1);
     });
     proc.on("error", (error) => {
-      observedSpawnError = error;
+      observedSpawnError = wrapSpawnFailure(error, options?.cwd, file);
       resolve(1);
     });
     if (options?.timeout && options.timeout > 0) {
@@ -445,13 +569,26 @@ function bunSpawn(cmd, options) {
     killTree: killChild
   };
 }
+function syncSpawnCreationFailure(error) {
+  return {
+    stdout: new Uint8Array(0),
+    stderr: new TextEncoder().encode(error.message),
+    exitCode: SPAWN_CREATION_FAILURE_EXIT_CODE,
+    success: false
+  };
+}
 function bunSpawnSync(cmd, options) {
+  const requestedCwd = Array.isArray(cmd) ? options?.cwd : options?.cwd ?? cmd.cwd;
+  const executable = (Array.isArray(cmd) ? cmd[0] : cmd.cmd[0]) ?? "";
   const bun = getBun();
   if (bun?.spawnSync) {
     const mergedEnv2 = mergeEnvForChild(options?.env, options?.envOverrides);
     const spawnOpts = mergedEnv2 !== undefined ? { ...options, env: mergedEnv2 } : options;
-    const result2 = bun.spawnSync(cmd, spawnOpts);
-    return result2;
+    try {
+      return bun.spawnSync(cmd, spawnOpts);
+    } catch (error) {
+      return syncSpawnCreationFailure(wrapSpawnFailure(error, requestedCwd, executable));
+    }
   }
   let argv;
   let mergedOptions;
@@ -473,13 +610,24 @@ function bunSpawnSync(cmd, options) {
   }
   const [file, ...args] = argv;
   const mergedEnv = mergeEnvForChild(mergedOptions.env, options?.envOverrides);
-  const result = nodeSpawnSync(file, args, {
-    cwd: mergedOptions.cwd,
-    env: mergedEnv,
-    input: mergedOptions.stdin instanceof Uint8Array || typeof mergedOptions.stdin === "string" ? mergedOptions.stdin : undefined,
-    timeout: mergedOptions.timeout,
-    windowsHide: true
-  });
+  let result;
+  try {
+    result = nodeSpawnSync(file, args, {
+      cwd: mergedOptions.cwd,
+      env: mergedEnv,
+      input: mergedOptions.stdin instanceof Uint8Array || typeof mergedOptions.stdin === "string" ? mergedOptions.stdin : undefined,
+      timeout: mergedOptions.timeout,
+      windowsHide: true
+    });
+  } catch (error) {
+    return syncSpawnCreationFailure(wrapSpawnFailure(error, mergedOptions.cwd, file));
+  }
+  if (result.error) {
+    const wrapped = wrapSpawnFailure(result.error, mergedOptions.cwd, file);
+    if (wrapped instanceof SpawnCwdMissingError) {
+      return syncSpawnCreationFailure(wrapped);
+    }
+  }
   const stdout = result.stdout instanceof Buffer ? new Uint8Array(result.stdout.buffer, result.stdout.byteOffset, result.stdout.byteLength) : typeof result.stdout === "string" ? new TextEncoder().encode(result.stdout) : new Uint8Array(0);
   const stderr = result.stderr instanceof Buffer ? new Uint8Array(result.stderr.buffer, result.stderr.byteOffset, result.stderr.byteLength) : typeof result.stderr === "string" ? new TextEncoder().encode(result.stderr) : new Uint8Array(0);
   const exitCode = result.status ?? (result.signal ? 128 : 1);
@@ -491,4 +639,4 @@ function bunSpawnSync(cmd, options) {
   };
 }
 
-export { bunFile, bunWrite, bunHash, mergeEnvForChild, bunSpawn, bunSpawnSync };
+export { bunFile, bunWrite, bunHash, classifySpawnFailure, mergeEnvForChild, bunSpawn, bunSpawnSync };

package/dist/cli/{index-btmsqv7p.js → index-zxr5r9b7.js}

@@ -2,7 +2,7 @@
 import {
   _internals,
   resolveWorktreeIsolationConfig
-} from "./index-psvxq93b.js";
+} from "./index-ckq719fr.js";
 import {
   ApprovalEvidenceSchema,
   BaseEvidenceSchema,
@@ -42,7 +42,7 @@ import {
   loadPluginConfig,
   loadPluginConfigWithMeta,
   loadPluginConfigWithMetaAsync
-} from "./index-9qq7c18c.js";
+} from "./index-ytzz6pq1.js";
 import {
   AUTO_REVIEW_V8_BURN_IN_DECISION,
   AgentOverrideConfigSchema,
@@ -64,8 +64,7 @@ import {
   TurboConfigSchema,
   WorktreeIsolationConfigSchema,
   resolveAutoReviewConfig
-} from "./index-y8j8ehc8.js";
-import"./index-4rhhvd1a.js";
+} from "./index-68mqwvf5.js";
 import {
   ALL_AGENT_NAMES,
   ALL_SUBAGENT_NAMES,
@@ -76,6 +75,8 @@ import {
   isQAAgent,
   isSubagent
 } from "./index-v3y3qg48.js";
+import"./index-9e6fdz2h.js";
+import"./index-4rhhvd1a.js";
 import"./index-zjygnfay.js";
 import"./index-bk5tah7q.js";
 import"./index-bpmtbmy9.js";