@probelabs/probe 0.6.0-rc141 → 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";
@@ -27922,17 +28105,20 @@ Search: query="${queries[0]}" path="${options.path}"`;
     if (options.session) logMessage += ` session=${options.session}`;
     console.error(logMessage);
   }
-  const positionalArgs = [];
+  const args = ["search", ...cliArgs];
   if (queries.length > 0) {
-    positionalArgs.push(escapeString(queries[0]));
+    args.push(queries[0]);
+  }
+  args.push(options.path);
+  if (process.env.DEBUG === "1") {
+    console.error(`Executing: ${binaryPath} ${args.join(" ")}`);
   }
-  positionalArgs.push(escapeString(options.path));
-  const command = `${binaryPath} search ${cliArgs.join(" ")} ${positionalArgs.join(" ")}`;
   try {
-    const { stdout, stderr } = await execAsync(command, {
-      shell: true,
-      timeout: options.timeout * 1e3
+    const { stdout, stderr } = await execFileAsync(binaryPath, args, {
+      timeout: options.timeout * 1e3,
       // Convert seconds to milliseconds
+      maxBuffer: 50 * 1024 * 1024
+      // 50MB buffer for large outputs
     });
     if (stderr && process.env.DEBUG) {
       console.error(`stderr: ${stderr}`);
@@ -27981,23 +28167,25 @@ Search results: ${resultCount} matches, ${tokenCount} tokens`;
   } catch (error2) {
     if (error2.code === "ETIMEDOUT" || error2.killed) {
       const timeoutMessage = `Search operation timed out after ${options.timeout} seconds.
-Command: ${command}`;
+Binary: ${binaryPath}
+Args: ${args.join(" ")}`;
       console.error(timeoutMessage);
       throw new Error(timeoutMessage);
     }
     const errorMessage = `Error executing search command: ${error2.message}
-Command: ${command}`;
+Binary: ${binaryPath}
+Args: ${args.join(" ")}`;
     throw new Error(errorMessage);
   }
 }
-var import_child_process2, import_util4, execAsync, SEARCH_FLAG_MAP;
+var import_child_process2, import_util4, execFileAsync, SEARCH_FLAG_MAP;
 var init_search = __esm({
   "src/search.js"() {
     "use strict";
     import_child_process2 = require("child_process");
     import_util4 = require("util");
     init_utils2();
-    execAsync = (0, import_util4.promisify)(import_child_process2.exec);
+    execFileAsync = (0, import_util4.promisify)(import_child_process2.execFile);
     SEARCH_FLAG_MAP = {
       filesOnly: "--files-only",
       ignore: "--ignore",
@@ -28005,6 +28193,7 @@ var init_search = __esm({
       reranker: "--reranker",
       frequencySearch: "--frequency",
       exact: "--exact",
+      strictElasticSyntax: "--strict-elastic-syntax",
       maxResults: "--max-results",
       maxBytes: "--max-bytes",
       maxTokens: "--max-tokens",
@@ -28042,7 +28231,7 @@ async function query(options) {
   }
   const command = `${binaryPath} query ${cliArgs.join(" ")}`;
   try {
-    const { stdout, stderr } = await execAsync2(command);
+    const { stdout, stderr } = await execAsync(command);
     if (stderr) {
       console.error(`stderr: ${stderr}`);
     }
@@ -28071,14 +28260,14 @@ Command: ${command}`;
     throw new Error(errorMessage);
   }
 }
-var import_child_process3, import_util5, execAsync2, QUERY_FLAG_MAP;
+var import_child_process3, import_util5, execAsync, QUERY_FLAG_MAP;
 var init_query = __esm({
   "src/query.js"() {
     "use strict";
     import_child_process3 = require("child_process");
     import_util5 = require("util");
     init_utils2();
-    execAsync2 = (0, import_util5.promisify)(import_child_process3.exec);
+    execAsync = (0, import_util5.promisify)(import_child_process3.exec);
     QUERY_FLAG_MAP = {
       language: "--language",
       ignore: "--ignore",
@@ -28131,7 +28320,7 @@ Extract:`;
   }
   const command = `${binaryPath} extract ${cliArgs.join(" ")}`;
   try {
-    const { stdout, stderr } = await execAsync3(command);
+    const { stdout, stderr } = await execAsync2(command);
     if (stderr) {
       console.error(`stderr: ${stderr}`);
     }
@@ -28229,14 +28418,14 @@ Token Usage:
   }
   return output;
 }
-var import_child_process4, import_util6, execAsync3, EXTRACT_FLAG_MAP;
+var import_child_process4, import_util6, execAsync2, EXTRACT_FLAG_MAP;
 var init_extract = __esm({
   "src/extract.js"() {
     "use strict";
     import_child_process4 = require("child_process");
     import_util6 = require("util");
     init_utils2();
-    execAsync3 = (0, import_util6.promisify)(import_child_process4.exec);
+    execAsync2 = (0, import_util6.promisify)(import_child_process4.exec);
     EXTRACT_FLAG_MAP = {
       allowTests: "--allow-tests",
       contextLines: "--context",
@@ -28247,14 +28436,14 @@ var init_extract = __esm({
 });
 
 // src/grep.js
-var import_child_process5, import_util7, execFileAsync;
+var import_child_process5, import_util7, execFileAsync2;
 var init_grep = __esm({
   "src/grep.js"() {
     "use strict";
     import_child_process5 = require("child_process");
     import_util7 = require("util");
     init_utils2();
-    execFileAsync = (0, import_util7.promisify)(import_child_process5.execFile);
+    execFileAsync2 = (0, import_util7.promisify)(import_child_process5.execFile);
   }
 });
 
@@ -34540,7 +34729,7 @@ async function listFilesByLevel(options) {
   return await listFilesByLevelManually(directory, maxFiles, respectGitignore);
 }
 async function listFilesUsingGit(directory, maxFiles) {
-  const { stdout } = await execAsync4("git ls-files", { cwd: directory });
+  const { stdout } = await execAsync3("git ls-files", { cwd: directory });
   const files = stdout.split("\n").filter(Boolean);
   const sortedFiles = files.sort((a3, b3) => {
     const depthA = a3.split(import_path6.default.sep).length;
@@ -34606,7 +34795,7 @@ function shouldIgnore(filePath, ignorePatterns) {
   }
   return false;
 }
-var import_fs2, import_path6, import_util11, import_child_process8, execAsync4;
+var import_fs2, import_path6, import_util11, import_child_process8, execAsync3;
 var init_file_lister = __esm({
   "src/utils/file-lister.js"() {
     "use strict";
@@ -34614,7 +34803,7 @@ var init_file_lister = __esm({
     import_path6 = __toESM(require("path"), 1);
     import_util11 = require("util");
     import_child_process8 = require("child_process");
-    execAsync4 = (0, import_util11.promisify)(import_child_process8.exec);
+    execAsync3 = (0, import_util11.promisify)(import_child_process8.exec);
   }
 });