@mixio-pro/kalaasetu-mcp 1.0.6 → 1.0.7

package/README.md

@@ -68,7 +68,9 @@ Add to your Cursor settings (`~/.cursor/config.json` or via Settings → MCP):
       "env": {
         "GEMINI_API_KEY": "your-gemini-api-key",
         "FAL_KEY": "your-fal-api-key",
-        "PERPLEXITY_API_KEY": "your-perplexity-api-key"
+        "PERPLEXITY_API_KEY": "your-perplexity-api-key", 
+        "STORAGE_PROVIDER":"gcs",
+        "GCS_BUCKET":"your-gcs-bucket-name"
       }
     }
   }
@@ -88,7 +90,9 @@ Add to your OpenCode MCP configuration:
       "environment": {
         "GEMINI_API_KEY": "your-gemini-api-key",
         "FAL_KEY": "your-fal-api-key",
-        "PERPLEXITY_API_KEY": "your-perplexity-api-key"
+        "PERPLEXITY_API_KEY": "your-perplexity-api-key", 
+        "STORAGE_PROVIDER":"gcs",
+        "GCS_BUCKET":"your-bucket-name"
       }
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mixio-pro/kalaasetu-mcp",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "description": "A powerful Model Context Protocol server providing AI tools for content generation and analysis",
   "type": "module",
   "module": "src/index.ts",
@@ -49,8 +49,10 @@
   "dependencies": {
     "@fal-ai/client": "^1.7.2",
     "@google/genai": "^1.28.0",
+    "@types/node": "^24.10.1",
     "@types/wav": "^1.0.4",
     "fastmcp": "^3.22.0",
+    "form-data": "^4.0.5",
     "google-auth-library": "^10.5.0",
     "wav": "^1.0.2",
     "zod": "^4.1.12"

package/src/storage/gcs.ts

@@ -0,0 +1,116 @@
+import { GoogleAuth } from "google-auth-library";
+import type { StorageProvider } from "./interface";
+import * as path from "path";
+
+export class GCSStorageProvider implements StorageProvider {
+  private bucket: string;
+  private auth: GoogleAuth;
+
+  constructor(bucket: string) {
+    this.bucket = bucket;
+    this.auth = new GoogleAuth({
+      scopes: ["https://www.googleapis.com/auth/cloud-platform"],
+    });
+  }
+
+  async init(): Promise<void> {
+    console.log(
+      `Initializing GCS Storage Provider with bucket: ${this.bucket}`
+    );
+    // Verify we can get credentials
+    try {
+      await this.auth.getClient();
+    } catch (error) {
+      console.warn(`Warning: Could not initialize GCS client: ${error}`);
+    }
+  }
+
+  private async getAccessToken(): Promise<string> {
+    const client = await this.auth.getClient();
+    const token = await client.getAccessToken();
+    if (!token.token) {
+      throw new Error("Failed to get GCS access token");
+    }
+    return token.token;
+  }
+
+  async readFile(filePath: string): Promise<Buffer> {
+    const objectName = path.basename(filePath);
+    const url = `https://storage.googleapis.com/storage/v1/b/${
+      this.bucket
+    }/o/${encodeURIComponent(objectName)}?alt=media`;
+
+    const token = await this.getAccessToken();
+    const response = await fetch(url, {
+      headers: {
+        Authorization: `Bearer ${token}`,
+      },
+    });
+
+    if (!response.ok) {
+      throw new Error(
+        `Failed to read file from GCS: ${response.status} ${response.statusText}`
+      );
+    }
+
+    const arrayBuffer = await response.arrayBuffer();
+    return Buffer.from(arrayBuffer);
+  }
+
+  async writeFile(filePath: string, data: Buffer | string): Promise<string> {
+    const objectName = path.basename(filePath);
+    const buffer = Buffer.isBuffer(data) ? data : Buffer.from(data);
+
+    // Upload using JSON API
+    const url = `https://storage.googleapis.com/upload/storage/v1/b/${
+      this.bucket
+    }/o?uploadType=media&name=${encodeURIComponent(objectName)}`;
+
+    const token = await this.getAccessToken();
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/octet-stream",
+        "Content-Length": buffer.length.toString(),
+      },
+      body: buffer,
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(
+        `Failed to upload to GCS: ${response.status} ${errorText}`
+      );
+    }
+
+    // Return public URL
+    return `https://storage.googleapis.com/${this.bucket}/${objectName}`;
+  }
+
+  async exists(filePath: string): Promise<boolean> {
+    try {
+      const objectName = path.basename(filePath);
+      const url = `https://storage.googleapis.com/storage/v1/b/${
+        this.bucket
+      }/o/${encodeURIComponent(objectName)}`;
+
+      const token = await this.getAccessToken();
+      const response = await fetch(url, {
+        method: "GET",
+        headers: {
+          Authorization: `Bearer ${token}`,
+        },
+      });
+
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+
+  async getPublicUrl(filePath: string): Promise<string> {
+    const objectName = path.basename(filePath);
+    return `https://storage.googleapis.com/${this.bucket}/${objectName}`;
+  }
+}

package/src/storage/index.ts

@@ -1,24 +1,27 @@
 import type { StorageProvider } from "./interface";
 import { LocalStorageProvider } from "./local";
-import { PayloadStorageProvider } from "./payload";
+import { GCSStorageProvider } from "./gcs";
 
 let storageInstance: StorageProvider | null = null;
 
 export function getStorage(): StorageProvider {
   if (!storageInstance) {
     const type = process.env.STORAGE_PROVIDER || "local";
-    console.error(`Initializing storage provider: ${type}`); // Log to stderr for debug
+    console.error(`Initializing storage provider: ${type}`);
 
-    if (type === "payload") {
-      storageInstance = new PayloadStorageProvider(
-        process.env.PAYLOAD_API_URL || "http://localhost:3000",
-        process.env.PAYLOAD_API_KEY || ""
-      );
+    if (type === "gcs") {
+      const bucket = process.env.GCS_BUCKET;
+
+      if (!bucket) {
+        throw new Error("GCS_BUCKET is required when using gcs storage");
+      }
+
+      storageInstance = new GCSStorageProvider(bucket);
     } else {
       storageInstance = new LocalStorageProvider(process.cwd());
     }
 
-    // Initialize async (fire and forget or handle properly in app startup)
+    // Initialize async
     storageInstance
       .init()
       .catch((err) => console.error("Failed to init storage:", err));

package/src/storage/interface.ts

@@ -1,7 +1,7 @@
 export interface StorageProvider {
   init(): Promise<void>;
   readFile(path: string): Promise<Buffer>;
-  writeFile(path: string, data: Buffer | string): Promise<string>; // Returns path or URL
+  writeFile(path: string, data: Buffer | string): Promise<string>; // Returns public URL
   exists(path: string): Promise<boolean>;
   getPublicUrl(path: string): Promise<string>;
 }

package/src/storage/local.ts

@@ -14,7 +14,6 @@ export class LocalStorageProvider implements StorageProvider {
   }
 
   async readFile(filePath: string): Promise<Buffer> {
-    // Handle absolute paths by checking if it starts with basePath or just use it if it exists
     let fullPath = filePath;
     if (!path.isAbsolute(filePath)) {
       fullPath = path.resolve(this.basePath, filePath);
@@ -45,7 +44,6 @@ export class LocalStorageProvider implements StorageProvider {
   }
 
   async getPublicUrl(filePath: string): Promise<string> {
-    // For local, we just return the absolute path
     let fullPath = filePath;
     if (!path.isAbsolute(filePath)) {
       fullPath = path.resolve(this.basePath, filePath);

package/src/tools/gemini.ts

@@ -164,7 +164,7 @@ async function processVideoInput(
 }
 
 export const geminiTextToImage = {
-  name: "geminiTextToImage",
+  name: "generateImage",
   description:
     "Generate images from text prompts using Gemini 2.5 Flash Image model",
   parameters: z.object({
@@ -203,11 +203,11 @@ export const geminiTextToImage = {
             const imageData = part.inlineData.data;
             if (args.output_path) {
               const storage = getStorage();
-              await storage.writeFile(
+              const url = await storage.writeFile(
                 args.output_path,
                 Buffer.from(imageData, "base64")
               );
-              result += `\nImage saved to: ${args.output_path}`;
+              result += `\nImage saved to: ${url}`;
             } else {
               result += `\nGenerated image (base64): ${imageData.substring(
                 0,
@@ -225,7 +225,7 @@ export const geminiTextToImage = {
 };
 
 export const geminiEditImage = {
-  name: "geminiEditImage",
+  name: "editImage",
   description:
     "Edit existing images with text instructions using Gemini 2.5 Flash Image Preview",
   parameters: z.object({
@@ -270,11 +270,11 @@ export const geminiEditImage = {
             const imageData = part.inlineData.data;
             if (args.output_path) {
               const storage = getStorage();
-              await storage.writeFile(
+              const url = await storage.writeFile(
                 args.output_path,
                 Buffer.from(imageData, "base64")
               );
-              result += `\nEdited image saved to: ${args.output_path}`;
+              result += `\nEdited image saved to: ${url}`;
             } else {
               result += `\nEdited image (base64): ${imageData.substring(
                 0,
@@ -292,7 +292,7 @@ export const geminiEditImage = {
 };
 
 export const geminiAnalyzeImages = {
-  name: "geminiAnalyzeImages",
+  name: "analyzeImages",
   description:
     "Analyze and describe images using Gemini 2.5 Pro with advanced multimodal understanding",
   parameters: z.object({
@@ -358,7 +358,7 @@ export const geminiAnalyzeImages = {
 };
 
 export const geminiSingleSpeakerTts = {
-  name: "geminiSingleSpeakerTts",
+  name: "generateSpeech",
   description:
     "Generate single speaker voice audio from text using Gemini 2.5 Pro Preview TTS model",
   parameters: z.object({
@@ -407,9 +407,10 @@ export const geminiSingleSpeakerTts = {
       // Generate output filename if not provided
       const outputPath = args.output_path || `voice_output_${Date.now()}.wav`;
 
-      await saveWaveFile(outputPath, audioBuffer);
+      const storage = getStorage();
+      const url = await storage.writeFile(outputPath, audioBuffer);
 
-      return `Audio generated successfully: ${outputPath}`;
+      return `Audio generated successfully: ${url}`;
     } catch (error: any) {
       throw new Error(`Voice generation failed: ${error.message}`);
     }
@@ -417,7 +418,7 @@ export const geminiSingleSpeakerTts = {
 };
 
 export const geminiAnalyzeVideos = {
-  name: "geminiAnalyzeVideos",
+  name: "analyzeVideos",
   description:
     "Analyze and understand video content using Gemini 2.5 Flash model. Intelligently handles YouTube URLs and local videos (files <20MB processed inline, ≥20MB uploaded via File API). Supports timestamp queries, clipping, and custom frame rates with default 5 FPS for local videos to optimize processing.",
   parameters: z.object({

package/src/tools/image-to-video.ts

@@ -64,7 +64,7 @@ async function fileToBase64(
 }
 
 export const imageToVideo = {
-  name: "image_to_video",
+  name: "generateVideoi2v",
   description:
     "Generate videos from an image as starting first frame using Vertex Veo models (predictLongRunning + fetchPredictOperation).",
   parameters: z.object({
@@ -291,14 +291,11 @@ export const imageToVideo = {
           ? args.output_path
           : args.output_path.replace(/\.mp4$/i, `_${index}.mp4`)
         : `video_output_${Date.now()}${index === 0 ? "" : "_" + index}.mp4`;
-      // For storage provider, we use the path as is (relative or absolute)
-      // If using LocalStorage, it handles resolving.
-      // If using Payload, it handles the key.
 
       const buf = Buffer.from(base64, "base64");
       const storage = getStorage();
-      await storage.writeFile(filePath, buf);
-      outputs.push(filePath);
+      const url = await storage.writeFile(filePath, buf);
+      outputs.push(url);
     };
 
     if (Array.isArray(resp?.videos) && resp.videos.length > 0) {
@@ -310,7 +307,7 @@ export const imageToVideo = {
       }
     }
     if (outputs.length > 0) {
-      return `Video(s) saved: ${outputs.join(", ")}`;
+      return `Video(s) saved to: ${outputs.join(", ")}`;
     }
 
     // If nothing saved, return a concise summary plus head/tail snippets of JSON

package/src/storage/payload.ts

@@ -1,46 +0,0 @@
-import type { StorageProvider } from "./interface";
-
-export class PayloadStorageProvider implements StorageProvider {
-  private apiUrl: string;
-  private apiKey: string;
-  private collection: string;
-
-  constructor(apiUrl: string, apiKey: string, collection: string = "media") {
-    this.apiUrl = apiUrl;
-    this.apiKey = apiKey;
-    this.collection = collection;
-  }
-
-  async init(): Promise<void> {
-    console.log("Initializing Payload Storage Provider...");
-    // TODO: Verify connection to Payload CMS
-  }
-
-  async readFile(filePath: string): Promise<Buffer> {
-    // TODO: Implement fetching file from Payload CMS
-    // 1. Search for file by filename or ID
-    // 2. Download the file buffer
-    console.log(`[Payload] Reading file: ${filePath}`);
-    throw new Error("PayloadStorageProvider.readFile not implemented yet.");
-  }
-
-  async writeFile(filePath: string, data: Buffer | string): Promise<string> {
-    // TODO: Implement uploading file to Payload CMS
-    // 1. Create FormData
-    // 2. POST to /api/{collection}
-    console.log(`[Payload] Writing file: ${filePath}`);
-    throw new Error("PayloadStorageProvider.writeFile not implemented yet.");
-  }
-
-  async exists(filePath: string): Promise<boolean> {
-    // TODO: Check if file exists in Payload
-    console.log(`[Payload] Checking existence: ${filePath}`);
-    return false;
-  }
-
-  async getPublicUrl(filePath: string): Promise<string> {
-    // TODO: Return the public URL of the file in Payload
-    console.log(`[Payload] Getting public URL: ${filePath}`);
-    return `${this.apiUrl}/${this.collection}/${filePath}`;
-  }
-}