@gamastudio/sendwave-provider 1.0.3 → 1.0.4

package/build/presentation/provider/sendwave.provider.js

@@ -0,0 +1,359 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SendWaveProvider = void 0;
+const bot_1 = require("@builderbot/bot");
+const queue_promise_1 = __importDefault(require("queue-promise"));
+const defaults_1 = require("../../config/defaults");
+const constants_1 = require("../../config/constants");
+const sendwave_core_1 = require("./sendwave-core");
+const connection_polling_service_1 = require("../../application/connection/connection-polling.service");
+const queue_flow_service_1 = require("../../application/queue-flow/queue-flow.service");
+const instance_registry_1 = require("../../infrastructure/persistence/instance.registry");
+const body_parser_middleware_1 = require("../../infrastructure/http/middleware/body-parser.middleware");
+const cors_middleware_1 = require("../../infrastructure/http/middleware/cors.middleware");
+const global_args_middleware_1 = require("../../infrastructure/http/middleware/global-args.middleware");
+const static_assets_middleware_1 = require("../../infrastructure/http/middleware/static-assets.middleware");
+const rate_limiter_middleware_1 = require("../../infrastructure/http/middleware/rate-limiter.middleware");
+const routes_1 = require("../../infrastructure/http/routes/routes");
+class SendWaveProvider extends bot_1.ProviderClass {
+    constructor(args) {
+        var _a;
+        super();
+        this.queue = new queue_promise_1.default();
+        this.state = false;
+        this.instanceConnected = false;
+        this.rateLimiter = new rate_limiter_middleware_1.RateLimiterMiddleware();
+        this.beforeHttpServerInit = async () => {
+            for (const middleware of (0, body_parser_middleware_1.bodyParserMiddleware)(this.globalVendorArgs)) {
+                this.server = this.server.use(middleware);
+            }
+            this.server = this.server
+                .use((0, global_args_middleware_1.globalArgsMiddleware)(this.globalVendorArgs))
+                .use(cors_middleware_1.corsMiddleware)
+                .use("/assets", static_assets_middleware_1.staticAssetsMiddleware)
+                .use(this.rateLimiter.handle)
+                .get("/qr/:instanceName?", (0, routes_1.createQrRouteHandler)(this.registry))
+                .get("/state/:instanceName?", (0, routes_1.createConnectionStateRouteHandler)(this.registry))
+                .get("/", this.createRootHandler())
+                .post("/webhook", (0, routes_1.createWebhookRouteHandler)(this.vendor));
+        };
+        this.busEvents = () => [
+            {
+                event: "auth_failure",
+                func: (payload) => this.emit("auth_failure", payload),
+            },
+            {
+                event: "notice",
+                func: ({ instructions, title }) => this.emit("notice", { instructions, title }),
+            },
+            {
+                event: "ready",
+                func: () => this.emit("ready", true),
+            },
+            {
+                event: "message",
+                func: (payload) => {
+                    var _a;
+                    if (((_a = this.globalVendorArgs.queueFlow) === null || _a === void 0 ? void 0 : _a.enabled) &&
+                        !payload.from.includes("@")) {
+                        this.resetUserTimeout(payload.from, payload.name);
+                    }
+                    this.emit("message", payload);
+                },
+            },
+            {
+                event: "flow-message",
+                func: (payload) => {
+                    this.emit("flow-message", payload);
+                },
+            },
+            {
+                event: "host",
+                func: (payload) => {
+                    this.emit("host", payload);
+                },
+            },
+            {
+                event: "qr-update-request",
+                func: () => {
+                    this.poller.start();
+                },
+            },
+        ];
+        this.initAll = (port, opts) => {
+            this.globalVendorArgs.port = port;
+            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,
+                sendText: this.sendText,
+                sendImage: this.sendImage,
+                sendVideo: this.sendVideo,
+                sendAudio: this.sendAudio,
+                sendFile: this.sendFile,
+                sendVoice: this.sendVoice,
+                sendPresence: this.sendPresence,
+                sendButton: this.sendButton,
+                sendCarousel: this.sendCarousel,
+                sendPoll: this.sendPoll,
+                readMessages: this.readMessages,
+                sendLocation: this.sendLocation,
+                sendReaction: this.sendReaction,
+                provider: this,
+                blacklist: opts === null || opts === void 0 ? void 0 : opts.blacklist,
+                dispatch: (customEvent, payload) => {
+                    this.emit("message", {
+                        ...payload,
+                        body: bot_1.utils.setEvent(customEvent),
+                        name: payload.name,
+                        from: bot_1.utils.removePlus(payload.from),
+                    });
+                },
+            };
+            this.initVendor()
+                .then((v) => this.listenOnEvents(v))
+                .then(() => {
+                this.beforeHttpServerInit();
+                this.start(methods, (routes) => {
+                    this.emit("notice", {
+                        title: "🛜  HTTP Server ON ",
+                        instructions: routes,
+                    });
+                    this.afterHttpServerInit();
+                });
+            })
+                .catch((error) => {
+                console.error("[Provider Error]:", error);
+                if (error.type === "entity.too.large") {
+                    console.error("[Provider] PayloadTooLarge error caught at provider level");
+                }
+            });
+        };
+        this.globalVendorArgs = (0, defaults_1.mergeDefaults)(args);
+        this.queue = new queue_promise_1.default({
+            concurrent: constants_1.QUEUE_OPTIONS.concurrent,
+            interval: constants_1.QUEUE_OPTIONS.interval,
+            start: true,
+        });
+        if ((_a = this.globalVendorArgs.queueFlow) === null || _a === void 0 ? void 0 : _a.enabled) {
+            queue_flow_service_1.queueFlow.updateConfig({
+                warningTimeout: this.globalVendorArgs.queueFlow.warningTimeout,
+                endTimeout: this.globalVendorArgs.queueFlow.endTimeout,
+                warningMessage: this.globalVendorArgs.queueFlow.warningMessage,
+            });
+        }
+        this.registry = new instance_registry_1.InstanceRegistry({
+            url: this.globalVendorArgs.url,
+            payloadLimits: this.globalVendorArgs.payloadLimits,
+        });
+        this.registry.registerMany(this.globalVendorArgs.instances || []);
+        const defaultInstance = this.registry.getDefault();
+        if (!defaultInstance) {
+            throw new Error("SendWaveProvider: At least one instance must be configured");
+        }
+        this.sender = defaultInstance.sender;
+        this.poller = new connection_polling_service_1.ConnectionPollingService(defaultInstance.api, {
+            onConnected: () => {
+                this.instanceConnected = true;
+                this.state = true;
+                this.emit("ready", true);
+            },
+            onDisconnected: () => {
+                this.instanceConnected = true;
+                this.state = false;
+                this.emit("ready", false);
+                this.poller.start();
+            },
+            onAuthFailure: (error) => {
+                var _a, _b;
+                this.instanceConnected = false;
+                this.emit("auth_failure", {
+                    instructions: `Error al autenticar: ${(_b = (_a = error === null || error === void 0 ? void 0 : error.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.error}`,
+                });
+            },
+        });
+        this.on("ready", (isReady) => {
+            if (this.lastReadyState !== isReady) {
+                if (isReady) {
+                    console.log("Instance connection status:", "Connected to server");
+                }
+                this.lastReadyState = isReady;
+            }
+        });
+        this.setupGlobalErrorHandlers();
+    }
+    setupGlobalErrorHandlers() {
+        process.on("uncaughtException", (error) => {
+            if (error.name === "PayloadTooLargeError" ||
+                error.type === "entity.too.large") {
+                console.error("[Global] PayloadTooLarge error intercepted:", error.message);
+                return;
+            }
+            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 deps = {
+            queue: this.queue,
+            globalVendorArgs: this.globalVendorArgs,
+            registry: this.registry,
+        };
+        const vendor = new sendwave_core_1.SendWaveCore(this.globalVendorArgs.port, deps);
+        this.vendor = vendor;
+        this.vendor.on("user-message", (data) => this.emit("user-message", data));
+        this.vendor.on("flow-message", (data) => this.emit("flow-message", data));
+        return Promise.resolve(this.vendor);
+    }
+    createRootHandler() {
+        return async (req, res) => {
+            if (this.state && this.instanceConnected) {
+                await this.afterHttpServerInit();
+                return this.vendor.indexHome(req, res);
+            }
+            if (!this.state && this.instanceConnected) {
+                await this.afterHttpServerInit();
+                return this.vendor.indexConnect(req, res);
+            }
+            return this.vendor.indexError()(req, res);
+        };
+    }
+    async afterHttpServerInit() {
+        await this.poller.check();
+    }
+    getInstance(name) {
+        const instance = name ? this.registry.get(name) : this.registry.getDefault();
+        if (!instance)
+            throw new Error(`Instance not found: ${name}`);
+        return instance;
+    }
+    getInstances() {
+        return this.registry.getAll();
+    }
+    saveFile(_, options) {
+        return Promise.resolve((options === null || options === void 0 ? void 0 : options.path) || "");
+    }
+    async listenOnEvents(vendor) {
+        const listEvents = this.busEvents();
+        for (const { event, func } of listEvents) {
+            vendor.on(event, func);
+        }
+    }
+    sendFlow(data) {
+        this.emit("message", {
+            body: bot_1.utils.setEvent(data.event),
+            name: data.name,
+            from: data.from,
+        });
+    }
+    async sendMessage(from, text, options) {
+        return this.sendToDefault((sender) => sender.dispatch(from, text, options));
+    }
+    sendText(data, instanceName) {
+        return this.sendToInstance(instanceName, (sender) => sender.sendText(data));
+    }
+    sendList(data, instanceName) {
+        return this.sendToInstance(instanceName, (sender) => sender.sendList(data));
+    }
+    sendImage(data, instanceName) {
+        return this.sendToInstance(instanceName, (sender) => sender.sendImage(data));
+    }
+    sendVideo(data, instanceName) {
+        return this.sendToInstance(instanceName, (sender) => sender.sendVideo(data));
+    }
+    sendAudio(data, instanceName) {
+        return this.sendToInstance(instanceName, (sender) => sender.sendAudio(data));
+    }
+    sendFile(data, instanceName) {
+        return this.sendToInstance(instanceName, (sender) => sender.sendFile(data));
+    }
+    sendPresence(data, instanceName) {
+        return this.sendToInstance(instanceName, (sender) => sender.sendPresence(data));
+    }
+    sendVoice(data, instanceName) {
+        return this.sendToInstance(instanceName, (sender) => sender.sendVoice(data));
+    }
+    sendButton(data, instanceName) {
+        return this.sendToInstance(instanceName, (sender) => sender.sendButton(data));
+    }
+    sendCarousel(data, instanceName) {
+        return this.sendToInstance(instanceName, (sender) => sender.sendCarousel(data));
+    }
+    sendPoll(data, instanceName) {
+        return this.sendToInstance(instanceName, (sender) => sender.sendPoll(data));
+    }
+    sendReaction(data, instanceName) {
+        return this.sendToInstance(instanceName, (sender) => sender.sendReaction(data));
+    }
+    sendLocation(data, instanceName) {
+        return this.sendToInstance(instanceName, (sender) => sender.sendLocation(data));
+    }
+    sendMedia(data, instanceName) {
+        return this.sendToInstance(instanceName, (sender) => sender.sendMedia(data));
+    }
+    readMessages(data, instanceName) {
+        return this.sendToInstance(instanceName, (sender) => sender.readMessages(data));
+    }
+    sendToInstance(instanceName, action) {
+        const instance = this.getInstance(instanceName);
+        return action(instance.sender);
+    }
+    sendToDefault(action) {
+        return action(this.sender);
+    }
+    resetUserTimeout(from, name) {
+        var _a;
+        if (!((_a = this.globalVendorArgs.queueFlow) === null || _a === void 0 ? void 0 : _a.enabled))
+            return;
+        return queue_flow_service_1.queueFlow.resetUserTimeout({
+            sendText: (to, text) => this.sender.sendText({ from: to, text }),
+            sendFlow: (event, name, from) => this.sendFlow({ event, name, from }),
+            from,
+            name,
+        });
+    }
+    clearUserTimeout(from) {
+        var _a;
+        if (!((_a = this.globalVendorArgs.queueFlow) === null || _a === void 0 ? void 0 : _a.enabled))
+            return;
+        queue_flow_service_1.queueFlow.clearUserTimeout(from);
+    }
+    forceClearUser(from) {
+        var _a;
+        if (!((_a = this.globalVendorArgs.queueFlow) === null || _a === void 0 ? void 0 : _a.enabled))
+            return;
+        queue_flow_service_1.queueFlow.forceClearUser(from);
+    }
+    isUserIgnored(from) {
+        var _a;
+        if (!((_a = this.globalVendorArgs.queueFlow) === null || _a === void 0 ? void 0 : _a.enabled))
+            return false;
+        return queue_flow_service_1.queueFlow.isUserIgnored(from);
+    }
+    onQueueFlowEvent(event, callback) {
+        queue_flow_service_1.queueFlow.on(event, callback);
+    }
+    offQueueFlowEvent(event, callback) {
+        if (callback) {
+            queue_flow_service_1.queueFlow.off(event, callback);
+        }
+        else {
+            queue_flow_service_1.queueFlow.removeAllListeners(event);
+        }
+    }
+}
+exports.SendWaveProvider = SendWaveProvider;

package/build/provider/sender.d.ts

@@ -1,4 +1,4 @@
-import { GlobalVendorArgs, ProviderInterface, SendButton, SendList, SendMedia, SendMessage, SendPresence, SendPoll, SendLocation, SendReaction, ReadMessage } from "../core/interface";
+import { GlobalVendorArgs, ProviderInterface, SendButton, SendCarousel, SendList, SendMedia, SendMessage, SendPresence, SendPoll, SendLocation, SendReaction, ReadMessage } from "../core/interface";
 export declare class SenderMessage implements ProviderInterface {
     private sendwaveApi?;
     private globalVendorArgs?;
@@ -14,7 +14,9 @@ export declare class SenderMessage implements ProviderInterface {
     sendAudio(data: SendMedia): Promise<import("axios").AxiosResponse<any, any, {}> | undefined>;
     sendVideo(data: SendMedia): Promise<import("axios").AxiosResponse<any, any, {}> | undefined>;
     sendVoice(data: SendMedia): Promise<import("axios").AxiosResponse<any, any, {}> | undefined>;
+    private normalizeButton;
     sendButton(data: SendButton): Promise<import("axios").AxiosResponse<any, any, {}> | undefined>;
+    sendCarousel(data: SendCarousel): Promise<import("axios").AxiosResponse<any, any, {}> | undefined>;
     sendPoll(data: SendPoll): Promise<import("axios").AxiosResponse<any, any, {}> | undefined>;
     sendLocation(data: SendLocation): Promise<import("axios").AxiosResponse<any, any, {}> | undefined>;
     sendReaction(data: SendReaction): Promise<import("axios").AxiosResponse<any, any, {}> | undefined>;

package/build/provider/sender.js

@@ -312,6 +312,23 @@ class SenderMessage {
             }
         }
     }
+    normalizeButton(button, index) {
+        if (typeof button === "string") {
+            return { type: "reply", displayText: button, id: `${index + 1}` };
+        }
+        const raw = button;
+        const { type = "reply", displayText, ...rest } = raw;
+        const base = {
+            type,
+            displayText: displayText || raw.text || "",
+            id: `${index + 1}`,
+            ...rest,
+        };
+        delete base.text;
+        delete base.body;
+        delete base.reply;
+        return base;
+    }
     async sendButton(data) {
         var _a, _b, _c, _d, _e, _f;
         try {
@@ -322,40 +339,7 @@ class SenderMessage {
                 body: data.body,
                 description: data.description,
                 footer: data.footer,
-                buttons: data.buttons.map((button, index) => {
-                    let type = "reply";
-                    let displayText = "";
-                    let rest = {};
-                    if (typeof button === "string") {
-                        displayText = button;
-                    }
-                    else if (button.displayText) {
-                        displayText = button.displayText;
-                        type = button.type || "reply";
-                        rest = button;
-                    }
-                    else if (button.type === "reply") {
-                        displayText = button.displayText;
-                        type = "reply";
-                        rest = button;
-                    }
-                    else {
-                        displayText = button.displayText || button.text || button;
-                        type = button.type || "reply";
-                        rest = button;
-                    }
-                    const base = {
-                        type,
-                        displayText,
-                        id: `${index + 1}`,
-                        ...rest
-                    };
-                    // Clean up unwanted properties
-                    delete base.text;
-                    delete base.body;
-                    delete base.reply;
-                    return base;
-                }),
+                buttons: data.buttons.map((button, index) => this.normalizeButton(button, index)),
                 delay: data.delay || 2000,
                 quoted: data.quoted,
                 everyOne: data.everyOne || false,
@@ -371,6 +355,40 @@ class SenderMessage {
             throw new Error(msg);
         }
     }
+    async sendCarousel(data) {
+        var _a, _b, _c, _d, _e, _f;
+        try {
+            if (!(data === null || data === void 0 ? void 0 : data.from))
+                throw new Error("sendCarousel: falta 'from'");
+            if (!Array.isArray(data.cards) || data.cards.length === 0)
+                throw new Error("sendCarousel: 'cards' debe ser un array no vacío");
+            const cards = data.cards.map((card, cardIndex) => ({
+                text: card.text,
+                thumbnailUrl: card.thumbnailUrl,
+                footerText: card.footerText,
+                buttons: (card.buttons || []).map((button, buttonIndex) => this.normalizeButton(button, cardIndex * 100 + buttonIndex)),
+            }));
+            return await ((_a = this.sendwaveApi) === null || _a === void 0 ? void 0 : _a.post(`/message/sendCarousel/${(_b = this.globalVendorArgs) === null || _b === void 0 ? void 0 : _b.name}`, {
+                number: data.from,
+                title: data.title,
+                description: data.description,
+                footer: data.footer,
+                cards,
+                delay: data.delay || 2000,
+                quoted: data.quoted,
+                everyOne: data.everyOne || false,
+                mentioned: ((_c = data.mentioned) === null || _c === void 0 ? void 0 : _c.length) ? data.mentioned : [data.from],
+                ...this.globalVendorArgs,
+            }));
+        }
+        catch (error) {
+            const msg = ((_f = (_e = (_d = error === null || error === void 0 ? void 0 : error.response) === null || _d === void 0 ? void 0 : _d.data) === null || _e === void 0 ? void 0 : _e.response) === null || _f === void 0 ? void 0 : _f.message) ||
+                (error === null || error === void 0 ? void 0 : error.message) ||
+                "Unknown error";
+            console.error(`[sendCarousel Error] ${msg}`);
+            throw new Error(msg);
+        }
+    }
     async sendPoll(data) {
         var _a, _b, _c, _d, _e, _f;
         try {

package/build/shared/exceptions/payload-too-large.exception.d.ts

@@ -0,0 +1,4 @@
+export declare class PayloadTooLargeError extends Error {
+    readonly code = "PAYLOAD_TOO_LARGE";
+    constructor(message?: string);
+}

package/build/shared/exceptions/payload-too-large.exception.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PayloadTooLargeError = void 0;
+class PayloadTooLargeError extends Error {
+    constructor(message = "Payload too large") {
+        super(message);
+        this.code = "PAYLOAD_TOO_LARGE";
+        this.name = "PayloadTooLargeError";
+    }
+}
+exports.PayloadTooLargeError = PayloadTooLargeError;

package/build/shared/utils/error-extractor.d.ts

@@ -0,0 +1 @@
+export declare function extractApiError(error: any, fallback?: string): string;

package/build/shared/utils/error-extractor.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractApiError = extractApiError;
+function extractApiError(error, fallback = "Unknown error") {
+    var _a, _b, _c;
+    return ((_c = (_b = (_a = error === null || error === void 0 ? void 0 : error.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.response) === null || _c === void 0 ? void 0 : _c.message) || (error === null || error === void 0 ? void 0 : error.message) || fallback;
+}

package/build/shared/utils/size-parser.d.ts

@@ -0,0 +1 @@
+export declare function parseSize(size: string, defaultValue?: number): number;

package/build/shared/utils/size-parser.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSize = parseSize;
+const units = {
+    b: 1,
+    kb: 1024,
+    mb: 1024 * 1024,
+    gb: 1024 * 1024 * 1024,
+};
+function parseSize(size, defaultValue = 50 * 1024 * 1024) {
+    const match = size.toLowerCase().match(/^(\d+(?:\.\d+)?)\s*(b|kb|mb|gb)?$/);
+    if (!match)
+        return defaultValue;
+    const value = parseFloat(match[1]);
+    const unit = match[2] || "b";
+    return Math.floor(value * (units[unit] || 1));
+}

package/package.json

@@ -1,48 +1,48 @@
-{
-  "name": "@gamastudio/sendwave-provider",
-  "version": "1.0.3",
-  "description": "Librería para interactuar con Sendwave usando configuración dinámica.",
-  "main": "build/index.js",
-  "types": "build/index.d.ts",
-  "publishConfig": {
-    "access": "public"
-  },
-  "scripts": {
-    "build": "tsc && tsc-alias && copyfiles package.json build",
-    "test": "ts-node -r tsconfig-paths/register test/test.ts",
-    "dev": "ts-node-dev --respawn --transpile-only -r tsconfig-paths/register test/test.ts",
-    "prepublishOnly": "npm run build"
-  },
-  "keywords": [
-    "Sendwave",
-    "Provider",
-    "Gamastudio",
-    "Bot"
-  ],
-  "author": "Ameth Galarcio <amethgm@gmail.com>",
-  "license": "ISC",
-  "dependencies": {
-    "@builderbot/bot": "^1.3.15",
-    "@gamastudio/colorslog": "^0.1.8",
-    "@types/mime-types": "^3.0.1",
-    "axios": "^1.13.2",
-    "body-parser": "^2.2.2",
-    "cors": "^2.8.5",
-    "file-type": "^21.3.0",
-    "mime-types": "^3.0.2",
-    "queue-promise": "^2.2.1",
-    "sirv": "^3.0.2"
-  },
-  "devDependencies": {
-    "@types/axios": "^0.14.4",
-    "@types/body-parser": "^1.19.6",
-    "@types/cors": "^2.8.19",
-    "@types/node": "^24.10.9",
-    "copyfiles": "^2.4.1",
-    "ts-node": "^10.9.2",
-    "ts-node-dev": "^2.0.0",
-    "tsc-alias": "^1.8.16",
-    "tsconfig-paths": "^4.2.0",
-    "typescript": "^5.9.3"
-  }
-}
+{
+  "name": "@gamastudio/sendwave-provider",
+  "version": "1.0.4",
+  "description": "Official Sendwaves provider for BuilderBot. Multi-instance WhatsApp messaging library with intelligent message merging, media support, interactive buttons, lists, carousels, polls, and automatic queue flow.",
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc && tsc-alias && copyfiles package.json build",
+    "test": "ts-node -r tsconfig-paths/register test/test.ts",
+    "dev": "ts-node-dev --respawn --transpile-only -r tsconfig-paths/register test/test.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "Sendwave",
+    "Provider",
+    "Gamastudio",
+    "Bot"
+  ],
+  "author": "Ameth Galarcio <amethgm@gmail.com>",
+  "license": "ISC",
+  "dependencies": {
+    "@builderbot/bot": "^1.3.15",
+    "@gamastudio/colorslog": "^0.1.8",
+    "@types/mime-types": "^3.0.1",
+    "axios": "^1.13.2",
+    "body-parser": "^2.2.2",
+    "cors": "^2.8.5",
+    "file-type": "^21.3.0",
+    "mime-types": "^3.0.2",
+    "queue-promise": "^2.2.1",
+    "sirv": "^3.0.2"
+  },
+  "devDependencies": {
+    "@types/axios": "^0.14.4",
+    "@types/body-parser": "^1.19.6",
+    "@types/cors": "^2.8.19",
+    "@types/node": "^24.10.9",
+    "copyfiles": "^2.4.1",
+    "ts-node": "^10.9.2",
+    "ts-node-dev": "^2.0.0",
+    "tsc-alias": "^1.8.16",
+    "tsconfig-paths": "^4.2.0",
+    "typescript": "^5.9.3"
+  }
+}

package/tsconfig.json

@@ -2,10 +2,12 @@
   "compilerOptions": {
     "baseUrl": "./src",
     "paths": {
-      "@provider/*": ["provider/*"],
-      "@interface/*": ["interface/*"],
-      "@utils/*": ["utils/*"],
-      "@core/*": ["core/*"]
+      "@config/*": ["config/*"],
+      "@domain/*": ["domain/*"],
+      "@infrastructure/*": ["infrastructure/*"],
+      "@application/*": ["application/*"],
+      "@presentation/*": ["presentation/*"],
+      "@shared/*": ["shared/*"]
     },
     "outDir": "build",
     "module": "CommonJS",
@@ -16,4 +18,4 @@
     "skipLibCheck": true
   },
   "include": ["src/**/*"]
-}
+}