wp-studio 1.7.7-alpha1

package/dist/cli/process-manager-ipc-AUZeYYDT.js

@@ -0,0 +1,454 @@
+import os from "os";
+import path from "path";
+import { EventEmitter } from "events";
+import fs from "fs";
+import net from "net";
+import { i as isErrnoException } from "./is-errno-exception-t38xF2pB.js";
+import { z } from "zod";
+import { c as childMessageFromProcessManagerSchema, m as managerMessageSchema } from "./wordpress-server-ipc-Dwsg9jSb.js";
+const PROCESS_MANAGER_HOME = process.env.STUDIO_PROCESS_MANAGER_HOME ?? path.join(os.homedir(), ".studio", "pm2");
+const PROCESS_MANAGER_LOGS_DIR = path.join(PROCESS_MANAGER_HOME, "logs");
+const PROCESS_MANAGER_CONTROL_SOCKET_PATH = process.platform === "win32" ? "\\\\.\\pipe\\studio-daemon.sock" : path.join(PROCESS_MANAGER_HOME, "daemon.sock");
+const PROCESS_MANAGER_EVENTS_SOCKET_PATH = process.platform === "win32" ? "\\\\.\\pipe\\studio-daemon-events.sock" : path.join(PROCESS_MANAGER_HOME, "daemon-events.sock");
+const DEFAULT_CONNECT_TIMEOUT_MS = 500;
+const DEFAULT_RECONNECT_DELAY_MS = 500;
+function isWindowsNamedPipe(endpoint) {
+  return endpoint.startsWith("\\\\.\\pipe\\");
+}
+function isUnixSocketPath(endpoint) {
+  return !isWindowsNamedPipe(endpoint);
+}
+function encodeSocketMessage(message) {
+  const json = JSON.stringify(message);
+  const body = Buffer.from(json, "utf8");
+  const header = Buffer.allocUnsafe(4);
+  header.writeUInt32BE(body.length, 0);
+  return Buffer.concat([header, body]);
+}
+class SocketMessageDecoder {
+  constructor() {
+    this.buffer = Buffer.alloc(0);
+  }
+  write(chunk) {
+    this.buffer = Buffer.concat([this.buffer, chunk]);
+    const messages = [];
+    while (this.buffer.length >= 4) {
+      const length = this.buffer.readUInt32BE(0);
+      if (this.buffer.length < 4 + length) {
+        break;
+      }
+      const payload = this.buffer.subarray(4, 4 + length);
+      this.buffer = this.buffer.subarray(4 + length);
+      messages.push(JSON.parse(payload.toString("utf8")));
+    }
+    return messages;
+  }
+}
+async function connectToEndpoint(peer, connectTimeoutMs) {
+  let timeoutId;
+  const socket = net.createConnection(peer);
+  return new Promise((resolve, reject) => {
+    timeoutId = setTimeout(() => {
+      socket.destroy();
+      reject(new Error(`Socket connect timeout: ${peer}`));
+    }, connectTimeoutMs);
+    socket.once("connect", () => {
+      resolve(socket);
+    });
+    socket.once("error", (error) => {
+      reject(error);
+    });
+  }).finally(() => {
+    clearTimeout(timeoutId);
+    socket.removeAllListeners();
+  });
+}
+class SocketClientEventEmitter extends EventEmitter {
+  on(event, listener) {
+    return super.on(event, listener);
+  }
+  emit(event, payload) {
+    return super.emit(event, payload);
+  }
+}
+class SocketStreamClient extends SocketClientEventEmitter {
+  constructor(endpoint, connectTimeoutMs = DEFAULT_CONNECT_TIMEOUT_MS) {
+    super();
+    this.socket = null;
+    this.connectPromise = null;
+    this.reconnectTimer = null;
+    this.closedByClient = false;
+    this.endpoint = endpoint;
+    this.connectTimeoutMs = connectTimeoutMs;
+    this.reconnectDelayMs = DEFAULT_RECONNECT_DELAY_MS;
+  }
+  async connect() {
+    this.closedByClient = false;
+    if (this.isConnected()) {
+      return this.socket;
+    }
+    if (this.connectPromise) {
+      return this.connectPromise;
+    }
+    this.connectPromise = connectToEndpoint(this.endpoint, this.connectTimeoutMs).then((socket) => {
+      this.attachPersistentSocketListeners(socket);
+      this.emit("connect", { socket });
+      return socket;
+    }).finally(() => {
+      this.connectPromise = null;
+    });
+    return this.connectPromise;
+  }
+  isConnected() {
+    return this.socket !== null && !this.socket.destroyed;
+  }
+  async close() {
+    this.closedByClient = true;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    const socket = this.socket;
+    this.socket = null;
+    if (socket && !socket.destroyed) {
+      await new Promise((resolve) => {
+        socket.once("close", () => resolve());
+        socket.end();
+      });
+    }
+  }
+  scheduleReconnect() {
+    if (this.closedByClient || this.reconnectTimer) {
+      return;
+    }
+    this.emit("reconnecting", { delayMs: this.reconnectDelayMs });
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      void this.connect().catch(() => {
+        this.scheduleReconnect();
+      });
+    }, this.reconnectDelayMs);
+  }
+  attachPersistentSocketListeners(socket) {
+    this.socket = socket;
+    socket.on("data", (chunk) => {
+      this.emit("data", { chunk, socket });
+    });
+    socket.on("error", (error) => {
+      this.emit("error", { error });
+    });
+    socket.on("close", (hadError) => {
+      if (this.socket === socket) {
+        this.socket = null;
+      }
+      this.emit("close", { hadError });
+      this.scheduleReconnect();
+    });
+  }
+}
+class SocketRequestClient {
+  constructor(endpoint, connectTimeoutMs = DEFAULT_CONNECT_TIMEOUT_MS) {
+    this.queue = Promise.resolve();
+    this.endpoint = endpoint;
+    this.connectTimeoutMs = connectTimeoutMs;
+  }
+  send(message) {
+    const payload = encodeSocketMessage(message);
+    const sendPromise = this.queue.then(async () => {
+      const socket = await connectToEndpoint(this.endpoint, this.connectTimeoutMs);
+      await this.sendToSocket(socket, payload);
+    });
+    this.queue = sendPromise.catch(() => void 0);
+    return sendPromise;
+  }
+  async sendToSocket(socket, payload) {
+    return new Promise((resolve, reject) => {
+      socket.once("error", (error) => {
+        reject(error);
+      });
+      socket.once("close", () => {
+        resolve();
+      });
+      if (socket.destroyed) {
+        reject(new Error(`Socket closed before send: ${this.endpoint}`));
+        return;
+      }
+      socket.end(payload);
+    }).finally(() => {
+      socket.removeAllListeners();
+    });
+  }
+  sendAndWaitForResponse(message) {
+    const payload = encodeSocketMessage(message);
+    const responsePromise = this.queue.then(async () => {
+      const socket = await connectToEndpoint(this.endpoint, this.connectTimeoutMs);
+      return this.sendAndReadFromSocket(socket, payload);
+    });
+    this.queue = responsePromise.then(
+      () => void 0,
+      () => void 0
+    );
+    return responsePromise;
+  }
+  async sendAndReadFromSocket(socket, payload) {
+    const decoder = new SocketMessageDecoder();
+    return new Promise((resolve, reject) => {
+      socket.once("error", (error) => {
+        reject(error);
+      });
+      socket.on("data", (chunk) => {
+        try {
+          for (const message of decoder.write(chunk)) {
+            resolve(message);
+            return;
+          }
+        } catch (error) {
+          reject(error);
+        }
+      });
+      socket.once("close", () => {
+        reject(new Error(`Socket closed before response: ${this.endpoint}`));
+      });
+      if (socket.destroyed) {
+        reject(new Error(`Socket closed before send: ${this.endpoint}`));
+        return;
+      }
+      socket.write(payload);
+    }).finally(() => {
+      socket.removeAllListeners();
+      socket.end();
+    });
+  }
+}
+class SocketServerEventEmitter extends EventEmitter {
+  on(event, listener) {
+    return super.on(event, listener);
+  }
+  emit(event, payload) {
+    return super.emit(event, payload);
+  }
+}
+class SocketServer extends SocketServerEventEmitter {
+  constructor(endpoint, connectTimeoutMs = DEFAULT_CONNECT_TIMEOUT_MS) {
+    super();
+    this.sockets = /* @__PURE__ */ new Set();
+    this.endpoint = endpoint;
+    this.connectTimeoutMs = connectTimeoutMs;
+    this.server = net.createServer((socket) => {
+      this.sockets.add(socket);
+      const decoder = new SocketMessageDecoder();
+      socket.on("data", (chunk) => {
+        try {
+          for (const message of decoder.write(chunk)) {
+            this.emit("message", { message, socket });
+          }
+        } catch (error) {
+          this.emit("message-error", { error });
+        }
+      });
+      socket.on("close", () => {
+        this.sockets.delete(socket);
+      });
+      socket.on("error", () => {
+        this.sockets.delete(socket);
+      });
+    });
+  }
+  async listen() {
+    try {
+      await this.attemptServerListen();
+    } catch (bindError) {
+      const isRecoverableInUse = isErrnoException(bindError) && bindError.code === "EADDRINUSE" && isUnixSocketPath(this.endpoint);
+      if (!isRecoverableInUse) {
+        throw bindError;
+      }
+      const activeServerExists = await this.canConnectUsingClient();
+      if (activeServerExists) {
+        throw bindError;
+      }
+      try {
+        fs.unlinkSync(this.endpoint);
+      } catch (unlinkError) {
+        if (isErrnoException(unlinkError) && unlinkError.code !== "ENOENT") {
+          throw unlinkError;
+        }
+      }
+      await this.attemptServerListen();
+    }
+  }
+  sendAndClose(socket, message) {
+    socket.end(encodeSocketMessage(message));
+  }
+  send(socket, message) {
+    socket.write(encodeSocketMessage(message));
+  }
+  broadcast(message) {
+    const payload = encodeSocketMessage(message);
+    for (const socket of this.sockets) {
+      if (!socket.destroyed) {
+        socket.write(payload);
+      }
+    }
+  }
+  async attemptServerListen() {
+    let timeoutId;
+    return new Promise((resolve, reject) => {
+      timeoutId = setTimeout(() => {
+        reject(new Error("Socket bind timeout"));
+      }, this.connectTimeoutMs);
+      this.server.once("error", (error) => {
+        reject(error);
+      });
+      this.server.once("listening", () => {
+        resolve();
+      });
+      this.server.listen(this.endpoint);
+    }).finally(() => {
+      this.server.removeAllListeners("error");
+      this.server.removeAllListeners("listening");
+      clearTimeout(timeoutId);
+    });
+  }
+  async canConnectUsingClient(timeoutMs = DEFAULT_CONNECT_TIMEOUT_MS) {
+    let timeoutId;
+    const socket = net.createConnection(this.endpoint);
+    return new Promise((resolve) => {
+      timeoutId = setTimeout(() => {
+        socket.destroy();
+        resolve(false);
+      }, timeoutMs);
+      socket.once("connect", () => {
+        socket.destroy();
+        resolve(true);
+      });
+      socket.once("error", () => {
+        resolve(false);
+      });
+    }).finally(() => {
+      clearTimeout(timeoutId);
+    });
+  }
+  close() {
+    return new Promise((resolve) => {
+      for (const socket of this.sockets) {
+        socket.destroy();
+      }
+      if (!this.server.listening) {
+        resolve();
+        return;
+      }
+      this.server.close(() => {
+        resolve();
+      });
+    });
+  }
+}
+const processDescriptionSchemaBase = z.object({
+  name: z.string(),
+  pmId: z.number()
+});
+const processDescriptionSchemaRunning = processDescriptionSchemaBase.extend({
+  status: z.literal("online"),
+  pid: z.number()
+});
+const processDescriptionSchemaStopped = processDescriptionSchemaBase.extend({
+  status: z.literal("stopped")
+});
+const processDescriptionSchema = z.discriminatedUnion("status", [
+  processDescriptionSchemaRunning,
+  processDescriptionSchemaStopped
+]);
+const daemonRequestPingSchema = z.object({
+  type: z.literal("ping")
+});
+const daemonRequestStartProcessSchema = z.object({
+  type: z.literal("start-process"),
+  processName: z.string(),
+  scriptPath: z.string(),
+  env: z.record(z.string(), z.string()).optional(),
+  args: z.array(z.string()).optional()
+});
+const daemonRequestStopProcessSchema = z.object({
+  type: z.literal("stop-process"),
+  processName: z.string()
+});
+const daemonRequestListProcessesSchema = z.object({
+  type: z.literal("list-processes")
+});
+const daemonRequestSendMessageToProcessSchema = z.object({
+  type: z.literal("send-message-to-process"),
+  processId: z.number(),
+  message: managerMessageSchema
+});
+const daemonRequestKillSchema = z.object({
+  type: z.literal("kill-daemon")
+});
+const daemonRequestSchema = z.discriminatedUnion("type", [
+  daemonRequestPingSchema,
+  daemonRequestStartProcessSchema,
+  daemonRequestStopProcessSchema,
+  daemonRequestListProcessesSchema,
+  daemonRequestSendMessageToProcessSchema,
+  daemonRequestKillSchema
+]);
+const daemonResponseResultSchema = z.object({
+  type: z.literal("result"),
+  payload: z.unknown()
+});
+const daemonResponseErrorSchema = z.object({
+  type: z.literal("error"),
+  error: z.object({
+    message: z.string(),
+    stack: z.string().optional()
+  })
+});
+const daemonResponseSchema = z.discriminatedUnion("type", [
+  daemonResponseResultSchema,
+  daemonResponseErrorSchema
+]);
+const processEventSchema = z.object({
+  process: z.object({
+    name: z.string(),
+    pm_id: z.number()
+  }),
+  event: z.union([
+    z.literal("delete"),
+    z.literal("exit"),
+    z.literal("online"),
+    z.literal("restart"),
+    z.literal("stop")
+  ])
+});
+const daemonProcessEventSchema = z.object({
+  type: z.literal("process-event"),
+  payload: processEventSchema
+});
+const daemonProcessMessageSchema = z.object({
+  type: z.literal("process-message"),
+  payload: childMessageFromProcessManagerSchema
+});
+const daemonKillEventSchema = z.object({
+  type: z.literal("daemon-kill"),
+  payload: z.object({
+    reason: z.string().optional()
+  })
+});
+const daemonEventSchema = z.discriminatedUnion("type", [
+  daemonProcessEventSchema,
+  daemonProcessMessageSchema,
+  daemonKillEventSchema
+]);
+export {
+  PROCESS_MANAGER_CONTROL_SOCKET_PATH as P,
+  SocketServer as S,
+  PROCESS_MANAGER_EVENTS_SOCKET_PATH as a,
+  PROCESS_MANAGER_LOGS_DIR as b,
+  daemonEventSchema as c,
+  daemonRequestSchema as d,
+  SocketRequestClient as e,
+  daemonResponseSchema as f,
+  PROCESS_MANAGER_HOME as g,
+  SocketMessageDecoder as h,
+  SocketStreamClient as i,
+  processDescriptionSchema as p
+};

package/dist/cli/proxy-daemon.js

@@ -0,0 +1,197 @@
+import require$$0 from "http";
+import require$$1 from "https";
+import { createSecureContext } from "node:tls";
+import { domainToASCII } from "node:url";
+import httpProxy from "http-proxy";
+import { r as readAppdata } from "./appdata-07CF2rhg.js";
+import { g as generateSiteCertificate } from "./certificate-manager-DdBumKZp.js";
+let httpProxyServer = null;
+let httpsProxyServer = null;
+let isHttpProxyRunning = false;
+let isHttpsProxyRunning = false;
+const proxy = httpProxy.createProxyServer();
+proxy.on("error", (err, req, res) => {
+  console.error("[Proxy Error]", err.message);
+  if (res && res instanceof require$$0.ServerResponse) {
+    res.writeHead(500, { "Content-Type": "text/plain" });
+    res.end("Proxy error: " + err.message);
+  }
+});
+async function getSiteByHost(domain) {
+  try {
+    const appdata = await readAppdata();
+    const site = appdata.sites.find(
+      (site2) => domainToASCII(site2.customDomain ?? "") === domainToASCII(domain)
+    );
+    return site ?? null;
+  } catch (error) {
+    console.error("[Proxy] Error looking up domain:", error);
+    return null;
+  }
+}
+function handleHealthCheck(res) {
+  res.writeHead(200, { "Content-Type": "application/json" });
+  res.end(
+    JSON.stringify({
+      status: "ok",
+      http: isHttpProxyRunning,
+      https: isHttpsProxyRunning,
+      timestamp: Date.now()
+    })
+  );
+}
+async function handleProxyRequest(req, res, isHttps) {
+  if (req.url === "/__studio_health") {
+    return handleHealthCheck(res);
+  }
+  const host = req.headers.host?.split(":")[0];
+  if (!host) {
+    console.log("[Proxy] No host header found");
+    res.writeHead(404, { "Content-Type": "text/plain" });
+    res.end("No host header found");
+    return;
+  }
+  const site = await getSiteByHost(host);
+  if (!site) {
+    console.log(`[Proxy] Domain not found: ${host}`);
+    res.writeHead(404, { "Content-Type": "text/plain" });
+    res.end(`Domain not found: ${host}`);
+    return;
+  }
+  if (!isHttps && site.enableHttps) {
+    res.writeHead(301, {
+      Location: `https://${host}${req.url}`
+    });
+    res.end();
+    return;
+  }
+  const headers = {};
+  if (isHttps) {
+    headers["X-Forwarded-Proto"] = "https";
+  }
+  proxy.web(req, res, {
+    target: `http://localhost:${site.port}`,
+    xfwd: true,
+    // Pass along x-forwarded headers
+    headers
+  });
+}
+async function startHttpProxy() {
+  if (isHttpProxyRunning) {
+    console.log("[Proxy] HTTP proxy already running");
+    return;
+  }
+  return new Promise((resolve, reject) => {
+    httpProxyServer = require$$0.createServer((req, res) => handleProxyRequest(req, res, false));
+    httpProxyServer.listen(80, () => {
+      console.log("[Proxy] HTTP server started on port 80");
+      isHttpProxyRunning = true;
+      resolve();
+    }).on("error", (err) => {
+      console.error("[Proxy] Error starting HTTP server:", err);
+      reject(err);
+    });
+  });
+}
+async function startHttpsProxy() {
+  if (isHttpsProxyRunning) {
+    console.log("[Proxy] HTTPS proxy already running");
+    return;
+  }
+  return new Promise((resolve, reject) => {
+    const defaultOptions = {
+      SNICallback: async (servername, cb) => {
+        try {
+          const site = await getSiteByHost(servername);
+          if (!site || !site.customDomain || !site.enableHttps) {
+            console.error(`[Proxy] SNI: Invalid hostname: ${servername}`);
+            cb(new Error(`Invalid hostname: ${servername}`));
+            return;
+          }
+          const { cert, key } = await generateSiteCertificate(site.customDomain);
+          const ctx = createSecureContext({
+            key,
+            cert,
+            minVersion: "TLSv1.2"
+          });
+          cb(null, ctx);
+        } catch (error) {
+          console.error(`[Proxy] SNI callback error for ${servername}:`, error);
+          cb(error);
+        }
+      }
+    };
+    httpsProxyServer = require$$1.createServer(
+      defaultOptions,
+      (req, res) => handleProxyRequest(req, res, true)
+    );
+    httpsProxyServer.listen(443, () => {
+      console.log("[Proxy] HTTPS server started on port 443");
+      isHttpsProxyRunning = true;
+      resolve();
+    }).on("error", (err) => {
+      console.error("[Proxy] Error starting HTTPS server:", err);
+      reject(err);
+    });
+  });
+}
+async function stopProxyServers() {
+  console.log("[Proxy] Stopping proxy servers…");
+  const promises = [];
+  if (httpProxyServer) {
+    promises.push(
+      new Promise((resolve) => {
+        httpProxyServer.close(() => {
+          httpProxyServer = null;
+          isHttpProxyRunning = false;
+          console.log("[Proxy] HTTP server stopped");
+          resolve();
+        });
+      })
+    );
+  }
+  if (httpsProxyServer) {
+    promises.push(
+      new Promise((resolve) => {
+        httpsProxyServer.close(() => {
+          httpsProxyServer = null;
+          isHttpsProxyRunning = false;
+          console.log("[Proxy] HTTPS server stopped");
+          resolve();
+        });
+      })
+    );
+  }
+  await Promise.all(promises);
+  console.log("[Proxy] All servers stopped");
+}
+async function startProxyServers() {
+  console.log("[Proxy] Starting WordPress Studio Proxy Server…");
+  const shutdown = async (signal) => {
+    console.log(`[Proxy] Received ${signal}, shutting down gracefully...`);
+    await stopProxyServers();
+    process.exit(0);
+  };
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+  process.on("SIGINT", () => shutdown("SIGINT"));
+  try {
+    await startHttpProxy();
+    await startHttpsProxy();
+    console.log("[Proxy] Proxy servers started successfully");
+    console.log("[Proxy] Ready to handle custom domain requests");
+    process.stdin.resume();
+  } catch (error) {
+    console.error("[Proxy] Failed to start proxy servers:", error);
+    throw error;
+  }
+}
+async function main() {
+  try {
+    console.log("[Proxy Daemon] Starting WordPress Studio Proxy Daemon…");
+    await startProxyServers();
+  } catch (error) {
+    console.error("[Proxy Daemon] Failed to start:", error);
+    process.exit(1);
+  }
+}
+void main();