node-plume 1.0.1

package/dist/start/chunk-EOB3JR5Y.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(`\u6B63\u5728\u542F\u52A8\u5E94\u7528 | \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(`\u5E94\u7528\u5DF2\u542F\u52A8 | 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.info("\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.info("\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("\u5E94\u7528\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) {
+        logger.error(`\u4E8B\u4EF6\u5904\u7406\u5668\u9519\u8BEF [${event}]:`, error);
+      }
+    });
+  }
+  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.info(`\u8FDB\u7A0B\u9000\u51FA | \u4FE1\u53F7: ${signal} | \u8FD0\u884C\u65F6\u95F4: ${uptime}ms`);
+    } else {
+      logger.info(`\u8FDB\u7A0B\u9000\u51FA | \u9000\u51FA\u7801: ${code ?? "\u672A\u77E5"} | \u8FD0\u884C\u65F6\u95F4: ${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);
+    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));
+      } else if (msg.type === "plume:stop") {
+        this.stop().catch((err) => logger.error("\u505C\u6B62\u5931\u8D25:", 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 appEntry = join(currentDir, "app.mjs");
+    if (existsSync(appEntry)) {
+      return appEntry;
+    }
+    const possibleEntries = [
+      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);
+    process.exit(1);
+  });
+}
+
+export {
+  __require,
+  ProcessLauncher,
+  launch
+};

package/dist/start/chunk-FSUAIZUX.mjs

@@ -0,0 +1,244 @@
+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("============================================================");
+    logger.info("Plume Process Launcher");
+    logger.info(`\u5DE5\u4F5C\u76EE\u5F55 | ${this.options.cwd}`);
+    logger.info(`\u8FD0\u884C\u6A21\u5F0F | ${this.options.watch ? "watch" : "foreground"}`);
+    logger.info(`\u6B63\u5728\u542F\u52A8\u5E94\u7528 | \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(`\u5E94\u7528\u5DF2\u542F\u52A8 | PID: ${this.process.pid}`);
+    logger.info("============================================================");
+    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.info("\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.info("\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("\u5E94\u7528\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) {
+        logger.error(`\u4E8B\u4EF6\u5904\u7406\u5668\u9519\u8BEF [${event}]:`, error);
+      }
+    });
+  }
+  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.info(`\u8FDB\u7A0B\u9000\u51FA | \u4FE1\u53F7: ${signal} | \u8FD0\u884C\u65F6\u95F4: ${uptime}ms`);
+    } else {
+      logger.info(`\u8FDB\u7A0B\u9000\u51FA | \u9000\u51FA\u7801: ${code ?? "\u672A\u77E5"} | \u8FD0\u884C\u65F6\u95F4: ${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);
+    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));
+      } else if (msg.type === "plume:stop") {
+        this.stop().catch((err) => logger.error("\u505C\u6B62\u5931\u8D25:", 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 appEntry = join(currentDir, "app.mjs");
+    if (existsSync(appEntry)) {
+      return appEntry;
+    }
+    const possibleEntries = [
+      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);
+    process.exit(1);
+  });
+}
+
+export {
+  __require,
+  ProcessLauncher,
+  launch
+};