wp-studio 1.7.7-alpha1

package/dist/cli/site-utils-CfsabjUn.js

@@ -0,0 +1,243 @@
+import { d as decodePassword } from "./passwords-DyzWd9Xi.js";
+import { S as SiteCommandLoggerAction } from "./logger-actions-OaIvl-ai.js";
+import { __ } from "@wordpress/i18n";
+import { L as LoggerError, A as getSiteUrl, r as readAppdata } from "./appdata-07CF2rhg.js";
+import { o as openBrowser } from "./browser-CgWK-yoe.js";
+import { g as generateSiteCertificate } from "./certificate-manager-DdBumKZp.js";
+import { h as isProxyProcessRunning, i as isServerRunning, j as stopProxyProcess, l as startProxyProcess } from "./wordpress-server-manager-CtiuJqEb.js";
+import fs from "fs";
+import { domainToASCII } from "node:url";
+import { tmpdir, platform } from "os";
+import path from "path";
+import { promisify } from "util";
+import sudo from "@vscode/sudo-prompt";
+const reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+function escapeRegex(string) {
+  return string ? string.replace(reRegExpChar, "\\$&") : string;
+}
+const sudoExec = (command, options) => {
+  return new Promise((resolve, reject) => {
+    sudo.exec(command, options, (error) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve();
+    });
+  });
+};
+const readFile = promisify(fs.readFile);
+const writeFile = promisify(fs.writeFile);
+const HOST_FILES = {
+  win32: path.resolve(process.env.SystemRoot ?? "C:\\Windows", "System32\\drivers\\etc\\hosts"),
+  darwin: "/etc/hosts",
+  linux: "/etc/hosts"
+};
+const getHostsFilePath = () => {
+  const currentPlatform = platform();
+  const hostsPath = HOST_FILES[currentPlatform];
+  if (!hostsPath) {
+    throw new Error(`Unsupported platform: ${currentPlatform}`);
+  }
+  return hostsPath;
+};
+const readHostsFile = async () => {
+  try {
+    const hostsPath = getHostsFilePath();
+    const content = await readFile(hostsPath, "utf8");
+    return content;
+  } catch (error) {
+    console.error("Error reading hosts file:", error);
+    throw error;
+  }
+};
+const writeHostsFile = async (content) => {
+  const hostsPath = getHostsFilePath();
+  try {
+    const tempPath = path.join(tmpdir(), "wp-studio-hosts");
+    await writeFile(tempPath, content);
+    const command = platform() === "win32" ? `type ${tempPath} > ${hostsPath}` : `cat ${tempPath} > ${hostsPath}`;
+    await sudoExec(command, {
+      name: "WordPress Studio"
+    });
+  } catch (error) {
+    console.error("Error writing hosts file:", error);
+    throw error;
+  }
+};
+function createHostsEntryPattern(domain) {
+  const sanitizedDomain = domain.replace(/\\/g, "");
+  const escapedDomain = escapeRegex(sanitizedDomain);
+  return new RegExp(`127\\.0\\.0\\.1\\s+${escapedDomain}(\\s|$)`, "i");
+}
+const addDomainToHosts = async (domain, port) => {
+  try {
+    const hostsContent = await readHostsFile();
+    const encodedDomain = domainToASCII(domain);
+    const newContent = updateStudioBlock(hostsContent, (entries) => {
+      const pattern = createHostsEntryPattern(encodedDomain);
+      if (entries.some((entry) => entry.match(pattern))) {
+        return entries;
+      }
+      return [...entries, `127.0.0.1 ${encodedDomain} # Port ${port}`];
+    });
+    if (newContent !== hostsContent) {
+      await writeHostsFile(newContent);
+    }
+  } catch (error) {
+    console.error(`Error adding domain ${domain} to hosts file:`, error);
+    throw error;
+  }
+};
+const removeDomainFromHosts = async (domain) => {
+  try {
+    const hostsContent = await readHostsFile();
+    const encodedDomain = domainToASCII(domain);
+    const pattern = createHostsEntryPattern(encodedDomain);
+    const newContent = updateStudioBlock(
+      hostsContent,
+      (entries) => entries.filter((entry) => !entry.match(pattern))
+    );
+    if (newContent !== hostsContent) {
+      await writeHostsFile(newContent);
+    }
+  } catch (error) {
+    console.error(`Error removing domain ${domain} from hosts file:`, error);
+    throw error;
+  }
+};
+const updateDomainInHosts = async (oldDomain, newDomain, port) => {
+  if (oldDomain === newDomain) {
+    return;
+  }
+  if (!oldDomain && newDomain) {
+    await addDomainToHosts(newDomain, port);
+    return;
+  }
+  if (oldDomain && !newDomain) {
+    await removeDomainFromHosts(oldDomain);
+    return;
+  }
+  try {
+    const hostsContent = await readHostsFile();
+    const encodedOldDomain = domainToASCII(oldDomain);
+    const encodedNewDomain = domainToASCII(newDomain);
+    const oldPattern = createHostsEntryPattern(encodedOldDomain);
+    const newContent = updateStudioBlock(hostsContent, (entries) => {
+      const filtered = entries.filter((entry) => !entry.match(oldPattern));
+      return [...filtered, `127.0.0.1 ${encodedNewDomain} # Port ${port}`];
+    });
+    if (newContent !== hostsContent) {
+      await writeHostsFile(newContent);
+    }
+  } catch (error) {
+    console.error(
+      `Error replacing domain ${oldDomain} with ${newDomain} in hosts file:`,
+      error
+    );
+    throw error;
+  }
+};
+function updateStudioBlock(content, updateFn) {
+  const STUDIO_BLOCK_PATTERN = /(^|\n)(# BEGIN WordPress Studio)([\s\S]*?)\n(# END WordPress Studio)/;
+  const match = content.match(STUDIO_BLOCK_PATTERN);
+  if (match) {
+    const [_, space, begin, block, end] = match;
+    const before = content.slice(0, match.index);
+    const after = content.slice((match.index ?? 0) + match[0].length);
+    const entries = block.split("\n").filter(Boolean);
+    const newEntries = updateFn(entries);
+    if (!newEntries.length) {
+      return before + after;
+    }
+    const newLines = [begin, ...newEntries, end];
+    return before + space + newLines.join("\n") + after;
+  } else {
+    const newEntries = updateFn([]);
+    if (newEntries.length) {
+      return content + ["\n", "# BEGIN WordPress Studio", ...newEntries, "# END WordPress Studio"].join("\n");
+    }
+  }
+  return content;
+}
+async function startProxyIfNeeded(logger) {
+  const proxyProcess = await isProxyProcessRunning();
+  if (!proxyProcess) {
+    logger.reportStart(SiteCommandLoggerAction.START_PROXY, __("Starting HTTP proxy server…"));
+    await startProxyProcess();
+    logger.reportSuccess(__("HTTP proxy server started"));
+  } else {
+    logger.reportSuccess(__("HTTP proxy already running"));
+  }
+}
+async function openSiteInBrowser(site) {
+  const siteUrl = getSiteUrl(site);
+  try {
+    const autoLoginUrl = `${siteUrl}/studio-auto-login?redirect_to=${encodeURIComponent(
+      `${siteUrl}/wp-admin/`
+    )}`;
+    await openBrowser(autoLoginUrl);
+  } catch (error) {
+  }
+}
+function logSiteDetails(site) {
+  const siteUrl = getSiteUrl(site);
+  console.log(__("Site URL: "), siteUrl);
+  console.log(__("Username: "), site.adminUsername || "admin");
+  if (site.adminPassword) {
+    console.log(__("Password: "), decodePassword(site.adminPassword));
+  }
+}
+async function setupCustomDomain(site, logger, options) {
+  if (!site.customDomain) {
+    return;
+  }
+  await startProxyIfNeeded(logger);
+  if (site.enableHttps && !site.tlsKey && !site.tlsCert) {
+    logger.reportStart(SiteCommandLoggerAction.GENERATE_CERT, __("Generating SSL certificates…"));
+    await generateSiteCertificate(site.customDomain);
+    logger.reportSuccess(__("SSL certificates generated"));
+  }
+  if (!options?.skipHostsUpdate) {
+    logger.reportStart(SiteCommandLoggerAction.ADD_DOMAIN_TO_HOSTS, __("Adding domain to hosts file…"));
+    try {
+      await addDomainToHosts(site.customDomain, site.port);
+      logger.reportSuccess(__("Domain added to hosts file"));
+    } catch (error) {
+      throw new LoggerError(__("Failed to add domain to hosts file"), error);
+    }
+  }
+}
+async function stopProxyIfNoSitesNeedIt(stoppedSiteIds, logger) {
+  const stoppedSiteIdsArray = Array.isArray(stoppedSiteIds) ? stoppedSiteIds : [stoppedSiteIds];
+  const proxyProcess = await isProxyProcessRunning();
+  if (!proxyProcess) {
+    return;
+  }
+  const appdata = await readAppdata();
+  const remainingSitesWithCustomDomains = appdata.sites.filter(
+    (site) => !stoppedSiteIdsArray.includes(site.id) && site.customDomain
+  );
+  const sitesStillRunning = await Promise.all(
+    remainingSitesWithCustomDomains.map((site) => isServerRunning(site.id))
+  );
+  if (sitesStillRunning.some((isRunning) => isRunning)) {
+    return;
+  }
+  logger.reportStart(SiteCommandLoggerAction.STOP_PROXY, __("Stopping HTTP proxy server…"));
+  await stopProxyProcess();
+  logger.reportSuccess(__("HTTP proxy server stopped"));
+}
+const isSiteRunning = async (site) => {
+  const processInfo = await isServerRunning(site.id);
+  return !!(processInfo && processInfo.status === "online" && site.latestCliPid !== void 0 && processInfo.pid === site.latestCliPid);
+};
+export {
+  stopProxyIfNoSitesNeedIt as a,
+  isSiteRunning as i,
+  logSiteDetails as l,
+  openSiteInBrowser as o,
+  removeDomainFromHosts as r,
+  setupCustomDomain as s,
+  updateDomainInHosts as u
+};