@mixio-pro/kalaasetu-mcp 1.0.10 → 1.0.12

package/package.json

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

package/src/storage/index.ts

@@ -8,6 +8,7 @@ export function getStorage(): StorageProvider {
   if (!storageInstance) {
     const type = process.env.STORAGE_PROVIDER || "local";
     console.error(`Initializing storage provider: ${type}`);
+    console.error(`Base path (cwd): ${process.cwd()}`);
 
     if (type === "gcs") {
       const bucket = process.env.GCS_BUCKET;

package/src/storage/local.ts

@@ -40,7 +40,12 @@ export class LocalStorageProvider implements StorageProvider {
     if (!path.isAbsolute(filePath)) {
       fullPath = path.resolve(this.basePath, filePath);
     }
-    return fs.existsSync(fullPath);
+    try {
+      await fs.promises.access(fullPath, fs.constants.F_OK);
+      return true;
+    } catch {
+      return false;
+    }
   }
 
   async getPublicUrl(filePath: string): Promise<string> {

package/src/tools/gemini.ts

@@ -18,9 +18,23 @@ const ai = new GoogleGenAI({
 
 async function fileToGenerativePart(filePath: string) {
   const storage = getStorage();
-  if (!(await storage.exists(filePath))) {
-    throw new Error(`File not found: ${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()}`
+    );
   }
+
   const imageBytes = await storage.readFile(filePath);
   return {
     inlineData: {
@@ -153,8 +167,19 @@ async function processVideoInput(
   } else {
     // Local file processing - use File Upload API
     const storage = getStorage();
-    if (!(await storage.exists(input))) {
-      throw new Error(`Video file not found: ${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()}`
+      );
     }
 
     // Upload file to Gemini API
@@ -220,16 +245,13 @@ export const geminiTextToImage = {
             const imageData = part.inlineData.data;
             if (args.output_path) {
               const storage = getStorage();
-              const timestampedPath = generateTimestampedFilename(
-                args.output_path
-              );
               const url = await storage.writeFile(
-                timestampedPath,
+                args.output_path,
                 Buffer.from(imageData, "base64")
               );
               images.push({
                 url,
-                filename: timestampedPath,
+                filename: args.output_path,
                 mimeType: "image/png",
               });
             }
@@ -301,16 +323,13 @@ export const geminiEditImage = {
             const imageData = part.inlineData.data;
             if (args.output_path) {
               const storage = getStorage();
-              const timestampedPath = generateTimestampedFilename(
-                args.output_path
-              );
               const url = await storage.writeFile(
-                timestampedPath,
+                args.output_path,
                 Buffer.from(imageData, "base64")
               );
               images.push({
                 url,
-                filename: timestampedPath,
+                filename: args.output_path,
                 mimeType: "image/png",
               });
             }
@@ -445,12 +464,11 @@ export const geminiSingleSpeakerTts = {
 
       const audioBuffer = Buffer.from(data, "base64");
 
-      // Generate output filename if not provided
-      const outputPath = args.output_path || "voice_output.wav";
-      const timestampedPath = generateTimestampedFilename(outputPath);
+      // Use provided output path or generate default with timestamp
+      const outputPath = args.output_path || generateTimestampedFilename("voice_output.wav");
 
       const storage = getStorage();
-      const url = await storage.writeFile(timestampedPath, audioBuffer);
+      const url = await storage.writeFile(outputPath, audioBuffer);
 
       return JSON.stringify({
         audio: {

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

@@ -54,9 +54,23 @@ async function fileToBase64(
   filePath: string
 ): Promise<{ data: string; mimeType: string }> {
   const storage = getStorage();
-  if (!(await storage.exists(filePath))) {
-    throw new Error(`File not found: ${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()}`
+    );
   }
+
   const buf = await storage.readFile(filePath);
   const data = Buffer.from(buf).toString("base64");
   // Default to PNG if not sure, similar to existing code
@@ -288,13 +302,19 @@ export const imageToVideo = {
       [];
     const saveVideo = async (base64: string, index: number) => {
       if (!base64) return;
-      const baseFilename = args.output_path
-        ? index === 0
+      
+      // Use provided output path or generate default with timestamp
+      let filePath: string;
+      if (args.output_path) {
+        // User provided path - use as-is for first video, add index for subsequent
+        filePath = index === 0
           ? args.output_path
-          : args.output_path.replace(/\.mp4$/i, `_${index}.mp4`)
-        : `video_output${index > 0 ? `_${index}` : ""}.mp4`;
-
-      const filePath = generateTimestampedFilename(baseFilename);
+          : args.output_path.replace(/\.mp4$/i, `_${index}.mp4`);
+      } else {
+        // No path provided - generate timestamped default
+        const defaultName = `video_output${index > 0 ? `_${index}` : ""}.mp4`;
+        filePath = generateTimestampedFilename(defaultName);
+      }
 
       const buf = Buffer.from(base64, "base64");
       const storage = getStorage();

package/src/utils/filename.ts

@@ -1,8 +1,11 @@
+import * as path from "path";
+
 /**
  * Generate a timestamped filename to avoid conflicts
  * Format: YYYYMMDD_HHmmss_filename.ext
+ * Preserves directory structure if present in the input path
  */
-export function generateTimestampedFilename(basename: string): string {
+export function generateTimestampedFilename(filePath: string): string {
   const now = new Date();
   const timestamp = now
     .toISOString()
@@ -10,13 +13,26 @@ export function generateTimestampedFilename(basename: string): string {
     .replace(/\.\d{3}Z$/, "")
     .replace("T", "_");
 
+  // Split into directory and filename
+  const dir = path.dirname(filePath);
+  const basename = path.basename(filePath);
+
   // Extract extension if present
   const lastDot = basename.lastIndexOf(".");
+  let timestampedFilename: string;
+  
   if (lastDot > 0) {
     const name = basename.substring(0, lastDot);
     const ext = basename.substring(lastDot);
-    return `${timestamp}_${name}${ext}`;
+    timestampedFilename = `${timestamp}_${name}${ext}`;
+  } else {
+    timestampedFilename = `${timestamp}_${basename}`;
   }
 
-  return `${timestamp}_${basename}`;
+  // Reconstruct the full path
+  if (dir === ".") {
+    return timestampedFilename;
+  }
+  
+  return path.join(dir, timestampedFilename);
 }