alemonjs 2.1.81 → 2.1.83-alpha.1

package/lib/cbp/normalize.js

@@ -0,0 +1,328 @@
+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/cbp/processor/actions.js

@@ -4,36 +4,38 @@ import 'fs';
 import 'path';
 import 'yaml';
 import { sanitizeForSerialization, createResult } from '../../core/utils.js';
-import { generateUniqueId, deviceId, actionResolves, actionTimeouts, timeoutTime } from './config.js';
+import { generateUniqueId, deviceId, actionRequestResolves, actionRequestTimeouts, timeoutTime } from './config.js';
 import { getDirectSend } from './transport.js';
+import { createActionRequestEnvelope } from '../normalize.js';
 
-const setupActionResolve = (actionId, resolve) => {
-    actionResolves.set(actionId, resolve);
+const setupActionResolve = (requestId, resolve) => {
+    actionRequestResolves.set(requestId, resolve);
     const timeout = setTimeout(() => {
-        if (!actionResolves.has(actionId) || !actionTimeouts.has(actionId)) {
+        if (!actionRequestResolves.has(requestId) || !actionRequestTimeouts.has(requestId)) {
             return;
         }
-        actionResolves.delete(actionId);
-        actionTimeouts.delete(actionId);
+        actionRequestResolves.delete(requestId);
+        actionRequestTimeouts.delete(requestId);
         resolve([createResult(ResultCode.Fail, '行为超时', null)]);
     }, timeoutTime);
-    actionTimeouts.set(actionId, timeout);
+    actionRequestTimeouts.set(requestId, timeout);
 };
 const sendAction = (data) => {
-    const actionId = generateUniqueId();
+    const requestId = generateUniqueId();
     return new Promise(resolve => {
-        data.actionId = actionId;
+        data.actionId = requestId;
         data.DeviceId = deviceId;
-        const safeData = sanitizeForSerialization(data);
+        const envelope = createActionRequestEnvelope(data);
+        const safeData = sanitizeForSerialization(envelope);
         const directSend = getDirectSend();
         if (directSend) {
             directSend(safeData);
-            setupActionResolve(actionId, resolve);
+            setupActionResolve(requestId, resolve);
             return;
         }
         if (process.env.__ALEMON_IPC === '1' && typeof process.send === 'function') {
             process.send({ type: 'ipc:data', data: safeData });
-            setupActionResolve(actionId, resolve);
+            setupActionResolve(requestId, resolve);
             return;
         }
         if (!global.chatbotClient?.send) {
@@ -41,7 +43,7 @@ const sendAction = (data) => {
             return;
         }
         global.chatbotClient?.send(flattedJSON.stringify(safeData));
-        setupActionResolve(actionId, resolve);
+        setupActionResolve(requestId, resolve);
     });
 };
 

package/lib/cbp/processor/api.js

@@ -3,37 +3,39 @@ import 'fs';
 import 'path';
 import 'yaml';
 import { sanitizeForSerialization, createResult } from '../../core/utils.js';
-import { generateUniqueId, deviceId, apiResolves, apiTimeouts, timeoutTime } from './config.js';
+import { generateUniqueId, deviceId, apiRequestResolves, apiRequestTimeouts, timeoutTime } from './config.js';
 import * as flattedJSON from 'flatted';
 import { getDirectSend } from './transport.js';
+import { createApiRequestEnvelope } from '../normalize.js';
 
-const setupApiResolve = (apiId, resolve) => {
-    apiResolves.set(apiId, resolve);
+const setupApiResolve = (requestId, resolve) => {
+    apiRequestResolves.set(requestId, resolve);
     const timeout = setTimeout(() => {
-        if (!apiResolves.has(apiId) || !apiTimeouts.has(apiId)) {
+        if (!apiRequestResolves.has(requestId) || !apiRequestTimeouts.has(requestId)) {
             return;
         }
-        apiResolves.delete(apiId);
-        apiTimeouts.delete(apiId);
+        apiRequestResolves.delete(requestId);
+        apiRequestTimeouts.delete(requestId);
         resolve([createResult(ResultCode.Fail, '接口超时', null)]);
     }, timeoutTime);
-    apiTimeouts.set(apiId, timeout);
+    apiRequestTimeouts.set(requestId, timeout);
 };
 const sendAPI = (data) => {
-    const ApiId = generateUniqueId();
+    const requestId = generateUniqueId();
     return new Promise(resolve => {
-        data.apiId = ApiId;
+        data.apiId = requestId;
         data.DeviceId = deviceId;
-        const safeData = sanitizeForSerialization(data);
+        const envelope = createApiRequestEnvelope(data);
+        const safeData = sanitizeForSerialization(envelope);
         const directSend = getDirectSend();
         if (directSend) {
             directSend(safeData);
-            setupApiResolve(ApiId, resolve);
+            setupApiResolve(requestId, resolve);
             return;
         }
         if (process.env.__ALEMON_IPC === '1' && typeof process.send === 'function') {
             process.send({ type: 'ipc:data', data: safeData });
-            setupApiResolve(ApiId, resolve);
+            setupApiResolve(requestId, resolve);
             return;
         }
         if (!global.chatbotClient?.send) {
@@ -41,7 +43,7 @@ const sendAPI = (data) => {
             return;
         }
         global.chatbotClient?.send(flattedJSON.stringify(safeData));
-        setupApiResolve(ApiId, resolve);
+        setupApiResolve(requestId, resolve);
     });
 };
 

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

@@ -12,10 +12,14 @@ export declare const USER_AGENT_HEADER_VALUE_MAP: {
 };
 export declare const DEVICE_ID_HEADER = "x-device-id";
 export declare const FULL_RECEIVE_HEADER = "x-full-receive";
-type actionResolvesValue = Result[] | PromiseLike<Result[]>;
-type actionResolvesValueFunc = (value: actionResolvesValue) => void;
-export declare const actionResolves: Map<string, actionResolvesValueFunc>;
-export declare const apiResolves: Map<string, actionResolvesValueFunc>;
+type RequestReplyValue = Result[] | PromiseLike<Result[]>;
+type RequestReplyResolve = (value: RequestReplyValue) => void;
+export declare const actionRequestResolves: Map<string, RequestReplyResolve>;
+export declare const apiRequestResolves: Map<string, RequestReplyResolve>;
+export declare const actionRequestTimeouts: Map<string, NodeJS.Timeout>;
+export declare const apiRequestTimeouts: Map<string, NodeJS.Timeout>;
+export declare const actionResolves: Map<string, RequestReplyResolve>;
+export declare const apiResolves: Map<string, RequestReplyResolve>;
 export declare const actionTimeouts: Map<string, NodeJS.Timeout>;
 export declare const apiTimeouts: Map<string, NodeJS.Timeout>;
 export declare const childrenBind: Map<string, string>;

package/lib/cbp/processor/config.js

@@ -12,10 +12,14 @@ const USER_AGENT_HEADER_VALUE_MAP = {
 };
 const DEVICE_ID_HEADER = 'x-device-id';
 const FULL_RECEIVE_HEADER = 'x-full-receive';
-const actionResolves = new Map();
-const apiResolves = new Map();
-const actionTimeouts = new Map();
-const apiTimeouts = new Map();
+const actionRequestResolves = new Map();
+const apiRequestResolves = new Map();
+const actionRequestTimeouts = new Map();
+const apiRequestTimeouts = new Map();
+const actionResolves = actionRequestResolves;
+const apiResolves = apiRequestResolves;
+const actionTimeouts = actionRequestTimeouts;
+const apiTimeouts = apiRequestTimeouts;
 const childrenBind = new Map();
 const clientBindCount = new Map();
 const bindChannelToClient = (channelId, clientId) => {
@@ -49,4 +53,4 @@ const timeoutTime = 1000 * 60 * 3;
 const reconnectInterval = 1000 * 6;
 const HEARTBEAT_INTERVAL = 1000 * 18;
 
-export { DEVICE_ID_HEADER, FULL_RECEIVE_HEADER, HEARTBEAT_INTERVAL, USER_AGENT_HEADER, USER_AGENT_HEADER_VALUE_MAP, actionResolves, actionTimeouts, apiResolves, apiTimeouts, bindChannelToClient, childrenBind, childrenClient, clientBindCount, deviceId, fullClient, generateUniqueId, platformClient, reconnectInterval, timeoutTime, unbindClient };
+export { DEVICE_ID_HEADER, FULL_RECEIVE_HEADER, HEARTBEAT_INTERVAL, USER_AGENT_HEADER, USER_AGENT_HEADER_VALUE_MAP, actionRequestResolves, actionRequestTimeouts, actionResolves, actionTimeouts, apiRequestResolves, apiRequestTimeouts, apiResolves, apiTimeouts, bindChannelToClient, childrenBind, childrenClient, clientBindCount, deviceId, fullClient, generateUniqueId, platformClient, reconnectInterval, timeoutTime, unbindClient };

package/lib/cbp/server/main.js

@@ -11,7 +11,27 @@ import '../../core/utils.js';
 import { USER_AGENT_HEADER, USER_AGENT_HEADER_VALUE_MAP, DEVICE_ID_HEADER, FULL_RECEIVE_HEADER, platformClient, childrenClient, fullClient, childrenBind, clientBindCount, unbindClient, bindChannelToClient } from '../processor/config.js';
 import { createTestOneController } from './testone.js';
 import { getClientChild } from '../../process/ipc-bridge.js';
+import { normalizeInboundMessage, getNormalizedDeviceId, getNormalizedEventRouteId } from '../normalize.js';
 
+const routeNormalizedMessage = (message, input) => {
+    const normalized = normalizeInboundMessage(input);
+    if (!normalized) {
+        return { normalized: null, handled: false };
+    }
+    if (normalized.kind === 'api.res' || normalized.kind === 'action.res') {
+        const resolvedDeviceId = getNormalizedDeviceId(normalized);
+        if (resolvedDeviceId) {
+            routeMessageToDevice(resolvedDeviceId, message);
+        }
+        return { normalized, handled: true };
+    }
+    if (normalized.kind === 'event') {
+        const routeId = getNormalizedEventRouteId(normalized);
+        handleEvent(message, routeId || '');
+        return { normalized, handled: true };
+    }
+    return { normalized, handled: false };
+};
 const routeMessageToDevice = (DeviceId, message) => {
     if (childrenClient.has(DeviceId)) {
         const clientWs = childrenClient.get(DeviceId);
@@ -204,24 +224,13 @@ const setPlatformClient = (originId, ws) => {
     platformClient.set(originId, ws);
     ws.on('message', (message) => {
         try {
-            const parsedMessage = flattedJSON.parse(message.toString());
+            const inbound = flattedJSON.parse(message.toString());
+            routeNormalizedMessage(message.toString(), inbound);
             logger.debug({
                 code: ResultCode.Ok,
                 message: '服务端接收到消息',
-                data: parsedMessage
+                data: inbound
             });
-            if (parsedMessage.apiId) {
-                const DeviceId = parsedMessage.DeviceId;
-                routeMessageToDevice(DeviceId, message);
-            }
-            else if (parsedMessage?.actionId) {
-                const DeviceId = parsedMessage.DeviceId;
-                routeMessageToDevice(DeviceId, message);
-            }
-            else if (parsedMessage?.name) {
-                const ID = parsedMessage.ChannelId || parsedMessage.GuildId || parsedMessage.DeviceId;
-                handleEvent(message, ID);
-            }
         }
         catch (error) {
             logger.error({
@@ -255,26 +264,15 @@ const setTestOnePlatformClient = (ws) => {
     const controller = createTestOneController(ws);
     ws.on('message', (message) => {
         try {
-            const parsedMessage = flattedJSON.parse(message.toString());
+            const inbound = flattedJSON.parse(message.toString());
+            const { handled } = routeNormalizedMessage(message.toString(), inbound);
             logger.debug({
                 code: ResultCode.Ok,
                 message: '测试端接收到消息',
-                data: parsedMessage
+                data: inbound
             });
-            if (parsedMessage.apiId) {
-                const DeviceId = parsedMessage.DeviceId;
-                routeMessageToDevice(DeviceId, message);
-            }
-            else if (parsedMessage?.actionId) {
-                const DeviceId = parsedMessage.DeviceId;
-                routeMessageToDevice(DeviceId, message);
-            }
-            else if (parsedMessage?.name) {
-                const ID = parsedMessage.ChannelId || parsedMessage.GuildId || parsedMessage.DeviceId;
-                handleEvent(message, ID);
-            }
-            else {
-                controller.onMessage(parsedMessage);
+            if (!handled) {
+                controller.onMessage(inbound);
             }
         }
         catch (error) {