@wabot-dev/framework 0.9.1 → 0.9.5

package/dist/src/addon/chat-controller/cmd/CmdChannelConfig.js

@@ -0,0 +1,8 @@
+class CmdChannelConfig {
+    route;
+    constructor(route) {
+        this.route = route;
+    }
+}
+
+export { CmdChannelConfig };

package/dist/src/addon/chat-controller/cmd/CmdChannelServer.js

@@ -0,0 +1,169 @@
+import { __decorate } from 'tslib';
+import * as fs from 'node:fs';
+import * as net from 'node:net';
+import * as path from 'node:path';
+import { singleton } from '../../../core/injection/index.js';
+import { Logger } from '../../../core/logger/Logger.js';
+import { cmdChannelSocketPath } from './cmdChannelSocketPath.js';
+
+const logger = new Logger('wabot:cmd-channel-server');
+let CmdChannelServer = class CmdChannelServer {
+    server = null;
+    channels = new Map();
+    client = null;
+    buffer = '';
+    activeRoute = null;
+    register(route, handlers) {
+        this.channels.set(route, handlers);
+        this.ensureStarted();
+    }
+    unregister(route) {
+        this.channels.delete(route);
+        if (this.activeRoute === route) {
+            this.activeRoute = null;
+        }
+    }
+    ensureStarted() {
+        if (this.server)
+            return;
+        const socketPath = cmdChannelSocketPath();
+        if (process.platform !== 'win32') {
+            try {
+                fs.unlinkSync(socketPath);
+            }
+            catch {
+                // ignore: socket file did not exist
+            }
+            fs.mkdirSync(path.dirname(socketPath), { recursive: true });
+        }
+        this.server = net.createServer((socket) => this.handleConnection(socket));
+        this.server.on('error', (err) => logger.error('cmd channel server error', err));
+        this.server.listen(socketPath, () => {
+            logger.info(`cmd channel server listening at ${socketPath}`);
+        });
+        process.once('exit', () => this.shutdown());
+        process.once('SIGINT', () => {
+            this.shutdown();
+            process.exit(0);
+        });
+        process.once('SIGTERM', () => {
+            this.shutdown();
+            process.exit(0);
+        });
+    }
+    shutdown() {
+        if (this.client) {
+            this.client.destroy();
+            this.client = null;
+        }
+        if (this.server) {
+            this.server.close();
+            this.server = null;
+        }
+        if (process.platform !== 'win32') {
+            try {
+                fs.unlinkSync(cmdChannelSocketPath());
+            }
+            catch {
+                // ignore
+            }
+        }
+    }
+    handleConnection(socket) {
+        if (this.client) {
+            this.send(socket, {
+                type: 'error',
+                message: 'Another cmd client is already connected',
+            });
+            socket.end();
+            return;
+        }
+        this.client = socket;
+        this.buffer = '';
+        this.activeRoute = null;
+        socket.on('data', (chunk) => this.handleData(chunk.toString()));
+        socket.on('close', () => {
+            if (this.client === socket) {
+                this.client = null;
+                this.activeRoute = null;
+                this.buffer = '';
+            }
+        });
+        socket.on('error', (err) => {
+            logger.warn('cmd client connection error', err);
+            if (this.client === socket) {
+                this.client = null;
+                this.activeRoute = null;
+            }
+        });
+    }
+    handleData(data) {
+        this.buffer += data;
+        let idx;
+        while ((idx = this.buffer.indexOf('\n')) !== -1) {
+            const line = this.buffer.slice(0, idx);
+            this.buffer = this.buffer.slice(idx + 1);
+            if (!line)
+                continue;
+            let msg;
+            try {
+                msg = JSON.parse(line);
+            }
+            catch {
+                this.sendToClient({ type: 'error', message: 'invalid json' });
+                continue;
+            }
+            this.handleMessage(msg).catch((err) => {
+                logger.error('cmd channel server error handling message', err);
+                this.sendToClient({ type: 'error', message: err.message });
+            });
+        }
+    }
+    async handleMessage(msg) {
+        switch (msg.type) {
+            case 'hello':
+                this.sendToClient({
+                    type: 'channels',
+                    list: Array.from(this.channels.keys()).map((route) => ({ route })),
+                });
+                return;
+            case 'select':
+                if (!this.channels.has(msg.route)) {
+                    this.sendToClient({ type: 'error', message: `unknown route: ${msg.route}` });
+                    return;
+                }
+                this.activeRoute = msg.route;
+                this.sendToClient({ type: 'selected', route: msg.route });
+                return;
+            case 'message': {
+                if (!this.activeRoute) {
+                    this.sendToClient({ type: 'error', message: 'no channel selected' });
+                    return;
+                }
+                const handlers = this.channels.get(this.activeRoute);
+                if (!handlers) {
+                    this.sendToClient({ type: 'error', message: 'channel no longer available' });
+                    this.activeRoute = null;
+                    return;
+                }
+                await handlers.onMessage(msg.text, (reply) => {
+                    this.sendToClient({ type: 'reply', ...reply });
+                });
+                return;
+            }
+        }
+    }
+    sendToClient(msg) {
+        if (!this.client)
+            return;
+        this.send(this.client, msg);
+    }
+    send(socket, msg) {
+        socket.write(JSON.stringify(msg) + '\n');
+    }
+};
+CmdChannelServer = __decorate([
+    singleton()
+], CmdChannelServer);
+
+export { CmdChannelServer };

package/dist/src/addon/chat-controller/cmd/cmdChannelSocketPath.js

@@ -0,0 +1,16 @@
+import * as crypto from 'node:crypto';
+import * as path from 'node:path';
+
+function cmdChannelSocketPath() {
+    if (process.platform === 'win32') {
+        const cwdHash = crypto
+            .createHash('sha1')
+            .update(process.cwd())
+            .digest('hex')
+            .slice(0, 12);
+        return `\\\\.\\pipe\\wabot-cmd-channel-${cwdHash}`;
+    }
+    return path.resolve(process.cwd(), '.cmd-channel/socket');
+}
+
+export { cmdChannelSocketPath };

package/dist/src/addon/chat-controller/cmd/runCmdClient.js

@@ -0,0 +1,226 @@
+import * as net from 'node:net';
+import * as readline from 'node:readline';
+import { cmdChannelSocketPath } from './cmdChannelSocketPath.js';
+
+const useColor = process.stdout.isTTY && !process.env.NO_COLOR && process.env.TERM !== 'dumb';
+const ansi = (code) => (text) => useColor ? `\x1b[${code}m${text}\x1b[0m` : text;
+const bold = ansi('1');
+const dim = ansi('2');
+const cyan = ansi('1;36');
+const green = ansi('1;32');
+const greenText = ansi('32');
+const red = ansi('1;31');
+const yellow = ansi('33');
+const COMMANDS = ['/channels', '/help', '/exit'];
+const HELP_LINES = [
+    'Commands:',
+    '  /channels   list channels and switch',
+    '  /help       show this help',
+    '  /exit       quit',
+];
+const RECONNECT_DELAY_MS = 1000;
+function runCmdClient() {
+    const socketPath = cmdChannelSocketPath();
+    let socket = null;
+    let buffer = '';
+    let routes = [];
+    let state = 'disconnected';
+    let selected = null;
+    let reconnectTimer = null;
+    let waitingNoticeShown = false;
+    let exiting = false;
+    let restoring = false;
+    const completer = (line) => {
+        if (line.startsWith('/')) {
+            const hits = COMMANDS.filter((c) => c.startsWith(line));
+            return [hits.length > 0 ? hits : [...COMMANDS], line];
+        }
+        if (state === 'choosing') {
+            const hits = routes
+                .map((r) => r.route)
+                .filter((r) => r.toLowerCase().startsWith(line.toLowerCase()));
+            return [hits, line];
+        }
+        return [[], line];
+    };
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        completer,
+    });
+    const send = (msg) => {
+        if (!socket) {
+            process.stderr.write(red('not connected to framework — waiting for server...') + '\n');
+            rl.prompt();
+            return false;
+        }
+        socket.write(JSON.stringify(msg) + '\n');
+        return true;
+    };
+    const printChannels = (list) => {
+        routes = list;
+        if (list.length === 0) {
+            process.stdout.write(yellow('No cmd channels are registered on the server yet.') + '\n');
+            rl.prompt();
+            return;
+        }
+        if (list.length === 1) {
+            send({ type: 'select', route: list[0].route });
+            return;
+        }
+        process.stdout.write(bold('Available cmd channels:') + '\n');
+        list.forEach((entry, i) => {
+            const marker = entry.route === selected ? ' ' + yellow('(active)') : '';
+            process.stdout.write(`  ${dim(`${i + 1}.`)} ${cyan(entry.route)}${marker}\n`);
+        });
+        state = 'choosing';
+        rl.setPrompt(bold('select # ') + dim('> '));
+        rl.prompt();
+    };
+    const handleServerMessage = (msg) => {
+        switch (msg.type) {
+            case 'channels':
+                printChannels(msg.list);
+                return;
+            case 'selected':
+                selected = msg.route;
+                state = 'chatting';
+                if (!restoring) {
+                    process.stdout.write(green(`[connected to ${msg.route}]`) + '\n');
+                }
+                restoring = false;
+                rl.setPrompt(cyan(msg.route) + dim(' > '));
+                rl.prompt();
+                return;
+            case 'reply':
+                process.stdout.write(`\n${green(`[${msg.senderName ?? 'bot'}]:`)} ${greenText(msg.text)}\n\n`);
+                rl.prompt();
+                return;
+            case 'error':
+                process.stderr.write(red('error: ') + red(msg.message) + '\n');
+                rl.prompt();
+                return;
+        }
+    };
+    const scheduleReconnect = () => {
+        if (exiting || reconnectTimer)
+            return;
+        reconnectTimer = setTimeout(() => {
+            reconnectTimer = null;
+            connect();
+        }, RECONNECT_DELAY_MS);
+    };
+    const connect = () => {
+        if (exiting)
+            return;
+        buffer = '';
+        socket = net.connect(socketPath);
+        socket.on('connect', () => {
+            waitingNoticeShown = false;
+            // Silent reconnect when we're restoring a prior selection;
+            // otherwise announce the connection and ask for channels.
+            if (selected) {
+                restoring = true;
+                socket.write(JSON.stringify({ type: 'select', route: selected }) + '\n');
+                state = 'chatting';
+                rl.setPrompt(cyan(selected) + dim(' > '));
+                rl.prompt();
+            }
+            else {
+                process.stdout.write(green('[connected to framework]') + '\n');
+                socket.write(JSON.stringify({ type: 'hello' }) + '\n');
+            }
+        });
+        socket.on('data', (chunk) => {
+            buffer += chunk.toString();
+            let idx;
+            while ((idx = buffer.indexOf('\n')) !== -1) {
+                const line = buffer.slice(0, idx);
+                buffer = buffer.slice(idx + 1);
+                if (!line)
+                    continue;
+                try {
+                    handleServerMessage(JSON.parse(line));
+                }
+                catch (err) {
+                    process.stderr.write(red(`invalid server message: ${err.message}`) + '\n');
+                }
+            }
+        });
+        socket.on('error', (err) => {
+            const transient = err.code === 'ENOENT' ||
+                err.code === 'ECONNREFUSED' ||
+                err.code === 'ECONNRESET' ||
+                err.code === 'EPIPE';
+            if (!transient) {
+                process.stderr.write(red(`socket error: ${err.message}`) + '\n');
+            }
+        });
+        socket.on('close', () => {
+            const wasConnected = state !== 'disconnected';
+            state = 'disconnected';
+            socket = null;
+            if (exiting)
+                return;
+            if (wasConnected) {
+                process.stdout.write(yellow('\n[disconnected — waiting for framework to come back...]') + '\n');
+            }
+            else if (!waitingNoticeShown && !selected) {
+                waitingNoticeShown = true;
+                process.stdout.write(dim('Waiting for framework...') + '\n');
+            }
+            scheduleReconnect();
+        });
+    };
+    const cleanup = (code) => {
+        exiting = true;
+        if (reconnectTimer) {
+            clearTimeout(reconnectTimer);
+            reconnectTimer = null;
+        }
+        rl.close();
+        if (socket)
+            socket.end();
+        process.exit(code);
+    };
+    rl.on('line', (input) => {
+        const trimmed = input.trim();
+        if (!trimmed) {
+            rl.prompt();
+            return;
+        }
+        if (trimmed === '/exit' || trimmed.toLowerCase() === 'exit') {
+            cleanup(0);
+            return;
+        }
+        if (trimmed === '/help') {
+            process.stdout.write(HELP_LINES.join('\n') + '\n');
+            rl.prompt();
+            return;
+        }
+        if (trimmed === '/channels') {
+            send({ type: 'hello' });
+            return;
+        }
+        if (state === 'disconnected') {
+            process.stderr.write(red('not connected to framework — waiting for server...') + '\n');
+            rl.prompt();
+            return;
+        }
+        if (state === 'choosing') {
+            const num = Number.parseInt(trimmed, 10);
+            if (!Number.isInteger(num) || num < 1 || num > routes.length) {
+                process.stderr.write(red(`Invalid selection. Enter a number between 1 and ${routes.length}.`) + '\n');
+                rl.prompt();
+                return;
+            }
+            send({ type: 'select', route: routes[num - 1].route });
+            return;
+        }
+        send({ type: 'message', text: trimmed });
+    });
+    rl.on('close', () => cleanup(0));
+    connect();
+}
+
+export { runCmdClient };

package/dist/src/addon/chat-controller/socket/@socket.js

@@ -2,17 +2,19 @@ import { container } from '../../../core/injection/index.js';
 import { ControllerMetadataStore } from '../../../feature/chat-controller/metadata/ControllerMetadataStore.js';
 import '../../../feature/chat-controller/ChatResolver.js';
 import '../../../feature/chat-controller/runChatControllers.js';
+import { resolveConfigReferences } from '../../../core/config/resolver.js';
 import { SocketChannel } from './SocketChannel.js';
 import { SocketChannelConfig } from './SocketChannelConfig.js';
 
 function socket(config) {
     return function (target, propertyKey) {
+        const resolved = resolveConfigReferences(config);
         const store = container.resolve(ControllerMetadataStore);
         store.saveChannelMetadata({
             channelConstructor: SocketChannel,
             functionName: propertyKey.toString(),
             controllerConstructor: target.constructor,
-            channelConfig: new SocketChannelConfig(config.namespace, config.handshakeMidlewares),
+            channelConfig: new SocketChannelConfig(resolved),
         });
     };
 }

package/dist/src/addon/chat-controller/socket/SocketChannelConfig.js

@@ -4,14 +4,14 @@ import { injectable } from '../../../core/injection/index.js';
 let SocketChannelConfig = class SocketChannelConfig {
     namespace;
     handshakeMidlewares;
-    constructor(namespace, handshakeMidlewares) {
-        this.namespace = namespace;
-        this.handshakeMidlewares = handshakeMidlewares;
+    constructor(config) {
+        this.namespace = config.namespace;
+        this.handshakeMidlewares = config.handshakeMidlewares;
     }
 };
 SocketChannelConfig = __decorate([
     injectable(),
-    __metadata("design:paramtypes", [String, Array])
+    __metadata("design:paramtypes", [Object])
 ], SocketChannelConfig);
 
 export { SocketChannelConfig };

package/dist/src/addon/chat-controller/whatsapp/WhatsAppSender.js

@@ -1,80 +1,10 @@
-import '../../../feature/chat-bot/ChatAdapterRegistry.js';
-import '../../../feature/chat-bot/ChatBot.js';
-import { ChatItem } from '../../../feature/chat-bot/ChatItem.js';
-import '../../../feature/chat-bot/ChatOperator.js';
-import '../../../feature/chat-bot/UnionChatAdapter.js';
-import '../../../core/injection/index.js';
-import '../../../feature/chat-bot/metadata/ChatAdapterMetadataStore.js';
-import 'uuid';
-import '../../../feature/chat-bot/metadata/ChatBotMetadataStore.js';
-import '../../../core/error/setupErrorHandlers.js';
-
 class WhatsAppSender {
-    chatRepository;
-    chatResolver;
-    whatsAppRepository;
-    constructor(chatRepository, chatResolver, whatsAppRepository) {
-        this.chatRepository = chatRepository;
-        this.chatResolver = chatResolver;
-        this.whatsAppRepository = whatsAppRepository;
-    }
-    async sendWhatsApp(request, options) {
-        throw new Error('Not implemented');
-    }
-    async sendWhatsAppTemplate(request, options) {
+    async sendMessage(request) {
         throw new Error('Not implemented');
     }
-    getWhatsAppTemplate(request) {
+    async sendTemplate(request) {
         throw new Error('Not implemented');
     }
-    async mapTemplateToChatMessage(request) {
-        const template = await this.getWhatsAppTemplate({
-            from: request.from,
-            templateName: request.templateMessage.templateName,
-            languageCode: request.templateMessage.languageCode,
-        });
-        if (!template) {
-            throw new Error(`WhatsAppTemplate with name ${request.templateMessage.templateName} and language ${request.templateMessage.languageCode} not found`);
-        }
-        const components = template.components
-            .filter((x) => x.text != null)
-            .map((x) => x.text)
-            .join('\n');
-        return {
-            text: this.replaceTemplateParameters(components, request.templateMessage.parameters),
-            senderName: request.senderName,
-        };
-    }
-    async writePrivateChatMemory(message, to) {
-        const chatConnection = {
-            id: to,
-            chatType: 'PRIVATE',
-            channelName: 'WhatsAppChannel',
-        };
-        const chat = await this.chatResolver.resolve(chatConnection);
-        const chatMemory = await this.chatRepository.findMemory(chat.id);
-        const chatItem = new ChatItem({
-            type: 'botMessage',
-            botMessage: message,
-        });
-        await chatMemory.create(chatItem);
-    }
-    replaceTemplateParameters(template, data) {
-        let result = template;
-        data.forEach((param) => {
-            if (param.type === 'text' && param.parameter_name) {
-                const tag = `{{${param.parameter_name}}}`;
-                result = result.split(tag).join(param.text);
-            }
-        });
-        data.forEach((param, index) => {
-            if (param.type === 'text') {
-                const tag = `{{${index + 1}}}`;
-                result = result.split(tag).join(param.text);
-            }
-        });
-        return result;
-    }
 }
 
 export { WhatsAppSender };

package/dist/src/addon/chat-controller/whatsapp/{WhatsAppReceiver.js → cloud-api/WhatsAppApiReceiver.js}

@@ -1,4 +1,4 @@
-class WhatsAppReceiver {
+class WhatsAppApiReceiver {
     connect() {
         throw new Error('Not Implemented');
     }
@@ -10,4 +10,4 @@ class WhatsAppReceiver {
     }
 }
 
-export { WhatsAppReceiver };
+export { WhatsAppApiReceiver };

package/dist/src/addon/chat-controller/whatsapp/cloud-api/WhatsAppApiSender.js

@@ -0,0 +1,67 @@
+class WhatsAppApiSender {
+    accessToken;
+    businessNumberId;
+    constructor(accessToken, businessNumberId) {
+        this.accessToken = accessToken;
+        this.businessNumberId = businessNumberId;
+    }
+    async sendMessage(request) {
+        const url = `https://graph.facebook.com/v23.0/${this.businessNumberId}/messages`;
+        const payload = {
+            messaging_product: 'whatsapp',
+            recipient_type: 'individual',
+            to: request.to,
+            type: 'text',
+            text: {
+                preview_url: false,
+                body: request.message.text ?? '',
+            },
+        };
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${this.accessToken}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(payload),
+        });
+        const data = await response.json();
+        if (!response.ok) {
+            throw new Error(JSON.stringify(data));
+        }
+    }
+    async sendTemplate(request) {
+        const payload = {
+            messaging_product: 'whatsapp',
+            recipient_type: 'individual',
+            to: request.to,
+            type: 'template',
+            template: {
+                name: request.templateData.templateName,
+                language: {
+                    code: request.templateData.languageCode,
+                },
+                components: [
+                    {
+                        type: 'body',
+                        parameters: request.templateData.parameters,
+                    },
+                ],
+            },
+        };
+        const response = await fetch(`https://graph.facebook.com/v23.0/${this.businessNumberId}/messages`, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${this.accessToken}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(payload),
+        });
+        const data = await response.json();
+        if (!response.ok) {
+            throw new Error(JSON.stringify(data));
+        }
+    }
+}
+
+export { WhatsAppApiSender };

package/dist/src/addon/chat-controller/whatsapp/cloud-api/WhatsAppReceiverByCloudApi.js

@@ -1,19 +1,17 @@
 import { Logger } from '../../../../core/logger/Logger.js';
-import { whatsAppChannelName } from '../whatsAppChannelName.js';
+import { whatsAppChannelName } from './whatsAppChannelName.js';
 import { json } from 'express';
-import { WhatsAppReceiver } from '../WhatsAppReceiver.js';
+import { WhatsAppApiReceiver } from './WhatsAppApiReceiver.js';
 
-class WhatsAppReceiverByCloudApi extends WhatsAppReceiver {
+class WhatsAppReceiverByCloudApi extends WhatsAppApiReceiver {
     expressProvider;
-    whatsAppRepository;
     listeners = new Map();
     expressApp;
     logger = new Logger('wabot:whatsapp-receiver-by-webhook');
     webhookPath = '/whatsapp/web-hook/:slug';
-    constructor(expressProvider, whatsAppRepository) {
+    constructor(expressProvider) {
         super();
         this.expressProvider = expressProvider;
-        this.whatsAppRepository = whatsAppRepository;
         this.expressApp = this.expressProvider.getExpress();
     }
     async connect() {
@@ -26,7 +24,7 @@ class WhatsAppReceiverByCloudApi extends WhatsAppReceiver {
                     res.sendStatus(400);
                     return;
                 }
-                const whatsApp = await this.whatsAppRepository.findBySlug(req.params.slug);
+                const whatsApp = 5; // TODO: await this.whatsAppRepository.findBySlug(req.params.slug)
                 if (!whatsApp || mode !== 'subscribe' || token !== whatsApp.getVerifyToken()) {
                     res.sendStatus(403);
                     return;

package/dist/src/addon/chat-controller/whatsapp/wasender/@wasender.js

@@ -0,0 +1,23 @@
+import { container } from '../../../../core/injection/index.js';
+import { resolveConfigReferences } from '../../../../core/config/resolver.js';
+import { WasenderChannelConfig } from './WasenderChannelConfig.js';
+import { ControllerMetadataStore } from '../../../../feature/chat-controller/metadata/ControllerMetadataStore.js';
+import '../../../../feature/chat-controller/ChatResolver.js';
+import '../../../../feature/chat-controller/runChatControllers.js';
+import { WasenderChannel } from './WasenderChannel.js';
+
+function wasender(config) {
+    return function (target, propertyKey) {
+        const cfg = config ?? {};
+        const resolvedConfig = resolveConfigReferences(cfg);
+        const store = container.resolve(ControllerMetadataStore);
+        store.saveChannelMetadata({
+            channelConstructor: WasenderChannel,
+            functionName: propertyKey.toString(),
+            controllerConstructor: target.constructor,
+            channelConfig: new WasenderChannelConfig(resolvedConfig),
+        });
+    };
+}
+
+export { wasender };