n8n-nodes-comfyui-all 2.2.9 → 2.2.11

package/dist/nodes/ComfyUiClient.js

@@ -7,12 +7,30 @@ exports.ComfyUIClient = void 0;
 const crypto_1 = require("crypto");
 const constants_1 = require("./constants");
 const form_data_1 = __importDefault(require("form-data"));
+const logger_1 = require("./logger");
+const utils_1 = require("./utils");
+const HttpClient_1 = require("./HttpClient");
+const N8nHelpersAdapter_1 = require("./N8nHelpersAdapter");
+/**
+ * Client state enumeration for state machine pattern
+ */
+var ClientState;
+(function (ClientState) {
+    ClientState["IDLE"] = "idle";
+    ClientState["REQUESTING"] = "requesting";
+    ClientState["DESTROYED"] = "destroyed";
+})(ClientState || (ClientState = {}));
 class ComfyUIClient {
     constructor(config) {
-        this.isDestroyed = false;
-        this.helpers = config.helpers;
+        this.state = ClientState.IDLE;
+        this.currentAbortController = null;
+        this.httpClient = new HttpClient_1.HttpClient({
+            adapter: new N8nHelpersAdapter_1.N8nHelpersAdapter(config.helpers),
+            logger: config.logger || new logger_1.Logger(),
+            defaultTimeout: config.timeout || constants_1.VALIDATION.REQUEST_TIMEOUT_MS,
+        });
+        this.logger = config.logger || new logger_1.Logger();
         this.baseUrl = config.baseUrl;
-        this.timeout = config.timeout || constants_1.VALIDATION.REQUEST_TIMEOUT_MS;
         this.clientId = config.clientId || this.generateClientId();
         this.maxRetries = config.maxRetries ?? constants_1.VALIDATION.MAX_RETRIES;
     }
@@ -20,45 +38,100 @@ class ComfyUIClient {
      * Cancel any ongoing request and clean up resources
      */
     cancelRequest() {
-        this.isDestroyed = true;
+        if (this.currentAbortController) {
+            this.currentAbortController.abort();
+            this.currentAbortController = null;
+        }
     }
     /**
      * Clean up resources when the client is no longer needed
      */
     destroy() {
+        this.state = ClientState.DESTROYED;
         this.cancelRequest();
     }
     /**
      * Check if the client has been destroyed
      */
     isClientDestroyed() {
-        return this.isDestroyed;
+        return this.state === ClientState.DESTROYED;
     }
+    /**
+     * Generate a unique client ID
+     * @returns Unique client ID string
+     */
     generateClientId() {
         return `client_${(0, crypto_1.randomUUID)()}`;
     }
+    /**
+     * Delay execution for a specified time
+     * @param ms - Delay time in milliseconds
+     * @returns Promise that resolves after the delay
+     */
+    async delay(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    /**
+     * Retry a request with exponential backoff
+     * @param requestFn - Function that returns a Promise to retry
+     * @param retries - Maximum number of retry attempts
+     * @returns Promise that resolves when the request succeeds
+     * @throws Error if all retry attempts fail
+     */
     async retryRequest(requestFn, retries = this.maxRetries) {
+        // Check if client is destroyed before starting
+        if (this.state === ClientState.DESTROYED) {
+            throw new Error('Client has been destroyed');
+        }
         let lastError;
-        for (let attempt = 0; attempt <= retries; attempt++) {
-            try {
-                if (this.isDestroyed) {
-                    throw new Error('Client has been destroyed');
+        const baseDelay = constants_1.VALIDATION.RETRY_DELAY_MS;
+        const maxBackoffDelay = constants_1.VALIDATION.MAX_BACKOFF_DELAY_RETRY;
+        let backoffDelay = baseDelay;
+        // Set state to REQUESTING and create AbortController
+        this.state = ClientState.REQUESTING;
+        this.currentAbortController = new AbortController();
+        try {
+            for (let attempt = 0; attempt <= retries; attempt++) {
+                try {
+                    // Check if request was aborted
+                    if (this.currentAbortController.signal.aborted) {
+                        throw new Error('Request aborted');
+                    }
+                    return await requestFn();
                 }
-                return await requestFn();
-            }
-            catch (error) {
-                lastError = error;
-                if (attempt < retries) {
-                    // Use a microtask to yield control between retries
-                    await Promise.resolve();
+                catch (error) {
+                    lastError = error;
+                    // If aborted, don't retry
+                    if (error instanceof Error && (error.name === 'AbortError' || error.message === 'Request aborted')) {
+                        throw new Error('Request was cancelled');
+                    }
+                    if (attempt < retries) {
+                        // Exponential backoff: double the delay with each error, capped at maxBackoffDelay
+                        backoffDelay = Math.min(backoffDelay * 2, maxBackoffDelay);
+                        if (attempt > 0) {
+                            const errorMsg = error instanceof Error ? error.message : String(error);
+                            this.logger.warn(`Request attempt ${attempt + 1}/${retries + 1} failed, retrying in ${backoffDelay}ms: ${errorMsg}`);
+                        }
+                        // Wait before retrying with exponential backoff
+                        await this.delay(backoffDelay);
+                    }
                 }
             }
+            throw lastError;
+        }
+        finally {
+            // Reset state to IDLE after request completes
+            this.state = ClientState.IDLE;
         }
-        throw lastError;
     }
+    /**
+     * Execute a ComfyUI workflow
+     * @param workflow - Workflow object containing nodes and their configurations
+     * @returns Promise containing workflow execution result
+     */
     async executeWorkflow(workflow) {
         try {
-            if (this.isDestroyed) {
+            if (this.isClientDestroyed()) {
                 return {
                     success: false,
                     error: 'Client has been destroyed',
@@ -69,16 +142,12 @@ class ComfyUIClient {
                 prompt,
                 client_id: this.clientId,
             };
-            // Debug: Log the request body
-            console.log('[ComfyUI] Sending workflow to ComfyUI:', JSON.stringify(requestBody, null, 2));
-            const response = await this.retryRequest(() => this.helpers.httpRequest({
-                method: 'POST',
-                url: `${this.baseUrl}/prompt`,
+            this.logger.debug('Sending workflow to ComfyUI:', JSON.stringify(requestBody, null, 2));
+            const response = await this.retryRequest(() => this.httpClient.post(`${this.baseUrl}/prompt`, requestBody, {
                 json: true,
-                body: requestBody,
-                timeout: this.timeout,
+                abortSignal: this.currentAbortController?.signal,
             }));
-            console.log('[ComfyUI] Response from ComfyUI:', JSON.stringify(response, null, 2));
+            this.logger.debug('Response from ComfyUI:', JSON.stringify(response, null, 2));
             if (response.prompt_id) {
                 return await this.waitForExecution(response.prompt_id);
             }
@@ -88,12 +157,14 @@ class ComfyUIClient {
             };
         }
         catch (error) {
-            console.error('[ComfyUI] Workflow execution error:', error);
-            console.error('[ComfyUI] Error details:', {
-                message: error.message,
-                statusCode: error.response?.statusCode || error.statusCode,
-                statusMessage: error.response?.statusMessage || error.statusMessage,
-                responseBody: error.response?.body || error.response?.data,
+            this.logger.error('Workflow execution error:', error);
+            const err = error instanceof Error ? error : new Error(String(error));
+            const httpError = err;
+            this.logger.error('Error details:', {
+                message: err.message,
+                statusCode: httpError.response?.statusCode || httpError.statusCode,
+                statusMessage: httpError.response?.statusMessage || httpError.statusMessage,
+                responseBody: httpError.response?.body || httpError.response?.data,
             });
             return {
                 success: false,
@@ -101,6 +172,11 @@ class ComfyUIClient {
             };
         }
     }
+    /**
+     * Prepare workflow prompt for ComfyUI API
+     * @param workflow - Workflow object containing nodes
+     * @returns Formatted prompt object
+     */
     preparePrompt(workflow) {
         const prompt = {};
         for (const nodeId in workflow) {
@@ -112,29 +188,39 @@ class ComfyUIClient {
         }
         return prompt;
     }
+    /**
+     * Wait for workflow execution to complete
+     * @param promptId - Prompt ID from ComfyUI
+     * @param maxWaitTime - Maximum time to wait in milliseconds
+     * @returns Promise containing workflow execution result
+     */
     async waitForExecution(promptId, maxWaitTime = constants_1.VALIDATION.MAX_WAIT_TIME_MS) {
         const startTime = Date.now();
         let lastStatus = 'pending';
         let consecutiveErrors = 0;
-        const maxConsecutiveErrors = 5;
+        const maxConsecutiveErrors = constants_1.VALIDATION.MAX_CONSECUTIVE_ERRORS;
+        let totalErrors = 0;
+        const maxTotalErrors = constants_1.VALIDATION.MAX_TOTAL_ERRORS;
+        let backoffDelay = constants_1.VALIDATION.POLL_INTERVAL_MS;
+        const maxBackoffDelay = constants_1.VALIDATION.MAX_BACKOFF_DELAY_POLLING;
+        const baseDelay = constants_1.VALIDATION.POLL_INTERVAL_MS;
         while (Date.now() - startTime < maxWaitTime) {
             try {
-                if (this.isDestroyed) {
+                if (this.isClientDestroyed()) {
                     return {
                         success: false,
                         error: 'Client has been destroyed',
                     };
                 }
-                const response = await this.helpers.httpRequest({
-                    method: 'GET',
-                    url: `${this.baseUrl}/history/${promptId}`,
+                const response = await this.httpClient.get(`${this.baseUrl}/history/${promptId}`, {
                     json: true,
-                    timeout: this.timeout,
+                    abortSignal: this.currentAbortController?.signal,
                 });
                 if (response[promptId]) {
-                    const status = response[promptId].status;
+                    const promptData = response[promptId];
+                    const status = promptData.status;
                     if (status.completed) {
-                        return this.extractResults(response[promptId].outputs);
+                        return this.extractResults(promptData.outputs);
                     }
                     if (lastStatus !== status.status_str) {
                         lastStatus = status.status_str;
@@ -142,19 +228,33 @@ class ComfyUIClient {
                 }
                 // Reset error counter on successful request
                 consecutiveErrors = 0;
-                // Yield control between polls
-                await Promise.resolve();
+                backoffDelay = baseDelay; // Reset backoff delay
+                // Wait before next poll
+                await this.delay(baseDelay);
             }
             catch (error) {
                 consecutiveErrors++;
+                totalErrors++;
+                const errorMsg = error instanceof Error ? error.message : String(error);
+                // Check consecutive errors limit
                 if (consecutiveErrors >= maxConsecutiveErrors) {
                     return {
                         success: false,
-                        error: `Workflow execution failed after ${maxConsecutiveErrors} consecutive errors: ${error.message}`,
+                        error: `Workflow execution failed after ${maxConsecutiveErrors} consecutive errors: ${errorMsg}`,
+                    };
+                }
+                // Check total errors limit to prevent resource exhaustion
+                if (totalErrors >= maxTotalErrors) {
+                    return {
+                        success: false,
+                        error: `Workflow execution failed after ${maxTotalErrors} total errors (last: ${errorMsg})`,
                     };
                 }
-                // Yield control between retries
-                await Promise.resolve();
+                // Exponential backoff: double the delay with each error, capped at maxBackoffDelay
+                backoffDelay = Math.min(backoffDelay * 2, maxBackoffDelay);
+                this.logger.warn(`Polling error ${consecutiveErrors}/${maxConsecutiveErrors} (total: ${totalErrors}/${maxTotalErrors}), retrying in ${backoffDelay}ms: ${errorMsg}`);
+                // Wait with exponential backoff
+                await this.delay(backoffDelay);
             }
         }
         return {
@@ -162,6 +262,16 @@ class ComfyUIClient {
             error: 'Workflow execution timeout',
         };
     }
+    /**
+     * Extract image and video results from workflow outputs
+     *
+     * Note: The `outputs` parameter uses `WorkflowOutputs` type because ComfyUI API responses
+     * have a dynamic structure that is not guaranteed. Different ComfyUI nodes
+     * may return different output formats, and we need to handle this flexibility.
+     *
+     * @param outputs - Raw output data from ComfyUI (format is not guaranteed, using WorkflowOutputs for flexibility)
+     * @returns WorkflowResult with extracted images and videos
+     */
     extractResults(outputs) {
         const result = {
             success: true,
@@ -169,122 +279,288 @@ class ComfyUIClient {
             videos: [],
             output: outputs,
         };
-        for (const nodeId in outputs) {
-            const nodeOutput = outputs[nodeId];
+        const outputsRecord = outputs;
+        for (const nodeId in outputsRecord) {
+            const nodeOutput = outputsRecord[nodeId];
+            if (!nodeOutput || typeof nodeOutput !== 'object') {
+                continue;
+            }
+            const nodeOutputObj = nodeOutput;
             // Process images
-            if (nodeOutput.images && Array.isArray(nodeOutput.images)) {
-                for (const image of nodeOutput.images) {
-                    const imageUrl = `/view?filename=${image.filename}&subfolder=${image.subfolder || ''}&type=${image.type}`;
-                    result.images.push(imageUrl);
+            if (nodeOutputObj.images && Array.isArray(nodeOutputObj.images)) {
+                for (const image of nodeOutputObj.images) {
+                    const imageObj = image;
+                    const imageUrl = `/view?filename=${imageObj.filename}&subfolder=${imageObj.subfolder || ''}&type=${imageObj.type}`;
+                    result.images?.push(imageUrl);
                 }
             }
             // Process videos (videos array)
-            if (nodeOutput.videos && Array.isArray(nodeOutput.videos)) {
-                for (const video of nodeOutput.videos) {
-                    const videoUrl = `/view?filename=${video.filename}&subfolder=${video.subfolder || ''}&type=${video.type}`;
-                    result.videos.push(videoUrl);
+            if (nodeOutputObj.videos && Array.isArray(nodeOutputObj.videos)) {
+                for (const video of nodeOutputObj.videos) {
+                    const videoObj = video;
+                    const videoUrl = `/view?filename=${videoObj.filename}&subfolder=${videoObj.subfolder || ''}&type=${videoObj.type}`;
+                    result.videos?.push(videoUrl);
                 }
             }
             // Process videos (gifs array) - some nodes use this name
-            if (nodeOutput.gifs && Array.isArray(nodeOutput.gifs)) {
-                for (const video of nodeOutput.gifs) {
-                    const videoUrl = `/view?filename=${video.filename}&subfolder=${video.subfolder || ''}&type=${video.type}`;
-                    result.videos.push(videoUrl);
+            if (nodeOutputObj.gifs && Array.isArray(nodeOutputObj.gifs)) {
+                for (const video of nodeOutputObj.gifs) {
+                    const videoObj = video;
+                    const videoUrl = `/view?filename=${videoObj.filename}&subfolder=${videoObj.subfolder || ''}&type=${videoObj.type}`;
+                    result.videos?.push(videoUrl);
                 }
             }
         }
         return result;
     }
+    /**
+     * Get execution history from ComfyUI
+     * @param limit - Maximum number of history entries to retrieve
+     * @returns Promise containing history data
+     */
     async getHistory(limit = 100) {
-        if (this.isDestroyed) {
+        if (this.isClientDestroyed()) {
             throw new Error('Client has been destroyed');
         }
-        const response = await this.retryRequest(() => this.helpers.httpRequest({
-            method: 'GET',
-            url: `${this.baseUrl}/history`,
+        const response = await this.retryRequest(() => this.httpClient.get(`${this.baseUrl}/history`, {
             qs: { limit },
             json: true,
-            timeout: this.timeout,
+            abortSignal: this.currentAbortController?.signal,
         }));
         return response;
     }
+    /**
+     * Upload an image to ComfyUI server
+     * @param imageData - Image data as Buffer
+     * @param filename - Name of the file to upload
+     * @param overwrite - Whether to overwrite existing file
+     * @returns Promise containing the uploaded filename
+     * @throws Error if image data is invalid or upload fails
+     */
     async uploadImage(imageData, filename, overwrite = false) {
-        if (this.isDestroyed) {
+        if (this.isClientDestroyed()) {
             throw new Error('Client has been destroyed');
         }
-        console.log('[ComfyUI] Uploading image:', { filename, size: imageData.length });
+        // Validate image data
+        if (!Buffer.isBuffer(imageData)) {
+            throw new Error('Invalid image data: expected Buffer');
+        }
+        if (imageData.length === 0) {
+            throw new Error('Invalid image data: buffer is empty');
+        }
+        // Validate image size (maximum 50MB as defined in VALIDATION.MAX_IMAGE_SIZE_MB)
+        const maxSize = (0, utils_1.getMaxImageSizeBytes)();
+        if (imageData.length > maxSize) {
+            throw new Error(`Image size (${(0, utils_1.formatBytes)(imageData.length)}) exceeds maximum allowed size of ${(0, utils_1.formatBytes)(maxSize)}`);
+        }
+        this.logger.debug('Uploading image:', { filename, size: imageData.length });
         const form = new form_data_1.default();
         form.append('image', imageData, { filename: filename });
         form.append('overwrite', overwrite.toString());
-        const response = await this.retryRequest(() => this.helpers.httpRequest({
+        const response = await this.retryRequest(() => this.httpClient.request({
             method: 'POST',
             url: `${this.baseUrl}/upload/image`,
             body: form,
             headers: {
                 ...form.getHeaders(),
             },
-            timeout: this.timeout,
+            abortSignal: this.currentAbortController?.signal,
         }));
-        console.log('[ComfyUI] Upload response:', response);
+        this.logger.debug('Upload response:', response);
         return response.name;
     }
+    /**
+     * Get system information from ComfyUI server
+     * @returns Promise containing system stats
+     */
     async getSystemInfo() {
-        if (this.isDestroyed) {
+        if (this.isClientDestroyed()) {
             throw new Error('Client has been destroyed');
         }
-        const response = await this.retryRequest(() => this.helpers.httpRequest({
-            method: 'GET',
-            url: `${this.baseUrl}/system_stats`,
+        const response = await this.retryRequest(() => this.httpClient.get(`${this.baseUrl}/system_stats`, {
             json: true,
-            timeout: this.timeout,
+            abortSignal: this.currentAbortController?.signal,
         }));
         return response;
     }
-    async getImageBuffer(imagePath) {
+    /**
+     * Check if ComfyUI server is accessible
+     * @returns Promise containing health status
+     */
+    async healthCheck() {
         try {
-            if (this.isDestroyed) {
-                throw new Error('Client has been destroyed');
-            }
-            const response = await this.helpers.httpRequest({
-                method: 'GET',
-                url: `${this.baseUrl}${imagePath}`,
-                encoding: 'arraybuffer',
-                timeout: this.timeout,
+            await this.httpClient.get(`${this.baseUrl}/system_stats`, {
+                json: true,
+                timeout: 5000,
             });
-            return Buffer.from(response);
+            return {
+                healthy: true,
+                message: 'ComfyUI server is accessible',
+            };
         }
         catch (error) {
-            throw new Error(`Failed to get image buffer: ${this.formatErrorMessage(error)}`);
+            return {
+                healthy: false,
+                message: `ComfyUI server is not accessible: ${error instanceof Error ? error.message : String(error)}`,
+            };
         }
     }
-    async getVideoBuffer(videoPath) {
+    /**
+     * Get buffer from ComfyUI server (internal method)
+     * @param path - Path to the resource on ComfyUI server
+     * @param resourceType - Type of resource ('image' or 'video')
+     * @returns Promise containing resource data as Buffer
+     * @throws Error if resource retrieval fails
+     */
+    async getBuffer(path, resourceType) {
         try {
-            if (this.isDestroyed) {
+            if (this.isClientDestroyed()) {
                 throw new Error('Client has been destroyed');
             }
-            const response = await this.helpers.httpRequest({
-                method: 'GET',
-                url: `${this.baseUrl}${videoPath}`,
+            const response = await this.httpClient.get(`${this.baseUrl}${path}`, {
                 encoding: 'arraybuffer',
-                timeout: this.timeout,
+                abortSignal: this.currentAbortController?.signal,
             });
-            return Buffer.from(response);
+            const buffer = Buffer.from(response);
+            // Validate buffer size (maximum 50MB as defined in VALIDATION.MAX_IMAGE_SIZE_MB)
+            const maxSize = (0, utils_1.getMaxImageSizeBytes)();
+            if (buffer.length > maxSize) {
+                const resourceTypeLabel = resourceType.charAt(0).toUpperCase() + resourceType.slice(1);
+                throw new Error(`${resourceTypeLabel} size (${(0, utils_1.formatBytes)(buffer.length)}) exceeds maximum allowed size of ${(0, utils_1.formatBytes)(maxSize)}`);
+            }
+            return buffer;
         }
         catch (error) {
-            throw new Error(`Failed to get video buffer: ${this.formatErrorMessage(error)}`);
+            throw new Error(`Failed to get ${resourceType} buffer: ${this.formatErrorMessage(error)}`);
         }
     }
+    /**
+     * Get image buffer from ComfyUI server
+     * @param imagePath - Path to the image on ComfyUI server
+     * @returns Promise containing image data as Buffer
+     * @throws Error if image retrieval fails
+     */
+    async getImageBuffer(imagePath) {
+        return this.getBuffer(imagePath, 'image');
+    }
+    /**
+     * Get video buffer from ComfyUI server
+     * @param videoPath - Path to the video on ComfyUI server
+     * @returns Promise containing video data as Buffer
+     * @throws Error if video retrieval fails
+     */
+    async getVideoBuffer(videoPath) {
+        return this.getBuffer(videoPath, 'video');
+    }
+    /**
+     * Get multiple image buffers concurrently from ComfyUI server
+     * @param imagePaths - Array of paths to the images on ComfyUI server
+     * @returns Promise containing array of image data as Buffers
+     * @throws Error if any image retrieval fails
+     */
+    async getImageBuffers(imagePaths) {
+        return Promise.all(imagePaths.map(path => this.getImageBuffer(path)));
+    }
+    /**
+     * Get multiple video buffers concurrently from ComfyUI server
+     * @param videoPaths - Array of paths to the videos on ComfyUI server
+     * @returns Promise containing array of video data as Buffers
+     * @throws Error if any video retrieval fails
+     */
+    async getVideoBuffers(videoPaths) {
+        return Promise.all(videoPaths.map(path => this.getVideoBuffer(path)));
+    }
     /**
      * Format error message with additional context
      */
     formatErrorMessage(error, context = '') {
-        if (error.response) {
-            return `${context}: ${error.response.statusCode} ${error.response.statusMessage}`;
+        if (error instanceof Error) {
+            const httpError = error;
+            if (httpError.response) {
+                return `${context}: ${httpError.response.statusCode} ${httpError.response.statusMessage}`;
+            }
+            else if (httpError.statusCode) {
+                return `${context}: ${httpError.statusCode} ${httpError.statusMessage || ''}`;
+            }
+            return context ? `${context}: ${error.message}` : error.message;
+        }
+        return context ? `${context}: ${String(error)}` : String(error);
+    }
+    /**
+     * Process workflow execution results and format them for n8n output
+     * @param result - Workflow execution result
+     * @param outputBinaryKey - Property name for the first output binary data
+     * @returns Processed result with json and binary data
+     */
+    async processResults(result, outputBinaryKey = 'data') {
+        const jsonData = {
+            success: true,
+        };
+        if (result.output) {
+            jsonData.data = result.output;
+        }
+        if (result.images && result.images.length > 0) {
+            jsonData.images = result.images;
+            jsonData.imageUrls = result.images.map(img => `${this.baseUrl}${img}`);
         }
-        else if (error.request) {
-            return `${context}: No response from server`;
+        if (result.videos && result.videos.length > 0) {
+            jsonData.videos = result.videos;
+            jsonData.videoUrls = result.videos.map(vid => `${this.baseUrl}${vid}`);
+        }
+        const binaryData = {};
+        const buffers = [];
+        try {
+            // Fetch and process images concurrently
+            if (result.images && result.images.length > 0) {
+                const imageBuffers = await this.getImageBuffers(result.images);
+                buffers.push(...imageBuffers);
+                for (let i = 0; i < result.images.length; i++) {
+                    const imagePath = result.images[i];
+                    const imageBuffer = imageBuffers[i];
+                    const fileInfo = (0, utils_1.extractFileInfo)(imagePath, 'png');
+                    const mimeType = (0, utils_1.validateMimeType)(fileInfo.mimeType, constants_1.IMAGE_MIME_TYPES);
+                    const binaryKey = i === 0 ? outputBinaryKey : `image_${i}`;
+                    binaryData[binaryKey] = {
+                        data: imageBuffer.toString('base64'),
+                        mimeType: mimeType,
+                        fileName: fileInfo.filename,
+                    };
+                }
+                jsonData.imageCount = result.images.length;
+            }
+            // Fetch and process videos concurrently
+            if (result.videos && result.videos.length > 0) {
+                const videoBuffers = await this.getVideoBuffers(result.videos);
+                buffers.push(...videoBuffers);
+                for (let i = 0; i < result.videos.length; i++) {
+                    const videoPath = result.videos[i];
+                    const videoBuffer = videoBuffers[i];
+                    const fileInfo = (0, utils_1.extractFileInfo)(videoPath, 'mp4');
+                    const mimeType = (0, utils_1.validateMimeType)(fileInfo.mimeType, constants_1.VIDEO_MIME_TYPES);
+                    const hasImages = result.images && result.images.length > 0;
+                    const binaryKey = (!hasImages && i === 0) ? outputBinaryKey : `video_${i}`;
+                    binaryData[binaryKey] = {
+                        data: videoBuffer.toString('base64'),
+                        mimeType: mimeType,
+                        fileName: fileInfo.filename,
+                    };
+                }
+                jsonData.videoCount = result.videos.length;
+            }
+            return {
+                json: jsonData,
+                binary: binaryData,
+            };
+        }
+        catch (error) {
+            // Clean up already fetched buffers to prevent memory leaks
+            buffers.forEach(buffer => {
+                if (buffer) {
+                    buffer.fill(0); // Zero out sensitive data
+                }
+            });
+            throw error;
         }
-        return context ? `${context}: ${error.message}` : error.message;
     }
 }
 exports.ComfyUIClient = ComfyUIClient;