mcp-rubber-duck 1.1.0

package/src/utils/logger.ts

@@ -0,0 +1,116 @@
+import winston from 'winston';
+import { existsSync, mkdirSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { homedir } from 'os';
+
+const logLevel = process.env.LOG_LEVEL || 'info';
+const isMCP = process.env.MCP_SERVER === 'true' || process.argv.includes('--mcp');
+
+// Determine logs directory based on environment and execution context
+function getLogsDirectory(): string {
+  // Allow custom logs directory via environment variable
+  if (process.env.LOGS_DIR) {
+    return process.env.LOGS_DIR;
+  }
+
+  try {
+    // Try to use project directory when possible (development/direct execution)
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = dirname(__filename);
+    const projectRoot = join(__dirname, '..', '..');
+    const projectLogsDir = join(projectRoot, 'logs');
+    
+    // Check if we can write to project directory
+    if (existsSync(projectRoot)) {
+      return projectLogsDir;
+    }
+  } catch (error) {
+    // Fall through to user directory if project root detection fails
+  }
+
+  // Fallback to user directory for MCP server or when project root isn't writable
+  return join(homedir(), '.mcp-rubber-duck', 'logs');
+}
+
+// Ensure logs directory exists
+const logsDir = getLogsDirectory();
+if (!existsSync(logsDir)) {
+  mkdirSync(logsDir, { recursive: true });
+}
+
+// Use simpler format for MCP to avoid interfering with JSON communication
+const consoleFormat = isMCP 
+  ? winston.format.simple()
+  : winston.format.combine(
+      winston.format.colorize(),
+      winston.format.simple()
+    );
+
+// File format with more details for debugging crashes
+const fileFormat = winston.format.combine(
+  winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }),
+  winston.format.errors({ stack: true }),
+  winston.format.splat(),
+  winston.format.printf(({ timestamp, level, message, stack, ...meta }) => {
+    let log = `${String(timestamp)} [${String(level).toUpperCase()}]: ${String(message)}`;
+    if (stack && typeof stack === 'string') {
+      log += `\nStack: ${stack}`;
+    }
+    if (Object.keys(meta).length > 0) {
+      log += `\nMeta: ${JSON.stringify(meta, null, 2)}`;
+    }
+    return log;
+  })
+);
+
+export const logger = winston.createLogger({
+  level: logLevel,
+  format: winston.format.combine(
+    winston.format.timestamp(),
+    winston.format.errors({ stack: true }),
+    winston.format.splat(),
+    winston.format.json()
+  ),
+  transports: [
+    new winston.transports.Console({
+      format: consoleFormat,
+      silent: isMCP, // Always silence console logs in MCP mode to avoid interfering with JSON-RPC
+    }),
+  ],
+});
+
+// Always add file logging for better crash diagnosis
+const filePrefix = isMCP ? 'mcp' : 'server';
+
+// Error log
+logger.add(
+  new winston.transports.File({
+    filename: join(logsDir, `${filePrefix}-error.log`),
+    level: 'error',
+    format: fileFormat,
+    maxsize: 10 * 1024 * 1024, // 10MB
+    maxFiles: 5,
+  })
+);
+
+// Combined log
+logger.add(
+  new winston.transports.File({
+    filename: join(logsDir, `${filePrefix}-combined.log`),
+    format: fileFormat,
+    maxsize: 50 * 1024 * 1024, // 50MB
+    maxFiles: 3,
+  })
+);
+
+// Crash log for fatal errors
+logger.add(
+  new winston.transports.File({
+    filename: join(logsDir, `${filePrefix}-crash.log`),
+    level: 'error',
+    format: fileFormat,
+    maxsize: 10 * 1024 * 1024, // 10MB
+    maxFiles: 10,
+  })
+);

package/src/utils/safe-logger.ts

@@ -0,0 +1,165 @@
+import { logger } from './logger.js';
+
+// List of fields that should be sanitized in logs
+const SENSITIVE_FIELDS = [
+  'password',
+  'apiKey',
+  'api_key',
+  'token',
+  'secret',
+  'auth',
+  'authorization',
+  'cookie',
+  'session',
+  'private_key',
+  'privateKey',
+  'client_secret',
+  'clientSecret',
+];
+
+// List of field patterns to look for
+const SENSITIVE_PATTERNS = [
+  /password/i,
+  /secret/i,
+  /token/i,
+  /key$/i,
+  /auth/i,
+  /cookie/i,
+  /session/i,
+];
+
+/**
+ * Sanitizes an object by redacting sensitive fields
+ */
+function sanitizeObject(obj: unknown, maxDepth = 5, currentDepth = 0): unknown {
+  if (currentDepth >= maxDepth) {
+    return '[Max depth exceeded]';
+  }
+
+  if (obj === null || obj === undefined) {
+    return obj;
+  }
+
+  if (typeof obj === 'string') {
+    // Check if the string looks like a sensitive value (e.g., long random strings)
+    if (obj.length > 20 && /^[a-zA-Z0-9+/=]{20,}$/.test(obj)) {
+      return `[REDACTED:${obj.length}chars]`;
+    }
+    return obj;
+  }
+
+  if (typeof obj === 'number' || typeof obj === 'boolean') {
+    return obj;
+  }
+
+  if (Array.isArray(obj)) {
+    return obj.map((item: unknown) => sanitizeObject(item, maxDepth, currentDepth + 1));
+  }
+
+  if (typeof obj === 'object') {
+    const sanitized: Record<string, unknown> = {};
+    
+    for (const [key, value] of Object.entries(obj as Record<string, unknown>)) {
+      const keyLower = key.toLowerCase();
+      
+      // Check if the field name is sensitive
+      const isSensitive = SENSITIVE_FIELDS.includes(keyLower) ||
+        SENSITIVE_PATTERNS.some(pattern => pattern.test(key));
+      
+      if (isSensitive) {
+        if (typeof value === 'string' && value.length > 0) {
+          sanitized[key] = `[REDACTED:${value.length}chars]`;
+        } else {
+          sanitized[key] = '[REDACTED]';
+        }
+      } else {
+        sanitized[key] = sanitizeObject(value, maxDepth, currentDepth + 1);
+      }
+    }
+    
+    return sanitized;
+  }
+
+  return obj;
+}
+
+/**
+ * Safe logger that sanitizes sensitive data before logging
+ */
+export class SafeLogger {
+  static debug(message: string, data?: unknown): void {
+    if (data) {
+      const sanitizedData = sanitizeObject(data);
+      logger.debug(message, sanitizedData);
+    } else {
+      logger.debug(message);
+    }
+  }
+
+  static info(message: string, data?: unknown): void {
+    if (data) {
+      const sanitizedData = sanitizeObject(data);
+      logger.info(message, sanitizedData);
+    } else {
+      logger.info(message);
+    }
+  }
+
+  static warn(message: string, data?: unknown): void {
+    if (data) {
+      const sanitizedData = sanitizeObject(data);
+      logger.warn(message, sanitizedData);
+    } else {
+      logger.warn(message);
+    }
+  }
+
+  static error(message: string, data?: unknown): void {
+    if (data) {
+      const sanitizedData = sanitizeObject(data);
+      logger.error(message, sanitizedData);
+    } else {
+      logger.error(message);
+    }
+  }
+
+  /**
+   * Sanitize arguments object specifically for MCP tool calls
+   */
+  static sanitizeToolArgs(args: unknown): unknown {
+    const sanitized = sanitizeObject(args);
+    
+    // Additional sanitization for common patterns in tool arguments
+    if (typeof sanitized === 'object' && sanitized !== null) {
+      const objSanitized = sanitized as Record<string, unknown>;
+      // Sanitize file paths that might contain usernames
+      if (objSanitized.path && typeof objSanitized.path === 'string') {
+        objSanitized.path = objSanitized.path.replace(/\/Users\/[^/]+/, '/Users/[USER]');
+        objSanitized.path = (objSanitized.path as string).replace(/\\Users\\[^\\]+/, '\\Users\\[USER]');
+      }
+      
+      // Sanitize URLs that might contain credentials
+      if (objSanitized.url && typeof objSanitized.url === 'string') {
+        objSanitized.url = objSanitized.url.replace(
+          /(https?:\/\/)([^:]+):([^@]+)@/,
+          '$1[USER]:[REDACTED]@'
+        );
+      }
+    }
+    
+    return sanitized;
+  }
+
+  /**
+   * Create a safe message for approval requests
+   */
+  static createApprovalMessage(duckName: string, server: string, tool: string, args: unknown): string {
+    const sanitizedArgs = this.sanitizeToolArgs(args);
+    const argsStr = JSON.stringify(sanitizedArgs, null, 2);
+    
+    return `Duck "${duckName}" wants to call ${server}:${tool} with arguments:\n${argsStr}`;
+  }
+}
+
+// Export the sanitize function for direct use
+export { sanitizeObject };

package/systemd/mcp-rubber-duck-with-ollama.service

@@ -0,0 +1,55 @@
+[Unit]
+Description=MCP Rubber Duck with Ollama - Multi-LLM AI Assistant
+Documentation=https://github.com/nesquikm/mcp-rubber-duck
+After=docker.service network-online.target
+Wants=network-online.target
+Requires=docker.service
+
+[Service]
+Type=forking
+Restart=always
+RestartSec=15
+TimeoutStartSec=600
+TimeoutStopSec=180
+
+# User and group
+User=pi
+Group=pi
+
+# Working directory (adjust path as needed)
+WorkingDirectory=/home/pi/mcp-rubber-duck
+
+# Environment
+Environment=COMPOSE_PROJECT_NAME=mcp-rubber-duck
+Environment=COMPOSE_FILE=docker-compose.yml
+Environment=COMPOSE_PROFILES=with-ollama
+
+# Commands
+ExecStartPre=/usr/bin/docker compose -f ${COMPOSE_FILE} down
+ExecStart=/usr/bin/docker compose -f ${COMPOSE_FILE} --profile with-ollama up -d
+ExecStop=/usr/bin/docker compose -f ${COMPOSE_FILE} down
+ExecReload=/usr/bin/docker compose -f ${COMPOSE_FILE} --profile with-ollama restart
+
+# Health check (wait longer for Ollama to start)
+ExecStartPost=/bin/sleep 60
+ExecStartPost=/bin/sh -c 'docker inspect --format="{{.State.Health.Status}}" mcp-rubber-duck | grep -q healthy || exit 1'
+
+# Logging
+StandardOutput=journal
+StandardError=journal
+SyslogIdentifier=mcp-rubber-duck-ollama
+
+# Security settings
+NoNewPrivileges=yes
+PrivateTmp=yes
+PrivateDevices=yes
+ProtectHome=yes
+ProtectSystem=strict
+ReadWritePaths=/home/pi/mcp-rubber-duck
+
+# Resource limits (higher for Ollama)
+MemoryMax=2G
+CPUQuota=300%
+
+[Install]
+WantedBy=multi-user.target

package/systemd/mcp-rubber-duck.service

@@ -0,0 +1,58 @@
+[Unit]
+Description=MCP Rubber Duck - Multi-LLM AI Assistant
+Documentation=https://github.com/nesquikm/mcp-rubber-duck
+After=docker.service network-online.target
+Wants=network-online.target
+Requires=docker.service
+
+# If using Ollama, also wait for it
+# After=docker.service network-online.target ollama.service
+# Wants=network-online.target ollama.service
+
+[Service]
+Type=forking
+Restart=always
+RestartSec=10
+TimeoutStartSec=300
+TimeoutStopSec=120
+
+# User and group
+User=pi
+Group=pi
+
+# Working directory (adjust path as needed)
+WorkingDirectory=/home/pi/mcp-rubber-duck
+
+# Environment
+Environment=COMPOSE_PROJECT_NAME=mcp-rubber-duck
+Environment=COMPOSE_FILE=docker-compose.yml
+
+# Commands
+ExecStartPre=/usr/bin/docker compose -f ${COMPOSE_FILE} down
+ExecStart=/usr/bin/docker compose -f ${COMPOSE_FILE} up -d
+ExecStop=/usr/bin/docker compose -f ${COMPOSE_FILE} down
+ExecReload=/usr/bin/docker compose -f ${COMPOSE_FILE} restart
+
+# Health check
+ExecStartPost=/bin/sleep 30
+ExecStartPost=/bin/sh -c 'docker inspect --format="{{.State.Health.Status}}" mcp-rubber-duck | grep -q healthy || exit 1'
+
+# Logging
+StandardOutput=journal
+StandardError=journal
+SyslogIdentifier=mcp-rubber-duck
+
+# Security settings
+NoNewPrivileges=yes
+PrivateTmp=yes
+PrivateDevices=yes
+ProtectHome=yes
+ProtectSystem=strict
+ReadWritePaths=/home/pi/mcp-rubber-duck
+
+# Resource limits (adjust based on your Pi model)
+MemoryMax=1G
+CPUQuota=200%
+
+[Install]
+WantedBy=multi-user.target

package/test-functionality.js

@@ -0,0 +1,147 @@
+#!/usr/bin/env node
+
+// Test script for MCP Rubber Duck functionality
+import 'dotenv/config';
+import { RubberDuckServer } from './dist/server.js';
+import { ConfigManager } from './dist/config/config.js';
+import { ProviderManager } from './dist/providers/manager.js';
+import { ConversationManager } from './dist/services/conversation.js';
+import { ResponseCache } from './dist/services/cache.js';
+import { HealthMonitor } from './dist/services/health.js';
+
+// Import tools
+import { askDuckTool } from './dist/tools/ask-duck.js';
+import { listDucksTool } from './dist/tools/list-ducks.js';
+import { listModelsTool } from './dist/tools/list-models.js';
+import { compareDucksTool } from './dist/tools/compare-ducks.js';
+import { duckCouncilTool } from './dist/tools/duck-council.js';
+import { chatDuckTool } from './dist/tools/chat-duck.js';
+
+console.log('🦆 Testing MCP Rubber Duck Functionality\n');
+console.log('API Keys loaded from .env:');
+console.log(`- OpenAI: ${process.env.OPENAI_API_KEY ? '✅ Found' : '❌ Missing'}`);
+console.log(`- Gemini: ${process.env.GEMINI_API_KEY ? '✅ Found' : '❌ Missing'}\n`);
+
+async function runTests() {
+  try {
+    // Initialize managers
+    const configManager = new ConfigManager();
+    const providerManager = new ProviderManager(configManager);
+    const conversationManager = new ConversationManager();
+    const cache = new ResponseCache(300);
+    const healthMonitor = new HealthMonitor(providerManager);
+
+    // Test 1: List all ducks
+    console.log('📋 Test 1: List all ducks');
+    const ducksResult = await listDucksTool(providerManager, healthMonitor, { check_health: false });
+    console.log(ducksResult.content[0].text);
+    console.log('\n---\n');
+
+    // Test 2: Check health of all ducks
+    console.log('🏥 Test 2: Health check');
+    await healthMonitor.performHealthChecks();
+    const healthyProviders = healthMonitor.getHealthyProviders();
+    console.log(`Healthy providers: ${healthyProviders.join(', ')}`);
+    console.log('\n---\n');
+
+    // Test 3: List models for all providers
+    console.log('📚 Test 3: List available models');
+    const modelsResult = await listModelsTool(providerManager, {});
+    console.log(modelsResult.content[0].text);
+    console.log('\n---\n');
+
+    // Test 4: Ask OpenAI
+    console.log('🦆 Test 4: Ask OpenAI');
+    try {
+      const openaiResult = await askDuckTool(providerManager, cache, {
+        prompt: 'What is 2+2? Answer in one word.',
+        provider: 'openai'
+      });
+      console.log(openaiResult.content[0].text);
+    } catch (error) {
+      console.error(`OpenAI error: ${error.message}`);
+    }
+    console.log('\n---\n');
+
+    // Test 5: Ask Gemini
+    console.log('🦆 Test 5: Ask Gemini');
+    try {
+      const geminiResult = await askDuckTool(providerManager, cache, {
+        prompt: 'What is 3+3? Answer in one word.',
+        provider: 'gemini'
+      });
+      console.log(geminiResult.content[0].text);
+    } catch (error) {
+      console.error(`Gemini error: ${error.message}`);
+    }
+    console.log('\n---\n');
+
+    // Test 6: Compare ducks
+    console.log('🔍 Test 6: Compare ducks');
+    try {
+      const compareResult = await compareDucksTool(providerManager, cache, {
+        prompt: 'What is the capital of France? Answer in one word.'
+      });
+      console.log(compareResult.content[0].text);
+    } catch (error) {
+      console.error(`Compare error: ${error.message}`);
+    }
+    console.log('\n---\n');
+
+    // Test 7: Duck council
+    console.log('🏛️ Test 7: Duck council');
+    try {
+      const councilResult = await duckCouncilTool(providerManager, {
+        prompt: 'What is the meaning of life? Answer in exactly 5 words.'
+      });
+      console.log(councilResult.content[0].text);
+    } catch (error) {
+      console.error(`Council error: ${error.message}`);
+    }
+    console.log('\n---\n');
+
+    // Test 8: Chat with context
+    console.log('💬 Test 8: Chat with context');
+    try {
+      // First message
+      await chatDuckTool(providerManager, conversationManager, {
+        conversation_id: 'test-chat',
+        message: 'My name is Alice.',
+        provider: 'openai'
+      });
+      
+      // Second message using context
+      const chatResult = await chatDuckTool(providerManager, conversationManager, {
+        conversation_id: 'test-chat',
+        message: 'What is my name?'
+      });
+      console.log(chatResult.content[0].text);
+    } catch (error) {
+      console.error(`Chat error: ${error.message}`);
+    }
+    console.log('\n---\n');
+
+    // Test 9: Test specific model
+    console.log('🎯 Test 9: Test specific model');
+    try {
+      const modelResult = await askDuckTool(providerManager, cache, {
+        prompt: 'Say hello',
+        provider: 'openai',
+        model: 'gpt-4o-mini'
+      });
+      console.log(modelResult.content[0].text);
+    } catch (error) {
+      console.error(`Model test error: ${error.message}`);
+    }
+
+    console.log('\n✅ All tests completed!');
+
+  } catch (error) {
+    console.error('Fatal error:', error);
+  }
+  
+  process.exit(0);
+}
+
+// Run tests
+runTests().catch(console.error);