cache-overflow-mcp 0.3.4 → 0.3.5

package/scripts/view-logs.js

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+
+/**
+ * Simple script to help users locate and view their cache.overflow MCP logs
+ */
+
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const homeLogPath = path.join(os.homedir(), '.cache-overflow', 'cache-overflow-mcp.log');
+const tempLogPath = path.join(os.tmpdir(), 'cache-overflow', 'cache-overflow-mcp.log');
+const customLogPath = process.env.CACHE_OVERFLOW_LOG_DIR
+  ? path.join(process.env.CACHE_OVERFLOW_LOG_DIR, 'cache-overflow-mcp.log')
+  : null;
+
+console.log('🔍 Looking for cache.overflow MCP log file...\n');
+
+// Check custom location first
+if (customLogPath && fs.existsSync(customLogPath)) {
+  console.log('✅ Found log file at custom location:');
+  console.log(`   ${customLogPath}\n`);
+  displayLog(customLogPath);
+}
+// Check home directory
+else if (fs.existsSync(homeLogPath)) {
+  console.log('✅ Found log file at default location:');
+  console.log(`   ${homeLogPath}\n`);
+  displayLog(homeLogPath);
+}
+// Check temp directory
+else if (fs.existsSync(tempLogPath)) {
+  console.log('✅ Found log file at fallback location:');
+  console.log(`   ${tempLogPath}\n`);
+  displayLog(tempLogPath);
+}
+// No log file found
+else {
+  console.log('❌ No log file found. Checked locations:');
+  console.log(`   ${homeLogPath}`);
+  console.log(`   ${tempLogPath}`);
+  if (customLogPath) {
+    console.log(`   ${customLogPath}`);
+  }
+  console.log('\nThe log file is created when the MCP server starts.');
+  console.log('Make sure cache.overflow-mcp has been run at least once.\n');
+  process.exit(1);
+}
+
+function displayLog(logPath) {
+  const stats = fs.statSync(logPath);
+  const sizeKB = (stats.size / 1024).toFixed(2);
+
+  console.log(`📊 File size: ${sizeKB} KB`);
+  console.log(`🕐 Last modified: ${stats.mtime.toLocaleString()}\n`);
+
+  // Read the file
+  const content = fs.readFileSync(logPath, 'utf-8');
+  const lines = content.trim().split('\n').filter(line => line.trim());
+
+  console.log(`📝 Total log entries: ${lines.length}\n`);
+
+  // Count by level
+  const levels = { ERROR: 0, WARN: 0, INFO: 0 };
+  lines.forEach(line => {
+    try {
+      const entry = JSON.parse(line);
+      if (entry.level in levels) {
+        levels[entry.level]++;
+      }
+    } catch (e) {
+      // Skip invalid JSON lines
+    }
+  });
+
+  console.log('📈 Log level breakdown:');
+  console.log(`   ERROR: ${levels.ERROR}`);
+  console.log(`   WARN:  ${levels.WARN}`);
+  console.log(`   INFO:  ${levels.INFO}\n`);
+
+  // Show last 10 entries
+  const recentLines = lines.slice(-10);
+  console.log('📋 Last 10 log entries:\n');
+  console.log('─'.repeat(80));
+
+  recentLines.forEach(line => {
+    try {
+      const entry = JSON.parse(line);
+      const timestamp = new Date(entry.timestamp).toLocaleString();
+      const level = entry.level.padEnd(5);
+      const icon = entry.level === 'ERROR' ? '❌' : entry.level === 'WARN' ? '⚠️' : 'ℹ️';
+
+      console.log(`${icon} [${timestamp}] ${level} ${entry.message}`);
+
+      if (entry.error) {
+        console.log(`   Error: ${entry.error.name}: ${entry.error.message}`);
+      }
+
+      if (entry.context && Object.keys(entry.context).length > 0) {
+        console.log(`   Context: ${JSON.stringify(entry.context)}`);
+      }
+
+      console.log('─'.repeat(80));
+    } catch (e) {
+      console.log(line);
+      console.log('─'.repeat(80));
+    }
+  });
+
+  console.log(`\n💡 To view the full log file, run:`);
+  if (process.platform === 'win32') {
+    console.log(`   type "${logPath}"`);
+  } else {
+    console.log(`   cat "${logPath}"`);
+  }
+
+  console.log(`\n💡 To follow logs in real-time, run:`);
+  if (process.platform === 'win32') {
+    console.log(`   Get-Content "${logPath}" -Wait`);
+  } else {
+    console.log(`   tail -f "${logPath}"`);
+  }
+
+  console.log('');
+}

package/src/cli.ts

@@ -1,10 +1,23 @@
-#!/usr/bin/env node
-
-import { CacheOverflowServer } from './server.js';
-
-async function main() {
-  const server = new CacheOverflowServer();
-  await server.start();
-}
-
-main().catch(console.error);
+#!/usr/bin/env node
+
+import { CacheOverflowServer } from './server.js';
+import { logger } from './logger.js';
+
+async function main() {
+  // Log startup information
+  logger.logStartup();
+  logger.info(`Log file location: ${logger.getLogFilePath()}`);
+
+  const server = new CacheOverflowServer();
+  await server.start();
+}
+
+main().catch((error) => {
+  logger.error('Fatal error during server startup', error, {
+    errorType: 'STARTUP_FAILURE',
+  });
+  console.error('Fatal error:', error);
+  console.error(`\nError details have been logged to: ${logger.getLogFilePath()}`);
+  console.error('Please send this log file when reporting issues.');
+  process.exit(1);
+});

package/src/client.test.ts

@@ -1,116 +1,116 @@
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-import { CacheOverflowClient } from './client.js';
-import { MockServer } from './testing/mock-server.js';
-import { mockSolutions, mockFindResults } from './testing/mock-data.js';
-
-describe('CacheOverflowClient', () => {
-  let mockServer: MockServer;
-  let client: CacheOverflowClient;
-
-  beforeAll(async () => {
-    mockServer = new MockServer();
-    await mockServer.start();
-    client = new CacheOverflowClient(mockServer.url);
-  });
-
-  afterAll(async () => {
-    await mockServer.stop();
-  });
-
-  describe('findSolution', () => {
-    it('should return search results', async () => {
-      const result = await client.findSolution('binary search');
-
-      expect(result.success).toBe(true);
-      if (result.success) {
-        expect(Array.isArray(result.data)).toBe(true);
-        expect(result.data.length).toBeGreaterThan(0);
-        expect(result.data[0]).toHaveProperty('solution_id');
-        expect(result.data[0]).toHaveProperty('query_title');
-        expect(result.data[0]).toHaveProperty('human_verification_required');
-      }
-    });
-
-    it('should return results matching the query', async () => {
-      const result = await client.findSolution('TypeScript');
-
-      expect(result.success).toBe(true);
-      if (result.success) {
-        const hasTypeScript = result.data.some((r) =>
-          r.query_title.toLowerCase().includes('typescript')
-        );
-        expect(hasTypeScript).toBe(true);
-      }
-    });
-  });
-
-  describe('unlockSolution', () => {
-    it('should return the unlocked solution', async () => {
-      const result = await client.unlockSolution(mockSolutions[0].id);
-
-      expect(result.success).toBe(true);
-      if (result.success) {
-        expect(result.data).toHaveProperty('id');
-        expect(result.data).toHaveProperty('solution_body');
-        expect(result.data).toHaveProperty('price_current');
-        expect(result.data).toHaveProperty('verification_state');
-      }
-    });
-
-    it('should return a solution even for unknown IDs', async () => {
-      const result = await client.unlockSolution('unknown_id');
-
-      expect(result.success).toBe(true);
-      if (result.success) {
-        expect(result.data).toHaveProperty('id');
-      }
-    });
-  });
-
-  describe('publishSolution', () => {
-    it('should create a new solution', async () => {
-      const result = await client.publishSolution(
-        'How to test async code in Vitest',
-        'Use async/await with expect().resolves or expect().rejects'
-      );
-
-      expect(result.success).toBe(true);
-      if (result.success) {
-        expect(result.data).toHaveProperty('id');
-        expect(result.data.query_title).toBe('How to test async code in Vitest');
-        expect(result.data.solution_body).toBe(
-          'Use async/await with expect().resolves or expect().rejects'
-        );
-        expect(result.data.verification_state).toBe('PENDING');
-      }
-    });
-  });
-
-  describe('submitVerification', () => {
-    it('should submit verification successfully', async () => {
-      const result = await client.submitVerification(mockSolutions[0].id, true);
-
-      expect(result.success).toBe(true);
-    });
-
-    it('should allow marking as unsafe', async () => {
-      const result = await client.submitVerification(mockSolutions[0].id, false);
-
-      expect(result.success).toBe(true);
-    });
-  });
-
-  describe('submitFeedback', () => {
-    it('should submit positive feedback', async () => {
-      const result = await client.submitFeedback(mockSolutions[0].id, true);
-
-      expect(result.success).toBe(true);
-    });
-
-    it('should submit negative feedback', async () => {
-      const result = await client.submitFeedback(mockSolutions[0].id, false);
-
-      expect(result.success).toBe(true);
-    });
-  });
-});
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { CacheOverflowClient } from './client.js';
+import { MockServer } from './testing/mock-server.js';
+import { mockSolutions, mockFindResults } from './testing/mock-data.js';
+
+describe('CacheOverflowClient', () => {
+  let mockServer: MockServer;
+  let client: CacheOverflowClient;
+
+  beforeAll(async () => {
+    mockServer = new MockServer();
+    await mockServer.start();
+    client = new CacheOverflowClient(mockServer.url);
+  });
+
+  afterAll(async () => {
+    await mockServer.stop();
+  });
+
+  describe('findSolution', () => {
+    it('should return search results', async () => {
+      const result = await client.findSolution('binary search');
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(Array.isArray(result.data)).toBe(true);
+        expect(result.data.length).toBeGreaterThan(0);
+        expect(result.data[0]).toHaveProperty('solution_id');
+        expect(result.data[0]).toHaveProperty('query_title');
+        expect(result.data[0]).toHaveProperty('human_verification_required');
+      }
+    });
+
+    it('should return results matching the query', async () => {
+      const result = await client.findSolution('TypeScript');
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        const hasTypeScript = result.data.some((r) =>
+          r.query_title.toLowerCase().includes('typescript')
+        );
+        expect(hasTypeScript).toBe(true);
+      }
+    });
+  });
+
+  describe('unlockSolution', () => {
+    it('should return the unlocked solution', async () => {
+      const result = await client.unlockSolution(mockSolutions[0].id);
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.data).toHaveProperty('id');
+        expect(result.data).toHaveProperty('solution_body');
+        expect(result.data).toHaveProperty('price_current');
+        expect(result.data).toHaveProperty('verification_state');
+      }
+    });
+
+    it('should return a solution even for unknown IDs', async () => {
+      const result = await client.unlockSolution('unknown_id');
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.data).toHaveProperty('id');
+      }
+    });
+  });
+
+  describe('publishSolution', () => {
+    it('should create a new solution', async () => {
+      const result = await client.publishSolution(
+        'How to test async code in Vitest',
+        'Use async/await with expect().resolves or expect().rejects'
+      );
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.data).toHaveProperty('id');
+        expect(result.data.query_title).toBe('How to test async code in Vitest');
+        expect(result.data.solution_body).toBe(
+          'Use async/await with expect().resolves or expect().rejects'
+        );
+        expect(result.data.verification_state).toBe('PENDING');
+      }
+    });
+  });
+
+  describe('submitVerification', () => {
+    it('should submit verification successfully', async () => {
+      const result = await client.submitVerification(mockSolutions[0].id, true);
+
+      expect(result.success).toBe(true);
+    });
+
+    it('should allow marking as unsafe', async () => {
+      const result = await client.submitVerification(mockSolutions[0].id, false);
+
+      expect(result.success).toBe(true);
+    });
+  });
+
+  describe('submitFeedback', () => {
+    it('should submit positive feedback', async () => {
+      const result = await client.submitFeedback(mockSolutions[0].id, true);
+
+      expect(result.success).toBe(true);
+    });
+
+    it('should submit negative feedback', async () => {
+      const result = await client.submitFeedback(mockSolutions[0].id, false);
+
+      expect(result.success).toBe(true);
+    });
+  });
+});

package/src/client.ts

@@ -1,76 +1,122 @@
-import { ApiResponse, Solution, FindSolutionResult } from './types.js';
-import { config } from './config.js';
-
-export class CacheOverflowClient {
-  private apiUrl: string;
-  private authToken: string | undefined;
-
-  constructor(apiUrl?: string) {
-    this.apiUrl = apiUrl ?? config.api.url;
-    this.authToken = config.auth.token;
-  }
-
-  private async request<T>(
-    method: string,
-    path: string,
-    body?: unknown
-  ): Promise<ApiResponse<T>> {
-    const headers: Record<string, string> = {
-      'Content-Type': 'application/json',
-    };
-
-    if (this.authToken) {
-      headers['Authorization'] = `Bearer ${this.authToken}`;
-    }
-
-    const response = await fetch(`${this.apiUrl}${path}`, {
-      method,
-      headers,
-      body: body ? JSON.stringify(body) : undefined,
-    });
-
-    const data = (await response.json()) as Record<string, unknown>;
-
-    if (!response.ok) {
-      return { success: false, error: (data.error as string) ?? 'Unknown error' };
-    }
-
-    return { success: true, data: data as T };
-  }
-
-  async findSolution(query: string): Promise<ApiResponse<FindSolutionResult[]>> {
-    return this.request('GET', `/solutions/search?query=${encodeURIComponent(query)}`);
-  }
-
-  async unlockSolution(solutionId: string): Promise<ApiResponse<Solution>> {
-    return this.request('POST', `/solutions/${solutionId}/unlock`);
-  }
-
-  async publishSolution(
-    queryTitle: string,
-    solutionBody: string
-  ): Promise<ApiResponse<Solution>> {
-    return this.request('POST', '/solutions', {
-      query_title: queryTitle,
-      solution_body: solutionBody,
-    });
-  }
-
-  async submitVerification(
-    solutionId: string,
-    isSafe: boolean
-  ): Promise<ApiResponse<void>> {
-    return this.request('POST', `/solutions/${solutionId}/verify`, {
-      is_safe: isSafe,
-    });
-  }
-
-  async submitFeedback(
-    solutionId: string,
-    isUseful: boolean
-  ): Promise<ApiResponse<void>> {
-    return this.request('POST', `/solutions/${solutionId}/feedback`, {
-      is_useful: isUseful,
-    });
-  }
-}
+import { ApiResponse, Solution, FindSolutionResult } from './types.js';
+import { config } from './config.js';
+import { logger } from './logger.js';
+
+export class CacheOverflowClient {
+  private apiUrl: string;
+  private authToken: string | undefined;
+
+  constructor(apiUrl?: string) {
+    this.apiUrl = apiUrl ?? config.api.url;
+    this.authToken = config.auth.token;
+  }
+
+  private async request<T>(
+    method: string,
+    path: string,
+    body?: unknown
+  ): Promise<ApiResponse<T>> {
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json',
+    };
+
+    if (this.authToken) {
+      headers['Authorization'] = `Bearer ${this.authToken}`;
+    }
+
+    const url = `${this.apiUrl}${path}`;
+
+    try {
+      const response = await fetch(url, {
+        method,
+        headers,
+        body: body ? JSON.stringify(body) : undefined,
+      });
+
+      // Read response as text first, then try to parse as JSON
+      const textResponse = await response.text();
+      const contentType = response.headers.get('content-type');
+      let data: Record<string, unknown>;
+
+      try {
+        data = JSON.parse(textResponse) as Record<string, unknown>;
+      } catch (jsonError) {
+        // If JSON parsing fails, log and return the text as error
+        logger.error('API returned non-JSON response', jsonError as Error, {
+          method,
+          path,
+          statusCode: response.status,
+          contentType,
+          responseText: textResponse.substring(0, 200), // Log first 200 chars
+          errorType: 'INVALID_JSON_RESPONSE',
+        });
+
+        // Return the text as an error message
+        return {
+          success: false,
+          error: textResponse || 'Invalid response from server'
+        };
+      }
+
+      if (!response.ok) {
+        const errorMessage = (data.error as string) ?? 'Unknown error';
+        logger.error('API request failed', undefined, {
+          method,
+          path,
+          statusCode: response.status,
+          errorMessage,
+          errorType: 'API_ERROR',
+        });
+        return { success: false, error: errorMessage };
+      }
+
+      return { success: true, data: data as T };
+    } catch (error) {
+      logger.error('Network or fetch error during API request', error as Error, {
+        method,
+        path,
+        url,
+        errorType: 'NETWORK_ERROR',
+      });
+
+      // Re-throw network errors so they can be handled by the caller
+      throw error;
+    }
+  }
+
+  async findSolution(query: string): Promise<ApiResponse<FindSolutionResult[]>> {
+    return this.request('GET', `/solutions/search?query=${encodeURIComponent(query)}`);
+  }
+
+  async unlockSolution(solutionId: string): Promise<ApiResponse<Solution>> {
+    return this.request('POST', `/solutions/${solutionId}/unlock`);
+  }
+
+  async publishSolution(
+    queryTitle: string,
+    solutionBody: string
+  ): Promise<ApiResponse<Solution>> {
+    return this.request('POST', '/solutions', {
+      query_title: queryTitle,
+      solution_body: solutionBody,
+    });
+  }
+
+  async submitVerification(
+    solutionId: string,
+    isSafe: boolean
+  ): Promise<ApiResponse<void>> {
+    return this.request('POST', `/solutions/${solutionId}/verify`, {
+      is_safe: isSafe,
+    });
+  }
+
+  async submitFeedback(
+    solutionId: string,
+    isUseful: boolean
+  ): Promise<ApiResponse<void>> {
+    return this.request('POST', `/solutions/${solutionId}/feedback`, {
+      is_useful: isUseful,
+    });
+  }
+}

package/src/config.ts

@@ -1,9 +1,14 @@
-export const config = {
-  api: {
-    url: process.env.CACHE_OVERFLOW_URL ?? 'https://cache-overflow.onrender.com/api',
-    timeout: parseInt(process.env.CACHE_OVERFLOW_TIMEOUT ?? '30000'),
-  },
-  auth: {
-    token: process.env.CACHE_OVERFLOW_TOKEN,
-  },
-};
+export const config = {
+  api: {
+    url: process.env.CACHE_OVERFLOW_URL ?? 'https://cache-overflow.onrender.com/api',
+    timeout: parseInt(process.env.CACHE_OVERFLOW_TIMEOUT ?? '30000'),
+  },
+  auth: {
+    token: process.env.CACHE_OVERFLOW_TOKEN,
+  },
+  logging: {
+    // Directory where log files will be written
+    // Default: ~/.cache-overflow/ (or temp directory if home is not writable)
+    logDir: process.env.CACHE_OVERFLOW_LOG_DIR,
+  },
+};

package/src/index.ts

@@ -1,3 +1,3 @@
-export { CacheOverflowServer } from './server.js';
-export { CacheOverflowClient } from './client.js';
-export * from './types.js';
+export { CacheOverflowServer } from './server.js';
+export { CacheOverflowClient } from './client.js';
+export * from './types.js';