node-karin 1.10.2 → 1.10.4

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # 更新日志
 
+## [1.10.4](https://github.com/KarinJS/Karin/compare/core-v1.10.3...core-v1.10.4) (2025-06-08)
+
+
+### 🐛 Bug Fixes
+
+* 提升`create-karin`的兼容性 ([#468](https://github.com/KarinJS/Karin/issues/468)) ([23153fd](https://github.com/KarinJS/Karin/commit/23153fdbd8a022af567c095d00f37602d50dc085))
+
+## [1.10.3](https://github.com/KarinJS/Karin/compare/core-v1.10.2...core-v1.10.3) (2025-06-08)
+
+
+### 🐛 Bug Fixes
+
+* kill Process ([#465](https://github.com/KarinJS/Karin/issues/465)) ([77c4fb6](https://github.com/KarinJS/Karin/commit/77c4fb62405607b585fff5be75357f09e676dd11))
+
 ## [1.10.2](https://github.com/KarinJS/Karin/compare/core-v1.10.1...core-v1.10.2) (2025-06-06)
 
 

package/dist/index.mjs

@@ -19362,7 +19362,7 @@ var init_exit = __esm({
     init_exec();
     init_uptime();
     exitStatus = false;
-    processExit = async (code) => {
+    processExit = async (code, isKillPm2 = false) => {
       logger.debug("[child] \u5B50\u8FDB\u7A0B\u6536\u5230\u9000\u51FA\u7533\u8BF7:", code);
       try {
         if (exitStatus) return;
@@ -19372,7 +19372,7 @@ var init_exit = __esm({
         if (redis3.id === "mock") await redis3.save();
         logger.debug("[child] redis\u6570\u636E\u4FDD\u5B58\u5B8C\u6210");
         logger.mark(tips(`\u8FD0\u884C\u7ED3\u675F \u8FD0\u884C\u65F6\u95F4\uFF1A${uptime2()} \u9000\u51FA\u7801\uFF1A${code ?? "\u672A\u77E5"}`));
-        if (process.env.pm_id) {
+        if (process.env.pm_id && isKillPm2) {
           logger.mark(tips("[child] pm2\u73AF\u5883 \u5220\u9664pm2\u8FDB\u7A0B"));
           await exec(`pm2 delete ${process.env.pm_id}`);
         }
@@ -20768,7 +20768,7 @@ var init_manage = __esm({
       logger.mark("\u6536\u5230\u9000\u51FA\u8BF7\u6C42\uFF0C\u6B63\u5728\u9000\u51FA...");
       createSuccessResponse(res, null, "\u9000\u51FA\u6307\u4EE4\u53D1\u9001\u6210\u529F");
       const { processExit: processExit2 } = await Promise.resolve().then(() => (init_exit(), exit_exports));
-      await processExit2(0);
+      await processExit2(0, true);
     };
   }
 });

package/dist/start/index.mjs

@@ -1,10 +1,331 @@
 import os from 'node:os';
 import fs from 'node:fs';
+import require$$0 from 'fs';
+import require$$1 from 'path';
+import require$$2 from 'os';
+import require$$3 from 'crypto';
 import path from 'node:path';
+import { createServer } from 'node:net';
 import { fileURLToPath } from 'node:url';
 import { fork } from 'node:child_process';
 
 // src/start/index.ts
+function _mergeNamespaces(n, m) {
+  for (var i = 0; i < m.length; i++) {
+    const e = m[i];
+    if (typeof e !== "string" && !Array.isArray(e)) {
+      for (const k in e) {
+        if (k !== "default" && !(k in n)) {
+          const d = Object.getOwnPropertyDescriptor(e, k);
+          if (d) {
+            Object.defineProperty(n, k, d.get ? d : {
+              enumerable: true,
+              get: () => e[k]
+            });
+          }
+        }
+      }
+    }
+  }
+  return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
+}
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+var main$1 = { exports: {} };
+var version = "16.5.0";
+var require$$4 = {
+  version
+};
+var hasRequiredMain;
+function requireMain() {
+  if (hasRequiredMain) return main$1.exports;
+  hasRequiredMain = 1;
+  const fs2 = require$$0;
+  const path2 = require$$1;
+  const os2 = require$$2;
+  const crypto = require$$3;
+  const packageJson = require$$4;
+  const version2 = packageJson.version;
+  const LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg;
+  function parse2(src) {
+    const obj = {};
+    let lines = src.toString();
+    lines = lines.replace(/\r\n?/mg, "\n");
+    let match;
+    while ((match = LINE.exec(lines)) != null) {
+      const key = match[1];
+      let value = match[2] || "";
+      value = value.trim();
+      const maybeQuote = value[0];
+      value = value.replace(/^(['"`])([\s\S]*)\1$/mg, "$2");
+      if (maybeQuote === '"') {
+        value = value.replace(/\\n/g, "\n");
+        value = value.replace(/\\r/g, "\r");
+      }
+      obj[key] = value;
+    }
+    return obj;
+  }
+  function _parseVault2(options) {
+    const vaultPath = _vaultPath(options);
+    const result = DotenvModule.configDotenv({ path: vaultPath });
+    if (!result.parsed) {
+      const err = new Error(`MISSING_DATA: Cannot parse ${vaultPath} for an unknown reason`);
+      err.code = "MISSING_DATA";
+      throw err;
+    }
+    const keys = _dotenvKey(options).split(",");
+    const length = keys.length;
+    let decrypted;
+    for (let i = 0; i < length; i++) {
+      try {
+        const key = keys[i].trim();
+        const attrs = _instructions(result, key);
+        decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key);
+        break;
+      } catch (error) {
+        if (i + 1 >= length) {
+          throw error;
+        }
+      }
+    }
+    return DotenvModule.parse(decrypted);
+  }
+  function _warn(message) {
+    console.log(`[dotenv@${version2}][WARN] ${message}`);
+  }
+  function _debug(message) {
+    console.log(`[dotenv@${version2}][DEBUG] ${message}`);
+  }
+  function _dotenvKey(options) {
+    if (options && options.DOTENV_KEY && options.DOTENV_KEY.length > 0) {
+      return options.DOTENV_KEY;
+    }
+    if (process.env.DOTENV_KEY && process.env.DOTENV_KEY.length > 0) {
+      return process.env.DOTENV_KEY;
+    }
+    return "";
+  }
+  function _instructions(result, dotenvKey) {
+    let uri;
+    try {
+      uri = new URL(dotenvKey);
+    } catch (error) {
+      if (error.code === "ERR_INVALID_URL") {
+        const err = new Error("INVALID_DOTENV_KEY: Wrong format. Must be in valid uri format like dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=development");
+        err.code = "INVALID_DOTENV_KEY";
+        throw err;
+      }
+      throw error;
+    }
+    const key = uri.password;
+    if (!key) {
+      const err = new Error("INVALID_DOTENV_KEY: Missing key part");
+      err.code = "INVALID_DOTENV_KEY";
+      throw err;
+    }
+    const environment = uri.searchParams.get("environment");
+    if (!environment) {
+      const err = new Error("INVALID_DOTENV_KEY: Missing environment part");
+      err.code = "INVALID_DOTENV_KEY";
+      throw err;
+    }
+    const environmentKey = `DOTENV_VAULT_${environment.toUpperCase()}`;
+    const ciphertext = result.parsed[environmentKey];
+    if (!ciphertext) {
+      const err = new Error(`NOT_FOUND_DOTENV_ENVIRONMENT: Cannot locate environment ${environmentKey} in your .env.vault file.`);
+      err.code = "NOT_FOUND_DOTENV_ENVIRONMENT";
+      throw err;
+    }
+    return { ciphertext, key };
+  }
+  function _vaultPath(options) {
+    let possibleVaultPath = null;
+    if (options && options.path && options.path.length > 0) {
+      if (Array.isArray(options.path)) {
+        for (const filepath of options.path) {
+          if (fs2.existsSync(filepath)) {
+            possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
+          }
+        }
+      } else {
+        possibleVaultPath = options.path.endsWith(".vault") ? options.path : `${options.path}.vault`;
+      }
+    } else {
+      possibleVaultPath = path2.resolve(process.cwd(), ".env.vault");
+    }
+    if (fs2.existsSync(possibleVaultPath)) {
+      return possibleVaultPath;
+    }
+    return null;
+  }
+  function _resolveHome(envPath) {
+    return envPath[0] === "~" ? path2.join(os2.homedir(), envPath.slice(1)) : envPath;
+  }
+  function _configVault2(options) {
+    const debug = Boolean(options && options.debug);
+    if (debug) {
+      _debug("Loading env from encrypted .env.vault");
+    }
+    const parsed = DotenvModule._parseVault(options);
+    let processEnv = process.env;
+    if (options && options.processEnv != null) {
+      processEnv = options.processEnv;
+    }
+    DotenvModule.populate(processEnv, parsed, options);
+    return { parsed };
+  }
+  function configDotenv2(options) {
+    const dotenvPath = path2.resolve(process.cwd(), ".env");
+    let encoding = "utf8";
+    const debug = Boolean(options && options.debug);
+    if (options && options.encoding) {
+      encoding = options.encoding;
+    } else {
+      if (debug) {
+        _debug("No encoding is specified. UTF-8 is used by default");
+      }
+    }
+    let optionPaths = [dotenvPath];
+    if (options && options.path) {
+      if (!Array.isArray(options.path)) {
+        optionPaths = [_resolveHome(options.path)];
+      } else {
+        optionPaths = [];
+        for (const filepath of options.path) {
+          optionPaths.push(_resolveHome(filepath));
+        }
+      }
+    }
+    let lastError;
+    const parsedAll = {};
+    for (const path22 of optionPaths) {
+      try {
+        const parsed = DotenvModule.parse(fs2.readFileSync(path22, { encoding }));
+        DotenvModule.populate(parsedAll, parsed, options);
+      } catch (e) {
+        if (debug) {
+          _debug(`Failed to load ${path22} ${e.message}`);
+        }
+        lastError = e;
+      }
+    }
+    let processEnv = process.env;
+    if (options && options.processEnv != null) {
+      processEnv = options.processEnv;
+    }
+    DotenvModule.populate(processEnv, parsedAll, options);
+    if (lastError) {
+      return { parsed: parsedAll, error: lastError };
+    } else {
+      return { parsed: parsedAll };
+    }
+  }
+  function config2(options) {
+    if (_dotenvKey(options).length === 0) {
+      return DotenvModule.configDotenv(options);
+    }
+    const vaultPath = _vaultPath(options);
+    if (!vaultPath) {
+      _warn(`You set DOTENV_KEY but you are missing a .env.vault file at ${vaultPath}. Did you forget to build it?`);
+      return DotenvModule.configDotenv(options);
+    }
+    return DotenvModule._configVault(options);
+  }
+  function decrypt2(encrypted, keyStr) {
+    const key = Buffer.from(keyStr.slice(-64), "hex");
+    let ciphertext = Buffer.from(encrypted, "base64");
+    const nonce = ciphertext.subarray(0, 12);
+    const authTag = ciphertext.subarray(-16);
+    ciphertext = ciphertext.subarray(12, -16);
+    try {
+      const aesgcm = crypto.createDecipheriv("aes-256-gcm", key, nonce);
+      aesgcm.setAuthTag(authTag);
+      return `${aesgcm.update(ciphertext)}${aesgcm.final()}`;
+    } catch (error) {
+      const isRange = error instanceof RangeError;
+      const invalidKeyLength = error.message === "Invalid key length";
+      const decryptionFailed = error.message === "Unsupported state or unable to authenticate data";
+      if (isRange || invalidKeyLength) {
+        const err = new Error("INVALID_DOTENV_KEY: It must be 64 characters long (or more)");
+        err.code = "INVALID_DOTENV_KEY";
+        throw err;
+      } else if (decryptionFailed) {
+        const err = new Error("DECRYPTION_FAILED: Please check your DOTENV_KEY");
+        err.code = "DECRYPTION_FAILED";
+        throw err;
+      } else {
+        throw error;
+      }
+    }
+  }
+  function populate2(processEnv, parsed, options = {}) {
+    const debug = Boolean(options && options.debug);
+    const override = Boolean(options && options.override);
+    if (typeof parsed !== "object") {
+      const err = new Error("OBJECT_REQUIRED: Please check the processEnv argument being passed to populate");
+      err.code = "OBJECT_REQUIRED";
+      throw err;
+    }
+    for (const key of Object.keys(parsed)) {
+      if (Object.prototype.hasOwnProperty.call(processEnv, key)) {
+        if (override === true) {
+          processEnv[key] = parsed[key];
+        }
+        if (debug) {
+          if (override === true) {
+            _debug(`"${key}" is already defined and WAS overwritten`);
+          } else {
+            _debug(`"${key}" is already defined and was NOT overwritten`);
+          }
+        }
+      } else {
+        processEnv[key] = parsed[key];
+      }
+    }
+  }
+  const DotenvModule = {
+    configDotenv: configDotenv2,
+    _configVault: _configVault2,
+    _parseVault: _parseVault2,
+    config: config2,
+    decrypt: decrypt2,
+    parse: parse2,
+    populate: populate2
+  };
+  main$1.exports.configDotenv = DotenvModule.configDotenv;
+  main$1.exports._configVault = DotenvModule._configVault;
+  main$1.exports._parseVault = DotenvModule._parseVault;
+  main$1.exports.config = DotenvModule.config;
+  main$1.exports.decrypt = DotenvModule.decrypt;
+  main$1.exports.parse = DotenvModule.parse;
+  main$1.exports.populate = DotenvModule.populate;
+  main$1.exports = DotenvModule;
+  return main$1.exports;
+}
+var mainExports = requireMain();
+var main = /* @__PURE__ */ getDefaultExportFromCjs(mainExports);
+var dotenv = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: main
+}, [mainExports]);
+
+// ../../node_modules/.pnpm/@karinjs+dotenv@1.1.2/node_modules/@karinjs/dotenv/dist/index.js
+var {
+  // @ts-ignore
+  _configVault,
+  _parseVault
+} = dotenv;
+mainExports.config;
+mainExports.configDotenv;
+mainExports.decrypt;
+mainExports.parse;
+mainExports.populate;
+
+// ../../node_modules/.pnpm/@karinjs+dotenv@1.1.2/node_modules/@karinjs/dotenv/index.js
+var app = dotenv.default;
+var dotenv_default = app;
 var ProcessManager = class {
   /** 是否已经启动 */
   isStarted = false;
@@ -25,6 +346,8 @@ var ProcessManager = class {
     /** 最后重启时间 */
     lastRestartTime: 0
   };
+  /** 默认HTTP端口 */
+  DEFAULT_HTTP_PORT = 7777;
   // ANSI 颜色代码
   COLORS = {
     green: "\x1B[32m",
@@ -97,7 +420,7 @@ var ProcessManager = class {
       const pid = this.childProcess.pid;
       const uptime = this.getProcessUptime();
       this.log(`\u6B63\u5728\u5173\u95ED\u5B50\u8FDB\u7A0B | PID: ${pid} | \u8FD0\u884C\u65F6\u95F4: ${uptime}`);
-      this.terminateChildProcess(false);
+      this.terminateChildProcess();
       this.childProcess = null;
       this.isStarted = false;
       this.isRestarting = false;
@@ -158,21 +481,98 @@ var ProcessManager = class {
       this.stop();
     }
   }
+  /**
+   * 等待端口释放
+   * @param port - 需要检查的端口号
+   * @param maxAttempts - 最大尝试次数
+   * @param interval - 检查间隔(ms)
+   * @returns 端口是否可用
+   */
+  async waitForPortRelease(port, maxAttempts = 30, interval = 500) {
+    const checkPort = (port2) => {
+      return new Promise((resolve) => {
+        const server = createServer();
+        server.once("error", () => {
+          server.close();
+          resolve(false);
+        });
+        server.once("listening", () => {
+          server.close();
+          resolve(true);
+        });
+        server.listen(port2, "127.0.0.1");
+      });
+    };
+    const isProcessAlive = (pid) => {
+      try {
+        process.kill(pid, 0);
+        return true;
+      } catch {
+        return false;
+      }
+    };
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      if (this.childProcess?.pid && !isProcessAlive(this.childProcess.pid)) {
+        this.log(`\u5B50\u8FDB\u7A0B\u5DF2\u9000\u51FA | PID: ${this.childProcess.pid}`);
+        const portAvailable2 = await checkPort(port);
+        if (portAvailable2) {
+          this.log(`\u7AEF\u53E3 ${port} \u5DF2\u91CA\u653E\uFF0C\u53EF\u4EE5\u4F7F\u7528`);
+          return true;
+        } else {
+          this.logWarn(`\u5B50\u8FDB\u7A0B\u5DF2\u9000\u51FA\uFF0C\u4F46\u7AEF\u53E3 ${port} \u4ECD\u88AB\u5360\u7528 (\u53EF\u80FD\u88AB\u5176\u4ED6\u8FDB\u7A0B\u5360\u7528)`);
+        }
+      }
+      const portAvailable = await checkPort(port);
+      if (portAvailable) {
+        this.log(`\u7AEF\u53E3 ${port} \u5DF2\u91CA\u653E\uFF0C\u53EF\u4EE5\u4F7F\u7528`);
+        return true;
+      }
+      this.logWarn(`\u7AEF\u53E3 ${port} \u4ECD\u88AB\u5360\u7528\uFF0C\u7B49\u5F85\u91CA\u653E... (${attempt + 1}/${maxAttempts})`);
+      try {
+        if (this?.childProcess?.pid && isProcessAlive(this.childProcess.pid)) {
+          this.log(`\u5C1D\u8BD5\u7EC8\u6B62\u5B50\u8FDB\u7A0B | PID: ${this.childProcess.pid}`);
+          process.kill(this.childProcess.pid);
+        }
+      } catch {
+      }
+      await new Promise((resolve) => setTimeout(resolve, interval));
+    }
+    this.logError(`\u7AEF\u53E3 ${port} \u5728 ${maxAttempts} \u6B21\u5C1D\u8BD5\u540E\u4ECD\u88AB\u5360\u7528`);
+    return false;
+  }
+  /**
+   * 获取HTTP端口号
+   * @returns HTTP端口号
+   */
+  getHttpPort() {
+    try {
+      const envPath = path.resolve(process.cwd(), ".env");
+      if (fs.existsSync(envPath)) {
+        const envConfig = dotenv_default.parse(fs.readFileSync(envPath));
+        if (envConfig.HTTP_PORT) {
+          return Number(envConfig.HTTP_PORT);
+        }
+      }
+      return this.DEFAULT_HTTP_PORT;
+    } catch (error) {
+      this.logWarn(`\u8BFB\u53D6HTTP\u7AEF\u53E3\u5931\u8D25: ${error.message}\uFF0C\u4F7F\u7528\u9ED8\u8BA4\u7AEF\u53E3${this.DEFAULT_HTTP_PORT}`);
+      return this.DEFAULT_HTTP_PORT;
+    }
+  }
   /**
    * 终止子进程
    */
-  async terminateChildProcess(waitForTermination = true) {
+  async terminateChildProcess() {
     if (!this.childProcess) return;
     try {
       const pid = this.childProcess.pid;
       this.log(`\u53D1\u9001\u7EC8\u6B62\u4FE1\u53F7 | PID: ${pid} | \u4FE1\u53F7: SIGTERM`);
       this.childProcess.kill("SIGTERM");
-      if (waitForTermination) {
-        this.log(`\u7B49\u5F85\u8FDB\u7A0B\u7EC8\u6B62 | PID: ${pid} | \u8D85\u65F6: ${this.RESTART_DELAY_MS}ms`);
-        await new Promise((resolve) => setTimeout(resolve, this.RESTART_DELAY_MS));
-      }
+      this.log(`\u7B49\u5F85\u8FDB\u7A0B\u7EC8\u6B62 | PID: ${pid} | \u8D85\u65F6: ${this.RESTART_DELAY_MS}ms`);
+      const port = this.getHttpPort();
+      await this.waitForPortRelease(port);
       try {
-        if (this.childProcess.pid) {
+        if (this?.childProcess?.pid) {
           this.log(`\u786E\u4FDD\u8FDB\u7A0B\u7EC8\u6B62 | PID: ${pid} | \u53D1\u9001\u5F3A\u5236\u7EC8\u6B62\u4FE1\u53F7`);
           process.kill(this.childProcess.pid);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-karin",
-  "version": "1.10.2",
+  "version": "1.10.4",
   "description": "Lightweight, efficient, concise, and stable robot framework.",
   "keywords": [
     "node",