@maiyunnet/kebab 2.0.0

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@maiyunnet/kebab",
+  "version": "2.0.0",
+  "description": "Simple, easy-to-use, and fully-featured Node.js framework that is ready-to-use out of the box.",
+  "keywords": [
+    "kebab",
+    "node",
+    "framework"
+  ],
+  "main": "index.js",
+  "author": "hanguoshuai",
+  "license": "Apache-2.0",
+  "bin": {
+    "kebab": "./bin/kebab.js"
+  },
+  "dependencies": {
+    "@aws-sdk/client-s3": "^3.826.0",
+    "@aws-sdk/lib-storage": "^3.826.0",
+    "@litert/http-client": "^1.1.2",
+    "@litert/mime": "^0.1.3",
+    "@litert/redis": "^3.0.5",
+    "@litert/websocket": "^0.2.3",
+    "ejs": "^3.1.10",
+    "jszip": "^3.10.1",
+    "mysql2": "^3.14.1",
+    "ssh2": "^1.16.0",
+    "svg-captcha": "^1.4.0",
+    "ts-alias-loader": "^0.1.5"
+  },
+  "devDependencies": {
+    "@litert/eslint-plugin-rules": "^0.3.1",
+    "@types/ejs": "^3.1.5",
+    "@types/node": "^24.0.0",
+    "@types/ssh2": "^1.15.5",
+    "typescript": "^5.8.3"
+  }
+}

package/sys/child.js

@@ -0,0 +1,585 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const http2 = __importStar(require("http2"));
+const tls = __importStar(require("tls"));
+const http = __importStar(require("http"));
+const crypto = __importStar(require("crypto"));
+const fs = __importStar(require("~/lib/fs"));
+const lCore = __importStar(require("~/lib/core"));
+const lText = __importStar(require("~/lib/text"));
+const sCtr = __importStar(require("~/sys/ctr"));
+const kebab = __importStar(require("~/index"));
+const sRoute = __importStar(require("~/sys/route"));
+const hbTimer = setInterval(function () {
+    if (!process.connected || !process.send) {
+        return;
+    }
+    process.send({
+        action: 'hbtime',
+        pid: process.pid
+    });
+}, 10_000);
+const certList = [];
+let certHostIndex = {};
+let vhosts = [];
+let httpServer;
+let http2Server;
+const linkCount = {};
+async function run() {
+    await reload();
+    http2Server = http2.createSecureServer({
+        'SNICallback': (servername, cb) => {
+            const i = certHostIndex[servername];
+            if (i !== undefined) {
+                cb(null, certList[i].sc);
+                return;
+            }
+            for (let i = 0; i < certList.length; ++i) {
+                if (!certList[i].cert.checkHost(servername)) {
+                    continue;
+                }
+                cb(null, certList[i].sc);
+                certHostIndex[servername] = i;
+                return;
+            }
+            const err = new Error('CERT NOT FOUND');
+            cb(err);
+        },
+        'ciphers': 'ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES128-SHA:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES128-SHA:ECDHE-ECDSA-AES256-SHA384:ECDHE-ECDSA-AES256-SHA:ECDHE-RSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA:DHE-RSA-AES256-SHA256:DHE-RSA-AES256-SHA:ECDHE-ECDSA-DES-CBC3-SHA:ECDHE-RSA-DES-CBC3-SHA:EDH-RSA-DES-CBC3-SHA:AES128-GCM-SHA256:AES256-GCM-SHA384:AES128-SHA256:AES256-SHA256:AES128-SHA:AES256-SHA:DES-CBC3-SHA:!DSS',
+        'allowHTTP1': true
+    }, function (req, res) {
+        const host = (req.headers[':authority'] ?? req.headers['host'] ?? '');
+        if (!host) {
+            req.socket.destroy();
+            return;
+        }
+        const key = host + req.url;
+        (async function () {
+            if (!linkCount[key]) {
+                linkCount[key] = 0;
+            }
+            ++linkCount[key];
+            await requestHandler(req, res, true);
+            --linkCount[key];
+            if (!linkCount[key]) {
+                delete linkCount[key];
+            }
+        })().catch(async function (e) {
+            await lCore.log({
+                'path': '',
+                'urlFull': '',
+                'hostname': '',
+                'req': req,
+                'get': {},
+                'cookie': {},
+                'headers': {}
+            }, '[child][http2][request]' + lText.stringifyJson(e.stack).slice(1, -1), '-error');
+            --linkCount[key];
+            if (!linkCount[key]) {
+                delete linkCount[key];
+            }
+        });
+    }).on('tlsClientError', (err, socket) => {
+        socket.destroy();
+    }).on('upgrade', function (req, socket) {
+        const host = (req.headers['host'] ?? '');
+        if (!host) {
+            req.socket.destroy();
+            return;
+        }
+        const key = host + (req.url ?? '');
+        (async function () {
+            if (!linkCount[key]) {
+                linkCount[key] = 0;
+            }
+            ++linkCount[key];
+            await upgradeHandler(req, socket, true);
+            --linkCount[key];
+            if (!linkCount[key]) {
+                delete linkCount[key];
+            }
+        })().catch(async function (e) {
+            await lCore.log({
+                'path': '',
+                'urlFull': '',
+                'hostname': '',
+                'req': req,
+                'get': {},
+                'cookie': {},
+                'headers': {}
+            }, '[child][http2][upgrade]' + lText.stringifyJson(e.stack).slice(1, -1), '-error');
+            --linkCount[key];
+            if (!linkCount[key]) {
+                delete linkCount[key];
+            }
+        });
+    }).listen(lCore.globalConfig.httpsPort);
+    httpServer = http.createServer(function (req, res) {
+        const host = (req.headers['host'] ?? '');
+        if (!host) {
+            req.socket.destroy();
+            return;
+        }
+        const key = host + (req.url ?? '');
+        (async function () {
+            if (!linkCount[key]) {
+                linkCount[key] = 0;
+            }
+            ++linkCount[key];
+            await requestHandler(req, res, false);
+            --linkCount[key];
+            if (!linkCount[key]) {
+                delete linkCount[key];
+            }
+        })().catch(async function (e) {
+            await lCore.log({
+                'path': '',
+                'urlFull': '',
+                'hostname': '',
+                'req': req,
+                'get': {},
+                'cookie': {},
+                'headers': {}
+            }, '[child][http][request]' + lText.stringifyJson(e.stack).slice(1, -1), '-error');
+            --linkCount[key];
+            if (!linkCount[key]) {
+                delete linkCount[key];
+            }
+        });
+    }).on('upgrade', function (req, socket) {
+        const host = (req.headers['host'] ?? '');
+        if (!host) {
+            req.socket.destroy();
+            return;
+        }
+        const key = host + (req.url ?? '');
+        (async function () {
+            if (!linkCount[key]) {
+                linkCount[key] = 0;
+            }
+            ++linkCount[key];
+            await upgradeHandler(req, socket, false);
+            --linkCount[key];
+            if (!linkCount[key]) {
+                delete linkCount[key];
+            }
+        })().catch(async function (e) {
+            await lCore.log({
+                'path': '',
+                'urlFull': '',
+                'hostname': '',
+                'req': req,
+                'get': {},
+                'cookie': {},
+                'headers': {}
+            }, '[child][http][upgrade]' + lText.stringifyJson(e.stack).slice(1, -1), '-error');
+            --linkCount[key];
+            if (!linkCount[key]) {
+                delete linkCount[key];
+            }
+        });
+    }).listen(lCore.globalConfig.httpPort);
+}
+async function requestHandler(req, res, https) {
+    const timer = {
+        'timer': {},
+        'timeout': 30_000,
+        'callback': () => {
+            if (!req.socket.writable) {
+                return;
+            }
+            if (res.headersSent) {
+                return;
+            }
+            res.setHeader('content-length', 37);
+            res.writeHead(504);
+            res.end('<h1>504 Gateway Timeout</h1><hr>Kebab');
+        }
+    };
+    timer.timer = setTimeout(timer.callback, timer.timeout);
+    res.setHeader('Server', 'Kebab/' + kebab.VER);
+    let host = req.headers[':authority'];
+    if (host === undefined || typeof host !== 'string') {
+        host = req.headers['host'];
+        if (host === undefined) {
+            req.socket.destroy();
+            return;
+        }
+    }
+    const uri = lText.parseUrl(`http${https ? 's' : ''}://${host}${req.url ?? ''}`);
+    const vhost = getVhostByHostname(uri.hostname ?? '');
+    if (!vhost) {
+        req.socket.destroy();
+        return;
+    }
+    const vhostRoot = vhost.root.replace(/\${example}/g, kebab.ROOT_PATH + 'www/example/');
+    let rootPath = lText.isRealPath(vhostRoot) ? vhostRoot : kebab.WWW_CWD + vhostRoot;
+    if (!rootPath.endsWith('/')) {
+        rootPath += '/';
+    }
+    let path = uri.pathname ?? '/';
+    if (path !== '/') {
+        path = lText.urlResolve('/', path);
+    }
+    const pathList = path.split('/');
+    let now = '';
+    for (let i = 0; i < pathList.length; ++i) {
+        const item = pathList[i];
+        if (item !== '') {
+            let stat = await fs.stats(rootPath + now + item);
+            if (!stat) {
+                res.setHeader('content-type', 'text/html; charset=utf-8');
+                res.setHeader('content-length', 22);
+                res.writeHead(404);
+                res.end('<h1>404 Not found</h1><hr>Kebab');
+                return;
+            }
+            if (stat.isDirectory()) {
+                now += item + '/';
+                stat = await fs.stats(rootPath + now + 'kebab.json');
+                if (stat) {
+                    try {
+                        if (await sRoute.run({
+                            'req': req,
+                            'res': res,
+                            'uri': uri,
+                            'rootPath': rootPath + now,
+                            'urlBase': '/' + now,
+                            'path': path.slice(('/' + pathList.slice(0, i).join('/')).length + 1),
+                            'timer': timer
+                        })) {
+                            return;
+                        }
+                    }
+                    catch (e) {
+                        await lCore.log({
+                            'path': path.slice(('/' + pathList.slice(0, i).join('/')).length + 1),
+                            'urlFull': (uri.protocol ?? '') + '//' + (uri.host ?? '') + '/' + now,
+                            'hostname': uri.hostname ?? '',
+                            'req': req,
+                            'get': uri.query ? lText.queryParse(uri.query) : {},
+                            'cookie': {},
+                            'headers': {}
+                        }, '(E01)' + lText.stringifyJson(e.stack).slice(1, -1), '-error');
+                        res.setHeader('content-type', 'text/html; charset=utf-8');
+                        res.setHeader('content-length', 25);
+                        res.writeHead(500);
+                        res.end('<h1>500 Server Error</h1><hr>Kebab');
+                        return;
+                    }
+                }
+            }
+            else {
+                await fs.readToResponse(rootPath + now + item, req, res, stat);
+                return;
+            }
+        }
+        else {
+            if (i > 0) {
+                break;
+            }
+            const stat = await fs.stats(rootPath + now + 'kebab.json');
+            if (stat) {
+                try {
+                    if (await sRoute.run({
+                        'req': req,
+                        'res': res,
+                        'uri': uri,
+                        'rootPath': rootPath + now,
+                        'urlBase': '/' + now,
+                        'path': path.slice(1),
+                        'timer': timer
+                    })) {
+                        return;
+                    }
+                }
+                catch (e) {
+                    await lCore.log({
+                        'path': path.slice(1),
+                        'urlFull': (uri.protocol ?? '') + '//' + (uri.host ?? '') + '/' + now,
+                        'hostname': uri.hostname ?? '',
+                        'req': req,
+                        'get': uri.query ? lText.queryParse(uri.query) : {},
+                        'cookie': {},
+                        'headers': {}
+                    }, '(E02)' + lText.stringifyJson(e.stack).slice(1, -1), '-error');
+                    res.setHeader('content-type', 'text/html; charset=utf-8');
+                    res.setHeader('content-length', 25);
+                    res.writeHead(500);
+                    res.end('<h1>500 Server Error</h1><hr>Kebab');
+                    return;
+                }
+            }
+        }
+    }
+    const indexFiles = ['index.html', 'index.htm'];
+    for (const indexFile of indexFiles) {
+        const stat = await fs.isFile(rootPath + now + indexFile);
+        if (stat) {
+            await fs.readToResponse(rootPath + now + indexFile, req, res, stat);
+            return;
+        }
+    }
+    res.setHeader('content-type', 'text/html; charset=utf-8');
+    res.setHeader('content-length', 22);
+    res.writeHead(403);
+    res.end('<h1>403 Forbidden</h1><hr>Kebab');
+}
+async function upgradeHandler(req, socket, https) {
+    socket.removeAllListeners('error');
+    const uri = lText.parseUrl(`ws${https ? 's' : ''}://${req.headers['host'] ?? ''}${req.url ?? ''}`);
+    const vhost = getVhostByHostname(uri.hostname ?? '');
+    if (!vhost) {
+        socket.destroy();
+        return;
+    }
+    const vhostRoot = vhost.root.replace(/\${example}/g, kebab.ROOT_PATH + 'www/example/');
+    let rootPath = lText.isRealPath(vhostRoot) ? vhostRoot : kebab.WWW_CWD + vhostRoot;
+    if (!rootPath.endsWith('/')) {
+        rootPath += '/';
+    }
+    let path = uri.pathname ?? '/';
+    if (path !== '/') {
+        path = lText.urlResolve('/', path);
+    }
+    const pathList = path.split('/');
+    let now = '';
+    for (let i = 0; i < pathList.length; ++i) {
+        const item = pathList[i];
+        if (item !== '') {
+            let stat = await fs.stats(rootPath + now + item);
+            if (!stat) {
+                socket.destroy();
+                return;
+            }
+            if (stat.isDirectory()) {
+                now += item + '/';
+                stat = await fs.stats(rootPath + now + 'kebab.json');
+                if (stat) {
+                    if (await sRoute.run({
+                        'req': req,
+                        'socket': socket,
+                        'uri': uri,
+                        'rootPath': rootPath + now,
+                        'urlBase': '/' + now,
+                        'path': path.slice(('/' + pathList.slice(0, i).join('/')).length + 1)
+                    })) {
+                        return;
+                    }
+                }
+            }
+            else {
+                socket.destroy();
+                return;
+            }
+        }
+        else {
+            if (i > 0) {
+                break;
+            }
+            const stat = await fs.stats(rootPath + now + 'kebab.json');
+            if (stat) {
+                if (await sRoute.run({
+                    'req': req,
+                    'socket': socket,
+                    'uri': uri,
+                    'rootPath': rootPath + now,
+                    'urlBase': '/' + now,
+                    'path': path.slice(1)
+                })) {
+                    return;
+                }
+            }
+        }
+    }
+    socket.destroy();
+}
+async function reload() {
+    const configContent = await fs.getContent(kebab.CONF_CWD + 'config.json', 'utf8');
+    if (!configContent) {
+        throw `File '${kebab.CONF_CWD}config.json' not found.`;
+    }
+    const config = lText.parseJson(configContent);
+    for (const key in lCore.globalConfig) {
+        delete lCore.globalConfig[key];
+    }
+    for (const key in config) {
+        lCore.globalConfig[key] = config[key];
+    }
+    const files = await fs.readDir(kebab.VHOST_CWD);
+    vhosts = [];
+    for (const file of files) {
+        if (!file.name.endsWith('.json')) {
+            continue;
+        }
+        const fstr = await fs.getContent(kebab.VHOST_CWD + file.name, 'utf8');
+        if (!fstr) {
+            continue;
+        }
+        let list = lText.parseJson(fstr);
+        if (!Array.isArray(list)) {
+            list = [list];
+        }
+        for (const item of list) {
+            vhosts.push(item);
+        }
+    }
+    certList.length = 0;
+    try {
+        const certConfig = await fs.getContent(kebab.CONF_CWD + 'cert.json', 'utf8');
+        if (certConfig) {
+            const certs = lText.parseJson(certConfig);
+            for (const item of certs) {
+                const key = await fs.getContent(lText.isRealPath(item.key) ? item.key : kebab.CERT_CWD + item.key, 'utf8');
+                const cert = await fs.getContent(lText.isRealPath(item.cert) ? item.cert : kebab.CERT_CWD + item.cert, 'utf8');
+                if (!cert || !key) {
+                    continue;
+                }
+                const certo = new crypto.X509Certificate(cert);
+                const sc = tls.createSecureContext({
+                    'key': key,
+                    'cert': cert
+                });
+                certList.push({
+                    'cert': certo,
+                    'sc': sc
+                });
+            }
+        }
+    }
+    catch {
+    }
+    certHostIndex = {};
+    sRoute.clearKebabConfigs();
+    sCtr.clearLocaleData();
+}
+process.on('message', function (msg) {
+    (async function () {
+        switch (msg.action) {
+            case 'reload': {
+                await reload();
+                console.log(`[child] Worker ${process.pid} reload execution succeeded.`);
+                break;
+            }
+            case 'stop': {
+                httpServer.close();
+                http2Server.close();
+                clearInterval(hbTimer);
+                let waiting = 0;
+                while (true) {
+                    if (!Object.keys(linkCount).length) {
+                        break;
+                    }
+                    const str = [];
+                    for (const key in linkCount) {
+                        str.push(key + ':' + linkCount[key].toString());
+                    }
+                    console.log(`[child] Worker ${process.pid} busy: ${str.join(',')}.`);
+                    await lCore.log({
+                        'path': '',
+                        'urlFull': '',
+                        'hostname': '',
+                        'req': null,
+                        'get': {},
+                        'cookie': {},
+                        'headers': {}
+                    }, `[child] Worker ${process.pid} busy: ${str.join(',')}.`, '-error');
+                    await lCore.sleep(30_000);
+                    waiting += 30_000;
+                    if (waiting > 3600_000) {
+                        break;
+                    }
+                }
+                process.exit();
+                break;
+            }
+            case 'global': {
+                if (msg.data === undefined || msg.data === null) {
+                    delete lCore.global[msg.key];
+                    break;
+                }
+                if (msg.key === '__init__') {
+                    for (const key in msg.data) {
+                        lCore.global[key] = msg.data[key];
+                    }
+                    break;
+                }
+                lCore.global[msg.key] = msg.data;
+                break;
+            }
+        }
+    })().catch(async function (e) {
+        await lCore.log({
+            'path': '',
+            'urlFull': '',
+            'hostname': '',
+            'req': null,
+            'get': {},
+            'cookie': {},
+            'headers': {}
+        }, '[child][process][message]' + lText.stringifyJson(e.stack).slice(1, -1), '-error');
+    });
+});
+function getVhostByHostname(hostname) {
+    let vGlobal, vSub;
+    for (const vhost of vhosts) {
+        for (let domain of vhost.domains) {
+            if (domain === '*') {
+                vGlobal = vhost;
+            }
+            else if (domain.includes('*')) {
+                domain = domain.replace(/\*/, '^.+?').replace(/\./, '\\.');
+                if (new RegExp(domain + '$').test(hostname)) {
+                    vSub = vhost;
+                }
+            }
+            else if (domain === hostname) {
+                return vhost;
+            }
+        }
+    }
+    if (vSub) {
+        return vSub;
+    }
+    if (vGlobal) {
+        return vGlobal;
+    }
+    return null;
+}
+run().catch(function (e) {
+    console.log('[child] ------ [Process fatal Error] ------');
+    console.log(e);
+});