node-plume 1.0.1

package/dist/start/chunk-T7M5RXO7.mjs

@@ -0,0 +1,239 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/start/index.ts
+import { fork } from "child_process";
+import { existsSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { logger } from "@plume/logger";
+var ProcessLauncher = class _ProcessLauncher {
+  process = null;
+  state = "idle";
+  stats = {
+    startTime: 0,
+    restartCount: 0,
+    lastRestartTime: 0
+  };
+  eventHandlers = /* @__PURE__ */ new Map();
+  options;
+  shutdownPromise = null;
+  resolveShutdown = null;
+  static DEFAULT_OPTIONS = {
+    entry: "",
+    cwd: process.cwd(),
+    watch: false,
+    env: {}
+  };
+  constructor(options = {}) {
+    this.options = { ..._ProcessLauncher.DEFAULT_OPTIONS, ...options };
+    this.setupSignalHandlers();
+  }
+  setupSignalHandlers() {
+    const signals = ["SIGINT", "SIGTERM", "SIGUSR2"];
+    signals.forEach((signal) => {
+      process.on(signal, () => {
+        logger.info(`\u6536\u5230\u4FE1\u53F7 ${signal}\uFF0C\u6B63\u5728\u5173\u95ED...`);
+        this.stop();
+      });
+    });
+    process.on("exit", () => {
+      this.kill();
+    });
+  }
+  async start() {
+    if (this.state === "running" && this.process) {
+      logger.warn("\u8FDB\u7A0B\u5DF2\u5728\u8FD0\u884C\u4E2D");
+      return this.process;
+    }
+    this.state = "starting";
+    const entry = this.resolveEntry();
+    if (!entry) {
+      const error = new Error("\u672A\u627E\u5230\u6709\u6548\u7684\u5165\u53E3\u6587\u4EF6");
+      this.emit("error", error);
+      throw error;
+    }
+    logger.info(`Launcher  cwd=${this.options.cwd}  mode=${this.options.watch ? "watch" : "foreground"}`);
+    logger.info(`\u5165\u53E3  ${entry}`);
+    this.process = fork(entry, [], {
+      cwd: this.options.cwd,
+      env: { ...process.env, ...this.options.env },
+      stdio: "inherit"
+    });
+    this.stats.startTime = Date.now();
+    this.stats.lastRestartTime = this.stats.startTime;
+    this.state = "running";
+    this.setupProcessEventHandlers();
+    this.emit("start", { pid: this.process.pid, entry });
+    logger.info(`\u5B50\u8FDB\u7A0B  pid=${this.process.pid}`);
+    return this.process;
+  }
+  async restart() {
+    if (this.state !== "running") {
+      logger.warn("\u8FDB\u7A0B\u672A\u8FD0\u884C\uFF0C\u76F4\u63A5\u542F\u52A8");
+      return this.start();
+    }
+    logger.warn("\u6B63\u5728\u91CD\u542F\u5E94\u7528");
+    this.stats.restartCount++;
+    this.stats.lastRestartTime = Date.now();
+    await this.stop();
+    this.state = "idle";
+    const newProcess = await this.start();
+    this.emit("restart", {
+      pid: newProcess.pid,
+      restartCount: this.stats.restartCount
+    });
+    return newProcess;
+  }
+  async stop() {
+    if (this.state !== "running" || !this.process) {
+      return;
+    }
+    this.state = "stopping";
+    logger.warn("\u6B63\u5728\u505C\u6B62\u5E94\u7528");
+    this.shutdownPromise = new Promise((resolve) => {
+      this.resolveShutdown = resolve;
+    });
+    this.process.kill("SIGTERM");
+    const timeout = setTimeout(() => {
+      if (this.process && this.process.pid) {
+        logger.warn("\u8FDB\u7A0B\u672A\u5728\u8D85\u65F6\u65F6\u95F4\u5185\u9000\u51FA\uFF0C\u5F3A\u5236\u7EC8\u6B62");
+        this.process.kill("SIGKILL");
+      }
+    }, 1e4);
+    await this.shutdownPromise;
+    clearTimeout(timeout);
+    this.state = "stopped";
+    this.emit("stop");
+    logger.info("Launcher \u5DF2\u505C\u6B62");
+  }
+  kill() {
+    if (this.process && this.process.pid) {
+      try {
+        process.kill(this.process.pid, "SIGKILL");
+      } catch {
+      }
+    }
+    this.process = null;
+    this.state = "stopped";
+  }
+  getState() {
+    return this.state;
+  }
+  getStats() {
+    return { ...this.stats };
+  }
+  getUptime() {
+    if (this.state !== "running") return 0;
+    return Date.now() - this.stats.startTime;
+  }
+  on(event, handler) {
+    if (!this.eventHandlers.has(event)) {
+      this.eventHandlers.set(event, /* @__PURE__ */ new Set());
+    }
+    this.eventHandlers.get(event).add(handler);
+    return this;
+  }
+  off(event, handler) {
+    this.eventHandlers.get(event)?.delete(handler);
+    return this;
+  }
+  emit(event, data) {
+    this.eventHandlers.get(event)?.forEach((handler) => {
+      try {
+        handler(event, data);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger.error(`\u4E8B\u4EF6\u5904\u7406\u5668\u9519\u8BEF [${event}]: ${message}`);
+      }
+    });
+  }
+  setupProcessEventHandlers() {
+    if (!this.process) return;
+    this.process.on("exit", (code, signal) => {
+      this.handleProcessExit(code, signal);
+    });
+    this.process.on("error", (error) => {
+      this.handleProcessError(error);
+    });
+    this.process.on("message", (message) => {
+      this.handleProcessMessage(message);
+    });
+  }
+  handleProcessExit(code, signal) {
+    const uptime = this.getUptime();
+    if (signal) {
+      logger.warn(`\u8FDB\u7A0B\u9000\u51FA  signal=${signal}  uptime=${uptime}ms`);
+    } else {
+      logger.info(`\u8FDB\u7A0B\u9000\u51FA  code=${code ?? "unknown"}  uptime=${uptime}ms`);
+    }
+    this.emit("exit", { code, signal, uptime });
+    if (this.resolveShutdown) {
+      this.resolveShutdown();
+      this.shutdownPromise = null;
+      this.resolveShutdown = null;
+    }
+    this.process = null;
+    this.state = "stopped";
+  }
+  handleProcessError(error) {
+    logger.error(`\u8FDB\u7A0B\u9519\u8BEF: ${error.message}`);
+    this.emit("error", error);
+  }
+  handleProcessMessage(message) {
+    if (typeof message === "object" && message !== null) {
+      const msg = message;
+      if (msg.type === "plume:restart") {
+        this.restart().catch((err) => logger.error(`\u91CD\u542F\u5931\u8D25: ${err instanceof Error ? err.message : String(err)}`));
+      } else if (msg.type === "plume:stop") {
+        this.stop().catch((err) => logger.error(`\u505C\u6B62\u5931\u8D25: ${err instanceof Error ? err.message : String(err)}`));
+      }
+    }
+  }
+  resolveEntry() {
+    if (this.options.entry && existsSync(this.options.entry)) {
+      return this.options.entry;
+    }
+    const cwd = this.options.cwd;
+    const currentDir = dirname(fileURLToPath(import.meta.url));
+    const possibleEntries = [
+      join(currentDir, "start", "app.mjs"),
+      join(currentDir, "app.mjs"),
+      join(cwd, "dist", "main.js"),
+      join(cwd, "dist", "index.js"),
+      join(cwd, "index.js"),
+      join(cwd, "src", "main.ts"),
+      join(cwd, "src", "index.ts"),
+      join(cwd, "index.ts")
+    ];
+    for (const entry of possibleEntries) {
+      if (existsSync(entry)) {
+        return entry;
+      }
+    }
+    return null;
+  }
+};
+async function launch(options) {
+  const launcher = new ProcessLauncher(options);
+  await launcher.start();
+  return launcher;
+}
+var currentFile = fileURLToPath(import.meta.url);
+var entryFile = process.argv[1] ? fileURLToPath(`file:///${process.argv[1].replace(/\\/g, "/")}`) : "";
+if (currentFile === entryFile || process.argv[1]?.includes("start/index.mjs")) {
+  launch().catch((error) => {
+    logger.error(`\u542F\u52A8\u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  });
+}
+
+export {
+  __require,
+  ProcessLauncher,
+  launch
+};

package/dist/start/index.mjs

@@ -0,0 +1,8 @@
+import {
+  ProcessLauncher,
+  launch
+} from "./chunk-T7M5RXO7.mjs";
+export {
+  ProcessLauncher,
+  launch
+};

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "node-plume",
+  "version": "1.0.1",
+  "description": "Core runtime and plugin system for Plume bots",
+  "type": "module",
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "plume": "./dist/cli/index.mjs"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs"
+    },
+    "./cli": {
+      "import": "./dist/cli/index.mjs"
+    },
+    "./start": {
+      "import": "./dist/start/index.mjs"
+    },
+    "./app": {
+      "import": "./dist/start/app.mjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "commander": "^14.0.0",
+    "picocolors": "^1.0.0",
+    "@plume/types": "1.0.0",
+    "@plume/logger": "1.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.19.41",
+    "tsup": "^8.5.0",
+    "tsx": "^4.20.6",
+    "typescript": "^5.9.3"
+  },
+  "engines": {
+    "node": ">=18.18.0"
+  },
+  "scripts": {
+    "app": "tsx src/index.ts",
+    "build": "tsup",
+    "build:dev": "tsup",
+    "cli": "node dist/cli/index.mjs",
+    "cli:dev": "tsx src/cli/index.ts",
+    "dev": "tsx src/index.ts",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "clean": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\""
+  }
+}