alemonjs 2.1.4 → 2.1.6

package/lib/adapter.js

@@ -0,0 +1,111 @@
+import { fork } from 'child_process';
+import { createRequire } from 'module';
+
+const require = createRequire(import.meta.url);
+/**
+ * 启动平台平台连接，优先使用子进程（fork），如不支持或平台连接未响应，则自动降级为 import 动态加载。
+ * 自动兼容新老版本平台连接。
+ * @param modulePath 平台连接模块绝对路径（require.resolve 得到的）
+ * @param env 环境变量对象
+ * @param logger 日志对象（需实现 info/warn/error）
+ */
+function startAdapterWithFallback() {
+    let modulePath = '';
+    try {
+        modulePath = require.resolve(process.env.platform);
+    }
+    catch {
+        void import(process.env.platform).then(res => res?.default());
+        return;
+    }
+    let imported = false; // 标记 import 是否已成功，避免重复
+    const startByFork = () => {
+        if (imported) {
+            return; // 如果已经 import 成功，不再 fork
+        }
+        let restarted = false;
+        let ready = false;
+        let child;
+        const restart = () => {
+            if (restarted || imported) {
+                return;
+            }
+            restarted = true;
+            if (child) {
+                child.removeAllListeners();
+                try {
+                    child.kill();
+                }
+                catch { }
+            }
+            setTimeout(() => {
+                startByFork();
+            }, 3000);
+        };
+        try {
+            child = fork(modulePath);
+            // 超时
+            const checkTimeout = async () => {
+                if (!ready && !imported) {
+                    logger?.warn?.('平台连接未及时响应（未发送 ready 消息），降级为 import 加载');
+                    try {
+                        child?.kill();
+                    }
+                    catch { }
+                    await startByImport();
+                }
+            };
+            const timer = setTimeout(() => void checkTimeout(), 2000);
+            child.on('exit', (code, signal) => {
+                clearTimeout(timer);
+                if (!imported) {
+                    logger?.warn?.(`平台连接子进程已退出，code=${code}, signal=${signal}，3秒后自动重启`);
+                    restart();
+                }
+            });
+            child.on('message', msg => {
+                try {
+                    const data = typeof msg === 'string' ? JSON.parse(msg) : msg;
+                    if (data?.type === 'ready') {
+                        ready = true;
+                        clearTimeout(timer);
+                        logger?.info?.('平台连接已就绪（子进程 fork 模式）');
+                    }
+                }
+                catch (err) {
+                    logger?.error?.('平台连接进程通信数据格式错误', err);
+                }
+            });
+        }
+        catch (err) {
+            logger?.warn?.('fork 启动平台连接失败，将尝试 import 加载', err);
+            void startByImport();
+        }
+    };
+    const startByImport = async () => {
+        if (imported) {
+            return;
+        }
+        imported = true;
+        try {
+            let importPath = modulePath;
+            if (!importPath.startsWith('file://')) {
+                importPath = 'file://' + importPath;
+            }
+            const mod = await import(importPath);
+            if (typeof mod.default === 'function') {
+                await mod.default();
+                logger?.info?.('通过 import 启动平台连接完成');
+            }
+            else {
+                logger?.warn?.('通过 import 启动平台连接，但未找到默认导出函数');
+            }
+        }
+        catch (err) {
+            logger?.error?.('import 启动平台连接失败', err);
+        }
+    };
+    startByFork();
+}
+
+export { startAdapterWithFallback };

package/lib/app/load.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 加载子模块
+ * @param mainPath
+ * @param appName
+ * @throws {Error} - 如果 mainPath 无效，抛出错误。
+ */
+declare const loadChildren: (mainPath: string, appName: string) => Promise<void>;
+/**
+ * 模块文件
+ * @param app
+ */
+declare const loadChildrenFile: (appName: string) => Promise<void>;
+
+export { loadChildren, loadChildrenFile };

package/lib/app/load.js

@@ -0,0 +1,167 @@
+import { dirname, join } from 'path';
+import { existsSync } from 'fs';
+import { showErrorModule, getRecursiveDirFiles, createEventName } from '../core/utils.js';
+import { createRequire } from 'module';
+import { ChildrenApp } from './store.js';
+import { ResultCode, fileSuffixMiddleware } from '../core/variable.js';
+
+const require = createRequire(import.meta.url);
+/**
+ * 加载子模块
+ * @param mainPath
+ * @param appName
+ * @throws {Error} - 如果 mainPath 无效，抛出错误。
+ */
+const loadChildren = async (mainPath, appName) => {
+    if (!mainPath || typeof mainPath !== 'string') {
+        logger.error({
+            code: ResultCode.FailParams,
+            message: 'The module path is not correct',
+            data: null
+        });
+        return;
+    }
+    const mainDir = dirname(mainPath);
+    const App = new ChildrenApp(appName);
+    try {
+        const moduleApp = await import(`file://${mainPath}`);
+        if (!moduleApp?.default) {
+            throw new Error('The Children is not default');
+        }
+        if (!moduleApp?.default?._name) {
+            throw new Error('The Children name is not correct');
+        }
+        if (moduleApp.default._name !== 'app') {
+            throw new Error('The Children name is not correct');
+        }
+        if (!moduleApp?.default?.callback) {
+            throw new Error('The Children callback is not correct');
+        }
+        let app = null;
+        if (typeof moduleApp?.default?.callback !== 'function') {
+            app = moduleApp?.default.callback;
+        }
+        else {
+            app = await moduleApp.default.callback();
+        }
+        App.pushSycle(app);
+        const unMounted = async (e) => {
+            showErrorModule(e);
+            // 卸载
+            App.un();
+            try {
+                app?.unMounted && (await app.unMounted(e));
+            }
+            catch (e) {
+                // 卸载周期出意外，不需要进行卸载
+                showErrorModule(e);
+            }
+        };
+        // onCreated 创建
+        try {
+            app?.onCreated && (await app?.onCreated());
+        }
+        catch (e) {
+            unMounted(e);
+            // 出错了，结束后续的操作。
+            return;
+        }
+        // onMounted 加载
+        try {
+            /**
+             * load response files
+             */
+            const appsDir = join(mainDir, 'apps');
+            const appsFiles = getRecursiveDirFiles(appsDir);
+            // 使用 新 目录 response
+            const responseDir = join(mainDir, 'response');
+            const responseFiles = getRecursiveDirFiles(responseDir);
+            const files = [...appsFiles, ...responseFiles];
+            const resData = [];
+            for (const file of files) {
+                // 切掉 mainDir
+                const url = file.path.replace(mainDir, '');
+                const stateKey = createEventName(url, appName);
+                const reesponse = {
+                    input: mainDir,
+                    dir: dirname(file.path),
+                    path: file.path,
+                    name: file.name,
+                    stateKey,
+                    appName: appName
+                };
+                resData.push(reesponse);
+            }
+            App.pushResponse(resData);
+            /**
+             * load middleware files
+             */
+            const mwDir = join(mainDir, 'middleware');
+            const mwFiles = getRecursiveDirFiles(mwDir, item => fileSuffixMiddleware.test(item.name));
+            const mwData = [];
+            for (const file of mwFiles) {
+                // 切掉 mainDir
+                const url = file.path.replace(mainDir, '');
+                const stateKey = createEventName(url, appName);
+                const middleware = {
+                    input: mainDir,
+                    dir: dirname(file.path),
+                    path: file.path,
+                    name: file.name,
+                    stateKey,
+                    appName: appName
+                };
+                mwData.push(middleware);
+            }
+            App.pushMiddleware(mwData);
+            App.on();
+            try {
+                app?.onMounted && (await app.onMounted({ response: resData, middleware: mwData }));
+            }
+            catch (e) {
+                unMounted(e);
+            }
+        }
+        catch (e) {
+            unMounted(e);
+        }
+        // unMounted 卸载
+    }
+    catch (e) {
+        showErrorModule(e);
+        // 卸载
+        App.un();
+    }
+};
+/**
+ * 模块文件
+ * @param app
+ */
+const loadChildrenFile = async (appName) => {
+    if (typeof appName !== 'string') {
+        logger.error({
+            code: ResultCode.FailParams,
+            message: 'The module name is not correct',
+            data: null
+        });
+        return;
+    }
+    try {
+        const mainPath = require.resolve(appName);
+        // 不存在 main
+        if (!existsSync(mainPath)) {
+            logger.error({
+                code: ResultCode.FailParams,
+                message: 'The main file does not exist,' + mainPath,
+                data: null
+            });
+            return;
+        }
+        loadChildren(mainPath, appName);
+    }
+    catch (e) {
+        showErrorModule(e);
+    }
+};
+
+export { loadChildren, loadChildrenFile };

package/lib/app/store.js

@@ -3,6 +3,17 @@ import { mkdirSync } from 'node:fs';
 import log4js from 'log4js';
 
 const createLogger = () => {
+    if (process.env.BROWSER_ENV === 'browser') {
+        return {
+            trace: console.trace.bind(console),
+            debug: console.debug.bind(console),
+            info: console.info.bind(console),
+            mark: console.info.bind(console),
+            warn: console.warn.bind(console),
+            error: console.error.bind(console),
+            fatal: console.error.bind(console)
+        };
+    }
     const logDir = process.env?.LOG_PATH ?? `./logs/${process.env.LOG_NAME ?? ''}`;
     mkdirSync(logDir, { recursive: true });
     const level = process.env.NODE_ENV === 'development' ? 'trace' : 'info';

package/lib/cbp/actions.js

@@ -0,0 +1,48 @@
+import { ResultCode } from '../core/variable.js';
+import { createResult } from '../core/utils.js';
+import { generateUniqueId, deviceId, actionResolves, actionTimeouts, timeoutTime } from './config.js';
+import * as flattedJSON from 'flatted';
+
+/**
+ * 发送行为
+ * @param data
+ */
+const sendAction = (data) => {
+    const actionId = generateUniqueId();
+    return new Promise(resolve => {
+        // 设置唯一标识符
+        data.actionId = actionId;
+        // 设置设备 ID
+        data.DeviceId = deviceId;
+        // 沙盒模式
+        if (global.sandbox) {
+            if (!global.testoneClient) {
+                return resolve([createResult(ResultCode.Fail, '未连接到客户端', null)]);
+            }
+            // 发送消息
+            global.testoneClient.send(flattedJSON.stringify(data));
+        }
+        else {
+            global.chatbotClient.send(flattedJSON.stringify(data));
+        }
+        // 设置回调函数
+        actionResolves.set(actionId, resolve);
+        // 超时
+        const timeout = setTimeout(() => {
+            // 被清理了
+            if (!actionResolves.has(actionId) || !actionTimeouts.has(actionId)) {
+                return;
+            }
+            // 删除回调
+            actionResolves.delete(actionId);
+            // 删除超时器
+            actionTimeouts.delete(actionId);
+            // 不会当错误进行处理。而是传入错误码
+            resolve([createResult(ResultCode.Fail, '行为超时', null)]);
+        }, timeoutTime);
+        // 设置超时
+        actionTimeouts.set(actionId, timeout);
+    });
+};
+
+export { sendAction };

package/lib/cbp/api.js

@@ -0,0 +1,48 @@
+import { ResultCode } from '../core/variable.js';
+import { createResult } from '../core/utils.js';
+import { generateUniqueId, deviceId, apiResolves, apiTimeouts, timeoutTime } from './config.js';
+import * as flattedJSON from 'flatted';
+
+/**
+ * 发送行为
+ * @param data
+ */
+const sendAPI = (data) => {
+    const ApiId = generateUniqueId();
+    return new Promise(resolve => {
+        // 设置唯一标识符
+        data.apiId = ApiId;
+        // 设置设备 ID
+        data.DeviceId = deviceId;
+        // 沙盒模式
+        if (global.sandbox) {
+            if (!global.testoneClient) {
+                return resolve([createResult(ResultCode.Fail, '未连接到客户端', null)]);
+            }
+            // 发送消息
+            global.testoneClient.send(flattedJSON.stringify(data));
+        }
+        else {
+            // 发送消息
+            global.chatbotClient.send(flattedJSON.stringify(data));
+        }
+        apiResolves.set(ApiId, resolve);
+        // 超时
+        const timeout = setTimeout(() => {
+            // 被清理了
+            if (!apiResolves.has(ApiId) || !apiTimeouts.has(ApiId)) {
+                return;
+            }
+            // 删除回调
+            apiResolves.delete(ApiId);
+            // 删除超时器
+            apiTimeouts.delete(ApiId);
+            // 不会当错误进行处理。而是传入错误码
+            resolve([createResult(ResultCode.Fail, '接口超时', null)]);
+        }, timeoutTime);
+        // 设置超时
+        apiTimeouts.set(ApiId, timeout);
+    });
+};
+
+export { sendAPI };

package/lib/cbp/client.d.ts

@@ -0,0 +1,10 @@
+import { CBPClientOptions } from './typings.js';
+
+/**
+ * CBP 客户端
+ * @param url
+ * @param onopen
+ */
+declare const cbpClient: (url: string, options?: CBPClientOptions) => void;
+
+export { cbpClient };

package/lib/cbp/client.js

@@ -0,0 +1,159 @@
+import { WebSocket } from 'ws';
+import { onProcessor } from '../app/event-processor.js';
+import { ResultCode } from '../core/variable.js';
+import { deviceId, FULL_RECEIVE_HEADER, DEVICE_ID_HEADER, USER_AGENT_HEADER, apiResolves, apiTimeouts, actionResolves, actionTimeouts, reconnectInterval } from './config.js';
+import { createResult } from '../core/utils.js';
+import * as flattedJSON from 'flatted';
+import { useHeartbeat } from './connect.js';
+
+/**
+ * CBP 客户端
+ * @param url
+ * @param onopen
+ */
+const cbpClient = (url, options = {}) => {
+    /**
+     * 纯 cbpClient 连接，会没有 一些 全局变量。
+     * 需要在此处进行判断并设置
+     */
+    if (global.chatbotClient) {
+        delete global.chatbotClient;
+    }
+    const { open = () => { }, isFullReceive = true } = options;
+    const [heartbeatControl] = useHeartbeat({
+        ping: () => {
+            global?.chatbotClient?.ping?.();
+        },
+        isConnected: () => {
+            return global?.chatbotClient && global?.chatbotClient?.readyState === WebSocket.OPEN;
+        },
+        terminate: () => {
+            try {
+                // 强制断开连接
+                global?.chatbotClient?.terminate?.();
+            }
+            catch (error) {
+                logger.debug({
+                    code: ResultCode.Fail,
+                    message: '强制断开连接失败',
+                    data: error
+                });
+            }
+        }
+    });
+    const start = () => {
+        global.chatbotClient = new WebSocket(url, {
+            headers: {
+                [USER_AGENT_HEADER]: 'client',
+                [DEVICE_ID_HEADER]: deviceId,
+                [FULL_RECEIVE_HEADER]: isFullReceive ? '1' : '0'
+            }
+        });
+        global.chatbotClient.on('open', () => {
+            open();
+            heartbeatControl.start(); // 启动心跳
+        });
+        global.chatbotClient.on('pong', () => {
+            heartbeatControl.pong(); // 更新 pong 时间
+        });
+        // 客户端接收，被标准化的平台消息
+        global.chatbotClient.on('message', message => {
+            try {
+                // 解析消息
+                const parsedMessage = flattedJSON.parse(message.toString());
+                logger.debug({
+                    code: ResultCode.Ok,
+                    message: '客户端接收到消息',
+                    data: parsedMessage
+                });
+                if (parsedMessage?.activeId) {
+                    // 主端端主动消息。
+                    if (parsedMessage.active === 'sync') {
+                        const configs = parsedMessage.payload;
+                        // env 同步
+                        const env = configs.env || {};
+                        for (const key in env) {
+                            process.env[key] = env[key];
+                        }
+                    }
+                }
+                else if (parsedMessage?.apiId) {
+                    // 如果有 apiId，说明是一个接口请求。要进行处理
+                    const resolve = apiResolves.get(parsedMessage.apiId);
+                    if (resolve) {
+                        apiResolves.delete(parsedMessage.apiId);
+                        // 清除超时器
+                        const timeout = apiTimeouts.get(parsedMessage.apiId);
+                        if (timeout) {
+                            apiTimeouts.delete(parsedMessage.apiId);
+                            clearTimeout(timeout);
+                        }
+                        // 调用回调函数
+                        if (Array.isArray(parsedMessage.payload)) {
+                            resolve(parsedMessage.payload);
+                        }
+                        else {
+                            // 错误处理
+                            resolve([createResult(ResultCode.Fail, '接口处理错误', null)]);
+                        }
+                    }
+                }
+                else if (parsedMessage?.actionId) {
+                    // 如果有 actionId
+                    const resolve = actionResolves.get(parsedMessage.actionId);
+                    if (resolve) {
+                        actionResolves.delete(parsedMessage.actionId);
+                        // 清除超时器
+                        const timeout = actionTimeouts.get(parsedMessage.actionId);
+                        if (timeout) {
+                            actionTimeouts.delete(parsedMessage.actionId);
+                            clearTimeout(timeout);
+                        }
+                        // 调用回调函数
+                        if (Array.isArray(parsedMessage.payload)) {
+                            resolve(parsedMessage.payload);
+                        }
+                        else {
+                            // 错误处理
+                            resolve([createResult(ResultCode.Fail, '消费处理错误', null)]);
+                        }
+                    }
+                }
+                else if (parsedMessage.name) {
+                    // 如果有 name，说明是一个事件请求。要进行处理
+                    onProcessor(parsedMessage.name, parsedMessage, parsedMessage.value);
+                }
+            }
+            catch (error) {
+                logger.error({
+                    code: ResultCode.Fail,
+                    message: '客户端解析消息失败',
+                    data: error
+                });
+            }
+        });
+        global.chatbotClient.on('close', () => {
+            heartbeatControl.stop(); // 停止心跳
+            logger.warn({
+                code: ResultCode.Fail,
+                message: '连接关闭，尝试重新连接...',
+                data: null
+            });
+            delete global.chatbotClient;
+            // 重新连接逻辑
+            setTimeout(() => {
+                start(); // 重新连接
+            }, reconnectInterval); // 6秒后重连
+        });
+        global.chatbotClient.on('error', err => {
+            logger.error({
+                code: ResultCode.Fail,
+                message: '客户端错误',
+                data: err
+            });
+        });
+    };
+    start();
+};
+
+export { cbpClient };

package/lib/cbp/config.js

@@ -0,0 +1,43 @@
+import { v4 } from 'uuid';
+
+// 子客户端
+const childrenClient = new Map();
+// 平台客户端
+const platformClient = new Map();
+// 全量客户端
+const fullClient = new Map();
+const deviceId = v4();
+// 连接类型
+const USER_AGENT_HEADER = 'user-agent';
+//
+const USER_AGENT_HEADER_VALUE_MAP = {
+    platform: 'platform',
+    client: 'client',
+    testone: 'testone'
+};
+// 设备 ID
+const DEVICE_ID_HEADER = 'x-device-id';
+// 是否全量接收
+const FULL_RECEIVE_HEADER = 'x-full-receive';
+// 行为回调
+const actionResolves = new Map();
+// 接口回调
+const apiResolves = new Map();
+// 超时器
+const actionTimeouts = new Map();
+// 接口超时器
+const apiTimeouts = new Map();
+// 分配绑定记录
+const childrenBind = new Map();
+// 生成唯一标识符
+const generateUniqueId = () => {
+    return Date.now().toString(36) + Math.random().toString(36).substring(2);
+};
+// 超时时间
+const timeoutTime = 1000 * 60 * 3; // 3分钟
+// 失败重连
+const reconnectInterval = 1000 * 6; // 6秒
+// 心跳间隔
+const HEARTBEAT_INTERVAL = 1000 * 18; // 18秒
+
+export { DEVICE_ID_HEADER, FULL_RECEIVE_HEADER, HEARTBEAT_INTERVAL, USER_AGENT_HEADER, USER_AGENT_HEADER_VALUE_MAP, actionResolves, actionTimeouts, apiResolves, apiTimeouts, childrenBind, childrenClient, deviceId, fullClient, generateUniqueId, platformClient, reconnectInterval, timeoutTime };

package/lib/cbp/connect.d.ts

@@ -0,0 +1,27 @@
+import { Actions } from '../typing/actions.js';
+import { EventsEnum } from '../typing/event/map.js';
+import { Result } from '../core/utils.js';
+import '../global.js';
+import { Apis } from '../typing/apis.js';
+
+type CBPClientOptions = {
+    open?: () => void;
+    isFullReceive?: boolean;
+};
+/**
+ * CBP 客户端
+ * @param url
+ * @param onopen
+ */
+declare const cbpClient: (url: string, options?: CBPClientOptions) => void;
+type ActionReplyFunc = (data: Actions, consume: (payload: Result[]) => void) => void;
+type ApiReplyFunc = (data: Apis, consume: (payload: Result[]) => void) => void;
+declare const cbpPlatform: (url: string, options?: {
+    open: () => void;
+}) => {
+    send: (data: EventsEnum) => void;
+    onactions: (reply: ActionReplyFunc) => void;
+    onapis: (reply: ApiReplyFunc) => void;
+};
+
+export { cbpClient, cbpPlatform };