wp-studio 1.7.7-alpha1

package/dist/cli/run-wp-cli-command-BctnMDWG.js

@@ -0,0 +1,88 @@
+import { rootCertificates } from "node:tls";
+import { loadNodeRuntime, createNodeFsMountHandler } from "@php-wasm/node";
+import { ProcessIdAllocator, PHP, setPhpIniEntries } from "@php-wasm/universal";
+import { createSpawnHandler } from "@php-wasm/util";
+import { c as cleanupLegacyMuPlugins, g as getMuPlugins } from "./mu-plugins-GEfKsl5U.js";
+import { P as LatestSupportedPHPVersion } from "./appdata-07CF2rhg.js";
+import { __ } from "@wordpress/i18n";
+import { setupPlatformLevelMuPlugins } from "@wp-playground/wordpress";
+import { g as getWpCliPharPath, a as getSqliteCommandPath } from "./server-files-C_oy-mnI.js";
+const processIdAllocator = new ProcessIdAllocator();
+const PLAYGROUND_INTERNAL_SHARED_FOLDER = "/internal/shared";
+function createNoopSpawnHandler() {
+  return createSpawnHandler(async (args, processApi) => {
+    await new Promise((resolve) => setTimeout(resolve, 1));
+    processApi.exit(1);
+  });
+}
+async function runWpCliCommand(siteFolder, phpVersion, args) {
+  const id = await loadNodeRuntime(phpVersion, {
+    followSymlinks: true,
+    withRedis: true,
+    withMemcached: true,
+    emscriptenOptions: {
+      processId: processIdAllocator.claim()
+    }
+  });
+  const php = new PHP(id);
+  try {
+    await php.setSapiName("cli");
+    php.mkdir("/wordpress");
+    await php.mount("/wordpress", createNodeFsMountHandler(siteFolder));
+    php.writeFile("/tmp/ca-bundle.crt", rootCertificates.join("\n"));
+    await setPhpIniEntries(php, {
+      "openssl.cafile": "/tmp/ca-bundle.crt",
+      allow_url_fopen: 1
+    });
+    await php.setSpawnHandler(createNoopSpawnHandler());
+    await cleanupLegacyMuPlugins(siteFolder);
+    const [studioMuPluginsHostPath, loaderMuPluginHostPath] = await getMuPlugins({
+      isWpAutoUpdating: false
+    });
+    await php.mount(
+      "/internal/studio/mu-plugins",
+      createNodeFsMountHandler(studioMuPluginsHostPath)
+    );
+    await php.mount(
+      PLAYGROUND_INTERNAL_SHARED_FOLDER + "/mu-plugins/99-studio-loader.php",
+      createNodeFsMountHandler(loaderMuPluginHostPath)
+    );
+    await php.mount("/tmp/wp-cli.phar", createNodeFsMountHandler(getWpCliPharPath()));
+    await php.mount("/tmp/sqlite-command", createNodeFsMountHandler(getSqliteCommandPath()));
+    await setupPlatformLevelMuPlugins(php);
+    return [
+      await php.cli(["php", "/tmp/wp-cli.phar", "--path=/wordpress", ...args]),
+      () => php.exit()
+    ];
+  } catch (error) {
+    throw new Error(__("An error occurred while running the WP-CLI command."));
+  }
+}
+async function runGlobalWpCliCommand(args) {
+  const id = await loadNodeRuntime(LatestSupportedPHPVersion, {
+    followSymlinks: true,
+    withRedis: true,
+    withMemcached: true,
+    emscriptenOptions: {
+      processId: processIdAllocator.claim()
+    }
+  });
+  const php = new PHP(id);
+  try {
+    await php.setSapiName("cli");
+    php.writeFile("/tmp/ca-bundle.crt", rootCertificates.join("\n"));
+    await setPhpIniEntries(php, {
+      "openssl.cafile": "/tmp/ca-bundle.crt",
+      allow_url_fopen: 1
+    });
+    await php.setSpawnHandler(createNoopSpawnHandler());
+    await php.mount("/tmp/wp-cli.phar", createNodeFsMountHandler(getWpCliPharPath()));
+    return [await php.cli(["php", "/tmp/wp-cli.phar", ...args]), () => php.exit()];
+  } catch (error) {
+    throw new Error(__("An error occurred while running the WP-CLI command."));
+  }
+}
+export {
+  runGlobalWpCliCommand as a,
+  runWpCliCommand as r
+};

package/dist/cli/sequential-BQFuixXz.js

@@ -0,0 +1,46 @@
+function sequential(fn, options) {
+  const concurrentCount = options?.concurrent ?? 1;
+  const maxQueueSize = options?.max;
+  const deduplicateKey = options?.deduplicateKey;
+  const locks = /* @__PURE__ */ new Set();
+  const inFlightByKey = /* @__PURE__ */ new Map();
+  let queueCount = 0;
+  return async (...args) => {
+    const key = deduplicateKey?.(...args);
+    if (key) {
+      const existing = inFlightByKey.get(key);
+      if (existing) {
+        return existing;
+      }
+    }
+    const execute = async () => {
+      if (maxQueueSize !== void 0 && queueCount >= maxQueueSize) {
+        throw new Error(
+          `Queue is full (${maxQueueSize} pending commands). Please try again later.`
+        );
+      }
+      while (locks.size >= concurrentCount) {
+        queueCount++;
+        await Promise.allSettled([...locks]);
+        queueCount--;
+      }
+      const fnPromise = fn(...args);
+      try {
+        locks.add(fnPromise);
+        return await fnPromise;
+      } finally {
+        locks.delete(fnPromise);
+      }
+    };
+    const resultPromise = execute();
+    if (key) {
+      inFlightByKey.set(key, resultPromise);
+      const cleanup = () => inFlightByKey.delete(key);
+      resultPromise.then(cleanup, cleanup);
+    }
+    return resultPromise;
+  };
+}
+export {
+  sequential as s
+};

package/dist/cli/server-files-C_oy-mnI.js

@@ -0,0 +1,26 @@
+import path from "path";
+import { Q as getAppdataDirectory } from "./appdata-07CF2rhg.js";
+const WP_CLI_PHAR_FILENAME = "wp-cli.phar";
+const SQLITE_COMMAND_FOLDER = "sqlite-command";
+function getServerFilesPath() {
+  return path.join(getAppdataDirectory(), "server-files");
+}
+function getWpCliPharPath() {
+  return path.join(getServerFilesPath(), WP_CLI_PHAR_FILENAME);
+}
+function getSqliteCommandPath() {
+  return path.join(getServerFilesPath(), SQLITE_COMMAND_FOLDER);
+}
+function getLanguagePacksPath() {
+  return path.join(getServerFilesPath(), "language-packs");
+}
+function getAiInstructionsPath() {
+  return path.join(getServerFilesPath(), "skills");
+}
+export {
+  getSqliteCommandPath as a,
+  getLanguagePacksPath as b,
+  getServerFilesPath as c,
+  getAiInstructionsPath as d,
+  getWpCliPharPath as g
+};

package/dist/cli/set-DknhAZpw.js

@@ -0,0 +1,327 @@
+import { SupportedPHPVersions } from "@php-wasm/universal";
+import { L as LoggerError, a as Logger, M as MINIMUM_WORDPRESS_VERSION, k as getSiteByFolder, r as readAppdata, l as lockAppdata, G as arePathsEqual, s as saveAppdata, u as unlockAppdata, F as DEFAULT_WORDPRESS_VERSION, H as updateSiteLatestCliPid, S as SITE_EVENTS } from "./appdata-07CF2rhg.js";
+import { V as ValidationError, g as getDomainNameValidationError } from "./validation-error-DqLxqQuA.js";
+import { v as validateAdminUsername, a as validateAdminEmail, e as encodePassword } from "./passwords-DyzWd9Xi.js";
+import { b as isValidWordPressVersion, c as isWordPressVersionAtLeast, g as getWordPressVersionUrl } from "./wordpress-version-utils-B6UVeTh_.js";
+import { S as SiteCommandLoggerAction } from "./logger-actions-OaIvl-ai.js";
+import { __, sprintf } from "@wordpress/i18n";
+import { c as connectToDaemon, i as isServerRunning, a as stopWordPressServer, s as startWordPressServer, e as emitSiteEvent, d as disconnectFromDaemon } from "./wordpress-server-manager-CtiuJqEb.js";
+import { u as updateDomainInHosts, s as setupCustomDomain } from "./site-utils-CfsabjUn.js";
+import { r as runWpCliCommand } from "./run-wp-cli-command-BctnMDWG.js";
+import { v as validatePhpVersion } from "./index-7pbG_s_U.js";
+function siteNeedsRestart(changes) {
+  const {
+    domainChanged,
+    httpsChanged,
+    phpChanged,
+    wpChanged,
+    xdebugChanged,
+    credentialsChanged,
+    debugLogChanged,
+    debugDisplayChanged
+  } = changes;
+  return !!(domainChanged || httpsChanged || phpChanged || wpChanged || xdebugChanged || credentialsChanged || debugLogChanged || debugDisplayChanged);
+}
+const ALLOWED_PHP_VERSIONS = [...SupportedPHPVersions];
+const logger = new Logger();
+async function runCommand(sitePath, options) {
+  const {
+    name,
+    domain,
+    https,
+    php,
+    wp,
+    xdebug,
+    adminUsername,
+    adminPassword,
+    debugLog,
+    debugDisplay
+  } = options;
+  let { adminEmail } = options;
+  if (name === void 0 && domain === void 0 && https === void 0 && php === void 0 && wp === void 0 && xdebug === void 0 && adminUsername === void 0 && adminPassword === void 0 && adminEmail === void 0 && debugLog === void 0 && debugDisplay === void 0) {
+    throw new LoggerError(
+      __(
+        "At least one option (--name, --domain, --https, --php, --wp, --xdebug, --admin-username, --admin-password, --admin-email, --debug-log, --debug-display) is required."
+      )
+    );
+  }
+  if (name !== void 0 && !name.trim()) {
+    throw new LoggerError(__("Site name cannot be empty."));
+  }
+  if (adminUsername !== void 0) {
+    const usernameError = validateAdminUsername(adminUsername);
+    if (usernameError) {
+      throw new LoggerError(usernameError);
+    }
+  }
+  if (adminPassword !== void 0 && !adminPassword.trim()) {
+    throw new LoggerError(__("Admin password cannot be empty."));
+  }
+  if (adminEmail !== void 0) {
+    if (!adminEmail.trim()) {
+      adminEmail = void 0;
+    } else {
+      const emailError = validateAdminEmail(adminEmail);
+      if (emailError) {
+        throw new LoggerError(emailError);
+      }
+    }
+  }
+  try {
+    logger.reportStart(SiteCommandLoggerAction.LOAD_SITES, __("Loading site…"));
+    let site = await getSiteByFolder(sitePath);
+    logger.reportSuccess(__("Site loaded"));
+    const initialAppdata = await readAppdata();
+    if (domain) {
+      const existingDomainNames = initialAppdata.sites.filter((s) => s.id !== site.id).map((s) => s.customDomain).filter((d) => Boolean(d));
+      const domainError = getDomainNameValidationError(true, domain, existingDomainNames);
+      if (domainError) {
+        throw new LoggerError(domainError);
+      }
+    }
+    if (https === true) {
+      const effectiveDomain = domain ?? site.customDomain;
+      if (!effectiveDomain) {
+        throw new LoggerError(__("HTTPS requires a custom domain. Use --domain to set one."));
+      }
+    }
+    if (xdebug === true) {
+      const otherXdebugSite = initialAppdata.sites.find(
+        (s) => s.enableXdebug && s.id !== site.id
+      );
+      if (otherXdebugSite) {
+        throw new LoggerError(
+          sprintf(
+            /* translators: %s: site name */
+            __('Only one site can have Xdebug enabled at a time. Disable Xdebug on "%s" first.'),
+            otherXdebugSite.name
+          )
+        );
+      }
+    }
+    const nameChanged = name !== void 0 && name !== site.name;
+    const domainChanged = domain !== void 0 && domain !== site.customDomain;
+    const httpsChanged = https !== void 0 && https !== site.enableHttps;
+    const phpChanged = php !== void 0 && php !== site.phpVersion;
+    const wpChanged = wp !== void 0;
+    const xdebugChanged = xdebug !== void 0 && xdebug !== site.enableXdebug;
+    const adminUsernameChanged = adminUsername !== void 0 && adminUsername !== (site.adminUsername ?? "admin");
+    const adminPasswordChanged = adminPassword !== void 0;
+    const adminEmailChanged = adminEmail !== void 0 && adminEmail !== (site.adminEmail ?? "");
+    const credentialsChanged = adminUsernameChanged || adminPasswordChanged || adminEmailChanged;
+    const debugLogChanged = debugLog !== void 0 && debugLog !== site.enableDebugLog;
+    const debugDisplayChanged = debugDisplay !== void 0 && debugDisplay !== site.enableDebugDisplay;
+    const hasChanges = nameChanged || domainChanged || httpsChanged || phpChanged || wpChanged || xdebugChanged || credentialsChanged || debugLogChanged || debugDisplayChanged;
+    if (!hasChanges) {
+      throw new LoggerError(
+        __("No changes to apply. The site already has the specified settings.")
+      );
+    }
+    const needsRestart = siteNeedsRestart({
+      domainChanged,
+      httpsChanged,
+      phpChanged,
+      wpChanged,
+      xdebugChanged,
+      credentialsChanged,
+      debugLogChanged,
+      debugDisplayChanged
+    });
+    const oldDomain = site.customDomain;
+    try {
+      await lockAppdata();
+      const appdata = await readAppdata();
+      const foundSite = appdata.sites.find((s) => arePathsEqual(s.path, sitePath));
+      if (!foundSite) {
+        throw new LoggerError(__("The specified directory is not added to Studio."));
+      }
+      if (nameChanged) {
+        foundSite.name = name;
+      }
+      if (domainChanged) {
+        foundSite.customDomain = domain || void 0;
+      }
+      if (httpsChanged) {
+        foundSite.enableHttps = https;
+      }
+      if (phpChanged) {
+        foundSite.phpVersion = php;
+      }
+      if (xdebugChanged) {
+        foundSite.enableXdebug = xdebug;
+      }
+      if (adminUsernameChanged) {
+        foundSite.adminUsername = adminUsername;
+      }
+      if (adminPasswordChanged) {
+        foundSite.adminPassword = encodePassword(adminPassword);
+      }
+      if (adminEmailChanged) {
+        foundSite.adminEmail = adminEmail;
+      }
+      if (debugLogChanged) {
+        foundSite.enableDebugLog = debugLog;
+      }
+      if (debugDisplayChanged) {
+        foundSite.enableDebugDisplay = debugDisplay;
+      }
+      await saveAppdata(appdata);
+      site = foundSite;
+    } finally {
+      await unlockAppdata();
+    }
+    if (domainChanged) {
+      logger.reportStart(SiteCommandLoggerAction.ADD_DOMAIN_TO_HOSTS, __("Updating hosts file…"));
+      await updateDomainInHosts(oldDomain, domain, site.port);
+      logger.reportSuccess(__("Hosts file updated"));
+    }
+    logger.reportStart(SiteCommandLoggerAction.START_DAEMON, __("Starting process daemon…"));
+    await connectToDaemon();
+    logger.reportSuccess(__("Process daemon started"));
+    const wasRunning = await isServerRunning(site.id);
+    if (needsRestart && wasRunning) {
+      logger.reportStart(SiteCommandLoggerAction.STOP_SITE, __("Stopping WordPress server…"));
+      await stopWordPressServer(site.id);
+      logger.reportSuccess(__("WordPress server stopped"));
+    }
+    if (wpChanged) {
+      logger.reportStart(SiteCommandLoggerAction.SET_WP_VERSION, __("Updating WordPress version…"));
+      const phpVersion = validatePhpVersion(site.phpVersion);
+      const zipUrl = getWordPressVersionUrl(wp);
+      const [response, exitPhp] = await runWpCliCommand(sitePath, phpVersion, [
+        "core",
+        "update",
+        zipUrl,
+        "--force",
+        "--skip-plugins",
+        "--skip-themes"
+      ]);
+      const exitCode = await response.exitCode;
+      if (exitCode !== 0) {
+        exitPhp();
+        throw new LoggerError(sprintf(__("Failed to update WordPress version to %s"), wp));
+      }
+      logger.reportSuccess(__("WordPress version updated"));
+      try {
+        await lockAppdata();
+        const appdata = await readAppdata();
+        const updatedSite = appdata.sites.find((s) => s.id === site.id);
+        if (updatedSite) {
+          updatedSite.isWpAutoUpdating = wp === DEFAULT_WORDPRESS_VERSION;
+          await saveAppdata(appdata);
+          site = updatedSite;
+        }
+      } finally {
+        await unlockAppdata();
+      }
+      exitPhp();
+    }
+    if (needsRestart && wasRunning) {
+      if (site.customDomain) {
+        await setupCustomDomain(site, logger, { skipHostsUpdate: true });
+      }
+      logger.reportStart(SiteCommandLoggerAction.START_SITE, __("Starting WordPress server…"));
+      const processDesc = await startWordPressServer(site, logger);
+      if (processDesc.status === "online") {
+        await updateSiteLatestCliPid(site.id, processDesc.pid);
+      }
+      logger.reportSuccess(__("WordPress server started"));
+    }
+    logger.reportSuccess(__("Site configuration updated"));
+    await emitSiteEvent(SITE_EVENTS.UPDATED, { siteId: site.id });
+    return;
+  } finally {
+    await disconnectFromDaemon();
+  }
+}
+const registerCommand = (yargs) => {
+  return yargs.command({
+    command: "set",
+    describe: __("Configure site settings"),
+    builder: (yargs2) => {
+      return yargs2.option("name", {
+        type: "string",
+        description: __("Site name")
+      }).option("domain", {
+        type: "string",
+        description: __("Custom domain (must end with .local)")
+      }).option("https", {
+        type: "boolean",
+        description: __("Enable HTTPS (requires custom domain)")
+      }).option("php", {
+        type: "string",
+        description: __("PHP version"),
+        choices: ALLOWED_PHP_VERSIONS
+      }).option("wp", {
+        type: "string",
+        description: __("WordPress version"),
+        coerce: (value) => {
+          if (!isValidWordPressVersion(value)) {
+            throw new ValidationError(
+              "wp",
+              value,
+              __(
+                'Must be: "latest", "nightly", or a valid version number (e.g., "6.4", "6.4.1", "6.4-beta1")'
+              )
+            );
+          }
+          if (!isWordPressVersionAtLeast(value, MINIMUM_WORDPRESS_VERSION)) {
+            throw new ValidationError(
+              "wp",
+              value,
+              sprintf(__("Must be: at least %s"), MINIMUM_WORDPRESS_VERSION)
+            );
+          }
+          return value;
+        }
+      }).option("xdebug", {
+        type: "boolean",
+        description: __("Enable Xdebug")
+      }).option("admin-username", {
+        type: "string",
+        description: __("Admin username")
+      }).option("admin-password", {
+        type: "string",
+        description: __("Admin password")
+      }).option("admin-email", {
+        type: "string",
+        description: __("Admin email")
+      }).option("debug-log", {
+        type: "boolean",
+        description: __("Enable WP_DEBUG_LOG")
+      }).option("debug-display", {
+        type: "boolean",
+        description: __("Enable WP_DEBUG_DISPLAY")
+      });
+    },
+    handler: async (argv) => {
+      try {
+        await runCommand(argv.path, {
+          name: argv.name,
+          domain: argv.domain,
+          https: argv.https,
+          php: argv.php,
+          wp: argv.wp,
+          xdebug: argv.xdebug,
+          adminUsername: argv.adminUsername,
+          adminPassword: argv.adminPassword,
+          adminEmail: argv.adminEmail,
+          debugLog: argv.debugLog,
+          debugDisplay: argv.debugDisplay
+        });
+      } catch (error) {
+        if (error instanceof LoggerError) {
+          logger.reportError(error);
+        } else {
+          const loggerError = new LoggerError(__("Failed to configure site"), error);
+          logger.reportError(loggerError);
+        }
+        process.exit(1);
+      }
+    }
+  });
+};
+export {
+  registerCommand,
+  runCommand
+};