alemonjs 2.1.83 → 2.1.85

package/lib/common/cbp/normalize.js

@@ -0,0 +1,324 @@
+const now = () => Date.now();
+const asRecord = (value) => {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+};
+const asResults = (value) => {
+    return Array.isArray(value) ? value : [];
+};
+const inferEventRouteId = (event) => {
+    const channelId = event.ChannelId;
+    const guildId = event.GuildId;
+    const deviceId = event.DeviceId;
+    if (typeof channelId === 'string' && channelId) {
+        return channelId;
+    }
+    if (typeof guildId === 'string' && guildId) {
+        return guildId;
+    }
+    if (typeof deviceId === 'string' && deviceId) {
+        return deviceId;
+    }
+    return undefined;
+};
+const createRequestEnvelope = (type, id, deviceId, payload) => {
+    return {
+        protocol: 'cbp',
+        version: 1,
+        type,
+        id,
+        timestamp: now(),
+        source: {
+            role: 'app-client',
+            deviceId
+        },
+        payload
+    };
+};
+const createResponseEnvelope = (type, replyTo, deviceId, payload, error) => {
+    return {
+        protocol: 'cbp',
+        version: 1,
+        type,
+        id: `${replyTo}:res`,
+        replyTo,
+        timestamp: now(),
+        source: {
+            role: 'platform',
+            deviceId
+        },
+        target: {
+            role: 'app-client',
+            deviceId
+        },
+        payload: {
+            results: payload
+        },
+        error
+    };
+};
+const normalizeEnvelopeMessage = (input) => {
+    const payload = input.payload;
+    const meta = asRecord(input.meta);
+    const deviceId = input.source?.deviceId ?? input.target?.deviceId;
+    const sourceRole = input.source?.role;
+    const targetRole = input.target?.role;
+    switch (input.type) {
+        case 'event': {
+            const eventPayload = asRecord(payload);
+            const event = asRecord(eventPayload.event);
+            return {
+                kind: 'event',
+                id: input.id,
+                timestamp: input.timestamp,
+                deviceId,
+                sourceRole,
+                targetRole,
+                eventName: String(eventPayload.name ?? ''),
+                event,
+                raw: eventPayload.raw,
+                meta
+            };
+        }
+        case 'action.req': {
+            const actionPayload = asRecord(payload);
+            return {
+                kind: 'action.req',
+                id: input.id,
+                timestamp: input.timestamp,
+                deviceId,
+                sourceRole,
+                targetRole,
+                action: String(actionPayload.action ?? ''),
+                input: asRecord(actionPayload.input),
+                meta
+            };
+        }
+        case 'action.res':
+            return {
+                kind: 'action.res',
+                id: input.id,
+                replyTo: String(input.replyTo ?? ''),
+                timestamp: input.timestamp,
+                deviceId,
+                sourceRole,
+                targetRole,
+                results: asResults(asRecord(payload).results),
+                error: input.error,
+                meta
+            };
+        case 'api.req': {
+            const apiPayload = asRecord(payload);
+            return {
+                kind: 'api.req',
+                id: input.id,
+                timestamp: input.timestamp,
+                deviceId,
+                sourceRole,
+                targetRole,
+                api: String(apiPayload.api ?? ''),
+                input: asRecord(apiPayload.input),
+                meta
+            };
+        }
+        case 'api.res':
+            return {
+                kind: 'api.res',
+                id: input.id,
+                replyTo: String(input.replyTo ?? ''),
+                timestamp: input.timestamp,
+                deviceId,
+                sourceRole,
+                targetRole,
+                results: asResults(asRecord(payload).results),
+                error: input.error,
+                meta
+            };
+        case 'control': {
+            const controlPayload = asRecord(payload);
+            return {
+                kind: 'control',
+                id: input.id,
+                timestamp: input.timestamp,
+                deviceId,
+                sourceRole,
+                targetRole,
+                op: String(controlPayload.op ?? 'error'),
+                payload: controlPayload,
+                error: input.error,
+                meta
+            };
+        }
+        default:
+            return null;
+    }
+};
+const normalizeLegacyMessage = (input) => {
+    if (input?.apiId) {
+        if (Array.isArray(input.payload)) {
+            return {
+                kind: 'api.res',
+                id: String(input.apiId),
+                replyTo: String(input.apiId),
+                timestamp: now(),
+                deviceId: typeof input.DeviceId === 'string' ? input.DeviceId : undefined,
+                results: input.payload,
+                meta: {}
+            };
+        }
+        return {
+            kind: 'api.req',
+            id: String(input.apiId),
+            timestamp: now(),
+            deviceId: typeof input.DeviceId === 'string' ? input.DeviceId : undefined,
+            api: typeof input.action === 'string' ? input.action : '',
+            input: asRecord(input.payload),
+            meta: {}
+        };
+    }
+    if (input?.actionId) {
+        if (Array.isArray(input.payload)) {
+            return {
+                kind: 'action.res',
+                id: String(input.actionId),
+                replyTo: String(input.actionId),
+                timestamp: now(),
+                deviceId: typeof input.DeviceId === 'string' ? input.DeviceId : undefined,
+                results: input.payload,
+                meta: {}
+            };
+        }
+        return {
+            kind: 'action.req',
+            id: String(input.actionId),
+            timestamp: now(),
+            deviceId: typeof input.DeviceId === 'string' ? input.DeviceId : undefined,
+            action: typeof input.action === 'string' ? input.action : '',
+            input: asRecord(input.payload),
+            meta: {}
+        };
+    }
+    if (input?.activeId && input?.active === 'sync') {
+        const payload = asRecord(input.payload);
+        return {
+            kind: 'control',
+            id: String(input.activeId),
+            timestamp: now(),
+            deviceId: typeof input.DeviceId === 'string' ? input.DeviceId : undefined,
+            op: 'sync',
+            payload,
+            meta: {}
+        };
+    }
+    if (input?.name) {
+        const event = input;
+        return {
+            kind: 'event',
+            id: typeof input.MessageId === 'string' ? input.MessageId : typeof input.DeviceId === 'string' ? input.DeviceId : `${input.name}:${now()}`,
+            timestamp: typeof input.CreateAt === 'number' ? input.CreateAt : now(),
+            deviceId: typeof input.DeviceId === 'string' ? input.DeviceId : undefined,
+            eventName: input.name,
+            event,
+            raw: input.value,
+            meta: {}
+        };
+    }
+    return null;
+};
+const isCBPEnvelope = (input) => {
+    if (!input || typeof input !== 'object') {
+        return false;
+    }
+    const value = input;
+    return value.protocol === 'cbp' && value.version === 1 && typeof value.type === 'string' && typeof value.id === 'string';
+};
+const normalizeInboundMessage = (input) => {
+    if (!input || typeof input !== 'object') {
+        return null;
+    }
+    if (isCBPEnvelope(input)) {
+        return normalizeEnvelopeMessage(input);
+    }
+    return normalizeLegacyMessage(input);
+};
+const toLegacyActionData = (message) => {
+    return {
+        action: message.action,
+        payload: message.input,
+        actionId: message.id,
+        DeviceId: message.deviceId
+    };
+};
+const toLegacyApiData = (message) => {
+    const input = message.input;
+    const key = typeof input.key === 'string' ? input.key : '';
+    const params = Array.isArray(input.params) ? input.params : [];
+    return {
+        action: message.api,
+        payload: {
+            event: input.event,
+            key,
+            params
+        },
+        apiId: message.id,
+        DeviceId: message.deviceId
+    };
+};
+const isNormalizedActionRequest = (message) => {
+    return message?.kind === 'action.req';
+};
+const isNormalizedApiRequest = (message) => {
+    return message?.kind === 'api.req';
+};
+const getNormalizedDeviceId = (message) => {
+    return message.deviceId;
+};
+const getNormalizedEventRouteId = (message) => {
+    if (message.kind !== 'event') {
+        return undefined;
+    }
+    return inferEventRouteId(message.event);
+};
+const createActionRequestEnvelope = (data) => {
+    return createRequestEnvelope('action.req', String(data.actionId ?? ''), data.DeviceId, {
+        action: data.action,
+        input: asRecord(data.payload)
+    });
+};
+const createApiRequestEnvelope = (data) => {
+    return createRequestEnvelope('api.req', String(data.apiId ?? ''), data.DeviceId, {
+        api: data.action,
+        input: asRecord(data.payload)
+    });
+};
+const createActionResponseEnvelope = (data, payload, error) => {
+    return createResponseEnvelope('action.res', String(data.actionId ?? ''), data.DeviceId, payload, error);
+};
+const createApiResponseEnvelope = (data, payload, error) => {
+    return createResponseEnvelope('api.res', String(data.apiId ?? ''), data.DeviceId, payload, error);
+};
+const createEventEnvelope = (data) => {
+    const deviceId = typeof data.DeviceId === 'string' ? data.DeviceId : undefined;
+    const eventName = typeof data.name === 'string' ? data.name : '';
+    const event = { ...data };
+    return {
+        protocol: 'cbp',
+        version: 1,
+        type: 'event',
+        id: typeof data.MessageId === 'string' ? data.MessageId : typeof deviceId === 'string' ? `${deviceId}:${now()}` : `${eventName}:${now()}`,
+        timestamp: typeof data.CreateAt === 'number' ? data.CreateAt : now(),
+        source: {
+            role: 'platform',
+            deviceId
+        },
+        payload: {
+            name: eventName,
+            event,
+            raw: data.value
+        },
+        meta: {
+            routeId: inferEventRouteId(event)
+        }
+    };
+};
+
+export { createActionRequestEnvelope, createActionResponseEnvelope, createApiRequestEnvelope, createApiResponseEnvelope, createEventEnvelope, getNormalizedDeviceId, getNormalizedEventRouteId, isCBPEnvelope, isNormalizedActionRequest, isNormalizedApiRequest, normalizeInboundMessage, toLegacyActionData, toLegacyApiData };

package/lib/common/cbp/runtime.d.ts

@@ -0,0 +1,2 @@
+export declare const deviceId: `${string}-${string}-${string}-${string}-${string}`;
+export declare const generateUniqueId: () => string;

package/lib/common/cbp/runtime.js

@@ -0,0 +1,10 @@
+import { randomUUID } from 'node:crypto';
+
+const deviceId = randomUUID();
+let idCounter = 0;
+const idPrefix = process.pid.toString(36) + Date.now().toString(36);
+const generateUniqueId = () => {
+    return idPrefix + (++idCounter).toString(36);
+};
+
+export { deviceId, generateUniqueId };

package/lib/common/cbp/typings.d.ts

@@ -0,0 +1,159 @@
+import type { EventKeys, Apis, Actions } from '../../types/index.js';
+import type { Result } from '../index.js';
+export type ParsedMessage = {
+    apiId?: string;
+    actionId?: string;
+    testID?: string;
+    ChannelId?: string;
+    GuildId?: string;
+    name?: EventKeys;
+    DeviceId?: string;
+    activeId?: string;
+    payload?: any;
+    [key: string]: any;
+};
+export type CBPProtocolRole = 'platform' | 'app-client' | 'server';
+export type CBPMessageType = 'event' | 'action.req' | 'action.res' | 'api.req' | 'api.res' | 'control';
+export type CBPEndpoint = {
+    role: CBPProtocolRole;
+    deviceId?: string;
+    appName?: string;
+    platform?: string;
+};
+export type CBPError = {
+    code: string;
+    message: string;
+    retryable?: boolean;
+    details?: unknown;
+};
+export type CBPResult = {
+    code: number;
+    message: string;
+    data?: unknown;
+};
+export type CBPCapability = 'event' | 'action' | 'api' | 'full-receive';
+export type CBPControlPayload = {
+    op: 'hello';
+    capabilities?: CBPCapability[];
+} | {
+    op: 'heartbeat';
+} | {
+    op: 'goodbye';
+    reason?: string;
+} | {
+    op: 'error';
+    code: string;
+    message: string;
+} | {
+    op: 'sync';
+    env?: Record<string, string>;
+};
+export type CBPEventPayload = {
+    name: EventKeys | string;
+    event: Record<string, unknown>;
+    raw?: unknown;
+};
+export type CBPActionRequestPayload = {
+    action: string;
+    input: Record<string, unknown>;
+};
+export type CBPActionResponsePayload = {
+    results: CBPResult[] | Result[];
+};
+export type CBPApiRequestPayload = {
+    api: string;
+    input: Record<string, unknown>;
+};
+export type CBPApiResponsePayload = {
+    results: CBPResult[] | Result[];
+};
+export type CBPEnvelope = {
+    protocol: 'cbp';
+    version: 1;
+    type: CBPMessageType;
+    id: string;
+    replyTo?: string;
+    timestamp: number;
+    source: CBPEndpoint;
+    target?: CBPEndpoint;
+    payload?: CBPEventPayload | CBPActionRequestPayload | CBPActionResponsePayload | CBPApiRequestPayload | CBPApiResponsePayload | CBPControlPayload | unknown;
+    error?: CBPError;
+    meta?: Record<string, unknown>;
+};
+export type NormalizedEventMessage = {
+    kind: 'event';
+    id: string;
+    timestamp: number;
+    deviceId?: string;
+    sourceRole?: CBPProtocolRole;
+    targetRole?: CBPProtocolRole;
+    eventName: EventKeys | string;
+    event: Record<string, unknown>;
+    raw?: unknown;
+    meta?: Record<string, unknown>;
+};
+export type NormalizedActionRequestMessage = {
+    kind: 'action.req';
+    id: string;
+    timestamp: number;
+    deviceId?: string;
+    sourceRole?: CBPProtocolRole;
+    targetRole?: CBPProtocolRole;
+    action: string;
+    input: Record<string, unknown>;
+    meta?: Record<string, unknown>;
+};
+export type NormalizedActionResponseMessage = {
+    kind: 'action.res';
+    id: string;
+    replyTo: string;
+    timestamp: number;
+    deviceId?: string;
+    sourceRole?: CBPProtocolRole;
+    targetRole?: CBPProtocolRole;
+    results: Result[];
+    error?: CBPError;
+    meta?: Record<string, unknown>;
+};
+export type NormalizedApiRequestMessage = {
+    kind: 'api.req';
+    id: string;
+    timestamp: number;
+    deviceId?: string;
+    sourceRole?: CBPProtocolRole;
+    targetRole?: CBPProtocolRole;
+    api: string;
+    input: Record<string, unknown>;
+    meta?: Record<string, unknown>;
+};
+export type NormalizedApiResponseMessage = {
+    kind: 'api.res';
+    id: string;
+    replyTo: string;
+    timestamp: number;
+    deviceId?: string;
+    sourceRole?: CBPProtocolRole;
+    targetRole?: CBPProtocolRole;
+    results: Result[];
+    error?: CBPError;
+    meta?: Record<string, unknown>;
+};
+export type NormalizedControlMessage = {
+    kind: 'control';
+    id: string;
+    timestamp: number;
+    deviceId?: string;
+    sourceRole?: CBPProtocolRole;
+    targetRole?: CBPProtocolRole;
+    op: CBPControlPayload['op'];
+    payload?: Record<string, unknown>;
+    error?: CBPError;
+    meta?: Record<string, unknown>;
+};
+export type NormalizedCBPMessage = NormalizedEventMessage | NormalizedActionRequestMessage | NormalizedActionResponseMessage | NormalizedApiRequestMessage | NormalizedApiResponseMessage | NormalizedControlMessage;
+export type CBPClientOptions = {
+    open?: () => void;
+    isFullReceive?: boolean;
+};
+export type ActionReplyFunc = (data: Actions, consume: (payload: Result[]) => void) => void;
+export type ApiReplyFunc = (data: Apis, consume: (payload: Result[]) => void) => void;

package/lib/{cbp/connects/base.js → common/cbp/ws-connector.js}

@@ -1,16 +1,14 @@
 import { WebSocket } from 'ws';
-import { ResultCode } from '../../core/variable.js';
-import 'fs';
-import 'path';
-import 'yaml';
-import '../../core/utils.js';
-import { deviceId, DEVICE_ID_HEADER, USER_AGENT_HEADER, reconnectInterval } from '../processor/config.js';
-import { useHeartbeat } from './connect.js';
+import { logger } from '../logger.js';
+import { ResultCode } from '../variable.js';
+import { DEVICE_ID_HEADER, USER_AGENT_HEADER, reconnectInterval } from './constants.js';
+import { deviceId } from './runtime.js';
+import { useHeartbeat } from './heartbeat.js';
 
 const createWSConnector = (options) => {
     const { url, role, onOpen, onMessage, extraHeaders = {}, globalKey } = options;
     if (global[globalKey]) {
-        delete global[globalKey];
+        Reflect.deleteProperty(global, globalKey);
     }
     const [heartbeatControl] = useHeartbeat({
         ping: () => {
@@ -57,7 +55,7 @@ const createWSConnector = (options) => {
                 message: `${role} 连接关闭，尝试重新连接...`,
                 data: code
             });
-            delete global[globalKey];
+            Reflect.deleteProperty(global, globalKey);
             setTimeout(() => {
                 start();
             }, reconnectInterval);

package/lib/{core → common}/config.d.ts

@@ -1,4 +1,4 @@
-import type { Package } from '../types';
+import type { Package } from '../types/index.js';
 type ConfigValue = {
     [key: string]: any;
     apps?: string[] | {
@@ -55,4 +55,4 @@ declare class ConfigCore<T extends ConfigValue = ConfigValue> {
 export declare const getConfig: <T extends ConfigValue = ConfigValue>() => ConfigCore<T>;
 export declare const getConfigValue: <T extends ConfigValue = ConfigValue>() => T;
 export declare const onWatchConfigValue: <T extends ConfigValue = ConfigValue>(callback: ConfigListener<T>) => (() => void);
-export {};
+export type { ConfigCore, ConfigListener, ConfigValue };

package/lib/{core → common}/config.js

@@ -1,6 +1,7 @@
 import { readFileSync, existsSync, watch, mkdirSync, writeFileSync } from 'fs';
 import { join, dirname } from 'path';
 import YAML from 'yaml';
+import { logger } from './logger.js';
 import { ResultCode } from './variable.js';
 
 class ConfigCore {
@@ -13,6 +14,7 @@ class ConfigCore {
     #argvProxy = null;
     #resolvedDir = null;
     #initValue = {};
+    #package = null;
     constructor(dir) {
         this.#resolvedDir = join(process.cwd(), dir);
     }
@@ -142,7 +144,6 @@ class ConfigCore {
         }
         this.#listeners.clear();
     }
-    #package = null;
     get package() {
         if (this.#package) {
             return this.#package;
@@ -179,9 +180,9 @@ class ConfigCore {
                 if (typeof key === 'symbol') {
                     return undefined;
                 }
-                const index$0 = process.argv.indexOf(key);
-                if (index$0 !== -1) {
-                    return process.argv[index$0 + 1];
+                const index0 = process.argv.indexOf(key);
+                if (index0 !== -1) {
+                    return process.argv[index0 + 1];
                 }
                 const index = process.argv.indexOf(`--${key}`);
                 if (index !== -1) {

package/lib/common/identity.d.ts

@@ -0,0 +1,11 @@
+export declare const matchIn: (source: any, key: string) => boolean;
+export declare const fastHash: (str: string) => string;
+export declare const createUserHashKey: (event: {
+    UserId: string;
+    Platform: string;
+}) => string;
+export declare const useUserHashKey: (event: {
+    UserId: string;
+    Platform: string;
+}) => string;
+export declare const isMaster: (UserId: string, platform: string) => boolean;

package/lib/common/identity.js

@@ -0,0 +1,34 @@
+import { getConfigValue } from './config.js';
+
+const matchIn = (source, key) => {
+    if (Array.isArray(source)) {
+        return source.includes(key);
+    }
+    if (source && typeof source === 'object') {
+        return Object.prototype.hasOwnProperty.call(source, key) && !!source[key];
+    }
+    return false;
+};
+const fastHash = (str) => {
+    let hash = 0x811c9dc5;
+    for (let i = 0; i < str.length; i++) {
+        hash ^= str.charCodeAt(i);
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return (hash >>> 0).toString(36);
+};
+const createUserHashKey = (event) => {
+    return fastHash(`${event.Platform}:${event.UserId}`);
+};
+const useUserHashKey = createUserHashKey;
+const isMaster = (UserId, platform) => {
+    const values = getConfigValue() || {};
+    const value = values[platform] && typeof values[platform] === 'object' ? values[platform] : {};
+    const UserKey = createUserHashKey({
+        Platform: platform,
+        UserId
+    });
+    return matchIn(values.master_key, UserKey) || matchIn(values.master_id, UserId) || matchIn(value.master_key, UserKey) || matchIn(value.master_id, UserId);
+};
+
+export { createUserHashKey, fastHash, isMaster, matchIn, useUserHashKey };

package/lib/common/index.d.ts

@@ -0,0 +1,15 @@
+export * from './config.js';
+export { processorRepeatedEventTime, processorRepeatedUserTime, processorRepeatedClearTimeMin, processorRepeatedClearTimeMax, processorRepeatedClearSize, processorMaxMapSize, fileSuffixMiddleware, fileSuffixResponse, filePrefixCommon, defaultPort, defaultLogin, defaultPlatformPrefix, defaultPlatformCommonPrefix, Ok, Warn, Fail, FailParams, FailAuth, FailInternal, EventMessageText, ResultCode } from './variable.js';
+export * from './logger.js';
+export * from './identity.js';
+export * from './result.js';
+export * from './SinglyLinkedList.js';
+export * from './utils.js';
+export * from './direct-channel.js';
+export * from './react.js';
+export * from './cbp/constants.js';
+export * from './cbp/runtime.js';
+export * from './cbp/heartbeat.js';
+export * from './cbp/ws-connector.js';
+export * from './cbp/normalize.js';
+export * from './cbp/typings.js';

package/lib/common/index.js

@@ -0,0 +1,14 @@
+export { getConfig, getConfigValue, onWatchConfigValue } from './config.js';
+export { EventMessageText, Fail, FailAuth, FailInternal, FailParams, Ok, ResultCode, Warn, defaultLogin, defaultPlatformCommonPrefix, defaultPlatformPrefix, defaultPort, filePrefixCommon, fileSuffixMiddleware, fileSuffixResponse, processorMaxMapSize, processorRepeatedClearSize, processorRepeatedClearTimeMax, processorRepeatedClearTimeMin, processorRepeatedEventTime, processorRepeatedUserTime } from './variable.js';
+export { Logger, logger } from './logger.js';
+export { createUserHashKey, fastHash, isMaster, matchIn, useUserHashKey } from './identity.js';
+export { createResult } from './result.js';
+export { SinglyLinkedList } from './SinglyLinkedList.js';
+export { createEventName, createHash, getCachedRegExp, getInputExportPath, getRecursiveDirFiles, sanitizeForSerialization, showErrorModule, stringToNumber } from './utils.js';
+export { createDirectClient, createDirectServer, generateSocketPath } from './direct-channel.js';
+export { A, Body, Component, DOCTYPE, Div, H1, Head, Html, P, Style, Title, createElement, renderToString } from './react.js';
+export { DEVICE_ID_HEADER, FULL_RECEIVE_HEADER, HEARTBEAT_INTERVAL, USER_AGENT_HEADER, USER_AGENT_HEADER_VALUE_MAP, reconnectInterval, timeoutTime } from './cbp/constants.js';
+export { deviceId, generateUniqueId } from './cbp/runtime.js';
+export { useHeartbeat } from './cbp/heartbeat.js';
+export { createWSConnector } from './cbp/ws-connector.js';
+export { createActionRequestEnvelope, createActionResponseEnvelope, createApiRequestEnvelope, createApiResponseEnvelope, createEventEnvelope, getNormalizedDeviceId, getNormalizedEventRouteId, isCBPEnvelope, isNormalizedActionRequest, isNormalizedApiRequest, normalizeInboundMessage, toLegacyActionData, toLegacyApiData } from './cbp/normalize.js';

package/lib/common/logger.d.ts

@@ -0,0 +1,6 @@
+export declare class Logger {
+    #private;
+    constructor();
+    get value(): any;
+}
+export declare const logger: any;