cache-overflow-mcp 0.3.3 → 0.3.5

package/src/logger.ts

@@ -0,0 +1,150 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+interface LogEntry {
+  timestamp: string;
+  level: 'ERROR' | 'WARN' | 'INFO';
+  message: string;
+  error?: {
+    name: string;
+    message: string;
+    stack?: string;
+  };
+  context?: Record<string, unknown>;
+}
+
+class Logger {
+  private logFilePath: string;
+  private maxLogSizeBytes = 5 * 1024 * 1024; // 5MB max log file size
+
+  constructor() {
+    // Determine log file location
+    const logDir = process.env.CACHE_OVERFLOW_LOG_DIR ?? path.join(os.homedir(), '.cache-overflow');
+
+    // Ensure log directory exists
+    if (!fs.existsSync(logDir)) {
+      try {
+        fs.mkdirSync(logDir, { recursive: true });
+      } catch (err) {
+        // Fallback to temp directory if home directory is not writable
+        const tempLogDir = path.join(os.tmpdir(), 'cache-overflow');
+        if (!fs.existsSync(tempLogDir)) {
+          fs.mkdirSync(tempLogDir, { recursive: true });
+        }
+        this.logFilePath = path.join(tempLogDir, 'cache-overflow-mcp.log');
+        return;
+      }
+    }
+
+    this.logFilePath = path.join(logDir, 'cache-overflow-mcp.log');
+  }
+
+  private rotateLogIfNeeded(): void {
+    try {
+      if (fs.existsSync(this.logFilePath)) {
+        const stats = fs.statSync(this.logFilePath);
+        if (stats.size >= this.maxLogSizeBytes) {
+          // Rotate: keep the last 1MB of the file
+          const content = fs.readFileSync(this.logFilePath, 'utf-8');
+          const lines = content.split('\n');
+          const keptLines = lines.slice(-1000); // Keep last 1000 lines
+          fs.writeFileSync(this.logFilePath, keptLines.join('\n') + '\n');
+        }
+      }
+    } catch (err) {
+      // Ignore rotation errors - don't want logging to break the app
+    }
+  }
+
+  private sanitizeContext(context?: Record<string, unknown>): Record<string, unknown> | undefined {
+    if (!context) return undefined;
+
+    const sanitized: Record<string, unknown> = {};
+    for (const [key, value] of Object.entries(context)) {
+      // Sanitize sensitive fields
+      if (key.toLowerCase().includes('token') ||
+          key.toLowerCase().includes('password') ||
+          key.toLowerCase().includes('secret') ||
+          key.toLowerCase().includes('auth')) {
+        sanitized[key] = '[REDACTED]';
+      } else if (typeof value === 'object' && value !== null) {
+        sanitized[key] = this.sanitizeContext(value as Record<string, unknown>);
+      } else {
+        sanitized[key] = value;
+      }
+    }
+    return sanitized;
+  }
+
+  private writeLog(entry: LogEntry): void {
+    try {
+      this.rotateLogIfNeeded();
+      const logLine = JSON.stringify(entry) + '\n';
+      fs.appendFileSync(this.logFilePath, logLine);
+    } catch (err) {
+      // If we can't write to log file, write to stderr as fallback
+      console.error('Failed to write to log file:', err);
+      console.error('Original log entry:', entry);
+    }
+  }
+
+  error(message: string, error?: Error, context?: Record<string, unknown>): void {
+    const entry: LogEntry = {
+      timestamp: new Date().toISOString(),
+      level: 'ERROR',
+      message,
+      context: this.sanitizeContext(context),
+    };
+
+    if (error) {
+      entry.error = {
+        name: error.name,
+        message: error.message,
+        stack: error.stack,
+      };
+    }
+
+    this.writeLog(entry);
+  }
+
+  warn(message: string, context?: Record<string, unknown>): void {
+    const entry: LogEntry = {
+      timestamp: new Date().toISOString(),
+      level: 'WARN',
+      message,
+      context: this.sanitizeContext(context),
+    };
+
+    this.writeLog(entry);
+  }
+
+  info(message: string, context?: Record<string, unknown>): void {
+    const entry: LogEntry = {
+      timestamp: new Date().toISOString(),
+      level: 'INFO',
+      message,
+      context: this.sanitizeContext(context),
+    };
+
+    this.writeLog(entry);
+  }
+
+  getLogFilePath(): string {
+    return this.logFilePath;
+  }
+
+  logStartup(): void {
+    this.info('MCP Server starting', {
+      version: '0.3.5',
+      nodeVersion: process.version,
+      platform: process.platform,
+      arch: process.arch,
+      apiUrl: process.env.CACHE_OVERFLOW_URL ?? 'https://cache-overflow.onrender.com/api',
+      hasAuthToken: !!process.env.CACHE_OVERFLOW_TOKEN,
+    });
+  }
+}
+
+// Singleton instance
+export const logger = new Logger();

package/src/server.ts

@@ -9,6 +9,7 @@ import {
 import { CacheOverflowClient } from './client.js';
 import { tools } from './tools/index.js';
 import { prompts } from './prompts/index.js';
+import { logger } from './logger.js';
 
 export class CacheOverflowServer {
   private server: Server;
@@ -18,7 +19,7 @@ export class CacheOverflowServer {
     this.server = new Server(
       {
         name: 'cache-overflow',
-        version: '0.3.0',
+        version: '0.3.5',
       },
       {
         capabilities: {
@@ -41,9 +42,28 @@ export class CacheOverflowServer {
     this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
       const tool = tools.find((t) => t.definition.name === request.params.name);
       if (!tool) {
-        throw new Error(`Unknown tool: ${request.params.name}`);
+        const error = new Error(`Unknown tool: ${request.params.name}`);
+        logger.error('Unknown tool requested', error, {
+          toolName: request.params.name,
+          availableTools: tools.map(t => t.definition.name),
+        });
+        throw error;
+      }
+
+      try {
+        logger.info(`Executing tool: ${request.params.name}`, {
+          toolName: request.params.name,
+          // Don't log full arguments as they might contain sensitive data
+          hasArguments: Object.keys(request.params.arguments ?? {}).length > 0,
+        });
+        return await tool.handler(request.params.arguments ?? {}, this.client);
+      } catch (error) {
+        logger.error(`Tool execution failed: ${request.params.name}`, error as Error, {
+          toolName: request.params.name,
+          errorType: 'TOOL_EXECUTION_FAILURE',
+        });
+        throw error;
       }
-      return tool.handler(request.params.arguments ?? {}, this.client);
     });
 
     // Prompt handlers
@@ -54,14 +74,36 @@ export class CacheOverflowServer {
     this.server.setRequestHandler(GetPromptRequestSchema, async (request) => {
       const prompt = prompts.find((p) => p.definition.name === request.params.name);
       if (!prompt) {
-        throw new Error(`Unknown prompt: ${request.params.name}`);
+        const error = new Error(`Unknown prompt: ${request.params.name}`);
+        logger.error('Unknown prompt requested', error, {
+          promptName: request.params.name,
+          availablePrompts: prompts.map(p => p.definition.name),
+        });
+        throw error;
+      }
+
+      try {
+        return await prompt.handler(request.params.arguments ?? {});
+      } catch (error) {
+        logger.error(`Prompt execution failed: ${request.params.name}`, error as Error, {
+          promptName: request.params.name,
+          errorType: 'PROMPT_EXECUTION_FAILURE',
+        });
+        throw error;
       }
-      return prompt.handler(request.params.arguments ?? {});
     });
   }
 
   async start(): Promise<void> {
-    const transport = new StdioServerTransport();
-    await this.server.connect(transport);
+    try {
+      const transport = new StdioServerTransport();
+      await this.server.connect(transport);
+      logger.info('MCP server connected successfully via stdio transport');
+    } catch (error) {
+      logger.error('Failed to connect MCP server', error as Error, {
+        errorType: 'CONNECTION_FAILURE',
+      });
+      throw error;
+    }
   }
 }

package/src/testing/mock-data.ts

@@ -1,142 +1,142 @@
-import type { Solution, FindSolutionResult, Balance } from '../types.js';
-
-export const mockSolutions: Solution[] = [
-  {
-    id: 'sol_001',
-    author_id: 'user_123',
-    query_title: 'How to implement binary search in TypeScript',
-    solution_body: `function binarySearch<T>(arr: T[], target: T): number {
-  let left = 0;
-  let right = arr.length - 1;
-  while (left <= right) {
-    const mid = Math.floor((left + right) / 2);
-    if (arr[mid] === target) return mid;
-    if (arr[mid] < target) left = mid + 1;
-    else right = mid - 1;
-  }
-  return -1;
-}`,
-    price_current: 50,
-    verification_state: 'VERIFIED',
-    access_count: 127,
-    upvotes: 45,
-    downvotes: 2,
-  },
-  {
-    id: 'sol_002',
-    author_id: 'user_456',
-    query_title: 'Fix memory leak in Node.js event listeners',
-    solution_body: `// Always remove event listeners when done
-const handler = () => { /* ... */ };
-emitter.on('event', handler);
-// Later:
-emitter.off('event', handler);
-
-// Or use once() for one-time listeners
-emitter.once('event', () => { /* ... */ });`,
-    price_current: 75,
-    verification_state: 'VERIFIED',
-    access_count: 89,
-    upvotes: 32,
-    downvotes: 1,
-  },
-  {
-    id: 'sol_003',
-    author_id: 'user_789',
-    query_title: 'Optimize React re-renders with useMemo',
-    solution_body: `import { useMemo } from 'react';
-
-function ExpensiveComponent({ data }) {
-  const processed = useMemo(() => {
-    return data.map(item => heavyComputation(item));
-  }, [data]);
-
-  return <div>{processed}</div>;
-}`,
-    price_current: 60,
-    verification_state: 'PENDING',
-    access_count: 15,
-    upvotes: 8,
-    downvotes: 0,
-  },
-];
-
-export const mockFindResults: FindSolutionResult[] = [
-  {
-    solution_id: 'sol_001',
-    query_title: 'How to implement binary search in TypeScript',
-    human_verification_required: false,
-  },
-  {
-    solution_id: 'sol_002',
-    query_title: 'Fix memory leak in Node.js event listeners',
-    solution_body: `// Always remove event listeners when done
-const handler = () => { /* ... */ };
-emitter.on('event', handler);
-// Later:
-emitter.off('event', handler);
-
-// Or use once() for one-time listeners
-emitter.once('event', () => { /* ... */ });`,
-    human_verification_required: true,
-  },
-  {
-    solution_id: 'sol_003',
-    query_title: 'Optimize React re-renders with useMemo',
-    solution_body: `import { useMemo } from 'react';
-
-function ExpensiveComponent({ data }) {
-  const processed = useMemo(() => {
-    return data.map(item => heavyComputation(item));
-  }, [data]);
-
-  return <div>{processed}</div>;
-}`,
-    human_verification_required: false,
-  },
-];
-
-export const mockBalance: Balance = {
-  available: 1500,
-  pending_debits: 75,
-  pending_credits: 200,
-  total_earned: 3500,
-  total_spent: 1800,
-};
-
-export function createMockSolution(overrides: Partial<Solution> = {}): Solution {
-  return {
-    id: `sol_${Date.now()}`,
-    author_id: 'user_mock',
-    query_title: 'Mock solution title',
-    solution_body: 'Mock solution body content',
-    price_current: 50,
-    verification_state: 'PENDING',
-    access_count: 0,
-    upvotes: 0,
-    downvotes: 0,
-    ...overrides,
-  };
-}
-
-export function createMockFindResult(
-  overrides: Partial<FindSolutionResult> = {}
-): FindSolutionResult {
-  return {
-    solution_id: `sol_${Date.now()}`,
-    query_title: 'Mock query title',
-    human_verification_required: false,
-    ...overrides,
-  };
-}
-
-export function createMockBalance(overrides: Partial<Balance> = {}): Balance {
-  return {
-    available: 1000,
-    pending_debits: 0,
-    pending_credits: 0,
-    total_earned: 1000,
-    total_spent: 0,
-    ...overrides,
-  };
-}
+import type { Solution, FindSolutionResult, Balance } from '../types.js';
+
+export const mockSolutions: Solution[] = [
+  {
+    id: 'sol_001',
+    author_id: 'user_123',
+    query_title: 'How to implement binary search in TypeScript',
+    solution_body: `function binarySearch<T>(arr: T[], target: T): number {
+  let left = 0;
+  let right = arr.length - 1;
+  while (left <= right) {
+    const mid = Math.floor((left + right) / 2);
+    if (arr[mid] === target) return mid;
+    if (arr[mid] < target) left = mid + 1;
+    else right = mid - 1;
+  }
+  return -1;
+}`,
+    price_current: 50,
+    verification_state: 'VERIFIED',
+    access_count: 127,
+    upvotes: 45,
+    downvotes: 2,
+  },
+  {
+    id: 'sol_002',
+    author_id: 'user_456',
+    query_title: 'Fix memory leak in Node.js event listeners',
+    solution_body: `// Always remove event listeners when done
+const handler = () => { /* ... */ };
+emitter.on('event', handler);
+// Later:
+emitter.off('event', handler);
+
+// Or use once() for one-time listeners
+emitter.once('event', () => { /* ... */ });`,
+    price_current: 75,
+    verification_state: 'VERIFIED',
+    access_count: 89,
+    upvotes: 32,
+    downvotes: 1,
+  },
+  {
+    id: 'sol_003',
+    author_id: 'user_789',
+    query_title: 'Optimize React re-renders with useMemo',
+    solution_body: `import { useMemo } from 'react';
+
+function ExpensiveComponent({ data }) {
+  const processed = useMemo(() => {
+    return data.map(item => heavyComputation(item));
+  }, [data]);
+
+  return <div>{processed}</div>;
+}`,
+    price_current: 60,
+    verification_state: 'PENDING',
+    access_count: 15,
+    upvotes: 8,
+    downvotes: 0,
+  },
+];
+
+export const mockFindResults: FindSolutionResult[] = [
+  {
+    solution_id: 'sol_001',
+    query_title: 'How to implement binary search in TypeScript',
+    human_verification_required: false,
+  },
+  {
+    solution_id: 'sol_002',
+    query_title: 'Fix memory leak in Node.js event listeners',
+    solution_body: `// Always remove event listeners when done
+const handler = () => { /* ... */ };
+emitter.on('event', handler);
+// Later:
+emitter.off('event', handler);
+
+// Or use once() for one-time listeners
+emitter.once('event', () => { /* ... */ });`,
+    human_verification_required: true,
+  },
+  {
+    solution_id: 'sol_003',
+    query_title: 'Optimize React re-renders with useMemo',
+    solution_body: `import { useMemo } from 'react';
+
+function ExpensiveComponent({ data }) {
+  const processed = useMemo(() => {
+    return data.map(item => heavyComputation(item));
+  }, [data]);
+
+  return <div>{processed}</div>;
+}`,
+    human_verification_required: false,
+  },
+];
+
+export const mockBalance: Balance = {
+  available: 1500,
+  pending_debits: 75,
+  pending_credits: 200,
+  total_earned: 3500,
+  total_spent: 1800,
+};
+
+export function createMockSolution(overrides: Partial<Solution> = {}): Solution {
+  return {
+    id: `sol_${Date.now()}`,
+    author_id: 'user_mock',
+    query_title: 'Mock solution title',
+    solution_body: 'Mock solution body content',
+    price_current: 50,
+    verification_state: 'PENDING',
+    access_count: 0,
+    upvotes: 0,
+    downvotes: 0,
+    ...overrides,
+  };
+}
+
+export function createMockFindResult(
+  overrides: Partial<FindSolutionResult> = {}
+): FindSolutionResult {
+  return {
+    solution_id: `sol_${Date.now()}`,
+    query_title: 'Mock query title',
+    human_verification_required: false,
+    ...overrides,
+  };
+}
+
+export function createMockBalance(overrides: Partial<Balance> = {}): Balance {
+  return {
+    available: 1000,
+    pending_debits: 0,
+    pending_credits: 0,
+    total_earned: 1000,
+    total_spent: 0,
+    ...overrides,
+  };
+}