@probelabs/probe 0.6.0-rc154 → 0.6.0-rc159

package/src/downloader.js

@@ -17,6 +17,35 @@ import { getPackageBinDir } from './directory-resolver.js';
 
 const exec = promisify(execCallback);
 
+/**
+ * Create a plain, serializable Error from possibly complex/circular errors (e.g., axios)
+ * Avoids passing circular req/res objects to IPC serializers and test runners.
+ */
+function sanitizeError(err) {
+    try {
+        const status = err?.response?.status;
+        const statusText = err?.response?.statusText;
+        const url = err?.config?.url || err?.response?.config?.url;
+        const code = err?.code;
+        const serverMsg = typeof err?.response?.data === 'string'
+            ? err.response.data.slice(0, 500)
+            : (typeof err?.response?.data?.message === 'string' ? err.response.data.message : undefined);
+        const base = err?.message || String(err);
+        const parts = [base];
+        if (status || statusText) parts.push(`[${(status ?? '')} ${(statusText ?? '')}]`.trim());
+        if (code) parts.push(`code=${code}`);
+        if (url) parts.push(`url=${url}`);
+        if (serverMsg) parts.push(`server="${String(serverMsg).replace(/\s+/g, ' ').trim()}"`);
+        const e = new Error(parts.filter(Boolean).join(' '));
+        if (status) e.status = status;
+        if (code) e.code = code;
+        if (url) e.url = url;
+        return e;
+    } catch (_) {
+        return new Error(err?.message || String(err));
+    }
+}
+
 // GitHub repository information
 const REPO_OWNER = "probelabs";
 const REPO_NAME = "probe";
@@ -69,7 +98,7 @@ async function acquireFileLock(lockPath, version) {
 			console.log(`Acquired file lock: ${lockPath}`);
 		}
 		return true;
-	} catch (error) {
+    } catch (error) {
 		if (error.code === 'EEXIST') {
 			// Lock file exists - check if it's stale
 			try {
@@ -265,13 +294,13 @@ function detectOsArch() {
 	let archInfo;
 
 	// Detect OS
-	switch (osType) {
-		case 'linux':
-			osInfo = {
-				type: 'linux',
-				keywords: ['linux', 'Linux', 'gnu']
-			};
-			break;
+    switch (osType) {
+        case 'linux':
+            osInfo = {
+                type: 'linux',
+                keywords: ['linux', 'Linux', 'musl', 'gnu']
+            };
+            break;
 		case 'darwin':
 			osInfo = {
 				type: 'darwin',
@@ -324,11 +353,11 @@ function constructAssetInfo(version, osInfo, archInfo) {
 	let extension;
 	
 	// Map OS and arch to the expected format in release names
-	switch (osInfo.type) {
-		case 'linux':
-			platform = `${archInfo.type}-unknown-linux-gnu`;
-			extension = 'tar.gz';
-			break;
+    switch (osInfo.type) {
+        case 'linux':
+            platform = `${archInfo.type}-unknown-linux-musl`;
+            extension = 'tar.gz';
+            break;
 		case 'darwin':
 			platform = `${archInfo.type}-apple-darwin`;
 			extension = 'tar.gz';
@@ -482,7 +511,7 @@ async function getLatestRelease(version) {
 			return { tag, assets };
 		}
 
-		throw error;
+		throw sanitizeError(error);
 	}
 }
 
@@ -787,7 +816,7 @@ async function extractBinary(assetPath, outputDir) {
 		return binaryPath;
 	} catch (error) {
 		console.error(`Error extracting binary: ${error instanceof Error ? error.message : String(error)}`);
-		throw error;
+		throw sanitizeError(error);
 	}
 }
 
@@ -1032,7 +1061,7 @@ export async function downloadProbeBinary(version) {
 		}
 		return await withDownloadLock(version, () => doDownload(version));
 	} catch (error) {
-		console.error('Error downloading probe binary:', error);
-		throw error;
+		console.error('Error downloading probe binary:', error?.message || String(error));
+		throw sanitizeError(error);
 	}
 }

package/src/extractor.js

@@ -27,16 +27,16 @@ function detectPlatform() {
 	let extension;
 
 	// Map to the same format used in release artifacts
-	if (osType === 'linux') {
-		if (archType === 'x64') {
-			platform = 'x86_64-unknown-linux-gnu';
-			extension = 'tar.gz';
-		} else if (archType === 'arm64') {
-			platform = 'aarch64-unknown-linux-gnu';
-			extension = 'tar.gz';
-		} else {
-			throw new Error(`Unsupported Linux architecture: ${archType}`);
-		}
+    if (osType === 'linux') {
+        if (archType === 'x64') {
+            platform = 'x86_64-unknown-linux-musl';
+            extension = 'tar.gz';
+        } else if (archType === 'arm64') {
+            platform = 'aarch64-unknown-linux-musl';
+            extension = 'tar.gz';
+        } else {
+            throw new Error(`Unsupported Linux architecture: ${archType}`);
+        }
 	} else if (osType === 'darwin') {
 		if (archType === 'x64') {
 			platform = 'x86_64-apple-darwin';
@@ -191,8 +191,8 @@ export async function extractBundledBinary(version) {
 			`Searched in: ${binariesDir}\n` +
 			`\n` +
 			`Supported platforms:\n` +
-			`  - x86_64-unknown-linux-gnu (Linux x64)\n` +
-			`  - aarch64-unknown-linux-gnu (Linux ARM64)\n` +
+            `  - x86_64-unknown-linux-musl (Linux x64, static)\n` +
+            `  - aarch64-unknown-linux-musl (Linux ARM64, static)\n` +
 			`  - x86_64-apple-darwin (macOS Intel)\n` +
 			`  - aarch64-apple-darwin (macOS Apple Silicon)\n` +
 			`  - x86_64-pc-windows-msvc (Windows x64)\n` +

package/src/tools/vercel.js

@@ -250,23 +250,64 @@ export const delegateTool = (options = {}) => {
 		name: 'delegate',
 		description: delegateDescription,
 		inputSchema: delegateSchema,
-		execute: async ({ task }) => {
-			try {
-				if (debug) {
-					console.error(`Executing delegate with task: "${task}"`);
-				}
+		execute: async ({ task, currentIteration, maxIterations, parentSessionId, path, provider, model, tracer }) => {
+			// Validate required parameters - throw errors for consistency
+			if (!task || typeof task !== 'string') {
+				throw new Error('Task parameter is required and must be a non-empty string');
+			}
 
-				const result = await delegate({
-					task,
-					timeout,
-					debug
-				});
+			if (task.trim().length === 0) {
+				throw new Error('Task parameter cannot be empty or whitespace only');
+			}
 
-				return result;
-			} catch (error) {
-				console.error('Error executing delegate command:', error);
-				return `Error executing delegate command: ${error.message}`;
+			// Validate optional numeric parameters
+			if (currentIteration !== undefined && (typeof currentIteration !== 'number' || currentIteration < 0)) {
+				throw new Error('currentIteration must be a non-negative number');
+			}
+
+			if (maxIterations !== undefined && (typeof maxIterations !== 'number' || maxIterations < 1)) {
+				throw new Error('maxIterations must be a positive number');
+			}
+
+			// Validate optional string parameters for type consistency
+			if (parentSessionId !== undefined && parentSessionId !== null && typeof parentSessionId !== 'string') {
+				throw new TypeError('parentSessionId must be a string, null, or undefined');
 			}
+
+			if (path !== undefined && path !== null && typeof path !== 'string') {
+				throw new TypeError('path must be a string, null, or undefined');
+			}
+
+			if (provider !== undefined && provider !== null && typeof provider !== 'string') {
+				throw new TypeError('provider must be a string, null, or undefined');
+			}
+
+			if (model !== undefined && model !== null && typeof model !== 'string') {
+				throw new TypeError('model must be a string, null, or undefined');
+			}
+
+			if (debug) {
+				console.error(`Executing delegate with task: "${task.substring(0, 100)}${task.length > 100 ? '...' : ''}"`);
+				if (parentSessionId) {
+					console.error(`Parent session: ${parentSessionId}`);
+				}
+			}
+
+			// Execute delegation - let errors propagate naturally
+			const result = await delegate({
+				task,
+				timeout,
+				debug,
+				currentIteration: currentIteration || 0,
+				maxIterations: maxIterations || 30,
+				parentSessionId,
+				path,
+				provider,
+				model,
+				tracer
+			});
+
+			return result;
 		}
 	});
 };

package/src/utils.js

@@ -25,9 +25,9 @@ let probeBinaryPath = '';
  * @returns {Promise<string>} - Path to the binary
  */
 export async function getBinaryPath(options = {}) {
-	const { forceDownload = false, version } = options;
+    const { forceDownload = false, version } = options;
 
-	// Check environment variable first (user override)
+    // Check environment variable first (user override)
 	if (process.env.PROBE_PATH && fs.existsSync(process.env.PROBE_PATH) && !forceDownload) {
 		probeBinaryPath = process.env.PROBE_PATH;
 		return probeBinaryPath;
@@ -40,13 +40,22 @@ export async function getBinaryPath(options = {}) {
 		return probeBinaryPath;
 	}
 
-	// Get dynamic bin directory (handles CI, npx, Docker scenarios)
-	const binDir = await getPackageBinDir();
-
-	// Check postinstall binary in package directory (most up-to-date with npm package version)
-	const isWindows = process.platform === 'win32';
-	const binaryName = isWindows ? 'probe.exe' : 'probe-binary';
-	const binaryPath = path.join(binDir, binaryName);
+    // Prefer local package bin if available (avoids network during tests/monorepo)
+    const isWindows = process.platform === 'win32';
+    const binaryName = isWindows ? 'probe.exe' : 'probe-binary';
+    const localPackageBin = path.resolve(__dirname, '..', 'bin');
+    const localBinaryPath = path.join(localPackageBin, binaryName);
+    if (fs.existsSync(localBinaryPath) && !forceDownload) {
+        // Use committed binary bundled with the repo/package
+        probeBinaryPath = localBinaryPath;
+        return probeBinaryPath;
+    }
+
+    // Get dynamic bin directory (handles CI, npx, Docker scenarios)
+    const binDir = await getPackageBinDir();
+
+    // Check postinstall binary in resolved directory
+    const binaryPath = path.join(binDir, binaryName);
 
 	if (fs.existsSync(binaryPath) && !forceDownload) {
 		probeBinaryPath = binaryPath;