@probelabs/probe 0.6.0-rc141 → 0.6.0-rc143

package/build/agent/index.js

@@ -1876,6 +1876,145 @@ import { exec as execCallback } from "child_process";
 import tar from "tar";
 import os2 from "os";
 import { fileURLToPath as fileURLToPath2 } from "url";
+async function acquireFileLock(lockPath, version) {
+  const lockData = {
+    version,
+    pid: process.pid,
+    timestamp: Date.now()
+  };
+  try {
+    await fs2.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 (error) {
+    if (error.code === "EEXIST") {
+      try {
+        const existingLock = JSON.parse(await fs2.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 fs2.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 fs2.remove(lockPath);
+        } catch {
+        }
+        return false;
+      }
+    }
+    if (error.code === "EACCES" || error.code === "EPERM" || error.code === "EROFS") {
+      if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
+        console.log(`Cannot create lock file (${error.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: ${error.message}`);
+      console.log(`Proceeding without file-based lock`);
+    }
+    return null;
+  }
+}
+async function releaseFileLock(lockPath) {
+  try {
+    await fs2.remove(lockPath);
+    if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
+      console.log(`Released file lock: ${lockPath}`);
+    }
+  } catch (error) {
+    if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
+      console.log(`Warning: Could not release lock file: ${error.message}`);
+    }
+  }
+}
+async function waitForFileLock(lockPath, binaryPath) {
+  const startTime = Date.now();
+  while (Date.now() - startTime < MAX_LOCK_WAIT_MS) {
+    if (await fs2.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 fs2.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 fs2.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((resolve5) => setTimeout(resolve5, 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 (error) {
+        if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
+          console.log(`In-memory locked download failed, will retry: ${error.message}`);
+        }
+      }
+    }
+  }
+  const downloadPromise = Promise.race([
+    downloadFn(),
+    new Promise(
+      (_, 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 = os2.platform();
   const archType = os2.arch();
@@ -2319,16 +2458,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 = os2.platform() === "win32";
+  const binaryName = isWindows ? `${BINARY_NAME}.exe` : `${BINARY_NAME}-binary`;
+  const binaryPath = path2.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, assets } = await getLatestRelease(void 0);
+    tagVersion = tag.startsWith("v") ? tag.substring(1) : tag;
+    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 fs2.remove(assetPath);
+    if (checksumPath) {
+      await fs2.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 = os2.platform() === "win32";
     const binaryName = isWindows ? `${BINARY_NAME}.exe` : `${BINARY_NAME}-binary`;
     const binaryPath = path2.join(localDir, binaryName);
@@ -2344,54 +2531,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, assets } = await getLatestRelease(void 0);
-      tagVersion = tag.startsWith("v") ? tag.substring(1) : tag;
-      bestAsset = findBestAsset(assets, osInfo, archInfo);
-      if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
-        console.log(`Found release version: ${tagVersion}`);
+    const lockPath = path2.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 fs2.remove(assetPath);
-      if (checksumPath) {
-        await fs2.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 (error) {
     console.error("Error downloading probe binary:", error);
     throw error;
   }
 }
-var exec, REPO_OWNER, REPO_NAME, BINARY_NAME, __filename2, __dirname2;
+var 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";
@@ -2403,6 +2580,10 @@ var init_downloader = __esm({
     BINARY_NAME = "probe";
     __filename2 = fileURLToPath2(import.meta.url);
     __dirname2 = path2.dirname(__filename2);
+    downloadLocks = /* @__PURE__ */ new Map();
+    LOCK_TIMEOUT_MS = 5 * 60 * 1e3;
+    LOCK_POLL_INTERVAL_MS = 1e3;
+    MAX_LOCK_WAIT_MS = 5 * 60 * 1e3;
   }
 });
 
@@ -2412,13 +2593,15 @@ import fs3 from "fs-extra";
 import { fileURLToPath as fileURLToPath3 } from "url";
 async function getBinaryPath(options = {}) {
   const { forceDownload = false, version } = options;
-  if (probeBinaryPath && !forceDownload && fs3.existsSync(probeBinaryPath)) {
-    return probeBinaryPath;
-  }
   if (process.env.PROBE_PATH && fs3.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";
@@ -2471,7 +2654,7 @@ var init_utils = __esm({
 });
 
 // src/search.js
-import { exec as exec2 } from "child_process";
+import { execFile } from "child_process";
 import { promisify as promisify2 } from "util";
 async function search(options) {
   if (!options || !options.path) {
@@ -2523,17 +2706,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}`);
@@ -2582,21 +2768,23 @@ Search results: ${resultCount} matches, ${tokenCount} tokens`;
   } catch (error) {
     if (error.code === "ETIMEDOUT" || error.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: ${error.message}
-Command: ${command}`;
+Binary: ${binaryPath}
+Args: ${args.join(" ")}`;
     throw new Error(errorMessage);
   }
 }
-var execAsync, SEARCH_FLAG_MAP;
+var execFileAsync, SEARCH_FLAG_MAP;
 var init_search = __esm({
   "src/search.js"() {
     "use strict";
     init_utils();
-    execAsync = promisify2(exec2);
+    execFileAsync = promisify2(execFile);
     SEARCH_FLAG_MAP = {
       filesOnly: "--files-only",
       ignore: "--ignore",
@@ -2604,6 +2792,7 @@ var init_search = __esm({
       reranker: "--reranker",
       frequencySearch: "--frequency",
       exact: "--exact",
+      strictElasticSyntax: "--strict-elastic-syntax",
       maxResults: "--max-results",
       maxBytes: "--max-bytes",
       maxTokens: "--max-tokens",
@@ -2619,7 +2808,7 @@ var init_search = __esm({
 });
 
 // src/query.js
-import { exec as exec3 } from "child_process";
+import { exec as exec2 } from "child_process";
 import { promisify as promisify3 } from "util";
 async function query(options) {
   if (!options || !options.path) {
@@ -2643,7 +2832,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}`);
     }
@@ -2672,12 +2861,12 @@ Command: ${command}`;
     throw new Error(errorMessage);
   }
 }
-var execAsync2, QUERY_FLAG_MAP;
+var execAsync, QUERY_FLAG_MAP;
 var init_query = __esm({
   "src/query.js"() {
     "use strict";
     init_utils();
-    execAsync2 = promisify3(exec3);
+    execAsync = promisify3(exec2);
     QUERY_FLAG_MAP = {
       language: "--language",
       ignore: "--ignore",
@@ -2689,7 +2878,7 @@ var init_query = __esm({
 });
 
 // src/extract.js
-import { exec as exec4, spawn } from "child_process";
+import { exec as exec3, spawn } from "child_process";
 import { promisify as promisify4 } from "util";
 async function extract(options) {
   if (!options) {
@@ -2732,7 +2921,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}`);
     }
@@ -2830,12 +3019,12 @@ Token Usage:
   }
   return output;
 }
-var execAsync3, EXTRACT_FLAG_MAP;
+var execAsync2, EXTRACT_FLAG_MAP;
 var init_extract = __esm({
   "src/extract.js"() {
     "use strict";
     init_utils();
-    execAsync3 = promisify4(exec4);
+    execAsync2 = promisify4(exec3);
     EXTRACT_FLAG_MAP = {
       allowTests: "--allow-tests",
       contextLines: "--context",
@@ -2846,14 +3035,14 @@ var init_extract = __esm({
 });
 
 // src/grep.js
-import { execFile } from "child_process";
+import { execFile as execFile2 } from "child_process";
 import { promisify as promisify5 } from "util";
-var execFileAsync;
+var execFileAsync2;
 var init_grep = __esm({
   "src/grep.js"() {
     "use strict";
     init_utils();
-    execFileAsync = promisify5(execFile);
+    execFileAsync2 = promisify5(execFile2);
   }
 });
 
@@ -9119,7 +9308,7 @@ var init_tools = __esm({
 import fs4 from "fs";
 import path4 from "path";
 import { promisify as promisify6 } from "util";
-import { exec as exec5 } from "child_process";
+import { exec as exec4 } from "child_process";
 async function listFilesByLevel(options) {
   const {
     directory,
@@ -9141,7 +9330,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((a, b) => {
     const depthA = a.split(path4.sep).length;
@@ -9207,11 +9396,11 @@ function shouldIgnore(filePath, ignorePatterns) {
   }
   return false;
 }
-var execAsync4;
+var execAsync3;
 var init_file_lister = __esm({
   "src/utils/file-lister.js"() {
     "use strict";
-    execAsync4 = promisify6(exec5);
+    execAsync3 = promisify6(exec4);
   }
 });
 
@@ -16149,7 +16338,7 @@ var init_esm5 = __esm({
 });
 
 // src/agent/probeTool.js
-import { exec as exec6 } from "child_process";
+import { exec as exec5 } from "child_process";
 import { promisify as promisify7 } from "util";
 import { randomUUID as randomUUID2 } from "crypto";
 import { EventEmitter as EventEmitter2 } from "events";