opencode-swarm 7.144.4 → 7.144.5

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 };