alemonjs 2.1.28 → 2.1.30-rc.0

package/README_CONFIG.md

@@ -4,8 +4,8 @@
 
 ```yaml
 # === 服务器配置 ===
-port: 17117 # CBP服务器端口，快捷参数 --port
-serverPort: 18110 # 应用服务器端口（可选，仅在需要Web服务时设置）
+port: 17117 # CBP Websocket 端口 （可选，将允许外部客户端互动）
+serverPort: 18110 # Koa 服务器端口（可选，仅在需要Web服务时设置）
 
 # === 应用配置 ===
 input: 'lib/index.js' # 应用入口文件路径，快捷参数 --input

package/lib/app/message-format-old.js

@@ -119,9 +119,9 @@ Markdown.text = (text) => {
 Markdown.mention = (uid, options) => {
     return {
         type: 'MD.mention',
-        value: uid || '',
+        value: uid || 'everyone',
         options: options ?? {
-            belong: 'all'
+            belong: 'user'
         }
     };
 };

package/lib/cbp/connects/client.js

@@ -18,9 +18,101 @@ import '../../app/message-api.js';
 import '../../app/message-format-old.js';
 import { apiResolves, apiTimeouts, actionResolves, actionTimeouts, FULL_RECEIVE_HEADER } from '../processor/config.js';
 import { createWSConnector } from './base.js';
+import { setDirectSend } from '../processor/transport.js';
+import { createDirectServer } from '../../process/direct-channel.js';
 
+const handleParsedMessage = (parsedMessage) => {
+    if (parsedMessage?.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) {
+        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) {
+        onProcessor(parsedMessage.name, parsedMessage, parsedMessage.value);
+    }
+};
+const cbpClientDirect = (sockPath, open) => {
+    createDirectServer(sockPath, (data) => {
+        handleParsedMessage(data);
+    }).then((channel) => {
+        setDirectSend(channel.send);
+        open();
+        logger.debug({
+            code: ResultCode.Ok,
+            message: '客户端已启用直连通道模式（Unix Domain Socket）',
+            data: null
+        });
+    }).catch((err) => {
+        logger.error({
+            code: ResultCode.Fail,
+            message: '客户端直连通道建立失败，回退 fork IPC',
+            data: err
+        });
+        cbpClientIPC(open);
+    });
+};
+const cbpClientIPC = (open) => {
+    process.on('message', (message) => {
+        try {
+            const msg = typeof message === 'string' ? JSON.parse(message) : message;
+            if (msg?.type === 'ipc:data') {
+                handleParsedMessage(msg.data);
+            }
+        }
+        catch (error) {
+            logger.error({
+                code: ResultCode.Fail,
+                message: 'IPC 客户端解析消息失败',
+                data: error
+            });
+        }
+    });
+    open();
+    logger.debug({
+        code: ResultCode.Ok,
+        message: '客户端已启用 IPC 极速通讯模式',
+        data: null
+    });
+};
 const cbpClient = (url, options = {}) => {
     const { open = () => { }, isFullReceive = true } = options;
+    if (process.env.__ALEMON_DIRECT_SOCK && typeof process.send === 'function') {
+        cbpClientDirect(process.env.__ALEMON_DIRECT_SOCK, open);
+        return;
+    }
+    if (process.env.__ALEMON_IPC === '1' && typeof process.send === 'function') {
+        cbpClientIPC(open);
+        return;
+    }
     createWSConnector({
         url,
         role: 'client',
@@ -41,42 +133,8 @@ const cbpClient = (url, options = {}) => {
                         }
                     }
                 }
-                else if (parsedMessage?.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) {
-                    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) {
-                    onProcessor(parsedMessage.name, parsedMessage, parsedMessage.value);
+                else {
+                    handleParsedMessage(parsedMessage);
                 }
             }
             catch (error) {

package/lib/cbp/connects/platform.js

@@ -7,11 +7,165 @@ import 'path';
 import 'yaml';
 import '../../core/utils.js';
 import { createWSConnector } from './base.js';
+import { createDirectClient } from '../../process/direct-channel.js';
 
+const cbpPlatformDirect = (sockPath, open) => {
+    const actionReplys = [];
+    const apiReplys = [];
+    let channel = null;
+    const pendingQueue = [];
+    const send = (data) => {
+        data.DeviceId = deviceId;
+        if (channel) {
+            channel.send(data);
+        }
+        else {
+            pendingQueue.push({ ...data });
+        }
+    };
+    const replyAction = (data, payload) => {
+        channel?.send({
+            action: data.action,
+            payload: payload,
+            actionId: data.actionId,
+            DeviceId: data.DeviceId
+        });
+    };
+    const replyApi = (data, payload) => {
+        channel?.send({
+            action: data.action,
+            apiId: data.apiId,
+            DeviceId: data.DeviceId,
+            payload: payload
+        });
+    };
+    const onactions = (reply) => {
+        actionReplys.push(reply);
+    };
+    const onapis = (reply) => {
+        apiReplys.push(reply);
+    };
+    createDirectClient(sockPath, (data) => {
+        if (data?.apiId) {
+            for (const cb of apiReplys) {
+                void cb(data, val => replyApi(data, val));
+            }
+        }
+        else if (data?.actionId) {
+            for (const cb of actionReplys) {
+                void cb(data, val => replyAction(data, val));
+            }
+        }
+    }).then((ch) => {
+        channel = ch;
+        for (const msg of pendingQueue) {
+            channel.send(msg);
+        }
+        pendingQueue.length = 0;
+        open();
+        logger.debug({
+            code: ResultCode.Ok,
+            message: '平台端已启用直连通道模式（Unix Domain Socket）',
+            data: null
+        });
+    }).catch((err) => {
+        logger.error({
+            code: ResultCode.Fail,
+            message: '平台端直连通道建立失败，回退 fork IPC',
+            data: err
+        });
+        cbpPlatformIPC(open, actionReplys, apiReplys);
+    });
+    return { send, onactions, onapis };
+};
+const cbpPlatformIPC = (open, existingActionReplys, existingApiReplys) => {
+    const actionReplys = existingActionReplys ?? [];
+    const apiReplys = existingApiReplys ?? [];
+    const send = (data) => {
+        if (typeof process.send === 'function') {
+            data.DeviceId = deviceId;
+            process.send({ type: 'ipc:data', data });
+        }
+    };
+    const replyAction = (data, payload) => {
+        if (typeof process.send === 'function') {
+            process.send({
+                type: 'ipc:data',
+                data: {
+                    action: data.action,
+                    payload: payload,
+                    actionId: data.actionId,
+                    DeviceId: data.DeviceId
+                }
+            });
+        }
+    };
+    const replyApi = (data, payload) => {
+        if (typeof process.send === 'function') {
+            process.send({
+                type: 'ipc:data',
+                data: {
+                    action: data.action,
+                    apiId: data.apiId,
+                    DeviceId: data.DeviceId,
+                    payload: payload
+                }
+            });
+        }
+    };
+    const onactions = (reply) => {
+        actionReplys.push(reply);
+    };
+    const onapis = (reply) => {
+        apiReplys.push(reply);
+    };
+    process.on('message', (message) => {
+        try {
+            const msg = typeof message === 'string' ? JSON.parse(message) : message;
+            if (msg?.type === 'ipc:data') {
+                const data = msg.data;
+                if (data?.apiId) {
+                    for (const cb of apiReplys) {
+                        void cb(data, val => replyApi(data, val));
+                    }
+                }
+                else if (data?.actionId) {
+                    for (const cb of actionReplys) {
+                        void cb(data, val => replyAction(data, val));
+                    }
+                }
+            }
+        }
+        catch (error) {
+            logger.error({
+                code: ResultCode.Fail,
+                message: 'IPC 平台端解析消息失败',
+                data: error
+            });
+        }
+    });
+    open();
+    logger.debug({
+        code: ResultCode.Ok,
+        message: '平台端已启用 IPC 极速通讯模式',
+        data: null
+    });
+    return {
+        send,
+        onactions,
+        onapis
+    };
+};
 const cbpPlatform = (url, options = {
     open: () => { }
 }) => {
     const { open = () => { } } = options;
+    if (process.env.__ALEMON_DIRECT_SOCK && typeof process.send === 'function') {
+        return cbpPlatformDirect(process.env.__ALEMON_DIRECT_SOCK, open);
+    }
+    if (process.env.__ALEMON_IPC === '1' && typeof process.send === 'function') {
+        return cbpPlatformIPC(open);
+    }
     const send = (data) => {
         if (global.chatbotPlatform && global.chatbotPlatform.readyState === WebSocket.OPEN) {
             data.DeviceId = deviceId;

package/lib/cbp/processor/actions.js

@@ -5,27 +5,42 @@ import 'path';
 import 'yaml';
 import { createResult } from '../../core/utils.js';
 import { generateUniqueId, deviceId, actionResolves, actionTimeouts, timeoutTime } from './config.js';
+import { getDirectSend } from './transport.js';
 
+const setupActionResolve = (actionId, resolve) => {
+    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);
+};
 const sendAction = (data) => {
     const actionId = generateUniqueId();
     return new Promise(resolve => {
+        data.actionId = actionId;
+        data.DeviceId = deviceId;
+        const directSend = getDirectSend();
+        if (directSend) {
+            directSend(data);
+            setupActionResolve(actionId, resolve);
+            return;
+        }
+        if (process.env.__ALEMON_IPC === '1' && typeof process.send === 'function') {
+            process.send({ type: 'ipc:data', data });
+            setupActionResolve(actionId, resolve);
+            return;
+        }
         if (!global.chatbotClient?.send) {
             resolve([createResult(ResultCode.Fail, 'Chatbot client is not available', null)]);
             return;
         }
-        data.actionId = actionId;
-        data.DeviceId = deviceId;
         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);
+        setupActionResolve(actionId, resolve);
     });
 };
 

package/lib/cbp/processor/api.js

@@ -5,27 +5,42 @@ import 'yaml';
 import { createResult } from '../../core/utils.js';
 import { generateUniqueId, deviceId, apiResolves, apiTimeouts, timeoutTime } from './config.js';
 import * as flattedJSON from 'flatted';
+import { getDirectSend } from './transport.js';
 
+const setupApiResolve = (apiId, resolve) => {
+    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);
+};
 const sendAPI = (data) => {
     const ApiId = generateUniqueId();
     return new Promise(resolve => {
+        data.apiId = ApiId;
+        data.DeviceId = deviceId;
+        const directSend = getDirectSend();
+        if (directSend) {
+            directSend(data);
+            setupApiResolve(ApiId, resolve);
+            return;
+        }
+        if (process.env.__ALEMON_IPC === '1' && typeof process.send === 'function') {
+            process.send({ type: 'ipc:data', data });
+            setupApiResolve(ApiId, resolve);
+            return;
+        }
         if (!global.chatbotClient?.send) {
             resolve([createResult(ResultCode.Fail, 'Chatbot client is not available', null)]);
             return;
         }
-        data.apiId = ApiId;
-        data.DeviceId = deviceId;
         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);
+        setupApiResolve(ApiId, resolve);
     });
 };
 

package/lib/cbp/processor/config.js

@@ -17,8 +17,10 @@ const apiResolves = new Map();
 const actionTimeouts = new Map();
 const apiTimeouts = new Map();
 const childrenBind = new Map();
+let _idCounter = 0;
+const _idPrefix = process.pid.toString(36) + Date.now().toString(36);
 const generateUniqueId = () => {
-    return Date.now().toString(36) + Math.random().toString(36).substring(2);
+    return _idPrefix + (++_idCounter).toString(36);
 };
 const timeoutTime = 1000 * 60 * 3;
 const reconnectInterval = 1000 * 6;

package/lib/cbp/processor/transport.d.ts

@@ -0,0 +1,4 @@
+type SendFunc = (data: any) => void;
+export declare const setDirectSend: (fn: SendFunc) => void;
+export declare const getDirectSend: () => SendFunc | null;
+export {};

package/lib/cbp/processor/transport.js

@@ -0,0 +1,7 @@
+let _directSend = null;
+const setDirectSend = (fn) => {
+    _directSend = fn;
+};
+const getDirectSend = () => _directSend;
+
+export { getDirectSend, setDirectSend };

package/lib/client.js

@@ -8,6 +8,9 @@ import { cbpClient } from './cbp/connects/client.js';
 import 'flatted';
 import 'ws';
 import './cbp/processor/config.js';
+import 'net';
+import 'v8';
+import 'os';
 import 'koa';
 import '@koa/cors';
 import './cbp/routers/router.js';

package/lib/core/utils.js

@@ -1,6 +1,6 @@
 import crypto from 'crypto';
-import fs, { existsSync, readdirSync } from 'fs';
-import path, { join } from 'path';
+import fs__default, { existsSync, readdirSync } from 'fs';
+import path__default, { join } from 'path';
 import { fileSuffixResponse, ResultCode } from './variable.js';
 import module from 'module';
 
@@ -87,8 +87,8 @@ const createExports = (packageJson) => {
     }
 };
 const getInputExportPath = (input) => {
-    const packageJsonPath = path.join(input ?? process.cwd(), 'package.json');
-    if (fs.existsSync(packageJsonPath)) {
+    const packageJsonPath = path__default.join(input ?? process.cwd(), 'package.json');
+    if (fs__default.existsSync(packageJsonPath)) {
         const packageJson = require(packageJsonPath);
         const main = packageJson?.main || createExports(packageJson);
         if (main) {

package/lib/main.js

@@ -1,8 +1,9 @@
 import { getConfig } from './core/config.js';
 import { cbpServer } from './cbp/server/main.js';
-import { defaultPort, filePrefixCommon, defaultPlatformCommonPrefix } from './core/variable.js';
+import { filePrefixCommon, defaultPlatformCommonPrefix } from './core/variable.js';
 import { startPlatformAdapterWithFallback } from './process/platform.js';
 import { startModuleAdapter } from './process/module.js';
+import { generateSocketPath } from './process/direct-channel.js';
 
 const createOptionsByKey = (options, key, defaultValue) => {
     const cfg = getConfig();
@@ -41,7 +42,7 @@ const startClient = (options) => {
     process.env.input = createOptionsByKey(options, 'input', '');
     process.env.output = createOptionsByKey(options, 'output', '');
     process.env.is_full_receive = String(createOptionsByKey(options, 'is_full_receive', true));
-    process.env.port = String(createOptionsByKey(options, 'port', defaultPort));
+    process.env.port = String(createOptionsByKey(options, 'port', '') || '');
     process.env.url = createOptionsByKey(options, 'url', '');
     startModuleAdapter();
 };
@@ -50,18 +51,27 @@ const start = (options = {}) => {
         options = { input: options };
     }
     global.__options = options;
-    const port = createOptionsByKey(options, 'port', defaultPort);
+    const port = createOptionsByKey(options, 'port', '');
     const serverPort = createOptionsByKey(options, 'serverPort', '');
-    process.env.port = port;
+    process.env.port = port ? String(port) : '';
     process.env.serverPort = serverPort;
-    cbpServer(port, () => {
-        const httpURL = `http://127.0.0.1:${port}`;
-        const wsURL = `ws://127.0.0.1:${port}`;
-        logger.info(`[CBP server started at ${httpURL}]`);
-        logger.info(`[CBP server started at ${wsURL}]`);
+    if (port) {
+        cbpServer(port, () => {
+            const httpURL = `http://127.0.0.1:${port}`;
+            const wsURL = `ws://127.0.0.1:${port}`;
+            logger.info(`[CBP server started at ${httpURL}]`);
+            logger.info(`[CBP server started at ${wsURL}]`);
+            startClient(options);
+            startPlatform(options);
+        });
+    }
+    else {
+        const sockPath = generateSocketPath();
+        process.env.__ALEMON_DIRECT_SOCK = sockPath;
+        logger.info('[Direct-IPC mode] 平台↔客户端直连通道，无主进程桥接');
         startClient(options);
         startPlatform(options);
-    });
+    }
 };
 
 export { start };

package/lib/process/direct-channel.d.ts

@@ -0,0 +1,7 @@
+export declare const generateSocketPath: () => string;
+export interface DirectChannel {
+    send: (data: any) => void;
+    close: () => void;
+}
+export declare const createDirectServer: (sockPath: string, onMessage: (data: any) => void) => Promise<DirectChannel>;
+export declare const createDirectClient: (sockPath: string, onMessage: (data: any) => void, maxRetries?: number, retryDelay?: number) => Promise<DirectChannel>;

package/lib/process/direct-channel.js

@@ -0,0 +1,110 @@
+import * as net from 'net';
+import * as v8 from 'v8';
+import * as os from 'os';
+import * as path from 'path';
+import * as fs from 'fs';
+
+const generateSocketPath = () => {
+    if (process.platform === 'win32') {
+        return `\\\\.\\pipe\\alemon-direct-${process.pid}-${Date.now()}`;
+    }
+    return path.join(os.tmpdir(), `alemon-direct-${process.pid}-${Date.now()}.sock`);
+};
+const encodeMessage = (data) => {
+    const serialized = v8.serialize(data);
+    const header = Buffer.alloc(4);
+    header.writeUInt32BE(serialized.length, 0);
+    return Buffer.concat([header, serialized]);
+};
+const createMessageParser = (onMessage) => {
+    let buffer = Buffer.alloc(0);
+    return (chunk) => {
+        buffer = Buffer.concat([buffer, chunk]);
+        while (buffer.length >= 4) {
+            const msgLen = buffer.readUInt32BE(0);
+            if (buffer.length < 4 + msgLen) {
+                break;
+            }
+            const msgBuf = buffer.subarray(4, 4 + msgLen);
+            buffer = buffer.subarray(4 + msgLen);
+            try {
+                onMessage(v8.deserialize(msgBuf));
+            }
+            catch {
+            }
+        }
+    };
+};
+const createDirectServer = (sockPath, onMessage) => {
+    return new Promise((resolve, reject) => {
+        let connection = null;
+        if (process.platform !== 'win32') {
+            try {
+                fs.unlinkSync(sockPath);
+            }
+            catch { }
+        }
+        const server = net.createServer((socket) => {
+            connection = socket;
+            const parser = createMessageParser(onMessage);
+            socket.on('data', parser);
+            socket.on('error', () => { connection = null; });
+            socket.on('close', () => { connection = null; });
+        });
+        const cleanup = () => {
+            try {
+                server.close();
+                connection?.destroy();
+                if (process.platform !== 'win32') {
+                    try {
+                        fs.unlinkSync(sockPath);
+                    }
+                    catch { }
+                }
+            }
+            catch { }
+        };
+        process.on('exit', cleanup);
+        server.listen(sockPath, () => {
+            resolve({
+                send: (data) => {
+                    if (connection && !connection.destroyed) {
+                        connection.write(encodeMessage(data));
+                    }
+                },
+                close: cleanup
+            });
+        });
+        server.on('error', reject);
+    });
+};
+const createDirectClient = (sockPath, onMessage, maxRetries = 30, retryDelay = 150) => {
+    let attempts = 0;
+    const tryConnect = () => {
+        return new Promise((resolve, reject) => {
+            const parser = createMessageParser(onMessage);
+            const socket = net.createConnection(sockPath, () => {
+                resolve({
+                    send: (data) => {
+                        if (!socket.destroyed) {
+                            socket.write(encodeMessage(data));
+                        }
+                    },
+                    close: () => {
+                        socket.destroy();
+                    }
+                });
+            });
+            socket.on('data', parser);
+            socket.on('error', reject);
+        }).catch((err) => {
+            if (++attempts < maxRetries) {
+                return new Promise((r) => setTimeout(() => r(tryConnect()), retryDelay));
+            }
+            throw err;
+        });
+    };
+    return tryConnect();
+};
+
+export { createDirectClient, createDirectServer, generateSocketPath };

package/lib/process/index.d.ts

@@ -1,2 +1,4 @@
 export * from './module';
 export * from './platform';
+export * from './ipc-bridge';
+export * from './direct-channel';

package/lib/process/index.js

@@ -1,2 +1,4 @@
 export { startModuleAdapter } from './module.js';
 export { startPlatformAdapterWithFallback } from './platform.js';
+export { forwardFromClient, forwardFromPlatform, getClientChild, getPlatformChild, setClientChild, setPlatformChild } from './ipc-bridge.js';
+export { createDirectClient, createDirectServer, generateSocketPath } from './direct-channel.js';

package/lib/process/ipc-bridge.d.ts

@@ -0,0 +1,7 @@
+import type { ChildProcess } from 'child_process';
+export declare const setPlatformChild: (child: ChildProcess | null) => void;
+export declare const setClientChild: (child: ChildProcess | null) => void;
+export declare const getPlatformChild: () => ChildProcess;
+export declare const getClientChild: () => ChildProcess;
+export declare const forwardFromPlatform: (data: any) => void;
+export declare const forwardFromClient: (data: any) => void;

package/lib/process/ipc-bridge.js

@@ -0,0 +1,39 @@
+import { WebSocket } from 'ws';
+import { fullClient } from '../cbp/processor/config.js';
+import * as flattedJSON from 'flatted';
+
+let platformChild = null;
+let clientChild = null;
+const setPlatformChild = (child) => {
+    platformChild = child;
+};
+const setClientChild = (child) => {
+    clientChild = child;
+};
+const getPlatformChild = () => platformChild;
+const getClientChild = () => clientChild;
+const forwardFromPlatform = (data) => {
+    if (clientChild?.connected) {
+        clientChild.send({ type: 'ipc:data', data });
+    }
+    try {
+        const messageStr = flattedJSON.stringify(data);
+        fullClient.forEach((ws, id) => {
+            if (ws.readyState === WebSocket.OPEN) {
+                ws.send(messageStr);
+            }
+            else {
+                fullClient.delete(id);
+            }
+        });
+    }
+    catch {
+    }
+};
+const forwardFromClient = (data) => {
+    if (platformChild?.connected) {
+        platformChild.send({ type: 'ipc:data', data });
+    }
+};
+
+export { forwardFromClient, forwardFromPlatform, getClientChild, getPlatformChild, setClientChild, setPlatformChild };

package/lib/process/module.js

@@ -3,6 +3,7 @@ import { ResultCode } from '../core/variable.js';
 import { getConfigValue } from '../core/config.js';
 import '../core/utils.js';
 import module from 'module';
+import { setClientChild, forwardFromClient } from './ipc-bridge.js';
 
 const initRequire = () => { };
 initRequire.resolve = () => '';
@@ -31,14 +32,18 @@ function startModuleAdapter() {
             restarted: false,
             ready: false
         };
-        const cleanup = () => {
+        const clearTimer = () => {
             if (manager.timer) {
                 clearTimeout(manager.timer);
                 manager.timer = undefined;
             }
+        };
+        const cleanup = () => {
+            clearTimer();
             if (manager.child) {
                 manager.child.removeAllListeners();
             }
+            setClientChild(null);
         };
         const restart = () => {
             if (manager.restarted) {
@@ -66,7 +71,9 @@ function startModuleAdapter() {
         };
         try {
             manager.child = childProcess.fork(modulePath, [], {
-                execArgv: process.execArgv
+                execArgv: process.execArgv,
+                env: { ...process.env, __ALEMON_IPC: '1' },
+                serialization: 'advanced'
             });
             manager.timer = setTimeout(checkTimeout, CONFIG.FORK_TIMEOUT);
             manager.child.on('exit', (code, signal) => {
@@ -83,14 +90,18 @@ function startModuleAdapter() {
                     const data = typeof message === 'string' ? JSON.parse(message) : message;
                     if (data?.type === 'ready') {
                         manager.ready = true;
-                        cleanup();
+                        clearTimer();
+                        setClientChild(manager.child);
                         logger?.debug?.({
                             code: ResultCode.Ok,
-                            message: '模块加载已就绪（子进程 fork 模式）',
+                            message: '模块加载已就绪（IPC）',
                             data: null
                         });
                         manager.child?.send?.({ type: 'start' });
                     }
+                    else if (data?.type === 'ipc:data') {
+                        forwardFromClient(data.data);
+                    }
                 }
                 catch (error) {
                     logger?.error?.({

package/lib/process/platform.js

@@ -3,6 +3,7 @@ import { ResultCode } from '../core/variable.js';
 import { getConfigValue } from '../core/config.js';
 import '../core/utils.js';
 import module from 'module';
+import { setPlatformChild, forwardFromPlatform } from './ipc-bridge.js';
 
 const initRequire = () => { };
 initRequire.resolve = () => '';
@@ -91,6 +92,7 @@ function startPlatformAdapterWithFallback() {
             if (manager.child) {
                 manager.child.removeAllListeners();
             }
+            setPlatformChild(null);
         };
         const restart = () => {
             if (manager.restarted || imported) {
@@ -110,6 +112,14 @@ function startPlatformAdapterWithFallback() {
             }
             isForkFailed = true;
             cleanup();
+            if (!process.env.port) {
+                logger?.error?.({
+                    code: ResultCode.Fail,
+                    message: 'fork 启动平台连接失败，当前为纯 IPC 模式（未配置 port），无法降级到 WebSocket，已终止平台连接',
+                    data: error
+                });
+                return;
+            }
             logger?.warn?.({
                 code: ResultCode.Fail,
                 message: 'fork 启动平台连接失败，将尝试 import 加载',
@@ -135,7 +145,9 @@ function startPlatformAdapterWithFallback() {
         };
         try {
             manager.child = childProcess.fork(modulePath, [], {
-                execArgv: process.execArgv
+                execArgv: process.execArgv,
+                env: { ...process.env, __ALEMON_IPC: '1' },
+                serialization: 'advanced'
             });
             manager.timer = setTimeout(checkTimeout, CONFIG.FORK_TIMEOUT);
             manager.child.on('exit', (code, signal) => {
@@ -161,13 +173,17 @@ function startPlatformAdapterWithFallback() {
                             clearTimeout(manager.timer);
                             manager.timer = undefined;
                         }
+                        setPlatformChild(manager.child);
                         logger?.debug?.({
                             code: ResultCode.Ok,
-                            message: '平台连接已就绪（子进程 fork 模式）',
+                            message: '平台连接已就绪（IPC）',
                             data: null
                         });
                         manager.child?.send?.({ type: 'start' });
                     }
+                    else if (data?.type === 'ipc:data') {
+                        forwardFromPlatform(data.data);
+                    }
                 }
                 catch (error) {
                     logger?.error?.({

package/lib/server/routers/middleware.js

@@ -1,5 +1,5 @@
 import { existsSync } from 'fs';
-import path, { dirname } from 'path';
+import path__default, { dirname } from 'path';
 
 async function collectMiddlewares(routeFile) {
     const middlewares = [];
@@ -7,7 +7,7 @@ async function collectMiddlewares(routeFile) {
     const suffixes = ['.ts', '.js', '.cjs', '.mjs', '.tsx', '.jsx'];
     while (true) {
         for (const ext of suffixes) {
-            const mwPath = path.join(dir, `_middleware${ext}`);
+            const mwPath = path__default.join(dir, `_middleware${ext}`);
             if (existsSync(mwPath)) {
                 const module = await import(`file://${mwPath}`);
                 const mw = module?.default ?? {};

package/lib/server/routers/router.js

@@ -1,6 +1,6 @@
 import KoaRouter from 'koa-router';
-import fs, { existsSync } from 'fs';
-import path, { join, dirname } from 'path';
+import fs__default, { existsSync } from 'fs';
+import path__default, { join, dirname } from 'path';
 import mime from 'mime-types';
 import hello from './hello.html.js';
 import { getModuelFile, formatPath } from './utils.js';
@@ -56,7 +56,7 @@ router.all('app/{*path}', async (ctx) => {
         const mainDir = dirname(mainPath);
         try {
             const dir = join(mainDir, 'route', ctx.path?.replace(apiPath, '/api') || '');
-            if (existsSync(dir) && fs.statSync(dir).isFile()) {
+            if (existsSync(dir) && fs__default.statSync(dir).isFile()) {
                 ctx.status = 404;
                 ctx.body = {
                     code: 404,
@@ -102,7 +102,7 @@ router.all('app/{*path}', async (ctx) => {
     let root = '';
     const resourcePath = formatPath(ctx.params?.path);
     try {
-        const pkg = require(path.join(rootPath, 'package.json')) ?? {};
+        const pkg = require(path__default.join(rootPath, 'package.json')) ?? {};
         root = pkg.alemonjs?.web?.root ?? '';
     }
     catch (err) {
@@ -114,9 +114,9 @@ router.all('app/{*path}', async (ctx) => {
         };
         return;
     }
-    const fullPath = root ? path.join(rootPath, root, resourcePath) : path.join(rootPath, resourcePath);
+    const fullPath = root ? path__default.join(rootPath, root, resourcePath) : path__default.join(rootPath, resourcePath);
     try {
-        const file = await fs.promises.readFile(fullPath);
+        const file = await fs__default.promises.readFile(fullPath);
         const mimeType = mime.lookup(fullPath) || 'application/octet-stream';
         ctx.set('Content-Type', mimeType);
         ctx.body = file;
@@ -164,7 +164,7 @@ router.all('apps/:app/{*path}', async (ctx) => {
                 mainDirMap.set(appName, mainDir);
             }
             const dir = join(mainDirMap.get(appName), 'route', ctx.path?.replace(apiPath, '/api') || '');
-            if (existsSync(dir) && fs.statSync(dir).isFile()) {
+            if (existsSync(dir) && fs__default.statSync(dir).isFile()) {
                 ctx.status = 404;
                 ctx.body = {
                     code: 404,
@@ -211,7 +211,7 @@ router.all('apps/:app/{*path}', async (ctx) => {
         ctx.status = 405;
         return;
     }
-    const rootPath = path.join(process.cwd(), 'node_modules', appName);
+    const rootPath = path__default.join(process.cwd(), 'node_modules', appName);
     const resourcePath = formatPath(ctx.params?.path);
     let root = '';
     try {
@@ -227,9 +227,9 @@ router.all('apps/:app/{*path}', async (ctx) => {
         };
         return;
     }
-    const fullPath = root ? path.join(rootPath, root, resourcePath) : path.join(rootPath, resourcePath);
+    const fullPath = root ? path__default.join(rootPath, root, resourcePath) : path__default.join(rootPath, resourcePath);
     try {
-        const file = await fs.promises.readFile(fullPath);
+        const file = await fs__default.promises.readFile(fullPath);
         const mimeType = mime.lookup(fullPath) || 'application/octet-stream';
         ctx.set('Content-Type', mimeType);
         ctx.body = file;

package/lib/server/routers/utils.js

@@ -1,4 +1,4 @@
-import fs, { existsSync } from 'fs';
+import fs__default, { existsSync } from 'fs';
 
 const getModuelFile = (dir) => {
     const dirMap = {
@@ -17,7 +17,7 @@ const getModuelFile = (dir) => {
     };
     for (const key in dirMap) {
         const filePath = dirMap[key];
-        if (existsSync(filePath) && fs.statSync(filePath)) {
+        if (existsSync(filePath) && fs__default.statSync(filePath)) {
             return filePath;
         }
     }

package/lib/types/message/markdown.d.ts

@@ -4,9 +4,9 @@ export type DataMarkdownText = {
 };
 export type DataMarkdownMention = {
     type: 'MD.mention';
-    value?: string;
+    value?: string | 'everyone';
     options?: {
-        belong?: 'user' | 'channel' | 'all';
+        belong?: 'user' | 'channel';
     };
 };
 export type DataMarkdownContent = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alemonjs",
-  "version": "2.1.28",
+  "version": "2.1.30-rc.0",
   "description": "bot script",
   "author": "lemonade",
   "license": "MIT",