Merge pull request Patrick-Ehimen#33 from Patrick-Ehimen/feat/vscode-extension-impl

feat: implement VSCode extension with AI integration

Author: Patrick-Ehimen

.vscode/settings.json

@@ -5,5 +5,7 @@
   "eslint.validate": ["javascript", "typescript", "typescriptreact"],
   "editor.codeActionsOnSave": {
     "source.fixAll.eslint": "explicit"
-  }
+  },
+  "lighthouse.vscode.mcpServerUrl": "http://localhost:3000",
+  "lighthouse.vscode.apiKey": "725ca23b.fcd4fe7b53b74a308d7c537fe0e60f79"
 }

packages/sdk-wrapper/package.json

@@ -22,7 +22,8 @@
     "@lighthouse-web3/sdk": "^0.2.3",
     "@lighthouse-web3/kavach": "^0.2.1",
     "eventemitter3": "^5.0.1",
-    "axios": "^1.6.0"
+    "axios": "^1.6.0",
+    "form-data": "^4.0.0"
   },
   "devDependencies": {
     "@types/jest": "^29.5.0",

packages/sdk-wrapper/src/LighthouseAISDK.ts

@@ -1,5 +1,6 @@
 import { EventEmitter } from "eventemitter3";
 import lighthouse from "@lighthouse-web3/sdk";
+import { readFileSync } from "fs";
 import { AuthenticationManager } from "./auth/AuthenticationManager";
 import { ProgressTracker } from "./progress/ProgressTracker";
 import { ErrorHandler } from "./errors/ErrorHandler";
@@ -217,19 +218,70 @@ export class LighthouseAISDK extends EventEmitter {
           // Update progress to uploading phase
           this.progress.updateProgress(operationId, 0, "uploading");
 
-          // Upload file using Lighthouse SDK
-          const uploadResponse = await lighthouse.upload(
-            filePath,
-            apiKey,
-            false, // dealStatus - set to false for now
-            undefined, // endDate
-            (data: any) => {
-              // Convert Lighthouse progress format to our format
-              if (data.loaded !== undefined) {
-                progressCallback(data.loaded, data.total);
+          // Calculate dynamic timeout based on file size (minimum 2 minutes, +30s per MB)
+          const fileSizeMB = fileStats.size / (1024 * 1024);
+          const dynamicTimeout = Math.max(120000, 120000 + fileSizeMB * 30000); // 2 min base + 30s per MB
+
+          // Read file as buffer to avoid fs-extra dependency issues
+          const fileBuffer = readFileSync(filePath);
+
+          // Upload file using Lighthouse SDK buffer method with timeout
+          let uploadResponse;
+          try {
+            const uploadPromise = lighthouse.uploadBuffer(fileBuffer, apiKey);
+            uploadResponse = await this.withTimeout(uploadPromise, dynamicTimeout);
+          } catch (error) {
+            // Try fallback to direct API call if standard method fails
+            const errorMessage = error instanceof Error ? error.message : String(error);
+
+            if (
+              errorMessage.includes("ETIMEDOUT") ||
+              errorMessage.includes("timeout") ||
+              errorMessage.includes("ENOTFOUND") ||
+              errorMessage.includes("ECONNREFUSED")
+            ) {
+              console.warn("Standard upload failed, trying direct API fallback:", errorMessage);
+
+              try {
+                uploadResponse = await this.uploadViDirectAPI(
+                  fileBuffer,
+                  apiKey,
+                  options.fileName || filePath.split("/").pop() || "file",
+                );
+                console.log("Fallback upload successful");
+              } catch (fallbackError) {
+                // If both methods fail, provide comprehensive error message
+                throw new Error(`Upload failed with both methods:
+
+Primary error: ${errorMessage}
+Fallback error: ${fallbackError instanceof Error ? fallbackError.message : String(fallbackError)}
+
+This could be due to:
+• Network connectivity issues
+• Large file size (current: ${(fileStats.size / 1024 / 1024).toFixed(1)}MB)
+• Lighthouse servers being temporarily unavailable
+• Firewall or proxy blocking the connection
+• Invalid API key
+
+Try uploading a smaller file or check your network connection.`);
               }
-            },
-          );
+            } else if (errorMessage.includes("401") || errorMessage.includes("unauthorized")) {
+              throw new Error(`Authentication failed. Please check:
+• Your API key is correct and valid
+• Your API key has upload permissions
+• Your API key hasn't expired
+
+Current API key: ${apiKey.substring(0, 8)}...`);
+            } else if (errorMessage.includes("413") || errorMessage.includes("too large")) {
+              throw new Error(`File too large (${(fileStats.size / 1024 / 1024).toFixed(1)}MB). 
+Maximum file size may be exceeded. Try uploading a smaller file.`);
+            } else if (errorMessage.includes("429") || errorMessage.includes("rate limit")) {
+              throw new Error(`Rate limit exceeded. Please wait a moment before trying again.`);
+            }
+
+            // Re-throw original error if we can't classify it
+            throw error;
+          }
 
           if (!uploadResponse || !uploadResponse.data || !uploadResponse.data.Hash) {
             throw new Error("Invalid upload response from Lighthouse");
@@ -257,6 +309,48 @@ export class LighthouseAISDK extends EventEmitter {
     }, "uploadFile");
   }
 
+  /**
+   * Add timeout wrapper for promises
+   */
+  private withTimeout<T>(promise: Promise<T>, timeoutMs: number): Promise<T> {
+    return Promise.race([
+      promise,
+      new Promise<never>((_, reject) =>
+        setTimeout(() => reject(new Error(`Operation timed out after ${timeoutMs}ms`)), timeoutMs),
+      ),
+    ]);
+  }
+
+  /**
+   * Upload file via direct API call as fallback when SDK fails
+   */
+  private async uploadViDirectAPI(
+    fileBuffer: Buffer,
+    apiKey: string,
+    fileName: string,
+  ): Promise<any> {
+    // This is a fallback method that uses direct HTTP calls to api.lighthouse.storage
+    // when the standard SDK fails (usually due to node.lighthouse.storage being down)
+
+    const FormData = eval("require")("form-data");
+    const axios = eval("require")("axios");
+
+    const formData = new FormData();
+    formData.append("file", fileBuffer, fileName);
+
+    const response = await axios.post("https://api.lighthouse.storage/api/v0/add", formData, {
+      headers: {
+        ...formData.getHeaders(),
+        Authorization: `Bearer ${apiKey}`,
+      },
+      timeout: 180000, // 3 minutes
+      maxContentLength: Infinity,
+      maxBodyLength: Infinity,
+    });
+
+    return response;
+  }
+
   /**
    * Download a file from Lighthouse with comprehensive error handling and progress tracking.
    *

packages/vscode-extension/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 0xOse
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

packages/vscode-extension/esbuild.js

@@ -0,0 +1,75 @@
+const esbuild = require("esbuild");
+
+const production = process.argv.includes("--production");
+const watch = process.argv.includes("--watch");
+
+async function main() {
+  const ctx = await esbuild.context({
+    entryPoints: ["src/index.ts"],
+    bundle: true,
+    format: "cjs",
+    minify: production,
+    sourcemap: !production,
+    sourcesContent: false,
+    platform: "node",
+    outfile: "dist/index.js",
+    external: ["vscode"],
+    // Mark optional encryption dependencies that may not be installed
+    alias: {
+      "@lighthouse-web3/kavach": "@lighthouse-web3/kavach",
+    },
+    logLevel: "info",
+    plugins: [stubMissingModules, esbuildProblemMatcherPlugin],
+  });
+
+  if (watch) {
+    await ctx.watch();
+  } else {
+    await ctx.rebuild();
+    await ctx.dispose();
+  }
+}
+
+/**
+ * Stub missing optional modules (encryption features not used by extension)
+ * @type {import('esbuild').Plugin}
+ */
+const stubMissingModules = {
+  name: "stub-missing-modules",
+  setup(build) {
+    build.onResolve({ filter: /^(joi|bls-eth-wasm|@lighthouse-web3\/kavach)/ }, (args) => {
+      return { path: args.path, namespace: "stub" };
+    });
+    build.onLoad({ filter: /.*/, namespace: "stub" }, () => {
+      return {
+        contents: "module.exports = {}",
+        loader: "js",
+      };
+    });
+  },
+};
+
+/**
+ * @type {import('esbuild').Plugin}
+ */
+const esbuildProblemMatcherPlugin = {
+  name: "esbuild-problem-matcher",
+
+  setup(build) {
+    build.onStart(() => {
+      console.log("[watch] build started");
+    });
+    build.onEnd((result) => {
+      result.errors.forEach(({ text, location }) => {
+        console.error(`✘ [ERROR] ${text}`);
+        console.error(`    ${location.file}:${location.line}:${location.column}:`);
+      });
+      console.log("[watch] build finished");
+    });
+  },
+};
+
+main().catch((e) => {
+  console.error(e);
+  process.exit(1);
+});

packages/vscode-extension/jest.config.js

@@ -0,0 +1,15 @@
+module.exports = {
+  preset: "ts-jest",
+  testEnvironment: "node",
+  roots: ["<rootDir>/src"],
+  testMatch: ["**/__tests__/**/*.test.ts"],
+  transform: {
+    "^.+\\.ts$": "ts-jest",
+  },
+  collectCoverageFrom: ["src/**/*.ts", "!src/**/*.d.ts", "!src/__tests__/**"],
+  moduleNameMapper: {
+    "^@lighthouse-tooling/(.*)$": "<rootDir>/../$1/src",
+    "^vscode$": "<rootDir>/src/__mocks__/vscode.ts",
+  },
+  setupFilesAfterEnv: ["<rootDir>/jest.setup.js"],
+};

packages/vscode-extension/jest.setup.js

@@ -0,0 +1,3 @@
+// Jest setup file for VSCode extension tests
+// Mock fetch for tests
+global.fetch = jest.fn();