alemonjs 2.1.0-alpha.43 → 2.1.0-alpha.44

package/lib/adapter.js

@@ -1,38 +1,45 @@
 import { fork } from 'child_process';
 import { createRequire } from 'module';
-import { createInterface } from 'readline';
+import path from 'path';
+import { fileURLToPath } from 'url';
 
 const require = createRequire(import.meta.url);
-/**
- * 启动平台平台连接，优先使用子进程（fork），如不支持或平台连接未响应，则自动降级为 import 动态加载。
- * 自动兼容新老版本平台连接。
- * @param modulePath 平台连接模块绝对路径（require.resolve 得到的）
- * @param env 环境变量对象
- * @param logger 日志对象（需实现 info/warn/error）
- */
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
 let currentChild;
-let cleanupRegistered = false;
-let shuttingDown = false; // 标记是否正在整体退出，避免触发重启
+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 : ''}`);
-            // 先尝试发送一个 shutdown 指令（如果对端支持）
+            logger?.debug?.(`终止平台子进程 pid=${currentChild.pid}${reason ? ' reason=' + reason : ''}`);
             try {
                 currentChild.send?.(JSON.stringify({ type: 'shutdown' }));
             }
-            catch { /* ignore */ }
+            catch { }
             currentChild.removeAllListeners();
             currentChild.kill('SIGTERM');
-            // 兜底强杀
             setTimeout(() => {
                 if (currentChild && !currentChild.killed) {
                     try {
                         currentChild.kill('SIGKILL');
                     }
-                    catch { /* ignore */ }
+                    catch { }
                 }
-            }, 3000).unref?.();
+            }, 2000).unref?.();
         }
         catch (e) {
             logger?.warn?.('终止子进程失败', e);
@@ -40,167 +47,174 @@ function terminateChild(reason) {
     }
     currentChild = undefined;
 }
-function registerProcessCleanup() {
-    if (cleanupRegistered) {
-        return;
-    }
-    cleanupRegistered = true;
-    const signals = ['SIGINT', 'SIGTERM', 'SIGQUIT'];
-    const handle = (sig) => {
-        shuttingDown = true;
-        terminateChild(`parent ${sig}`);
-    };
-    signals.forEach(s => process.once(s, handle));
-    process.once('beforeExit', () => handle('beforeExit'));
-    process.once('exit', () => handle('exit'));
-    // 如果父进程与其父断开（例如被主控杀掉），也尝试清理
+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);
     });
 }
-function stopAdapter() {
-    shuttingDown = true;
-    terminateChild('manual stop');
+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 startAdapterWithFallback() {
-    let modulePath = '';
+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 {
-        modulePath = require.resolve(process.env.platform);
+        currentChild = fork(modulePath, {
+            stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
+            execArgv,
+            env: { ...process.env, ALEMON_PARENT_PID: String(process.pid) }
+        });
     }
-    catch {
-        void import(process.env.platform).then(res => res?.default());
-        logger?.warn?.('平台连接包未支持 require，降级为 import 加载, 请升级对应的平台连接包以提高进程稳定性');
+    catch (err) {
+        logger?.warn?.('fork 启动失败，降级 import', err);
+        void startByImport(modulePath);
         return;
     }
-    let imported = false; // 标记 import 是否已成功，避免重复
-    const startByFork = () => {
-        if (imported) {
-            return; // 如果已经 import 成功，不再 fork
+    // 超时检测
+    const timeout = setTimeout(() => {
+        if (!ready && !imported && !shuttingDown) {
+            (async () => {
+                logger?.warn?.('子进程未及时 ready，降级 import');
+                terminateChild('timeout');
+                await startByImport(modulePath);
+            })().catch(() => { });
         }
-        let restarted = false;
-        let ready = false;
-        const restart = () => {
-            if (restarted || imported) {
-                return;
-            }
-            restarted = true;
-            terminateChild('restart');
-            setTimeout(() => {
-                startByFork();
-            }, 3000);
-        };
+    }, 2000);
+    currentChild.on('message', msg => {
         try {
-            currentChild = fork(modulePath);
-            registerProcessCleanup();
-            // 超时
-            const checkTimeout = async () => {
-                if (!ready && !imported) {
-                    logger?.warn?.('平台连接未及时响应（未发送 ready 消息），降级为 import 加载, 请升级对应的平台连接包以提高进程稳定性');
-                    try {
-                        currentChild?.kill();
-                    }
-                    catch { }
-                    await startByImport();
-                }
-            };
-            const timer = setTimeout(() => void checkTimeout(), 2000);
-            currentChild.on('exit', (code, signal) => {
-                clearTimeout(timer);
-                if (shuttingDown) {
-                    logger?.debug?.('父进程正在关闭，忽略子进程退出重启逻辑');
-                    return;
-                }
-                if (!imported) {
-                    logger?.warn?.(`平台连接子进程已退出，code=${code}, signal=${signal}，3秒后自动重启`);
-                    restart();
-                }
-            });
-            currentChild.on('message', msg => {
-                try {
-                    const data = typeof msg === 'string' ? JSON.parse(msg) : msg;
-                    if (data?.type === 'ready') {
-                        ready = true;
-                        clearTimeout(timer);
-                        logger?.debug?.('平台连接已就绪（子进程 fork 模式）');
-                        // 发送启动
-                        currentChild?.send(JSON.stringify({ type: 'start' }));
-                    }
-                }
-                catch (err) {
-                    logger?.error?.('平台连接进程通信数据格式错误', err);
-                }
-            });
+            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 (err) {
-            logger?.warn?.('fork 启动平台连接失败，将尝试 import 加载', err);
-            void startByImport();
+        catch (e) {
+            logger?.error?.('子进程消息解析失败', e);
         }
-    };
-    const startByImport = async () => {
-        if (imported) {
+    });
+    currentChild.on('exit', (code, signal) => {
+        clearTimeout(timeout);
+        if (shuttingDown || externalSignal || 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 启动平台连接，但未找到默认导出函数');
-            }
+        if (process.env.ALEMON_DISABLE_RESTART === '1') {
+            logger?.warn?.(`子进程退出 code=${code} signal=${signal}，已禁用自动重启 (ALEMON_DISABLE_RESTART=1)`);
+            return;
         }
-        catch (err) {
-            logger?.error?.('import 启动平台连接失败', err);
+        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);
         }
-    };
-    startByFork();
+    });
 }
-// 若当前进程本身也是被上层 fork/spawn 的子进程，可接收父进程的 shutdown 指令并级联关闭其内部子进程。
+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');
+        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;
-                stopAdapter();
-                // 给父进程一个确认
+                terminateChild('parent-shutdown');
                 try {
                     process.send?.(JSON.stringify({ type: 'shutdown-ack' }));
                 }
-                catch {
-                    // ignore
-                }
-                // 适当延迟确保子进程杀干净
-                setTimeout(() => process.exit(0), 100);
+                catch { }
+                setTimeout(() => process.exit(0), 60);
             }
         }
-        catch { /* ignore parse errors */ }
+        catch { }
     });
 }
-// 兼容由 Go / 其它语言通过 exec 启动：向 stdin 写入 "shutdown"(换行) 触发优雅退出
+// stdin 指令触发优雅关闭（供 Go 或其他语言写入）
 try {
     if (!process.stdin.destroyed) {
-        const rl = createInterface({ input: process.stdin, crlfDelay: Infinity });
-        rl.on('line', line => {
-            const cmd = line.trim().toLowerCase();
-            if (cmd === 'shutdown' || cmd === 'quit' || cmd === 'exit') {
-                shuttingDown = true;
-                stopAdapter();
-                rl.close();
-                setTimeout(() => process.exit(0), 50);
+        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;
+                    }
+                }
             }
         });
-        // 不阻止进程退出
-        rl.on('close', () => { });
     }
 }
-catch { /* ignore */ }
+catch { }
 
-export { startAdapterWithFallback, stopAdapter };
+export { startAdapterWithFallback };

package/package.json

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