@mixio-pro/kalaasetu-mcp 2.3.28-exp → 2.3.29

package/bin/cli.js

@@ -7,7 +7,7 @@ import { dirname, join } from 'path';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
-const indexPath = join(__dirname, '..', 'dist', 'index.js');
+const indexPath = join(__dirname, '..', 'src', 'index.ts');
 
 // Try to run with Bun first
 const bunProcess = spawn('bun', [indexPath], {

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@mixio-pro/kalaasetu-mcp",
-  "version": "2.3.28-exp",
+  "version": "2.3.29",
   "description": "A powerful Model Context Protocol server providing AI tools for content generation and analysis",
   "type": "module",
-  "module": "dist/index.js",
-  "main": "dist/index.js",
+  "module": "src/index.ts",
+  "main": "src/index.ts",
   "bin": {
     "kalaasetu-mcp": "bin/cli.js"
   },
   "files": [
-    "dist",
+    "src",
     "bin",
     "fal-config.json",
     "README.md",
@@ -17,9 +17,7 @@
   ],
   "scripts": {
     "start": "bun run src/index.ts",
-    "dev": "bun --watch src/index.ts",
-    "build": "bun build ./src/index.ts --outdir ./dist --target bun --minify --no-sourcemap --external \"@fal-ai/client\" --external \"@google/genai\" --external \"@openmeter/sdk\" --external \"@sentry/node\" --external \"@types/node\" --external \"@types/sharp\" --external \"@types/wav\" --external \"dotenv\" --external \"fastmcp\" --external \"form-data\" --external \"google-auth-library\" --external \"jsonata\" --external \"sharp\" --external \"wav\" --external \"winston\" --external \"winston-transport-sentry-node\" --external \"zod\"",
-    "prepublishOnly": "bun run build"
+    "dev": "bun --watch src/index.ts"
   },
   "keywords": [
     "mcp",

package/src/index.ts

@@ -0,0 +1,162 @@
+#!/usr/bin/env bun
+import { FastMCP } from "fastmcp";
+import pkg from "../package.json";
+import {
+  falListPresets,
+  falGetPresetDetails,
+  falUploadFile,
+  falGenerate,
+} from "./tools/fal";
+import { createAllFalTools } from "./tools/fal/dynamic-tools";
+// import { geminiEditImage, geminiTextToImage } from "./tools/gemini";
+import { generateImage } from "./tools/generate-image";
+import { generateSceneImage } from "./tools/generate-scene-image";
+import { imageToVideo } from "./tools/image-to-video";
+import { ingredientsToVideo } from "./tools/ingredients-to-video";
+import {
+  byteplusImageToVideo,
+  byteplusRefToVideo,
+  byteplusSceneVideo,
+} from "./tools/byteplus";
+import { getGenerationStatus } from "./tools/get-status";
+import {
+  smallestAiTtsToWav,
+  smallestAiTranscribeAudio,
+  smallestAiCreateClone,
+  smallestAiListClones,
+  smallestAiDeleteClone,
+  smallestAiListVoices,
+} from "./tools/smallestai";
+import {
+  mixioMultiAngle,
+  mixioNextScene,
+  mixioFaceSwap,
+  mixioMultiAngleBatch,
+  mixioEditImage,
+  mixioImageToVideo,
+} from "./tools/mixio";
+
+import { syncFalConfig } from "./tools/fal/config";
+import { logger } from "./utils/logger";
+import { loadRemoteConfig } from "./utils/remote-config";
+import { z } from "zod";
+
+const server = new FastMCP({
+  name: "Kalaasetu MCP Server",
+  version: pkg.version as any,
+});
+
+async function main() {
+  const args = process.argv.slice(2);
+  const transportArg = args.find((arg) => arg.startsWith("--transport="));
+  const portArg = args.find((arg) => arg.startsWith("--port="));
+
+  const transportType = transportArg?.split("=")[1] ?? "stdio";
+  const portValue = portArg?.split("=")[1];
+  const port = portValue ? parseInt(portValue, 10) : 3000;
+
+  logger.info("🚀 Initializing Kalaasetu MCP Server...");
+
+  const noRemoteConfig = args.includes("--no-remote-config");
+
+  // 0. Load Remote Config
+  await loadRemoteConfig({ enabled: !noRemoteConfig });
+
+  // 1. Sync Remote Configs
+  await Promise.all([syncFalConfig()]);
+
+  // 2. Add Google Tools (Veo & Image)
+  const googleVeoEnabled = process.env.GOOGLE_VEO_ENABLED !== "false";
+  const googleImageEnabled = process.env.GOOGLE_IMAGE_ENABLED !== "false";
+
+  if (googleVeoEnabled) {
+    server.addTool(imageToVideo);
+    server.addTool(ingredientsToVideo);
+  }
+
+  if (googleImageEnabled) {
+    server.addTool(generateImage);
+    server.addTool(generateSceneImage);
+  }
+
+  // if (process.env.BYTEDANCE_ENABLED && process.env.BYTEPLUS_API_KEY) {
+  //   server.addTool(byteplusImageToVideo);
+  //   server.addTool(byteplusRefToVideo);
+  //   server.addTool(byteplusSceneVideo);
+  // }
+
+  if (process.env.WAVES_ENABLED && process.env.WAVES_API_KEY) {
+    server.addTool(smallestAiTtsToWav);
+    server.addTool(smallestAiTranscribeAudio);
+    server.addTool(smallestAiCreateClone);
+    server.addTool(smallestAiListClones);
+    server.addTool(smallestAiDeleteClone);
+    server.addTool(smallestAiListVoices);
+  }
+
+  // 3. Add Discovery Tools
+  if (process.env.FAL_ENABLED && process.env.FAL_KEY) {
+    server.addTool(falListPresets);
+    server.addTool(falGetPresetDetails);
+    server.addTool(falUploadFile);
+    server.addTool(falGenerate);
+    // 4. Register Dynamic FAL AI Tools
+    // These are now based on potentially synced remote config
+    const falTools = createAllFalTools();
+    for (const tool of falTools) {
+      server.addTool(tool);
+    }
+  }
+
+  // 4. Add Mixio Tools
+  // server.addTool(mixioMultiAngle);
+  // server.addTool(mixioMultiAngleBatch);
+  // server.addTool(mixioNextScene);
+  // server.addTool(mixioFaceSwap);
+  if (process.env.GROK_ENABLED === "true") {
+    server.addTool(mixioEditImage);
+    server.addTool(mixioImageToVideo);
+  }
+
+  // 5. Add Status Tool
+  server.addTool(getGenerationStatus);
+
+  // 6. Add Version Tool
+  server.addTool({
+    name: "get_version_" + process.env.CLIENT_ID,
+    description: "Get the current version of the Kalaasetu MCP server",
+    parameters: z.object({}),
+    execute: async () => {
+      return JSON.stringify({
+        version: pkg.version,
+        clientId: process.env.CLIENT_ID,
+        projectId: process.env.PROJECT_ID,
+        env: process.env,
+        mixioTokenFound: process.env.MIXIO_TOKEN_FOUND,
+        mixioToken: process.env.MIXIO_TOKEN,
+      });
+    },
+  });
+
+  if (transportType === "sse" || transportType === "httpStream") {
+    logger.info(
+      `✅ Starting server on port ${port} with transport: ${transportType}...`,
+    );
+    server.start({
+      transportType: "httpStream",
+      httpStream: {
+        port,
+      },
+    });
+  } else {
+    logger.info("✅ Starting server with transport: stdio...");
+    server.start({
+      transportType: "stdio",
+    });
+  }
+}
+
+main().catch((err) => {
+  logger.error("❌ Failed to start server:", err);
+  process.exit(1);
+});

package/src/runtime-env.test.ts

@@ -0,0 +1,77 @@
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+
+describe("runtime env resolution", () => {
+  const originalEnv = { ...process.env };
+  const originalFetch = globalThis.fetch;
+
+  beforeEach(() => {
+    process.env = { ...originalEnv };
+    globalThis.fetch = originalFetch;
+  });
+
+  afterEach(() => {
+    process.env = { ...originalEnv };
+    globalThis.fetch = originalFetch;
+  });
+
+  it("uses runtime FAL_KEY in checkFalStatus", async () => {
+    delete process.env.FAL_KEY;
+    const mod = await import("./tools/get-status");
+
+    process.env.FAL_KEY = "runtime_fal_key";
+
+    let authHeader: string | null = null;
+    globalThis.fetch = async (_url, init) => {
+      const headers = new Headers(init?.headers);
+      authHeader = headers.get("Authorization");
+      return new Response(JSON.stringify({ status: "IN_PROGRESS" }), {
+        status: 200,
+        headers: { "content-type": "application/json" },
+      });
+    };
+
+    await mod.checkFalStatus("https://queue.fal.run/test");
+    expect(authHeader).toBe("Key runtime_fal_key");
+  });
+
+  it("uses runtime WAVES_API_KEY in waves client", async () => {
+    delete process.env.WAVES_API_KEY;
+    const mod = await import("./tools/smallestai/client");
+
+    process.env.WAVES_API_KEY = "runtime_waves_key";
+
+    let authHeader: string | null = null;
+    globalThis.fetch = async (_url, init) => {
+      const headers = new Headers(init?.headers);
+      authHeader = headers.get("Authorization");
+      return new Response(JSON.stringify({ ok: true }), {
+        status: 200,
+        headers: { "content-type": "application/json" },
+      });
+    };
+
+    await mod.wavesClient.request("/v1/test", { method: "GET" });
+    expect(authHeader).toBe("Bearer runtime_waves_key");
+  });
+
+  it("uses runtime BYTEPLUS_BASE_URL in createTask", async () => {
+    delete process.env.BYTEPLUS_BASE_URL;
+    const mod = await import("./tools/byteplus/common");
+
+    process.env.BYTEPLUS_BASE_URL = "https://example.byteplus.local/api/v3";
+
+    let requestUrl = "";
+    globalThis.fetch = async (url) => {
+      requestUrl = String(url);
+      return new Response(JSON.stringify({ id: "task_123" }), {
+        status: 200,
+        headers: { "content-type": "application/json" },
+      });
+    };
+
+    await mod.createTask("api_key", { prompt: "hello" });
+    expect(requestUrl.startsWith("https://example.byteplus.local/api/v3")).toBe(
+      true,
+    );
+  });
+});

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";
+import {
+  getGoogleAuthClient,
+  getGoogleAccessToken,
+} from "../utils/google-auth";
+
+export class GCSStorageProvider implements StorageProvider {
+  private bucket: string;
+  private auth: GoogleAuth | null = null;
+
+  constructor(bucket: string) {
+    this.bucket = bucket;
+  }
+
+  async init(): Promise<void> {
+    this.auth = await getGoogleAuthClient({
+      scopes: ["https://www.googleapis.com/auth/cloud-platform"],
+    });
+    try {
+      await this.auth.getClient();
+    } catch (error) {
+      console.warn(`Warning: Could not initialize GCS client: ${error}`);
+    }
+  }
+
+  private async getAccessToken(): Promise<string> {
+    // 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> {
+    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: new Uint8Array(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

@@ -0,0 +1,36 @@
+import type { StorageProvider } from "./interface";
+import { LocalStorageProvider } from "./local";
+import { GCSStorageProvider } from "./gcs";
+import { logger } from "../utils/logger";
+
+let storageInstance: StorageProvider | null = null;
+
+export function getStorage(): StorageProvider {
+  if (!storageInstance) {
+    const type = process.env.STORAGE_PROVIDER || "local";
+    logger.info(`Initializing storage provider: ${type}`);
+    logger.info(`Base path (cwd): ${process.cwd()}`);
+    if (process.env.VSCODE_CWD) {
+      logger.info(`VSCode CWD: ${process.env.VSCODE_CWD}`);
+    }
+
+    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 {
+      const basePath = process.env.VSCODE_CWD || process.cwd();
+      storageInstance = new LocalStorageProvider(basePath);
+    }
+
+    // Initialize async
+    storageInstance
+      .init()
+      .catch((err) => logger.error("Failed to init storage:", err));
+  }
+  return storageInstance;
+}

package/src/storage/interface.ts

@@ -0,0 +1,7 @@
+export interface StorageProvider {
+  init(): Promise<void>;
+  readFile(path: string): Promise<Buffer>;
+  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

@@ -0,0 +1,63 @@
+import * as fs from "fs";
+import * as path from "path";
+import type { StorageProvider } from "./interface";
+
+export class LocalStorageProvider implements StorageProvider {
+  private basePath: string;
+
+  constructor(basePath: string = process.cwd()) {
+    this.basePath = basePath;
+  }
+
+  async init(): Promise<void> {
+    // No-op for local
+  }
+
+  private resolvePath(filePath: string): string {
+    if (path.isAbsolute(filePath)) {
+      return filePath;
+    }
+
+    // Handle LLM hallucinations: if path is relative but doesn't start with ./ or ../,
+    // and VSCODE_CWD is available, use it as the base.
+    if (
+      process.env.VSCODE_CWD &&
+      !filePath.startsWith("./") &&
+      !filePath.startsWith("../")
+    ) {
+      return path.resolve(process.env.VSCODE_CWD, filePath);
+    }
+
+    return path.resolve(this.basePath, filePath);
+  }
+
+  async readFile(filePath: string): Promise<Buffer> {
+    const fullPath = this.resolvePath(filePath);
+    return fs.promises.readFile(fullPath);
+  }
+
+  async writeFile(filePath: string, data: Buffer | string): Promise<string> {
+    const fullPath = this.resolvePath(filePath);
+
+    const dir = path.dirname(fullPath);
+    if (!fs.existsSync(dir)) {
+      await fs.promises.mkdir(dir, { recursive: true });
+    }
+    await fs.promises.writeFile(fullPath, data);
+    return fullPath;
+  }
+
+  async exists(filePath: string): Promise<boolean> {
+    const fullPath = this.resolvePath(filePath);
+    try {
+      await fs.promises.access(fullPath, fs.constants.F_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async getPublicUrl(filePath: string): Promise<string> {
+    return this.resolvePath(filePath);
+  }
+}

package/src/tools/byteplus/README.md

@@ -0,0 +1,52 @@
+# BytePlus Seedance 1.5 Pro — Video Generation Tools
+
+Three MCP tools for video generation using [BytePlus ModelArk](https://docs.byteplus.com/en/docs/ModelArk) Seedance 1.5 Pro.
+
+## Tools
+
+### `generateVideoSeedance` — Image-to-Video
+Single-shot video from a first frame image, with optional last frame for start→end interpolation.
+Always generates in **draft mode** (480p). Use `finalize_draft_task_id` to promote to final quality.
+
+**Use when:** animating a single image, or interpolating between start/end frames.
+
+### `generateVideoSeedanceRef` — Reference Images to Video
+Generate video incorporating elements from 1–4 reference images. Prompt uses `[Image 1]`, `[Image 2]` syntax.
+Rarely used. Always **draft mode**.
+
+**Use when:** compositing characters/objects/styles from multiple reference images.
+
+### `generateVideoSeedanceScene` — Multi-Shot Scene
+Chains multiple shots within one continuous scene. Each shot's last frame becomes the next shot's first frame.
+Uses **standard mode** (not draft) because `return_last_frame` is required for chaining.
+Handles MCP timeouts via `resume_state`.
+
+**Use when:** generating longer videos or continuous multi-shot scenes (not cut scenes).
+
+## Environment Variables
+
+| Variable | Required | Description |
+|---|---|---|
+| `BYTEPLUS_API_KEY` | Yes | API key from [BytePlus ModelArk console](https://console.byteplus.com/ark/region:ark+ap-southeast-1/apikey) |
+| `BYTEPLUS_BASE_URL` | No | Override base URL (default: `https://ark.ap-southeast.bytepluses.com/api/v3`) |
+| `GEMINI_API_KEY` | No | Required for LLM-based prompt enhancement (uses Gemini 2.0 Flash) |
+
+## API Reference
+
+- [Video Generation API](https://docs.byteplus.com/en/docs/ModelArk/1366799)
+- [Seedance 1.5 Pro Prompt Guide](https://docs.byteplus.com/en/docs/ModelArk/2168087)
+- [Image-to-Video modes](https://docs.byteplus.com/en/docs/ModelArk/1520757)
+- [Retrieve task status](https://docs.byteplus.com/en/docs/ModelArk/1521309)
+
+## Model
+
+Default model: `seedance-1-5-pro-251215`
+
+### Draft Mode (Image-to-Video & Reference tools)
+- 480p only — other resolutions will error
+- Fewer tokens consumed (60% of standard with audio)
+- `return_last_frame` not supported
+- Draft task ID valid for 7 days for finalization
+
+### Finalization
+Pass `finalize_draft_task_id` to promote a draft to a final video. The model reuses all inputs from the draft (prompt, images, seed, ratio, duration, camera_fixed). You can configure `final_resolution`, `watermark`, and `return_last_frame` during finalization.