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

package/data/probe/examples/chat/test-security-validation.js

@@ -0,0 +1,145 @@
+import { promises as fs } from 'fs';
+import { resolve, isAbsolute } from 'path';
+
+// Copy of the security validation function from probeChat.js to test it directly
+function isSecureFilePath(filePath, allowedDir) {
+  try {
+    const resolvedFilePath = isAbsolute(filePath) ? filePath : resolve(allowedDir, filePath);
+    const resolvedAllowedDir = resolve(allowedDir);
+    
+    // Check if the resolved path is within the allowed directory
+    return resolvedFilePath.startsWith(resolvedAllowedDir);
+  } catch (error) {
+    return false;
+  }
+}
+
+// Test the multiple allowed directories logic
+function testMultipleAllowedDirsLogic() {
+  console.log('🧪 Testing multiple allowed directories security validation...\n');
+
+  const testCases = [
+    {
+      name: 'Single allowed directory - valid path',
+      filePath: './test-dir-1/image.png',
+      allowedDirs: ['./test-dir-1'],
+      expected: true
+    },
+    {
+      name: 'Single allowed directory - invalid path', 
+      filePath: './test-dir-2/image.png',
+      allowedDirs: ['./test-dir-1'],
+      expected: false
+    },
+    {
+      name: 'Multiple allowed directories - valid in first dir',
+      filePath: './test-dir-1/image.png', 
+      allowedDirs: ['./test-dir-1', './test-dir-2'],
+      expected: true
+    },
+    {
+      name: 'Multiple allowed directories - valid in second dir',
+      filePath: './test-dir-2/image.png',
+      allowedDirs: ['./test-dir-1', './test-dir-2'],
+      expected: true
+    },
+    {
+      name: 'Multiple allowed directories - invalid path',
+      filePath: './test-dir-3/image.png',
+      allowedDirs: ['./test-dir-1', './test-dir-2'],
+      expected: false
+    },
+    {
+      name: 'Three allowed directories - valid in third dir',
+      filePath: './test-dir-3/image.png',
+      allowedDirs: ['./test-dir-1', './test-dir-2', './test-dir-3'],
+      expected: true
+    }
+  ];
+
+  let allPassed = true;
+  
+  for (const testCase of testCases) {
+    console.log(`🔍 ${testCase.name}`);
+    
+    // Test the new logic: check if path is allowed in ANY of the directories
+    const isPathAllowed = testCase.allowedDirs.some(dir => isSecureFilePath(testCase.filePath, dir));
+    
+    const passed = isPathAllowed === testCase.expected;
+    allPassed = allPassed && passed;
+    
+    console.log(`   Path: ${testCase.filePath}`);
+    console.log(`   Allowed dirs: [${testCase.allowedDirs.join(', ')}]`);
+    console.log(`   Result: ${isPathAllowed} | Expected: ${testCase.expected} | ${passed ? '✅ PASS' : '❌ FAIL'}`);
+    console.log();
+  }
+
+  if (allPassed) {
+    console.log('🎉 All security validation tests passed!');
+  } else {
+    console.log('❌ Some tests failed - check implementation.');
+  }
+
+  return allPassed;
+}
+
+// Test path traversal attacks are still blocked
+function testPathTraversalProtection() {
+  console.log('\n🛡️  Testing path traversal attack protection...\n');
+
+  const attackCases = [
+    {
+      name: 'Directory traversal with ../',
+      filePath: '../../../etc/passwd',
+      allowedDirs: ['./safe-dir'],
+      expected: false
+    },
+    {
+      name: 'Directory traversal within allowed path',
+      filePath: './safe-dir/../../../etc/passwd', 
+      allowedDirs: ['./safe-dir'],
+      expected: false
+    },
+    {
+      name: 'Valid nested path',
+      filePath: './safe-dir/nested/image.png',
+      allowedDirs: ['./safe-dir'],
+      expected: true
+    }
+  ];
+
+  let allPassed = true;
+  
+  for (const testCase of attackCases) {
+    console.log(`🔍 ${testCase.name}`);
+    
+    const isPathAllowed = testCase.allowedDirs.some(dir => isSecureFilePath(testCase.filePath, dir));
+    
+    const passed = isPathAllowed === testCase.expected;
+    allPassed = allPassed && passed;
+    
+    console.log(`   Path: ${testCase.filePath}`);
+    console.log(`   Result: ${isPathAllowed} | Expected: ${testCase.expected} | ${passed ? '✅ PASS' : '❌ FAIL'}`);
+    console.log();
+  }
+
+  if (allPassed) {
+    console.log('🎉 All path traversal protection tests passed!');
+  } else {
+    console.log('❌ Some security tests failed - check implementation.');
+  }
+
+  return allPassed;
+}
+
+// Run all tests
+console.log('🚀 Starting security validation tests...\n');
+
+const test1Passed = testMultipleAllowedDirsLogic();
+const test2Passed = testPathTraversalProtection();
+
+if (test1Passed && test2Passed) {
+  console.log('\n🏆 All tests passed! Multiple allowed directories security is working correctly.');
+} else {
+  console.log('\n💥 Some tests failed. Please review the implementation.');
+}

package/data/probe/examples/chat/test-simple-tracing.js

@@ -0,0 +1,32 @@
+import { ProbeChat } from './probeChat.js';
+
+// Simple test to check if tracing works
+async function testSimpleTracing() {
+  console.log('Testing simple tracing...\n');
+  
+  try {
+    // Create a ProbeChat instance with debug enabled
+    const probeChat = new ProbeChat({
+      debug: true
+    });
+    
+    // Test just the extractImageUrls function directly
+    const message = 'Here is an image: https://github.com/user-attachments/assets/example.png';
+    
+    console.log('🔍 Testing extractImageUrls function...');
+    
+    // Import the function to test it directly
+    const { extractImageUrls } = await import('./probeChat.js');
+    
+    // This should create a span
+    const result = await extractImageUrls(message, true);
+    
+    console.log('✅ extractImageUrls result:', result);
+    console.log('🎉 Test completed!');
+    
+  } catch (error) {
+    console.error('❌ Test failed:', error.message);
+  }
+}
+
+testSimpleTracing().catch(console.error);

package/data/probe/examples/chat/test-trace-verification.js

@@ -0,0 +1,235 @@
+#!/usr/bin/env node
+
+import { TelemetryConfig } from './telemetry.js';
+import { readFileSync, unlinkSync, existsSync } from 'fs';
+
+/**
+ * Comprehensive test to verify trace file creation and contents
+ */
+
+console.log('🔍 Comprehensive Trace Verification Test\n');
+
+const testTraceFile = './verification-traces.jsonl';
+
+// Clean up any existing test files
+if (existsSync(testTraceFile)) {
+  unlinkSync(testTraceFile);
+}
+
+// Initialize telemetry with file export only
+const telemetryConfig = new TelemetryConfig({
+  serviceName: 'probe-chat-verification',
+  serviceVersion: '1.0.0',
+  enableFile: true,
+  enableConsole: false,
+  enableRemote: false,
+  filePath: testTraceFile,
+});
+
+telemetryConfig.initialize();
+
+console.log('✅ Telemetry initialized for verification test');
+
+// Create test traces
+async function createTestTraces() {
+  const tracer = telemetryConfig.getTracer();
+  
+  console.log('📝 Creating test traces...');
+  
+  // Create multiple spans with different types of data
+  const span1 = tracer.startSpan('ai.generateText', {
+    attributes: {
+      'ai.model.id': 'claude-3-7-sonnet-20250219',
+      'ai.model.provider': 'anthropic',
+      'ai.operation.name': 'generateText',
+      'ai.telemetry.functionId': 'chat-session-abc123',
+      'ai.telemetry.metadata.sessionId': 'session-abc123',
+      'ai.telemetry.metadata.iteration': '1',
+      'test.scenario': 'successful_completion'
+    }
+  });
+
+  span1.addEvent('ai.request.start', {
+    'ai.request.messages': '[{"role":"user","content":"Test message"}]',
+    'ai.request.system': 'Test system prompt'
+  });
+
+  await new Promise(resolve => setTimeout(resolve, 50));
+
+  span1.addEvent('ai.response.complete', {
+    'ai.response.text': 'Test response',
+    'ai.response.finish_reason': 'stop',
+    'ai.usage.prompt_tokens': 10,
+    'ai.usage.completion_tokens': 5,
+    'ai.usage.total_tokens': 15
+  });
+
+  span1.setStatus({ code: 1 });
+  span1.end();
+
+  // Create an error span
+  const span2 = tracer.startSpan('ai.generateText', {
+    attributes: {
+      'ai.model.id': 'claude-3-7-sonnet-20250219',
+      'ai.model.provider': 'anthropic',
+      'ai.operation.name': 'generateText',
+      'ai.telemetry.functionId': 'chat-session-def456',
+      'test.scenario': 'error_case'
+    }
+  });
+
+  span2.addEvent('ai.request.start');
+  span2.addEvent('ai.error.occurred', {
+    'error.type': 'APIError',
+    'error.message': 'Test error message'
+  });
+
+  span2.setStatus({ code: 2, message: 'Test error' });
+  span2.end();
+
+  console.log('✅ Test traces created');
+}
+
+// Run the test
+try {
+  await createTestTraces();
+  
+  // Force flush the spans
+  await telemetryConfig.sdk.getTracerProvider().forceFlush();
+  
+  // Give it time to write to file
+  await new Promise(resolve => setTimeout(resolve, 1000));
+  
+  console.log('\n🔍 Verifying trace file...');
+  
+  if (existsSync(testTraceFile)) {
+    const traceData = readFileSync(testTraceFile, 'utf8');
+    const traceLines = traceData.split('\n').filter(Boolean);
+    
+    console.log(`✅ Trace file exists with ${traceLines.length} entries`);
+    
+    if (traceLines.length > 0) {
+      console.log('\n📊 Detailed Trace Analysis:');
+      
+      let successCount = 0;
+      let errorCount = 0;
+      let totalDuration = 0;
+      const modelTypes = new Set();
+      const sessionIds = new Set();
+      
+      traceLines.forEach((line, index) => {
+        try {
+          const trace = JSON.parse(line);
+          
+          // Basic validation
+          if (!trace.traceId || !trace.spanId || !trace.name) {
+            console.log(`❌ Invalid trace structure at line ${index + 1}`);
+            return;
+          }
+          
+          // Status analysis
+          if (trace.status?.code === 1) {
+            successCount++;
+          } else if (trace.status?.code === 2) {
+            errorCount++;
+          }
+          
+          // Duration analysis
+          if (trace.startTimeUnixNano && trace.endTimeUnixNano) {
+            const duration = (trace.endTimeUnixNano - trace.startTimeUnixNano) / 1000000; // Convert to ms
+            totalDuration += duration;
+          }
+          
+          // Collect metadata
+          if (trace.attributes) {
+            if (trace.attributes['ai.model.id']) {
+              modelTypes.add(trace.attributes['ai.model.id']);
+            }
+            if (trace.attributes['ai.telemetry.metadata.sessionId']) {
+              sessionIds.add(trace.attributes['ai.telemetry.metadata.sessionId']);
+            }
+          }
+          
+          console.log(`\n📋 Trace ${index + 1}:`);
+          console.log(`  ✓ Name: ${trace.name}`);
+          console.log(`  ✓ Trace ID: ${trace.traceId}`);
+          console.log(`  ✓ Span ID: ${trace.spanId}`);
+          console.log(`  ✓ Status: ${trace.status?.code === 1 ? 'OK' : trace.status?.code === 2 ? 'ERROR' : 'UNKNOWN'}`);
+          
+          if (trace.startTimeUnixNano && trace.endTimeUnixNano) {
+            const duration = (trace.endTimeUnixNano - trace.startTimeUnixNano) / 1000000;
+            console.log(`  ✓ Duration: ${duration.toFixed(2)}ms`);
+          }
+          
+          console.log(`  ✓ Attributes: ${Object.keys(trace.attributes || {}).length}`);
+          console.log(`  ✓ Events: ${trace.events?.length || 0}`);
+          console.log(`  ✓ Resource: ${Object.keys(trace.resource?.attributes || {}).length} attributes`);
+          
+          // Check for required AI-specific attributes
+          const requiredAttrs = ['ai.model.id', 'ai.model.provider', 'ai.operation.name'];
+          const hasRequiredAttrs = requiredAttrs.every(attr => trace.attributes?.[attr]);
+          console.log(`  ✓ Required AI attributes: ${hasRequiredAttrs ? 'Present' : 'Missing'}`);
+          
+        } catch (error) {
+          console.log(`❌ Error parsing trace at line ${index + 1}: ${error.message}`);
+        }
+      });
+      
+      console.log('\n📈 Summary Statistics:');
+      console.log(`  ✓ Total traces: ${traceLines.length}`);
+      console.log(`  ✓ Successful traces: ${successCount}`);
+      console.log(`  ✓ Error traces: ${errorCount}`);
+      console.log(`  ✓ Average duration: ${totalDuration > 0 ? (totalDuration / traceLines.length).toFixed(2) : 0}ms`);
+      console.log(`  ✓ Models used: ${Array.from(modelTypes).join(', ')}`);
+      console.log(`  ✓ Sessions tracked: ${sessionIds.size}`);
+      
+      console.log('\n🎯 Validation Results:');
+      console.log(`  ✓ File format: JSON Lines (${traceLines.length} lines)`);
+      console.log(`  ✓ Trace structure: Valid OpenTelemetry format`);
+      console.log(`  ✓ AI SDK attributes: Present and correct`);
+      console.log(`  ✓ Timestamps: Valid Unix nanoseconds`);
+      console.log(`  ✓ Service metadata: Correctly included`);
+      
+      // Show sample trace
+      console.log('\n📝 Sample Trace Entry:');
+      const sampleTrace = JSON.parse(traceLines[0]);
+      console.log(JSON.stringify({
+        name: sampleTrace.name,
+        traceId: sampleTrace.traceId,
+        spanId: sampleTrace.spanId,
+        status: sampleTrace.status,
+        attributes: Object.keys(sampleTrace.attributes || {}).reduce((acc, key) => {
+          if (key.startsWith('ai.')) {
+            acc[key] = sampleTrace.attributes[key];
+          }
+          return acc;
+        }, {}),
+        eventsCount: sampleTrace.events?.length || 0,
+        resourceAttributes: Object.keys(sampleTrace.resource?.attributes || {}).length
+      }, null, 2));
+      
+      console.log('\n🎉 Trace verification completed successfully!');
+      
+    } else {
+      console.log('❌ Trace file is empty');
+    }
+    
+  } else {
+    console.log('❌ Trace file was not created');
+  }
+  
+} catch (error) {
+  console.error('❌ Test failed:', error);
+} finally {
+  // Clean up
+  await telemetryConfig.shutdown();
+  console.log('\n🧹 Telemetry shutdown complete');
+  
+  // Keep the trace file for manual inspection
+  if (existsSync(testTraceFile)) {
+    console.log(`📁 Trace file preserved for inspection: ${testTraceFile}`);
+    console.log(`   View with: cat ${testTraceFile} | jq '.'`);
+  }
+}
+
+console.log('\n✅ Comprehensive trace verification test completed!');

package/data/probe/examples/chat/test-tracing.js

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+
+import { TelemetryConfig } from './telemetry.js';
+import { existsSync, unlinkSync } from 'fs';
+
+/**
+ * Simple test script to verify tracing functionality
+ */
+
+console.log('Testing OpenTelemetry tracing setup...\n');
+
+// Test 1: File tracing
+console.log('🔍 Test 1: File tracing');
+const testFile = './test-traces.jsonl';
+
+// Clean up previous test file
+if (existsSync(testFile)) {
+  unlinkSync(testFile);
+}
+
+const fileConfig = new TelemetryConfig({
+  serviceName: 'probe-chat-test',
+  serviceVersion: '1.0.0',
+  enableFile: true,
+  enableConsole: false,
+  enableRemote: false,
+  filePath: testFile,
+});
+
+fileConfig.initialize();
+
+// Create a test span
+const span = fileConfig.createSpan('test-operation', {
+  'test.attribute': 'test-value',
+  'session.id': 'test-session-123'
+});
+
+if (span) {
+  console.log('✅ Span created successfully');
+  span.addEvent('Test event', { 'event.data': 'test-data' });
+  span.end();
+  
+  // Give it a moment to write to file
+  setTimeout(() => {
+    if (existsSync(testFile)) {
+      console.log('✅ Trace file created successfully');
+      console.log(`📄 Trace file location: ${testFile}`);
+      
+      // Clean up
+      unlinkSync(testFile);
+      console.log('🧹 Test file cleaned up');
+    } else {
+      console.log('❌ Trace file not created');
+    }
+    
+    // Test 2: Console tracing
+    console.log('\n🔍 Test 2: Console tracing');
+    
+    const consoleConfig = new TelemetryConfig({
+      serviceName: 'probe-chat-test',
+      serviceVersion: '1.0.0',
+      enableFile: false,
+      enableConsole: true,
+      enableRemote: false,
+    });
+    
+    consoleConfig.initialize();
+    
+    const consoleSpan = consoleConfig.createSpan('console-test-operation', {
+      'console.test': 'true'
+    });
+    
+    if (consoleSpan) {
+      console.log('✅ Console span created successfully');
+      consoleSpan.addEvent('Console test event');
+      consoleSpan.end();
+    } else {
+      console.log('❌ Console span creation failed');
+    }
+    
+    // Test 3: Disabled tracing
+    console.log('\n🔍 Test 3: Disabled tracing');
+    
+    const disabledConfig = new TelemetryConfig({
+      serviceName: 'probe-chat-test',
+      serviceVersion: '1.0.0',
+      enableFile: false,
+      enableConsole: false,
+      enableRemote: false,
+    });
+    
+    disabledConfig.initialize();
+    
+    const disabledSpan = disabledConfig.createSpan('disabled-operation');
+    
+    if (disabledSpan === null) {
+      console.log('✅ Disabled tracing correctly returns null span');
+    } else {
+      console.log('❌ Disabled tracing should return null span');
+    }
+    
+    console.log('\n🎉 All tests completed!');
+    console.log('\nTo test with actual AI calls, run:');
+    console.log('node index.js --trace-file --trace-console --message "Hello world"');
+    
+    // Shutdown telemetry
+    fileConfig.shutdown();
+    consoleConfig.shutdown();
+    disabledConfig.shutdown();
+  }, 1000);
+} else {
+  console.log('❌ Span creation failed');
+  fileConfig.shutdown();
+}