@raihan0824/mcp-veo2/dist/cli.js

MCP server for generating videos with Google Veo2

#!/usr/bin/env node
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
import { createServer } from './server.js';
import config from './config.js';
import { log } from './utils/logger.js';
import fs from 'fs/promises';
import express from 'express';
/**
 * CLI entry point for MCP Veo2 server
 */
async function main() {
    const args = process.argv.slice(2);
    // Handle help command
    if (args.includes('--help') || args.includes('-h')) {
        console.log(`
MCP Veo2 - Video Generation Server
==================================

Usage:
  npx @raihan0824/mcp-veo2 [transport] [options]

Transport Types:
  stdio    Use stdio transport (default) - for MCP clients
  sse      Use Server-Sent Events transport - for web interfaces

Options:
  --help, -h     Show this help message
  --version, -v  Show version information

Examples:
  npx @raihan0824/mcp-veo2           # Start with stdio transport
  npx @raihan0824/mcp-veo2 stdio     # Start with stdio transport  
  npx @raihan0824/mcp-veo2 sse       # Start with SSE transport

Environment Variables:
  GOOGLE_GENAI_API_KEY    Required: Your Google GenAI API key
  PORT                    Optional: Port for SSE transport (default: 3000)
  STORAGE_DIR            Optional: Directory for generated videos
`);
        process.exit(0);
    }
    // Handle version command
    if (args.includes('--version') || args.includes('-v')) {
        try {
            const packageJsonPath = new URL('../package.json', import.meta.url);
            const packageJsonContent = await fs.readFile(packageJsonPath, 'utf-8');
            const packageJson = JSON.parse(packageJsonContent);
            console.log(`MCP Veo2 v${packageJson.version}`);
        }
        catch {
            console.log('MCP Veo2 v1.0.0');
        }
        process.exit(0);
    }
    try {
        // Create the MCP server
        const server = createServer();
        // Determine the transport type from command line arguments
        const transportType = args[0] || 'stdio';
        // Ensure the storage directory exists
        await fs.mkdir(config.STORAGE_DIR, { recursive: true });
        if (transportType === 'stdio') {
            // Use stdio transport
            log.info('Starting MCP Veo2 server with stdio transport');
            const transport = new StdioServerTransport();
            await server.connect(transport);
            log.info('MCP Veo2 server started with stdio transport');
        }
        else if (transportType === 'sse') {
            // Use SSE transport
            log.info(`Starting MCP Veo2 server with SSE transport on port ${config.PORT}`);
            const app = express();
            const port = config.PORT;
            // Store active SSE transports
            const transports = {};
            // Serve static files from the generated-videos directory
            app.use('/videos', express.static(config.STORAGE_DIR));
            // SSE endpoint
            app.get('/sse', (req, res) => {
                log.info('New SSE connection');
                const transport = new SSEServerTransport('/messages', res);
                transports[transport.sessionId] = transport;
                res.on('close', () => {
                    log.info(`SSE connection closed: ${transport.sessionId}`);
                    delete transports[transport.sessionId];
                });
                server.connect(transport).catch(err => {
                    log.error('Error connecting transport:', err);
                });
            });
            // Message endpoint
            app.post('/messages', express.json(), (req, res) => {
                const sessionId = req.query.sessionId;
                const transport = transports[sessionId];
                if (transport) {
                    transport.handlePostMessage(req, res).catch(err => {
                        log.error(`Error handling message for session ${sessionId}:`, err);
                    });
                }
                else {
                    res.status(404).send('Session not found');
                }
            });
            // Start the server
            app.listen(port, () => {
                log.info(`MCP Veo2 server started with SSE transport on port ${port}`);
                log.info(`Connect to http://localhost:${port}/sse`);
                console.log(`\nMCP Veo2 server running on http://localhost:${port}`);
                console.log(`SSE endpoint: http://localhost:${port}/sse`);
                console.log(`Generated videos: http://localhost:${port}/videos/`);
            });
        }
        else {
            console.error(`Unknown transport type: ${transportType}`);
            console.log('Usage: npx @raihan0824/mcp-veo2 [stdio|sse]');
            console.log('Run with --help for more information');
            process.exit(1);
        }
    }
    catch (error) {
        log.fatal('Error starting MCP Veo2 server:', error);
        // Check for common configuration issues
        if (error instanceof Error && error.message?.includes('GOOGLE_GENAI_API_KEY')) {
            console.error('\n❌ Missing Google GenAI API key!');
            console.error('Please set the GOOGLE_GENAI_API_KEY environment variable.');
            console.error('Get your API key from: https://aistudio.google.com/app/apikey');
        }
        process.exit(1);
    }
}
// Start the CLI
main().catch(err => {
    log.fatal('Unhandled error:', err);
    process.exit(1);
});
//# sourceMappingURL=cli.js.map