@gamastudio/sendwave-provider 0.0.7-dev → 0.0.7-dev1

package/build/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gamastudio/sendwave-provider",
-  "version": "0.0.7-dev",
+  "version": "0.0.7-dev1",
   "description": "Librería para interactuar con Sendwave usando configuración dinámica.",
   "main": "build/index.js",
   "types": "build/index.d.ts",

package/build/provider/provider.js

@@ -178,12 +178,6 @@ class SendWaveProvider extends bot_1.ProviderClass {
                 .then(() => {
                 this.beforeHttpServerInit();
                 this.start(methods, (routes) => {
-                    // Log the actual server binding info
-                    console.log(`🌐 Server binding: ${this.globalVendorArgs.host || 'localhost'}:${this.globalVendorArgs.port}`);
-                    if (this.globalVendorArgs.host === "0.0.0.0") {
-                        console.log(`🔗 External access: Server accessible from all network interfaces`);
-                        console.log(`📡 Webhook URL for external services: http://<your-ip>:${this.globalVendorArgs.port}/webhook`);
-                    }
                     this.emit("notice", {
                         title: "🛜  HTTP Server ON ",
                         instructions: routes,
@@ -363,11 +357,6 @@ class SendWaveProvider extends bot_1.ProviderClass {
                     detectorMedia_1.detectorMedia.updateLimits(this.globalVendorArgs.payloadLimits.media);
                 }
                 const { media, mediaType, fileName, size } = await detectorMedia_1.detectorMedia.processMedia(options.media);
-                // Log large media processing
-                if (size && size > 1024 * 1024) {
-                    const sizeMB = Math.round(size / 1024 / 1024 * 100) / 100;
-                    console.log(`[SendMessage] Processing ${mediaType} file: ${sizeMB}MB`);
-                }
                 switch (mediaType) {
                     case "image":
                         return await this.sender.sendImage({

package/build/provider/sender.d.ts

@@ -8,6 +8,7 @@ export declare class SenderMessage implements ProviderInterface {
     sendText(data: SendMessage): Promise<import("axios").AxiosResponse<any, any, {}> | undefined>;
     sendList(data: SendList): Promise<import("axios").AxiosResponse<any, any, {}> | undefined>;
     sendMedia(data: SendMedia): Promise<import("axios").AxiosResponse<any, any, {}> | undefined>;
+    private getDefaultMimeType;
     sendFile(data: SendMedia): Promise<import("axios").AxiosResponse<any, any, {}> | undefined>;
     sendImage(data: SendMedia): Promise<import("axios").AxiosResponse<any, any, {}> | undefined>;
     sendAudio(data: SendMedia): Promise<import("axios").AxiosResponse<any, any, {}> | undefined>;

package/build/provider/sender.js

@@ -10,7 +10,7 @@ const detectorMedia_1 = require("../utils/detectorMedia");
 class SenderMessage {
     constructor(args) {
         const payloadLimits = args.payloadLimits || {};
-        const maxContentLength = this.parseSize(payloadLimits.json || '50mb');
+        const maxContentLength = this.parseSize(payloadLimits.json || "50mb");
         this.sendwaveApi = axios_1.default.create({
             baseURL: args.url,
             httpsAgent: new https_1.Agent({ rejectUnauthorized: false }),
@@ -26,16 +26,16 @@ class SenderMessage {
     }
     parseSize(size) {
         const units = {
-            'b': 1,
-            'kb': 1024,
-            'mb': 1024 * 1024,
-            'gb': 1024 * 1024 * 1024
+            b: 1,
+            kb: 1024,
+            mb: 1024 * 1024,
+            gb: 1024 * 1024 * 1024,
         };
         const match = size.toLowerCase().match(/^(\d+(?:\.\d+)?)\s*(b|kb|mb|gb)?$/);
         if (!match)
             return 50 * 1024 * 1024; // Default 50MB
         const value = parseFloat(match[1]);
-        const unit = match[2] || 'b';
+        const unit = match[2] || "b";
         return Math.floor(value * units[unit]);
     }
     async sendPresence(data) {
@@ -121,12 +121,43 @@ class SenderMessage {
             if ((_b = (_a = this.globalVendorArgs) === null || _a === void 0 ? void 0 : _a.payloadLimits) === null || _b === void 0 ? void 0 : _b.media) {
                 detectorMedia_1.detectorMedia.updateLimits(this.globalVendorArgs.payloadLimits.media);
             }
-            const { media, mimeType, mediaType, size } = await detectorMedia_1.detectorMedia.processMedia(data.url);
-            // Log large media processing
-            if (size && size > 1024 * 1024) {
-                const sizeMB = Math.round(size / 1024 / 1024 * 100) / 100;
-                console.log(`[SendMedia] Processing ${mediaType} file: ${sizeMB}MB`);
+            let media;
+            let mimeType;
+            let mediaType;
+            // If mediaType is already specified (from sendImage, sendVideo, etc), use it
+            if (data.mediaType) {
+                console.log(`[SendMedia] Using predefined mediaType: ${data.mediaType}`);
+                // Just validate size and get media content without detection
+                if (detectorMedia_1.detectorMedia.isRemoteUrl(data.url)) {
+                    // For remote URLs, validate size and use URL directly
+                    await detectorMedia_1.detectorMedia.validateUrlSize(data.url, data.mediaType);
+                    media = data.url;
+                    // Get actual MIME type from server if possible
+                    try {
+                        const { mimeType: detectedMime } = await detectorMedia_1.detectorMedia.getMimeTypeFromUrl(data.url);
+                        mimeType = detectedMime || this.getDefaultMimeType(data.mediaType);
+                    }
+                    catch {
+                        mimeType = this.getDefaultMimeType(data.mediaType);
+                    }
+                }
+                else {
+                    // For local files, convert to base64
+                    const result = await detectorMedia_1.detectorMedia.convertPathToBase64(data.url);
+                    media = result.media;
+                    mimeType = result.mimeType;
+                }
+                mediaType = data.mediaType;
             }
+            else {
+                // If no mediaType specified, detect it (for generic sendMedia calls)
+                console.log(`[SendMedia] Auto-detecting mediaType for: ${data.url}`);
+                const result = await detectorMedia_1.detectorMedia.processMedia(data.url);
+                media = result.media;
+                mimeType = result.mimeType;
+                mediaType = result.mediaType;
+            }
+            console.log(`[SendMedia] Final - MediaType: ${mediaType}, MimeType: ${mimeType}`);
             return await ((_c = this.sendwaveApi) === null || _c === void 0 ? void 0 : _c.post(`/message/sendMedia/${(_d = this.globalVendorArgs) === null || _d === void 0 ? void 0 : _d.name}`, {
                 number: data.from.split("@")[0],
                 caption: data.text,
@@ -139,25 +170,34 @@ class SenderMessage {
         }
         catch (e) {
             // Enhanced error handling for large files
-            if (e.message && e.message.includes('exceeds limit')) {
+            if (e.message && e.message.includes("exceeds limit")) {
                 console.error(`[SendMedia Error] File size validation failed: ${e.message}`);
                 throw new Error(`File too large: ${e.message}`);
             }
             else if (((_e = e.response) === null || _e === void 0 ? void 0 : _e.status) === 413) {
-                console.error('[SendMedia Error] Server rejected large payload');
-                throw new Error('File too large for server');
+                console.error("[SendMedia Error] Server rejected large payload");
+                throw new Error("File too large for server");
             }
-            else if (e.code === 'ECONNABORTED') {
-                console.error('[SendMedia Error] Request timeout - file may be too large');
-                throw new Error('Upload timeout - file may be too large');
+            else if (e.code === "ECONNABORTED") {
+                console.error("[SendMedia Error] Request timeout - file may be too large");
+                throw new Error("Upload timeout - file may be too large");
             }
             else {
-                const errorMsg = ((_h = (_g = (_f = e.response) === null || _f === void 0 ? void 0 : _f.data) === null || _g === void 0 ? void 0 : _g.response) === null || _h === void 0 ? void 0 : _h.message) || e.message || 'Unknown error';
+                const errorMsg = ((_h = (_g = (_f = e.response) === null || _f === void 0 ? void 0 : _f.data) === null || _g === void 0 ? void 0 : _g.response) === null || _h === void 0 ? void 0 : _h.message) || e.message || "Unknown error";
                 console.error(`[SendMedia Error] ${errorMsg}`);
                 throw new Error(errorMsg);
             }
         }
     }
+    getDefaultMimeType(mediaType) {
+        const defaults = {
+            image: 'image/jpeg',
+            video: 'video/mp4',
+            audio: 'audio/mpeg',
+            document: 'application/octet-stream'
+        };
+        return defaults[mediaType] || 'application/octet-stream';
+    }
     async sendFile(data) {
         try {
             return await this.sendMedia({
@@ -210,12 +250,7 @@ class SenderMessage {
             if ((_b = (_a = this.globalVendorArgs) === null || _a === void 0 ? void 0 : _a.payloadLimits) === null || _b === void 0 ? void 0 : _b.media) {
                 detectorMedia_1.detectorMedia.updateLimits(this.globalVendorArgs.payloadLimits.media);
             }
-            const { media, size } = await detectorMedia_1.detectorMedia.processMedia(data.url);
-            // Log large audio processing
-            if (size && size > 1024 * 1024) {
-                const sizeMB = Math.round(size / 1024 / 1024 * 100) / 100;
-                console.log(`[SendVoice] Processing audio file: ${sizeMB}MB`);
-            }
+            const { media } = await detectorMedia_1.detectorMedia.processMedia(data.url);
             await this.sendPresence({
                 from: data.from,
                 presence: "recording",
@@ -229,20 +264,20 @@ class SenderMessage {
         }
         catch (e) {
             // Enhanced error handling for large audio files
-            if (e.message && e.message.includes('exceeds limit')) {
+            if (e.message && e.message.includes("exceeds limit")) {
                 console.error(`[SendVoice Error] File size validation failed: ${e.message}`);
                 throw new Error(`Audio file too large: ${e.message}`);
             }
             else if (((_e = e.response) === null || _e === void 0 ? void 0 : _e.status) === 413) {
-                console.error('[SendVoice Error] Server rejected large payload');
-                throw new Error('Audio file too large for server');
+                console.error("[SendVoice Error] Server rejected large payload");
+                throw new Error("Audio file too large for server");
             }
-            else if (e.code === 'ECONNABORTED') {
-                console.error('[SendVoice Error] Request timeout - audio file may be too large');
-                throw new Error('Upload timeout - audio file may be too large');
+            else if (e.code === "ECONNABORTED") {
+                console.error("[SendVoice Error] Request timeout - audio file may be too large");
+                throw new Error("Upload timeout - audio file may be too large");
             }
             else {
-                const errorMsg = ((_h = (_g = (_f = e.response) === null || _f === void 0 ? void 0 : _f.data) === null || _g === void 0 ? void 0 : _g.response) === null || _h === void 0 ? void 0 : _h.message) || e.message || 'Unknown error';
+                const errorMsg = ((_h = (_g = (_f = e.response) === null || _f === void 0 ? void 0 : _f.data) === null || _g === void 0 ? void 0 : _g.response) === null || _h === void 0 ? void 0 : _h.message) || e.message || "Unknown error";
                 console.error(`[SendVoice Error] ${errorMsg}`);
                 throw new Error(errorMsg);
             }

package/build/utils/detectorMedia.d.ts

@@ -19,10 +19,13 @@ export declare class DetectorMedia {
     updateLimits(limits: MediaLimits): void;
     private parseSize;
     private validateFileSize;
-    private validateUrlSize;
+    validateUrlSize(url: string, mediaType: string): Promise<number>;
     isRemoteUrl(url: string): boolean;
     convertPathToBase64(filePath: string): Promise<DetectorMediaProps>;
-    getMimeTypeFromUrl(url: string): Promise<string | null>;
+    getMimeTypeFromUrl(url: string): Promise<{
+        mediaType: string | null;
+        mimeType: string | null;
+    }>;
     extractFileNameFromUrl(url: string): Promise<string>;
     /**
      * Método unificado que acepta path o url y devuelve:

package/build/utils/detectorMedia.js

@@ -11,11 +11,11 @@ const axios_1 = __importDefault(require("axios"));
 class DetectorMedia {
     constructor(limits) {
         this.mediaLimits = {
-            image: '10mb',
-            video: '100mb',
-            audio: '50mb',
-            document: '25mb',
-            ...limits
+            image: "10mb",
+            video: "100mb",
+            audio: "50mb",
+            document: "25mb",
+            ...limits,
         };
     }
     static getInstance(limits) {
@@ -29,56 +29,56 @@ class DetectorMedia {
     }
     parseSize(size) {
         const units = {
-            'b': 1,
-            'kb': 1024,
-            'mb': 1024 * 1024,
-            'gb': 1024 * 1024 * 1024
+            b: 1,
+            kb: 1024,
+            mb: 1024 * 1024,
+            gb: 1024 * 1024 * 1024,
         };
         const match = size.toLowerCase().match(/^(\d+(?:\.\d+)?)\s*(b|kb|mb|gb)?$/);
         if (!match)
             return 10 * 1024 * 1024; // Default 10MB
         const value = parseFloat(match[1]);
-        const unit = match[2] || 'b';
+        const unit = match[2] || "b";
         return Math.floor(value * units[unit]);
     }
     validateFileSize(filePath, mediaType) {
         return new Promise((resolve, reject) => {
-            promises_1.default.stat(filePath).then((stats) => {
+            promises_1.default.stat(filePath)
+                .then((stats) => {
                 const fileSize = stats.size;
-                const limitStr = this.mediaLimits[mediaType] || '10mb';
+                const limitStr = this.mediaLimits[mediaType] || "10mb";
                 const limit = this.parseSize(limitStr);
                 if (fileSize > limit) {
-                    const fileSizeMB = Math.round(fileSize / 1024 / 1024 * 100) / 100;
-                    const limitMB = Math.round(limit / 1024 / 1024 * 100) / 100;
+                    const fileSizeMB = Math.round((fileSize / 1024 / 1024) * 100) / 100;
+                    const limitMB = Math.round((limit / 1024 / 1024) * 100) / 100;
                     reject(new Error(`File size ${fileSizeMB}MB exceeds limit of ${limitMB}MB for ${mediaType} files`));
                 }
                 else {
                     resolve();
                 }
-            }).catch(reject);
+            })
+                .catch(reject);
         });
     }
     async validateUrlSize(url, mediaType) {
         try {
             const response = await axios_1.default.head(url);
-            const contentLength = parseInt(response.headers['content-length'] || '0');
+            const contentLength = parseInt(response.headers["content-length"] || "0");
             if (contentLength > 0) {
-                const limitStr = this.mediaLimits[mediaType] || '10mb';
+                const limitStr = this.mediaLimits[mediaType] || "10mb";
                 const limit = this.parseSize(limitStr);
                 if (contentLength > limit) {
-                    const fileSizeMB = Math.round(contentLength / 1024 / 1024 * 100) / 100;
-                    const limitMB = Math.round(limit / 1024 / 1024 * 100) / 100;
+                    const fileSizeMB = Math.round((contentLength / 1024 / 1024) * 100) / 100;
+                    const limitMB = Math.round((limit / 1024 / 1024) * 100) / 100;
                     throw new Error(`Remote file size ${fileSizeMB}MB exceeds limit of ${limitMB}MB for ${mediaType} files`);
                 }
             }
             return contentLength;
         }
         catch (error) {
-            if (error.message.includes('exceeds limit')) {
+            if (error.message.includes("exceeds limit")) {
                 throw error;
             }
-            // If we can't get size, assume it's valid but warn
-            console.warn(`[DetectorMedia] Could not validate size for URL: ${url}`);
             return 0;
         }
     }
@@ -113,11 +113,15 @@ class DetectorMedia {
     async getMimeTypeFromUrl(url) {
         try {
             const res = await axios_1.default.head(url);
-            const mediaType = this.mapMimeToCategory(res.headers["content-type"]);
-            return mediaType || null;
+            const contentType = res.headers["content-type"];
+            const mediaType = this.mapMimeToCategory(contentType);
+            return {
+                mediaType: mediaType || null,
+                mimeType: contentType || null,
+            };
         }
         catch {
-            return null;
+            return { mediaType: null, mimeType: null };
         }
     }
     async extractFileNameFromUrl(url) {
@@ -135,15 +139,15 @@ class DetectorMedia {
      */
     async processMedia(input) {
         if (this.isRemoteUrl(input)) {
-            const mediaType = await this.getMimeTypeFromUrl(input);
-            if (!mediaType)
+            const { mediaType, mimeType } = await this.getMimeTypeFromUrl(input);
+            if (!mediaType || !mimeType)
                 throw new Error("No se pudo determinar el tipo MIME de la URL remota");
             // Validate remote file size
             const size = await this.validateUrlSize(input, mediaType);
             const fileName = await this.extractFileNameFromUrl(input);
             return {
                 media: input,
-                mimeType: mime_types_1.default.lookup(input).toString(),
+                mimeType: mimeType,
                 fileName,
                 mediaType,
                 size,
@@ -152,15 +156,20 @@ class DetectorMedia {
         return this.convertPathToBase64(input);
     }
     mapMimeToCategory(mimeType) {
-        if (mimeType.startsWith("image/"))
+        if (!mimeType) {
+            return "unknown";
+        }
+        const normalizedMimeType = mimeType.toLowerCase().split(";")[0].trim();
+        if (normalizedMimeType.startsWith("image/"))
             return "image";
-        if (mimeType.startsWith("video/"))
+        if (normalizedMimeType.startsWith("video/"))
             return "video";
-        if (mimeType.startsWith("audio/"))
+        if (normalizedMimeType.startsWith("audio/"))
             return "audio";
-        if (mimeType.startsWith("application/") || mimeType.startsWith("text/"))
+        if (normalizedMimeType.startsWith("application/") ||
+            normalizedMimeType.startsWith("text/"))
             return "document";
-        return "unknown";
+        return "document"; // Default to document instead of unknown for better compatibility
     }
 }
 exports.DetectorMedia = DetectorMedia;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gamastudio/sendwave-provider",
-  "version": "0.0.7-dev",
+  "version": "0.0.7-dev1",
   "description": "Librería para interactuar con Sendwave usando configuración dinámica.",
   "main": "build/index.js",
   "types": "build/index.d.ts",