@infimind/video-mcp-cli 1.0.0

package/README.md

@@ -0,0 +1,119 @@
+# @infimind/video-mcp-cli
+
+MCP Server for Sora AI Video Generator - Access video generation features through Claude Desktop.
+
+## What is MCP?
+
+MCP (Model Context Protocol) is an open protocol that enables Claude Desktop to securely connect to external data sources and tools. This MCP server allows you to interact with the Sora AI Video Generator API directly from Claude Desktop.
+
+## Installation
+
+### Via npm (Recommended)
+
+```bash
+npm install -g @infimind/video-mcp-cli
+```
+
+### Via npx (No installation required)
+
+```json
+{
+  "mcpServers": {
+    "sora-video-generator": {
+      "command": "npx",
+      "args": ["-y", "@infimind/video-mcp-cli", "--token=YOUR_TOKEN"]
+    }
+  }
+}
+```
+
+## Configuration
+
+### 1. Get Your API Token
+
+1. Log in to your Sora AI Video Generator account
+2. Navigate to "API Tokens" in the sidebar
+3. Click "New Token" and give it a name
+4. Copy the generated token (it will only be shown once!)
+
+### 2. Configure Claude Desktop
+
+Add the following to your Claude Desktop configuration file:
+
+**macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
+**Windows**: `%APPDATA%\Claude\claude_desktop_config.json`
+
+```json
+{
+  "mcpServers": {
+    "sora-video-generator": {
+      "command": "sora-mcp",
+      "args": ["--token=YOUR_TOKEN_HERE"],
+      "env": {
+        "SORA_API_URL": "https://your-api-domain.com/api/trpc"
+      }
+    }
+  }
+}
+```
+
+#### Environment Variables
+
+- `SORA_API_URL` (optional): Your API base URL. Defaults to `http://localhost:3000/api/trpc`
+
+### 3. Restart Claude Desktop
+
+After saving the configuration, restart Claude Desktop for the changes to take effect.
+
+## Available Tools
+
+### `get_user_info`
+
+Get information about the authenticated user.
+
+**Example usage in Claude:**
+```
+Get my user information for the video generator
+```
+
+## Development
+
+```bash
+# Clone the repository
+git clone <repository-url>
+
+# Install dependencies
+cd mcp-server
+npm install
+
+# Build
+npm run build
+
+# Run in development mode
+node dist/index.js --token=YOUR_TOKEN
+```
+
+## Publishing
+
+```bash
+# Build the package
+npm run build
+
+# Publish to npm
+npm publish --access public
+```
+
+## Security
+
+- Never share your API token with others
+- Store tokens securely and rotate them periodically
+- Use environment variables for sensitive configuration
+- The token is transmitted over HTTPS in production
+
+## License
+
+MIT
+
+## Support
+
+For issues and support, please visit: https://github.com/infimind/sora-video-generator

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { createServer } from "./server.js";
+/**
+ * CLI Entry Point for Sora MCP Server
+ *
+ * Usage: sora-mcp --token=YOUR_TOKEN
+ *
+ * Environment Variables:
+ *   SORA_API_URL - API base URL (default: http://localhost:3000/api)
+ */
+async function main() {
+    // Parse command line arguments
+    const args = process.argv.slice(2);
+    const tokenArg = args.find(arg => arg.startsWith("--token="));
+    if (!tokenArg) {
+        console.error("Error: --token argument is required");
+        console.error("Usage: sora-mcp --token=YOUR_TOKEN");
+        process.exit(1);
+    }
+    const token = tokenArg.split("=")[1];
+    if (!token) {
+        console.error("Error: Token value is empty");
+        process.exit(1);
+    }
+    // Get API URL from environment variable or use default
+    // Note: Default should be just the base path without /trpc
+    const apiUrl = process.env.SORA_API_URL || "http://localhost:3000/api";
+    // Create and start the MCP server
+    const server = createServer(token, apiUrl);
+    // Set up stdio transport
+    const transport = new StdioServerTransport();
+    // Connect the server to the transport
+    await server.connect(transport);
+    // Server is now running and listening for messages via stdio
+    // Graceful shutdown
+    process.on("SIGINT", async () => {
+        await server.close();
+        process.exit(0);
+    });
+}
+main().catch((error) => {
+    console.error("Fatal error:", error);
+    process.exit(1);
+});

package/dist/server.d.ts

@@ -0,0 +1,11 @@
+/**
+ * MCP Server Implementation for Sora AI Video Generator
+ *
+ * This server implements the Model Context Protocol to allow Claude Desktop
+ * to interact with the Sora AI Video Generator API.
+ */
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+/**
+ * Create and configure the MCP Server
+ */
+export declare function createServer(token: string, apiBaseUrl: string): Server;

package/dist/server.js

@@ -0,0 +1,399 @@
+/**
+ * MCP Server Implementation for Sora AI Video Generator
+ *
+ * This server implements the Model Context Protocol to allow Claude Desktop
+ * to interact with the Sora AI Video Generator API.
+ */
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+/**
+ * Create and configure the MCP Server
+ */
+export function createServer(token, apiBaseUrl) {
+    const server = new Server({
+        name: "sora-video-generator-mcp",
+        version: "1.0.0",
+    }, {
+        capabilities: {
+            tools: {},
+        },
+    });
+    /**
+     * List available tools
+     */
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        const tools = [
+            {
+                name: "get_user_info",
+                description: "Get information about the authenticated user, including username, name, email, role, credits, and VIP status",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+            {
+                name: "create_video_task",
+                description: "Create a video generation task. Supports local file paths or public URLs for reference images. " +
+                    "The prompt will be automatically translated and optimized based on the target language.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        prompt: {
+                            type: "string",
+                            description: "The video generation prompt describing what you want to create",
+                        },
+                        sourceImage: {
+                            type: "string",
+                            description: "Optional reference image - can be a local file path (e.g., /path/to/image.jpg) or a public URL",
+                        },
+                        model: {
+                            type: "string",
+                            description: "Video model to use: sora_video2-15s (default) or sora-pro",
+                            enum: ["sora_video2-15s", "sora-pro"],
+                        },
+                        size: {
+                            type: "string",
+                            description: "Video resolution (default: 1280x704)",
+                            enum: ["1280x704", "1920x1080", "1080x1920", "704x1280"],
+                        },
+                        seconds: {
+                            type: "number",
+                            description: "Video duration in seconds: 10 (default) or 15",
+                            enum: [10, 15],
+                        },
+                        language: {
+                            type: "string",
+                            description: "Target language for the video (default: zh-CN)",
+                            enum: ["zh-CN", "en-US", "ja-JP", "ko-KR", "es-ES", "fr-FR"],
+                        },
+                        count: {
+                            type: "number",
+                            description: "Number of videos to generate (1-10, default: 1)",
+                            minimum: 1,
+                            maximum: 10,
+                        },
+                        route: {
+                            type: "string",
+                            description: "API route to use: S1 (default), S2, or S3",
+                            enum: ["S1", "S2", "S3"],
+                        },
+                    },
+                    required: ["prompt"],
+                },
+            },
+            {
+                name: "get_video_status",
+                description: "Get the status of a video generation task, including progress and video URLs",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        taskId: {
+                            type: "number",
+                            description: "The video generation task ID",
+                        },
+                    },
+                    required: ["taskId"],
+                },
+            },
+            {
+                name: "create_video_analysis_task",
+                description: "Create a video analysis task that breaks down a video into script, style, selling points, viral formula, and generates a prompt for video creation. " +
+                    "Supports local file paths or public URLs for the video file.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        videoFile: {
+                            type: "string",
+                            description: "Video file to analyze - can be a local file path (e.g., /path/to/video.mp4) or a public URL",
+                        },
+                    },
+                    required: ["videoFile"],
+                },
+            },
+            {
+                name: "get_video_analysis_status",
+                description: "Get the status and results of a video analysis task",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        analysisId: {
+                            type: "number",
+                            description: "The video analysis task ID",
+                        },
+                    },
+                    required: ["analysisId"],
+                },
+            },
+        ];
+        return { tools };
+    });
+    /**
+     * Handle tool calls
+     */
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        try {
+            switch (name) {
+                case "get_user_info":
+                    return await handleGetUserInfo(apiBaseUrl, token);
+                case "create_video_task":
+                    return await handleCreateVideoTask(apiBaseUrl, token, args);
+                case "get_video_status":
+                    return await handleGetVideoStatus(apiBaseUrl, token, args);
+                case "create_video_analysis_task":
+                    return await handleCreateVideoAnalysisTask(apiBaseUrl, token, args);
+                case "get_video_analysis_status":
+                    return await handleGetVideoAnalysisStatus(apiBaseUrl, token, args);
+                default:
+                    throw new Error(`Unknown tool: ${name}`);
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: ${errorMessage}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    return server;
+}
+/**
+ * Handle get_user_info tool call
+ */
+async function handleGetUserInfo(apiBaseUrl, token) {
+    const response = await callRestApi(apiBaseUrl, "/mcp/user-info", { token }, "GET");
+    const userInfo = [
+        `# User Information`,
+        ``,
+        `- **Username**: ${response.username}`,
+        `- **Name**: ${response.name || "N/A"}`,
+        `- **Email**: ${response.email || "N/A"}`,
+        `- **Role**: ${response.role === "admin" ? "Administrator" : "User"}`,
+        `- **Credits**: ${response.credits}`,
+        `- **VIP Status**: ${response.isVip ? "Yes" : "No"}`,
+    ].join("\n");
+    return {
+        content: [
+            {
+                type: "text",
+                text: userInfo,
+            },
+        ],
+    };
+}
+/**
+ * Handle create_video_task tool call
+ */
+async function handleCreateVideoTask(apiBaseUrl, token, args) {
+    const response = await callRestApi(apiBaseUrl, "/mcp/video/create", {
+        token,
+        prompt: args.prompt,
+        sourceImage: args.sourceImage,
+        model: args.model || "sora_video2-15s",
+        size: args.size || "1280x704",
+        seconds: args.seconds || 10,
+        language: args.language || "zh-CN",
+        count: args.count || 1,
+        route: args.route || "S1",
+    }, "POST");
+    const result = [
+        `# Video Generation Task Created`,
+        ``,
+        `- **Task ID**: ${response.taskId}`,
+        `- **Message**: ${response.message}`,
+        `- **Videos to Generate**: ${response.videoCount}`,
+        `- **Credits Used**: ${response.creditsUsed}`,
+        `- **Remaining Credits**: ${response.remainingCredits}`,
+        ``,
+        `Use \`get_video_status\` with task ID ${response.taskId} to check the progress.`,
+    ].join("\n");
+    return {
+        content: [
+            {
+                type: "text",
+                text: result,
+            },
+        ],
+    };
+}
+/**
+ * Handle get_video_status tool call
+ */
+async function handleGetVideoStatus(apiBaseUrl, token, args) {
+    const response = await callRestApi(apiBaseUrl, `/mcp/video/status/${args.taskId}`, { token }, "GET");
+    const statusText = response.status === "completed" ? "✅ Completed" :
+        response.status === "processing" ? "🔄 Processing" :
+            response.status === "failed" ? "❌ Failed" : `⏳ ${response.status}`;
+    let result = [
+        `# Video Generation Task Status`,
+        ``,
+        `- **Task ID**: ${response.taskId}`,
+        `- **Status**: ${statusText}`,
+        `- **Progress**: ${response.progress}% (${response.completedVideos}/${response.totalVideos} videos)`,
+        ``,
+    ];
+    if (response.videos && response.videos.length > 0) {
+        result.push(`## Videos:`);
+        response.videos.forEach((video, index) => {
+            const videoStatus = video.status === "completed" ? "✅" :
+                video.status === "processing" ? "🔄" :
+                    video.status === "failed" ? "❌" : "⏳";
+            result.push(``);
+            result.push(`${index + 1}. ${videoStatus} Video ID: ${video.id}`);
+            if (video.videoUrl) {
+                result.push(`   📹 [Video](${video.videoUrl})`);
+            }
+            if (video.thumbnailUrl) {
+                result.push(`   🖼️ [Thumbnail](${video.thumbnailUrl})`);
+            }
+            if (video.errorMessage) {
+                result.push(`   ❌ Error: ${video.errorMessage}`);
+            }
+        });
+    }
+    return {
+        content: [
+            {
+                type: "text",
+                text: result.join("\n"),
+            },
+        ],
+    };
+}
+/**
+ * Handle create_video_analysis_task tool call
+ */
+async function handleCreateVideoAnalysisTask(apiBaseUrl, token, args) {
+    const response = await callRestApi(apiBaseUrl, "/mcp/video-analysis/create", {
+        token,
+        videoFile: args.videoFile,
+    }, "POST");
+    const result = [
+        `# Video Analysis Task Created`,
+        ``,
+        `- **Analysis ID**: ${response.analysisId}`,
+        `- **Message**: ${response.message}`,
+        `- **Credits Used**: ${response.creditsUsed}`,
+        `- **Remaining Credits**: ${response.remainingCredits}`,
+        ``,
+        `Use \`get_video_analysis_status\` with analysis ID ${response.analysisId} to check the progress.`,
+    ].join("\n");
+    return {
+        content: [
+            {
+                type: "text",
+                text: result,
+            },
+        ],
+    };
+}
+/**
+ * Handle get_video_analysis_status tool call
+ */
+async function handleGetVideoAnalysisStatus(apiBaseUrl, token, args) {
+    const response = await callRestApi(apiBaseUrl, `/mcp/video-analysis/status/${args.analysisId}`, { token }, "GET");
+    const statusText = response.status === "completed" ? "✅ Completed" :
+        response.status === "processing" ? "🔄 Processing" :
+            response.status === "pending" ? "⏳ Pending" :
+                response.status === "failed" ? "❌ Failed" : `⏳ ${response.status}`;
+    let result = [
+        `# Video Analysis Task Status`,
+        ``,
+        `- **Analysis ID**: ${response.analysisId}`,
+        `- **Status**: ${statusText}`,
+    ];
+    if (response.conversionProgress !== null) {
+        result.push(`- **Conversion Progress**: ${response.conversionProgress}%`);
+    }
+    if (response.status === "completed") {
+        result.push(``);
+        result.push(`## Analysis Results:`);
+        result.push(``);
+        if (response.script) {
+            result.push(`### 📝 Video Script`);
+            result.push(response.script);
+            result.push(``);
+        }
+        if (response.style) {
+            result.push(`### 🎨 Video Style`);
+            result.push(response.style);
+            result.push(``);
+        }
+        if (response.sellingPoints) {
+            result.push(`### 🎯 Selling Points`);
+            result.push(response.sellingPoints);
+            result.push(``);
+        }
+        if (response.viralFormula) {
+            result.push(`### 💡 Viral Formula`);
+            result.push(response.viralFormula);
+            result.push(``);
+        }
+        if (response.generatedPrompt) {
+            result.push(`### 🎬 Generated Prompt (for Sora)`);
+            result.push(`\`\`\``);
+            result.push(response.generatedPrompt);
+            result.push(`\`\`\``);
+        }
+    }
+    else if (response.status === "failed" && response.errorMessage) {
+        result.push(``);
+        result.push(`### ❌ Error`);
+        result.push(response.errorMessage);
+    }
+    if (response.videoFileName) {
+        result.push(``);
+        result.push(`**Source File**: ${response.videoFileName}`);
+    }
+    return {
+        content: [
+            {
+                type: "text",
+                text: result.join("\n"),
+            },
+        ],
+    };
+}
+/**
+ * Call REST API
+ *
+ * @param apiBaseUrl - Base URL of the API (e.g., http://localhost:3001/api)
+ * @param path - API path (e.g., /mcp/user-info)
+ * @param params - Query parameters or request body
+ * @param method - HTTP method (GET or POST)
+ * @returns Parsed response data
+ */
+async function callRestApi(apiBaseUrl, path, params, method = "GET") {
+    // Build URL
+    const baseUrl = apiBaseUrl.endsWith("/") ? apiBaseUrl.slice(0, -1) : apiBaseUrl;
+    const fullPath = path.startsWith("/") ? path : "/" + path;
+    let fullUrl = `${baseUrl}${fullPath}`;
+    // For GET requests, add params as query string
+    if (method === "GET" && Object.keys(params).length > 0) {
+        const queryParams = new URLSearchParams(params).toString();
+        fullUrl += `?${queryParams}`;
+    }
+    const response = await fetch(fullUrl, {
+        method,
+        headers: {
+            "Content-Type": "application/json",
+        },
+        body: method === "POST" ? JSON.stringify(params) : undefined,
+    });
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`API request failed with status ${response.status}: ${errorText}`);
+    }
+    const data = await response.json();
+    // Check for error in response
+    if (data.error) {
+        throw new Error(data.error.message || "API returned an error");
+    }
+    return data;
+}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@infimind/video-mcp-cli",
+  "version": "1.0.0",
+  "description": "MCP Server for Sora AI Video Generator - Access video generation features through Claude Desktop",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "sora-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "claude",
+    "video-generation",
+    "sora"
+  ],
+  "author": "INFIMIND",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.4",
+    "node-fetch": "^3.3.2"
+  },
+  "devDependencies": {
+    "@types/node": "^20.17.10",
+    "typescript": "^5.7.2"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}