alemonjs 2.1.0-alpha.42 → 2.1.0-alpha.44

package/lib/adapter.js

@@ -1,114 +1,220 @@
 import { fork } from 'child_process';
 import { createRequire } from 'module';
+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 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);
+        }
+    });
+}
 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;
     }
-    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();
+    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');
                 try {
-                    child.kill();
+                    process.send?.(JSON.stringify({ type: 'shutdown-ack' }));
                 }
                 catch { }
+                setTimeout(() => process.exit(0), 60);
             }
-            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(JSON.stringify({ type: 'start' }));
+        }
+        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;
                     }
                 }
-                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 { }
 
 export { startAdapterWithFallback };

package/package.json

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