alemonjs 2.1.7 → 2.1.9

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/channel/index.d.ts

@@ -0,0 +1,10 @@
+import { Guild, Channel } from '../base/guild';
+import { platform } from '../base/platform';
+import { Message } from '../base/message';
+import { Expansion } from '../base/expansion';
+export type PublicEventChannelCreate = platform & Guild & Channel & Message & {
+    name: 'channel.create';
+} & Expansion;
+export type PublicEventChannelDelete = platform & Guild & Channel & Message & {
+    name: 'channel.delete';
+} & Expansion;

package/lib/types/event/channel/index.js

@@ -0,0 +1 @@
+

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

@@ -1,4 +1,4 @@
-import { PublicEventChannalCreate, PublicEventChannalDelete } from './channal';
+import { PublicEventChannelCreate, PublicEventChannelDelete } from './channel';
 import { PublicEventGuildExit, PublicEventGuildJoin } from './guild';
 import { PrivateEventInteractionCreate, PublicEventInteractionCreate } from './interaction';
 import { PublicEventMemberAdd, PublicEventMemberRemove } from './member';
@@ -18,8 +18,8 @@ export type Events = {
     'message.delete': PublicEventMessageDelete;
     'message.reaction.add': PublicEventMessageReactionAdd;
     'message.reaction.remove': PublicEventMessageReactionRemove;
-    'channal.create': PublicEventChannalCreate;
-    'channal.delete': PublicEventChannalDelete;
+    'channel.create': PublicEventChannelCreate;
+    'channel.delete': PublicEventChannelDelete;
     'guild.join': PublicEventGuildJoin;
     'guild.exit': PublicEventGuildExit;
     'member.add': PublicEventMemberAdd;

package/lib/types/index.d.ts

@@ -4,7 +4,7 @@ export * from './event/base/guild';
 export * from './event/base/message';
 export * from './event/base/platform';
 export * from './event/base/user';
-export * from './event/channal/index';
+export * from './event/channel/index';
 export * from './event/guild/index';
 export * from './event/interaction/index';
 export * from './event/member/index';

package/package.json

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