@probelabs/probe 0.6.0-rc225 → 0.6.0-rc226

package/src/utils/path-validation.js

@@ -4,9 +4,48 @@
  */
 
 import path from 'path';
-import { promises as fs } from 'fs';
+import { promises as fs, realpathSync } from 'fs';
 import { PathError } from './error-types.js';
 
+/**
+ * Safely resolve symlinks for a path.
+ * Returns the real path if it exists, otherwise finds the nearest existing
+ * ancestor directory and resolves it, then appends the remaining path components.
+ * This is important for security to prevent symlink bypass attacks.
+ *
+ * @param {string} inputPath - Path to resolve
+ * @returns {string} Resolved real path or best-effort resolved path
+ */
+export function safeRealpath(inputPath) {
+	try {
+		return realpathSync(inputPath);
+	} catch (error) {
+		// If path doesn't exist, find the nearest existing ancestor
+		// and resolve it, then append the remaining components.
+		// This handles cases like non-existent nested paths where an ancestor
+		// may be a symlink (e.g., /var -> /private/var on macOS)
+		const normalized = path.normalize(inputPath);
+		const parts = normalized.split(path.sep);
+
+		// Try progressively shorter paths until we find one that exists
+		for (let i = parts.length - 1; i >= 0; i--) {
+			const ancestorPath = parts.slice(0, i).join(path.sep) || path.sep;
+			try {
+				const resolvedAncestor = realpathSync(ancestorPath);
+				// Found an existing ancestor - append remaining components
+				const remainingParts = parts.slice(i);
+				return path.join(resolvedAncestor, ...remainingParts);
+			} catch (ancestorError) {
+				// This ancestor doesn't exist either, try the next one up
+				continue;
+			}
+		}
+
+		// No existing ancestor found, return normalized path
+		return normalized;
+	}
+}
+
 /**
  * Validates and normalizes a path to be used as working directory (cwd).
  *
@@ -74,3 +113,111 @@ export function normalizePath(inputPath, defaultPath = process.cwd()) {
 	const targetPath = inputPath || defaultPath;
 	return path.normalize(path.resolve(targetPath));
 }
+
+/**
+ * Compute the common prefix (workspace root) from an array of folder paths.
+ * This is useful for finding a single workspace root from multiple allowed folders.
+ *
+ * IMPORTANT: This function returns a value for DISPLAY and CWD purposes only.
+ * It is NOT a security boundary. All security checks should be performed against
+ * the original allowedFolders array, not against workspaceRoot.
+ *
+ * When no common prefix exists (e.g., unrelated paths), returns the first folder.
+ * This is intentional - the caller should use allowedFolders for security validation.
+ *
+ * Examples:
+ * - ['/tmp/ws/tyk', '/tmp/ws/tyk-docs'] -> '/tmp/ws'
+ * - ['/tmp/ws/tyk'] -> '/tmp/ws/tyk'
+ * - ['/a/b', '/c/d'] -> '/a/b' (no common prefix, returns first folder for cwd)
+ * - ['C:\\Users\\ws\\tyk', 'C:\\Users\\ws\\docs'] -> 'C:\\Users\\ws' (Windows)
+ *
+ * @param {string[]} folders - Array of absolute folder paths
+ * @returns {string} Common prefix path (for display/cwd, NOT security boundary)
+ */
+export function getCommonPrefix(folders) {
+	if (!folders || folders.length === 0) {
+		return process.cwd();
+	}
+
+	if (folders.length === 1) {
+		// Resolve symlinks for security
+		return safeRealpath(folders[0]);
+	}
+
+	// Resolve symlinks and normalize all paths to handle mixed separators
+	// This prevents symlink bypass attacks where a symlink could point outside the workspace
+	const normalized = folders.map(f => safeRealpath(f));
+
+	// Split into segments
+	const segments = normalized.map(f => f.split(path.sep));
+
+	// Find minimum length
+	const minLen = Math.min(...segments.map(s => s.length));
+
+	// Find common prefix segments
+	const commonSegments = [];
+	for (let i = 0; i < minLen; i++) {
+		const segment = segments[0][i];
+		if (segments.every(s => s[i] === segment)) {
+			commonSegments.push(segment);
+		} else {
+			break;
+		}
+	}
+
+	// Handle edge cases
+	if (commonSegments.length === 0) {
+		// No common prefix at all, return first folder
+		return normalized[0];
+	}
+
+	// Handle Windows drive letters (e.g., 'C:')
+	// If only the drive letter is common, return first folder for more useful context
+	if (commonSegments.length === 1 && /^[a-zA-Z]:$/.test(commonSegments[0])) {
+		return normalized[0];
+	}
+
+	// Handle Unix root (empty string from split)
+	// If only the root '/' is common, return first folder for more useful context
+	if (commonSegments.length === 1 && commonSegments[0] === '') {
+		return normalized[0];
+	}
+
+	return commonSegments.join(path.sep);
+}
+
+/**
+ * Convert an absolute path to a relative path from the workspace root.
+ * Returns the original path if it cannot be made relative (outside workspace).
+ *
+ * @param {string} absolutePath - Absolute path to convert
+ * @param {string} workspaceRoot - Workspace root to compute relative path from
+ * @returns {string} Relative path or original if outside workspace
+ */
+export function toRelativePath(absolutePath, workspaceRoot) {
+	if (!absolutePath || !workspaceRoot) {
+		return absolutePath;
+	}
+
+	// Resolve symlinks for security to prevent bypass attacks
+	// Use safeRealpath which falls back to normalized path if resolution fails
+	let normalized = safeRealpath(absolutePath);
+	let normalizedRoot = safeRealpath(workspaceRoot);
+
+	// Remove trailing separators (path.normalize doesn't always do this)
+	while (normalizedRoot.length > 1 && normalizedRoot.endsWith(path.sep)) {
+		normalizedRoot = normalizedRoot.slice(0, -1);
+	}
+
+	// Check if path is within workspace (exact match or starts with root + separator)
+	if (normalized === normalizedRoot) {
+		return '.';
+	}
+
+	if (normalized.startsWith(normalizedRoot + path.sep)) {
+		return path.relative(normalizedRoot, normalized);
+	}
+
+	// Path is outside workspace, return as-is
+	return absolutePath;
+}