wp-studio 1.7.7-alpha1

package/dist/cli/wordpress-server-manager-CtiuJqEb.js

@@ -0,0 +1,566 @@
+import path from "path";
+import { T as lockFileAsync, U as unlockFileAsync, V as LOCKFILE_STALE_TIME, W as LOCKFILE_WAIT_TIME, X as PLAYGROUND_CLI_INACTIVITY_TIMEOUT, Y as PLAYGROUND_CLI_MAX_TIMEOUT, Z as PLAYGROUND_CLI_ACTIVITY_CHECK_INTERVAL, S as SITE_EVENTS } from "./appdata-07CF2rhg.js";
+import { z } from "zod";
+import { spawn } from "child_process";
+import crypto$1 from "crypto";
+import { EventEmitter } from "events";
+import fs from "fs";
+import { i as isErrnoException } from "./is-errno-exception-t38xF2pB.js";
+import { e as SocketRequestClient, a as PROCESS_MANAGER_EVENTS_SOCKET_PATH, P as PROCESS_MANAGER_CONTROL_SOCKET_PATH, f as daemonResponseSchema, g as PROCESS_MANAGER_HOME, h as SocketMessageDecoder, i as SocketStreamClient, c as daemonEventSchema, p as processDescriptionSchema } from "./process-manager-ipc-AUZeYYDT.js";
+const PROXY_PROCESS_NAME = "studio-proxy";
+const CONNECTION_TIMEOUT_MS = 1e4;
+const PROCESS_MANAGER_LOCKFILE_PATH = path.join(PROCESS_MANAGER_HOME, "pm-connection.lock");
+const SITE_EVENTS_SOCKET_PATH = process.platform === "win32" ? "\\\\.\\pipe\\studio-events.sock" : path.join(PROCESS_MANAGER_HOME, "events.sock");
+if (!fs.existsSync(PROCESS_MANAGER_HOME)) {
+  fs.mkdirSync(PROCESS_MANAGER_HOME, { recursive: true });
+}
+class DaemonBusEventEmitter extends EventEmitter {
+  on(event, listener) {
+    return super.on(event, listener);
+  }
+  emit(event, payload) {
+    return super.emit(event, payload);
+  }
+}
+class DaemonBus extends DaemonBusEventEmitter {
+  constructor(endpoint) {
+    super();
+    this.decoder = new SocketMessageDecoder();
+    this.socketClient = new SocketStreamClient(endpoint, 2500);
+    this.socketClient.on("data", ({ chunk }) => {
+      try {
+        for (const packet of this.decoder.write(chunk)) {
+          this.handlePacket(packet);
+        }
+      } catch {
+        this.decoder = new SocketMessageDecoder();
+      }
+    });
+    this.socketClient.on("close", () => {
+      this.decoder = new SocketMessageDecoder();
+    });
+  }
+  isConnected() {
+    return this.socketClient.isConnected();
+  }
+  handlePacket(packet) {
+    const result = daemonEventSchema.safeParse(packet);
+    if (!result.success) {
+      return;
+    }
+    switch (result.data.type) {
+      case "process-message":
+        this.emit("process-message", result.data.payload);
+        return;
+      case "process-event":
+        this.emit("process-event", result.data.payload);
+        return;
+      case "daemon-kill":
+        this.emit("daemon-kill", result.data.payload);
+        return;
+    }
+  }
+  async connect() {
+    await this.socketClient.connect();
+  }
+  async close() {
+    await this.socketClient.close();
+  }
+}
+async function sendDaemonRequest(request) {
+  const socketClient = new SocketRequestClient(
+    PROCESS_MANAGER_CONTROL_SOCKET_PATH,
+    CONNECTION_TIMEOUT_MS
+  );
+  const rawResponse = await socketClient.sendAndWaitForResponse({
+    ...request,
+    requestId: crypto$1.randomUUID()
+  });
+  const response = daemonResponseSchema.parse(rawResponse);
+  if (response.type === "error") {
+    throw new Error(response.error.message);
+  }
+  return response.payload;
+}
+async function waitForDaemonReady() {
+  const start = Date.now();
+  let lastError;
+  while (Date.now() - start < CONNECTION_TIMEOUT_MS) {
+    try {
+      await sendDaemonRequest({ type: "ping" });
+      return;
+    } catch (error) {
+      lastError = error;
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+  }
+  if (lastError instanceof Error) {
+    throw lastError;
+  }
+  throw new Error(`Daemon connection timeout after ${CONNECTION_TIMEOUT_MS / 1e3} seconds`);
+}
+function spawnDaemonProcess() {
+  const daemonScriptPath = path.resolve(import.meta.dirname, "process-manager-daemon.js");
+  const daemonProcess = spawn(process.execPath, [daemonScriptPath], {
+    detached: true,
+    stdio: "ignore",
+    windowsHide: true
+  });
+  daemonProcess.unref();
+}
+function isRecoverableConnectError(error) {
+  return isErrnoException(error) && (error.code === "ENOENT" || error.code === "ECONNREFUSED" || error.code === "EPIPE");
+}
+async function ensureDaemonIsRunning() {
+  try {
+    await sendDaemonRequest({ type: "ping" });
+  } catch (error) {
+    if (!isRecoverableConnectError(error)) {
+      throw error;
+    }
+    spawnDaemonProcess();
+    await waitForDaemonReady();
+    await sendDaemonRequest({ type: "ping" });
+  }
+}
+let daemonBus = null;
+async function ensureDaemonBus() {
+  if (daemonBus) {
+    if (!daemonBus.isConnected()) {
+      await daemonBus.connect();
+    }
+    return daemonBus;
+  }
+  const bus = new DaemonBus(PROCESS_MANAGER_EVENTS_SOCKET_PATH);
+  await bus.connect();
+  daemonBus = bus;
+  return bus;
+}
+async function cleanupDaemonBus() {
+  const busToClose = daemonBus;
+  daemonBus = null;
+  if (busToClose) {
+    await busToClose.close();
+  }
+}
+let isConnected = false;
+async function connectToDaemon() {
+  if (isConnected) {
+    return;
+  }
+  await lockFileAsync(PROCESS_MANAGER_LOCKFILE_PATH, {
+    wait: LOCKFILE_WAIT_TIME,
+    stale: LOCKFILE_STALE_TIME
+  });
+  try {
+    await ensureDaemonIsRunning();
+    await ensureDaemonBus();
+    isConnected = true;
+  } catch (error) {
+    await cleanupDaemonBus();
+    throw error;
+  } finally {
+    await unlockFileAsync(PROCESS_MANAGER_LOCKFILE_PATH);
+  }
+}
+async function disconnectFromDaemon() {
+  isConnected = false;
+  await cleanupDaemonBus();
+}
+async function killDaemonAndChildren() {
+  await sendDaemonRequest({ type: "kill-daemon" });
+}
+const daemonListProcessesSuccessResponseSchema = z.object({
+  processes: z.array(processDescriptionSchema)
+});
+async function listProcesses() {
+  await connectToDaemon();
+  const response = await sendDaemonRequest({
+    type: "list-processes"
+  });
+  return daemonListProcessesSuccessResponseSchema.parse(response).processes;
+}
+async function getDaemonBus() {
+  if (!daemonBus) {
+    throw new Error("Daemon bus is not initialized");
+  }
+  return daemonBus;
+}
+async function sendMessageToProcess(processId, messageToProcess) {
+  await sendDaemonRequest({
+    type: "send-message-to-process",
+    processId,
+    message: messageToProcess
+  });
+}
+async function startProxyProcess() {
+  const proxyDaemonPath = path.resolve(import.meta.dirname, "proxy-daemon.js");
+  return startProcess(PROXY_PROCESS_NAME, proxyDaemonPath);
+}
+async function isProxyProcessRunning() {
+  return isProcessRunning(PROXY_PROCESS_NAME);
+}
+async function stopProxyProcess() {
+  return stopProcess(PROXY_PROCESS_NAME);
+}
+async function isProcessRunning(processName) {
+  try {
+    const processes = await listProcesses();
+    return processes.find((p) => p.name === processName && p.status === "online");
+  } catch (error) {
+    console.error(`Error checking if process ${processName} is running:`, error);
+    return void 0;
+  }
+}
+const daemonStartProcessSuccessResponseSchema = z.object({
+  process: processDescriptionSchema
+});
+async function startProcess(processName, scriptPath, env = {}, args = []) {
+  const response = await sendDaemonRequest({
+    type: "start-process",
+    processName,
+    scriptPath,
+    env,
+    args
+  });
+  return daemonStartProcessSuccessResponseSchema.parse(response).process;
+}
+async function stopProcess(processName) {
+  const runningProcess = await isProcessRunning(processName);
+  if (!runningProcess) {
+    return;
+  }
+  await connectToDaemon();
+  await sendDaemonRequest({
+    type: "stop-process",
+    processName
+  });
+}
+const eventsSocketClient = new SocketRequestClient(SITE_EVENTS_SOCKET_PATH);
+async function emitSiteEvent(event, data) {
+  try {
+    await eventsSocketClient.send({ event, data });
+  } catch {
+  }
+}
+const SITE_PROCESS_PREFIX = "studio-site-";
+const abortController = new AbortController();
+process.on("SIGINT", () => abortController.abort());
+process.on("SIGTERM", () => abortController.abort());
+function getProcessName(siteId) {
+  return `${SITE_PROCESS_PREFIX}${siteId}`;
+}
+async function isServerRunning(siteId) {
+  const processName = getProcessName(siteId);
+  return isProcessRunning(processName);
+}
+async function startWordPressServer(site, logger, options) {
+  const wordPressServerChildPath = path.resolve(import.meta.dirname, "wordpress-server-child.js");
+  const processName = getProcessName(site.id);
+  const serverConfig = {
+    siteId: site.id,
+    sitePath: site.path,
+    port: site.port,
+    phpVersion: site.phpVersion,
+    siteTitle: site.name
+  };
+  if (site.customDomain) {
+    const protocol = site.enableHttps ? "https" : "http";
+    serverConfig.absoluteUrl = `${protocol}://${site.customDomain}`;
+  }
+  if (site.adminUsername) {
+    serverConfig.adminUsername = site.adminUsername;
+  }
+  if (site.adminPassword) {
+    serverConfig.adminPassword = site.adminPassword;
+  }
+  if (site.adminEmail) {
+    serverConfig.adminEmail = site.adminEmail;
+  }
+  if (site.isWpAutoUpdating !== void 0) {
+    serverConfig.isWpAutoUpdating = site.isWpAutoUpdating;
+  }
+  if (options?.wpVersion) {
+    serverConfig.wpVersion = options.wpVersion;
+  }
+  if (options?.blueprint && options.blueprintUri) {
+    serverConfig.blueprint = {
+      contents: options.blueprint,
+      uri: options.blueprintUri
+    };
+  }
+  if (site.enableXdebug) {
+    serverConfig.enableXdebug = true;
+  }
+  if (site.enableDebugLog) {
+    serverConfig.enableDebugLog = true;
+  }
+  if (site.enableDebugDisplay) {
+    serverConfig.enableDebugDisplay = true;
+  }
+  const processDesc = await startProcess(processName, wordPressServerChildPath);
+  await waitForReadyMessage(processDesc.pmId);
+  await sendMessage(
+    processDesc.pmId,
+    processName,
+    {
+      topic: "start-server",
+      data: { config: serverConfig }
+    },
+    { logger }
+  );
+  return processDesc;
+}
+async function waitForReadyMessage(pmId) {
+  const bus = await getDaemonBus();
+  let timeoutId;
+  let readyHandler;
+  let abortListener;
+  return new Promise((resolve, reject) => {
+    timeoutId = setTimeout(() => {
+      reject(new Error("Timeout waiting for ready message from WordPress server child"));
+    }, PLAYGROUND_CLI_INACTIVITY_TIMEOUT);
+    readyHandler = (packet) => {
+      if (packet.process.pm_id === pmId && packet.raw.topic === "ready") {
+        resolve();
+      }
+    };
+    abortListener = () => {
+      reject(new Error("Operation aborted"));
+    };
+    abortController.signal.addEventListener("abort", abortListener);
+    bus.on("process-message", readyHandler);
+  }).finally(() => {
+    clearTimeout(timeoutId);
+    abortController.signal.removeEventListener("abort", abortListener);
+    bus.off("process-message", readyHandler);
+  });
+}
+const messageActivityTrackers = /* @__PURE__ */ new Map();
+async function sendMessage(pmId, processName, message, options = {}) {
+  const { maxTotalElapsedTime = PLAYGROUND_CLI_MAX_TIMEOUT, logger } = options;
+  const bus = await getDaemonBus();
+  const messageId = crypto.randomUUID();
+  let responseHandler;
+  let processEventHandler;
+  let abortListener;
+  return new Promise((resolve, reject) => {
+    const startTime = Date.now();
+    let lastActivityTimestamp = Date.now();
+    const activityCheckIntervalId = setInterval(() => {
+      const now = Date.now();
+      const timeSinceLastActivity = now - lastActivityTimestamp;
+      const totalElapsedTime = now - startTime;
+      if (timeSinceLastActivity > PLAYGROUND_CLI_INACTIVITY_TIMEOUT || totalElapsedTime > maxTotalElapsedTime) {
+        const timeoutReason = totalElapsedTime > maxTotalElapsedTime ? `Maximum timeout of ${maxTotalElapsedTime / 1e3}s exceeded` : `No activity for ${PLAYGROUND_CLI_INACTIVITY_TIMEOUT / 1e3}s`;
+        reject(
+          new Error(
+            `Timeout waiting for response to message ${message.topic}: ${timeoutReason}`
+          )
+        );
+      }
+    }, PLAYGROUND_CLI_ACTIVITY_CHECK_INTERVAL);
+    messageActivityTrackers.set(messageId, {
+      activityCheckIntervalId
+    });
+    processEventHandler = (event) => {
+      if (event.process.name === processName && event.event === "exit") {
+        reject(new Error("WordPress server process exited unexpectedly"));
+      }
+    };
+    responseHandler = (packet) => {
+      if (packet.process.pm_id !== pmId) {
+        return;
+      }
+      if (packet.raw.topic === "activity") {
+        lastActivityTimestamp = Date.now();
+      } else if (packet.raw.topic === "console-message") {
+        lastActivityTimestamp = Date.now();
+        logger?.reportProgress(packet.raw.message);
+      } else if (packet.raw.topic === "error" && packet.raw.originalMessageId === messageId) {
+        const error = new Error(packet.raw.errorMessage);
+        if (packet.raw.errorStack) {
+          error.stack = packet.raw.errorStack;
+        }
+        if (packet.raw.cliArgs) {
+          error.cliArgs = packet.raw.cliArgs;
+        }
+        reject(error);
+      } else if (packet.raw.topic === "result" && packet.raw.originalMessageId === messageId) {
+        resolve(packet.raw.result);
+      }
+    };
+    abortListener = () => {
+      void sendMessageToProcess(pmId, { messageId, topic: "abort", data: {} });
+      reject(new Error("Operation aborted"));
+    };
+    abortController.signal.addEventListener("abort", abortListener);
+    bus.on("process-event", processEventHandler);
+    bus.on("process-message", responseHandler);
+    sendMessageToProcess(pmId, { ...message, messageId }).catch(reject);
+  }).finally(() => {
+    abortController.signal.removeEventListener("abort", abortListener);
+    bus.off("process-event", processEventHandler);
+    bus.off("process-message", responseHandler);
+    const tracker = messageActivityTrackers.get(messageId);
+    if (tracker) {
+      clearInterval(tracker.activityCheckIntervalId);
+      messageActivityTrackers.delete(messageId);
+    }
+  });
+}
+const GRACEFUL_STOP_TIMEOUT = 5e3;
+async function stopWordPressServer(siteId) {
+  const processName = getProcessName(siteId);
+  const runningProcess = await isProcessRunning(processName);
+  if (!runningProcess) {
+    return;
+  }
+  try {
+    const bus = await getDaemonBus();
+    let busExitEventListener;
+    const exitPromise = new Promise((resolve) => {
+      busExitEventListener = (event) => {
+        if (event.process.name === processName && event.event === "exit") {
+          resolve();
+        }
+      };
+      bus.on("process-event", busExitEventListener);
+    }).finally(() => {
+      bus.off("process-event", busExitEventListener);
+    });
+    await sendMessage(
+      runningProcess.pmId,
+      processName,
+      { topic: "stop-server", data: {} },
+      { maxTotalElapsedTime: GRACEFUL_STOP_TIMEOUT }
+    );
+    await Promise.race([
+      exitPromise,
+      new Promise((resolve, reject) => setTimeout(reject, 5e3))
+    ]);
+  } catch {
+    return stopProcess(processName);
+  }
+}
+async function runBlueprint(site, logger, options) {
+  const wordPressServerChildPath = path.resolve(import.meta.dirname, "wordpress-server-child.js");
+  const processName = getProcessName(site.id);
+  const serverConfig = {
+    siteId: site.id,
+    sitePath: site.path,
+    port: site.port,
+    phpVersion: site.phpVersion,
+    siteTitle: site.name,
+    blueprint: {
+      contents: options.blueprint,
+      uri: options.blueprintUri
+    }
+  };
+  if (site.customDomain) {
+    const protocol = site.enableHttps ? "https" : "http";
+    serverConfig.absoluteUrl = `${protocol}://${site.customDomain}`;
+  }
+  if (site.adminUsername) {
+    serverConfig.adminUsername = site.adminUsername;
+  }
+  if (site.adminPassword) {
+    serverConfig.adminPassword = site.adminPassword;
+  }
+  if (site.adminEmail) {
+    serverConfig.adminEmail = site.adminEmail;
+  }
+  if (site.isWpAutoUpdating !== void 0) {
+    serverConfig.isWpAutoUpdating = site.isWpAutoUpdating;
+  }
+  if (options.wpVersion) {
+    serverConfig.wpVersion = options.wpVersion;
+  }
+  if (site.enableXdebug) {
+    serverConfig.enableXdebug = true;
+  }
+  if (site.enableDebugLog) {
+    serverConfig.enableDebugLog = true;
+  }
+  if (site.enableDebugDisplay) {
+    serverConfig.enableDebugDisplay = true;
+  }
+  const processDesc = await startProcess(processName, wordPressServerChildPath);
+  try {
+    await waitForReadyMessage(processDesc.pmId);
+    await sendMessage(
+      processDesc.pmId,
+      processName,
+      {
+        topic: "run-blueprint",
+        data: { config: serverConfig }
+      },
+      { logger }
+    );
+  } finally {
+    await stopProcess(processName);
+  }
+}
+const wpCliResultSchema = z.object({
+  stdout: z.string(),
+  stderr: z.string(),
+  exitCode: z.number()
+});
+async function sendWpCliCommand(siteId, args) {
+  const processName = getProcessName(siteId);
+  const runningProcess = await isProcessRunning(processName);
+  if (!runningProcess) {
+    throw new Error(`WordPress server is not running`);
+  }
+  const result = await sendMessage(runningProcess.pmId, processName, {
+    topic: "wp-cli-command",
+    data: { args }
+  });
+  return wpCliResultSchema.parse(result);
+}
+async function subscribeSiteEvents(handler) {
+  const bus = await getDaemonBus();
+  const messageHandler = (message) => {
+    const processName = message.process.name;
+    if (!processName.startsWith(SITE_PROCESS_PREFIX)) {
+      return;
+    }
+    if (message.raw.topic === "result") {
+      const siteId = processName.replace(SITE_PROCESS_PREFIX, "");
+      handler({ siteId, event: SITE_EVENTS.UPDATED, running: true });
+    }
+  };
+  bus.on("process-message", messageHandler);
+  const eventHandler = (event) => {
+    const processName = event.process.name;
+    if (!processName.startsWith(SITE_PROCESS_PREFIX)) {
+      return;
+    }
+    if (event.event !== "online") {
+      const siteId = processName.replace(SITE_PROCESS_PREFIX, "");
+      handler({ siteId, event: SITE_EVENTS.UPDATED, running: false });
+    }
+  };
+  bus.on("process-event", eventHandler);
+  return () => {
+    bus.off("process-message", messageHandler);
+    bus.off("process-event", eventHandler);
+  };
+}
+export {
+  SITE_EVENTS_SOCKET_PATH as S,
+  stopWordPressServer as a,
+  sendWpCliCommand as b,
+  connectToDaemon as c,
+  disconnectFromDaemon as d,
+  emitSiteEvent as e,
+  subscribeSiteEvents as f,
+  getDaemonBus as g,
+  isProxyProcessRunning as h,
+  isServerRunning as i,
+  stopProxyProcess as j,
+  killDaemonAndChildren as k,
+  startProxyProcess as l,
+  runBlueprint as r,
+  startWordPressServer as s
+};

package/dist/cli/wordpress-version-utils-B6UVeTh_.js

@@ -0,0 +1,51 @@
+function isValidWordPressVersion(version) {
+  const versionPattern = /^latest$|^nightly$|^(?:(\d+)\.(\d+)(?:\.(\d+))?)((?:-beta(?:\d+)?)|(?:-RC(?:\d+)?))?$/;
+  return versionPattern.test(version);
+}
+function isWordPressDevVersion(version) {
+  return version === "nightly" || /^\d+\.\d+(?:\.\d+)?(?:-[a-zA-Z0-9]+)*-\d+$/.test(version);
+}
+function isWordPressBetaVersion(version) {
+  return version.includes("beta") || version.includes("RC");
+}
+function getWordPressVersionUrl(version) {
+  if (isWordPressDevVersion(version)) {
+    return "https://wordpress.org/nightly-builds/wordpress-latest.zip";
+  }
+  if (!isValidWordPressVersion(version)) {
+    throw new Error(
+      'Unrecognized WordPress version. Please use "latest" or numeric versions such as "6.2", "6.0.1", "6.2-beta1", or "6.2-RC1"'
+    );
+  }
+  return `https://wordpress.org/wordpress-${version}.zip`;
+}
+function isWordPressVersionAtLeast(version, minimumVersion) {
+  if (version === "latest" || version === "nightly") {
+    return true;
+  }
+  let versionToCompare = version;
+  if (version.includes("-")) {
+    versionToCompare = version.split("-")[0];
+  }
+  const parseVersion = (v) => v.split(".").map(Number);
+  const provided = parseVersion(versionToCompare);
+  const minimum = parseVersion(minimumVersion);
+  for (let i = 0; i < Math.max(provided.length, minimum.length); i++) {
+    const p = provided[i] || 0;
+    const m = minimum[i] || 0;
+    if (p < m) {
+      return false;
+    }
+    if (p > m) {
+      return true;
+    }
+  }
+  return true;
+}
+export {
+  isWordPressBetaVersion as a,
+  isValidWordPressVersion as b,
+  isWordPressVersionAtLeast as c,
+  getWordPressVersionUrl as g,
+  isWordPressDevVersion as i
+};