alemonjs 2.1.0-alpha.44 → 2.1.0-alpha.45

package/lib/adapter.js

@@ -1,220 +1,122 @@
 import { fork } from 'child_process';
 import { createRequire } from 'module';
-import path from 'path';
-import { fileURLToPath } from 'url';
 
 const require = createRequire(import.meta.url);
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-let currentChild;
-let imported = false;
-let shuttingDown = false;
-let externalSignal = false;
-let restartScheduled = false;
-let started = false; // 防止重复 start
-let restartAttempts = 0; // 记录连续重启次数
-const RESTART_BASE_DELAY = 3000; // ms
-const RESTART_MAX_DELAY = 20000; // ms
-function calcBackoffDelay() {
-    if (restartAttempts <= 1) {
-        return RESTART_BASE_DELAY;
-    }
-    const delay = RESTART_BASE_DELAY * Math.pow(2, restartAttempts - 1);
-    return Math.min(delay, RESTART_MAX_DELAY);
-}
-function terminateChild(reason) {
-    if (currentChild && !currentChild.killed) {
-        try {
-            logger?.debug?.(`终止平台子进程 pid=${currentChild.pid}${reason ? ' reason=' + reason : ''}`);
-            try {
-                currentChild.send?.(JSON.stringify({ type: 'shutdown' }));
-            }
-            catch { }
-            currentChild.removeAllListeners();
-            currentChild.kill('SIGTERM');
-            setTimeout(() => {
-                if (currentChild && !currentChild.killed) {
-                    try {
-                        currentChild.kill('SIGKILL');
-                    }
-                    catch { }
-                }
-            }, 2000).unref?.();
-        }
-        catch (e) {
-            logger?.warn?.('终止子进程失败', e);
-        }
-    }
-    currentChild = undefined;
-}
-function setupSignals() {
-    ['SIGINT', 'SIGTERM', 'SIGQUIT'].forEach(sig => {
-        process.once(sig, s => {
-            externalSignal = true;
-            shuttingDown = true;
-            terminateChild(`parent ${s}`);
-            setImmediate(() => process.exit(0));
-        });
-    });
-    process.on('disconnect', () => {
-        externalSignal = true;
-        shuttingDown = true;
-        terminateChild('parent disconnect');
-        setTimeout(() => process.exit(0), 10);
-    });
-}
-async function startByImport(modulePath) {
-    if (imported) {
-        return;
-    }
-    imported = true;
-    try {
-        if (!modulePath.startsWith('file://')) {
-            modulePath = 'file://' + modulePath;
-        }
-        const mod = await import(modulePath);
-        if (typeof mod.default === 'function') {
-            await mod.default();
-            logger?.debug?.('平台连接已就绪（import 模式）');
-        }
-        else {
-            logger?.warn?.('import 启动，但未找到默认导出函数');
-        }
-    }
-    catch (err) {
-        logger?.error?.('import 启动平台连接失败', err);
-    }
-}
-function startByFork(modulePath) {
-    if (imported) {
-        return;
-    }
-    let ready = false;
-    const watchdog = path.join(__dirname, 'child-watchdog.cjs');
-    const execArgv = Array.from(new Set([...(process.execArgv || []), '--require', watchdog]));
-    try {
-        currentChild = fork(modulePath, {
-            stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
-            execArgv,
-            env: { ...process.env, ALEMON_PARENT_PID: String(process.pid) }
-        });
-    }
-    catch (err) {
-        logger?.warn?.('fork 启动失败，降级 import', err);
-        void startByImport(modulePath);
-        return;
-    }
-    // 超时检测
-    const timeout = setTimeout(() => {
-        if (!ready && !imported && !shuttingDown) {
-            (async () => {
-                logger?.warn?.('子进程未及时 ready，降级 import');
-                terminateChild('timeout');
-                await startByImport(modulePath);
-            })().catch(() => { });
-        }
-    }, 2000);
-    currentChild.on('message', msg => {
-        try {
-            const data = typeof msg === 'string' ? JSON.parse(msg) : msg;
-            if (data?.type === 'ready') {
-                ready = true;
-                clearTimeout(timeout);
-                logger?.debug?.('平台连接已就绪（fork 模式）');
-                currentChild?.send(JSON.stringify({ type: 'start' }));
-            }
-        }
-        catch (e) {
-            logger?.error?.('子进程消息解析失败', e);
-        }
-    });
-    currentChild.on('exit', (code, signal) => {
-        clearTimeout(timeout);
-        if (shuttingDown || externalSignal || imported) {
-            return;
-        }
-        if (process.env.ALEMON_DISABLE_RESTART === '1') {
-            logger?.warn?.(`子进程退出 code=${code} signal=${signal}，已禁用自动重启 (ALEMON_DISABLE_RESTART=1)`);
-            return;
-        }
-        if (!restartScheduled) {
-            restartScheduled = true;
-            restartAttempts++;
-            const delay = calcBackoffDelay();
-            logger?.warn?.(`子进程退出 code=${code} signal=${signal}，${delay / 1000}s 后重启 (attempt=${restartAttempts})`);
-            setTimeout(() => {
-                if (shuttingDown || externalSignal) {
-                    restartScheduled = false;
-                    return;
-                }
-                restartScheduled = false;
-                startByFork(modulePath);
-            }, delay);
-        }
-    });
-}
+/**
+ * 启动平台平台连接，优先使用子进程（fork），如不支持或平台连接未响应，则自动降级为 import 动态加载。
+ * 自动兼容新老版本平台连接。
+ * @param modulePath 平台连接模块绝对路径（require.resolve 得到的）
+ * @param env 环境变量对象
+ * @param logger 日志对象（需实现 info/warn/error）
+ */
 function startAdapterWithFallback() {
-    if (started) {
-        return; // 避免重复调用
-    }
-    started = true;
     let modulePath = '';
     try {
         modulePath = require.resolve(process.env.platform);
     }
     catch {
         void import(process.env.platform).then(res => res?.default());
-        logger?.warn?.('平台连接包不支持 require，降级 import');
+        logger?.warn?.('平台连接包未支持 require，降级为 import 加载, 请升级对应的平台连接包以提高进程稳定性');
         return;
     }
-    setupSignals();
-    if (process.env.ALEMON_NO_FORK === '1') {
-        logger?.info?.('ALEMON_NO_FORK=1 -> 直接 import 启动');
-        void startByImport(modulePath);
-        return;
-    }
-    startByFork(modulePath);
-}
-// 父进程（如果本身也是子进程）收到上层 shutdown 指令
-if (typeof process.send === 'function') {
-    process.on('message', msg => {
-        try {
-            const data = typeof msg === 'string' ? JSON.parse(msg) : msg;
-            if (data?.type === 'shutdown') {
-                shuttingDown = true;
-                terminateChild('parent-shutdown');
+    let imported = false; // 标记 import 是否已成功，避免重复
+    const startByFork = () => {
+        if (imported) {
+            return; // 如果已经 import 成功，不再 fork
+        }
+        let restarted = false;
+        let ready = false;
+        let child;
+        const restart = () => {
+            if (restarted || imported) {
+                return;
+            }
+            restarted = true;
+            if (child) {
+                child.removeAllListeners();
                 try {
-                    process.send?.(JSON.stringify({ type: 'shutdown-ack' }));
+                    child.kill();
                 }
                 catch { }
-                setTimeout(() => process.exit(0), 60);
             }
-        }
-        catch { }
-    });
-}
-// stdin 指令触发优雅关闭（供 Go 或其他语言写入）
-try {
-    if (!process.stdin.destroyed) {
-        let buffer = '';
-        process.stdin.on('data', chunk => {
-            buffer += chunk.toString();
-            if (buffer.includes('\n')) {
-                const lines = buffer.split(/\r?\n/);
-                buffer = lines.pop() || '';
-                for (const line of lines) {
-                    const text = line.trim().toLowerCase();
-                    if (['shutdown', 'quit', 'exit'].includes(text)) {
-                        shuttingDown = true;
-                        terminateChild('stdin-cmd');
-                        setTimeout(() => process.exit(0), 30);
-                        break;
+            setTimeout(() => {
+                startByFork();
+            }, 3000);
+        };
+        try {
+            child = fork(modulePath);
+            // 超时
+            const checkTimeout = async () => {
+                if (!ready && !imported) {
+                    logger?.warn?.('平台连接未及时响应（未发送 ready 消息），降级为 import 加载, 请升级对应的平台连接包以提高进程稳定性');
+                    try {
+                        child?.kill();
+                    }
+                    catch { }
+                    await startByImport();
+                }
+            };
+            const timer = setTimeout(() => void checkTimeout(), 2000);
+            child.on('exit', (code, signal) => {
+                clearTimeout(timer);
+                if (!imported) {
+                    logger?.warn?.(`平台连接子进程已退出，code=${code}, signal=${signal}，3秒后自动重启`);
+                    restart();
+                }
+            });
+            child.on('message', msg => {
+                try {
+                    const data = typeof msg === 'string' ? JSON.parse(msg) : msg;
+                    if (data?.type === 'ready') {
+                        ready = true;
+                        clearTimeout(timer);
+                        logger?.debug?.('平台连接已就绪（子进程 fork 模式）');
+                        child?.send?.({ type: 'start' });
                     }
                 }
+                catch (err) {
+                    logger?.error?.('平台连接进程通信数据格式错误', err);
+                }
+            });
+        }
+        catch (err) {
+            logger?.warn?.('fork 启动平台连接失败，将尝试 import 加载', err);
+            void startByImport();
+        }
+    };
+    const startByImport = async () => {
+        if (imported) {
+            return;
+        }
+        imported = true;
+        try {
+            let importPath = modulePath;
+            if (!importPath.startsWith('file://')) {
+                importPath = 'file://' + importPath;
             }
-        });
-    }
+            const mod = await import(importPath);
+            if (typeof mod.default === 'function') {
+                await mod.default();
+                logger?.debug?.('通过 import 启动平台连接完成');
+            }
+            else {
+                logger?.warn?.('通过 import 启动平台连接，但未找到默认导出函数');
+            }
+        }
+        catch (err) {
+            logger?.error?.('import 启动平台连接失败', err);
+        }
+    };
+    startByFork();
 }
-catch { }
+['SIGINT', 'SIGTERM', 'SIGQUIT', 'disconnect'].forEach(sig => {
+    process?.on?.(sig, () => {
+        logger?.info?.(`[${sig}] 收到信号，正在关闭...`);
+        setImmediate(() => process.exit(0));
+    });
+});
+process?.on?.('exit', (code) => {
+    logger?.info?.(`[exit] 进程退出，code=${code}`);
+});
 
 export { startAdapterWithFallback };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alemonjs",
-  "version": "2.1.0-alpha.44",
+  "version": "2.1.0-alpha.45",
   "description": "bot script",
   "author": "lemonade",
   "license": "MIT",