@mixio-pro/kalaasetu-mcp 1.0.15 → 1.0.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mixio-pro/kalaasetu-mcp",
-  "version": "1.0.15",
+  "version": "1.0.17",
   "description": "A powerful Model Context Protocol server providing AI tools for content generation and analysis",
   "type": "module",
   "module": "src/index.ts",

package/src/storage/gcs.ts

@@ -18,9 +18,6 @@ export class GCSStorageProvider implements StorageProvider {
   }
 
   async init(): Promise<void> {
-    console.log(
-      `Initializing GCS Storage Provider with bucket: ${this.bucket}`
-    );
     // Verify we can get credentials
     try {
       await this.auth.getClient();

package/src/tools/gemini.ts

@@ -16,32 +16,23 @@ const ai = new GoogleGenAI({
   apiKey: process.env.GEMINI_API_KEY || "",
 });
 
+import { ensureLocalFile } from "../utils/url-file";
+
 async function fileToGenerativePart(filePath: string) {
-  const storage = getStorage();
+  const fileResult = await ensureLocalFile(filePath);
 
-  // Check if file exists
-  const exists = await storage.exists(filePath);
-  if (!exists) {
-    // Try to provide more helpful error information
-    const isAbsolute = path.isAbsolute(filePath);
-    const resolvedPath = isAbsolute
-      ? filePath
-      : path.resolve(process.cwd(), filePath);
-    throw new Error(
-      `File not found: ${filePath}\n` +
-        `Resolved path: ${resolvedPath}\n` +
-        `Is absolute: ${isAbsolute}\n` +
-        `CWD: ${process.cwd()}`
-    );
+  try {
+    const storage = getStorage();
+    const imageBytes = await storage.readFile(fileResult.path);
+    return {
+      inlineData: {
+        data: Buffer.from(imageBytes).toString("base64"),
+        mimeType: "image/jpeg",
+      },
+    };
+  } finally {
+    fileResult.cleanup();
   }
-
-  const imageBytes = await storage.readFile(filePath);
-  return {
-    inlineData: {
-      data: Buffer.from(imageBytes).toString("base64"),
-      mimeType: "image/jpeg",
-    },
-  };
 }
 
 // Helper function to save WAV file
@@ -165,29 +156,18 @@ async function processVideoInput(
       },
     };
   } else {
-    // Local file processing - use File Upload API
-    const storage = getStorage();
+    // Local file processing or non-YouTube URL - use File Upload API
+    // ensureLocalFile handles downloading URLs if needed
+    const fileResult = await ensureLocalFile(input);
 
-    // Check if file exists
-    const exists = await storage.exists(input);
-    if (!exists) {
-      // Try to provide more helpful error information
-      const isAbsolute = path.isAbsolute(input);
-      const resolvedPath = isAbsolute
-        ? input
-        : path.resolve(process.cwd(), input);
-      throw new Error(
-        `Video file not found: ${input}\n` +
-          `Resolved path: ${resolvedPath}\n` +
-          `Is absolute: ${isAbsolute}\n` +
-          `CWD: ${process.cwd()}`
-      );
+    try {
+      // Upload file to Gemini API
+      // We pass the local path (temp or original)
+      const uploadedFile = await uploadFileToGemini(fileResult.path);
+      return uploadedFile;
+    } finally {
+      fileResult.cleanup();
     }
-
-    // Upload file to Gemini API
-    const uploadedFile = await uploadFileToGemini(input);
-
-    return uploadedFile;
   }
 }
 

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

@@ -15,27 +15,67 @@ function fileToBase64(filePath: string): { data: string; mimeType: string } {
   const data = Buffer.from(buf).toString("base64");
   // Detect mime type from extension
   const ext = path.extname(filePath).toLowerCase();
-  const mimeType = ext === '.jpg' || ext === '.jpeg' ? 'image/jpeg' : 
-                   ext === '.png' ? 'image/png' :
-                   ext === '.webp' ? 'image/webp' : 'image/png';
+  const mimeType =
+    ext === ".jpg" || ext === ".jpeg"
+      ? "image/jpeg"
+      : ext === ".png"
+      ? "image/png"
+      : ext === ".webp"
+      ? "image/webp"
+      : "image/png";
   return { data, mimeType };
 }
 
 export const imageToVideo = {
   name: "imageToVideo",
-  description: "Generate videos from an image as starting first frame using Vertex Veo models (predictLongRunning + fetchPredictOperation).",
+  description:
+    "Generate videos from an image as starting first frame using Vertex Veo models (predictLongRunning + fetchPredictOperation).",
   parameters: z.object({
     prompt: z.string().describe("Text description for the video"),
-    image_path: z.string().optional().describe("Path to source image for image-to-video generation"),
-    aspect_ratio: z.string().optional().describe("Video aspect ratio: '16:9' or '9:16' (default: '9:16')"),
-    duration_seconds: z.number().optional().describe("Video duration in seconds: 4, 6, or 8 (default: 6)"),
-    resolution: z.string().optional().describe("Video resolution: '720p' or '1080p' (default: '720p')"),
-    negative_prompt: z.string().optional().describe("Text describing what not to include in the video"),
-    person_generation: z.string().optional().describe("Controls generation of people: 'allow_adult' (default for image-to-video) or 'allow_all'"),
-    reference_images: z.array(z.string()).optional().describe("Additional image paths for reference (max 3)"),
-    output_path: z.string().optional().describe("Output MP4 file path (if multiple predictions, index suffix is added)"),
-    gemini_api_key: z.string().optional().describe("Gemini API key (uses GEMINI_API_KEY env var if not provided)"),
-    model_id: z.string().optional().describe("Model ID (default: veo-2.0-generate-001)"),
+    image_path: z
+      .string()
+      .optional()
+      .describe("Path to source image for image-to-video generation"),
+    aspect_ratio: z
+      .string()
+      .optional()
+      .describe("Video aspect ratio: '16:9' or '9:16' (default: '9:16')"),
+    duration_seconds: z
+      .number()
+      .optional()
+      .describe("Video duration in seconds: 4, 6, or 8 (default: 6)"),
+    resolution: z
+      .string()
+      .optional()
+      .describe("Video resolution: '720p' or '1080p' (default: '720p')"),
+    negative_prompt: z
+      .string()
+      .optional()
+      .describe("Text describing what not to include in the video"),
+    person_generation: z
+      .string()
+      .optional()
+      .describe(
+        "Controls generation of people: 'allow_adult' (default for image-to-video) or 'allow_all'"
+      ),
+    reference_images: z
+      .array(z.string())
+      .optional()
+      .describe("Additional image paths for reference (max 3)"),
+    output_path: z
+      .string()
+      .optional()
+      .describe(
+        "Output MP4 file path (if multiple predictions, index suffix is added)"
+      ),
+    gemini_api_key: z
+      .string()
+      .optional()
+      .describe("Gemini API key (uses GEMINI_API_KEY env var if not provided)"),
+    model_id: z
+      .string()
+      .optional()
+      .describe("Model ID (default: veo-2.0-generate-001)"),
   }),
   execute: async (args: {
     prompt: string;
@@ -52,47 +92,49 @@ export const imageToVideo = {
   }) => {
     const apiKey = args.gemini_api_key || process.env.GEMINI_API_KEY;
     if (!apiKey) {
-      throw new Error("Gemini API key is required. Set GEMINI_API_KEY environment variable or pass gemini_api_key parameter. Get one at https://aistudio.google.com/app/apikey");
+      throw new Error(
+        "Gemini API key is required. Set GEMINI_API_KEY environment variable or pass gemini_api_key parameter. Get one at https://aistudio.google.com/app/apikey"
+      );
     }
 
     const model = args.model_id || "veo-2.0-generate-001";
-    
+
     // Initialize Google GenAI client
     const genai = new GoogleGenAI({ apiKey });
 
     // Build config for video generation
     const config: any = {};
-    
+
     if (args.duration_seconds !== undefined) {
       config.duration_seconds = args.duration_seconds;
     } else {
       config.duration_seconds = 6; // default
     }
-    
+
     if (args.aspect_ratio) {
       config.aspect_ratio = args.aspect_ratio;
     }
 
     try {
       // Start video generation operation
-      console.log(`Starting video generation with model: ${model}`);
+      console.error(`Starting video generation with model: ${model}`);
       let operation = await genai.models.generateVideos({
         model,
         prompt: args.prompt,
         config,
       });
 
-      console.log("Operation started, waiting for completion...");
-      
+      console.error("Operation started, waiting for completion...");
+
       // Poll until operation is complete (max 10 minutes)
       let tries = 0;
       const maxTries = 60; // 10 minutes with 10s intervals
-      
+
       while (!operation.done && tries < maxTries) {
         await wait(10000); // Wait 10 seconds
         tries++;
-        console.log(`Polling attempt ${tries}/${maxTries}...`);
-        
+        console.error(`Polling attempt ${tries}/${maxTries}...`);
+
         operation = await genai.operations.getVideosOperation({
           operation: operation,
         });
@@ -102,60 +144,75 @@ export const imageToVideo = {
         throw new Error("Video generation timed out after 10 minutes");
       }
 
-      console.log("Operation completed!");
-      console.log("Full Response:", JSON.stringify(operation.response, null, 2));
+      console.error("Operation completed!");
+      console.error(
+        "Full Response:",
+        JSON.stringify(operation.response, null, 2)
+      );
 
       // Extract generated videos from response
       const generatedVideos = operation.response?.generatedVideos || [];
-      
+
       if (!generatedVideos || generatedVideos.length === 0) {
         const respStr = JSON.stringify(operation.response, null, 2);
-        return `Video generation completed but no videos found in response.\n\nFull Response:\n${respStr.slice(0, 2000)}${respStr.length > 2000 ? '\n...(truncated)' : ''}`;
+        return `Video generation completed but no videos found in response.\n\nFull Response:\n${respStr.slice(
+          0,
+          2000
+        )}${respStr.length > 2000 ? "\n...(truncated)" : ""}`;
       }
 
       // Download and save videos
       const outputs: string[] = [];
-      
+
       for (let i = 0; i < generatedVideos.length; i++) {
         const generatedVideo = generatedVideos[i];
         const videoUri = generatedVideo?.video?.uri;
-        
+
         if (!videoUri) {
           console.warn(`Video ${i} has no URI`);
           continue;
         }
 
-        console.log(`Downloading video ${i + 1}/${generatedVideos.length}...`);
-        
+        console.error(
+          `Downloading video ${i + 1}/${generatedVideos.length}...`
+        );
+
         // Download video from URI
         const videoUrl = `${videoUri}&key=${apiKey}`;
         const response = await fetch(videoUrl);
-        
+
         if (!response.ok) {
-          throw new Error(`Failed to download video: ${response.status} ${response.statusText}`);
+          throw new Error(
+            `Failed to download video: ${response.status} ${response.statusText}`
+          );
         }
-        
+
         const buffer = await response.arrayBuffer();
-        
+
         // Save video to file
         const filePath = args.output_path
-          ? (i === 0 ? args.output_path : args.output_path.replace(/\.mp4$/i, `_${i}.mp4`))
-          : `video_output_${Date.now()}${i === 0 ? '' : '_' + i}.mp4`;
+          ? i === 0
+            ? args.output_path
+            : args.output_path.replace(/\.mp4$/i, `_${i}.mp4`)
+          : `video_output_${Date.now()}${i === 0 ? "" : "_" + i}.mp4`;
         const absPath = path.resolve(filePath);
-        
+
         fs.writeFileSync(absPath, Buffer.from(buffer));
         outputs.push(absPath);
-        console.log(`Saved video to: ${absPath}`);
+        console.error(`Saved video to: ${absPath}`);
       }
 
       if (outputs.length > 0) {
-        return `Video(s) saved successfully:\n${outputs.map((p, i) => `${i + 1}. ${p}`).join('\n')}`;
+        return `Video(s) saved successfully:\n${outputs
+          .map((p, i) => `${i + 1}. ${p}`)
+          .join("\n")}`;
       }
 
       return "Video generation completed but no videos were saved.";
-      
     } catch (error: any) {
-      throw new Error(`Video generation failed: ${error.message || JSON.stringify(error)}`);
+      throw new Error(
+        `Video generation failed: ${error.message || JSON.stringify(error)}`
+      );
     }
   },
 };

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

@@ -11,32 +11,23 @@ async function wait(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+import { ensureLocalFile } from "../utils/url-file";
+
 async function fileToBase64(
   filePath: string
 ): Promise<{ data: string; mimeType: string }> {
-  const storage = getStorage();
+  const fileResult = await ensureLocalFile(filePath);
 
-  // Check if file exists
-  const exists = await storage.exists(filePath);
-  if (!exists) {
-    // Try to provide more helpful error information
-    const isAbsolute = path.isAbsolute(filePath);
-    const resolvedPath = isAbsolute
-      ? filePath
-      : path.resolve(process.cwd(), filePath);
-    throw new Error(
-      `File not found: ${filePath}\n` +
-        `Resolved path: ${resolvedPath}\n` +
-        `Is absolute: ${isAbsolute}\n` +
-        `CWD: ${process.cwd()}`
-    );
+  try {
+    const storage = getStorage();
+    const buf = await storage.readFile(fileResult.path);
+    const data = Buffer.from(buf).toString("base64");
+    // Default to PNG if not sure, similar to existing code
+    const mimeType = "image/png";
+    return { data, mimeType };
+  } finally {
+    fileResult.cleanup();
   }
-
-  const buf = await storage.readFile(filePath);
-  const data = Buffer.from(buf).toString("base64");
-  // Default to PNG if not sure, similar to existing code
-  const mimeType = "image/png";
-  return { data, mimeType };
 }
 
 export const imageToVideo = {

package/src/utils/fal.utils.ts

@@ -8,14 +8,16 @@ export async function callFalModel(
   const { falKey, logs = true } = options;
   const key = falKey || process.env.FAL_KEY;
   if (!key) {
-    throw new Error("FAL_KEY is required. Provide it via fal_key parameter or FAL_KEY environment variable.");
+    throw new Error(
+      "FAL_KEY is required. Provide it via fal_key parameter or FAL_KEY environment variable."
+    );
   }
 
   fal.config({
     credentials: key,
   });
 
-  console.log(`[${modelName}] Submitting request to FAL AI...`);
+  console.error(`[${modelName}] Submitting request to FAL AI...`);
 
   try {
     const result = await fal.subscribe(modelName, {
@@ -23,23 +25,29 @@ export async function callFalModel(
       logs,
       onQueueUpdate: (update) => {
         if (update.status === "IN_PROGRESS") {
-          console.log(`[${modelName}] Status: ${update.status}`);
+          console.error(`[${modelName}] Status: ${update.status}`);
           if (logs && "logs" in update && update.logs) {
             update.logs.forEach((log) => {
-              console.log(`[${modelName}] ${log.message}`);
+              console.error(`[${modelName}] ${log.message}`);
             });
           }
         } else if (update.status === "IN_QUEUE") {
-          console.log(`[${modelName}] Status: ${update.status} - Waiting in queue...`);
+          console.error(
+            `[${modelName}] Status: ${update.status} - Waiting in queue...`
+          );
         }
       },
     });
 
-    console.log(`[${modelName}] Generation completed successfully`);
+    console.error(`[${modelName}] Generation completed successfully`);
 
     return result;
   } catch (error: any) {
     console.error(`[${modelName}] Error:`, error);
-    throw new Error(`FAL AI ${modelName} generation failed: ${error.message || JSON.stringify(error)}`);
+    throw new Error(
+      `FAL AI ${modelName} generation failed: ${
+        error.message || JSON.stringify(error)
+      }`
+    );
   }
 }

package/src/utils/url-file.ts

@@ -0,0 +1,91 @@
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { getStorage } from "../storage";
+import { generateTimestampedFilename } from "./filename";
+
+export interface LocalFileResult {
+  path: string;
+  isTemp: boolean;
+  cleanup: () => void;
+}
+
+/**
+ * Ensures the input is a local file path.
+ * If input is a URL, downloads it to a temporary file.
+ * If input is a file path, returns it as is (resolving if necessary).
+ */
+export async function ensureLocalFile(input: string): Promise<LocalFileResult> {
+  const isUrl = input.startsWith("http://") || input.startsWith("https://");
+
+  if (isUrl) {
+    const tempDir = os.tmpdir();
+    // Use a timestamped filename to avoid collisions
+    // Try to guess extension from URL or default to bin/tmp
+    const urlPath = new URL(input).pathname;
+    const ext = path.extname(urlPath) || ".tmp";
+    // We'll use a simple name since generateTimestampedFilename expects a file path
+    const safeName = `mcp_download_${Date.now()}${ext}`;
+    const tempFilePath = path.join(tempDir, safeName);
+
+    try {
+      const response = await fetch(input);
+      if (!response.ok) {
+        throw new Error(
+          `Failed to download URL: ${input} (${response.status} ${response.statusText})`
+        );
+      }
+
+      const arrayBuffer = await response.arrayBuffer();
+      const buffer = Buffer.from(arrayBuffer);
+      fs.writeFileSync(tempFilePath, buffer);
+
+      return {
+        path: tempFilePath,
+        isTemp: true,
+        cleanup: () => {
+          try {
+            if (fs.existsSync(tempFilePath)) {
+              fs.unlinkSync(tempFilePath);
+            }
+          } catch (e) {
+            console.error(`Failed to cleanup temp file ${tempFilePath}:`, e);
+          }
+        },
+      };
+    } catch (error: any) {
+      // If download failed, clean up if we created the file
+      try {
+        if (fs.existsSync(tempFilePath)) {
+          fs.unlinkSync(tempFilePath);
+        }
+      } catch {}
+      throw new Error(`Failed to process URL ${input}: ${error.message}`);
+    }
+  } else {
+    // It's a local file path (or at least we treat it as one)
+    // We verify existence using our storage abstraction or fs
+    const storage = getStorage();
+    const exists = await storage.exists(input);
+
+    if (!exists) {
+      // Try to provide more helpful error information
+      const isAbsolute = path.isAbsolute(input);
+      const resolvedPath = isAbsolute
+        ? input
+        : path.resolve(process.cwd(), input);
+      throw new Error(
+        `File not found: ${input}\n` +
+          `Resolved path: ${resolvedPath}\n` +
+          `Is absolute: ${isAbsolute}\n` +
+          `CWD: ${process.cwd()}`
+      );
+    }
+
+    return {
+      path: input,
+      isTemp: false,
+      cleanup: () => {}, // No-op for existing local files
+    };
+  }
+}