n8n-nodes-github-copilot 3.2.4 → 3.2.6

package/dist/nodes/GitHubCopilotChatAPI/nodeProperties.js

@@ -82,7 +82,7 @@ exports.nodeProperties = [
         name: 'includeMedia',
         type: 'boolean',
         default: false,
-        description: 'Whether to include a media file (image or audio) in the message. Type is auto-detected.',
+        description: 'Whether to include a media file in the message. Supported: Images (PNG, JPEG, GIF, WebP) and Audio files. Type is auto-detected.',
     },
     {
         displayName: 'Media Source',
@@ -125,7 +125,7 @@ exports.nodeProperties = [
         },
         default: '',
         placeholder: 'Paste base64 string or file path',
-        description: 'Media file as base64 string or file path (auto-detects image/audio)',
+        description: 'Media file as base64 string or file path (Images: PNG/JPEG/GIF/WebP, Audio: MP3/WAV/M4A)',
     },
     {
         displayName: 'Media URL',
@@ -139,7 +139,7 @@ exports.nodeProperties = [
         },
         default: '',
         placeholder: 'https://example.com/file.jpg',
-        description: 'URL of the media file to download and include',
+        description: 'URL of the media file to download and include (Images: PNG/JPEG/GIF/WebP, Audio: MP3/WAV/M4A)',
     },
     {
         displayName: 'Media Binary Property',

package/dist/nodes/GitHubCopilotChatAPI/utils/mediaDetection.d.ts

@@ -7,3 +7,9 @@ export declare function processMediaFile(context: IExecuteFunctions, itemIndex:
 }>;
 export declare function isImageMimeType(mimeType: string): boolean;
 export declare function isAudioMimeType(mimeType: string): boolean;
+export declare function validateImageFormat(mimeType: string): {
+    isValid: boolean;
+    error?: string;
+};
+export declare function getFileExtensionFromMimeType(mimeType: string): string;
+export declare function suggestImageConversion(mimeType: string): string;

package/dist/nodes/GitHubCopilotChatAPI/utils/mediaDetection.js

@@ -1,30 +1,144 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isAudioMimeType = exports.isImageMimeType = exports.processMediaFile = void 0;
+exports.suggestImageConversion = exports.getFileExtensionFromMimeType = exports.validateImageFormat = exports.isAudioMimeType = exports.isImageMimeType = exports.processMediaFile = void 0;
 const index_1 = require("./index");
-async function processMediaFile(context, itemIndex, source, mediaFile, mediaUrl, binaryProperty) {
+async function detectMimeType(context, itemIndex, source, mediaFile, mediaUrl, binaryProperty) {
+    var _a, _b;
     try {
-        try {
-            const imageResult = await (0, index_1.processImageFile)(context, itemIndex, source, mediaFile, mediaUrl, binaryProperty);
-            return {
-                type: 'image',
-                dataUrl: `data:${imageResult.mimeType};base64,${imageResult.data}`,
-                description: `Image file: ${imageResult.filename} (${Math.round(imageResult.size / 1024)}KB)`,
-                mimeType: imageResult.mimeType,
+        if (source === 'binary') {
+            const binaryData = context.getInputData()[itemIndex].binary;
+            if (binaryData && binaryProperty && binaryData[binaryProperty]) {
+                return binaryData[binaryProperty].mimeType || 'application/octet-stream';
+            }
+        }
+        else if (source === 'url' && mediaUrl) {
+            const extension = (_a = mediaUrl.split('.').pop()) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+            const extToMime = {
+                'png': 'image/png',
+                'jpg': 'image/jpeg',
+                'jpeg': 'image/jpeg',
+                'gif': 'image/gif',
+                'webp': 'image/webp',
+                'mp3': 'audio/mpeg',
+                'wav': 'audio/wav',
+                'm4a': 'audio/mp4',
+                'ogg': 'audio/ogg',
+                'mp4': 'video/mp4'
             };
+            return extToMime[extension || ''] || 'application/octet-stream';
         }
-        catch (imageError) {
+        else if (source === 'manual' && mediaFile) {
+            if (mediaFile.startsWith('data:')) {
+                const mimeMatch = mediaFile.match(/data:([^;]+)/);
+                if (mimeMatch)
+                    return mimeMatch[1];
+            }
+            const extension = (_b = mediaFile.split('.').pop()) === null || _b === void 0 ? void 0 : _b.toLowerCase();
+            const extToMime = {
+                'png': 'image/png',
+                'jpg': 'image/jpeg',
+                'jpeg': 'image/jpeg',
+                'gif': 'image/gif',
+                'webp': 'image/webp',
+                'mp3': 'audio/mpeg',
+                'wav': 'audio/wav',
+                'm4a': 'audio/mp4',
+                'ogg': 'audio/ogg',
+                'mp4': 'video/mp4'
+            };
+            return extToMime[extension || ''] || 'application/octet-stream';
+        }
+    }
+    catch (error) {
+    }
+    return 'application/octet-stream';
+}
+async function processMediaFile(context, itemIndex, source, mediaFile, mediaUrl, binaryProperty) {
+    try {
+        const detectedMimeType = await detectMimeType(context, itemIndex, source, mediaFile, mediaUrl, binaryProperty);
+        const isLikelyImage = isImageMimeType(detectedMimeType);
+        const isLikelyAudio = isAudioMimeType(detectedMimeType);
+        if (isLikelyAudio && !isLikelyImage) {
             try {
                 const audioResult = await (0, index_1.processAudioFile)(context, itemIndex, source, mediaFile, mediaUrl, binaryProperty);
                 return {
                     type: 'audio',
                     dataUrl: `data:${audioResult.mimeType};base64,${audioResult.data}`,
-                    description: `Audio file: ${audioResult.filename} (${Math.round(audioResult.size / 1024)}KB)`,
+                    description: `Audio file: ${audioResult.filename} (${Math.round(audioResult.size / 1024)}KB, ${audioResult.mimeType})`,
                     mimeType: audioResult.mimeType,
                 };
             }
             catch (audioError) {
-                throw new Error(`File is neither a valid image nor audio file. Image error: ${imageError instanceof Error ? imageError.message : 'Unknown'}. Audio error: ${audioError instanceof Error ? audioError.message : 'Unknown'}`);
+                throw new Error(`Audio processing failed: ${audioError instanceof Error ? audioError.message : 'Unknown error'}`);
+            }
+        }
+        else if (isLikelyImage && !isLikelyAudio) {
+            try {
+                const imageResult = await (0, index_1.processImageFile)(context, itemIndex, source, mediaFile, mediaUrl, binaryProperty);
+                const formatValidation = validateImageFormat(imageResult.mimeType);
+                if (!formatValidation.isValid) {
+                    throw new Error(suggestImageConversion(imageResult.mimeType));
+                }
+                return {
+                    type: 'image',
+                    dataUrl: `data:${imageResult.mimeType};base64,${imageResult.data}`,
+                    description: `Image file: ${imageResult.filename} (${Math.round(imageResult.size / 1024)}KB, ${imageResult.mimeType})`,
+                    mimeType: imageResult.mimeType,
+                };
+            }
+            catch (imageError) {
+                throw new Error(`Image processing failed: ${imageError instanceof Error ? imageError.message : 'Unknown error'}`);
+            }
+        }
+        else {
+            if (detectedMimeType.includes('mpeg') || detectedMimeType.includes('mp3')) {
+                try {
+                    const audioResult = await (0, index_1.processAudioFile)(context, itemIndex, source, mediaFile, mediaUrl, binaryProperty);
+                    return {
+                        type: 'audio',
+                        dataUrl: `data:${audioResult.mimeType};base64,${audioResult.data}`,
+                        description: `Audio file: ${audioResult.filename} (${Math.round(audioResult.size / 1024)}KB, ${audioResult.mimeType})`,
+                        mimeType: audioResult.mimeType,
+                    };
+                }
+                catch (audioError) {
+                    throw new Error(`MPEG audio processing failed: ${audioError instanceof Error ? audioError.message : 'Unknown error'}`);
+                }
+            }
+            else {
+                try {
+                    const imageResult = await (0, index_1.processImageFile)(context, itemIndex, source, mediaFile, mediaUrl, binaryProperty);
+                    const formatValidation = validateImageFormat(imageResult.mimeType);
+                    if (!formatValidation.isValid) {
+                        throw new Error(suggestImageConversion(imageResult.mimeType));
+                    }
+                    return {
+                        type: 'image',
+                        dataUrl: `data:${imageResult.mimeType};base64,${imageResult.data}`,
+                        description: `Image file: ${imageResult.filename} (${Math.round(imageResult.size / 1024)}KB, ${imageResult.mimeType})`,
+                        mimeType: imageResult.mimeType,
+                    };
+                }
+                catch (imageError) {
+                    try {
+                        const audioResult = await (0, index_1.processAudioFile)(context, itemIndex, source, mediaFile, mediaUrl, binaryProperty);
+                        return {
+                            type: 'audio',
+                            dataUrl: `data:${audioResult.mimeType};base64,${audioResult.data}`,
+                            description: `Audio file: ${audioResult.filename} (${Math.round(audioResult.size / 1024)}KB, ${audioResult.mimeType})`,
+                            mimeType: audioResult.mimeType,
+                        };
+                    }
+                    catch (audioError) {
+                        const supportedImageFormats = ['PNG', 'JPEG', 'GIF', 'WebP'];
+                        const supportedAudioFormats = ['MP3', 'WAV', 'M4A', 'OGG'];
+                        throw new Error(`File is neither a valid image nor audio file (detected MIME: ${detectedMimeType}).\n` +
+                            `Supported image formats: ${supportedImageFormats.join(', ')}\n` +
+                            `Supported audio formats: ${supportedAudioFormats.join(', ')}\n` +
+                            `Image error: ${imageError instanceof Error ? imageError.message : 'Unknown'}\n` +
+                            `Audio error: ${audioError instanceof Error ? audioError.message : 'Unknown'}`);
+                    }
+                }
             }
         }
     }
@@ -38,7 +152,14 @@ async function processMediaFile(context, itemIndex, source, mediaFile, mediaUrl,
 }
 exports.processMediaFile = processMediaFile;
 function isImageMimeType(mimeType) {
-    return mimeType.startsWith('image/') && !mimeType.includes('svg');
+    const supportedFormats = [
+        'image/png',
+        'image/jpeg',
+        'image/jpg',
+        'image/gif',
+        'image/webp'
+    ];
+    return supportedFormats.includes(mimeType.toLowerCase());
 }
 exports.isImageMimeType = isImageMimeType;
 function isAudioMimeType(mimeType) {
@@ -47,3 +168,36 @@ function isAudioMimeType(mimeType) {
         mimeType === 'video/mp4';
 }
 exports.isAudioMimeType = isAudioMimeType;
+function validateImageFormat(mimeType) {
+    if (!isImageMimeType(mimeType)) {
+        const supportedFormats = ['PNG', 'JPEG', 'GIF', 'WebP'];
+        return {
+            isValid: false,
+            error: `Unsupported image format: ${mimeType}. GitHub Copilot API only supports: ${supportedFormats.join(', ')}`
+        };
+    }
+    return { isValid: true };
+}
+exports.validateImageFormat = validateImageFormat;
+function getFileExtensionFromMimeType(mimeType) {
+    const mimeToExt = {
+        'image/png': 'png',
+        'image/jpeg': 'jpg',
+        'image/jpg': 'jpg',
+        'image/gif': 'gif',
+        'image/webp': 'webp',
+        'image/bmp': 'bmp',
+        'image/tiff': 'tiff',
+        'image/svg+xml': 'svg',
+    };
+    return mimeToExt[mimeType.toLowerCase()] || 'unknown';
+}
+exports.getFileExtensionFromMimeType = getFileExtensionFromMimeType;
+function suggestImageConversion(mimeType) {
+    const ext = getFileExtensionFromMimeType(mimeType);
+    const supportedFormats = ['PNG', 'JPEG', 'GIF', 'WebP'];
+    return `Image format ${ext.toUpperCase()} is not supported by GitHub Copilot API. ` +
+        `Please convert your image to one of these formats: ${supportedFormats.join(', ')}. ` +
+        `Recommended: Convert to PNG or WebP for best compatibility.`;
+}
+exports.suggestImageConversion = suggestImageConversion;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-github-copilot",
-  "version": "3.2.4",
+  "version": "3.2.6",
   "description": "n8n community node for GitHub Copilot with CLI integration and official Chat API access to GPT-5, Claude, Gemini and more using your existing Copilot credits",
   "license": "MIT",
   "homepage": "https://github.com/sufficit/n8n-nodes-github-copilot",