wp-studio 1.7.7-alpha1

package/dist/cli/process-manager-daemon.js

@@ -0,0 +1,327 @@
+import { spawn } from "child_process";
+import fs, { createWriteStream } from "fs";
+import path from "path";
+import readline from "readline";
+import semver from "semver";
+import { S as SocketServer, P as PROCESS_MANAGER_CONTROL_SOCKET_PATH, a as PROCESS_MANAGER_EVENTS_SOCKET_PATH, b as PROCESS_MANAGER_LOGS_DIR, d as daemonRequestSchema, c as daemonEventSchema } from "./process-manager-ipc-AUZeYYDT.js";
+const SOCKET_TIMEOUT_MS = 2500;
+const STOP_TIMEOUT_MS = 5e3;
+function getProcessLogPaths(processName) {
+  return {
+    stdoutLogPath: path.join(PROCESS_MANAGER_LOGS_DIR, `${processName}-out.log`),
+    stderrLogPath: path.join(PROCESS_MANAGER_LOGS_DIR, `${processName}-error.log`)
+  };
+}
+function timestampLogLine(line) {
+  return `${(/* @__PURE__ */ new Date()).toISOString()} ${line}
+`;
+}
+function writeTimestampedLines(target, content) {
+  const normalizedContent = content.split("\r\n").join("\n");
+  const lines = normalizedContent.trimEnd().split("\n");
+  lines.forEach((line) => {
+    target.write(timestampLogLine(line));
+  });
+}
+class ProcessManagerDaemon {
+  constructor() {
+    this.controlServer = new SocketServer(
+      PROCESS_MANAGER_CONTROL_SOCKET_PATH,
+      SOCKET_TIMEOUT_MS
+    );
+    this.eventsServer = new SocketServer(
+      PROCESS_MANAGER_EVENTS_SOCKET_PATH,
+      SOCKET_TIMEOUT_MS
+    );
+    this.managedProcesses = /* @__PURE__ */ new Map();
+    this.nextPmId = 1;
+    this.shuttingDown = false;
+  }
+  async start() {
+    fs.mkdirSync(PROCESS_MANAGER_LOGS_DIR, { recursive: true });
+    this.controlServer.on("message", ({ message, socket }) => {
+      void this.handleDecodedRequest(socket, message);
+    });
+    await this.eventsServer.listen();
+    await this.controlServer.listen();
+    process.on("SIGINT", () => void this.shutdown("signal"));
+    process.on("SIGTERM", () => void this.shutdown("signal"));
+    process.on("exit", () => {
+      this.forceCleanupChildren();
+    });
+  }
+  async handleDecodedRequest(socket, payload) {
+    const parsed = daemonRequestSchema.safeParse(payload);
+    if (!parsed.success) {
+      this.controlServer.sendAndClose(socket, {
+        type: "error",
+        error: { message: parsed.error.message }
+      });
+      return;
+    }
+    const request = parsed.data;
+    try {
+      const response = await this.handleRequest(request);
+      this.controlServer.sendAndClose(socket, response);
+      if (request.type === "kill-daemon") {
+        setImmediate(() => {
+          void this.shutdown("kill-daemon");
+        });
+      }
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      this.controlServer.sendAndClose(socket, {
+        type: "error",
+        error: { message: err.message, stack: err.stack }
+      });
+    }
+  }
+  async handleRequest(request) {
+    switch (request.type) {
+      case "ping":
+        return {
+          type: "result",
+          payload: {}
+        };
+      case "start-process": {
+        const processDesc = await this.startProcess(
+          request.processName,
+          request.scriptPath,
+          request.env ?? {},
+          request.args ?? []
+        );
+        return {
+          type: "result",
+          payload: { process: processDesc }
+        };
+      }
+      case "stop-process":
+        await this.stopProcess(request.processName);
+        return {
+          type: "result",
+          payload: {}
+        };
+      case "list-processes":
+        return {
+          type: "result",
+          payload: { processes: this.listProcesses() }
+        };
+      case "send-message-to-process":
+        await this.sendMessageToProcess(request.processId, request.message);
+        return {
+          type: "result",
+          payload: {}
+        };
+      case "kill-daemon":
+        return {
+          type: "result",
+          payload: {}
+        };
+    }
+  }
+  listProcesses() {
+    return Array.from(this.managedProcesses.values()).map(this.toProcessDescription);
+  }
+  getManagedProcessByName(processName) {
+    for (const managedProcess of this.managedProcesses.values()) {
+      if (managedProcess.name === processName) {
+        return managedProcess;
+      }
+    }
+    return void 0;
+  }
+  async startProcess(processName, scriptPath, env, args) {
+    const existing = this.getManagedProcessByName(processName);
+    if (existing && existing.status === "online") {
+      return this.toProcessDescription(existing);
+    }
+    const pmId = this.nextPmId++;
+    const { stdoutLogPath, stderrLogPath } = getProcessLogPaths(processName);
+    const stdoutStream = createWriteStream(stdoutLogPath, { flags: "a" });
+    const stderrStream = createWriteStream(stderrLogPath, { flags: "a" });
+    const doesCurrentNodeSupportJspi = semver.gte(process.version, "24.0.0");
+    const execArgv = doesCurrentNodeSupportJspi ? ["--experimental-wasm-jspi"] : [];
+    const child = spawn(process.execPath, [...execArgv, scriptPath, ...args], {
+      env: { ...process.env, ...env },
+      stdio: ["ignore", "pipe", "pipe", "ipc"],
+      windowsHide: true
+    });
+    const managedProcess = {
+      pmId,
+      name: processName,
+      scriptPath,
+      args,
+      env,
+      child,
+      // `child.pid` is only undefined if there's an error, in which case our error handler
+      // immediately changes the status and deletes the process from the map
+      pid: child.pid,
+      status: "online",
+      stdoutLogPath,
+      stderrLogPath,
+      stdoutStream,
+      stderrStream,
+      settled: false
+    };
+    this.managedProcesses.set(pmId, managedProcess);
+    this.pipeOutputWithTimestamp(child.stdout, stdoutStream);
+    this.pipeOutputWithTimestamp(child.stderr, stderrStream);
+    child.on("message", (raw) => {
+      const event = daemonEventSchema.safeParse({
+        type: "process-message",
+        payload: {
+          process: { name: processName, pm_id: pmId },
+          raw
+        }
+      });
+      if (event.success) {
+        void this.broadcastEvent(event.data);
+      }
+    });
+    child.on("error", (error) => {
+      writeTimestampedLines(stderrStream, error.stack ?? error.message);
+      void this.handleProcessExit(managedProcess);
+    });
+    child.on("exit", () => {
+      void this.handleProcessExit(managedProcess);
+    });
+    await this.broadcastEvent({
+      type: "process-event",
+      payload: {
+        process: { name: processName, pm_id: pmId },
+        event: "online"
+      }
+    });
+    return this.toProcessDescription(managedProcess);
+  }
+  async stopProcess(processName) {
+    const managedProcess = this.getManagedProcessByName(processName);
+    if (!managedProcess || managedProcess.settled) {
+      return;
+    }
+    await new Promise((resolve) => {
+      const timeoutId = setTimeout(() => {
+        managedProcess.child.kill("SIGKILL");
+      }, STOP_TIMEOUT_MS);
+      managedProcess.child.once("exit", () => {
+        clearTimeout(timeoutId);
+        void this.broadcastEvent({
+          type: "process-event",
+          payload: {
+            process: { name: managedProcess.name, pm_id: managedProcess.pmId },
+            event: "delete"
+          }
+        });
+        resolve();
+      });
+      managedProcess.child.kill("SIGTERM");
+    });
+  }
+  async handleProcessExit(managedProcess) {
+    if (managedProcess.settled) {
+      return;
+    }
+    managedProcess.settled = true;
+    managedProcess.status = "stopped";
+    this.managedProcesses.delete(managedProcess.pmId);
+    managedProcess.stdoutStream.end();
+    managedProcess.stderrStream.end();
+    await this.broadcastEvent({
+      type: "process-event",
+      payload: {
+        process: { name: managedProcess.name, pm_id: managedProcess.pmId },
+        event: "exit"
+      }
+    });
+  }
+  async sendMessageToProcess(processId, message) {
+    const managedProcess = this.managedProcesses.get(processId);
+    if (!managedProcess) {
+      throw new Error(`Process with id ${processId} not found`);
+    }
+    if (!managedProcess.child.connected) {
+      throw new Error(`Process with id ${processId} is not connected`);
+    }
+    await new Promise((resolve, reject) => {
+      managedProcess.child.send(message, (error) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve();
+      });
+    });
+  }
+  async broadcastEvent(event) {
+    this.eventsServer.broadcast(event);
+  }
+  pipeOutputWithTimestamp(input, target) {
+    if (!input) {
+      return;
+    }
+    const lineReader = readline.createInterface({
+      input,
+      crlfDelay: Infinity
+    });
+    lineReader.on("line", (line) => {
+      void target.write(timestampLogLine(line));
+    });
+  }
+  toProcessDescription(managedProcess) {
+    if (managedProcess.status === "stopped") {
+      return {
+        name: managedProcess.name,
+        pmId: managedProcess.pmId,
+        status: managedProcess.status
+      };
+    }
+    return {
+      name: managedProcess.name,
+      pmId: managedProcess.pmId,
+      status: managedProcess.status,
+      pid: managedProcess.pid
+    };
+  }
+  forceCleanupChildren() {
+    for (const managedProcess of this.managedProcesses.values()) {
+      if (managedProcess.settled) {
+        continue;
+      }
+      try {
+        managedProcess.child.kill("SIGKILL");
+      } catch {
+      }
+    }
+  }
+  async shutdown(reason) {
+    if (this.shuttingDown) {
+      return;
+    }
+    this.shuttingDown = true;
+    await this.broadcastEvent({
+      type: "daemon-kill",
+      payload: { reason }
+    });
+    await Promise.allSettled(
+      Array.from(this.managedProcesses.values()).map(
+        (managedProcess) => this.stopProcess(managedProcess.name)
+      )
+    );
+    await new Promise((resolve) => {
+      void this.controlServer.close().then(() => resolve());
+    });
+    await this.eventsServer.close();
+  }
+}
+async function main() {
+  try {
+    const daemon = new ProcessManagerDaemon();
+    await daemon.start();
+  } catch (error) {
+    console.error(error);
+  }
+}
+void main();
+export {
+  ProcessManagerDaemon
+};