@gamastudio/sendwave-provider 0.0.6 → 0.0.7-dev1

package/build/core/interface/parser.interface.d.ts

@@ -7,5 +7,7 @@ export interface ParsedMessage {
     type: string;
     media?: string;
     caption?: string;
-    originalPayload: any;
+    originalPayload: {
+        key: any;
+    };
 }

package/build/core/interface/types.d.ts

@@ -10,6 +10,7 @@ export interface GlobalVendorArgs {
     url?: string;
     apiKey: string;
     port?: number;
+    host?: string;
     delay?: number;
     linkPreview?: boolean;
     message?: {
@@ -25,6 +26,17 @@ export interface GlobalVendorArgs {
         endTimeout?: number;
         warningMessage?: string;
     };
+    payloadLimits?: {
+        json?: string;
+        urlencoded?: string;
+        text?: string;
+        media?: {
+            image?: string;
+            video?: string;
+            audio?: string;
+            document?: string;
+        };
+    };
 }
 export interface Message {
     type: string;

package/build/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gamastudio/sendwave-provider",
-  "version": "0.0.6",
+  "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",
@@ -22,7 +22,7 @@
   "author": "Ameth Galarcio <amethgm@gmail.com>",
   "license": "ISC",
   "dependencies": {
-    "@builderbot/bot": "^1.3.1",
+    "@builderbot/bot": "^1.2.9",
     "@gamastudio/colorslog": "^0.1.6",
     "@types/mime-types": "^2.1.4",
     "axios": "^1.11.0",

package/build/provider/core.js

@@ -54,8 +54,35 @@ class SendWaveCore extends node_events_1.EventEmitter {
             }
             catch (e) {
                 console.error("[IncomingMsg Error]:", e);
+                // Handle PayloadTooLargeError specifically
+                if (e.name === 'PayloadTooLargeError' || e.type === 'entity.too.large') {
+                    console.error(`[PayloadTooLarge] Request from ${req.ip || 'unknown'} exceeded size limit`);
+                    res.statusCode = 413;
+                    res.setHeader('Content-Type', 'application/json');
+                    return res.end(JSON.stringify({
+                        error: 'Payload too large',
+                        message: 'El archivo o mensaje es demasiado grande',
+                        code: 'PAYLOAD_TOO_LARGE'
+                    }));
+                }
+                // Handle timeout errors
+                if (e.type === 'request.timeout') {
+                    console.error(`[RequestTimeout] Request from ${req.ip || 'unknown'} timed out`);
+                    res.statusCode = 408;
+                    res.setHeader('Content-Type', 'application/json');
+                    return res.end(JSON.stringify({
+                        error: 'Request timeout',
+                        message: 'La solicitud ha tardado demasiado',
+                        code: 'REQUEST_TIMEOUT'
+                    }));
+                }
                 res.statusCode = 500;
-                return res.end("Internal Server Error");
+                res.setHeader('Content-Type', 'application/json');
+                return res.end(JSON.stringify({
+                    error: 'Internal Server Error',
+                    message: 'Error interno del servidor',
+                    code: 'INTERNAL_ERROR'
+                }));
             }
         };
         this.messageBuffers = {};

package/build/provider/provider.d.ts

@@ -14,6 +14,7 @@ export declare class SendWaveProvider extends ProviderClass<SendWaveCore> {
     sender: SenderMessage;
     globalVendorArgs: GlobalVendorArgs;
     constructor(args: Partial<GlobalVendorArgs>);
+    private setupGlobalErrorHandlers;
     protected initVendor(): Promise<any>;
     protected beforeHttpServerInit: () => Promise<void>;
     protected getApiQrConnect: () => Promise<void>;
@@ -22,6 +23,7 @@ export declare class SendWaveProvider extends ProviderClass<SendWaveCore> {
         path: string;
     }): Promise<string>;
     createInstance(): void;
+    private parseSize;
     busEvents: () => ({
         event: string;
         func: (payload: BotContext) => void;
@@ -48,6 +50,7 @@ export declare class SendWaveProvider extends ProviderClass<SendWaveCore> {
     sendButton(...args: Parameters<SenderMessage["sendButton"]>): Promise<import("axios").AxiosResponse<any, any, {}> | undefined>;
     sendReaction(...args: Parameters<SenderMessage["sendReaction"]>): Promise<import("axios").AxiosResponse<any, any, {}> | undefined>;
     sendLocation(...args: Parameters<SenderMessage["sendLocation"]>): Promise<import("axios").AxiosResponse<any, any, {}> | undefined>;
+    sendMedia(...args: Parameters<SenderMessage["sendMedia"]>): Promise<import("axios").AxiosResponse<any, any, {}> | undefined>;
     /**
      * Reset user timeout for queue flow system
      */

package/build/provider/provider.js

@@ -27,6 +27,7 @@ class SendWaveProvider extends bot_1.ProviderClass {
             name: "bot",
             url: "https://sendwave-api.gamastudio.co",
             port: 3000,
+            host: "0.0.0.0", // Listen on all interfaces by default
             apiKey: "",
             delay: 0,
             linkPreview: true,
@@ -40,10 +41,38 @@ class SendWaveProvider extends bot_1.ProviderClass {
                 endTimeout: 2 * 60 * 1000, // 2 minutes
                 warningMessage: "⏳ Parece que has estado inactivo. ¿Sigues ahí?",
             },
+            payloadLimits: {
+                json: '50mb',
+                urlencoded: '50mb',
+                text: '10mb',
+                media: {
+                    image: '10mb',
+                    video: '100mb',
+                    audio: '50mb',
+                    document: '25mb',
+                },
+            },
         };
         this.beforeHttpServerInit = async () => {
+            // Configure body parser with large payload limits
+            const payloadLimits = this.globalVendorArgs.payloadLimits || {};
             this.server = this.server
-                .use(body_parser_1.default.json())
+                .use(body_parser_1.default.json({
+                limit: payloadLimits.json || '50mb',
+                type: 'application/json'
+            }))
+                .use(body_parser_1.default.urlencoded({
+                limit: payloadLimits.urlencoded || '50mb',
+                extended: true
+            }))
+                .use(body_parser_1.default.text({
+                limit: payloadLimits.text || '10mb',
+                type: 'text/*'
+            }))
+                .use(body_parser_1.default.raw({
+                limit: payloadLimits.json || '50mb',
+                type: 'application/octet-stream'
+            }))
                 .use((req, _, next) => {
                 req["globalVendorArgs"] = this.globalVendorArgs;
                 return next();
@@ -117,6 +146,11 @@ class SendWaveProvider extends bot_1.ProviderClass {
         ];
         this.initAll = (port, opts) => {
             this.globalVendorArgs.port = port;
+            // Override the server binding to listen on all interfaces
+            if (this.globalVendorArgs.host === "0.0.0.0") {
+                process.env.HOST = "0.0.0.0";
+                process.env.HOSTNAME = "0.0.0.0";
+            }
             const methods = {
                 sendMessage: this.sendMessage,
                 sendList: this.sendList,
@@ -150,6 +184,12 @@ class SendWaveProvider extends bot_1.ProviderClass {
                     });
                     this.afterHttpServerInit();
                 });
+            })
+                .catch((error) => {
+                console.error("[Provider Error]:", error);
+                if (error.type === 'entity.too.large') {
+                    console.error("[Provider] PayloadTooLarge error caught at provider level");
+                }
             });
             return;
         };
@@ -174,6 +214,27 @@ class SendWaveProvider extends bot_1.ProviderClass {
             // Puedes emitir eventos a websockets aquí, notificar a frontends, etc.
         });
         this.sender = new sender_1.SenderMessage(this.globalVendorArgs);
+        // Add global error handlers for payload errors
+        this.setupGlobalErrorHandlers();
+    }
+    setupGlobalErrorHandlers() {
+        // Handle uncaught PayloadTooLarge errors
+        process.on('uncaughtException', (error) => {
+            if (error.name === 'PayloadTooLargeError' || error.type === 'entity.too.large') {
+                console.error('[Global] PayloadTooLarge error intercepted:', error.message);
+                // Don't exit process for this type of error
+                return;
+            }
+            // For other uncaught exceptions, log and continue
+            console.error('[Global] Uncaught exception:', error);
+        });
+        process.on('unhandledRejection', (reason) => {
+            if (reason && (reason.name === 'PayloadTooLargeError' || reason.type === 'entity.too.large')) {
+                console.error('[Global] PayloadTooLarge rejection intercepted:', reason.message);
+                return;
+            }
+            console.error('[Global] Unhandled rejection:', reason);
+        });
     }
     initVendor() {
         const vendor = new core_1.SendWaveCore(this.globalVendorArgs.port, this.queue, this.globalVendorArgs);
@@ -223,6 +284,8 @@ class SendWaveProvider extends bot_1.ProviderClass {
             this.globalVendorArgs.url.trim()
             ? this.globalVendorArgs.url.trim()
             : "https://sendwave-api.gamastudio.co";
+        const payloadLimits = this.globalVendorArgs.payloadLimits || {};
+        const maxContentLength = this.parseSize(payloadLimits.json || '50mb');
         this.sendwaveApi = axios_1.default.create({
             baseURL: url,
             httpsAgent: new https_1.Agent({ rejectUnauthorized: false }),
@@ -230,8 +293,46 @@ class SendWaveProvider extends bot_1.ProviderClass {
                 "Content-Type": "application/json",
                 apikey: this.globalVendorArgs.apiKey,
             },
+            // Large file support configuration
+            maxContentLength: maxContentLength,
+            maxBodyLength: maxContentLength,
+            timeout: 300000, // 5 minutes timeout for large files
+        });
+        // Add request interceptor for large file logging
+        this.sendwaveApi.interceptors.request.use((config) => {
+            const contentLength = config.headers['content-length'] ||
+                (config.data ? JSON.stringify(config.data).length : 0);
+            if (contentLength > 1024 * 1024) { // Log requests larger than 1MB
+                console.log(`[LargeRequest] Sending ${Math.round(contentLength / 1024 / 1024 * 100) / 100}MB to ${config.url}`);
+            }
+            return config;
+        }, (error) => Promise.reject(error));
+        // Add response interceptor for error handling
+        this.sendwaveApi.interceptors.response.use((response) => response, (error) => {
+            var _a;
+            if (error.code === 'ECONNABORTED') {
+                console.error('[RequestTimeout] Large file upload timed out');
+            }
+            else if (((_a = error.response) === null || _a === void 0 ? void 0 : _a.status) === 413) {
+                console.error('[PayloadTooLarge] Server rejected large payload');
+            }
+            return Promise.reject(error);
         });
     }
+    parseSize(size) {
+        const units = {
+            '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';
+        return Math.floor(value * units[unit]);
+    }
     async listenOnEvents(vendor) {
         const listEvents = this.busEvents();
         for (const { event, func } of listEvents) {
@@ -246,38 +347,60 @@ class SendWaveProvider extends bot_1.ProviderClass {
         });
     }
     async sendMessage(from, text, options) {
-        options = { ...options["options"] };
-        let mss = { from, text, options };
-        if (options.media) {
-            const { media, mediaType, fileName } = await detectorMedia_1.detectorMedia.processMedia(options.media);
-            switch (mediaType) {
-                case "image":
-                    return await this.sender.sendImage({
-                        ...mss,
-                        url: media,
-                        text: text,
-                    });
-                case "video":
-                    return await this.sender.sendVideo({
-                        ...mss,
-                        url: media,
-                        text: text,
-                    });
-                case "audio":
-                    return await this.sender.sendVoice({ ...mss, url: media });
-                case "document":
-                    return await this.sender.sendFile({
-                        ...mss,
-                        url: media,
-                        fileName,
-                        text: text,
-                    });
-                default:
-                    return await this.sender.sendText(mss);
+        var _a, _b;
+        try {
+            options = { ...options["options"] };
+            let mss = { from, text, options };
+            if (options.media) {
+                // Initialize detector with payload limits from global args
+                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, mediaType, fileName, size } = await detectorMedia_1.detectorMedia.processMedia(options.media);
+                switch (mediaType) {
+                    case "image":
+                        return await this.sender.sendImage({
+                            ...mss,
+                            url: media,
+                            text: text,
+                        });
+                    case "video":
+                        return await this.sender.sendVideo({
+                            ...mss,
+                            url: media,
+                            text: text,
+                        });
+                    case "audio":
+                        return await this.sender.sendVoice({ ...mss, url: media });
+                    case "document":
+                        return await this.sender.sendFile({
+                            ...mss,
+                            url: media,
+                            fileName,
+                            text: text,
+                        });
+                    default:
+                        return await this.sender.sendText(mss);
+                }
+            }
+            else {
+                return await this.sender.sendText(mss);
             }
         }
-        else {
-            return await this.sender.sendText(mss);
+        catch (error) {
+            // Enhanced error handling for large files
+            if (error.message && error.message.includes('exceeds limit')) {
+                console.error(`[SendMessage Error] File size validation failed: ${error.message}`);
+                throw new Error(`File too large: ${error.message}`);
+            }
+            else if (error.message && error.message.includes('too large')) {
+                console.error(`[SendMessage Error] Large file error: ${error.message}`);
+                throw error;
+            }
+            else {
+                console.error(`[SendMessage Error] ${error.message || 'Unknown error'}`);
+                throw error;
+            }
         }
     }
     // Métodos de conveniencia para mantener la API limpia
@@ -314,6 +437,9 @@ class SendWaveProvider extends bot_1.ProviderClass {
     sendLocation(...args) {
         return this.sender.sendLocation(...args);
     }
+    sendMedia(...args) {
+        return this.sender.sendMedia(...args);
+    }
     // Queue Flow Management Methods
     /**
      * Reset user timeout for queue flow system

package/build/provider/sender.d.ts

@@ -3,10 +3,12 @@ export declare class SenderMessage implements ProviderInterface {
     private sendwaveApi?;
     private globalVendorArgs?;
     constructor(args: Partial<GlobalVendorArgs>);
+    private parseSize;
     sendPresence(data: SendPresence): Promise<import("axios").AxiosResponse<any, any, {}> | undefined>;
     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

@@ -9,6 +9,8 @@ const axios_1 = __importDefault(require("axios"));
 const detectorMedia_1 = require("../utils/detectorMedia");
 class SenderMessage {
     constructor(args) {
+        const payloadLimits = args.payloadLimits || {};
+        const maxContentLength = this.parseSize(payloadLimits.json || "50mb");
         this.sendwaveApi = axios_1.default.create({
             baseURL: args.url,
             httpsAgent: new https_1.Agent({ rejectUnauthorized: false }),
@@ -16,9 +18,26 @@ class SenderMessage {
                 "Content-Type": "application/json",
                 apikey: args.apiKey,
             },
+            maxContentLength: maxContentLength,
+            maxBodyLength: maxContentLength,
+            timeout: 300000, // 5 minutes for large files
         });
         this.globalVendorArgs = args;
     }
+    parseSize(size) {
+        const units = {
+            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";
+        return Math.floor(value * units[unit]);
+    }
     async sendPresence(data) {
         var _a, _b;
         try {
@@ -96,10 +115,50 @@ class SenderMessage {
         }
     }
     async sendMedia(data) {
-        var _a, _b;
+        var _a, _b, _c, _d, _e, _f, _g, _h;
         try {
-            const { media, mimeType, mediaType } = await detectorMedia_1.detectorMedia.processMedia(data.url);
-            return await ((_a = this.sendwaveApi) === null || _a === void 0 ? void 0 : _a.post(`/message/sendMedia/${(_b = this.globalVendorArgs) === null || _b === void 0 ? void 0 : _b.name}`, {
+            // Initialize detector with payload limits from global args
+            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);
+            }
+            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,
                 mediatype: mediaType,
@@ -110,9 +169,35 @@ class SenderMessage {
             }));
         }
         catch (e) {
-            console.error(e.response.data.response.message);
+            // Enhanced error handling for large files
+            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");
+            }
+            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";
+                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({
@@ -159,22 +244,43 @@ class SenderMessage {
         }
     }
     async sendVoice(data) {
-        var _a, _b;
+        var _a, _b, _c, _d, _e, _f, _g, _h;
         try {
+            // Initialize detector with payload limits from global args
+            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 } = await detectorMedia_1.detectorMedia.processMedia(data.url);
             await this.sendPresence({
                 from: data.from,
                 presence: "recording",
                 delay: data.delay || 2000,
             });
-            return await ((_a = this.sendwaveApi) === null || _a === void 0 ? void 0 : _a.post(`/message/sendWhatsAppAudio/${(_b = this.globalVendorArgs) === null || _b === void 0 ? void 0 : _b.name}`, {
+            return await ((_c = this.sendwaveApi) === null || _c === void 0 ? void 0 : _c.post(`/message/sendWhatsAppAudio/${(_d = this.globalVendorArgs) === null || _d === void 0 ? void 0 : _d.name}`, {
                 number: data.from,
                 audio: media,
                 ...this.globalVendorArgs,
             }));
         }
         catch (e) {
-            console.error(e.response.data.response.message);
+            // Enhanced error handling for large audio files
+            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");
+            }
+            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";
+                console.error(`[SendVoice Error] ${errorMsg}`);
+                throw new Error(errorMsg);
+            }
         }
     }
     async sendButton(data) {

package/build/utils/detectorMedia.d.ts

@@ -3,19 +3,36 @@ interface DetectorMediaProps {
     mimeType?: string;
     mediaType?: string;
     fileName?: string;
+    size?: number;
+}
+interface MediaLimits {
+    image?: string;
+    video?: string;
+    audio?: string;
+    document?: string;
 }
 export declare class DetectorMedia {
     static instance: DetectorMedia;
-    static getInstance(): DetectorMedia;
+    private mediaLimits;
+    constructor(limits?: MediaLimits);
+    static getInstance(limits?: MediaLimits): DetectorMedia;
+    updateLimits(limits: MediaLimits): void;
+    private parseSize;
+    private validateFileSize;
+    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:
      * - media (base64 si es path, url si es remota)
      * - mimeType
      * - fileName
+     * - size
      */
     processMedia(input: string): Promise<DetectorMediaProps>;
     mapMimeToCategory(mimeType: string): "image" | "video" | "audio" | "document" | "unknown";

package/build/utils/detectorMedia.js

@@ -9,12 +9,79 @@ const path_1 = __importDefault(require("path"));
 const mime_types_1 = __importDefault(require("mime-types"));
 const axios_1 = __importDefault(require("axios"));
 class DetectorMedia {
-    static getInstance() {
+    constructor(limits) {
+        this.mediaLimits = {
+            image: "10mb",
+            video: "100mb",
+            audio: "50mb",
+            document: "25mb",
+            ...limits,
+        };
+    }
+    static getInstance(limits) {
         if (!DetectorMedia.instance) {
-            DetectorMedia.instance = new DetectorMedia();
+            DetectorMedia.instance = new DetectorMedia(limits);
         }
         return DetectorMedia.instance;
     }
+    updateLimits(limits) {
+        this.mediaLimits = { ...this.mediaLimits, ...limits };
+    }
+    parseSize(size) {
+        const units = {
+            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";
+        return Math.floor(value * units[unit]);
+    }
+    validateFileSize(filePath, mediaType) {
+        return new Promise((resolve, reject) => {
+            promises_1.default.stat(filePath)
+                .then((stats) => {
+                const fileSize = stats.size;
+                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;
+                    reject(new Error(`File size ${fileSizeMB}MB exceeds limit of ${limitMB}MB for ${mediaType} files`));
+                }
+                else {
+                    resolve();
+                }
+            })
+                .catch(reject);
+        });
+    }
+    async validateUrlSize(url, mediaType) {
+        try {
+            const response = await axios_1.default.head(url);
+            const contentLength = parseInt(response.headers["content-length"] || "0");
+            if (contentLength > 0) {
+                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;
+                    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")) {
+                throw error;
+            }
+            return 0;
+        }
+    }
     isRemoteUrl(url) {
         try {
             const u = new URL(url);
@@ -25,28 +92,36 @@ class DetectorMedia {
         }
     }
     async convertPathToBase64(filePath) {
-        const fileBuffer = await promises_1.default.readFile(filePath);
         const mediaType = this.mapMimeToCategory(mime_types_1.default.lookup(filePath).toString());
         if (!mediaType)
             throw new Error("No se pudo determinar el tipo MIME del archivo");
+        // Validate file size before processing
+        await this.validateFileSize(filePath, mediaType);
+        const fileBuffer = await promises_1.default.readFile(filePath);
         const base64Data = fileBuffer.toString("base64");
         const media = base64Data;
         const fileName = path_1.default.basename(filePath);
+        const stats = await promises_1.default.stat(filePath);
         return {
             media,
             mediaType,
             fileName,
             mimeType: mime_types_1.default.lookup(filePath).toString(),
+            size: stats.size,
         };
     }
     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) {
@@ -60,32 +135,41 @@ class DetectorMedia {
      * - media (base64 si es path, url si es remota)
      * - mimeType
      * - fileName
+     * - size
      */
     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,
             };
         }
         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.6",
+  "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",
@@ -22,7 +22,7 @@
   "author": "Ameth Galarcio <amethgm@gmail.com>",
   "license": "ISC",
   "dependencies": {
-    "@builderbot/bot": "^1.3.1",
+    "@builderbot/bot": "^1.2.9",
     "@gamastudio/colorslog": "^0.1.6",
     "@types/mime-types": "^2.1.4",
     "axios": "^1.11.0",