@probelabs/probe 0.6.0-rc142 → 0.6.0-rc143

package/cjs/agent/ProbeAgent.cjs

@@ -27268,6 +27268,145 @@ var init_directory_resolver = __esm({
 });
 
 // src/downloader.js
+async function acquireFileLock(lockPath, version) {
+  const lockData = {
+    version,
+    pid: process.pid,
+    timestamp: Date.now()
+  };
+  try {
+    await import_fs_extra2.default.writeFile(lockPath, JSON.stringify(lockData), { flag: "wx" });
+    if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
+      console.log(`Acquired file lock: ${lockPath}`);
+    }
+    return true;
+  } catch (error2) {
+    if (error2.code === "EEXIST") {
+      try {
+        const existingLock = JSON.parse(await import_fs_extra2.default.readFile(lockPath, "utf-8"));
+        const lockAge = Date.now() - existingLock.timestamp;
+        if (lockAge > LOCK_TIMEOUT_MS) {
+          if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
+            console.log(`Removing stale lock file (age: ${Math.round(lockAge / 1e3)}s, pid: ${existingLock.pid})`);
+          }
+          await import_fs_extra2.default.remove(lockPath);
+          return false;
+        }
+        if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
+          console.log(`Download in progress by process ${existingLock.pid}, waiting...`);
+        }
+        return false;
+      } catch (readError) {
+        if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
+          console.log(`Lock file corrupted, removing: ${readError.message}`);
+        }
+        try {
+          await import_fs_extra2.default.remove(lockPath);
+        } catch {
+        }
+        return false;
+      }
+    }
+    if (error2.code === "EACCES" || error2.code === "EPERM" || error2.code === "EROFS") {
+      if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
+        console.log(`Cannot create lock file (${error2.code}): ${lockPath}`);
+        console.log(`File-based locking unavailable, will proceed without cross-process coordination`);
+      }
+      return null;
+    }
+    if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
+      console.log(`Unexpected error creating lock file: ${error2.message}`);
+      console.log(`Proceeding without file-based lock`);
+    }
+    return null;
+  }
+}
+async function releaseFileLock(lockPath) {
+  try {
+    await import_fs_extra2.default.remove(lockPath);
+    if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
+      console.log(`Released file lock: ${lockPath}`);
+    }
+  } catch (error2) {
+    if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
+      console.log(`Warning: Could not release lock file: ${error2.message}`);
+    }
+  }
+}
+async function waitForFileLock(lockPath, binaryPath) {
+  const startTime = Date.now();
+  while (Date.now() - startTime < MAX_LOCK_WAIT_MS) {
+    if (await import_fs_extra2.default.pathExists(binaryPath)) {
+      if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
+        console.log(`Binary now available at ${binaryPath}, download completed by another process`);
+      }
+      return true;
+    }
+    const lockExists = await import_fs_extra2.default.pathExists(lockPath);
+    if (!lockExists) {
+      if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
+        console.log(`Lock file removed but binary not found - download may have failed`);
+      }
+      return false;
+    }
+    try {
+      const lockData = JSON.parse(await import_fs_extra2.default.readFile(lockPath, "utf-8"));
+      const lockAge = Date.now() - lockData.timestamp;
+      if (lockAge > LOCK_TIMEOUT_MS) {
+        if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
+          console.log(`Lock expired (age: ${Math.round(lockAge / 1e3)}s), will retry download`);
+        }
+        return false;
+      }
+    } catch {
+    }
+    await new Promise((resolve4) => setTimeout(resolve4, LOCK_POLL_INTERVAL_MS));
+  }
+  if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
+    console.log(`Timeout waiting for file lock`);
+  }
+  return false;
+}
+async function withDownloadLock(version, downloadFn) {
+  const lockKey = version || "latest";
+  if (downloadLocks.has(lockKey)) {
+    const lock = downloadLocks.get(lockKey);
+    const lockAge = Date.now() - lock.timestamp;
+    if (lockAge > LOCK_TIMEOUT_MS) {
+      if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
+        console.log(`In-memory lock for version ${lockKey} expired (age: ${Math.round(lockAge / 1e3)}s), removing stale lock`);
+      }
+      downloadLocks.delete(lockKey);
+    } else {
+      if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
+        console.log(`Download already in progress in this process for version ${lockKey}, waiting...`);
+      }
+      try {
+        return await lock.promise;
+      } catch (error2) {
+        if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
+          console.log(`In-memory locked download failed, will retry: ${error2.message}`);
+        }
+      }
+    }
+  }
+  const downloadPromise = Promise.race([
+    downloadFn(),
+    new Promise(
+      (_2, reject2) => setTimeout(() => reject2(new Error(`Download timeout after ${LOCK_TIMEOUT_MS / 1e3}s`)), LOCK_TIMEOUT_MS)
+    )
+  ]);
+  downloadLocks.set(lockKey, {
+    promise: downloadPromise,
+    timestamp: Date.now()
+  });
+  try {
+    const result = await downloadPromise;
+    return result;
+  } finally {
+    downloadLocks.delete(lockKey);
+  }
+}
 function detectOsArch() {
   const osType = import_os2.default.platform();
   const archType = import_os2.default.arch();
@@ -27711,16 +27850,64 @@ async function getPackageVersion() {
     return "0.0.0";
   }
 }
+async function doDownload(version) {
+  const localDir = await getPackageBinDir();
+  if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
+    console.log(`Downloading probe binary (version: ${version || "latest"})...`);
+    console.log(`Using binary directory: ${localDir}`);
+  }
+  const isWindows = import_os2.default.platform() === "win32";
+  const binaryName = isWindows ? `${BINARY_NAME}.exe` : `${BINARY_NAME}-binary`;
+  const binaryPath = import_path2.default.join(localDir, binaryName);
+  const { os: osInfo, arch: archInfo } = detectOsArch();
+  let versionToUse = version;
+  let bestAsset;
+  let tagVersion;
+  if (!versionToUse || versionToUse === "0.0.0") {
+    if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
+      console.log("No specific version requested, will use the latest release");
+    }
+    const { tag: tag2, assets } = await getLatestRelease(void 0);
+    tagVersion = tag2.startsWith("v") ? tag2.substring(1) : tag2;
+    bestAsset = findBestAsset(assets, osInfo, archInfo);
+    if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
+      console.log(`Found release version: ${tagVersion}`);
+    }
+  } else {
+    if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
+      console.log(`Direct download for version: ${versionToUse}`);
+    }
+    tagVersion = versionToUse;
+    bestAsset = constructAssetInfo(versionToUse, osInfo, archInfo);
+  }
+  const { assetPath, checksumPath } = await downloadAsset(bestAsset, localDir);
+  const checksumValid = await verifyChecksum(assetPath, checksumPath);
+  if (!checksumValid) {
+    throw new Error("Checksum verification failed");
+  }
+  const extractedBinaryPath = await extractBinary(assetPath, localDir);
+  await saveVersionInfo(tagVersion, localDir);
+  try {
+    await import_fs_extra2.default.remove(assetPath);
+    if (checksumPath) {
+      await import_fs_extra2.default.remove(checksumPath);
+    }
+  } catch (err) {
+    if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
+      console.log(`Warning: Could not clean up temporary files: ${err}`);
+    }
+  }
+  if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
+    console.log(`Binary successfully installed at ${extractedBinaryPath} (version: ${tagVersion})`);
+  }
+  return extractedBinaryPath;
+}
 async function downloadProbeBinary(version) {
   try {
     const localDir = await getPackageBinDir();
     if (!version || version === "0.0.0") {
       version = await getPackageVersion();
     }
-    if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
-      console.log(`Downloading probe binary (version: ${version || "latest"})...`);
-      console.log(`Using binary directory: ${localDir}`);
-    }
     const isWindows = import_os2.default.platform() === "win32";
     const binaryName = isWindows ? `${BINARY_NAME}.exe` : `${BINARY_NAME}-binary`;
     const binaryPath = import_path2.default.join(localDir, binaryName);
@@ -27736,54 +27923,44 @@ async function downloadProbeBinary(version) {
         console.log(`Existing binary version (${versionInfo?.version || "unknown"}) doesn't match requested version (${version}). Downloading new version...`);
       }
     }
-    const { os: osInfo, arch: archInfo } = detectOsArch();
-    let versionToUse = version;
-    let bestAsset;
-    let tagVersion;
-    if (!versionToUse || versionToUse === "0.0.0") {
-      if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
-        console.log("No specific version requested, will use the latest release");
-      }
-      const { tag: tag2, assets } = await getLatestRelease(void 0);
-      tagVersion = tag2.startsWith("v") ? tag2.substring(1) : tag2;
-      bestAsset = findBestAsset(assets, osInfo, archInfo);
-      if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
-        console.log(`Found release version: ${tagVersion}`);
+    const lockPath = import_path2.default.join(localDir, `.probe-download-${version}.lock`);
+    const maxRetries = 3;
+    for (let retry = 0; retry < maxRetries; retry++) {
+      const lockAcquired = await acquireFileLock(lockPath, version);
+      if (lockAcquired === true) {
+        try {
+          const result = await withDownloadLock(version, () => doDownload(version));
+          return result;
+        } finally {
+          await releaseFileLock(lockPath);
+        }
       }
-    } else {
-      if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
-        console.log(`Direct download for version: ${versionToUse}`);
+      if (lockAcquired === null) {
+        if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
+          console.log(`File-based locking unavailable, downloading without cross-process coordination`);
+        }
+        return await withDownloadLock(version, () => doDownload(version));
       }
-      tagVersion = versionToUse;
-      bestAsset = constructAssetInfo(versionToUse, osInfo, archInfo);
-    }
-    const { assetPath, checksumPath } = await downloadAsset(bestAsset, localDir);
-    const checksumValid = await verifyChecksum(assetPath, checksumPath);
-    if (!checksumValid) {
-      throw new Error("Checksum verification failed");
-    }
-    const extractedBinaryPath = await extractBinary(assetPath, localDir);
-    await saveVersionInfo(tagVersion, localDir);
-    try {
-      await import_fs_extra2.default.remove(assetPath);
-      if (checksumPath) {
-        await import_fs_extra2.default.remove(checksumPath);
+      const downloadCompleted = await waitForFileLock(lockPath, binaryPath);
+      if (downloadCompleted) {
+        return binaryPath;
       }
-    } catch (err) {
-      if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
-        console.log(`Warning: Could not clean up temporary files: ${err}`);
+      if (retry < maxRetries - 1) {
+        if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
+          console.log(`Retrying download (attempt ${retry + 2}/${maxRetries})...`);
+        }
       }
     }
     if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
-      console.log(`Binary successfully installed at ${extractedBinaryPath} (version: ${tagVersion})`);
+      console.log(`All lock attempts exhausted, attempting direct download`);
     }
-    return extractedBinaryPath;
+    return await withDownloadLock(version, () => doDownload(version));
   } catch (error2) {
     console.error("Error downloading probe binary:", error2);
     throw error2;
   }
 }
-var import_axios, import_fs_extra2, import_path2, import_crypto, import_util3, import_child_process, import_tar, import_os2, import_url2, exec, REPO_OWNER, REPO_NAME, BINARY_NAME, __filename2, __dirname2;
+var import_axios, import_fs_extra2, import_path2, import_crypto, import_util3, import_child_process, import_tar, import_os2, import_url2, exec, REPO_OWNER, REPO_NAME, BINARY_NAME, __filename2, __dirname2, downloadLocks, LOCK_TIMEOUT_MS, LOCK_POLL_INTERVAL_MS, MAX_LOCK_WAIT_MS;
 var init_downloader = __esm({
   "src/downloader.js"() {
     "use strict";
@@ -27804,19 +27981,25 @@ var init_downloader = __esm({
     BINARY_NAME = "probe";
     __filename2 = (0, import_url2.fileURLToPath)("file:///");
     __dirname2 = import_path2.default.dirname(__filename2);
+    downloadLocks = /* @__PURE__ */ new Map();
+    LOCK_TIMEOUT_MS = 5 * 60 * 1e3;
+    LOCK_POLL_INTERVAL_MS = 1e3;
+    MAX_LOCK_WAIT_MS = 5 * 60 * 1e3;
   }
 });
 
 // src/utils.js
 async function getBinaryPath(options = {}) {
   const { forceDownload = false, version } = options;
-  if (probeBinaryPath && !forceDownload && import_fs_extra3.default.existsSync(probeBinaryPath)) {
-    return probeBinaryPath;
-  }
   if (process.env.PROBE_PATH && import_fs_extra3.default.existsSync(process.env.PROBE_PATH) && !forceDownload) {
     probeBinaryPath = process.env.PROBE_PATH;
     return probeBinaryPath;
   }
+  if (version && !forceDownload) {
+    console.log(`Specific version ${version} requested. Downloading...`);
+    probeBinaryPath = await downloadProbeBinary(version);
+    return probeBinaryPath;
+  }
   const binDir = await getPackageBinDir();
   const isWindows = process.platform === "win32";
   const binaryName = isWindows ? "probe.exe" : "probe-binary";

package/cjs/index.cjs

@@ -206,6 +206,145 @@ var init_directory_resolver = __esm({
 });
 
 // src/downloader.js
+async function acquireFileLock(lockPath, version) {
+  const lockData = {
+    version,
+    pid: process.pid,
+    timestamp: Date.now()
+  };
+  try {
+    await import_fs_extra2.default.writeFile(lockPath, JSON.stringify(lockData), { flag: "wx" });
+    if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
+      console.log(`Acquired file lock: ${lockPath}`);
+    }
+    return true;
+  } catch (error2) {
+    if (error2.code === "EEXIST") {
+      try {
+        const existingLock = JSON.parse(await import_fs_extra2.default.readFile(lockPath, "utf-8"));
+        const lockAge = Date.now() - existingLock.timestamp;
+        if (lockAge > LOCK_TIMEOUT_MS) {
+          if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
+            console.log(`Removing stale lock file (age: ${Math.round(lockAge / 1e3)}s, pid: ${existingLock.pid})`);
+          }
+          await import_fs_extra2.default.remove(lockPath);
+          return false;
+        }
+        if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
+          console.log(`Download in progress by process ${existingLock.pid}, waiting...`);
+        }
+        return false;
+      } catch (readError) {
+        if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
+          console.log(`Lock file corrupted, removing: ${readError.message}`);
+        }
+        try {
+          await import_fs_extra2.default.remove(lockPath);
+        } catch {
+        }
+        return false;
+      }
+    }
+    if (error2.code === "EACCES" || error2.code === "EPERM" || error2.code === "EROFS") {
+      if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
+        console.log(`Cannot create lock file (${error2.code}): ${lockPath}`);
+        console.log(`File-based locking unavailable, will proceed without cross-process coordination`);
+      }
+      return null;
+    }
+    if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
+      console.log(`Unexpected error creating lock file: ${error2.message}`);
+      console.log(`Proceeding without file-based lock`);
+    }
+    return null;
+  }
+}
+async function releaseFileLock(lockPath) {
+  try {
+    await import_fs_extra2.default.remove(lockPath);
+    if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
+      console.log(`Released file lock: ${lockPath}`);
+    }
+  } catch (error2) {
+    if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
+      console.log(`Warning: Could not release lock file: ${error2.message}`);
+    }
+  }
+}
+async function waitForFileLock(lockPath, binaryPath) {
+  const startTime = Date.now();
+  while (Date.now() - startTime < MAX_LOCK_WAIT_MS) {
+    if (await import_fs_extra2.default.pathExists(binaryPath)) {
+      if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
+        console.log(`Binary now available at ${binaryPath}, download completed by another process`);
+      }
+      return true;
+    }
+    const lockExists = await import_fs_extra2.default.pathExists(lockPath);
+    if (!lockExists) {
+      if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
+        console.log(`Lock file removed but binary not found - download may have failed`);
+      }
+      return false;
+    }
+    try {
+      const lockData = JSON.parse(await import_fs_extra2.default.readFile(lockPath, "utf-8"));
+      const lockAge = Date.now() - lockData.timestamp;
+      if (lockAge > LOCK_TIMEOUT_MS) {
+        if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
+          console.log(`Lock expired (age: ${Math.round(lockAge / 1e3)}s), will retry download`);
+        }
+        return false;
+      }
+    } catch {
+    }
+    await new Promise((resolve4) => setTimeout(resolve4, LOCK_POLL_INTERVAL_MS));
+  }
+  if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
+    console.log(`Timeout waiting for file lock`);
+  }
+  return false;
+}
+async function withDownloadLock(version, downloadFn) {
+  const lockKey = version || "latest";
+  if (downloadLocks.has(lockKey)) {
+    const lock = downloadLocks.get(lockKey);
+    const lockAge = Date.now() - lock.timestamp;
+    if (lockAge > LOCK_TIMEOUT_MS) {
+      if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
+        console.log(`In-memory lock for version ${lockKey} expired (age: ${Math.round(lockAge / 1e3)}s), removing stale lock`);
+      }
+      downloadLocks.delete(lockKey);
+    } else {
+      if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
+        console.log(`Download already in progress in this process for version ${lockKey}, waiting...`);
+      }
+      try {
+        return await lock.promise;
+      } catch (error2) {
+        if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
+          console.log(`In-memory locked download failed, will retry: ${error2.message}`);
+        }
+      }
+    }
+  }
+  const downloadPromise = Promise.race([
+    downloadFn(),
+    new Promise(
+      (_2, reject2) => setTimeout(() => reject2(new Error(`Download timeout after ${LOCK_TIMEOUT_MS / 1e3}s`)), LOCK_TIMEOUT_MS)
+    )
+  ]);
+  downloadLocks.set(lockKey, {
+    promise: downloadPromise,
+    timestamp: Date.now()
+  });
+  try {
+    const result = await downloadPromise;
+    return result;
+  } finally {
+    downloadLocks.delete(lockKey);
+  }
+}
 function detectOsArch() {
   const osType = import_os2.default.platform();
   const archType = import_os2.default.arch();
@@ -649,16 +788,64 @@ async function getPackageVersion() {
     return "0.0.0";
   }
 }
+async function doDownload(version) {
+  const localDir = await getPackageBinDir();
+  if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
+    console.log(`Downloading probe binary (version: ${version || "latest"})...`);
+    console.log(`Using binary directory: ${localDir}`);
+  }
+  const isWindows = import_os2.default.platform() === "win32";
+  const binaryName = isWindows ? `${BINARY_NAME}.exe` : `${BINARY_NAME}-binary`;
+  const binaryPath = import_path2.default.join(localDir, binaryName);
+  const { os: osInfo, arch: archInfo } = detectOsArch();
+  let versionToUse = version;
+  let bestAsset;
+  let tagVersion;
+  if (!versionToUse || versionToUse === "0.0.0") {
+    if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
+      console.log("No specific version requested, will use the latest release");
+    }
+    const { tag: tag2, assets } = await getLatestRelease(void 0);
+    tagVersion = tag2.startsWith("v") ? tag2.substring(1) : tag2;
+    bestAsset = findBestAsset(assets, osInfo, archInfo);
+    if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
+      console.log(`Found release version: ${tagVersion}`);
+    }
+  } else {
+    if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
+      console.log(`Direct download for version: ${versionToUse}`);
+    }
+    tagVersion = versionToUse;
+    bestAsset = constructAssetInfo(versionToUse, osInfo, archInfo);
+  }
+  const { assetPath, checksumPath } = await downloadAsset(bestAsset, localDir);
+  const checksumValid = await verifyChecksum(assetPath, checksumPath);
+  if (!checksumValid) {
+    throw new Error("Checksum verification failed");
+  }
+  const extractedBinaryPath = await extractBinary(assetPath, localDir);
+  await saveVersionInfo(tagVersion, localDir);
+  try {
+    await import_fs_extra2.default.remove(assetPath);
+    if (checksumPath) {
+      await import_fs_extra2.default.remove(checksumPath);
+    }
+  } catch (err) {
+    if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
+      console.log(`Warning: Could not clean up temporary files: ${err}`);
+    }
+  }
+  if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
+    console.log(`Binary successfully installed at ${extractedBinaryPath} (version: ${tagVersion})`);
+  }
+  return extractedBinaryPath;
+}
 async function downloadProbeBinary(version) {
   try {
     const localDir = await getPackageBinDir();
     if (!version || version === "0.0.0") {
       version = await getPackageVersion();
     }
-    if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
-      console.log(`Downloading probe binary (version: ${version || "latest"})...`);
-      console.log(`Using binary directory: ${localDir}`);
-    }
     const isWindows = import_os2.default.platform() === "win32";
     const binaryName = isWindows ? `${BINARY_NAME}.exe` : `${BINARY_NAME}-binary`;
     const binaryPath = import_path2.default.join(localDir, binaryName);
@@ -674,54 +861,44 @@ async function downloadProbeBinary(version) {
         console.log(`Existing binary version (${versionInfo?.version || "unknown"}) doesn't match requested version (${version}). Downloading new version...`);
       }
     }
-    const { os: osInfo, arch: archInfo } = detectOsArch();
-    let versionToUse = version;
-    let bestAsset;
-    let tagVersion;
-    if (!versionToUse || versionToUse === "0.0.0") {
-      if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
-        console.log("No specific version requested, will use the latest release");
-      }
-      const { tag: tag2, assets } = await getLatestRelease(void 0);
-      tagVersion = tag2.startsWith("v") ? tag2.substring(1) : tag2;
-      bestAsset = findBestAsset(assets, osInfo, archInfo);
-      if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
-        console.log(`Found release version: ${tagVersion}`);
+    const lockPath = import_path2.default.join(localDir, `.probe-download-${version}.lock`);
+    const maxRetries = 3;
+    for (let retry = 0; retry < maxRetries; retry++) {
+      const lockAcquired = await acquireFileLock(lockPath, version);
+      if (lockAcquired === true) {
+        try {
+          const result = await withDownloadLock(version, () => doDownload(version));
+          return result;
+        } finally {
+          await releaseFileLock(lockPath);
+        }
       }
-    } else {
-      if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
-        console.log(`Direct download for version: ${versionToUse}`);
+      if (lockAcquired === null) {
+        if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
+          console.log(`File-based locking unavailable, downloading without cross-process coordination`);
+        }
+        return await withDownloadLock(version, () => doDownload(version));
       }
-      tagVersion = versionToUse;
-      bestAsset = constructAssetInfo(versionToUse, osInfo, archInfo);
-    }
-    const { assetPath, checksumPath } = await downloadAsset(bestAsset, localDir);
-    const checksumValid = await verifyChecksum(assetPath, checksumPath);
-    if (!checksumValid) {
-      throw new Error("Checksum verification failed");
-    }
-    const extractedBinaryPath = await extractBinary(assetPath, localDir);
-    await saveVersionInfo(tagVersion, localDir);
-    try {
-      await import_fs_extra2.default.remove(assetPath);
-      if (checksumPath) {
-        await import_fs_extra2.default.remove(checksumPath);
+      const downloadCompleted = await waitForFileLock(lockPath, binaryPath);
+      if (downloadCompleted) {
+        return binaryPath;
       }
-    } catch (err) {
-      if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
-        console.log(`Warning: Could not clean up temporary files: ${err}`);
+      if (retry < maxRetries - 1) {
+        if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
+          console.log(`Retrying download (attempt ${retry + 2}/${maxRetries})...`);
+        }
       }
     }
     if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
-      console.log(`Binary successfully installed at ${extractedBinaryPath} (version: ${tagVersion})`);
+      console.log(`All lock attempts exhausted, attempting direct download`);
     }
-    return extractedBinaryPath;
+    return await withDownloadLock(version, () => doDownload(version));
   } catch (error2) {
     console.error("Error downloading probe binary:", error2);
     throw error2;
   }
 }
-var import_axios, import_fs_extra2, import_path2, import_crypto, import_util, import_child_process, import_tar, import_os2, import_url2, exec, REPO_OWNER, REPO_NAME, BINARY_NAME, __filename2, __dirname2;
+var import_axios, import_fs_extra2, import_path2, import_crypto, import_util, import_child_process, import_tar, import_os2, import_url2, exec, REPO_OWNER, REPO_NAME, BINARY_NAME, __filename2, __dirname2, downloadLocks, LOCK_TIMEOUT_MS, LOCK_POLL_INTERVAL_MS, MAX_LOCK_WAIT_MS;
 var init_downloader = __esm({
   "src/downloader.js"() {
     "use strict";
@@ -742,19 +919,25 @@ var init_downloader = __esm({
     BINARY_NAME = "probe";
     __filename2 = (0, import_url2.fileURLToPath)("file:///");
     __dirname2 = import_path2.default.dirname(__filename2);
+    downloadLocks = /* @__PURE__ */ new Map();
+    LOCK_TIMEOUT_MS = 5 * 60 * 1e3;
+    LOCK_POLL_INTERVAL_MS = 1e3;
+    MAX_LOCK_WAIT_MS = 5 * 60 * 1e3;
   }
 });
 
 // src/utils.js
 async function getBinaryPath(options = {}) {
   const { forceDownload = false, version } = options;
-  if (probeBinaryPath && !forceDownload && import_fs_extra3.default.existsSync(probeBinaryPath)) {
-    return probeBinaryPath;
-  }
   if (process.env.PROBE_PATH && import_fs_extra3.default.existsSync(process.env.PROBE_PATH) && !forceDownload) {
     probeBinaryPath = process.env.PROBE_PATH;
     return probeBinaryPath;
   }
+  if (version && !forceDownload) {
+    console.log(`Specific version ${version} requested. Downloading...`);
+    probeBinaryPath = await downloadProbeBinary(version);
+    return probeBinaryPath;
+  }
   const binDir = await getPackageBinDir();
   const isWindows = process.platform === "win32";
   const binaryName = isWindows ? "probe.exe" : "probe-binary";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@probelabs/probe",
-  "version": "0.6.0-rc142",
+  "version": "0.6.0-rc143",
   "description": "Node.js wrapper for the probe code search tool",
   "main": "src/index.js",
   "module": "src/index.js",