@mixio-pro/kalaasetu-mcp 1.0.13 → 1.0.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mixio-pro/kalaasetu-mcp",
-  "version": "1.0.13",
+  "version": "1.0.15",
   "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

@@ -1,6 +1,10 @@
 import { GoogleAuth } from "google-auth-library";
 import type { StorageProvider } from "./interface";
 import * as path from "path";
+import {
+  getGoogleAuthClient,
+  getGoogleAccessToken,
+} from "../utils/google-auth";
 
 export class GCSStorageProvider implements StorageProvider {
   private bucket: string;
@@ -8,7 +12,7 @@ export class GCSStorageProvider implements StorageProvider {
 
   constructor(bucket: string) {
     this.bucket = bucket;
-    this.auth = new GoogleAuth({
+    this.auth = getGoogleAuthClient({
       scopes: ["https://www.googleapis.com/auth/cloud-platform"],
     });
   }
@@ -26,12 +30,12 @@ export class GCSStorageProvider implements StorageProvider {
   }
 
   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;
+    // Use the centralized helper which includes gcloud fallback if needed,
+    // although GCSStorageProvider primarily relies on the initialized GoogleAuth.
+    // However, if we want to support the same fallback logic as tools:
+    return getGoogleAccessToken({
+      scopes: ["https://www.googleapis.com/auth/cloud-platform"],
+    });
   }
 
   async readFile(filePath: string): Promise<Buffer> {

package/src/tools/gemini.ts

@@ -167,18 +167,20 @@ async function processVideoInput(
   } else {
     // Local file processing - use File Upload API
     const storage = getStorage();
-    
+
     // 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);
+      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()}`
+          `Resolved path: ${resolvedPath}\n` +
+          `Is absolute: ${isAbsolute}\n` +
+          `CWD: ${process.cwd()}`
       );
     }
 
@@ -192,7 +194,7 @@ async function processVideoInput(
 export const geminiTextToImage = {
   name: "generateImage",
   description:
-    "Generate images from text prompts using Gemini image models with optional reference images",
+    "Generate images from text prompts using Gemini image models with optional reference images. Returns the URL of the generated image.",
   parameters: z.object({
     prompt: z.string().describe("Text description of the image to generate"),
     aspect_ratio: z
@@ -202,7 +204,9 @@ export const geminiTextToImage = {
     output_path: z
       .string()
       .optional()
-      .describe("File path to save the generated image"),
+      .describe(
+        "File path to save the generated image (optional, auto-generated if not provided)"
+      ),
     reference_images: z
       .array(z.string())
       .optional()
@@ -243,31 +247,35 @@ export const geminiTextToImage = {
             textResponse += part.text;
           } else if (part.inlineData?.data) {
             const imageData = part.inlineData.data;
-            if (args.output_path) {
-              const storage = getStorage();
-              const url = await storage.writeFile(
-                args.output_path,
-                Buffer.from(imageData, "base64")
-              );
-              images.push({
-                url,
-                filename: args.output_path,
-                mimeType: "image/png",
-              });
-            }
+            // Always save the image - use provided path or generate one
+            const outputPath =
+              args.output_path ||
+              generateTimestampedFilename("generated_image.png");
+            const storage = getStorage();
+            const url = await storage.writeFile(
+              outputPath,
+              Buffer.from(imageData, "base64")
+            );
+            images.push({
+              url,
+              filename: outputPath,
+              mimeType: "image/png",
+            });
           }
         }
       }
 
       if (images.length > 0) {
+        // Return the URL directly for easy parsing
         return JSON.stringify({
+          url: images?.[0]?.url,
           images,
           message: textResponse || "Image generated successfully",
         });
       }
 
       return (
-        textResponse || "Image generation completed but no response received"
+        textResponse || "Image generation completed but no image was produced"
       );
     } catch (error: any) {
       throw new Error(`Image generation failed: ${error.message}`);
@@ -465,7 +473,8 @@ export const geminiSingleSpeakerTts = {
       const audioBuffer = Buffer.from(data, "base64");
 
       // Use provided output path or generate default with timestamp
-      const outputPath = args.output_path || generateTimestampedFilename("voice_output.wav");
+      const outputPath =
+        args.output_path || generateTimestampedFilename("voice_output.wav");
 
       const storage = getStorage();
       const url = await storage.writeFile(outputPath, audioBuffer);

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

@@ -5,50 +5,12 @@ import { z } from "zod";
 import { getStorage } from "../storage";
 import { generateTimestampedFilename } from "../utils/filename";
 
+import { getGoogleAccessToken } from "../utils/google-auth";
+
 async function wait(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
-async function fetchAccessToken(): Promise<string> {
-  try {
-    const auth = new GoogleAuth({
-      scopes: ["https://www.googleapis.com/auth/cloud-platform"],
-    });
-    const client = await auth.getClient();
-    const token = await client.getAccessToken();
-    if (!token || typeof token !== "string") {
-      throw new Error("No token from GoogleAuth");
-    }
-    return token;
-  } catch (e) {
-    // Fallback to gcloud
-    return await new Promise((resolve, reject) => {
-      exec("gcloud auth print-access-token", (err, stdout, stderr) => {
-        if (err) {
-          reject(
-            new Error(
-              `Failed to fetch an access token (ADC and gcloud): ${
-                stderr || err.message
-              }`
-            )
-          );
-          return;
-        }
-        const t = (stdout || "").trim();
-        if (!t) {
-          reject(
-            new Error(
-              "Failed to fetch an access token: empty token from gcloud"
-            )
-          );
-          return;
-        }
-        resolve(t);
-      });
-    });
-  }
-}
-
 async function fileToBase64(
   filePath: string
 ): Promise<{ data: string; mimeType: string }> {
@@ -191,7 +153,7 @@ export const imageToVideo = {
       durationSeconds = 8;
     }
 
-    const token = await fetchAccessToken();
+    const token = await getGoogleAccessToken();
 
     const url = `https://${location}-aiplatform.googleapis.com/v1/projects/${projectId}/locations/${location}/publishers/google/models/${modelId}:predictLongRunning`;
 

package/src/utils/google-auth.ts

@@ -0,0 +1,83 @@
+import { GoogleAuth } from "google-auth-library";
+import { exec } from "child_process";
+
+export interface GoogleAuthOptions {
+  scopes?: string | string[];
+}
+
+/**
+ * Returns a GoogleAuth client, prioritizing GOOGLE_SERVICE_ACCOUNT_JSON env var.
+ */
+export function getGoogleAuthClient(
+  options: GoogleAuthOptions = {}
+): GoogleAuth {
+  const opts: any = {
+    scopes: options.scopes || [
+      "https://www.googleapis.com/auth/cloud-platform",
+    ],
+  };
+
+  if (process.env.GOOGLE_SERVICE_ACCOUNT_JSON) {
+    try {
+      const credentials = JSON.parse(process.env.GOOGLE_SERVICE_ACCOUNT_JSON);
+      opts.credentials = credentials;
+      if (credentials.project_id) {
+        opts.projectId = credentials.project_id;
+      }
+    } catch (error) {
+      console.warn(
+        "Failed to parse GOOGLE_SERVICE_ACCOUNT_JSON, falling back to other methods:",
+        error
+      );
+    }
+  } else if (process.env.GOOGLE_SERVICE_ACCOUNT_JSON_PATH) {
+    // GoogleAuth natively supports keyFile/keyFilename
+    opts.keyFile = process.env.GOOGLE_SERVICE_ACCOUNT_JSON_PATH;
+  }
+
+  return new GoogleAuth(opts);
+}
+
+/**
+ * Returns an access token, trying GoogleAuth first (JSON > ADC), then gcloud CLI.
+ */
+export async function getGoogleAccessToken(
+  options: GoogleAuthOptions = {}
+): Promise<string> {
+  try {
+    const auth = getGoogleAuthClient(options);
+    const client = await auth.getClient();
+    const token = await client.getAccessToken();
+    if (token.token) {
+      return token.token;
+    }
+    throw new Error("No token returned from GoogleAuth");
+  } catch (e) {
+    // Fallback to gcloud
+    console.warn("GoogleAuth failed, falling back to gcloud CLI:", e);
+    return await new Promise((resolve, reject) => {
+      exec("gcloud auth print-access-token", (err, stdout, stderr) => {
+        if (err) {
+          reject(
+            new Error(
+              `Failed to fetch an access token (Auth Library and gcloud): ${
+                stderr || err.message
+              }`
+            )
+          );
+          return;
+        }
+        const t = (stdout || "").trim();
+        if (!t) {
+          reject(
+            new Error(
+              "Failed to fetch an access token: empty token from gcloud"
+            )
+          );
+          return;
+        }
+        resolve(t);
+      });
+    });
+  }
+}