alemonjs 2.1.89 → 2.1.91

package/lib/core/process/platform.js

@@ -17,14 +17,311 @@ import { setPlatformChild, forwardFromPlatform } from './ipc-bridge.js';
 const initRequire = () => { };
 initRequire.resolve = () => '';
 const require$1 = module$1?.createRequire?.(import.meta.url) ?? initRequire;
-function startPlatformAdapterWithFallback() {
+const createInitialState = () => ({
+    phase: 'idle',
+    protocolVersion: 'legacy',
+    transportMode: 'unknown',
+    restartCount: 0,
+    consecutiveFailures: 0,
+    legacyReadyMode: false,
+    bootTimings: {},
+    lastError: null
+});
+let platformManager = null;
+let platformState = createInitialState();
+let platformProcessConfig = null;
+let platformBootstrapPath = '';
+let platformEntryPath = '';
+const normalizeErrorMessage = (error) => {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return typeof error === 'string' ? error : 'Unknown process adapter error';
+};
+const isDebugEnabled = () => process.env.NODE_ENV === 'development';
+const debugLog = (message, data = {}) => {
+    if (!isDebugEnabled()) {
+        return;
+    }
+    logger.debug?.({
+        message,
+        data
+    });
+};
+const clearTimer = (timer) => {
+    if (timer) {
+        clearTimeout(timer);
+    }
+};
+const clearManagerTimers = (manager) => {
+    clearTimer(manager?.controlTimer);
+    clearTimer(manager?.transportTimer);
+    clearTimer(manager?.appTimer);
+    clearTimer(manager?.legacyTransportTimer);
+    if (manager) {
+        manager.controlTimer = undefined;
+        manager.transportTimer = undefined;
+        manager.appTimer = undefined;
+        manager.legacyTransportTimer = undefined;
+    }
+};
+const buildConfig = () => {
     const values = getConfigValue();
     const pro = values?.process ?? {};
-    const CONFIG = {
-        RESTART_DELAY: pro?.restart_delay ?? 3000,
-        FORK_TIMEOUT: pro?.fork_timeout ?? 6000,
-        FORK_RESTART_DELAY: pro?.fork_restart_delay ?? 5000
+    return {
+        restartDelay: Number(pro?.restart_delay ?? 3000),
+        controlReadyTimeout: Number(pro?.control_ready_timeout ?? 10000),
+        transportReadyTimeout: Number(pro?.transport_ready_timeout ?? 15000),
+        appReadyTimeout: Number(pro?.app_ready_timeout ?? 30000),
+        maxRestartDelay: Number(pro?.max_restart_delay ?? 30000),
+        legacyTransportGraceMs: Number(pro?.legacy_transport_grace_ms ?? 50)
+    };
+};
+const resetBootState = () => {
+    platformState = {
+        ...platformState,
+        phase: 'booting',
+        protocolVersion: 'legacy',
+        transportMode: 'unknown',
+        legacyReadyMode: false,
+        startedAt: Date.now(),
+        lastReadyAt: undefined,
+        lastTransportReadyAt: undefined,
+        lastAppReadyAt: undefined,
+        bootTimings: {},
+        lastError: null
+    };
+};
+const updateTransportBinding = (transportMode) => {
+    if (transportMode === 'ipc' && platformManager?.child) {
+        setPlatformChild(platformManager.child);
+    }
+    else {
+        setPlatformChild(null);
+    }
+};
+const markFailure = (error) => {
+    platformState = {
+        ...platformState,
+        phase: 'failed',
+        lastError: error ? normalizeErrorMessage(error) : platformState.lastError,
+        consecutiveFailures: platformState.consecutiveFailures + 1
+    };
+};
+const markTransportReady = (transport, legacyReadyMode = false) => {
+    const now = Date.now();
+    if (!platformManager) {
+        return;
+    }
+    platformManager.transportReady = true;
+    clearTimer(platformManager.transportTimer);
+    clearTimer(platformManager.legacyTransportTimer);
+    platformManager.transportTimer = undefined;
+    platformManager.legacyTransportTimer = undefined;
+    platformState = {
+        ...platformState,
+        phase: platformState.lastAppReadyAt ? 'app_ready' : 'transport_ready',
+        transportMode: transport,
+        lastTransportReadyAt: now,
+        legacyReadyMode,
+        consecutiveFailures: 0,
+        bootTimings: {
+            ...platformState.bootTimings,
+            readyToTransportReadyMs: platformState.lastReadyAt ? now - platformState.lastReadyAt : undefined,
+            transportReadyToAppReadyMs: platformState.lastAppReadyAt ? platformState.lastAppReadyAt - now : platformState.bootTimings.transportReadyToAppReadyMs
+        }
+    };
+    updateTransportBinding(transport);
+    if (legacyReadyMode) {
+        debugLog('platform adapter fallback to legacy transport ready');
+    }
+};
+const scheduleRestart = (reason) => {
+    if (!platformProcessConfig || !platformBootstrapPath || !platformEntryPath) {
+        return;
+    }
+    const baseDelay = platformProcessConfig.restartDelay;
+    const delay = Math.min(baseDelay * 2 ** Math.max(platformState.consecutiveFailures - 1, 0), platformProcessConfig.maxRestartDelay);
+    platformState = {
+        ...platformState,
+        restartCount: platformState.restartCount + 1
     };
+    debugLog('schedule platform adapter restart', { reason, delay });
+    setTimeout(() => {
+        void startPlatformAdapterWithFallback();
+    }, delay);
+};
+const cleanupManager = (manager) => {
+    clearManagerTimers(manager);
+    if (manager?.child) {
+        manager.child.removeAllListeners();
+    }
+    setPlatformChild(null);
+    if (platformManager === manager) {
+        platformManager = null;
+    }
+};
+const startByImport = async () => {
+    try {
+        const importPath = platformEntryPath.startsWith('file://') ? platformEntryPath : `file://${platformEntryPath}`;
+        const mod = await import(importPath);
+        const run = typeof mod.default === 'function' ? mod.default : typeof mod.main === 'function' ? mod.main : null;
+        if (typeof run !== 'function') {
+            throw new Error('Platform entry must export a callable default or main function');
+        }
+        await run();
+        platformState = {
+            ...platformState,
+            phase: 'app_ready',
+            protocolVersion: 'legacy',
+            transportMode: 'import',
+            consecutiveFailures: 0,
+            lastTransportReadyAt: Date.now(),
+            lastAppReadyAt: Date.now()
+        };
+        debugLog('platform adapter started via import fallback');
+    }
+    catch (error) {
+        logger?.error?.({
+            code: ResultCode.Fail,
+            message: 'import 启动平台连接失败',
+            data: error
+        });
+        markFailure(error);
+        scheduleRestart('import_fallback_failed');
+    }
+};
+const handleControlReady = (manager, message) => {
+    const protocolVersion = message.protocolVersion === 'v2' ? 'v2' : 'legacy';
+    const now = Date.now();
+    manager.protocolVersion = protocolVersion;
+    clearTimer(manager.controlTimer);
+    manager.controlTimer = undefined;
+    platformState = {
+        ...platformState,
+        phase: 'control_ready',
+        protocolVersion,
+        legacyReadyMode: protocolVersion === 'legacy',
+        lastReadyAt: now,
+        bootTimings: {
+            ...platformState.bootTimings,
+            forkToReadyMs: platformState.startedAt ? now - platformState.startedAt : undefined
+        }
+    };
+    manager.child?.send?.({ type: 'start' });
+    if (protocolVersion === 'v2') {
+        manager.transportTimer = setTimeout(() => {
+            logger?.warn?.({
+                code: ResultCode.Fail,
+                message: '平台连接进程未在规定时间内建立通讯层，准备降级/重启',
+                data: null
+            });
+            manager.isKilling = true;
+            manager.fallbackToImportOnExit = Boolean(process.env.port);
+            markFailure('transport_ready_timeout');
+            try {
+                manager.child?.kill();
+            }
+            catch {
+                cleanupManager(manager);
+                if (manager.fallbackToImportOnExit) {
+                    void startByImport();
+                }
+                else {
+                    scheduleRestart('transport_ready_timeout');
+                }
+            }
+        }, platformProcessConfig?.transportReadyTimeout ?? 15000);
+        manager.appTimer = setTimeout(() => {
+            logger?.warn?.({
+                code: ResultCode.Warn,
+                message: '平台连接进程业务初始化较慢，尚未收到 app_ready',
+                data: null
+            });
+        }, platformProcessConfig?.appReadyTimeout ?? 30000);
+    }
+    else {
+        const legacyTransportMode = process.env.__ALEMON_DIRECT_SOCK ? 'direct' : 'ipc';
+        manager.legacyTransportTimer = setTimeout(() => {
+            if (!manager.transportReady) {
+                markTransportReady(legacyTransportMode, true);
+            }
+        }, platformProcessConfig?.legacyTransportGraceMs ?? 50);
+    }
+};
+const handleMessage = (manager, message) => {
+    const data = typeof message === 'string' ? JSON.parse(message) : message;
+    if (data?.type === 'ready') {
+        handleControlReady(manager, data);
+        return;
+    }
+    if (data?.type === 'transport_ready') {
+        markTransportReady(data.transport ?? 'unknown');
+        return;
+    }
+    if (data?.type === 'app_ready') {
+        const now = Date.now();
+        manager.appReady = true;
+        clearTimer(manager.appTimer);
+        manager.appTimer = undefined;
+        platformState = {
+            ...platformState,
+            phase: 'app_ready',
+            lastAppReadyAt: now,
+            bootTimings: {
+                ...platformState.bootTimings,
+                transportReadyToAppReadyMs: platformState.lastTransportReadyAt
+                    ? now - platformState.lastTransportReadyAt
+                    : platformState.bootTimings.transportReadyToAppReadyMs
+            }
+        };
+        return;
+    }
+    if (data?.type === 'boot_error') {
+        platformState = {
+            ...platformState,
+            lastError: normalizeErrorMessage(data.error?.message ?? data.error)
+        };
+        logger?.warn?.({
+            code: ResultCode.Fail,
+            message: `平台连接进程启动阶段失败: ${String(data.stage ?? 'unknown')}`,
+            data: data.error ?? null
+        });
+        return;
+    }
+    if (data?.type === 'ipc:data') {
+        forwardFromPlatform(data.data);
+    }
+};
+const getPlatformAdapterState = () => ({
+    ...platformState,
+    bootTimings: { ...platformState.bootTimings }
+});
+function restartPlatformAdapter() {
+    if (!platformManager?.child) {
+        void startPlatformAdapterWithFallback();
+        return;
+    }
+    if (platformManager.restartRequested) {
+        return;
+    }
+    platformManager.restartRequested = true;
+    platformManager.isKilling = true;
+    platformState = {
+        ...platformState,
+        phase: 'stopping'
+    };
+    clearManagerTimers(platformManager);
+    try {
+        platformManager.child.kill();
+    }
+    catch {
+        cleanupManager(platformManager);
+        scheduleRestart('manual_restart');
+    }
+}
+function startPlatformAdapterWithFallback() {
+    platformProcessConfig = buildConfig();
     const platformPath = process.env.platform;
     if (!platformPath) {
         logger?.error?.({
@@ -32,188 +329,119 @@ function startPlatformAdapterWithFallback() {
             message: '未配置平台连接路径',
             data: null
         });
-        return;
+        platformState = {
+            ...platformState,
+            phase: 'failed',
+            lastError: 'missing platform path'
+        };
+        return Promise.resolve();
     }
-    let modulePath = '';
-    let isForkFailed = false;
-    let imported = false;
     try {
-        modulePath = require$1.resolve(platformPath);
+        platformEntryPath = require$1.resolve(platformPath);
+        platformBootstrapPath = require$1.resolve('../../platform-bootstrap.js');
     }
-    catch {
+    catch (error) {
         logger?.warn?.({
             code: ResultCode.Fail,
             message: '平台连接包未支持 require',
-            data: null
+            data: error
         });
-        return;
+        markFailure(error);
+        return Promise.resolve();
     }
-    const startByImport = async () => {
-        if (imported) {
-            return;
-        }
-        imported = true;
-        isForkFailed = true;
-        try {
-            const importPath = modulePath.startsWith('file://') ? modulePath : `file://${modulePath}`;
-            const mod = await import(importPath);
-            if (typeof mod.default === 'function') {
-                await mod.default();
-                logger?.debug?.({
-                    code: ResultCode.Ok,
-                    message: '通过 import 启动平台连接完成',
-                    data: null
-                });
-            }
-            else {
-                logger?.warn?.({
-                    code: ResultCode.Fail,
-                    message: '通过 import 启动平台连接，但未找到默认导出函数',
-                    data: null
-                });
-            }
-        }
-        catch (error) {
-            logger?.error?.({
-                code: ResultCode.Fail,
-                message: 'import 启动平台连接失败',
-                data: error
-            });
-        }
+    if (platformManager?.child && platformManager.child.exitCode === null && !platformManager.child.killed) {
+        return Promise.resolve();
+    }
+    resetBootState();
+    const manager = {
+        isKilling: false,
+        restartRequested: false,
+        transportReady: false,
+        appReady: false,
+        protocolVersion: 'legacy',
+        fallbackToImportOnExit: false
     };
-    const startByFork = () => {
-        if (imported) {
-            return;
+    platformManager = manager;
+    manager.controlTimer = setTimeout(() => {
+        logger?.error?.({
+            code: ResultCode.Fail,
+            message: '平台连接进程未及时发送 ready，正在重启',
+            data: null
+        });
+        manager.isKilling = true;
+        markFailure('control_ready_timeout');
+        try {
+            manager.child?.kill();
         }
-        if (isForkFailed) {
-            return;
+        catch {
+            cleanupManager(manager);
+            scheduleRestart('control_ready_timeout');
         }
-        const manager = {
-            restarted: false,
-            ready: false,
-            isKilling: false
-        };
-        const cleanup = () => {
-            if (manager.timer) {
-                clearTimeout(manager.timer);
-                manager.timer = undefined;
-            }
-            if (manager.child) {
-                manager.child.removeAllListeners();
-            }
-            setPlatformChild(null);
-        };
-        const restart = () => {
-            if (manager.restarted || imported) {
+    }, platformProcessConfig.controlReadyTimeout);
+    try {
+        manager.child = childProcess.fork(platformBootstrapPath, [], {
+            execArgv: process.execArgv,
+            env: {
+                ...process.env,
+                __ALEMON_IPC: '1',
+                __ALEMON_PLATFORM_ENTRY: platformEntryPath
+            },
+            serialization: 'advanced'
+        });
+        manager.child.on('exit', (code, signal) => {
+            const fallbackToImportOnExit = manager.fallbackToImportOnExit;
+            cleanupManager(manager);
+            if (fallbackToImportOnExit) {
+                void startByImport();
                 return;
             }
-            manager.restarted = true;
-            cleanup();
-            setTimeout(() => {
-                if (!imported && !isForkFailed) {
-                    startByFork();
-                }
-            }, CONFIG.RESTART_DELAY);
-        };
-        const handleForkFailure = (error) => {
-            if (imported) {
+            if (manager.isKilling || manager.restartRequested) {
+                scheduleRestart(manager.restartRequested ? 'manual_restart' : 'timeout_or_kill');
                 return;
             }
-            isForkFailed = true;
-            cleanup();
-            if (!process.env.port) {
+            logger?.warn?.({
+                code: ResultCode.Fail,
+                message: `平台连接子进程已退出，code=${code}, signal=${signal}，稍后自动重启`,
+                data: null
+            });
+            markFailure(`exit:${code ?? 'null'}:${signal ?? 'null'}`);
+            scheduleRestart('unexpected_exit');
+        });
+        manager.child.on('message', message => {
+            try {
+                handleMessage(manager, message);
+            }
+            catch (error) {
                 logger?.error?.({
                     code: ResultCode.Fail,
-                    message: 'fork 启动平台连接失败，当前为纯 IPC 模式（未配置 port），无法降级到 WebSocket，已终止平台连接',
+                    message: '平台连接进程通信数据格式错误',
                     data: error
                 });
-                return;
             }
-            logger?.warn?.({
+        });
+        manager.child.on('error', error => {
+            logger?.error?.({
                 code: ResultCode.Fail,
-                message: 'fork 启动平台连接失败，将尝试 import 加载',
+                message: '平台连接子进程发生错误',
                 data: error
             });
-            void startByImport();
-        };
-        const checkTimeout = () => {
-            if (!manager.ready && !imported) {
-                logger?.warn?.({
-                    code: ResultCode.Fail,
-                    message: '平台连接未及时响应（未发送 ready 消息），降级为 import 加载, 请升级对应的平台连接包以提高进程稳定性',
-                    data: null
-                });
-                manager.isKilling = true;
-                try {
-                    manager.child?.kill();
-                }
-                catch {
-                }
-                handleForkFailure();
-            }
-        };
-        try {
-            manager.child = childProcess.fork(modulePath, [], {
-                execArgv: process.execArgv,
-                env: { ...process.env, __ALEMON_IPC: '1' },
-                serialization: 'advanced'
-            });
-            manager.timer = setTimeout(checkTimeout, CONFIG.FORK_TIMEOUT);
-            manager.child.on('exit', (code, signal) => {
-                cleanup();
-                if (manager.isKilling) {
-                    return;
-                }
-                if (!imported) {
-                    logger?.warn?.({
-                        code: ResultCode.Fail,
-                        message: `平台连接子进程已退出，code=${code}, signal=${signal}，${CONFIG.FORK_RESTART_DELAY / 1000}秒后自动重启`,
-                        data: null
-                    });
-                    restart();
-                }
-            });
-            manager.child.on('message', (message) => {
-                try {
-                    const data = typeof message === 'string' ? JSON.parse(message) : message;
-                    if (data?.type === 'ready') {
-                        if (manager.ready) {
-                            return;
-                        }
-                        manager.ready = true;
-                        if (manager.timer) {
-                            clearTimeout(manager.timer);
-                            manager.timer = undefined;
-                        }
-                        setPlatformChild(manager.child);
-                        logger?.debug?.({
-                            code: ResultCode.Ok,
-                            message: '平台连接已就绪（IPC）',
-                            data: null
-                        });
-                        manager.child?.send?.({ type: 'start' });
-                    }
-                    else if (data?.type === 'ipc:data') {
-                        forwardFromPlatform(data.data);
-                    }
-                }
-                catch (error) {
-                    logger?.error?.({
-                        code: ResultCode.Fail,
-                        message: '平台连接进程通信数据格式错误',
-                        data: error
-                    });
-                }
-            });
-            manager.child.on('error', error => {
-                handleForkFailure(error);
-            });
-        }
-        catch (error) {
-            handleForkFailure(error);
-        }
-    };
-    startByFork();
+            platformState = {
+                ...platformState,
+                lastError: normalizeErrorMessage(error)
+            };
+        });
+    }
+    catch (error) {
+        cleanupManager(manager);
+        logger?.warn?.({
+            code: ResultCode.Fail,
+            message: 'fork 启动平台连接失败',
+            data: error
+        });
+        markFailure(error);
+        scheduleRestart('fork_error');
+    }
+    return Promise.resolve();
 }
 
-export { startPlatformAdapterWithFallback };
+export { getPlatformAdapterState, restartPlatformAdapter, startPlatformAdapterWithFallback };

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

@@ -0,0 +1,22 @@
+export type AdapterPhase = 'idle' | 'booting' | 'control_ready' | 'transport_ready' | 'app_ready' | 'stopping' | 'failed';
+export type AdapterProtocolVersion = 'legacy' | 'v2';
+export type AdapterTransportMode = 'unknown' | 'ipc' | 'direct' | 'ws' | 'import';
+export type AdapterBootTimings = {
+    forkToReadyMs?: number;
+    readyToTransportReadyMs?: number;
+    transportReadyToAppReadyMs?: number;
+};
+export type ProcessAdapterState = {
+    phase: AdapterPhase;
+    protocolVersion: AdapterProtocolVersion;
+    transportMode: AdapterTransportMode;
+    restartCount: number;
+    consecutiveFailures: number;
+    legacyReadyMode: boolean;
+    startedAt?: number;
+    lastReadyAt?: number;
+    lastTransportReadyAt?: number;
+    lastAppReadyAt?: number;
+    bootTimings: AdapterBootTimings;
+    lastError?: string | null;
+};

package/lib/core/process/types.js

@@ -0,0 +1 @@
+

package/lib/global.d.ts

@@ -9,6 +9,7 @@ declare global {
     var __options: StartOptions;
     var __sandbox: boolean | undefined;
     var __client_loaded: boolean | undefined;
+    var __platform_bootstrap_loaded: boolean | undefined;
     var __publicIp: string | undefined;
     var logger: LoggerUtils;
     var alemonjsCore: {
@@ -46,6 +47,8 @@ declare global {
             platform?: string;
             port?: string;
             input?: string;
+            __ALEMON_PLATFORM_ENTRY?: string;
+            __ALEMON_DIRECT_SOCK?: string;
             NODE_ENV?: 'development' | 'production';
         }
     }

package/lib/index.js

@@ -49,6 +49,8 @@ export { expendMiddleware } from './application/runtime/event-processor-middlewa
 export { expendSubscribe, expendSubscribeCreate, expendSubscribeMount, expendSubscribeUnmount } from './application/runtime/event-processor-subscribe.js';
 export { finishCurrentTrace, getCurrentAppName, getCurrentEvent, getCurrentNext, getCurrentPhase, markEventSendAttempt, markEventSendFailure, markEventSendSuccess, recordEventSendResults, withEventContext, withProcessorTrace } from './application/runtime/hook-event-context.js';
 export { getConfig, getConfigValue, onWatchConfigValue } from './common/config.js';
+export { getModuleAdapterState, restartModuleAdapter, startModuleAdapter } from './core/process/module.js';
+export { getPlatformAdapterState, restartPlatformAdapter, startPlatformAdapterWithFallback } from './core/process/platform.js';
 export { loadChildren, loadChildrenFile } from './application/runtime/load-modules/loadChild.js';
 export { loadModels, run } from './application/runtime/load-modules/load.js';
 export { normalizeRoutePath, parseMessageText } from './application/router/parser.js';

package/lib/main.d.ts

@@ -1 +1,2 @@
 export { start } from './core/start.js';
+export { restartModuleAdapter, restartPlatformAdapter, getModuleAdapterState, getPlatformAdapterState } from './core/index.js';

package/lib/main.js

@@ -1 +1,3 @@
 export { start } from './core/start.js';
+export { getModuleAdapterState, restartModuleAdapter } from './core/process/module.js';
+export { getPlatformAdapterState, restartPlatformAdapter } from './core/process/platform.js';