alemonjs 2.1.0-alpha.44 → 2.1.0-alpha.46

package/lib/adapter.js

@@ -1,220 +1,113 @@
 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');
-        return;
-    }
-    setupSignals();
-    if (process.env.ALEMON_NO_FORK === '1') {
-        logger?.info?.('ALEMON_NO_FORK=1 -> 直接 import 启动');
-        void startByImport(modulePath);
+        logger?.warn?.('平台连接包未支持 require，降级为 import 加载, 请升级对应的平台连接包以提高进程稳定性');
         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 { }
 
 export { startAdapterWithFallback };

package/lib/cbp/router-middleware.js

@@ -0,0 +1,51 @@
+import { existsSync } from 'fs';
+import path, { dirname } from 'path';
+
+/**
+ * 递归向上查找所有目录级 _middleware 文件
+ * 支持 .ts/.js/.cjs/.mjs/.tsx/.jsx
+ * 按目录从上到下顺序合成
+ */
+async function collectMiddlewares(routeFile) {
+    const middlewares = [];
+    let dir = dirname(routeFile);
+    // 支持的后缀
+    const suffixes = ['.ts', '.js', '.cjs', '.mjs', '.tsx', '.jsx'];
+    while (true) {
+        for (const ext of suffixes) {
+            const mwPath = path.join(dir, `_middleware${ext}`);
+            if (existsSync(mwPath)) {
+                const mw = (await import(`file://${mwPath}`)).default;
+                if (typeof mw === 'function') {
+                    middlewares.unshift(mw);
+                }
+            }
+        }
+        const parent = dirname(dir);
+        if (parent === dir) {
+            break;
+        }
+        dir = parent;
+    }
+    return middlewares;
+}
+/**
+ * 依次执行中间件链，最后执行 handler
+ * 如果有任意中间件或 handler 抛错，自动捕获并处理
+ */
+async function runMiddlewares(middlewares, ctx, handler) {
+    let idx = 0;
+    async function dispatch() {
+        if (idx < middlewares.length) {
+            // 执行下一个中间件
+            await middlewares[idx++](ctx, dispatch);
+        }
+        else {
+            // 执行最终 handler
+            await handler(ctx);
+        }
+    }
+    await dispatch();
+}
+
+export { collectMiddlewares, runMiddlewares };

package/lib/cbp/router-utils.js

@@ -0,0 +1,40 @@
+import fs, { existsSync } from 'fs';
+
+// 输入一个文件路径。
+const getModuelFile = (dir) => {
+    const dirMap = {
+        '.js': `${dir}.js`,
+        '.jsx': `${dir}.jsx`,
+        '.mjs': `${dir}.mjs`,
+        '.cjs': `${dir}.cjs`,
+        '/index.js': `${dir}/index.js`,
+        '/index.jsx': `${dir}/index.jsx`,
+        '/index.mjs': `${dir}/index.mjs`,
+        '/index.cjs': `${dir}/index.cjs`,
+        '.ts': `${dir}.ts`,
+        '.tsx': `${dir}.tsx`,
+        '/index.ts': `${dir}/index.ts`,
+        '/index.tsx': `${dir}/index.tsx`
+    };
+    for (const key in dirMap) {
+        const filePath = dirMap[key];
+        if (existsSync(filePath) && fs.statSync(filePath)) {
+            return filePath;
+        }
+    }
+    return '';
+};
+const formatPath = (path) => {
+    if (!path || path === '/') {
+        return '/index.html';
+    }
+    const pates = path.split('/');
+    const lastPath = pates[pates.length - 1];
+    if (lastPath.includes('.')) {
+        return path;
+    }
+    path += '.html';
+    return path;
+};
+
+export { formatPath, getModuelFile };

package/lib/cbp/router.js

@@ -4,45 +4,11 @@ import path, { join, dirname } from 'path';
 import mime from 'mime-types';
 import { createRequire } from 'module';
 import { html } from './hello.html.js';
+import { getModuelFile, formatPath } from './router-utils.js';
+import { collectMiddlewares, runMiddlewares } from './router-middleware.js';
 
 const require = createRequire(import.meta.url);
 const mainDirMap = new Map();
-const formatPath = (path) => {
-    if (!path || path === '/') {
-        return '/index.html';
-    }
-    const pates = path.split('/');
-    const lastPath = pates[pates.length - 1];
-    if (lastPath.includes('.')) {
-        return path;
-    }
-    path += '.html';
-    return path;
-};
-// 输入一个文件路径。
-const getModuelFile = (dir) => {
-    const dirMap = {
-        '.js': `${dir}.js`,
-        '.jsx': `${dir}.jsx`,
-        '.mjs': `${dir}.mjs`,
-        '.cjs': `${dir}.cjs`,
-        '/index.js': `${dir}/index.js`,
-        '/index.jsx': `${dir}/index.jsx`,
-        '/index.mjs': `${dir}/index.mjs`,
-        '/index.cjs': `${dir}/index.cjs`,
-        '.ts': `${dir}.ts`,
-        '.tsx': `${dir}.tsx`,
-        '/index.ts': `${dir}/index.ts`,
-        '/index.tsx': `${dir}/index.tsx`
-    };
-    for (const key in dirMap) {
-        const filePath = dirMap[key];
-        if (existsSync(filePath) && fs.statSync(filePath)) {
-            return filePath;
-        }
-    }
-    return '';
-};
 const router = new KoaRouter({
     prefix: '/'
 });
@@ -109,11 +75,13 @@ router.all('app/{*path}', async (ctx) => {
                 return;
             }
             const apiModule = await import(`file://${modulePath}`);
-            if (!apiModule[ctx.method] || typeof apiModule[ctx.method] !== 'function') {
+            const handler = apiModule[ctx.method];
+            if (!handler || typeof handler !== 'function') {
                 ctx.status = 405;
                 return;
             }
-            await apiModule[ctx.method](ctx);
+            const middlewares = await collectMiddlewares(modulePath);
+            await runMiddlewares(middlewares, ctx, handler);
         }
         catch (err) {
             console.error(`Error handling API request ${ctx.path}`);
@@ -214,17 +182,19 @@ router.all('apps/:app/{*path}', async (ctx) => {
                 ctx.status = 404;
                 ctx.body = {
                     code: 404,
-                    message: `API 'route/${ctx.path}' 未找到。`,
-                    data: null
+                    message: `API '${ctx.path}' 未找到。`,
+                    data: 'existsSync modulePath'
                 };
                 return;
             }
             const apiModule = await import(`file://${modulePath}`);
-            if (!apiModule[ctx.method] || typeof apiModule[ctx.method] !== 'function') {
+            const handler = apiModule[ctx.method];
+            if (!handler || typeof handler !== 'function') {
                 ctx.status = 405;
                 return;
             }
-            await apiModule[ctx.method](ctx);
+            const middlewares = await collectMiddlewares(modulePath);
+            await runMiddlewares(middlewares, ctx, handler);
         }
         catch (err) {
             logger.warn(`Error request ${ctx.path}:`, err?.message || '');

package/lib/index.js

@@ -23,3 +23,14 @@ export { cbpClient } from './cbp/client.js';
 export { cbpServer } from './cbp/server.js';
 export { cbpPlatform } from './cbp/platform.js';
 export { run, start } from './main.js';
+
+// 导出类型
+['SIGINT', 'SIGTERM', 'SIGQUIT', 'disconnect'].forEach(sig => {
+    process?.on?.(sig, () => {
+        logger?.info?.(`[alemonjs][${sig}] 收到信号，正在关闭...`);
+        setImmediate(() => process.exit(0));
+    });
+});
+process?.on?.('exit', code => {
+    logger?.info?.(`[alemonjs][exit] 进程退出，code=${code}`);
+});

package/package.json

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