luma-mcp 1.0.1 → 1.0.3

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

@@ -1,376 +0,0 @@
-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

@@ -1,126 +0,0 @@
-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

@@ -1,160 +0,0 @@
-#!/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();