@mixio-pro/kalaasetu-mcp 1.0.16 → 1.0.18

package/package.json

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

package/src/tools/gemini.ts

@@ -16,32 +16,32 @@ 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 {
+    let imageBytes: Buffer;
+    if (fileResult.isTemp) {
+      // Temp files are always local on disk, read directly with fs
+      // This avoids 404s if storage provider is GCS/S3
+      imageBytes = fs.readFileSync(fileResult.path);
+    } else {
+      // If not temp, it might be a storage path, let storage provider handle it
+      const storage = getStorage();
+      imageBytes = await storage.readFile(fileResult.path);
+    }
 
-  const imageBytes = await storage.readFile(filePath);
-  return {
-    inlineData: {
-      data: Buffer.from(imageBytes).toString("base64"),
-      mimeType: "image/jpeg",
-    },
-  };
+    return {
+      inlineData: {
+        data: Buffer.from(imageBytes).toString("base64"),
+        mimeType: "image/jpeg",
+      },
+    };
+  } finally {
+    fileResult.cleanup();
+  }
 }
 
 // Helper function to save WAV file
@@ -165,29 +165,30 @@ 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
+      // If it's a temp file, we should bypass storage.readFile logic in uploadFileToGemini
+      // OR we can rely on uploadFileToGemini's existence check.
+      // But uploadFileToGemini uses storage.readFile if !fs.exists.
+      // Since fileResult.path IS a local temp file, fs.exists WILL be true.
+      // So uploadFileToGemini will see it exists locally and NOT try storage.readFile.
+      // Wait, uploadFileToGemini takes `filePath`.
+      // If `filePath` is absolute local path, `fs.existsSync` is true.
+      // So no changes needed here?
+      // Let's verify uploadFileToGemini logic again.
+      // It does: if (!fs.existsSync(filePath)) { read from storage }
+      // fileResult.path is guaranteed to exist locally (if temp).
+      // So correct.
+
+      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.ts

@@ -11,32 +11,33 @@ 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 {
+    let data: string;
+    if (fileResult.isTemp) {
+      // Temp files are always local on disk, read directly with fs
+      // This avoids 404s if storage provider is GCS
+      const fs = await import("fs");
+      const buf = fs.readFileSync(fileResult.path);
+      data = Buffer.from(buf).toString("base64");
+    } else {
+      const storage = getStorage();
+      const buf = await storage.readFile(fileResult.path);
+      data = Buffer.from(buf).toString("base64");
+    }
 
-  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 };
+    // Default to PNG if not sure, similar to existing code
+    const mimeType = "image/png";
+    return { data, mimeType };
+  } finally {
+    fileResult.cleanup();
+  }
 }
 
 export const imageToVideo = {

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
+    };
+  }
+}