wp-studio 1.8.1 → 1.8.2

package/dist/cli/rewrite-wp-cli-post-content-Wfod7ZMk.mjs

@@ -0,0 +1,297 @@
+import fs__default, { promises } from "fs";
+import path__default from "path";
+import ignore from "ignore";
+import { i as isErrnoException } from "./is-errno-exception-t38xF2pB.mjs";
+import { f as getWpFilesPath } from "./passwords-Do9ZGj8i.mjs";
+import { randomUUID } from "crypto";
+const DEPLOY_IGNORE_DEFAULTS = [".git", "node_modules", ".DS_Store", "Thumbs.db"];
+function calculateDirectorySizeForArchive(directoryPath, deployIgnore, pathPrefix) {
+  const ig = deployIgnore ?? ignore().add(DEPLOY_IGNORE_DEFAULTS);
+  return new Promise((resolve, reject) => {
+    let totalSize = 0;
+    async function calculateSize(dirPath) {
+      try {
+        const files = await promises.readdir(dirPath, { withFileTypes: true });
+        await Promise.all(
+          files.map(async (file) => {
+            const filePath = path__default.join(dirPath, file.name);
+            const fileRelativeToRoot = path__default.relative(directoryPath, filePath);
+            const ignorePath = pathPrefix ? path__default.join(pathPrefix, fileRelativeToRoot) : fileRelativeToRoot;
+            try {
+              if (ig.ignores(ignorePath)) {
+                return;
+              }
+              if (file.isDirectory()) {
+                await calculateSize(filePath);
+              } else {
+                const stats = await promises.stat(filePath);
+                totalSize += stats.size;
+              }
+            } catch (error) {
+              console.warn(`Error processing ${filePath}:`, error);
+            }
+          })
+        );
+      } catch (error) {
+        throw new Error(`Failed to read directory ${dirPath}: ${error}`);
+      }
+    }
+    calculateSize(directoryPath).then(() => resolve(totalSize)).catch(reject);
+  });
+}
+function isWordPressDirectory(projectPath) {
+  return fs__default.existsSync(path__default.join(projectPath, "wp-content")) && fs__default.existsSync(path__default.join(projectPath, "wp-includes")) && fs__default.existsSync(path__default.join(projectPath, "wp-load.php"));
+}
+function arePathsEqual(path1, path2) {
+  try {
+    const stats1 = fs__default.statSync(path__default.resolve(path1));
+    const stats2 = fs__default.statSync(path__default.resolve(path2));
+    return stats1.ino === stats2.ino && stats1.dev === stats2.dev;
+  } catch (error) {
+    return path__default.resolve(path1) === path__default.resolve(path2);
+  }
+}
+async function pathExists(path2) {
+  try {
+    await promises.access(path2);
+    return true;
+  } catch (err) {
+    if (isErrnoException(err) && err.code === "ENOENT") {
+      return false;
+    }
+    throw err;
+  }
+}
+async function recursiveCopyDirectory(source, destination) {
+  await promises.mkdir(destination, { recursive: true });
+  const entries = await promises.readdir(source, { withFileTypes: true });
+  await Promise.all(
+    entries.map((entry) => {
+      const sourcePath = path__default.join(source, entry.name);
+      const destinationPath = path__default.join(destination, entry.name);
+      if (entry.isDirectory()) {
+        return recursiveCopyDirectory(sourcePath, destinationPath);
+      }
+      if (entry.isFile()) {
+        return promises.cp(sourcePath, destinationPath, {
+          mode: fs__default.constants.COPYFILE_FICLONE,
+          preserveTimestamps: true
+        });
+      }
+    })
+  );
+}
+async function isEmptyDir(directory) {
+  const stats = await promises.stat(directory);
+  if (!stats.isDirectory()) {
+    return false;
+  }
+  const files = await promises.readdir(directory);
+  return files.length === 0;
+}
+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;
+}
+const IS_JSPI_AVAILABLE = "Suspending" in WebAssembly;
+class SqliteIntegrationProvider {
+  async isSqliteIntegrationAvailable() {
+    const sqliteSourcePath = this.getSqlitePluginSourcePath();
+    const dbCopyPath = path__default.join(sqliteSourcePath, "db.copy");
+    return fs__default.existsSync(sqliteSourcePath) && fs__default.existsSync(dbCopyPath);
+  }
+  // Returns true if site has db.php or no wp-config.php
+  async needsSqliteSetup(sitePath) {
+    const hasDbPhp = fs__default.existsSync(path__default.join(sitePath, "wp-content", "db.php"));
+    const hasWpConfig = fs__default.existsSync(path__default.join(sitePath, "wp-config.php"));
+    return hasDbPhp || !hasWpConfig;
+  }
+  async getSqliteVersionFromInstallation(sqliteMuPluginPath) {
+    try {
+      const versionFileContent = await fs__default.promises.readFile(
+        path__default.join(sqliteMuPluginPath, "load.php"),
+        "utf8"
+      );
+      const matches = versionFileContent.match(/\s\*\sVersion:\s*([0-9a-zA-Z.-]+)/);
+      return matches?.[1] || "";
+    } catch (err) {
+      return "";
+    }
+  }
+  async installSqliteIntegration(sitePath) {
+    if (!await this.isSqliteIntegrationAvailable()) {
+      throw new Error("SQLite integration files not found.");
+    }
+    const wpContentPath = path__default.join(sitePath, "wp-content");
+    const databasePath = path__default.join(wpContentPath, "database");
+    await fs__default.promises.mkdir(databasePath, { recursive: true });
+    const sqliteSourcePath = this.getSqlitePluginSourcePath();
+    const dbCopyContent = await fs__default.promises.readFile(
+      path__default.join(sqliteSourcePath, "db.copy"),
+      "utf8"
+    );
+    const sqliteDirname = this.getSqliteDirname();
+    const updatedContent = dbCopyContent.replace(
+      "'{SQLITE_IMPLEMENTATION_FOLDER_PATH}'",
+      `realpath( __DIR__ . '/mu-plugins/${sqliteDirname}' )`
+    );
+    await fs__default.promises.writeFile(path__default.join(wpContentPath, "db.php"), updatedContent);
+    const sqliteDestPath = path__default.join(wpContentPath, "mu-plugins", sqliteDirname);
+    await fs__default.promises.rm(sqliteDestPath, { recursive: true, force: true });
+    await fs__default.promises.cp(sqliteSourcePath, sqliteDestPath, {
+      recursive: true,
+      verbatimSymlinks: true
+    });
+  }
+  async keepSqliteIntegrationUpdated(sitePath) {
+    if (await this.needsSqliteSetup(sitePath)) {
+      await this.installSqliteIntegration(sitePath);
+      return true;
+    }
+    return false;
+  }
+  async isSqliteInstalled(sitePath) {
+    return fs__default.existsSync(path__default.join(sitePath, "wp-content", "mu-plugins", this.getSqliteDirname())) && fs__default.existsSync(path__default.join(sitePath, "wp-content", "db.php"));
+  }
+}
+const SQLITE_FILENAME = "sqlite-database-integration";
+class CliSqliteProvider extends SqliteIntegrationProvider {
+  getSqliteDirname() {
+    return SQLITE_FILENAME;
+  }
+  getSqlitePluginSourcePath() {
+    return path__default.join(getWpFilesPath(), SQLITE_FILENAME);
+  }
+}
+const provider = new CliSqliteProvider();
+async function installSqliteIntegration(sitePath) {
+  return provider.installSqliteIntegration(sitePath);
+}
+async function keepSqliteIntegrationUpdated(sitePath) {
+  return provider.keepSqliteIntegrationUpdated(sitePath);
+}
+async function isSqliteIntegrationInstalled(sitePath) {
+  return provider.isSqliteInstalled(sitePath);
+}
+const UNSUPPORTED_WP_CLI_POST_CONTENT_MESSAGE = "Unsupported `--post_content` value: `wp_cli` does not run in a shell. Do not use `$(cat file)` or backticks. Pass the literal post content directly and Studio will rewrite large content to a virtual temp file automatically.";
+function generatePostContentTempFilePath() {
+  return `/tmp/wp-cli-post-content-${randomUUID()}.html`;
+}
+function getPostContentArg(args) {
+  const contentArg = args.find((arg) => arg.startsWith("--post_content="));
+  if (!contentArg) {
+    return void 0;
+  }
+  return contentArg.slice("--post_content=".length);
+}
+function getUnsupportedWpCliPostContentMessage(args) {
+  const isPostCommand = args[0] === "post" && (args[1] === "create" || args[1] === "update");
+  if (!isPostCommand) {
+    return null;
+  }
+  const postContent = getPostContentArg(args);
+  if (postContent === void 0) {
+    return null;
+  }
+  const trimmedContent = postContent.trim();
+  const hasCatCommandSubstitution = /^[`'"]?\$\(\s*cat\b[\s\S]*$/.test(trimmedContent) || /^[`'"]?`cat\b[\s\S]*$/.test(trimmedContent);
+  return hasCatCommandSubstitution ? UNSUPPORTED_WP_CLI_POST_CONTENT_MESSAGE : null;
+}
+function rewriteWpCliPostContentArgs(args) {
+  const isPostCommand = args[0] === "post" && (args[1] === "create" || args[1] === "update");
+  if (!isPostCommand) {
+    return null;
+  }
+  const contentArgIndex = args.findIndex((arg) => arg.startsWith("--post_content="));
+  if (contentArgIndex === -1) {
+    return null;
+  }
+  const content = args[contentArgIndex].slice("--post_content=".length);
+  const tempFilePath = generatePostContentTempFilePath();
+  const rewrittenArgs = args.filter((_, i) => i !== contentArgIndex);
+  if (args[1] === "create") {
+    rewrittenArgs.splice(2, 0, tempFilePath);
+  } else {
+    let insertIndex = 2;
+    for (let i = 2; i < rewrittenArgs.length; i++) {
+      if (!rewrittenArgs[i].startsWith("--")) {
+        insertIndex = i + 1;
+        break;
+      }
+    }
+    rewrittenArgs.splice(insertIndex, 0, tempFilePath);
+  }
+  return { args: rewrittenArgs, content, tempFilePath };
+}
+async function rewriteWpCliPostContentToFile(args, writeFile) {
+  const unsupportedMessage = getUnsupportedWpCliPostContentMessage(args);
+  if (unsupportedMessage) {
+    throw new Error(unsupportedMessage);
+  }
+  const result = rewriteWpCliPostContentArgs(args);
+  if (!result) {
+    return args;
+  }
+  await writeFile(result.tempFilePath, result.content);
+  return result.args;
+}
+export {
+  DEPLOY_IGNORE_DEFAULTS as D,
+  IS_JSPI_AVAILABLE as I,
+  arePathsEqual as a,
+  isWordPressBetaVersion as b,
+  calculateDirectorySizeForArchive as c,
+  isWordPressDevVersion as d,
+  isEmptyDir as e,
+  isValidWordPressVersion as f,
+  getWordPressVersionUrl as g,
+  isWordPressVersionAtLeast as h,
+  isWordPressDirectory as i,
+  getUnsupportedWpCliPostContentMessage as j,
+  keepSqliteIntegrationUpdated as k,
+  installSqliteIntegration as l,
+  isSqliteIntegrationInstalled as m,
+  rewriteWpCliPostContentToFile as n,
+  pathExists as p,
+  recursiveCopyDirectory as r
+};

package/dist/cli/{set-CJjcoYpy.mjs → set-DMP-dHXP.mjs}

@@ -45,10 +45,10 @@ var __callDispose = (stack, error, hasError) => {
 };
 import { SupportedPHPVersions } from "@php-wasm/universal";
 import { M as MINIMUM_WORDPRESS_VERSION, k as DEFAULT_WORDPRESS_VERSION } from "./well-known-paths-kP8oHPED.mjs";
-import { L as LoggerError, c as Logger, r as readCliConfig, l as lockCliConfig, s as saveCliConfig, u as unlockCliConfig, n as generateSiteCertificate, S as SITE_EVENTS } from "./certificate-manager-FOFTUHXy.mjs";
-import { V as ValidationError, y as SiteCommandLoggerAction, z as getSiteByFolder, B as getDomainNameValidationError, C as updateDomainInHosts, D as connectToDaemon, E as isServerRunning, F as stopWordPressServer, G as runWpCliCommand, H as setupCustomDomain, I as startWordPressServer, J as updateSiteLatestCliPid, t as emitCliEvent, K as disconnectFromDaemon } from "./index-DSF11Tac.mjs";
-import { j as isValidWordPressVersion, l as isWordPressVersionAtLeast, a as arePathsEqual, g as getWordPressVersionUrl } from "./rewrite-wp-cli-post-content-BAJ-W0ra.mjs";
-import { v as validateAdminUsername, i as validateAdminEmail, j as encodePassword } from "./passwords-CHfZ7oMW.mjs";
+import { L as LoggerError, c as Logger, r as readCliConfig, l as lockCliConfig, s as saveCliConfig, u as unlockCliConfig, n as generateSiteCertificate, S as SITE_EVENTS } from "./certificate-manager-CNr2j_S-.mjs";
+import { V as ValidationError, z as SiteCommandLoggerAction, B as getSiteByFolder, C as getDomainNameValidationError, D as updateDomainInHosts, E as connectToDaemon, F as isServerRunning, G as stopWordPressServer, H as runWpCliCommand, I as setupCustomDomain, J as startWordPressServer, K as updateSiteLatestCliPid, v as emitCliEvent, L as disconnectFromDaemon } from "./index-ByKye4Bc.mjs";
+import { f as isValidWordPressVersion, h as isWordPressVersionAtLeast, a as arePathsEqual, g as getWordPressVersionUrl } from "./rewrite-wp-cli-post-content-Wfod7ZMk.mjs";
+import { v as validateAdminUsername, m as validateAdminEmail, n as encodePassword } from "./passwords-Do9ZGj8i.mjs";
 import { __, sprintf } from "@wordpress/i18n";
 function siteNeedsRestart(changes) {
   const {

package/dist/cli/{set-DjPvi0eA.mjs → set-_Kt_Gwjr.mjs}

@@ -1,5 +1,5 @@
-import { L as LoggerError, c as Logger, f as SNAPSHOT_EVENTS } from "./certificate-manager-FOFTUHXy.mjs";
-import { w as normalizeHostname, P as PreviewCommandLoggerAction, x as setSnapshotInConfig, t as emitCliEvent } from "./index-DSF11Tac.mjs";
+import { L as LoggerError, c as Logger, f as SNAPSHOT_EVENTS } from "./certificate-manager-CNr2j_S-.mjs";
+import { x as normalizeHostname, P as PreviewCommandLoggerAction, y as setSnapshotInConfig, v as emitCliEvent } from "./index-ByKye4Bc.mjs";
 import { __ } from "@wordpress/i18n";
 async function runCommand(host, options) {
   const { name } = options;

package/dist/cli/{status-YTRS43jf.mjs → status-DcvWFeQZ.mjs}

@@ -1,6 +1,6 @@
-import { A as AuthCommandLoggerAction, r as readAuthToken, g as getUserInfo } from "./index-DSF11Tac.mjs";
+import { A as AuthCommandLoggerAction, r as readAuthToken, g as getUserInfo } from "./index-ByKye4Bc.mjs";
 import { __, sprintf } from "@wordpress/i18n";
-import { c as Logger, L as LoggerError } from "./certificate-manager-FOFTUHXy.mjs";
+import { c as Logger, L as LoggerError } from "./certificate-manager-CNr2j_S-.mjs";
 async function runCommand(format = "text") {
   const logger = new Logger();
   if (format !== "json") {

package/dist/cli/{wordpress-server-ipc-LCHRL4uO.mjs → wordpress-server-ipc-PoQqdZGl.mjs}

@@ -86,7 +86,10 @@ const childMessageActivity = z.object({
 const childMessageResult = z.object({
   originalMessageId: z.string(),
   topic: z.literal("result"),
-  result: z.unknown()
+  // `result` is `optional` so handlers that return `void` (e.g. `start-server`) survive
+  // IPC serialization — Node's default JSON IPC drops `undefined` values, leaving the key
+  // absent on the receiving side. Zod 4's `z.unknown()` rejects an absent key.
+  result: z.unknown().optional()
 });
 const childMessageError = z.object({
   originalMessageId: z.string(),

package/dist/cli/{wp-BYFV-TCc.mjs → wp-BGWXruY0.mjs}

@@ -44,12 +44,12 @@ var __callDispose = (stack, error, hasError) => {
   return next();
 };
 import { spawn } from "node:child_process";
+import { w as writeStudioMuPluginsForNativePhpRuntime, e as getPhpBinaryPath, b as getWpCliPharPath } from "./passwords-Do9ZGj8i.mjs";
 import { v as validateNativePhpVersion } from "./php-binary-metadata-B51UcEYo.mjs";
 import { __ } from "@wordpress/i18n";
 import yargsParser from "yargs-parser";
-import { L as runGlobalWpCliCommand, z as getSiteByFolder, M as validatePhpVersion, K as disconnectFromDaemon, D as connectToDaemon, E as isServerRunning, N as sendWpCliCommand, G as runWpCliCommand } from "./index-DSF11Tac.mjs";
-import { c as getPhpBinaryPath, a as getWpCliPharPath } from "./passwords-CHfZ7oMW.mjs";
-import { L as LoggerError, c as Logger } from "./certificate-manager-FOFTUHXy.mjs";
+import { M as runGlobalWpCliCommand, B as getSiteByFolder, N as validatePhpVersion, L as disconnectFromDaemon, E as connectToDaemon, F as isServerRunning, O as sendWpCliCommand, H as runWpCliCommand } from "./index-ByKye4Bc.mjs";
+import { L as LoggerError, c as Logger } from "./certificate-manager-CNr2j_S-.mjs";
 const logger = new Logger();
 async function pipePHPResponse(response) {
   const decoder = new TextDecoder();
@@ -70,6 +70,7 @@ async function pipePHPResponse(response) {
 }
 async function runNativePhpWpCliCommand(site, args) {
   const phpVersion = validateNativePhpVersion(site.phpVersion);
+  await writeStudioMuPluginsForNativePhpRuntime(site.path, site.isWpAutoUpdating);
   const child = spawn(
     getPhpBinaryPath(phpVersion),
     [getWpCliPharPath(), `--path=${site.path}`, ...args],