@crownpeak/dqm-react-component-dev-mcp 1.2.0

package/data/probe/npm/tests/unit/bash-probe-agent-integration.test.js

@@ -0,0 +1,389 @@
+/**
+ * Tests for bash tool integration with ProbeAgent
+ * @module tests/unit/bash-probe-agent-integration
+ */
+
+import { jest, describe, test, expect, beforeEach } from '@jest/globals';
+
+// Mock all the heavy dependencies that ProbeAgent uses
+jest.mock('@ai-sdk/anthropic', () => ({}));
+jest.mock('@ai-sdk/openai', () => ({}));
+jest.mock('@ai-sdk/google', () => ({}));
+jest.mock('ai', () => ({
+  generateText: jest.fn(),
+  tool: jest.fn((config) => ({
+    name: config.name,
+    description: config.description,
+    inputSchema: config.inputSchema,
+    execute: config.execute
+  }))
+}));
+
+// Import ProbeAgent
+import { ProbeAgent } from '../../src/agent/ProbeAgent.js';
+
+describe('Bash Tool ProbeAgent Integration', () => {
+  describe('ProbeAgent Configuration', () => {
+    test('should create ProbeAgent with bash disabled by default', () => {
+      const agent = new ProbeAgent({
+        debug: false
+      });
+
+      expect(agent.enableBash).toBe(false);
+      expect(agent.bashConfig).toEqual({});
+      expect(agent.toolImplementations.bash).toBeUndefined();
+    });
+
+    test('should create ProbeAgent with bash enabled', () => {
+      const agent = new ProbeAgent({
+        enableBash: true,
+        debug: false
+      });
+
+      expect(agent.enableBash).toBe(true);
+      expect(agent.bashConfig).toEqual({});
+      
+      // Should have bash tool in implementations
+      expect(agent.toolImplementations.bash).toBeDefined();
+    });
+
+    test('should create ProbeAgent with custom bash config', () => {
+      const bashConfig = {
+        allow: ['docker:ps', 'make:help'],
+        deny: ['git:push'],
+        timeout: 60000,
+        workingDirectory: '/test'
+      };
+
+      const agent = new ProbeAgent({
+        enableBash: true,
+        bashConfig: bashConfig,
+        debug: false
+      });
+
+      expect(agent.enableBash).toBe(true);
+      expect(agent.bashConfig).toEqual(bashConfig);
+      expect(agent.toolImplementations.bash).toBeDefined();
+    });
+
+    test('should pass configuration to tools properly', () => {
+      const bashConfig = {
+        allow: ['custom:command'],
+        timeout: 30000
+      };
+
+      const agent = new ProbeAgent({
+        enableBash: true,
+        bashConfig: bashConfig,
+        allowedFolders: ['/home/test'],
+        debug: false
+      });
+
+      expect(agent.enableBash).toBe(true);
+      expect(agent.bashConfig).toEqual(bashConfig);
+      expect(agent.allowedFolders).toEqual(['/home/test']);
+    });
+  });
+
+  describe('Tool Implementation Availability', () => {
+    test('should not have bash tool when disabled', () => {
+      const agent = new ProbeAgent({
+        enableBash: false,
+        debug: false
+      });
+
+      expect(agent.toolImplementations.bash).toBeUndefined();
+      
+      // Should have other tools
+      expect(agent.toolImplementations.search).toBeDefined();
+      expect(agent.toolImplementations.query).toBeDefined();
+      expect(agent.toolImplementations.extract).toBeDefined();
+    });
+
+    test('should have bash tool when enabled', () => {
+      const agent = new ProbeAgent({
+        enableBash: true,
+        debug: false
+      });
+
+      expect(agent.toolImplementations.bash).toBeDefined();
+      
+      // Should also have other tools
+      expect(agent.toolImplementations.search).toBeDefined();
+      expect(agent.toolImplementations.query).toBeDefined();
+      expect(agent.toolImplementations.extract).toBeDefined();
+    });
+
+    test('should have executable bash tool', () => {
+      const agent = new ProbeAgent({
+        enableBash: true,
+        debug: false
+      });
+
+      const bashTool = agent.toolImplementations.bash;
+      expect(bashTool).toBeDefined();
+      expect(typeof bashTool.execute).toBe('function');
+    });
+  });
+
+  describe('Configuration Edge Cases', () => {
+    test('should handle empty bash config', () => {
+      const agent = new ProbeAgent({
+        enableBash: true,
+        bashConfig: {},
+        debug: false
+      });
+
+      expect(agent.enableBash).toBe(true);
+      expect(agent.bashConfig).toEqual({});
+      expect(agent.toolImplementations.bash).toBeDefined();
+    });
+
+    test('should handle null bash config', () => {
+      const agent = new ProbeAgent({
+        enableBash: true,
+        bashConfig: null,
+        debug: false
+      });
+
+      expect(agent.enableBash).toBe(true);
+      expect(agent.bashConfig).toEqual({});
+      expect(agent.toolImplementations.bash).toBeDefined();
+    });
+
+    test('should handle undefined bash config', () => {
+      const agent = new ProbeAgent({
+        enableBash: true,
+        debug: false
+      });
+
+      expect(agent.enableBash).toBe(true);
+      expect(agent.bashConfig).toEqual({});
+      expect(agent.toolImplementations.bash).toBeDefined();
+    });
+
+    test('should handle complex bash configuration', () => {
+      const complexConfig = {
+        allow: ['docker:*', 'npm:run:*', 'make:*'],
+        deny: ['docker:rm:*', 'npm:install:*'],
+        disableDefaultAllow: false,
+        disableDefaultDeny: false,
+        timeout: 120000,
+        workingDirectory: '/app',
+        env: {
+          NODE_ENV: 'test',
+          DEBUG: '1'
+        },
+        maxBuffer: 10 * 1024 * 1024
+      };
+
+      const agent = new ProbeAgent({
+        enableBash: true,
+        bashConfig: complexConfig,
+        debug: false
+      });
+
+      expect(agent.bashConfig).toEqual(complexConfig);
+      expect(agent.toolImplementations.bash).toBeDefined();
+    });
+  });
+
+  describe('Working Directory Integration', () => {
+    test('should use allowedFolders as default working directory', () => {
+      const agent = new ProbeAgent({
+        enableBash: true,
+        allowedFolders: ['/project', '/tmp'],
+        debug: false
+      });
+
+      expect(agent.allowedFolders).toEqual(['/project', '/tmp']);
+      expect(agent.toolImplementations.bash).toBeDefined();
+    });
+
+    test('should handle empty allowedFolders', () => {
+      const agent = new ProbeAgent({
+        enableBash: true,
+        allowedFolders: [],
+        debug: false
+      });
+
+      expect(agent.allowedFolders).toEqual([]);
+      expect(agent.toolImplementations.bash).toBeDefined();
+    });
+
+    test('should use path parameter as allowedFolders', () => {
+      const agent = new ProbeAgent({
+        enableBash: true,
+        path: '/single/path',
+        debug: false
+      });
+
+      expect(agent.allowedFolders).toEqual(['/single/path']);
+      expect(agent.toolImplementations.bash).toBeDefined();
+    });
+  });
+
+  describe('Debug Mode Integration', () => {
+    test('should pass debug flag to bash configuration', () => {
+      const agent = new ProbeAgent({
+        enableBash: true,
+        debug: true
+      });
+
+      expect(agent.debug).toBe(true);
+      expect(agent.enableBash).toBe(true);
+      expect(agent.toolImplementations.bash).toBeDefined();
+    });
+
+    test('should respect process.env.DEBUG', () => {
+      const originalDebug = process.env.DEBUG;
+      process.env.DEBUG = '1';
+
+      const agent = new ProbeAgent({
+        enableBash: true
+      });
+
+      expect(agent.debug).toBe(true);
+      expect(agent.enableBash).toBe(true);
+      
+      // Restore original value
+      if (originalDebug !== undefined) {
+        process.env.DEBUG = originalDebug;
+      } else {
+        delete process.env.DEBUG;
+      }
+    });
+  });
+});
+
+describe('Bash Tool Configuration Parsing', () => {
+  // These tests simulate what the CLI would do when parsing arguments
+  describe('CLI-style Configuration Processing', () => {
+    test('should parse comma-separated allow patterns', () => {
+      const allowPatterns = 'docker:ps,docker:images,npm:list';
+      const parsedPatterns = allowPatterns.split(',').map(p => p.trim()).filter(p => p.length > 0);
+
+      expect(parsedPatterns).toEqual(['docker:ps', 'docker:images', 'npm:list']);
+
+      const agent = new ProbeAgent({
+        enableBash: true,
+        bashConfig: {
+          allow: parsedPatterns
+        },
+        debug: false
+      });
+
+      expect(agent.bashConfig.allow).toEqual(parsedPatterns);
+    });
+
+    test('should parse comma-separated deny patterns', () => {
+      const denyPatterns = 'rm:*,sudo:*,chmod:777';
+      const parsedPatterns = denyPatterns.split(',').map(p => p.trim()).filter(p => p.length > 0);
+
+      expect(parsedPatterns).toEqual(['rm:*', 'sudo:*', 'chmod:777']);
+
+      const agent = new ProbeAgent({
+        enableBash: true,
+        bashConfig: {
+          deny: parsedPatterns
+        },
+        debug: false
+      });
+
+      expect(agent.bashConfig.deny).toEqual(parsedPatterns);
+    });
+
+    test('should handle empty patterns gracefully', () => {
+      const allowPatterns = '';
+      const parsedPatterns = allowPatterns.split(',').map(p => p.trim()).filter(p => p.length > 0);
+
+      expect(parsedPatterns).toEqual([]);
+
+      const agent = new ProbeAgent({
+        enableBash: true,
+        bashConfig: {
+          allow: parsedPatterns.length > 0 ? parsedPatterns : undefined
+        },
+        debug: false
+      });
+
+      expect(agent.bashConfig.allow).toBeUndefined();
+    });
+
+    test('should handle patterns with extra whitespace', () => {
+      const allowPatterns = ' docker:ps , npm:list , git:status ';
+      const parsedPatterns = allowPatterns.split(',').map(p => p.trim()).filter(p => p.length > 0);
+
+      expect(parsedPatterns).toEqual(['docker:ps', 'npm:list', 'git:status']);
+    });
+
+    test('should parse timeout values', () => {
+      const timeoutString = '60000';
+      const timeout = parseInt(timeoutString, 10);
+
+      expect(timeout).toBe(60000);
+      expect(isNaN(timeout)).toBe(false);
+
+      const agent = new ProbeAgent({
+        enableBash: true,
+        bashConfig: {
+          timeout: timeout
+        },
+        debug: false
+      });
+
+      expect(agent.bashConfig.timeout).toBe(60000);
+    });
+
+    test('should handle invalid timeout values', () => {
+      const timeoutString = 'invalid';
+      const timeout = parseInt(timeoutString, 10);
+
+      expect(isNaN(timeout)).toBe(true);
+      
+      // In real CLI, this would cause an error before ProbeAgent creation
+      // Here we just test that ProbeAgent doesn't break with invalid values
+      const agent = new ProbeAgent({
+        enableBash: true,
+        bashConfig: {
+          timeout: isNaN(timeout) ? undefined : timeout
+        },
+        debug: false
+      });
+
+      expect(agent.bashConfig.timeout).toBeUndefined();
+    });
+
+    test('should handle disable flags', () => {
+      // Simulating --no-default-bash-allow and --no-default-bash-deny
+      const defaultBashAllow = false;
+      const defaultBashDeny = false;
+
+      const agent = new ProbeAgent({
+        enableBash: true,
+        bashConfig: {
+          disableDefaultAllow: defaultBashAllow === false,
+          disableDefaultDeny: defaultBashDeny === false
+        },
+        debug: false
+      });
+
+      expect(agent.bashConfig.disableDefaultAllow).toBe(true);
+      expect(agent.bashConfig.disableDefaultDeny).toBe(true);
+    });
+  });
+
+  describe('Environment Variable Integration', () => {
+    test('should not interfere with existing environment handling', () => {
+      const agent = new ProbeAgent({
+        enableBash: true,
+        debug: false
+      });
+
+      // Should still have basic functionality
+      expect(agent.sessionId).toBeTruthy();
+      expect(typeof agent.sessionId).toBe('string');
+      expect(agent.toolImplementations).toBeDefined();
+    });
+  });
+});

package/data/probe/npm/tests/unit/bash-simple-commands.test.js

@@ -0,0 +1,324 @@
+/**
+ * Tests for simplified bash tool (rejects complex commands for security)
+ * @module tests/unit/bash-simple-commands
+ */
+
+import { jest, describe, test, expect, beforeEach } from '@jest/globals';
+import { parseSimpleCommand, parseCommand, parseCommandForExecution, isComplexCommand } from '../../src/agent/bashCommandUtils.js';
+import { BashPermissionChecker } from '../../src/agent/bashPermissions.js';
+
+// Mock the 'ai' package since it may not be available in test environment
+jest.mock('ai', () => ({
+  tool: jest.fn((config) => ({
+    name: config.name,
+    description: config.description,
+    inputSchema: config.inputSchema,
+    execute: config.execute
+  }))
+}));
+
+import { bashTool } from '../../src/tools/bash.js';
+
+describe('Simple Command Parser', () => {
+  describe('parseSimpleCommand', () => {
+    test('should parse simple commands correctly', () => {
+      const result = parseSimpleCommand('ls -la');
+      expect(result.success).toBe(true);
+      expect(result.command).toBe('ls');
+      expect(result.args).toEqual(['-la']);
+      expect(result.isComplex).toBe(false);
+    });
+
+    test('should handle quoted arguments correctly (fix quote bug)', () => {
+      const result = parseSimpleCommand('grep "test file" *.txt');
+      expect(result.success).toBe(true);
+      expect(result.command).toBe('grep');
+      expect(result.args).toEqual(['test file', '*.txt']); // Quotes stripped!
+      expect(result.fullArgs).toEqual(['grep', 'test file', '*.txt']);
+    });
+
+    test('should handle single quotes correctly', () => {
+      const result = parseSimpleCommand("echo 'hello world'");
+      expect(result.success).toBe(true);
+      expect(result.command).toBe('echo');
+      expect(result.args).toEqual(['hello world']); // Single quotes stripped!
+    });
+
+    test('should handle mixed quotes', () => {
+      const result = parseSimpleCommand('git commit -m "Fixed bug" --author="John Doe"');
+      expect(result.success).toBe(true);
+      expect(result.command).toBe('git');
+      expect(result.args).toEqual(['commit', '-m', 'Fixed bug', '--author=John Doe']);
+    });
+
+    test('should reject commands with unclosed quotes', () => {
+      const result = parseSimpleCommand('echo "unclosed quote');
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('Unclosed quote');
+    });
+
+    test('should reject empty commands', () => {
+      const result = parseSimpleCommand('');
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('empty');
+    });
+
+    test('should reject null/undefined commands', () => {
+      expect(parseSimpleCommand(null).success).toBe(false);
+      expect(parseSimpleCommand(undefined).success).toBe(false);
+    });
+  });
+
+  describe('Complex Command Detection', () => {
+    test('should detect pipes as complex', () => {
+      expect(isComplexCommand('ls | grep test')).toBe(true);
+      const result = parseSimpleCommand('ls | grep test');
+      expect(result.success).toBe(false);
+      expect(result.isComplex).toBe(true);
+      expect(result.error).toContain('Complex shell commands');
+    });
+
+    test('should detect logical operators as complex', () => {
+      expect(isComplexCommand('make && make test')).toBe(true);
+      expect(isComplexCommand('make || echo failed')).toBe(true);
+    });
+
+    test('should detect command substitution as complex', () => {
+      expect(isComplexCommand('echo $(date)')).toBe(true);
+      expect(isComplexCommand('ls `pwd`')).toBe(true);
+    });
+
+    test('should detect redirections as complex', () => {
+      expect(isComplexCommand('ls > output.txt')).toBe(true);
+      expect(isComplexCommand('cat < input.txt')).toBe(true);
+    });
+
+    test('should detect background execution as complex', () => {
+      expect(isComplexCommand('long-task &')).toBe(true);
+    });
+
+    test('should detect command separators as complex', () => {
+      expect(isComplexCommand('cd /tmp; ls')).toBe(true);
+    });
+
+    test('should allow simple commands', () => {
+      expect(isComplexCommand('ls -la')).toBe(false);
+      expect(isComplexCommand('git status')).toBe(false);
+      expect(isComplexCommand('npm test')).toBe(false);
+    });
+  });
+
+  describe('parseCommandForExecution', () => {
+    test('should return array for simple commands', () => {
+      const result = parseCommandForExecution('ls -la');
+      expect(result).toEqual(['ls', '-la']);
+    });
+
+    test('should return null for complex commands', () => {
+      const result = parseCommandForExecution('ls | grep test');
+      expect(result).toBeNull();
+    });
+
+    test('should handle quotes correctly for execution', () => {
+      const result = parseCommandForExecution('grep "test file" data.txt');
+      expect(result).toEqual(['grep', 'test file', 'data.txt']);
+    });
+  });
+});
+
+describe('Simplified Permission Checker', () => {
+  let checker;
+
+  beforeEach(() => {
+    checker = new BashPermissionChecker({
+      allow: ['test:*', 'echo:hello'],
+      deny: ['rm:*', 'dangerous:cmd'],
+      debug: false
+    });
+  });
+
+  describe('Complex Command Rejection', () => {
+    test('should reject piped commands', () => {
+      const result = checker.check('ls | grep test');
+      expect(result.allowed).toBe(false);
+      expect(result.reason).toContain('Complex shell commands');
+      expect(result.isComplex).toBe(true);
+    });
+
+    test('should reject commands with logical operators', () => {
+      const result = checker.check('make && make test');
+      expect(result.allowed).toBe(false);
+      expect(result.reason).toContain('Complex shell commands');
+    });
+
+    test('should reject command substitution', () => {
+      const result = checker.check('echo $(whoami)');
+      expect(result.allowed).toBe(false);
+      expect(result.reason).toContain('Complex shell commands');
+    });
+
+    test('should reject redirections', () => {
+      const result = checker.check('ls > output.txt');
+      expect(result.allowed).toBe(false);
+      expect(result.reason).toContain('Complex shell commands');
+    });
+  });
+
+  describe('Simple Command Processing', () => {
+    test('should allow commands matching allow patterns', () => {
+      const result = checker.check('test --version');
+      expect(result.allowed).toBe(true);
+      expect(result.isComplex).toBe(false);
+    });
+
+    test('should reject commands matching deny patterns', () => {
+      const result = checker.check('rm -rf /');
+      expect(result.allowed).toBe(false);
+      expect(result.reason).toContain('deny pattern');
+    });
+
+    test('should handle quoted arguments in pattern matching', () => {
+      // This tests the quote handling fix
+      const result = checker.check('echo "hello"');
+      expect(result.allowed).toBe(true); // Should match echo:hello pattern
+    });
+
+    test('should reject commands with no matching allow pattern', () => {
+      const result = checker.check('unknown-command');
+      expect(result.allowed).toBe(false);
+      expect(result.reason).toContain('Command not in allow list');
+    });
+  });
+
+  describe('Configuration', () => {
+    test('should work with empty allow list (allows everything not denied)', () => {
+      const permissiveChecker = new BashPermissionChecker({
+        allow: [], // Empty allow list
+        deny: ['rm:*'],
+        disableDefaultAllow: true,
+        disableDefaultDeny: true
+      });
+
+      const allowed = permissiveChecker.check('any-command');
+      expect(allowed.allowed).toBe(true);
+
+      const denied = permissiveChecker.check('rm -rf');
+      expect(denied.allowed).toBe(false);
+    });
+
+    test('should provide configuration summary', () => {
+      const config = checker.getConfig();
+      expect(config).toHaveProperty('allowPatterns');
+      expect(config).toHaveProperty('denyPatterns');
+      expect(config).toHaveProperty('totalPatterns');
+      expect(typeof config.allowPatterns).toBe('number');
+      expect(typeof config.denyPatterns).toBe('number');
+    });
+  });
+});
+
+describe('Bash Tool Integration with Simplified Architecture', () => {
+  test('should create bash tool with working configuration', () => {
+    const tool = bashTool({
+      enableBash: true,
+      bashConfig: {
+        allow: ['ls:*', 'echo:*'],
+        deny: ['rm:*'],
+        timeout: 30000
+      }
+    });
+
+    expect(tool.name).toBe('bash');
+    expect(tool.description).toContain('Execute bash commands');
+    expect(typeof tool.execute).toBe('function');
+  });
+
+  test('should reject complex commands in tool execution', async () => {
+    const tool = bashTool({
+      enableBash: true,
+      bashConfig: { allow: ['ls:*'], deny: [] }
+    });
+
+    const result = await tool.execute({ command: 'ls | grep test' });
+    expect(result).toContain('Permission denied');
+    expect(result).toContain('Complex shell commands');
+  });
+
+  test('should handle simple commands in tool', async () => {
+    const tool = bashTool({
+      enableBash: true,
+      bashConfig: { 
+        allow: ['echo:*'], 
+        deny: [],
+        disableDefaultAllow: true,
+        disableDefaultDeny: true 
+      }
+    });
+
+    // This should not throw during permission check
+    // (actual execution might fail without proper environment, but permissions should pass)
+    let permissionError = null;
+    try {
+      await tool.execute({ command: 'echo hello' });
+    } catch (error) {
+      if (error.message.includes('Permission denied')) {
+        permissionError = error;
+      }
+      // Other execution errors (like missing environment) are expected in tests
+    }
+
+    expect(permissionError).toBeNull();
+  });
+});
+
+describe('Architecture Alignment Tests', () => {
+  test('should ensure parser and executor handle same command format', () => {
+    const testCommands = [
+      'ls -la',
+      'git status',
+      'echo "hello world"',
+      'npm test',
+      'docker ps',
+      'make clean'
+    ];
+
+    for (const command of testCommands) {
+      const parserResult = parseCommandForExecution(command);
+      const permissionResult = parseCommand(command);
+
+      // Both should succeed for simple commands
+      expect(parserResult).not.toBeNull();
+      expect(permissionResult.error).toBeNull();
+
+      // Both should parse to same basic structure
+      expect(parserResult[0]).toBe(permissionResult.command);
+      expect(parserResult.slice(1)).toEqual(permissionResult.args);
+    }
+  });
+
+  test('should ensure complex commands are consistently rejected', () => {
+    const complexCommands = [
+      'ls | grep test',
+      'make && make test',
+      'echo $(date)',
+      'ls > output.txt',
+      'cmd1 ; cmd2',
+      'background-task &'
+    ];
+
+    for (const command of complexCommands) {
+      const parserResult = parseCommandForExecution(command);
+      const isComplex = isComplexCommand(command);
+
+      // Parser should reject complex commands
+      expect(parserResult).toBeNull();
+      expect(isComplex).toBe(true);
+
+      // Permission checker should also reject
+      const checker = new BashPermissionChecker({ allow: ['*'], deny: [] });
+      const permissionResult = checker.check(command);
+      expect(permissionResult.allowed).toBe(false);
+      expect(permissionResult.reason).toContain('Complex shell commands');
+    }
+  });
+});