luma-mcp 1.0.0 → 1.0.1

package/mcp-server/build/core/error-handler.js

@@ -0,0 +1,376 @@
+import { ApiError, ValidationError } from '../types/index.js';
+/**
+ * Error severity levels
+ */
+export var ErrorSeverity;
+(function (ErrorSeverity) {
+    ErrorSeverity["LOW"] = "low";
+    ErrorSeverity["MEDIUM"] = "medium";
+    ErrorSeverity["HIGH"] = "high";
+    ErrorSeverity["CRITICAL"] = "critical";
+})(ErrorSeverity || (ErrorSeverity = {}));
+/**
+ * Error categories
+ */
+export var ErrorCategory;
+(function (ErrorCategory) {
+    ErrorCategory["VALIDATION"] = "validation";
+    ErrorCategory["AUTHENTICATION"] = "authentication";
+    ErrorCategory["AUTHORIZATION"] = "authorization";
+    ErrorCategory["NETWORK"] = "network";
+    ErrorCategory["API"] = "api";
+    ErrorCategory["SYSTEM"] = "system";
+    ErrorCategory["BUSINESS"] = "business";
+    ErrorCategory["UNKNOWN"] = "unknown";
+})(ErrorCategory || (ErrorCategory = {}));
+/**
+ * Base error class
+ */
+export class BaseError extends Error {
+    code;
+    severity;
+    category;
+    context;
+    cause;
+    recoverable;
+    constructor(message, code, severity, category, context = {}, cause, recoverable = true) {
+        super(message);
+        this.name = this.constructor.name;
+        this.code = code;
+        this.severity = severity;
+        this.category = category;
+        this.context = {
+            timestamp: Date.now(),
+            ...context
+        };
+        this.cause = cause;
+        this.recoverable = recoverable;
+        // Preserve stack trace
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+    }
+    /**
+     * Convert to JSON format
+     */
+    toJSON() {
+        return {
+            name: this.name,
+            message: this.message,
+            code: this.code,
+            severity: this.severity,
+            category: this.category,
+            context: this.context,
+            recoverable: this.recoverable,
+            stack: this.stack,
+            cause: this.cause ? {
+                name: this.cause.name,
+                message: this.cause.message,
+                stack: this.cause.stack
+            } : undefined
+        };
+    }
+}
+/**
+ * Business logic error
+ */
+export class BusinessError extends BaseError {
+    constructor(message, code = 'BUSINESS_ERROR', context = {}, cause) {
+        super(message, code, ErrorSeverity.MEDIUM, ErrorCategory.BUSINESS, context, cause, true);
+    }
+    getUserMessage() {
+        return this.message;
+    }
+}
+/**
+ * System error
+ */
+export class SystemError extends BaseError {
+    constructor(message, code = 'SYSTEM_ERROR', context = {}, cause) {
+        super(message, code, ErrorSeverity.HIGH, ErrorCategory.SYSTEM, context, cause, false);
+    }
+    getUserMessage() {
+        return 'An internal system error occurred. Please try again later.';
+    }
+}
+/**
+ * Network error
+ */
+export class NetworkError extends BaseError {
+    constructor(message, code = 'NETWORK_ERROR', context = {}, cause) {
+        super(message, code, ErrorSeverity.MEDIUM, ErrorCategory.NETWORK, context, cause, true);
+    }
+    getUserMessage() {
+        return 'Network connection error. Please check your connection and try again.';
+    }
+}
+/**
+ * Authentication error
+ */
+export class AuthenticationError extends BaseError {
+    constructor(message, code = 'AUTHENTICATION_ERROR', context = {}, cause) {
+        super(message, code, ErrorSeverity.HIGH, ErrorCategory.AUTHENTICATION, context, cause, false);
+    }
+    getUserMessage() {
+        return 'Authentication failed. Please check your credentials.';
+    }
+}
+/**
+ * Authorization error
+ */
+export class AuthorizationError extends BaseError {
+    constructor(message, code = 'AUTHORIZATION_ERROR', context = {}, cause) {
+        super(message, code, ErrorSeverity.HIGH, ErrorCategory.AUTHORIZATION, context, cause, false);
+    }
+    getUserMessage() {
+        return 'Access denied. You do not have permission to perform this action.';
+    }
+}
+/**
+ * Tool execution error
+ */
+export class ToolExecutionError extends BaseError {
+    constructor(message, toolName, code = 'TOOL_EXECUTION_ERROR', context = {}, cause) {
+        super(message, code, ErrorSeverity.MEDIUM, ErrorCategory.BUSINESS, { ...context, toolName }, cause, true);
+    }
+    getUserMessage() {
+        return `Tool execution failed: ${this.message}`;
+    }
+}
+/**
+ * Default error handling strategy
+ */
+export class DefaultErrorHandlingStrategy {
+    canHandle(error) {
+        return true; // Default strategy handles all errors
+    }
+    async handle(error, context = { timestamp: Date.now() }) {
+        // If already a standardized error, return directly
+        if (error instanceof BaseError) {
+            return error;
+        }
+        // Handle known error types
+        if (error instanceof ValidationError) {
+            return new BusinessError(error.message, 'VALIDATION_ERROR', context, error);
+        }
+        if (error instanceof ApiError) {
+            return new SystemError(error.message, 'API_ERROR', context, error);
+        }
+        // Handle unknown errors
+        return new SystemError(error.message || 'An unknown error occurred', 'UNKNOWN_ERROR', context, error);
+    }
+}
+/**
+ * Network error handling strategy
+ */
+export class NetworkErrorHandlingStrategy {
+    canHandle(error) {
+        return error.message.includes('network') ||
+            error.message.includes('timeout') ||
+            error.message.includes('connection') ||
+            error.name === 'NetworkError';
+    }
+    async handle(error, context = { timestamp: Date.now() }) {
+        return new NetworkError(error.message, 'NETWORK_CONNECTION_ERROR', context, error);
+    }
+}
+/**
+ * Retry recovery strategy
+ */
+export class RetryRecoveryStrategy {
+    maxRetries;
+    retryDelay;
+    constructor(maxRetries = 3, retryDelay = 1000) {
+        this.maxRetries = maxRetries;
+        this.retryDelay = retryDelay;
+    }
+    canRecover(error) {
+        return error.recoverable &&
+            (error.category === ErrorCategory.NETWORK ||
+                error.category === ErrorCategory.API);
+    }
+    async recover(error) {
+        console.info(`Attempting recovery for error: ${error.code}`, {
+            maxRetries: this.maxRetries,
+            retryDelay: this.retryDelay
+        });
+        // Implement specific retry logic here
+        // For example, re-execute the failed operation
+        await new Promise(resolve => setTimeout(resolve, this.retryDelay));
+        return { recovered: true, strategy: 'retry' };
+    }
+}
+/**
+ * Unified error handler
+ */
+export class ErrorHandler {
+    strategies = [];
+    recoveryStrategies = [];
+    constructor() {
+        // Register default strategy
+        this.addStrategy(new NetworkErrorHandlingStrategy());
+        this.addStrategy(new DefaultErrorHandlingStrategy()); // Default strategy goes last
+        // Register recovery strategies
+        this.addRecoveryStrategy(new RetryRecoveryStrategy());
+    }
+    /**
+     * Add error handling strategy
+     * @param strategy Error handling strategy
+     */
+    addStrategy(strategy) {
+        this.strategies.push(strategy);
+    }
+    /**
+     * Add error recovery strategy
+     * @param strategy Error recovery strategy
+     */
+    addRecoveryStrategy(strategy) {
+        this.recoveryStrategies.push(strategy);
+    }
+    /**
+     * Handle error
+     * @param error Original error
+     * @param context Error context
+     * @returns Standardized error
+     */
+    async handleError(error, context) {
+        const errorContext = {
+            timestamp: Date.now(),
+            ...context
+        };
+        try {
+            // Find appropriate handling strategy
+            const strategy = this.strategies.find(s => s.canHandle(error));
+            if (!strategy) {
+                console.warn('No suitable error handling strategy found', { error: error.message });
+                return new SystemError('No error handler available', 'NO_HANDLER_ERROR', errorContext, error);
+            }
+            // Handle error
+            const standardError = await strategy.handle(error, errorContext);
+            // Log error
+            this.logError(standardError);
+            // Attempt recovery
+            await this.attemptRecovery(standardError);
+            return standardError;
+        }
+        catch (handlingError) {
+            console.error('Error occurred while handling error', {
+                originalError: error.message,
+                handlingError: handlingError instanceof Error ? handlingError.message : handlingError
+            });
+            return new SystemError('Error handling failed', 'ERROR_HANDLER_FAILURE', errorContext, error);
+        }
+    }
+    /**
+     * Attempt error recovery
+     * @param error Standardized error
+     */
+    async attemptRecovery(error) {
+        const recoveryStrategy = this.recoveryStrategies.find(s => s.canRecover(error));
+        if (recoveryStrategy) {
+            try {
+                await recoveryStrategy.recover(error);
+                console.info('Error recovery successful', { errorCode: error.code });
+            }
+            catch (recoveryError) {
+                console.warn('Error recovery failed', {
+                    errorCode: error.code,
+                    recoveryError: recoveryError instanceof Error ? recoveryError.message : recoveryError
+                });
+            }
+        }
+    }
+    /**
+     * Log error
+     * @param error Standardized error
+     */
+    logError(error) {
+        const logData = {
+            code: error.code,
+            message: error.message,
+            severity: error.severity,
+            category: error.category,
+            context: error.context,
+            recoverable: error.recoverable
+        };
+        switch (error.severity) {
+            case ErrorSeverity.CRITICAL:
+                console.error('Critical error occurred', logData);
+                break;
+            case ErrorSeverity.HIGH:
+                console.error('High severity error occurred', logData);
+                break;
+            case ErrorSeverity.MEDIUM:
+                console.warn('Medium severity error occurred', logData);
+                break;
+            case ErrorSeverity.LOW:
+                console.info('Low severity error occurred', logData);
+                break;
+            default:
+                console.warn('Unknown severity error occurred', logData);
+        }
+    }
+    /**
+     * Create error context
+     * @param options Context options
+     */
+    static createContext(options = {}) {
+        return {
+            timestamp: Date.now(),
+            ...options
+        };
+    }
+}
+/**
+ * Global error handler instance
+ */
+export const globalErrorHandler = new ErrorHandler();
+/**
+ * Convenience function: handle error
+ * @param error Error object
+ * @param context Error context
+ */
+export async function handleError(error, context) {
+    return globalErrorHandler.handleError(error, context);
+}
+/**
+ * Convenience function: create business error
+ * @param message Error message
+ * @param code Error code
+ * @param context Error context
+ */
+export function createBusinessError(message, code, context) {
+    return new BusinessError(message, code, context);
+}
+/**
+ * Convenience function: create system error
+ * @param message Error message
+ * @param code Error code
+ * @param context Error context
+ */
+export function createSystemError(message, code, context) {
+    return new SystemError(message, code, context);
+}
+/**
+ * Error handling decorator
+ * @param errorHandler Error handler (optional)
+ */
+export function HandleErrors(errorHandler) {
+    return function (target, propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        const handler = errorHandler || globalErrorHandler;
+        descriptor.value = async function (...args) {
+            try {
+                return await originalMethod.apply(this, args);
+            }
+            catch (error) {
+                const context = ErrorHandler.createContext({
+                    operation: `${target.constructor.name}.${propertyKey}`
+                });
+                const standardError = await handler.handleError(error, context);
+                throw standardError;
+            }
+        };
+        return descriptor;
+    };
+}

package/mcp-server/build/core/file-service.js

@@ -0,0 +1,126 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { FileNotFoundError, ValidationError } from '../types/index.js';
+/**
+ * File operations service
+ */
+export class FileService {
+    /**
+     * Check if a string is a URL
+     */
+    static isUrl(source) {
+        try {
+            const url = new URL(source);
+            return url.protocol === 'http:' || url.protocol === 'https:';
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Validate if image source exists and check size limit
+     * @param imageSource Path to image file or URL
+     * @param maxSizeMB Maximum file size in MB (default: 5MB)
+     */
+    static async validateImageSource(imageSource, maxSizeMB = 5) {
+        if (this.isUrl(imageSource)) {
+            return;
+        }
+        if (!fs.existsSync(imageSource)) {
+            throw new FileNotFoundError(`Image file not found: ${imageSource}`);
+        }
+        const stats = fs.statSync(imageSource);
+        const maxSizeBytes = maxSizeMB * 1024 * 1024;
+        if (stats.size > maxSizeBytes) {
+            throw new ValidationError(`Image file too large: ${(stats.size / (1024 * 1024)).toFixed(2)}MB. Maximum allowed: ${maxSizeMB}MB`);
+        }
+        const ext = path.extname(imageSource).toLowerCase();
+        const supportedExts = ['.jpg', '.jpeg', '.png'];
+        if (!supportedExts.includes(ext)) {
+            throw new ValidationError(`Unsupported image format: ${ext}. Supported formats: ${supportedExts.join(', ')}`);
+        }
+    }
+    /**
+     * Validate if video source exists and check size limit
+     * @param videoSource Path to video file or URL
+     * @param maxSizeMB Maximum file size in MB (default: 8MB)
+     */
+    static async validateVideoSource(videoSource, maxSizeMB = 8) {
+        if (this.isUrl(videoSource)) {
+            return;
+        }
+        if (!fs.existsSync(videoSource)) {
+            throw new FileNotFoundError(videoSource);
+        }
+        const stats = fs.statSync(videoSource);
+        const fileSizeMB = stats.size / (1024 * 1024);
+        if (fileSizeMB > maxSizeMB) {
+            throw new Error(`Video file size (${fileSizeMB.toFixed(2)}MB) exceeds maximum allowed size (${maxSizeMB}MB)`);
+        }
+    }
+    /**
+     * Encode image to base64 data URL (from file or URL)
+     * @param imageSource Path to image file or URL
+     * @returns Base64 encoded image data or URL
+     */
+    static async encodeImageToBase64(imageSource) {
+        if (this.isUrl(imageSource)) {
+            // For URLs, return the URL directly (no base64 encoding needed)
+            return imageSource;
+        }
+        // For local files, encode to base64
+        const imageBuffer = fs.readFileSync(imageSource);
+        const ext = path.extname(imageSource).toLowerCase().slice(1);
+        const mimeType = this.getMimeType(ext);
+        console.debug('Encoded image to base64', { imageSource, mimeType });
+        return `data:${mimeType};base64,${imageBuffer.toString('base64')}`;
+    }
+    /**
+     * Encode video to base64 data URL (from file or URL)
+     * @param videoSource Path to video file or URL
+     * @returns Base64 encoded video data URL
+     */
+    static async encodeVideoToBase64(videoSource) {
+        if (this.isUrl(videoSource)) {
+            // For URLs, return the URL directly (no base64 encoding needed)
+            return videoSource;
+        }
+        // For local files, encode to base64
+        const videoBuffer = fs.readFileSync(videoSource);
+        const ext = path.extname(videoSource).toLowerCase().slice(1);
+        const mimeType = this.getVideoMimeType(ext);
+        console.debug('Encoded video to base64', { videoSource, mimeType });
+        return `data:${mimeType};base64,${videoBuffer.toString('base64')}`;
+    }
+    /**
+     * Get MIME type for image file extension
+     */
+    static getMimeType(extension) {
+        const mimeTypes = {
+            png: 'image/png',
+            jpg: 'image/jpeg',
+            jpeg: 'image/jpeg'
+        };
+        return mimeTypes[extension] || 'image/png';
+    }
+    /**
+     * Get MIME type for video file extension
+     * @param extension File extension without dot
+     * @returns MIME type string
+     */
+    static getVideoMimeType(extension) {
+        const mimeTypes = {
+            mp4: 'video/mp4',
+            avi: 'video/x-msvideo',
+            mov: 'video/quicktime',
+            wmv: 'video/x-ms-wmv',
+            webm: 'video/webm',
+            m4v: 'video/x-m4v'
+        };
+        return mimeTypes[extension] || 'video/mp4';
+    }
+}
+/**
+ * File service for image operations
+ */
+export const fileService = FileService;

package/mcp-server/build/index.js

@@ -0,0 +1,160 @@
+#!/usr/bin/env node
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { configurationService } from './core/environment.js';
+import { handleError } from './core/error-handler.js';
+import { setupConsoleRedirection } from './utils/logger.js';
+// Setup console redirection BEFORE any other code to prevent stdout pollution
+setupConsoleRedirection();
+// Import tool registration functions
+import { registerImageAnalysisTool } from './tools/image-analysis.js';
+import { registerVideoAnalysisTool } from './tools/video-analysis.js';
+import { McpError } from "./types/index.js";
+/**
+ * MCP Server Application class
+ */
+class McpServerApplication {
+    server;
+    constructor() {
+        this.server = new McpServer({
+            name: configurationService.getServerConfig().name,
+            version: configurationService.getServerConfig().version
+        }, {
+            capabilities: {
+                tools: {}
+            }
+        });
+        this.setupErrorHandling();
+        console.info('MCP Server Application initialized');
+    }
+    /**
+     * Register all tools
+     */
+    async registerTools() {
+        try {
+            // Register tools directly with server
+            registerImageAnalysisTool(this.server);
+            registerVideoAnalysisTool(this.server);
+            console.info('Successfully registered all tools');
+        }
+        catch (error) {
+            const standardError = await handleError(error, {
+                operation: 'tool-registration',
+                metadata: { component: 'McpServerApplication' }
+            });
+            console.error('Failed to register tools', standardError);
+            throw standardError;
+        }
+    }
+    /**
+     * Setup error handling
+     */
+    setupErrorHandling() {
+        process.on('uncaughtException', (error) => {
+            console.error('Uncaught exception:', error);
+            this.gracefulShutdown(1);
+        });
+        process.on('unhandledRejection', (reason, promise) => {
+            console.error('Unhandled rejection at:', { promise, reason });
+            this.gracefulShutdown(1);
+        });
+        process.on('SIGINT', () => {
+            console.info('Received SIGINT, shutting down gracefully...');
+            this.gracefulShutdown(0);
+        });
+        process.on('SIGTERM', () => {
+            console.info('Received SIGTERM, shutting down gracefully...');
+            this.gracefulShutdown(0);
+        });
+    }
+    /**
+     * Graceful shutdown
+     */
+    gracefulShutdown(exitCode) {
+        try {
+            console.info('Performing graceful shutdown...');
+            // Cleanup logic can be added here
+            process.exit(exitCode);
+        }
+        catch (error) {
+            console.error('Error during graceful shutdown:', { error });
+            process.exit(1);
+        }
+    }
+    /**
+     * Start server
+     */
+    async start() {
+        try {
+            console.info('Starting MCP server...');
+            // Set up global error handling
+            process.on('uncaughtException', async (error) => {
+                const standardError = await handleError(error, {
+                    operation: 'uncaughtException',
+                    metadata: { source: 'process' }
+                });
+                console.error('Uncaught exception:', standardError);
+                process.exit(1);
+            });
+            process.on('unhandledRejection', async (reason) => {
+                const error = reason instanceof Error ? reason : new Error(String(reason));
+                const standardError = await handleError(error, {
+                    operation: 'unhandledRejection',
+                    metadata: { source: 'process' }
+                });
+                console.error('Unhandled Promise rejection:', standardError);
+                process.exit(1);
+            });
+            // Register tools
+            await this.registerTools();
+            // Create transport layer
+            const transport = new StdioServerTransport();
+            // Start server
+            await this.server.connect(transport);
+            console.info('MCP Server started successfully', {
+                mode: configurationService.getPlatformModel(),
+                name: configurationService.getServerConfig().name,
+                version: configurationService.getServerConfig().version
+            });
+        }
+        catch (error) {
+            const standardError = await handleError(error, {
+                operation: 'server-start',
+                metadata: { component: 'McpServerApplication' }
+            });
+            console.error('Server startup failed:', standardError);
+            throw standardError;
+        }
+    }
+    /**
+     * Gracefully shutdown server
+     */
+    async shutdown() {
+        try {
+            console.info('Shutting down MCP server...');
+            console.info('MCP server shutdown completed');
+        }
+        catch (error) {
+            console.error('Error during server shutdown', { error });
+            throw error;
+        }
+    }
+}
+// Start application
+async function main() {
+    try {
+        const app = new McpServerApplication();
+        await app.start();
+    }
+    catch (error) {
+        if (error instanceof McpError) {
+            console.error('Application startup failed:', { message: error.message });
+        }
+        else {
+            console.error('Application startup failed:', { error });
+        }
+        process.exit(1);
+    }
+}
+// Start main program
+main();