@probelabs/probe 0.6.0-rc173 → 0.6.0-rc175

package/src/tools/vercel.js

@@ -31,15 +31,15 @@ export const searchTool = (options = {}) => {
 				// Use parameter maxTokens if provided, otherwise use the default
 				const effectiveMaxTokens = paramMaxTokens || maxTokens;
 
-				// Use the path from parameters if provided, otherwise use defaultPath from config
-				let searchPath = path || options.defaultPath || '.';
+				// Use the path from parameters if provided, otherwise use cwd from config
+				let searchPath = path || options.cwd || '.';
 
-				// If path is "." or "./", use the defaultPath if available
-				if ((searchPath === "." || searchPath === "./") && options.defaultPath) {
+				// If path is "." or "./", use the cwd if available
+				if ((searchPath === "." || searchPath === "./") && options.cwd) {
 					if (debug) {
-						console.error(`Using default path "${options.defaultPath}" instead of "${searchPath}"`);
+						console.error(`Using cwd "${options.cwd}" instead of "${searchPath}"`);
 					}
-					searchPath = options.defaultPath;
+					searchPath = options.cwd;
 				}
 
 				if (debug) {
@@ -49,6 +49,7 @@ export const searchTool = (options = {}) => {
 				const searchOptions = {
 					query: searchQuery,
 					path: searchPath,
+					cwd: options.cwd, // Working directory for resolving relative paths
 					allowTests: allow_tests,
 					exact,
 					json: false,
@@ -89,15 +90,15 @@ export const queryTool = (options = {}) => {
 		inputSchema: querySchema,
 		execute: async ({ pattern, path, language, allow_tests }) => {
 			try {
-				// Use the path from parameters if provided, otherwise use defaultPath from config
-				let queryPath = path || options.defaultPath || '.';
+				// Use the path from parameters if provided, otherwise use cwd from config
+				let queryPath = path || options.cwd || '.';
 
-				// If path is "." or "./", use the defaultPath if available
-				if ((queryPath === "." || queryPath === "./") && options.defaultPath) {
+				// If path is "." or "./", use the cwd if available
+				if ((queryPath === "." || queryPath === "./") && options.cwd) {
 					if (debug) {
-						console.error(`Using default path "${options.defaultPath}" instead of "${queryPath}"`);
+						console.error(`Using cwd "${options.cwd}" instead of "${queryPath}"`);
 					}
-					queryPath = options.defaultPath;
+					queryPath = options.cwd;
 				}
 
 				if (debug) {
@@ -107,6 +108,7 @@ export const queryTool = (options = {}) => {
 				const results = await query({
 					pattern,
 					path: queryPath,
+					cwd: options.cwd, // Working directory for resolving relative paths
 					language,
 					allow_tests,
 					json: false
@@ -137,28 +139,20 @@ export const extractTool = (options = {}) => {
 		inputSchema: extractSchema,
 		execute: async ({ targets, input_content, line, end_line, allow_tests, context_lines, format }) => {
 			try {
-				// Use the defaultPath from config for context
-				let extractPath = options.defaultPath || '.';
-
-				// If path is "." or "./", use the defaultPath if available
-				if ((extractPath === "." || extractPath === "./") && options.defaultPath) {
-					if (debug) {
-						console.error(`Using default path "${options.defaultPath}" instead of "${extractPath}"`);
-					}
-					extractPath = options.defaultPath;
-				}
+				// Use the cwd from config for working directory
+				const effectiveCwd = options.cwd || '.';
 
 				if (debug) {
 					if (targets) {
-						console.error(`Executing extract with targets: "${targets}", path: "${extractPath}", context lines: ${context_lines || 10}`);
+						console.error(`Executing extract with targets: "${targets}", cwd: "${effectiveCwd}", context lines: ${context_lines || 10}`);
 					} else if (input_content) {
-						console.error(`Executing extract with input content, path: "${extractPath}", context lines: ${context_lines || 10}`);
+						console.error(`Executing extract with input content, cwd: "${effectiveCwd}", context lines: ${context_lines || 10}`);
 					}
 				}
 
 				// Create a temporary file for input content if provided
 				let tempFilePath = null;
-				let extractOptions = { path: extractPath };
+				let extractOptions = { cwd: effectiveCwd };
 
 				if (input_content) {
 					// Import required modules
@@ -184,6 +178,7 @@ export const extractTool = (options = {}) => {
 					// Set up extract options with input file
 					extractOptions = {
 						inputFile: tempFilePath,
+						cwd: effectiveCwd,
 						allowTests: allow_tests,
 						contextLines: context_lines,
 						format: effectiveFormat
@@ -202,6 +197,7 @@ export const extractTool = (options = {}) => {
 					// Set up extract options with files
 					extractOptions = {
 						files,
+						cwd: effectiveCwd,
 						allowTests: allow_tests,
 						contextLines: context_lines,
 						format: effectiveFormat
@@ -241,12 +237,12 @@ export const extractTool = (options = {}) => {
  * @param {Object} [options] - Configuration options
  * @param {boolean} [options.debug=false] - Enable debug logging
  * @param {number} [options.timeout=300] - Default timeout in seconds
- * @param {string} [options.defaultPath] - Default path to use if not specified in call
+ * @param {string} [options.cwd] - Working directory to use if not specified in call
  * @param {string[]} [options.allowedFolders] - Allowed folders for workspace isolation
  * @returns {Object} Configured delegate tool
  */
 export const delegateTool = (options = {}) => {
-	const { debug = false, timeout = 300, defaultPath, allowedFolders } = options;
+	const { debug = false, timeout = 300, cwd, allowedFolders } = options;
 
 	return tool({
 		name: 'delegate',
@@ -289,8 +285,8 @@ export const delegateTool = (options = {}) => {
 			}
 
 			// Use inherited path if not specified in AI call
-			// Priority: explicit path > defaultPath > first allowedFolder
-			const effectivePath = path || defaultPath || (allowedFolders && allowedFolders[0]);
+			// Priority: explicit path > cwd > first allowedFolder
+			const effectivePath = path || cwd || (allowedFolders && allowedFolders[0]);
 
 			if (debug) {
 				console.error(`Executing delegate with task: "${task.substring(0, 100)}${task.length > 100 ? '...' : ''}"`);

package/src/utils/file-lister.js

@@ -7,6 +7,7 @@ import fs from 'fs';
 import path from 'path';
 import { promisify } from 'util';
 import { exec } from 'child_process';
+import { getEntryTypeSync } from './symlink-utils.js';
 
 const execAsync = promisify(exec);
 
@@ -101,7 +102,10 @@ async function listFilesByLevelManually(directory, maxFiles, respectGitignore) {
 			const entries = fs.readdirSync(dir, { withFileTypes: true });
 
 			// Process files first (at current level)
-			const files = entries.filter(entry => entry.isFile());
+			const files = entries.filter(entry => {
+				const fullPath = path.join(dir, entry.name);
+				return getEntryTypeSync(entry, fullPath).isFile;
+			});
 			for (const file of files) {
 				if (result.length >= maxFiles) break;
 
@@ -115,7 +119,10 @@ async function listFilesByLevelManually(directory, maxFiles, respectGitignore) {
 			}
 
 			// Then add directories to queue for next level
-			const dirs = entries.filter(entry => entry.isDirectory());
+			const dirs = entries.filter(entry => {
+				const fullPath = path.join(dir, entry.name);
+				return getEntryTypeSync(entry, fullPath).isDirectory;
+			});
 			for (const subdir of dirs) {
 				const subdirPath = path.join(dir, subdir.name);
 				const relativeSubdirPath = path.relative(directory, subdirPath);

package/src/utils/path-validation.js

@@ -0,0 +1,58 @@
+/**
+ * Path validation utilities for the probe package
+ * @module utils/path-validation
+ */
+
+import path from 'path';
+import { promises as fs } from 'fs';
+
+/**
+ * Validates and normalizes a path to be used as working directory (cwd).
+ *
+ * Security considerations:
+ * - Normalizes path to resolve '..' and '.' components
+ * - Returns absolute path to prevent ambiguity
+ * - Does NOT restrict access to specific directories (that's the responsibility
+ *   of higher-level components like ProbeAgent with allowedFolders)
+ *
+ * @param {string} inputPath - The path to validate
+ * @param {string} [defaultPath] - Default path to use if inputPath is not provided
+ * @returns {Promise<string>} Normalized absolute path
+ * @throws {Error} If the path is invalid or doesn't exist
+ */
+export async function validateCwdPath(inputPath, defaultPath = process.cwd()) {
+	// Use default if not provided
+	const targetPath = inputPath || defaultPath;
+
+	// Normalize and resolve to absolute path
+	// This handles '..' traversal and makes the path unambiguous
+	const normalizedPath = path.normalize(path.resolve(targetPath));
+
+	// Verify the path exists and is a directory
+	try {
+		const stats = await fs.stat(normalizedPath);
+		if (!stats.isDirectory()) {
+			throw new Error(`Path is not a directory: ${normalizedPath}`);
+		}
+	} catch (error) {
+		if (error.code === 'ENOENT') {
+			throw new Error(`Path does not exist: ${normalizedPath}`);
+		}
+		throw error;
+	}
+
+	return normalizedPath;
+}
+
+/**
+ * Validates a path option without requiring it to exist.
+ * Use this for paths that might be created or are optional.
+ *
+ * @param {string} inputPath - The path to validate
+ * @param {string} [defaultPath] - Default path to use if inputPath is not provided
+ * @returns {string} Normalized absolute path
+ */
+export function normalizePath(inputPath, defaultPath = process.cwd()) {
+	const targetPath = inputPath || defaultPath;
+	return path.normalize(path.resolve(targetPath));
+}

package/src/utils/symlink-utils.js

@@ -0,0 +1,63 @@
+/**
+ * Symlink resolution utilities for the probe package
+ * @module utils/symlink-utils
+ */
+
+import fs from 'fs';
+import { promises as fsPromises } from 'fs';
+
+/**
+ * Get entry type following symlinks (async version)
+ *
+ * Uses fs.stat() which follows symlinks to get the actual target type.
+ * Falls back to dirent type if stat fails (e.g., broken symlink).
+ *
+ * @param {fs.Dirent} entry - Directory entry from readdir
+ * @param {string} fullPath - Full path to the entry
+ * @returns {Promise<{isFile: boolean, isDirectory: boolean, size: number}>}
+ */
+export async function getEntryType(entry, fullPath) {
+	try {
+		const stats = await fsPromises.stat(fullPath);
+		return {
+			isFile: stats.isFile(),
+			isDirectory: stats.isDirectory(),
+			size: stats.size
+		};
+	} catch {
+		// Fall back to dirent type if stat fails (e.g., broken symlink)
+		return {
+			isFile: entry.isFile(),
+			isDirectory: entry.isDirectory(),
+			size: 0
+		};
+	}
+}
+
+/**
+ * Get entry type following symlinks (sync version)
+ *
+ * Uses fs.statSync() which follows symlinks to get the actual target type.
+ * Falls back to dirent type if stat fails (e.g., broken symlink).
+ *
+ * @param {fs.Dirent} entry - Directory entry from readdir
+ * @param {string} fullPath - Full path to the entry
+ * @returns {{isFile: boolean, isDirectory: boolean, size: number}}
+ */
+export function getEntryTypeSync(entry, fullPath) {
+	try {
+		const stats = fs.statSync(fullPath);
+		return {
+			isFile: stats.isFile(),
+			isDirectory: stats.isDirectory(),
+			size: stats.size
+		};
+	} catch {
+		// Fall back to dirent type if stat fails (e.g., broken symlink)
+		return {
+			isFile: entry.isFile(),
+			isDirectory: entry.isDirectory(),
+			size: 0
+		};
+	}
+}