alemonjs 2.1.6 → 2.1.8

package/lib/cbp/core/connection-manager.d.ts

@@ -0,0 +1,18 @@
+import { WebSocket } from 'ws';
+export interface ConnectionState {
+    connections: Map<string, WebSocket>;
+    lastActivity: Map<string, number>;
+    metadata: Map<string, any>;
+}
+export declare const createConnectionState: () => ConnectionState;
+export declare const addConnection: (state: ConnectionState, id: string, ws: WebSocket, metadata?: any) => ConnectionState;
+export declare const removeConnection: (state: ConnectionState, id: string) => ConnectionState;
+export declare const getConnection: (state: ConnectionState, id: string) => WebSocket | undefined;
+export declare const getHealthyConnectionIds: (state: ConnectionState) => string[];
+export declare const getConnectionStats: (state: ConnectionState) => {
+    total: number;
+    healthy: number;
+    unhealthy: number;
+    lastUpdate: number;
+};
+export declare const clearAllConnections: (state: ConnectionState) => ConnectionState;

package/lib/cbp/core/connection-manager.js

@@ -0,0 +1,67 @@
+import { WebSocket } from 'ws';
+
+const createConnectionState = () => ({
+    connections: new Map(),
+    lastActivity: new Map(),
+    metadata: new Map()
+});
+const addConnection = (state, id, ws, metadata) => {
+    const newState = {
+        connections: new Map(state.connections),
+        lastActivity: new Map(state.lastActivity),
+        metadata: new Map(state.metadata)
+    };
+    newState.connections.set(id, ws);
+    newState.lastActivity.set(id, Date.now());
+    if (metadata) {
+        newState.metadata.set(id, metadata);
+    }
+    return newState;
+};
+const removeConnection = (state, id) => {
+    const newState = {
+        connections: new Map(state.connections),
+        lastActivity: new Map(state.lastActivity),
+        metadata: new Map(state.metadata)
+    };
+    const ws = newState.connections.get(id);
+    if (ws && ws.readyState === WebSocket.OPEN) {
+        ws.close();
+    }
+    newState.connections.delete(id);
+    newState.lastActivity.delete(id);
+    newState.metadata.delete(id);
+    return newState;
+};
+const getConnection = (state, id) => {
+    return state.connections.get(id);
+};
+const getHealthyConnectionIds = (state) => {
+    const healthyIds = [];
+    for (const [id, ws] of state.connections.entries()) {
+        if (ws.readyState === WebSocket.OPEN) {
+            healthyIds.push(id);
+        }
+    }
+    return healthyIds;
+};
+const getConnectionStats = (state) => {
+    const total = state.connections.size;
+    const healthy = getHealthyConnectionIds(state).length;
+    return {
+        total,
+        healthy,
+        unhealthy: total - healthy,
+        lastUpdate: Date.now()
+    };
+};
+const clearAllConnections = (state) => {
+    for (const ws of state.connections.values()) {
+        if (ws.readyState === WebSocket.OPEN) {
+            ws.close();
+        }
+    }
+    return createConnectionState();
+};
+
+export { addConnection, clearAllConnections, createConnectionState, getConnection, getConnectionStats, getHealthyConnectionIds, removeConnection };

package/lib/cbp/core/constants.d.ts

@@ -0,0 +1,19 @@
+export declare const USER_AGENT_HEADER = "user-agent";
+export declare const DEVICE_ID_HEADER = "x-device-id";
+export declare const FULL_RECEIVE_HEADER = "x-full-receive";
+export declare const USER_AGENT_HEADER_VALUE_MAP: {
+    readonly platform: "platform";
+    readonly client: "client";
+    readonly testone: "testone";
+};
+export declare const TIME_CONFIG: {
+    readonly TIMEOUT: number;
+    readonly RECONNECT_INTERVAL: number;
+    readonly HEARTBEAT_INTERVAL: number;
+};
+export declare const HEALTH_CHECK_CONFIG: {
+    readonly INTERVAL: 30000;
+    readonly MAX_CONSECUTIVE_FAILURES: 3;
+    readonly PING_TIMEOUT: 5000;
+};
+export declare const generateUniqueId: () => string;

package/lib/cbp/core/constants.js

@@ -0,0 +1,23 @@
+const USER_AGENT_HEADER = 'user-agent';
+const DEVICE_ID_HEADER = 'x-device-id';
+const FULL_RECEIVE_HEADER = 'x-full-receive';
+const USER_AGENT_HEADER_VALUE_MAP = {
+    platform: 'platform',
+    client: 'client',
+    testone: 'testone'
+};
+const TIME_CONFIG = {
+    TIMEOUT: 1000 * 60 * 3,
+    RECONNECT_INTERVAL: 1000 * 6,
+    HEARTBEAT_INTERVAL: 1000 * 18
+};
+const HEALTH_CHECK_CONFIG = {
+    INTERVAL: 30000,
+    MAX_CONSECUTIVE_FAILURES: 3,
+    PING_TIMEOUT: 5000
+};
+const generateUniqueId = () => {
+    return Date.now().toString(36) + Math.random().toString(36).substring(2);
+};
+
+export { DEVICE_ID_HEADER, FULL_RECEIVE_HEADER, HEALTH_CHECK_CONFIG, TIME_CONFIG, USER_AGENT_HEADER, USER_AGENT_HEADER_VALUE_MAP, generateUniqueId };

package/lib/cbp/core/load-balancer.d.ts

@@ -0,0 +1,37 @@
+import { ConnectionState } from './connection-manager';
+export type LoadBalanceStrategy = 'round-robin' | 'least-connections' | 'random' | 'first-available';
+export declare const LoadBalanceStrategyEnum: {
+    readonly ROUND_ROBIN: "round-robin";
+    readonly LEAST_CONNECTIONS: "least-connections";
+    readonly RANDOM: "random";
+    readonly FIRST_AVAILABLE: "first-available";
+};
+export interface LoadBalancerState {
+    strategy: LoadBalanceStrategy;
+    roundRobinIndex: number;
+    bindingCounts: Map<string, number>;
+}
+export declare const createLoadBalancerState: (strategy?: LoadBalanceStrategy) => LoadBalancerState;
+export declare const selectByRoundRobin: (availableIds: string[], currentIndex: number) => {
+    selectedId: string | null;
+    nextIndex: number;
+};
+export declare const selectByLeastConnections: (availableIds: string[], bindingCounts: Map<string, number>) => string | null;
+export declare const selectByRandom: (availableIds: string[]) => string | null;
+export declare const selectFirstAvailable: (availableIds: string[]) => string | null;
+export declare const selectConnection: (connectionState: ConnectionState, balancerState: LoadBalancerState) => {
+    selectedId: string | null;
+    newBalancerState: LoadBalancerState;
+};
+export declare const incrementBindingCount: (balancerState: LoadBalancerState, connectionId: string) => LoadBalancerState;
+export declare const decrementBindingCount: (balancerState: LoadBalancerState, connectionId: string) => LoadBalancerState;
+export declare const getLoadBalancerStats: (balancerState: LoadBalancerState) => {
+    strategy: LoadBalanceStrategy;
+    roundRobinIndex: number;
+    totalConnections: number;
+    totalBindings: number;
+    bindingCounts: {
+        [k: string]: number;
+    };
+    lastUpdate: number;
+};

package/lib/cbp/core/load-balancer.js

@@ -0,0 +1,118 @@
+import { getHealthyConnectionIds } from './connection-manager.js';
+
+const LoadBalanceStrategyEnum = {
+    ROUND_ROBIN: 'round-robin',
+    LEAST_CONNECTIONS: 'least-connections',
+    RANDOM: 'random',
+    FIRST_AVAILABLE: 'first-available'
+};
+const createLoadBalancerState = (strategy = 'round-robin') => ({
+    strategy,
+    roundRobinIndex: 0,
+    bindingCounts: new Map()
+});
+const selectByRoundRobin = (availableIds, currentIndex) => {
+    if (availableIds.length === 0) {
+        return { selectedId: null, nextIndex: currentIndex };
+    }
+    const selectedId = availableIds[currentIndex % availableIds.length];
+    const nextIndex = (currentIndex + 1) % availableIds.length;
+    return { selectedId, nextIndex };
+};
+const selectByLeastConnections = (availableIds, bindingCounts) => {
+    if (availableIds.length === 0) {
+        return null;
+    }
+    let selectedId = availableIds[0];
+    let minConnections = bindingCounts.get(selectedId) || 0;
+    for (let i = 1; i < availableIds.length; i++) {
+        const id = availableIds[i];
+        const connections = bindingCounts.get(id) || 0;
+        if (connections < minConnections) {
+            minConnections = connections;
+            selectedId = id;
+        }
+    }
+    return selectedId;
+};
+const selectByRandom = (availableIds) => {
+    if (availableIds.length === 0) {
+        return null;
+    }
+    const randomIndex = Math.floor(Math.random() * availableIds.length);
+    return availableIds[randomIndex];
+};
+const selectFirstAvailable = (availableIds) => {
+    return availableIds.length > 0 ? availableIds[0] : null;
+};
+const selectConnection = (connectionState, balancerState) => {
+    const availableIds = getHealthyConnectionIds(connectionState);
+    if (availableIds.length === 0) {
+        return { selectedId: null, newBalancerState: balancerState };
+    }
+    let selectedId = null;
+    const newBalancerState = { ...balancerState };
+    switch (balancerState.strategy) {
+        case 'round-robin': {
+            const result = selectByRoundRobin(availableIds, balancerState.roundRobinIndex);
+            selectedId = result.selectedId;
+            newBalancerState.roundRobinIndex = result.nextIndex;
+            break;
+        }
+        case 'least-connections': {
+            selectedId = selectByLeastConnections(availableIds, balancerState.bindingCounts);
+            break;
+        }
+        case 'random': {
+            selectedId = selectByRandom(availableIds);
+            break;
+        }
+        case 'first-available': {
+            selectedId = selectFirstAvailable(availableIds);
+            break;
+        }
+        default: {
+            const result = selectByRoundRobin(availableIds, balancerState.roundRobinIndex);
+            selectedId = result.selectedId;
+            newBalancerState.roundRobinIndex = result.nextIndex;
+            break;
+        }
+    }
+    return { selectedId, newBalancerState };
+};
+const incrementBindingCount = (balancerState, connectionId) => {
+    const newBindingCounts = new Map(balancerState.bindingCounts);
+    const currentCount = newBindingCounts.get(connectionId) || 0;
+    newBindingCounts.set(connectionId, currentCount + 1);
+    return {
+        ...balancerState,
+        bindingCounts: newBindingCounts
+    };
+};
+const decrementBindingCount = (balancerState, connectionId) => {
+    const newBindingCounts = new Map(balancerState.bindingCounts);
+    const currentCount = newBindingCounts.get(connectionId) || 0;
+    if (currentCount > 0) {
+        newBindingCounts.set(connectionId, currentCount - 1);
+    }
+    else {
+        newBindingCounts.delete(connectionId);
+    }
+    return {
+        ...balancerState,
+        bindingCounts: newBindingCounts
+    };
+};
+const getLoadBalancerStats = (balancerState) => {
+    const totalBindings = Array.from(balancerState.bindingCounts.values()).reduce((sum, count) => sum + count, 0);
+    return {
+        strategy: balancerState.strategy,
+        roundRobinIndex: balancerState.roundRobinIndex,
+        totalConnections: balancerState.bindingCounts.size,
+        totalBindings,
+        bindingCounts: Object.fromEntries(balancerState.bindingCounts),
+        lastUpdate: Date.now()
+    };
+};
+
+export { LoadBalanceStrategyEnum, createLoadBalancerState, decrementBindingCount, getLoadBalancerStats, incrementBindingCount, selectByLeastConnections, selectByRandom, selectByRoundRobin, selectConnection, selectFirstAvailable };

package/lib/cbp/processor/request-handler.d.ts

@@ -0,0 +1,17 @@
+import { Result } from '../../core';
+type ResolversValue = (value: Result[]) => void;
+export interface RequestHandlerState {
+    resolvers: Map<string, ResolversValue>;
+    timeouts: Map<string, NodeJS.Timeout>;
+    requestType: string;
+    idField: 'actionId' | 'apiId';
+}
+export declare const createRequestHandlerState: (requestType: string, idField: "actionId" | "apiId") => RequestHandlerState;
+export declare const sendRequest: <T>(state: RequestHandlerState, data: T & {
+    DeviceId?: string;
+}) => Promise<Result[]>;
+export declare const handleRequestResponse: (state: RequestHandlerState, requestId: string, results: Result[]) => void;
+export declare const handleRequestTimeout: (state: RequestHandlerState, requestId: string) => void;
+export declare const getPendingRequestCount: (state: RequestHandlerState) => number;
+export declare const destroyRequestHandler: (state: RequestHandlerState) => void;
+export {};

package/lib/cbp/processor/request-handler.js

@@ -0,0 +1,65 @@
+import * as flattedJSON from 'flatted';
+import { ResultCode } from '../../core/variable.js';
+import 'fs';
+import 'path';
+import 'yaml';
+import { createResult } from '../../core/utils.js';
+import { deviceId, timeoutTime } from './config.js';
+import { generateUniqueId } from '../core/constants.js';
+
+const createRequestHandlerState = (requestType, idField) => ({
+    resolvers: new Map(),
+    timeouts: new Map(),
+    requestType,
+    idField
+});
+const sendRequest = (state, data) => {
+    const requestId = generateUniqueId();
+    return new Promise(resolve => {
+        data[state.idField] = requestId;
+        data.DeviceId = deviceId;
+        global.chatbotClient.send(flattedJSON.stringify(data));
+        state.resolvers.set(requestId, resolve);
+        const timeout = setTimeout(() => {
+            handleRequestTimeout(state, requestId);
+        }, timeoutTime);
+        state.timeouts.set(requestId, timeout);
+    });
+};
+const handleRequestResponse = (state, requestId, results) => {
+    const resolver = state.resolvers.get(requestId);
+    const timeout = state.timeouts.get(requestId);
+    if (resolver) {
+        state.resolvers.delete(requestId);
+        if (timeout) {
+            clearTimeout(timeout);
+            state.timeouts.delete(requestId);
+        }
+        resolver(results);
+    }
+};
+const handleRequestTimeout = (state, requestId) => {
+    const resolver = state.resolvers.get(requestId);
+    if (resolver) {
+        state.resolvers.delete(requestId);
+        state.timeouts.delete(requestId);
+        const timeoutResult = createResult(ResultCode.Fail, `${state.requestType}请求超时`, null);
+        resolver([timeoutResult]);
+    }
+};
+const getPendingRequestCount = (state) => {
+    return state.resolvers.size;
+};
+const destroyRequestHandler = (state) => {
+    for (const timeout of state.timeouts.values()) {
+        clearTimeout(timeout);
+    }
+    for (const [_requestId, resolver] of state.resolvers.entries()) {
+        const cancelResult = createResult(ResultCode.FailInternal, `${state.requestType}请求已取消`, null);
+        resolver([cancelResult]);
+    }
+    state.resolvers.clear();
+    state.timeouts.clear();
+};
+
+export { createRequestHandlerState, destroyRequestHandler, getPendingRequestCount, handleRequestResponse, handleRequestTimeout, sendRequest };

package/lib/cbp/server/main.js

@@ -4,7 +4,9 @@ import * as flattedJSON from 'flatted';
 import koaCors from '@koa/cors';
 import router from '../routers/router.js';
 import { ResultCode } from '../../core/variable.js';
-import { getConfig } from '../../core/config.js';
+import 'fs';
+import 'path';
+import 'yaml';
 import '../../core/utils.js';
 import { USER_AGENT_HEADER, USER_AGENT_HEADER_VALUE_MAP, DEVICE_ID_HEADER, FULL_RECEIVE_HEADER, platformClient, childrenClient, fullClient, childrenBind } from '../processor/config.js';
 import { createTestOneController } from './testone.js';
@@ -343,15 +345,9 @@ const cbpServer = (port, listeningListener) => {
                     ws.send(flattedJSON.stringify({
                         active: 'sync',
                         payload: {
-                            value: getConfig().value,
-                            args: getConfig().argv,
-                            package: {
-                                version: getConfig().package?.version
-                            },
                             env: {
                                 login: process.env.login,
-                                platform: process.env.platform,
-                                port: process.env.port
+                                platform: process.env.platform
                             }
                         },
                         activeId: originId

package/lib/main.js

@@ -35,7 +35,7 @@ const startPlatform = (options) => {
     if (login) {
         process.env.login = login;
     }
-    startPlatformAdapterWithFallback();
+    void startPlatformAdapterWithFallback();
 };
 const startClient = (options) => {
     process.env.input = createOptionsByKey(options, 'input', '');

package/lib/types/event/channal/index.d.ts

@@ -3,7 +3,7 @@ import { platform } from '../base/platform';
 import { Message } from '../base/message';
 import { Expansion } from '../base/expansion';
 export type PublicEventChannalCreate = platform & Guild & Channel & Message & {
-    name: 'channal.create';
+    name: 'channel.create';
 } & Expansion;
 export type PublicEventChannalDelete = platform & Guild & Channel & Message & {
     name: 'channal.delete';

package/lib/types/event/map.d.ts

@@ -18,7 +18,7 @@ export type Events = {
     'message.delete': PublicEventMessageDelete;
     'message.reaction.add': PublicEventMessageReactionAdd;
     'message.reaction.remove': PublicEventMessageReactionRemove;
-    'channal.create': PublicEventChannalCreate;
+    'channel.create': PublicEventChannalCreate;
     'channal.delete': PublicEventChannalDelete;
     'guild.join': PublicEventGuildJoin;
     'guild.exit': PublicEventGuildExit;

package/package.json

@@ -1,6 +1,7 @@
 {
+  "$schema": "https://json.schemastore.org/package",
   "name": "alemonjs",
-  "version": "2.1.6",
+  "version": "2.1.8",
   "description": "bot script",
   "author": "lemonade",
   "license": "MIT",
@@ -71,4 +72,4 @@
     "type": "git",
     "url": "https://github.com/lemonade-lab/alemonjs.git"
   }
-}
+}

package/lib/adapter.js

@@ -1,111 +0,0 @@
-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

@@ -1,14 +0,0 @@
-/**
- * 加载子模块
- * @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 };