feat: fix MCP server build and authentication

- Fix TypeScript compilation errors in index.ts and server.ts
- Add optional initialize() method to ILighthouseService interface
- Replace JWT authentication with direct API key usage for Lighthouse Web3 SDK
- Remove problematic token endpoint requests causing 404 errors
- Successfully build and run MCP server with real Lighthouse API integration
- Add test script for running server with mock services

Author: Patrick-Ehimen

apps/mcp-server/INTEGRATION.md

@@ -0,0 +1,94 @@
+# Lighthouse MCP Server - Real SDK Integration
+
+This document describes the integration between the MCP server foundation (task 3) and the unified SDK wrapper (task 2).
+
+## What Changed
+
+The MCP server has been updated to use the real `LighthouseService` instead of the mock service:
+
+### Key Changes
+
+1. **Real Lighthouse Integration**: The server now uses `LighthouseService` which integrates with the actual Lighthouse SDK wrapper from task 2.
+
+2. **Common Interface**: Created `ILighthouseService` interface that both mock and real services implement, ensuring compatibility.
+
+3. **API Key Configuration**: Added `lighthouseApiKey` to server configuration, supporting both environment variable and command-line argument.
+
+4. **Async Operations**: Updated all file operations to be properly async, matching the real SDK behavior.
+
+## Usage
+
+### Environment Setup
+
+```bash
+export LIGHTHOUSE_API_KEY="your-lighthouse-api-key"
+```
+
+### Command Line
+
+```bash
+node dist/index.js --api-key "your-lighthouse-api-key"
+```
+
+### Programmatic Usage
+
+```typescript
+import { LighthouseMCPServer } from "@lighthouse-tooling/mcp-server";
+
+const server = new LighthouseMCPServer({
+  lighthouseApiKey: "your-api-key",
+  logLevel: "info",
+});
+
+await server.start();
+```
+
+## MCP Tools Available
+
+1. **lighthouse_upload_file**: Upload files to IPFS via Lighthouse
+2. **lighthouse_create_dataset**: Create managed datasets with metadata
+3. **lighthouse_fetch_file**: Download and optionally decrypt files
+
+## Architecture
+
+```
+AI Agent (Cursor/Claude)
+    ↓ MCP Protocol
+LighthouseMCPServer
+    ↓ Interface
+LighthouseService
+    ↓ SDK Wrapper
+LighthouseAISDK
+    ↓ HTTP API
+Lighthouse Infrastructure
+```
+
+## Testing
+
+The integration includes comprehensive tests:
+
+```bash
+npm test -- integration.test.ts
+```
+
+## Next Steps
+
+- Task 4: Implement core MCP tools for file operations with real file handling
+- Task 5: Add encryption and access control features using Kavach SDK
+- Task 6: Implement dataset management functionality with versioning
+
+## Error Handling
+
+The real service includes:
+
+- Retry logic with exponential backoff
+- Circuit breaker pattern for API failures
+- Comprehensive error logging
+- Authentication token refresh
+
+## Performance
+
+- Progress tracking for long-running operations
+- Connection pooling for API requests
+- Intelligent caching with LRU cache
+- Memory management and backpressure handling

apps/mcp-server/demo-test.js

@@ -1,5 +1,5 @@
-const { LighthouseMCPServer } = require("./dist/server.js");
-const fs = require("fs");
+import { LighthouseMCPServer } from "./dist/server.js";
+import fs from "fs";
 
 async function demo() {
   const testFile = "./demo-test.txt";
@@ -12,6 +12,9 @@ async function demo() {
     enableMetrics: false,
   });
 
+  // Register tools
+  await server.registerTools();
+
   const registry = server.getRegistry();
   console.log("Server initialized with", registry.listTools().length, "tools\n");
 

apps/mcp-server/src/config/server-config.ts

@@ -10,6 +10,7 @@ export interface ServerConfig {
   port?: number;
   enableMetrics: boolean;
   metricsInterval: number;
+  lighthouseApiKey?: string;
 }
 
 export const DEFAULT_SERVER_CONFIG: ServerConfig = {
@@ -19,4 +20,5 @@ export const DEFAULT_SERVER_CONFIG: ServerConfig = {
   maxStorageSize: 1024 * 1024 * 1024, // 1GB
   enableMetrics: true,
   metricsInterval: 60000, // 1 minute
+  lighthouseApiKey: process.env.LIGHTHOUSE_API_KEY,
 };

apps/mcp-server/src/handlers/ListResourcesHandler.ts

@@ -5,16 +5,16 @@
 import { Logger } from "@lighthouse-tooling/shared";
 import { MCPResponse } from "@lighthouse-tooling/types";
 import { ResponseBuilder } from "../utils/response-builder.js";
-import { MockLighthouseService } from "../services/MockLighthouseService.js";
+import { ILighthouseService } from "../services/ILighthouseService.js";
 import { MockDatasetService } from "../services/MockDatasetService.js";
 
 export class ListResourcesHandler {
-  private lighthouseService: MockLighthouseService;
+  private lighthouseService: ILighthouseService;
   private datasetService: MockDatasetService;
   private logger: Logger;
 
   constructor(
-    lighthouseService: MockLighthouseService,
+    lighthouseService: ILighthouseService,
     datasetService: MockDatasetService,
     logger?: Logger,
   ) {
@@ -32,7 +32,8 @@ export class ListResourcesHandler {
       this.logger.info("Handling resources/list request", { requestId });
 
       // Get all uploaded files
-      const files = this.lighthouseService.listFiles();
+      const filesResult = this.lighthouseService.listFiles();
+      const files = Array.isArray(filesResult) ? filesResult : await filesResult;
 
       // Get all datasets
       const datasets = this.datasetService.listDatasets();

apps/mcp-server/src/index.ts

@@ -8,7 +8,7 @@ import { ServerConfig } from "./config/server-config.js";
 // Export main server class
 export { LighthouseMCPServer } from "./server.js";
 export { ToolRegistry } from "./registry/ToolRegistry.js";
-export { MockLighthouseService } from "./services/MockLighthouseService.js";
+export { LighthouseService } from "./services/LighthouseService.js";
 export { MockDatasetService } from "./services/MockDatasetService.js";
 export * from "./registry/types.js";
 export * from "./config/server-config.js";
@@ -28,7 +28,12 @@ async function main() {
       switch (arg) {
         case "--log-level":
           i++;
-          if (args[i]) config.logLevel = args[i] as any;
+          if (args[i]) {
+            const level = args[i] as string;
+            if (["debug", "info", "warn", "error"].includes(level)) {
+              config.logLevel = level as "debug" | "info" | "warn" | "error";
+            }
+          }
           break;
         case "--max-storage":
           i++;
@@ -42,6 +47,10 @@ async function main() {
           i++;
           if (args[i]) config.version = args[i];
           break;
+        case "--api-key":
+          i++;
+          if (args[i]) config.lighthouseApiKey = args[i];
+          break;
         case "--help":
           console.log(`
 Lighthouse MCP Server
@@ -53,6 +62,7 @@ Options:
   --max-storage <bytes>  Set maximum storage size in bytes [default: 1073741824]
   --name <name>         Set server name [default: lighthouse-storage]
   --version <version>    Set server version [default: 0.1.0]
+  --api-key <key>       Set Lighthouse API key (or use LIGHTHOUSE_API_KEY env var)
   --help                Show this help message
 
 Examples:

apps/mcp-server/src/server.ts

@@ -13,7 +13,8 @@ import { Logger } from "@lighthouse-tooling/shared";
 import { LIGHTHOUSE_MCP_TOOLS } from "@lighthouse-tooling/types";
 
 import { ToolRegistry } from "./registry/ToolRegistry.js";
-import { MockLighthouseService } from "./services/MockLighthouseService.js";
+import { LighthouseService } from "./services/LighthouseService.js";
+import { ILighthouseService } from "./services/ILighthouseService.js";
 import { MockDatasetService } from "./services/MockDatasetService.js";
 import {
   ListToolsHandler,
@@ -26,7 +27,7 @@ import { ServerConfig, DEFAULT_SERVER_CONFIG } from "./config/server-config.js";
 export class LighthouseMCPServer {
   private server: Server;
   private registry: ToolRegistry;
-  private lighthouseService: MockLighthouseService;
+  private lighthouseService: ILighthouseService;
   private datasetService: MockDatasetService;
   private logger: Logger;
   private config: ServerConfig;
@@ -37,7 +38,13 @@ export class LighthouseMCPServer {
   private listResourcesHandler: ListResourcesHandler;
   private initializeHandler: InitializeHandler;
 
-  constructor(config: Partial<ServerConfig> = {}) {
+  constructor(
+    config: Partial<ServerConfig> = {},
+    services?: {
+      lighthouseService?: ILighthouseService;
+      datasetService?: MockDatasetService;
+    },
+  ) {
     this.config = { ...DEFAULT_SERVER_CONFIG, ...config };
 
     // Initialize logger
@@ -61,8 +68,20 @@ export class LighthouseMCPServer {
     );
 
     // Initialize services
-    this.lighthouseService = new MockLighthouseService(this.config.maxStorageSize, this.logger);
-    this.datasetService = new MockDatasetService(this.lighthouseService, this.logger);
+    if (services?.lighthouseService) {
+      this.lighthouseService = services.lighthouseService;
+    } else {
+      if (!this.config.lighthouseApiKey) {
+        throw new Error("LIGHTHOUSE_API_KEY environment variable is required");
+      }
+      this.lighthouseService = new LighthouseService(this.config.lighthouseApiKey, this.logger);
+    }
+
+    if (services?.datasetService) {
+      this.datasetService = services.datasetService;
+    } else {
+      this.datasetService = new MockDatasetService(this.lighthouseService, this.logger);
+    }
 
     // Initialize registry
     this.registry = new ToolRegistry(this.logger);
@@ -201,7 +220,7 @@ export class LighthouseMCPServer {
 
     // Handle ListResources
     this.server.setRequestHandler(ListResourcesRequestSchema, async () => {
-      const files = this.lighthouseService.listFiles();
+      const files = await this.lighthouseService.listFiles();
       const datasets = this.datasetService.listDatasets();
 
       const resources = [
@@ -237,6 +256,11 @@ export class LighthouseMCPServer {
         version: this.config.version,
       });
 
+      // Initialize Lighthouse service
+      if (this.lighthouseService.initialize) {
+        await this.lighthouseService.initialize();
+      }
+
       // Register tools
       await this.registerTools();
 
@@ -311,7 +335,7 @@ export class LighthouseMCPServer {
   getStats(): {
     registry: any;
     storage: any;
-    datasets: any;
+    datasets: unknown;
   } {
     return {
       registry: this.registry.getMetrics(),
@@ -330,7 +354,7 @@ export class LighthouseMCPServer {
   /**
    * Get lighthouse service instance (for testing)
    */
-  getLighthouseService(): MockLighthouseService {
+  getLighthouseService(): ILighthouseService {
     return this.lighthouseService;
   }
 

apps/mcp-server/src/services/ILighthouseService.ts

@@ -0,0 +1,78 @@
+/**
+ * Common interface for Lighthouse services
+ */
+
+import { UploadResult, DownloadResult, AccessCondition } from "@lighthouse-tooling/types";
+
+export interface StoredFile {
+  cid: string;
+  filePath: string;
+  size: number;
+  encrypted: boolean;
+  accessConditions?: AccessCondition[];
+  tags?: string[];
+  uploadedAt: Date;
+  pinned: boolean;
+  hash?: string;
+}
+
+export interface ILighthouseService {
+  /**
+   * Initialize the service
+   */
+  initialize?(): Promise<void>;
+
+  /**
+   * Upload file
+   */
+  uploadFile(params: {
+    filePath: string;
+    encrypt?: boolean;
+    accessConditions?: AccessCondition[];
+    tags?: string[];
+  }): Promise<UploadResult>;
+
+  /**
+   * Fetch/download file
+   */
+  fetchFile(params: {
+    cid: string;
+    outputPath?: string;
+    decrypt?: boolean;
+  }): Promise<DownloadResult>;
+
+  /**
+   * Pin file
+   */
+  pinFile(cid: string): Promise<{ success: boolean; cid: string; pinned: boolean }>;
+
+  /**
+   * Unpin file
+   */
+  unpinFile(cid: string): Promise<{ success: boolean; cid: string; pinned: boolean }>;
+
+  /**
+   * Get file info by CID
+   */
+  getFileInfo(cid: string): StoredFile | undefined | Promise<StoredFile | undefined>;
+
+  /**
+   * List all uploaded files
+   */
+  listFiles(): StoredFile[] | Promise<StoredFile[]>;
+
+  /**
+   * Get storage stats
+   */
+  getStorageStats(): {
+    fileCount: number;
+    totalSize: number;
+    maxSize: number;
+    utilization: number;
+  };
+
+  /**
+   * Clear cache (for testing)
+   */
+  clear(): void;
+}