alemonjs 2.1.82 → 2.1.83-alpha.2

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;

package/lib/common/logger.js

@@ -0,0 +1,99 @@
+import { mkdirSync } from 'node:fs';
+import log4js from 'log4js';
+
+const createLogger = () => {
+    if (process.env.BROWSER_ENV === 'browser') {
+        return {
+            trace: console.trace.bind(console),
+            debug: console.debug.bind(console),
+            info: console.info.bind(console),
+            mark: console.info.bind(console),
+            warn: console.warn.bind(console),
+            error: console.error.bind(console),
+            fatal: console.error.bind(console)
+        };
+    }
+    const logDir = process.env?.LOG_PATH ?? `./logs/${process.env.LOG_NAME ?? ''}`;
+    mkdirSync(logDir, { recursive: true });
+    const level = process.env.NODE_ENV === 'development' ? 'trace' : 'info';
+    const hideTime = process.env.LOGGER_TIME === 'false';
+    const hideLevel = process.env.LOGGER_LEVEL === 'false';
+    let pattern = '';
+    if (hideTime && hideLevel) {
+        pattern = '%m';
+    }
+    else if (hideTime && !hideLevel) {
+        pattern = '[%p] %m';
+    }
+    else if (!hideTime && hideLevel) {
+        pattern = '[%d{yyyy-MM-dd hh:mm:ss}] %m';
+    }
+    else {
+        pattern = '[%d{yyyy-MM-dd hh:mm:ss}][%p] %m';
+    }
+    log4js.configure({
+        appenders: {
+            console: {
+                type: 'console',
+                layout: {
+                    type: 'pattern',
+                    pattern
+                }
+            },
+            command: {
+                type: 'dateFile',
+                filename: `${logDir}/command`,
+                pattern: 'yyyy-MM-dd.log',
+                numBackups: 15,
+                alwaysIncludePattern: true,
+                layout: {
+                    type: 'pattern',
+                    pattern
+                }
+            },
+            error: {
+                type: 'dateFile',
+                filename: `${logDir}/error`,
+                pattern: 'yyyy-MM-dd.log',
+                numBackups: 15,
+                alwaysIncludePattern: true,
+                layout: {
+                    type: 'pattern',
+                    pattern
+                }
+            }
+        },
+        categories: {
+            default: { appenders: ['console'], level },
+            command: { appenders: ['console', 'command'], level: 'info' },
+            error: { appenders: ['console', 'command', 'error'], level: 'warn' }
+        }
+    });
+    const defaultLogger = log4js.getLogger('default');
+    const commandLogger = log4js.getLogger('command');
+    const errorLogger = log4js.getLogger('error');
+    return {
+        trace: defaultLogger.trace.bind(defaultLogger),
+        debug: defaultLogger.debug.bind(defaultLogger),
+        info: commandLogger.info.bind(commandLogger),
+        mark: commandLogger.mark.bind(commandLogger),
+        warn: errorLogger.warn.bind(errorLogger),
+        error: errorLogger.error.bind(errorLogger),
+        fatal: errorLogger.fatal.bind(errorLogger)
+    };
+};
+class Logger {
+    #logger = null;
+    constructor() {
+        this.#logger = createLogger();
+        if (!global.logger) {
+            global.logger = this.#logger;
+        }
+    }
+    get value() {
+        return this.#logger;
+    }
+}
+const logger = new Logger().value;
+
+export { Logger, logger };

package/lib/common/result.d.ts

@@ -0,0 +1,7 @@
+import { ResultCode } from './variable.js';
+export type Result<T = any> = {
+    code: ResultCode;
+    message: string | object;
+    data: T;
+};
+export declare const createResult: <T>(code: ResultCode, message: string | object, data?: T) => Result<T>;

package/lib/common/result.js

@@ -0,0 +1,19 @@
+import { logger } from './logger.js';
+import { ResultCode } from './variable.js';
+
+const createResult = (code, message, data) => {
+    if (code !== ResultCode.Ok) {
+        logger.error({
+            code,
+            message,
+            data
+        });
+    }
+    return {
+        code,
+        message,
+        data
+    };
+};
+
+export { createResult };

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

@@ -1,21 +1,12 @@
 import { Dirent } from 'fs';
-import { ResultCode } from './variable';
+export { createUserHashKey, fastHash, isMaster, matchIn, useUserHashKey } from './identity.js';
+export type { Result } from './result.js';
+export { createResult } from './result.js';
 export declare const createHash: (str: string, options?: {
     length?: number;
     algorithm?: string;
 }) => string;
-export declare const fastHash: (str: string) => string;
 export declare const getCachedRegExp: (pattern: string | RegExp) => RegExp;
-export declare const createUserHashKey: (event: {
-    UserId: string;
-    Platform: string;
-}) => string;
-export declare const useUserHashKey: (event: {
-    UserId: string;
-    Platform: string;
-}) => string;
-export declare const matchIn: (source: any, key: string) => boolean;
-export declare const isMaster: (UserId: string, platform: string) => boolean;
 export declare const createEventName: (url: string, appKey: string) => string;
 export declare const stringToNumber: (str: string, size?: number) => number;
 export declare const getRecursiveDirFiles: (dir: string, condition?: (func: Dirent) => boolean) => {
@@ -25,9 +16,3 @@ export declare const getRecursiveDirFiles: (dir: string, condition?: (func: Dire
 export declare const showErrorModule: (e: Error) => void;
 export declare const sanitizeForSerialization: (data: any) => any;
 export declare const getInputExportPath: (input?: string) => any;
-export type Result<T = any> = {
-    code: ResultCode;
-    message: string | object;
-    data: T;
-};
-export declare const createResult: <T>(code: ResultCode, message: string | object, data?: T) => Result<T>;

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

@@ -1,9 +1,11 @@
 import { createHash as createHash$1 } from 'node:crypto';
 import fs__default, { existsSync, readdirSync } from 'fs';
 import path__default, { join } from 'path';
-import { ResultCode, fileSuffixResponse } from './variable.js';
 import module$1 from 'module';
-import { getConfigValue } from './config.js';
+import { ResultCode, fileSuffixResponse } from './variable.js';
+import { logger } from './logger.js';
+export { createUserHashKey, fastHash, isMaster, matchIn, useUserHashKey } from './identity.js';
+export { createResult } from './result.js';
 
 const initRequire = () => { };
 initRequire.resolve = () => '';
@@ -13,14 +15,6 @@ const createHash = (str, options = {}) => {
     const hash = createHash$1(algorithm).update(str).digest('hex');
     return hash.slice(0, length);
 };
-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 _regexpCache = new Map();
 const getCachedRegExp = (pattern) => {
     if (pattern instanceof RegExp) {
@@ -33,28 +27,6 @@ const getCachedRegExp = (pattern) => {
     }
     return cached;
 };
-const createUserHashKey = (event) => {
-    return fastHash(`${event.Platform}:${event.UserId}`);
-};
-const useUserHashKey = createUserHashKey;
-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 isMaster = (UserId, platform) => {
-    const values = getConfigValue() || {};
-    const value = values[platform] && typeof values[platform] === 'object' ? values[platform] : {};
-    const UserKey = createUserHashKey({
-        Platform: platform,
-        UserId: UserId
-    });
-    return matchIn(values.master_key, UserKey) || matchIn(values.master_id, UserId) || matchIn(value.master_key, UserKey) || matchIn(value.master_id, UserId);
-};
 const createEventName = (url, appKey) => {
     let uri = url;
     if (process.platform === 'win32') {
@@ -62,8 +34,7 @@ const createEventName = (url, appKey) => {
     }
     const names = uri.split('/').filter(item => item !== '');
     names.pop();
-    const name = `${appKey}:${names.join(':')}`;
-    return name;
+    return `${appKey}:${names.join(':')}`;
 };
 const stringToNumber = (str, size = 33) => {
     let hash = 5381;
@@ -140,19 +111,5 @@ const getInputExportPath = (input) => {
         }
     }
 };
-const createResult = (code, message, data) => {
-    if (code !== ResultCode.Ok) {
-        logger.error({
-            code,
-            message,
-            data: data
-        });
-    }
-    return {
-        code,
-        message,
-        data: data
-    };
-};
 
-export { createEventName, createHash, createResult, createUserHashKey, fastHash, getCachedRegExp, getInputExportPath, getRecursiveDirFiles, isMaster, matchIn, sanitizeForSerialization, showErrorModule, stringToNumber, useUserHashKey };
+export { createEventName, createHash, getCachedRegExp, getInputExportPath, getRecursiveDirFiles, sanitizeForSerialization, showErrorModule, stringToNumber };

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

@@ -61,7 +61,7 @@ class Result {
             this.#data[this.#currentIndex] = {
                 code: ResultCode.Ok,
                 message: '',
-                data: data
+                data
             };
         }
         this.#data[this.#currentIndex].data = data;

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

@@ -0,0 +1 @@
+export { cbpServer } from './server/main.js';

package/lib/core/cbp/index.js

@@ -0,0 +1 @@
+export { cbpServer } from './server/main.js';

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

@@ -0,0 +1,8 @@
+import { WebSocket } from 'ws';
+export declare const childrenClient: Map<string, WebSocket>;
+export declare const platformClient: Map<string, WebSocket>;
+export declare const fullClient: Map<string, WebSocket>;
+export declare const childrenBind: Map<string, string>;
+export declare const clientBindCount: Map<string, number>;
+export declare const bindChannelToClient: (channelId: string, clientId: string) => void;
+export declare const unbindClient: (clientId: string) => void;

package/lib/core/cbp/processor/config.js

@@ -0,0 +1,29 @@
+const childrenClient = new Map();
+const platformClient = new Map();
+const fullClient = new Map();
+const childrenBind = new Map();
+const clientBindCount = new Map();
+const bindChannelToClient = (channelId, clientId) => {
+    const oldClientId = childrenBind.get(channelId);
+    if (oldClientId && oldClientId !== clientId) {
+        const oldCount = clientBindCount.get(oldClientId) ?? 0;
+        if (oldCount > 1) {
+            clientBindCount.set(oldClientId, oldCount - 1);
+        }
+        else {
+            clientBindCount.delete(oldClientId);
+        }
+    }
+    childrenBind.set(channelId, clientId);
+    clientBindCount.set(clientId, (clientBindCount.get(clientId) ?? 0) + 1);
+};
+const unbindClient = (clientId) => {
+    for (const [channelId, boundClientId] of childrenBind.entries()) {
+        if (boundClientId === clientId) {
+            childrenBind.delete(channelId);
+        }
+    }
+    clientBindCount.delete(clientId);
+};
+
+export { bindChannelToClient, childrenBind, childrenClient, clientBindCount, fullClient, platformClient, unbindClient };

package/lib/{cbp → core/cbp}/routers/hello.html.js

@@ -1,4 +1,4 @@
-import { Component, Head, Title, Style, Body, H1, P, A, Div, Html } from '../../core/react.js';
+import { Component, Head, Title, Style, Body, H1, P, A, Div, Html } from '../../../common/react.js';
 
 class App extends Component {
     render() {

package/lib/{cbp → core/cbp}/server/main.js

@@ -3,15 +3,41 @@ import { WebSocketServer, WebSocket } from 'ws';
 import * as flattedJSON from 'flatted';
 import koaCors from '@koa/cors';
 import router from '../routers/router.js';
-import { ResultCode } from '../../core/variable.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, clientBindCount, unbindClient, bindChannelToClient } from '../processor/config.js';
+import '../../../common/logger.js';
+import { ResultCode } from '../../../common/variable.js';
+import '../../../common/utils.js';
+import 'net';
+import 'v8';
+import 'os';
+import { USER_AGENT_HEADER, USER_AGENT_HEADER_VALUE_MAP, DEVICE_ID_HEADER, FULL_RECEIVE_HEADER } from '../../../common/cbp/constants.js';
+import '../../../common/cbp/runtime.js';
+import { normalizeInboundMessage, getNormalizedDeviceId, getNormalizedEventRouteId } from '../../../common/cbp/normalize.js';
+import { platformClient, childrenClient, fullClient, childrenBind, clientBindCount, unbindClient, bindChannelToClient } from '../processor/config.js';
 import { createTestOneController } from './testone.js';
 import { getClientChild } from '../../process/ipc-bridge.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 +230,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 +270,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) {

package/lib/{cbp → core/cbp}/server/testone.d.ts

@@ -1,6 +1,6 @@
 import { IncomingMessage } from 'http';
 import { WebSocket } from 'ws';
-import type { ParsedMessage } from '../typings';
+import type { ParsedMessage } from '../../../common/cbp/typings.js';
 export declare const createTestOneController: (ws: WebSocket, _request: IncomingMessage) => {
     onMessage: (parsedMessage: ParsedMessage) => void;
     close: () => void;

package/lib/{cbp → core/cbp}/server/testone.js

@@ -3,9 +3,15 @@ import { join, dirname } from 'path';
 import { existsSync, mkdirSync, watch, readFileSync, writeFile } from 'fs';
 import _ from 'lodash';
 import { readFile } from 'fs/promises';
-import { ResultCode } from '../../core/variable.js';
 import 'yaml';
-import '../../core/utils.js';
+import '../../../common/logger.js';
+import { ResultCode } from '../../../common/variable.js';
+import '../../../common/utils.js';
+import 'net';
+import 'v8';
+import 'os';
+import '../../../common/cbp/runtime.js';
+import 'ws';
 
 const createTestOneController = (ws, _request) => {
     const testonePath = join(process.cwd(), 'testone');

package/lib/core/index.d.ts

@@ -1,3 +1 @@
-export { ResultCode } from './variable.js';
-export * from './config.js';
-export * from './utils.js';
+export { start } from './start.js';

package/lib/core/index.js

@@ -1,3 +1 @@
-export { ResultCode } from './variable.js';
-export { getConfig, getConfigValue, onWatchConfigValue } from './config.js';
-export { createEventName, createHash, createResult, createUserHashKey, fastHash, getCachedRegExp, getInputExportPath, getRecursiveDirFiles, isMaster, matchIn, sanitizeForSerialization, showErrorModule, stringToNumber, useUserHashKey } from './utils.js';
+export { start } from './start.js';

package/lib/core/process/index.d.ts

@@ -0,0 +1,3 @@
+export * from './module.js';
+export * from './platform.js';
+export * from './ipc-bridge.js';

package/lib/{process → core/process}/index.js

@@ -1,4 +1,3 @@
 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 → core/process}/ipc-bridge.js

@@ -4,7 +4,12 @@ import * as flattedJSON from 'flatted';
 import 'fs';
 import 'path';
 import 'yaml';
-import { sanitizeForSerialization } from '../core/utils.js';
+import '../../common/logger.js';
+import { sanitizeForSerialization } from '../../common/utils.js';
+import 'net';
+import 'v8';
+import 'os';
+import '../../common/cbp/runtime.js';
 
 let platformChild = null;
 let clientChild = null;

package/lib/{process → core/process}/module.js

@@ -1,7 +1,16 @@
 import childProcess from 'child_process';
-import { ResultCode } from '../core/variable.js';
-import { getConfigValue } from '../core/config.js';
-import '../core/utils.js';
+import { getConfigValue } from '../../common/config.js';
+import { ResultCode } from '../../common/variable.js';
+import '../../common/logger.js';
+import '../../common/utils.js';
+import 'net';
+import 'v8';
+import 'os';
+import 'path';
+import 'fs';
+import 'flatted';
+import '../../common/cbp/runtime.js';
+import 'ws';
 import module$1 from 'module';
 import { setClientChild, forwardFromClient } from './ipc-bridge.js';
 
@@ -17,7 +26,7 @@ function startModuleAdapter() {
         FORK_TIMEOUT: pro?.fork_timeout ?? 6000
     };
     try {
-        modulePath = require$1.resolve('../client.js');
+        modulePath = require$1.resolve('../../client.js');
     }
     catch (error) {
         logger?.warn?.({

package/lib/{process → core/process}/platform.js

@@ -1,7 +1,16 @@
 import childProcess from 'child_process';
-import { ResultCode } from '../core/variable.js';
-import { getConfigValue } from '../core/config.js';
-import '../core/utils.js';
+import { getConfigValue } from '../../common/config.js';
+import { ResultCode } from '../../common/variable.js';
+import '../../common/logger.js';
+import '../../common/utils.js';
+import 'net';
+import 'v8';
+import 'os';
+import 'path';
+import 'fs';
+import 'flatted';
+import '../../common/cbp/runtime.js';
+import 'ws';
 import module$1 from 'module';
 import { setPlatformChild, forwardFromPlatform } from './ipc-bridge.js';
 

package/lib/core/start.d.ts

@@ -0,0 +1,2 @@
+import type { StartOptions } from '../types';
+export declare const start: (options?: StartOptions | string) => void;

package/lib/core/start.js

@@ -0,0 +1,76 @@
+import { getConfig } from '../common/config.js';
+import { cbpServer } from './cbp/server/main.js';
+import { filePrefixCommon, defaultPlatformCommonPrefix } from '../common/variable.js';
+import { startPlatformAdapterWithFallback } from './process/platform.js';
+import { startModuleAdapter } from './process/module.js';
+import { generateSocketPath } from '../common/direct-channel.js';
+
+const createOptionsByKey = (options, key, defaultValue) => {
+    const cfg = getConfig();
+    const curValue = options?.[key] ?? cfg.argv?.[key];
+    const value = curValue ?? cfg.value?.[key] ?? defaultValue;
+    return value;
+};
+const startPlatform = (options) => {
+    const platform = createOptionsByKey(options, 'platform', '');
+    const login = createOptionsByKey(options, 'login', '');
+    if (!platform && !login) {
+        global.__sandbox = true;
+        return;
+    }
+    void startPlatformAdapterWithFallback();
+};
+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', '') || '');
+    process.env.url = createOptionsByKey(options, 'url', '');
+    startModuleAdapter();
+};
+const start = (options = {}) => {
+    if (typeof options === 'string') {
+        options = { input: options };
+    }
+    global.__options = options;
+    const port = createOptionsByKey(options, 'port', '');
+    const serverPort = createOptionsByKey(options, 'serverPort', '');
+    const platform = createOptionsByKey(options, 'platform', '');
+    const login = createOptionsByKey(options, 'login', '');
+    if (platform) {
+        const reg = filePrefixCommon;
+        if (reg.test(platform)) {
+            process.env.platform = platform;
+            process.env.login = platform.replace(reg, '');
+        }
+        else {
+            process.env.platform = platform;
+            process.env.login = platform;
+        }
+    }
+    else if (login) {
+        process.env.platform = `${defaultPlatformCommonPrefix}${login}`;
+        process.env.login = login;
+    }
+    process.env.port = port ? String(port) : '';
+    process.env.serverPort = serverPort;
+    if (port) {
+        cbpServer(port, () => {
+            const httpURL = `http://127.0.0.1:${port}`;
+            const wsURL = `ws://127.0.0.1:${port}`;
+            logger.info(`[CBP-Server] ${httpURL}`);
+            logger.info(`[CBP-Server] ${wsURL}]`);
+            startClient(options);
+            startPlatform(options);
+        });
+    }
+    else {
+        const sockPath = generateSocketPath();
+        process.env.__ALEMON_DIRECT_SOCK = sockPath;
+        logger.info('[Direct-IPC] 平台↔客户端直连');
+        startClient(options);
+        startPlatform(options);
+    }
+};
+
+export { start };

package/lib/global.d.ts

@@ -1,8 +1,9 @@
 import type { DefineChildrenFunc, OnResponseReversalFunc, OnMiddlewareReversalFunc, OnSelectsFunc, OnDataFormatFunc, OnResponseReversalFuncBack, OnGroupFunc, OnMiddlewareReversalFuncBack, DefineResponseFunc, defineMiddlewareFunc, StoreChildrenApp, StateSubscribeMap, SubscribeKeysMap, LoggerUtils, ResponseState, StartOptions } from './types';
-import WebSocket, { Server } from 'ws';
-import { IncomingMessage } from 'http';
+import { type Server } from 'ws';
+import type WebSocket from 'ws';
+import type { IncomingMessage } from 'http';
 import type KoaRouter from 'koa-router';
-import type { RuntimeAppRecord } from './app/store.js';
+import type { RuntimeAppRecord } from './application/runtime/store.js';
 declare global {
     var __config: any;
     var __options: StartOptions;