@probelabs/probe 0.6.0-rc178 → 0.6.0-rc186

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@probelabs/probe",
-  "version": "0.6.0-rc178",
+  "version": "0.6.0-rc186",
   "description": "Node.js wrapper for the probe code search tool",
   "main": "src/index.js",
   "module": "src/index.js",

package/src/agent/ProbeAgent.js

@@ -2501,10 +2501,26 @@ When troubleshooting:
               // Execute native tool
               try {
                 // Add sessionId and workingDirectory to params for tool execution
+                // Validate and resolve workingDirectory
+                let resolvedWorkingDirectory = (this.allowedFolders && this.allowedFolders[0]) || process.cwd();
+                if (params.workingDirectory) {
+                  const requestedDir = resolve(params.workingDirectory);
+                  // Check if the requested directory is within allowed folders
+                  const isWithinAllowed = !this.allowedFolders || this.allowedFolders.length === 0 ||
+                    this.allowedFolders.some(folder => {
+                      const resolvedFolder = resolve(folder);
+                      return requestedDir === resolvedFolder || requestedDir.startsWith(resolvedFolder + sep);
+                    });
+                  if (isWithinAllowed) {
+                    resolvedWorkingDirectory = requestedDir;
+                  } else if (this.debug) {
+                    console.error(`[DEBUG] Rejected workingDirectory "${params.workingDirectory}" - not within allowed folders`);
+                  }
+                }
                 const toolParams = {
                   ...params,
                   sessionId: this.sessionId,
-                  workingDirectory: (this.allowedFolders && this.allowedFolders[0]) || process.cwd()
+                  workingDirectory: resolvedWorkingDirectory
                 };
 
                 // Log tool execution in debug mode

package/src/agent/bashCommandUtils.js

@@ -159,6 +159,69 @@ export function isComplexCommand(command) {
   return result.isComplex;
 }
 
+/**
+ * Check if a pattern is a complex pattern (contains shell operators)
+ * Complex patterns are used to match full command strings including operators
+ * @param {string} pattern - Pattern to check
+ * @returns {boolean} True if pattern contains shell operators
+ */
+export function isComplexPattern(pattern) {
+  if (!pattern || typeof pattern !== 'string') return false;
+
+  // Check for operators in the pattern (aligned with complexPatterns in parseSimpleCommand)
+  const operatorPatterns = [
+    /\|/,           // Pipes
+    /&&/,           // Logical AND
+    /\|\|/,         // Logical OR
+    /;/,            // Command separator
+    /&$/,           // Background execution
+    /\$\(/,         // Command substitution $()
+    /`/,            // Command substitution ``
+    />/,            // Redirection >
+    /</,            // Redirection <
+  ];
+
+  return operatorPatterns.some(p => p.test(pattern));
+}
+
+/**
+ * Convert a glob-style pattern to regex for matching
+ * Supports * as wildcard (matches any characters except operators)
+ * @param {string} pattern - Glob pattern
+ * @returns {RegExp} Compiled regex
+ */
+function globToRegex(pattern) {
+  // Escape regex special characters except *
+  let escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
+  // Convert * to .*? (non-greedy match)
+  escaped = escaped.replace(/\*/g, '.*?');
+  // Make it match the full string
+  return new RegExp('^' + escaped + '$', 'i');
+}
+
+/**
+ * Match a command string against a complex pattern
+ * Complex patterns use glob-style wildcards (*) for matching
+ * @param {string} command - Full command string
+ * @param {string} pattern - Complex pattern with wildcards
+ * @returns {boolean} True if command matches the pattern
+ */
+export function matchesComplexPattern(command, pattern) {
+  if (!command || !pattern) return false;
+
+  // Normalize whitespace
+  const normalizedCommand = command.trim().replace(/\s+/g, ' ');
+  const normalizedPattern = pattern.trim().replace(/\s+/g, ' ');
+
+  try {
+    const regex = globToRegex(normalizedPattern);
+    return regex.test(normalizedCommand);
+  } catch (e) {
+    // If regex fails, fall back to exact match
+    return normalizedCommand === normalizedPattern;
+  }
+}
+
 /**
  * Legacy compatibility function - parses command for permission checking
  * @param {string} command - Command to parse

package/src/agent/bashExecutor.js

@@ -6,7 +6,7 @@
 import { spawn } from 'child_process';
 import { resolve, join } from 'path';
 import { existsSync } from 'fs';
-import { parseCommandForExecution } from './bashCommandUtils.js';
+import { parseCommandForExecution, isComplexCommand } from './bashCommandUtils.js';
 
 /**
  * Execute a bash command with security controls
@@ -63,31 +63,46 @@ export async function executeBashCommand(command, options = {}) {
       ...env
     };
 
-    // Parse command for shell execution
-    // We use shell: false for security, so we need to parse manually
-    const args = parseCommandForExecution(command);
-    if (!args || args.length === 0) {
-      resolve({
-        success: false,
-        error: 'Failed to parse command',
-        stdout: '',
-        stderr: '',
-        exitCode: 1,
-        command,
-        workingDirectory: cwd,
-        duration: Date.now() - startTime
-      });
-      return;
-    }
+    // Check if this is a complex command (contains pipes, operators, etc.)
+    const isComplex = isComplexCommand(command);
 
-    const [cmd, ...cmdArgs] = args;
+    let cmd, cmdArgs, useShell;
+
+    if (isComplex) {
+      // For complex commands, use sh -c to execute through shell
+      // This is only reached if the permission checker allowed the complex command
+      cmd = 'sh';
+      cmdArgs = ['-c', command];
+      useShell = false; // We explicitly use sh -c, not spawn's shell option
+      if (debug) {
+        console.log(`[BashExecutor] Complex command - using sh -c`);
+      }
+    } else {
+      // Parse simple command for direct execution
+      const args = parseCommandForExecution(command);
+      if (!args || args.length === 0) {
+        resolve({
+          success: false,
+          error: 'Failed to parse command',
+          stdout: '',
+          stderr: '',
+          exitCode: 1,
+          command,
+          workingDirectory: cwd,
+          duration: Date.now() - startTime
+        });
+        return;
+      }
+      [cmd, ...cmdArgs] = args;
+      useShell = false;
+    }
 
     // Spawn the process
     const child = spawn(cmd, cmdArgs, {
       cwd,
       env: processEnv,
       stdio: ['ignore', 'pipe', 'pipe'], // stdin ignored, capture stdout/stderr
-      shell: false, // For security
+      shell: useShell, // false for security
       windowsHide: true
     });
 

package/src/agent/bashPermissions.js

@@ -4,7 +4,7 @@
  */
 
 import { DEFAULT_ALLOW_PATTERNS, DEFAULT_DENY_PATTERNS } from './bashDefaults.js';
-import { parseCommand, isComplexCommand } from './bashCommandUtils.js';
+import { parseCommand, isComplexCommand, isComplexPattern, matchesComplexPattern } from './bashCommandUtils.js';
 
 /**
  * Check if a pattern matches a parsed command
@@ -125,7 +125,7 @@ export class BashPermissionChecker {
   }
 
   /**
-   * Check if a simple command is allowed (rejects complex commands for security)
+   * Check if a simple command is allowed (complex commands allowed if they match patterns)
    * @param {string} command - Command to check
    * @returns {Object} Permission result
    */
@@ -138,19 +138,17 @@ export class BashPermissionChecker {
       };
     }
 
-    // First check if this is a complex command - reject immediately for security
-    if (isComplexCommand(command)) {
-      return {
-        allowed: false,
-        reason: 'Complex shell commands with pipes, operators, or redirections are not supported for security reasons',
-        command: command,
-        isComplex: true
-      };
+    // Check if this is a complex command
+    const commandIsComplex = isComplexCommand(command);
+
+    if (commandIsComplex) {
+      // For complex commands, check against complex patterns in allow/deny lists
+      return this._checkComplexCommand(command);
     }
 
     // Parse the simple command
     const parsed = parseCommand(command);
-    
+
     if (parsed.error) {
       return {
         allowed: false,
@@ -203,14 +201,77 @@ export class BashPermissionChecker {
       parsed: parsed,
       isComplex: false
     };
-    
+
     if (this.debug) {
       console.log(`[BashPermissions] ALLOWED - command passed all checks`);
     }
-    
+
     return result;
   }
 
+  /**
+   * Check a complex command against complex patterns in allow/deny lists
+   * @private
+   * @param {string} command - Complex command to check
+   * @returns {Object} Permission result
+   */
+  _checkComplexCommand(command) {
+    if (this.debug) {
+      console.log(`[BashPermissions] Checking complex command: "${command}"`);
+    }
+
+    // Get complex patterns from allow and deny lists
+    const complexAllowPatterns = this.allowPatterns.filter(p => isComplexPattern(p));
+    const complexDenyPatterns = this.denyPatterns.filter(p => isComplexPattern(p));
+
+    if (this.debug) {
+      console.log(`[BashPermissions] Complex allow patterns: ${complexAllowPatterns.length}`);
+      console.log(`[BashPermissions] Complex deny patterns: ${complexDenyPatterns.length}`);
+    }
+
+    // Check deny patterns first (deny takes precedence)
+    for (const pattern of complexDenyPatterns) {
+      if (matchesComplexPattern(command, pattern)) {
+        if (this.debug) {
+          console.log(`[BashPermissions] DENIED - matches complex deny pattern: ${pattern}`);
+        }
+        return {
+          allowed: false,
+          reason: `Command matches deny pattern: ${pattern}`,
+          command: command,
+          isComplex: true,
+          matchedPatterns: [pattern]
+        };
+      }
+    }
+
+    // Check allow patterns
+    for (const pattern of complexAllowPatterns) {
+      if (matchesComplexPattern(command, pattern)) {
+        if (this.debug) {
+          console.log(`[BashPermissions] ALLOWED - matches complex allow pattern: ${pattern}`);
+        }
+        return {
+          allowed: true,
+          command: command,
+          isComplex: true,
+          matchedPattern: pattern
+        };
+      }
+    }
+
+    // No matching complex pattern found - reject complex command
+    if (this.debug) {
+      console.log(`[BashPermissions] DENIED - no matching complex pattern found`);
+    }
+    return {
+      allowed: false,
+      reason: 'Complex shell commands require explicit allow patterns (e.g., "cd * && git *")',
+      command: command,
+      isComplex: true
+    };
+  }
+
   /**
    * Get configuration summary
    * @returns {Object} Configuration info