opencode-swarm 7.140.3 → 7.140.5

package/dist/cli/{index-hfvxhk4z.js → index-912qz4y0.js}

@@ -8,16 +8,89 @@ import {
 } from "./index-zgwm4ryv.js";
 import {
   emit
-} from "./index-ry0hgg3m.js";
+} from "./index-epvhf50h.js";
 import {
   __toESM
 } from "./index-a76rekgs.js";
 
+// src/parallel/file-locks.ts
+var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
+import * as crypto from "crypto";
+import * as fs from "fs";
+import * as path from "path";
+var LOCKS_DIR = ".swarm/locks";
+var LOCK_TIMEOUT_MS = 5 * 60 * 1000;
+var _internals = {
+  tryAcquireLock,
+  writeFile: fs.promises.writeFile
+};
+function getLockFilePath(directory, filePath) {
+  const normalized = path.resolve(directory, filePath);
+  const baseDir = path.resolve(directory) + path.sep;
+  const pathOk = process.platform === "win32" ? normalized.toLowerCase().startsWith(baseDir.toLowerCase()) : normalized.startsWith(baseDir);
+  if (!pathOk) {
+    throw new Error("Invalid file path: path traversal not allowed");
+  }
+  const pathForHash = process.platform === "win32" ? normalized.toLowerCase() : normalized;
+  const hash = crypto.createHash("sha256").update(pathForHash).digest("hex");
+  const lockPath = path.join(directory, LOCKS_DIR, `${hash}.lock`);
+  const legacyPaths = [pathForHash];
+  if (process.platform === "win32" && normalized !== pathForHash) {
+    legacyPaths.push(normalized);
+  }
+  for (const legacyPath of legacyPaths) {
+    const oldHash = Buffer.from(legacyPath).toString("base64").replace(/[/+=]/g, "_");
+    const oldLockPath = path.join(directory, LOCKS_DIR, `${oldHash}.lock`);
+    if (fs.existsSync(oldLockPath)) {
+      return oldLockPath;
+    }
+  }
+  return lockPath;
+}
+async function tryAcquireLock(directory, filePath, agent, taskId) {
+  const lockPath = getLockFilePath(directory, filePath);
+  const locksDir = path.dirname(lockPath);
+  if (!fs.existsSync(locksDir)) {
+    fs.mkdirSync(locksDir, { recursive: true });
+  }
+  if (!fs.existsSync(lockPath)) {
+    fs.writeFileSync(lockPath, "", "utf-8");
+  }
+  let release;
+  try {
+    release = await import_proper_lockfile.default.lock(lockPath, {
+      stale: LOCK_TIMEOUT_MS,
+      retries: {
+        retries: 5,
+        minTimeout: 10,
+        maxTimeout: 500,
+        factor: 2
+      },
+      realpath: false
+    });
+  } catch (err) {
+    const code = err.code;
+    if (code === "ELOCKED" || code === "EEXIST") {
+      return { acquired: false };
+    }
+    throw err;
+  }
+  const lock = {
+    filePath,
+    agent,
+    taskId,
+    timestamp: new Date().toISOString(),
+    expiresAt: Date.now() + LOCK_TIMEOUT_MS,
+    _release: release
+  };
+  return { acquired: true, lock };
+}
+
 // src/utils/project-boundary.ts
 init_logger();
-import * as fs from "fs";
+import * as fs2 from "fs";
 import * as os from "os";
-import * as path from "path";
+import * as path2 from "path";
 var MAX_PROJECT_ROOT_DEPTH = 20;
 var PROJECT_ROOT_INDICATORS = [
   "package.json",
@@ -40,14 +113,14 @@ var PROJECT_BOUNDARY_MARKERS = [
   { name: ".opencode", accepts: (stat) => stat.isDirectory() }
 ];
 function isAbsoluteDirectoryInput(value) {
-  return typeof value === "string" && value.trim().length > 0 && path.isAbsolute(value);
+  return typeof value === "string" && value.trim().length > 0 && path2.isAbsolute(value);
 }
 function hasExplicitProjectBoundary(directory) {
   if (!isAbsoluteDirectoryInput(directory))
     return false;
   for (const marker of PROJECT_BOUNDARY_MARKERS) {
     try {
-      const stat = _internals.lstatSync(path.join(directory, marker.name));
+      const stat = _internals2.lstatSync(path2.join(directory, marker.name));
       if (!stat.isSymbolicLink() && marker.accepts(stat))
         return true;
     } catch {}
@@ -58,8 +131,8 @@ function isStrictPathDescendant(candidate, root) {
   if (!isAbsoluteDirectoryInput(candidate) || !isAbsoluteDirectoryInput(root)) {
     return false;
   }
-  const relative2 = path.relative(root, candidate);
-  return relative2 !== "" && relative2 !== ".." && !relative2.startsWith(`..${path.sep}`) && !path.isAbsolute(relative2);
+  const relative2 = path2.relative(root, candidate);
+  return relative2 !== "" && relative2 !== ".." && !relative2.startsWith(`..${path2.sep}`) && !path2.isAbsolute(relative2);
 }
 function isMissingPathError(error) {
   const code = error?.code;
@@ -70,8 +143,8 @@ function isWeakConfigContainerRoot(directory, dependencies) {
     const resolved = dependencies.realpathSync(directory);
     return resolved === dependencies.realpathSync(os.tmpdir()) || resolved === dependencies.realpathSync(os.homedir());
   } catch {
-    const resolved = path.resolve(directory);
-    return resolved === path.resolve(os.tmpdir()) || resolved === path.resolve(os.homedir());
+    const resolved = path2.resolve(directory);
+    return resolved === path2.resolve(os.tmpdir()) || resolved === path2.resolve(os.homedir());
   }
 }
 function projectIndicatorState(directory, dependencies, options = {}) {
@@ -80,7 +153,7 @@ function projectIndicatorState(directory, dependencies, options = {}) {
     if (!allowConfigOnly && indicator === ".opencode")
       continue;
     try {
-      const indicatorStat = dependencies.statSync(path.join(directory, indicator));
+      const indicatorStat = dependencies.statSync(path2.join(directory, indicator));
       if (indicatorStat.isFile() || indicatorStat.isDirectory())
         return "present";
     } catch (error) {
@@ -90,7 +163,7 @@ function projectIndicatorState(directory, dependencies, options = {}) {
   }
   return "absent";
 }
-function assertProjectRoot(directory, dependencies = fs, artifactLabel = "runtime state") {
+function assertProjectRoot(directory, dependencies = fs2, artifactLabel = "runtime state") {
   let resolved;
   try {
     resolved = dependencies.realpathSync(directory);
@@ -108,14 +181,14 @@ function assertProjectRoot(directory, dependencies = fs, artifactLabel = "runtim
       throw new Error(`Cannot verify project root for "${resolved}" \u2014 ancestor search exceeded ${MAX_PROJECT_ROOT_DEPTH} levels`);
     }
     depth++;
-    const parent = path.dirname(current);
+    const parent = path2.dirname(current);
     if (parent === current)
       break;
-    if (path.dirname(parent) === parent) {
+    if (path2.dirname(parent) === parent) {
       current = parent;
       continue;
     }
-    const parentSwarm = path.join(parent, ".swarm");
+    const parentSwarm = path2.join(parent, ".swarm");
     let parentSwarmStat;
     try {
       parentSwarmStat = dependencies.statSync(parentSwarm);
@@ -143,82 +216,9 @@ function assertProjectRoot(directory, dependencies = fs, artifactLabel = "runtim
     current = parent;
   }
 }
-var _internals = {
-  lstatSync: fs.lstatSync
-};
-
-// src/parallel/file-locks.ts
-var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
-import * as crypto from "crypto";
-import * as fs2 from "fs";
-import * as path2 from "path";
-var LOCKS_DIR = ".swarm/locks";
-var LOCK_TIMEOUT_MS = 5 * 60 * 1000;
 var _internals2 = {
-  tryAcquireLock,
-  writeFile: fs2.promises.writeFile
+  lstatSync: fs2.lstatSync
 };
-function getLockFilePath(directory, filePath) {
-  const normalized = path2.resolve(directory, filePath);
-  const baseDir = path2.resolve(directory) + path2.sep;
-  const pathOk = process.platform === "win32" ? normalized.toLowerCase().startsWith(baseDir.toLowerCase()) : normalized.startsWith(baseDir);
-  if (!pathOk) {
-    throw new Error("Invalid file path: path traversal not allowed");
-  }
-  const pathForHash = process.platform === "win32" ? normalized.toLowerCase() : normalized;
-  const hash = crypto.createHash("sha256").update(pathForHash).digest("hex");
-  const lockPath = path2.join(directory, LOCKS_DIR, `${hash}.lock`);
-  const legacyPaths = [pathForHash];
-  if (process.platform === "win32" && normalized !== pathForHash) {
-    legacyPaths.push(normalized);
-  }
-  for (const legacyPath of legacyPaths) {
-    const oldHash = Buffer.from(legacyPath).toString("base64").replace(/[/+=]/g, "_");
-    const oldLockPath = path2.join(directory, LOCKS_DIR, `${oldHash}.lock`);
-    if (fs2.existsSync(oldLockPath)) {
-      return oldLockPath;
-    }
-  }
-  return lockPath;
-}
-async function tryAcquireLock(directory, filePath, agent, taskId) {
-  const lockPath = getLockFilePath(directory, filePath);
-  const locksDir = path2.dirname(lockPath);
-  if (!fs2.existsSync(locksDir)) {
-    fs2.mkdirSync(locksDir, { recursive: true });
-  }
-  if (!fs2.existsSync(lockPath)) {
-    fs2.writeFileSync(lockPath, "", "utf-8");
-  }
-  let release;
-  try {
-    release = await import_proper_lockfile.default.lock(lockPath, {
-      stale: LOCK_TIMEOUT_MS,
-      retries: {
-        retries: 5,
-        minTimeout: 10,
-        maxTimeout: 500,
-        factor: 2
-      },
-      realpath: false
-    });
-  } catch (err) {
-    const code = err.code;
-    if (code === "ELOCKED" || code === "EEXIST") {
-      return { acquired: false };
-    }
-    throw err;
-  }
-  const lock = {
-    filePath,
-    agent,
-    taskId,
-    timestamp: new Date().toISOString(),
-    expiresAt: Date.now() + LOCK_TIMEOUT_MS,
-    _release: release
-  };
-  return { acquired: true, lock };
-}
 
 // src/evidence/lock.ts
 class EvidenceLockTimeoutError extends Error {