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

package/data/probe/npm/tests/integration/examplesChatMcp.test.js

@@ -0,0 +1,402 @@
+/**
+ * Integration tests for examples/chat ProbeChat with MCP support
+ *
+ * NOTE: This test requires examples/chat dependencies to be installed.
+ * It tests the integration between the npm package and the examples/chat application.
+ */
+
+import { jest } from '@jest/globals';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { mkdtemp, writeFile, rm } from 'fs/promises';
+import { tmpdir } from 'os';
+import { existsSync } from 'fs';
+
+// Check if examples/chat exists and has node_modules
+const examplesPath = join(dirname(dirname(dirname(dirname(fileURLToPath(import.meta.url))))), 'examples', 'chat');
+const examplesNodeModules = join(examplesPath, 'node_modules');
+
+// Skip these tests if examples/chat dependencies are not installed
+const skipTests = !existsSync(examplesNodeModules);
+
+// Only import ProbeChat if we can run the tests
+let ProbeChat;
+if (!skipTests) {
+  // Mock dotenv/config before importing modules that use it
+  jest.unstable_mockModule('dotenv/config', () => ({}));
+
+  // Import ProbeChat only if we'll run the tests
+  const module = await import('../../../examples/chat/probeChat.js');
+  ProbeChat = module.ProbeChat;
+}
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const describeOrSkip = skipTests ? describe.skip : describe;
+
+describeOrSkip('ProbeChat MCP Integration', () => {
+  let tempDir;
+
+  if (skipTests) {
+    test('Tests skipped - examples/chat dependencies not installed', () => {
+      console.log('Skipping ProbeChat tests as examples/chat dependencies are not installed');
+      console.log(`Checked path: ${examplesNodeModules}`);
+      expect(true).toBe(true);
+    });
+    return;
+  }
+
+  beforeEach(async () => {
+    tempDir = await mkdtemp(join(tmpdir(), 'probe-chat-mcp-test-'));
+  });
+
+  afterEach(async () => {
+    if (tempDir) {
+      await rm(tempDir, { recursive: true, force: true });
+    }
+    // Clean up environment variables
+    delete process.env.ENABLE_MCP;
+    delete process.env.MCP_CONFIG_PATH;
+    delete process.env.ANTHROPIC_API_KEY;
+    delete process.env.OPENAI_API_KEY;
+    delete process.env.GOOGLE_API_KEY;
+    delete process.env.PROBE_NON_INTERACTIVE;
+    delete process.env.DEBUG_CHAT;
+  });
+
+  describe('ProbeChat Initialization', () => {
+    test('should initialize ProbeChat without MCP by default', async () => {
+      process.env.PROBE_NON_INTERACTIVE = '1'; // Suppress logs in tests
+
+      const chat = new ProbeChat({
+        isNonInteractive: true,
+        debug: false
+      });
+
+      expect(chat.agent.enableMcp).toBe(false);
+      expect(chat.agent.mcpBridge).toBeNull();
+
+      await chat.cleanup();
+    });
+
+    test('should initialize ProbeChat with MCP enabled via options', async () => {
+      process.env.PROBE_NON_INTERACTIVE = '1';
+
+      const chat = new ProbeChat({
+        enableMcp: true,
+        isNonInteractive: true,
+        debug: false
+      });
+
+      expect(chat.agent.enableMcp).toBe(true);
+
+      await chat.cleanup();
+    });
+
+    test('should initialize ProbeChat with MCP enabled via environment', async () => {
+      process.env.ENABLE_MCP = '1';
+      process.env.PROBE_NON_INTERACTIVE = '1';
+
+      const chat = new ProbeChat({
+        isNonInteractive: true,
+        debug: false
+      });
+
+      expect(chat.agent.enableMcp).toBe(true);
+
+      await chat.cleanup();
+    });
+
+    test('should pass MCP server configurations to ProbeAgent', async () => {
+      process.env.PROBE_NON_INTERACTIVE = '1';
+
+      const mcpServers = [
+        {
+          name: 'test-server',
+          command: 'node',
+          args: ['test.js']
+        }
+      ];
+
+      const chat = new ProbeChat({
+        enableMcp: true,
+        mcpServers: mcpServers,
+        isNonInteractive: true,
+        debug: false
+      });
+
+      expect(chat.agent.enableMcp).toBe(true);
+      expect(chat.agent.mcpServers).toEqual(mcpServers);
+
+      await chat.cleanup();
+    });
+  });
+
+  describe('ProbeChat API Integration', () => {
+    test('should maintain ProbeChat API compatibility', async () => {
+      process.env.PROBE_NON_INTERACTIVE = '1';
+      process.env.ANTHROPIC_API_KEY = 'test-key';
+
+      const chat = new ProbeChat({
+        enableMcp: true,
+        isNonInteractive: true,
+        debug: false
+      });
+
+      // Verify all expected methods exist
+      expect(typeof chat.chat).toBe('function');
+      expect(typeof chat.getSessionId).toBe('function');
+      expect(typeof chat.getUsageSummary).toBe('function');
+      expect(typeof chat.clearHistory).toBe('function');
+      expect(typeof chat.exportHistory).toBe('function');
+      expect(typeof chat.saveHistory).toBe('function');
+      expect(typeof chat.cancel).toBe('function');
+      expect(typeof chat.cleanup).toBe('function');
+
+      // Test basic functionality
+      expect(chat.getSessionId()).toBeDefined();
+      expect(chat.getUsageSummary()).toBeDefined();
+      expect(chat.exportHistory()).toEqual([]);
+
+      chat.clearHistory();
+      expect(chat.exportHistory()).toEqual([]);
+
+      await chat.cleanup();
+    });
+
+    test('should handle image URL extraction', async () => {
+      process.env.PROBE_NON_INTERACTIVE = '1';
+
+      const chat = new ProbeChat({
+        isNonInteractive: true,
+        debug: false
+      });
+
+      // Test that ProbeChat can be instantiated without errors
+      // Image extraction is tested in the ProbeChat source, here we just verify integration
+      expect(chat).toBeDefined();
+
+      await chat.cleanup();
+    });
+  });
+
+  describe('Token Usage and Display', () => {
+    test('should initialize token usage tracking', async () => {
+      process.env.PROBE_NON_INTERACTIVE = '1';
+
+      const chat = new ProbeChat({
+        isNonInteractive: true,
+        debug: false
+      });
+
+      expect(chat.tokenUsage).toBeDefined();
+      expect(typeof chat.tokenUsage.updateFromTokenCounter).toBe('function');
+      expect(typeof chat.tokenUsage.display).toBe('function');
+      expect(typeof chat.tokenUsage.clear).toBe('function');
+
+      await chat.cleanup();
+    });
+
+    test('should handle telemetry configuration', async () => {
+      process.env.PROBE_NON_INTERACTIVE = '1';
+
+      const chat = new ProbeChat({
+        isNonInteractive: true,
+        debug: false
+      });
+
+      expect(chat.telemetryConfig).toBeDefined();
+
+      await chat.cleanup();
+    });
+  });
+
+  describe('History Management', () => {
+    test('should save and load conversation history', async () => {
+      process.env.PROBE_NON_INTERACTIVE = '1';
+
+      const chat = new ProbeChat({
+        isNonInteractive: true,
+        debug: false
+      });
+
+      // Test history export/import
+      const initialHistory = chat.exportHistory();
+      expect(Array.isArray(initialHistory)).toBe(true);
+
+      // Test history saving (filename generation)
+      const filename = join(tempDir, 'test-history.json');
+      const savedFile = chat.saveHistory(filename);
+      expect(savedFile).toBe(filename);
+
+      await chat.cleanup();
+    });
+
+    test('should generate automatic history filenames', async () => {
+      process.env.PROBE_NON_INTERACTIVE = '1';
+
+      const chat = new ProbeChat({
+        isNonInteractive: true,
+        debug: false
+      });
+
+      // Test automatic filename generation
+      const sessionId = chat.getSessionId();
+      const filename = chat.saveHistory();
+
+      expect(filename).toContain(sessionId);
+      expect(filename).toContain('.json');
+
+      await chat.cleanup();
+    });
+  });
+
+  describe('Mock Server Integration', () => {
+    test('should work with mock MCP server configuration', async () => {
+      // Create MCP configuration with mock server
+      const mcpConfig = {
+        mcpServers: {
+          'mock-chat-test': {
+            command: 'node',
+            args: [join(__dirname, '../mcp/mockMcpServer.js')],
+            transport: 'stdio',
+            enabled: true
+          }
+        }
+      };
+
+      const configPath = join(tempDir, 'chat-mcp-config.json');
+      await writeFile(configPath, JSON.stringify(mcpConfig, null, 2));
+
+      process.env.MCP_CONFIG_PATH = configPath;
+      process.env.PROBE_NON_INTERACTIVE = '1';
+      process.env.ANTHROPIC_API_KEY = 'test-key';
+
+      const chat = new ProbeChat({
+        enableMcp: true,
+        isNonInteractive: true,
+        debug: true
+      });
+
+      // Wait for MCP initialization
+      await new Promise(resolve => setTimeout(resolve, 3000));
+
+      // Verify MCP integration is working
+      expect(chat.agent.enableMcp).toBe(true);
+
+      if (chat.agent.mcpBridge && chat.agent.mcpBridge.getToolNames().length > 0) {
+        const toolNames = chat.agent.mcpBridge.getToolNames();
+        console.log('ProbeChat successfully connected to mock server with tools:', toolNames);
+
+        // Verify expected tools
+        expect(toolNames.some(name => name.includes('foobar'))).toBe(true);
+        expect(toolNames.some(name => name.includes('calculator'))).toBe(true);
+      } else {
+        console.warn('Mock server connection failed in ProbeChat - may be expected in test environment');
+      }
+
+      await chat.cleanup();
+    }, 20000); // Extended timeout for server startup
+  });
+
+  describe('Error Handling', () => {
+    test('should handle MCP initialization errors gracefully', async () => {
+      // Create invalid MCP configuration
+      const mcpConfig = {
+        mcpServers: {
+          'invalid-chat-server': {
+            command: 'nonexistent-command',
+            args: ['--invalid'],
+            transport: 'stdio',
+            enabled: true
+          }
+        }
+      };
+
+      const configPath = join(tempDir, 'invalid-chat-config.json');
+      await writeFile(configPath, JSON.stringify(mcpConfig, null, 2));
+
+      process.env.MCP_CONFIG_PATH = configPath;
+      process.env.PROBE_NON_INTERACTIVE = '1';
+
+      // Should not crash during initialization
+      const chat = new ProbeChat({
+        enableMcp: true,
+        isNonInteractive: true,
+        debug: false
+      });
+
+      // Wait for initialization attempt
+      await new Promise(resolve => setTimeout(resolve, 2000));
+
+      expect(chat).toBeDefined();
+      expect(chat.agent.enableMcp).toBe(true);
+      // MCP bridge should be null due to failed connection
+      expect(chat.agent.mcpBridge).toBeNull();
+
+      await chat.cleanup();
+    }, 10000);
+
+    test('should handle cleanup errors gracefully', async () => {
+      process.env.PROBE_NON_INTERACTIVE = '1';
+
+      const chat = new ProbeChat({
+        enableMcp: true,
+        isNonInteractive: true,
+        debug: false
+      });
+
+      // Mock the agent cleanup to throw an error
+      const originalCleanup = chat.agent.cleanup;
+      chat.agent.cleanup = jest.fn().mockRejectedValue(new Error('Cleanup failed'));
+
+      // Should not throw even if underlying cleanup fails
+      await expect(chat.cleanup()).resolves.not.toThrow();
+
+      // Restore original cleanup
+      chat.agent.cleanup = originalCleanup;
+      await chat.cleanup();
+    });
+  });
+
+  describe('Environment Variable Handling', () => {
+    test('should respect ENABLE_MCP environment variable', async () => {
+      process.env.ENABLE_MCP = '1';
+      process.env.PROBE_NON_INTERACTIVE = '1';
+      process.env.DEBUG_CHAT = '1';
+
+      const chat = new ProbeChat({
+        isNonInteractive: true
+      });
+
+      expect(chat.agent.enableMcp).toBe(true);
+      expect(chat.debug).toBe(true);
+
+      await chat.cleanup();
+    });
+
+    test('should respect DEBUG_CHAT environment variable', async () => {
+      process.env.DEBUG_CHAT = '1';
+      process.env.PROBE_NON_INTERACTIVE = '1';
+
+      const chat = new ProbeChat({
+        isNonInteractive: true
+      });
+
+      expect(chat.debug).toBe(true);
+
+      await chat.cleanup();
+    });
+
+    test('should handle non-interactive mode properly', async () => {
+      process.env.PROBE_NON_INTERACTIVE = '1';
+
+      const chat = new ProbeChat();
+
+      expect(chat.isNonInteractive).toBe(true);
+
+      await chat.cleanup();
+    });
+  });
+});

package/data/probe/npm/tests/integration/mcpDotenvSupport.test.js

@@ -0,0 +1,174 @@
+/**
+ * Integration tests for MCP Server .env file loading
+ */
+
+import { jest } from '@jest/globals';
+import { spawn } from 'child_process';
+import { join } from 'path';
+import { mkdtemp, writeFile, rm } from 'fs/promises';
+import { tmpdir } from 'os';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+describe('MCP Server .env Support', () => {
+  let tempDir;
+
+  beforeEach(async () => {
+    tempDir = await mkdtemp(join(tmpdir(), 'mcp-dotenv-test-'));
+  });
+
+  afterEach(async () => {
+    if (tempDir) {
+      await rm(tempDir, { recursive: true, force: true });
+    }
+  });
+
+  test('should load environment variables from .env file', async () => {
+    // Create a .env file in the temp directory
+    const envContent = `
+TEST_VAR=from_dotenv
+PROBE_PATH=/custom/probe/path
+DEBUG=true
+    `.trim();
+
+    await writeFile(join(tempDir, '.env'), envContent);
+
+    // Test using dotenv directly (simulating what MCP server does)
+    const dotenv = await import('dotenv');
+    const result = dotenv.config({ path: join(tempDir, '.env') });
+
+    expect(result.error).toBeUndefined();
+    expect(result.parsed).toEqual({
+      TEST_VAR: 'from_dotenv',
+      PROBE_PATH: '/custom/probe/path',
+      DEBUG: 'true'
+    });
+  });
+
+  test('should not fail if .env file does not exist', async () => {
+    // Test using dotenv with non-existent file (simulating what MCP server does)
+    const dotenv = await import('dotenv');
+    const result = dotenv.config({ path: join(tempDir, '.env') });
+
+    // dotenv.config() should not throw when file doesn't exist
+    // It returns an error object but doesn't throw
+    expect(result.error).toBeDefined();
+    expect(result.error.code).toBe('ENOENT');
+    // When there's an error, parsed is an empty object
+    expect(result.parsed).toEqual({});
+  });
+
+  test('should prioritize existing environment variables over .env', async () => {
+    // Create a .env file
+    const envContent = `
+TEST_PRIORITY=from_dotenv
+    `.trim();
+
+    await writeFile(join(tempDir, '.env'), envContent);
+
+    // Set an environment variable
+    const originalValue = process.env.TEST_PRIORITY;
+    process.env.TEST_PRIORITY = 'from_environment';
+
+    try {
+      // Test using dotenv
+      const dotenv = await import('dotenv');
+      const result = dotenv.config({ path: join(tempDir, '.env') });
+
+      expect(result.error).toBeUndefined();
+      // dotenv by default does not override existing env vars
+      expect(process.env.TEST_PRIORITY).toBe('from_environment');
+    } finally {
+      // Clean up
+      if (originalValue !== undefined) {
+        process.env.TEST_PRIORITY = originalValue;
+      } else {
+        delete process.env.TEST_PRIORITY;
+      }
+    }
+  });
+
+  test('MCP server should have dotenv loaded at startup', async () => {
+    // This test verifies that the MCP server index.ts has dotenv import
+    const { readFile } = await import('fs/promises');
+    const mcpIndexPath = join(__dirname, '..', '..', 'src', 'mcp', 'index.ts');
+
+    const content = await readFile(mcpIndexPath, 'utf8');
+
+    // Check that dotenv is imported
+    expect(content).toContain("import { config } from 'dotenv'");
+
+    // Check that config() is called
+    expect(content).toContain('config()');
+
+    // Check that the dotenv import is near the top (before other imports)
+    const lines = content.split('\n');
+    const dotenvImportLine = lines.findIndex(line => line.includes("import { config } from 'dotenv'"));
+    const configCallLine = lines.findIndex(line => line.includes('config()'));
+    const firstRegularImport = lines.findIndex(line =>
+      line.includes('import') &&
+      !line.includes('dotenv') &&
+      !line.includes('#!/usr/bin/env node')
+    );
+
+    // dotenv should be imported and called before other imports
+    expect(dotenvImportLine).toBeGreaterThan(-1);
+    expect(configCallLine).toBeGreaterThan(-1);
+    expect(dotenvImportLine).toBeLessThan(firstRegularImport);
+  });
+
+  test('ProbeAgent should have dotenv loaded at startup', async () => {
+    // This test verifies that ProbeAgent.js has dotenv import
+    const { readFile } = await import('fs/promises');
+    const probeAgentPath = join(__dirname, '..', '..', 'src', 'agent', 'ProbeAgent.js');
+
+    const content = await readFile(probeAgentPath, 'utf8');
+
+    // Check that dotenv is imported
+    expect(content).toContain("import dotenv from 'dotenv'");
+
+    // Check that config() is called
+    expect(content).toContain('dotenv.config()');
+
+    // Check that the dotenv import is near the top (before other imports)
+    const lines = content.split('\n');
+    const dotenvImportLine = lines.findIndex(line => line.includes("import dotenv from 'dotenv'"));
+    const configCallLine = lines.findIndex(line => line.includes('dotenv.config()'));
+
+    // dotenv should be imported and called at the top
+    expect(dotenvImportLine).toBeGreaterThan(-1);
+    expect(configCallLine).toBeGreaterThan(-1);
+    expect(dotenvImportLine).toBeLessThan(10); // Should be in first 10 lines
+  });
+
+  test('Main package index should have dotenv loaded at startup', async () => {
+    // This test verifies that index.js has dotenv import
+    const { readFile } = await import('fs/promises');
+    const indexPath = join(__dirname, '..', '..', 'src', 'index.js');
+
+    const content = await readFile(indexPath, 'utf8');
+
+    // Check that dotenv is imported
+    expect(content).toContain("import dotenv from 'dotenv'");
+
+    // Check that config() is called
+    expect(content).toContain('dotenv.config()');
+  });
+
+  test('Agent CLI index should have dotenv loaded at startup', async () => {
+    // This test verifies that agent/index.js has dotenv import
+    const { readFile } = await import('fs/promises');
+    const agentIndexPath = join(__dirname, '..', '..', 'src', 'agent', 'index.js');
+
+    const content = await readFile(agentIndexPath, 'utf8');
+
+    // Check that dotenv is imported
+    expect(content).toContain("import dotenv from 'dotenv'");
+
+    // Check that config() is called
+    expect(content).toContain('dotenv.config()');
+  });
+});