@wp-operations/wp-app 0.1.0

package/dist/main.js

@@ -0,0 +1,1096 @@
+// src/run-cli.ts
+import fs11 from "fs-extra";
+import path14 from "path";
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import { spawn, execSync } from "child_process";
+
+// src/start-server.ts
+import fs10 from "fs";
+import express from "express";
+import fileUpload from "express-fileupload";
+
+// src/port-finder.ts
+import http from "http";
+
+// src/constants.ts
+var WP_NOW_HIDDEN_FOLDER = ".wp-app";
+var SQLITE_FILENAME = "sqlite-database-integration";
+var SQLITE_URL = "https://github.com/WordPress/sqlite-database-integration/archive/refs/heads/main.zip";
+var CLASSICPRESS_LATEST_URL = "https://www.classicpress.net/latest.zip";
+var DEFAULT_PORT = 8881;
+var DEFAULT_PHP_VERSION = "8.0";
+var DEFAULT_WORDPRESS_VERSION = "latest";
+
+// src/port-finder.ts
+var PortFinder = class _PortFinder {
+  static #instance;
+  #searchPort = DEFAULT_PORT;
+  #openPort = null;
+  constructor() {
+  }
+  static getInstance() {
+    if (!_PortFinder.#instance) {
+      _PortFinder.#instance = new _PortFinder();
+    }
+    return _PortFinder.#instance;
+  }
+  #incrementPort() {
+    return this.#searchPort++;
+  }
+  #isPortFree() {
+    return new Promise((resolve) => {
+      const server = http.createServer();
+      server.listen(this.#searchPort, () => {
+        server.close();
+        resolve(true);
+      }).on("error", () => {
+        resolve(false);
+      });
+    });
+  }
+  /**
+   * Returns the first available open port, caching and reusing it for subsequent calls.
+   *
+   * @returns {Promise<number>} A promise that resolves to the open port number.
+   */
+  async getOpenPort() {
+    if (this.#openPort) {
+      return this.#openPort;
+    }
+    while (!await this.#isPortFree()) {
+      this.#incrementPort();
+    }
+    this.#openPort = this.#searchPort;
+    return this.#openPort;
+  }
+  setPort(port) {
+    this.#openPort = port;
+  }
+};
+var portFinder = PortFinder.getInstance();
+
+// src/wp-now.ts
+import fs9 from "fs-extra";
+import { NodePHP } from "@php-wasm/node";
+import path13 from "path";
+
+// src/download.ts
+import fs8 from "fs-extra";
+import path11 from "path";
+import followRedirects from "follow-redirects";
+import unzipper from "unzipper";
+import os3 from "os";
+
+// src/wp-playground-wordpress/has-index-file.ts
+import fs from "fs-extra";
+import path from "path";
+function hasIndexFile(projectPath) {
+  return fs.existsSync(path.join(projectPath, "index.php"));
+}
+
+// src/wp-playground-wordpress/is-valid-wordpress-version.ts
+function isValidWordPressVersion(version) {
+  const versionPattern = /^latest$|^(?:(\d+)\.(\d+)(?:\.(\d+))?)((?:-beta(?:\d+)?)|(?:-RC(?:\d+)?))?$/;
+  const classicPressPattern = /^classicpress(?:-(\d+)\.(\d+)(?:\.(\d+))?)?$/;
+  return versionPattern.test(version) || classicPressPattern.test(version);
+}
+function isClassicPressVersion(version) {
+  return version === "classicpress" || version.startsWith("classicpress-");
+}
+
+// src/wp-playground-wordpress/get-plugin-file.ts
+import fs3 from "fs-extra";
+import path2, { basename } from "path";
+
+// src/wp-playground-wordpress/read-file-head.ts
+import fs2 from "fs-extra";
+function readFileHead(filePath, length = 8192) {
+  const buffer = Buffer.alloc(length);
+  const fd = fs2.openSync(filePath, "r");
+  fs2.readSync(fd, buffer, 0, buffer.length, 0);
+  const fileContentBuffer = buffer.toString("utf8");
+  fs2.closeSync(fd);
+  return fileContentBuffer.toString();
+}
+
+// src/wp-playground-wordpress/get-plugin-file.ts
+function heuristicSort(files, projectPath) {
+  const heuristicsBestGuess = `${basename(projectPath)}.php`;
+  const heuristicsBestGuessIndex = files.indexOf(heuristicsBestGuess);
+  if (heuristicsBestGuessIndex !== -1) {
+    files.splice(heuristicsBestGuessIndex, 1);
+    files.unshift(heuristicsBestGuess);
+  }
+  return files;
+}
+function getPluginFile(projectPath) {
+  const files = heuristicSort(fs3.readdirSync(projectPath), projectPath);
+  for (const file of files) {
+    if (file.endsWith(".php")) {
+      const fileContent = readFileHead(path2.join(projectPath, file));
+      const pluginNameRegex = /^(?:[ \t]*<\?php)?[ \t/*#@]*Plugin Name:(.*)$/im;
+      if (pluginNameRegex.test(fileContent)) {
+        return path2.join(path2.basename(projectPath), file);
+      }
+    }
+  }
+  return null;
+}
+
+// src/wp-playground-wordpress/is-plugin-directory.ts
+function isPluginDirectory(projectPath) {
+  const pluginFile = getPluginFile(projectPath);
+  return pluginFile !== null;
+}
+
+// src/wp-playground-wordpress/is-theme-directory.ts
+import fs4 from "fs-extra";
+import path3 from "path";
+function isThemeDirectory(projectPath) {
+  const styleCSSExists = fs4.existsSync(path3.join(projectPath, "style.css"));
+  if (!styleCSSExists) {
+    return false;
+  }
+  const styleCSS = readFileHead(path3.join(projectPath, "style.css"));
+  const themeNameRegex = /^(?:[ \t]*<\?php)?[ \t/*#@]*Theme Name:(.*)$/im;
+  return themeNameRegex.test(styleCSS);
+}
+
+// src/wp-playground-wordpress/is-wp-content-directory.ts
+import fs5 from "fs-extra";
+import path4 from "path";
+function isWpContentDirectory(projectPath) {
+  const muPluginsExists = fs5.existsSync(path4.join(projectPath, "mu-plugins"));
+  const pluginsExists = fs5.existsSync(path4.join(projectPath, "plugins"));
+  const themesExists = fs5.existsSync(path4.join(projectPath, "themes"));
+  if (muPluginsExists || pluginsExists || themesExists) {
+    return true;
+  }
+  return false;
+}
+
+// src/wp-playground-wordpress/is-wordpress-directory.ts
+import fs6 from "fs-extra";
+import path5 from "path";
+function isWordPressDirectory(projectPath) {
+  return fs6.existsSync(path5.join(projectPath, "wp-content")) && fs6.existsSync(path5.join(projectPath, "wp-includes")) && fs6.existsSync(path5.join(projectPath, "wp-load.php"));
+}
+
+// src/wp-playground-wordpress/is-wordpress-develop-directory.ts
+import fs7 from "fs-extra";
+import path6 from "path";
+function isWordPressDevelopDirectory(projectPath) {
+  const requiredFiles = [
+    "src",
+    "src/wp-content",
+    "src/wp-includes",
+    "src/wp-load.php",
+    "build",
+    "build/wp-content",
+    "build/wp-includes",
+    "build/wp-load.php"
+  ];
+  return requiredFiles.every(
+    (file) => fs7.existsSync(path6.join(projectPath, file))
+  );
+}
+
+// src/output.ts
+function shouldOutput() {
+  return process.env.NODE_ENV !== "test";
+}
+var output = shouldOutput() ? console : null;
+function disableOutput() {
+  output = null;
+}
+
+// src/get-wp-now-path.ts
+import path8 from "path";
+import os2 from "os";
+
+// src/get-wp-now-tmp-path.ts
+import path7 from "path";
+import os from "os";
+function getWpNowTmpPath() {
+  const tmpDirectory = os.tmpdir();
+  return path7.join(tmpDirectory, `wp-now-tests-hidden-folder`);
+}
+
+// src/get-wp-now-path.ts
+function getWpNowPath() {
+  if (process.env.NODE_ENV !== "test") {
+    return path8.join(os2.homedir(), WP_NOW_HIDDEN_FOLDER);
+  }
+  return getWpNowTmpPath();
+}
+
+// src/get-wordpress-versions-path.ts
+import path9 from "path";
+function getWordpressVersionsPath() {
+  return path9.join(getWpNowPath(), "wordpress-versions");
+}
+
+// src/get-sqlite-path.ts
+import path10 from "path";
+function getSqlitePath() {
+  return path10.join(getWpNowPath(), `${SQLITE_FILENAME}-main`);
+}
+
+// src/download.ts
+function getWordPressVersionUrl(version = DEFAULT_WORDPRESS_VERSION) {
+  if (!isValidWordPressVersion(version)) {
+    throw new Error(
+      'Unrecognized WordPress version. Please use "latest", numeric versions such as "6.2", "6.0.1", "6.2-beta1", "6.2-RC1", or "classicpress" / "classicpress-2.4.1".'
+    );
+  }
+  return `https://wordpress.org/wordpress-${version}.zip`;
+}
+function getClassicPressVersionUrl(version) {
+  if (version === "classicpress" || version === "classicpress-latest") {
+    return CLASSICPRESS_LATEST_URL;
+  }
+  const tag = version.slice("classicpress-".length);
+  return `https://github.com/ClassicPress/ClassicPress-release/archive/refs/tags/${tag}.zip`;
+}
+followRedirects.maxRedirects = 5;
+var { https } = followRedirects;
+async function downloadFileAndUnzip({
+  url,
+  destinationFolder,
+  checkFinalPath,
+  itemName
+}) {
+  if (fs8.existsSync(checkFinalPath)) {
+    output?.log(`${itemName} folder already exists. Skipping download.`);
+    return { downloaded: false, statusCode: 0 };
+  }
+  let statusCode = 0;
+  try {
+    fs8.ensureDirSync(path11.dirname(destinationFolder));
+    output?.log(`Downloading ${itemName}...`);
+    const response = await new Promise(
+      (resolve) => https.get(url, (response2) => resolve(response2))
+    );
+    statusCode = response.statusCode;
+    if (response.statusCode !== 200) {
+      throw new Error(
+        `Failed to download file (Status code ${response.statusCode}).`
+      );
+    }
+    await response.pipe(unzipper.Parse()).on("entry", (entry) => {
+      const filePath = path11.join(destinationFolder, entry.path);
+      fs8.ensureDirSync(path11.dirname(filePath));
+      if (entry.type !== "Directory") {
+        entry.pipe(fs8.createWriteStream(filePath));
+      }
+    }).promise();
+    return { downloaded: true, statusCode };
+  } catch (err) {
+    output?.error(`Error downloading or unzipping ${itemName}:`, err);
+  }
+  return { downloaded: false, statusCode };
+}
+async function downloadWordPress(wordPressVersion = DEFAULT_WORDPRESS_VERSION) {
+  const finalFolder = path11.join(getWordpressVersionsPath(), wordPressVersion);
+  if (isClassicPressVersion(wordPressVersion)) {
+    return downloadClassicPress(wordPressVersion, finalFolder);
+  }
+  const tempFolder = os3.tmpdir();
+  const { downloaded, statusCode } = await downloadFileAndUnzip({
+    url: getWordPressVersionUrl(wordPressVersion),
+    destinationFolder: tempFolder,
+    checkFinalPath: finalFolder,
+    itemName: `WordPress ${wordPressVersion}`
+  });
+  if (downloaded) {
+    fs8.ensureDirSync(path11.dirname(finalFolder));
+    fs8.moveSync(path11.join(tempFolder, "wordpress"), finalFolder, {
+      overwrite: true
+    });
+  } else if (404 === statusCode) {
+    output?.log(
+      `WordPress ${wordPressVersion} not found. Check https://wordpress.org/download/releases/ for available versions.`
+    );
+    process.exit(1);
+  }
+}
+async function downloadClassicPress(version, finalFolder) {
+  const tempFolder = path11.join(os3.tmpdir(), `wp-app-classicpress-${Date.now()}`);
+  const { downloaded, statusCode } = await downloadFileAndUnzip({
+    url: getClassicPressVersionUrl(version),
+    destinationFolder: tempFolder,
+    checkFinalPath: finalFolder,
+    itemName: `ClassicPress ${version}`
+  });
+  if (downloaded) {
+    fs8.ensureDirSync(path11.dirname(finalFolder));
+    const entries = fs8.readdirSync(tempFolder);
+    const singleDirRoot = entries.length === 1 && fs8.statSync(path11.join(tempFolder, entries[0])).isDirectory() ? path11.join(tempFolder, entries[0]) : null;
+    fs8.moveSync(singleDirRoot ?? tempFolder, finalFolder, {
+      overwrite: true
+    });
+    fs8.removeSync(tempFolder);
+  } else if (404 === statusCode) {
+    output?.log(
+      `ClassicPress ${version} not found. Check https://www.classicpress.net for available releases.`
+    );
+    process.exit(1);
+  }
+}
+async function downloadSqliteIntegrationPlugin() {
+  return downloadFileAndUnzip({
+    url: SQLITE_URL,
+    destinationFolder: getWpNowPath(),
+    checkFinalPath: getSqlitePath(),
+    itemName: "SQLite"
+  });
+}
+async function downloadMuPlugins() {
+  fs8.ensureDirSync(path11.join(getWpNowPath(), "mu-plugins"));
+  fs8.writeFile(
+    path11.join(getWpNowPath(), "mu-plugins", "0-allow-wp-org.php"),
+    `<?php
+	// Needed because gethostbyname( 'wordpress.org' ) returns
+	// a private network IP address for some reason.
+	add_filter( 'allowed_redirect_hosts', function( $deprecated = '' ) {
+		return array(
+			'wordpress.org',
+			'api.wordpress.org',
+			'downloads.wordpress.org',
+		);
+	} );`
+  );
+}
+
+// src/wp-now.ts
+import {
+  activatePlugin,
+  activateTheme,
+  defineWpConfigConsts,
+  login
+} from "@wp-playground/blueprints";
+
+// src/config.ts
+import {
+  SupportedPHPVersionsList
+} from "@php-wasm/universal";
+import crypto from "crypto";
+
+// src/github-codespaces.ts
+var isGitHubCodespace = Boolean(
+  process.env.CODESPACE_NAME && process.env.GITHUB_CODESPACES_PORT_FORWARDING_DOMAIN
+);
+function getCodeSpaceURL(port) {
+  return `https://${process.env.CODESPACE_NAME}-${port}.${process.env.GITHUB_CODESPACES_PORT_FORWARDING_DOMAIN}`;
+}
+
+// src/config.ts
+import path12 from "path";
+var DEFAULT_OPTIONS = {
+  phpVersion: DEFAULT_PHP_VERSION,
+  wordPressVersion: DEFAULT_WORDPRESS_VERSION,
+  documentRoot: "/var/www/html",
+  projectPath: process.cwd(),
+  mode: "auto" /* AUTO */,
+  numberOfPhpInstances: 1
+};
+async function getAbsoluteURL() {
+  const port = await portFinder.getOpenPort();
+  if (isGitHubCodespace) {
+    return getCodeSpaceURL(port);
+  }
+  return `http://localhost:${port}`;
+}
+function getWpContentHomePath(projectPath, mode) {
+  const basename2 = path12.basename(projectPath);
+  const directoryHash = crypto.createHash("sha1").update(projectPath).digest("hex");
+  const projectDirectory = mode === "playground" /* PLAYGROUND */ ? "playground" : `${basename2}-${directoryHash}`;
+  return path12.join(getWpNowPath(), "wp-content", projectDirectory);
+}
+async function getWpNowConfig(args) {
+  if (args.port) {
+    portFinder.setPort(args.port);
+  }
+  const port = await portFinder.getOpenPort();
+  const optionsFromCli = {
+    phpVersion: args.php,
+    projectPath: args.path,
+    wordPressVersion: args.wp,
+    mode: args.mode,
+    port
+  };
+  const options = {};
+  [optionsFromCli, DEFAULT_OPTIONS].forEach((config) => {
+    for (const key in config) {
+      if (!options[key]) {
+        options[key] = config[key];
+      }
+    }
+  });
+  if (!options.mode || options.mode === "auto") {
+    options.mode = inferMode(options.projectPath);
+  }
+  if (!options.wpContentPath) {
+    options.wpContentPath = getWpContentHomePath(
+      options.projectPath,
+      options.mode
+    );
+  }
+  if (!options.absoluteUrl) {
+    options.absoluteUrl = await getAbsoluteURL();
+  }
+  if (!isValidWordPressVersion(options.wordPressVersion)) {
+    throw new Error(
+      'Unrecognized WordPress version. Please use "latest", numeric versions such as "6.2", "6.0.1", "6.2-beta1", "6.2-RC1", or "classicpress" / "classicpress-2.4.1"'
+    );
+  }
+  if (options.phpVersion && !SupportedPHPVersionsList.includes(options.phpVersion)) {
+    throw new Error(
+      `Unsupported PHP version: ${options.phpVersion}. Supported versions: ${SupportedPHPVersionsList.join(", ")}`
+    );
+  }
+  return options;
+}
+
+// src/wp-now.ts
+function seemsLikeAPHPFile(path15) {
+  return path15.endsWith(".php") || path15.includes(".php/");
+}
+async function applyToInstances(phpInstances, callback) {
+  for (let i = 0; i < phpInstances.length; i++) {
+    await callback(phpInstances[i]);
+  }
+}
+async function startWPNow(options = {}) {
+  const { documentRoot } = options;
+  const nodePHPOptions = {
+    requestHandler: {
+      documentRoot,
+      absoluteUrl: options.absoluteUrl,
+      isStaticFilePath: (path15) => {
+        try {
+          const fullPath = options.documentRoot + path15;
+          return php.fileExists(fullPath) && !php.isDir(fullPath) && !seemsLikeAPHPFile(fullPath);
+        } catch (e) {
+          output?.error(e);
+          return false;
+        }
+      }
+    }
+  };
+  const phpInstances = [];
+  for (let i = 0; i < Math.max(options.numberOfPhpInstances, 1); i++) {
+    phpInstances.push(
+      await NodePHP.load(options.phpVersion, nodePHPOptions)
+    );
+  }
+  const php = phpInstances[0];
+  phpInstances.forEach((_php) => {
+    _php.mkdirTree(documentRoot);
+    _php.chdir(documentRoot);
+    _php.writeFile(
+      `${documentRoot}/index.php`,
+      `<?php echo 'Hello wp-app!';`
+    );
+  });
+  output?.log(`directory: ${options.projectPath}`);
+  output?.log(`mode: ${options.mode}`);
+  output?.log(`php: ${options.phpVersion}`);
+  if (options.mode === "index" /* INDEX */) {
+    await applyToInstances(phpInstances, async (_php) => {
+      runIndexMode(_php, options);
+    });
+    return { php, phpInstances, options };
+  }
+  output?.log(`wp: ${options.wordPressVersion}`);
+  await Promise.all([
+    downloadWordPress(options.wordPressVersion),
+    downloadSqliteIntegrationPlugin(),
+    downloadMuPlugins()
+  ]);
+  const isFirstTimeProject = !fs9.existsSync(options.wpContentPath);
+  await applyToInstances(phpInstances, async (_php) => {
+    switch (options.mode) {
+      case "wp-content" /* WP_CONTENT */:
+        await runWpContentMode(_php, options);
+        break;
+      case "wordpress-develop" /* WORDPRESS_DEVELOP */:
+        await runWordPressDevelopMode(_php, options);
+        break;
+      case "wordpress" /* WORDPRESS */:
+        await runWordPressMode(_php, options);
+        break;
+      case "plugin" /* PLUGIN */:
+        await runPluginOrThemeMode(_php, options);
+        break;
+      case "theme" /* THEME */:
+        await runPluginOrThemeMode(_php, options);
+        break;
+      case "playground" /* PLAYGROUND */:
+        await runWpPlaygroundMode(_php, options);
+        break;
+    }
+  });
+  await installationStep2(php);
+  await login(php, {
+    username: "admin",
+    password: "password"
+  });
+  if (isFirstTimeProject && ["plugin" /* PLUGIN */, "theme" /* THEME */].includes(options.mode)) {
+    await activatePluginOrTheme(php, options);
+  }
+  return {
+    php,
+    phpInstances,
+    options
+  };
+}
+async function runIndexMode(php, { documentRoot, projectPath }) {
+  php.mount(projectPath, documentRoot);
+}
+async function runWpContentMode(php, {
+  documentRoot,
+  wordPressVersion,
+  wpContentPath,
+  projectPath,
+  absoluteUrl
+}) {
+  const wordPressPath = path13.join(
+    getWordpressVersionsPath(),
+    wordPressVersion
+  );
+  php.mount(wordPressPath, documentRoot);
+  await initWordPress(php, wordPressVersion, documentRoot, absoluteUrl);
+  fs9.ensureDirSync(wpContentPath);
+  php.mount(projectPath, `${documentRoot}/wp-content`);
+  mountSqlitePlugin(php, documentRoot);
+  mountSqliteDatabaseDirectory(php, documentRoot, wpContentPath);
+  mountMuPlugins(php, documentRoot);
+}
+async function runWordPressDevelopMode(php, { documentRoot, projectPath, absoluteUrl }) {
+  await runWordPressMode(php, {
+    documentRoot,
+    projectPath: projectPath + "/build",
+    absoluteUrl
+  });
+}
+async function runWordPressMode(php, { documentRoot, wpContentPath, projectPath, absoluteUrl }) {
+  php.mount(projectPath, documentRoot);
+  const { initializeDefaultDatabase } = await initWordPress(
+    php,
+    "user-provided",
+    documentRoot,
+    absoluteUrl
+  );
+  if (initializeDefaultDatabase || fs9.existsSync(path13.join(wpContentPath, "database"))) {
+    mountSqlitePlugin(php, documentRoot);
+    mountSqliteDatabaseDirectory(php, documentRoot, wpContentPath);
+  }
+  mountMuPlugins(php, documentRoot);
+}
+async function runPluginOrThemeMode(php, {
+  wordPressVersion,
+  documentRoot,
+  projectPath,
+  wpContentPath,
+  absoluteUrl,
+  mode
+}) {
+  const wordPressPath = path13.join(
+    getWordpressVersionsPath(),
+    wordPressVersion
+  );
+  php.mount(wordPressPath, documentRoot);
+  await initWordPress(php, wordPressVersion, documentRoot, absoluteUrl);
+  fs9.ensureDirSync(wpContentPath);
+  fs9.copySync(
+    path13.join(getWordpressVersionsPath(), wordPressVersion, "wp-content"),
+    wpContentPath
+  );
+  php.mount(wpContentPath, `${documentRoot}/wp-content`);
+  const pluginName = path13.basename(projectPath);
+  const directoryName = mode === "plugin" /* PLUGIN */ ? "plugins" : "themes";
+  php.mount(
+    projectPath,
+    `${documentRoot}/wp-content/${directoryName}/${pluginName}`
+  );
+  mountSqlitePlugin(php, documentRoot);
+  mountMuPlugins(php, documentRoot);
+}
+async function runWpPlaygroundMode(php, { documentRoot, wordPressVersion, wpContentPath, absoluteUrl }) {
+  const wordPressPath = path13.join(
+    getWordpressVersionsPath(),
+    wordPressVersion
+  );
+  php.mount(wordPressPath, documentRoot);
+  await initWordPress(php, wordPressVersion, documentRoot, absoluteUrl);
+  fs9.ensureDirSync(wpContentPath);
+  fs9.copySync(
+    path13.join(getWordpressVersionsPath(), wordPressVersion, "wp-content"),
+    wpContentPath
+  );
+  php.mount(wpContentPath, `${documentRoot}/wp-content`);
+  mountSqlitePlugin(php, documentRoot);
+  mountMuPlugins(php, documentRoot);
+}
+async function initWordPress(php, wordPressVersion, vfsDocumentRoot, siteUrl) {
+  let initializeDefaultDatabase = false;
+  if (!php.fileExists(`${vfsDocumentRoot}/wp-config.php`)) {
+    php.writeFile(
+      `${vfsDocumentRoot}/wp-config.php`,
+      php.readFileAsText(`${vfsDocumentRoot}/wp-config-sample.php`)
+    );
+    initializeDefaultDatabase = true;
+  }
+  const wpConfigConsts = {
+    WP_HOME: siteUrl,
+    WP_SITEURL: siteUrl
+  };
+  if (wordPressVersion !== "user-defined") {
+    wpConfigConsts["WP_AUTO_UPDATE_CORE"] = wordPressVersion === "latest";
+  }
+  await defineWpConfigConsts(php, {
+    consts: wpConfigConsts,
+    virtualize: true
+  });
+  return { initializeDefaultDatabase };
+}
+async function activatePluginOrTheme(php, { projectPath, mode }) {
+  if (mode === "plugin" /* PLUGIN */) {
+    const pluginFile = getPluginFile(projectPath);
+    await activatePlugin(php, { pluginPath: pluginFile });
+  } else if (mode === "theme" /* THEME */) {
+    const themeFolderName = path13.basename(projectPath);
+    await activateTheme(php, { themeFolderName });
+  }
+}
+function mountMuPlugins(php, vfsDocumentRoot) {
+  php.mount(
+    path13.join(getWpNowPath(), "mu-plugins"),
+    // VFS paths are always POSIX — path.join would break them on Windows.
+    `${vfsDocumentRoot}/wp-content/mu-plugins`
+  );
+}
+function mountSqlitePlugin(php, vfsDocumentRoot) {
+  const sqlitePluginPath = `${vfsDocumentRoot}/wp-content/plugins/${SQLITE_FILENAME}`;
+  if (php.listFiles(sqlitePluginPath).length === 0) {
+    php.mount(getSqlitePath(), sqlitePluginPath);
+    php.mount(
+      path13.join(getSqlitePath(), "db.copy"),
+      `${vfsDocumentRoot}/wp-content/db.php`
+    );
+  }
+}
+function mountSqliteDatabaseDirectory(php, vfsDocumentRoot, wpContentPath) {
+  fs9.ensureDirSync(path13.join(wpContentPath, "database"));
+  php.mount(
+    path13.join(wpContentPath, "database"),
+    `${vfsDocumentRoot}/wp-content/database`
+  );
+}
+function inferMode(projectPath) {
+  if (isWordPressDevelopDirectory(projectPath)) {
+    return "wordpress-develop" /* WORDPRESS_DEVELOP */;
+  } else if (isWordPressDirectory(projectPath)) {
+    return "wordpress" /* WORDPRESS */;
+  } else if (isWpContentDirectory(projectPath)) {
+    return "wp-content" /* WP_CONTENT */;
+  } else if (isPluginDirectory(projectPath)) {
+    return "plugin" /* PLUGIN */;
+  } else if (isThemeDirectory(projectPath)) {
+    return "theme" /* THEME */;
+  } else if (hasIndexFile(projectPath)) {
+    return "index" /* INDEX */;
+  }
+  return "playground" /* PLAYGROUND */;
+}
+async function installationStep2(php) {
+  const fields = new URLSearchParams({
+    language: "en",
+    prefix: "wp_",
+    weblog_title: "My WordPress Website",
+    user_name: "admin",
+    admin_password: "password",
+    admin_password2: "password",
+    Submit: "Install WordPress",
+    pw_weak: "1",
+    admin_email: "admin@localhost.com"
+  });
+  return php.request({
+    url: "/wp-admin/install.php?step=2",
+    method: "POST",
+    headers: {
+      "content-type": "application/x-www-form-urlencoded"
+    },
+    body: fields.toString()
+  });
+}
+
+// src/start-server.ts
+function requestBodyToMultipartFormData(json, boundary) {
+  let multipartData = "";
+  const eol = "\r\n";
+  for (const key in json) {
+    multipartData += `--${boundary}${eol}`;
+    multipartData += `Content-Disposition: form-data; name="${key}"${eol}${eol}`;
+    multipartData += `${json[key]}${eol}`;
+  }
+  multipartData += `--${boundary}--${eol}`;
+  return multipartData;
+}
+var requestBodyToString = async (req) => await new Promise((resolve) => {
+  let body = "";
+  req.on("data", (chunk) => {
+    body += chunk.toString();
+  });
+  req.on("end", () => {
+    resolve(body);
+  });
+});
+async function startServer(options = {}) {
+  if (!fs10.existsSync(options.projectPath)) {
+    throw new Error(
+      `The given path "${options.projectPath}" does not exist.`
+    );
+  }
+  const app = express();
+  app.use(fileUpload());
+  const port = await portFinder.getOpenPort();
+  const { php, options: wpNowOptions } = await startWPNow(options);
+  app.use("/", async (req, res) => {
+    try {
+      const requestHeaders = {};
+      if (req.rawHeaders && req.rawHeaders.length) {
+        for (let i = 0; i < req.rawHeaders.length; i += 2) {
+          requestHeaders[req.rawHeaders[i].toLowerCase()] = req.rawHeaders[i + 1];
+        }
+      }
+      const body = requestHeaders["content-type"]?.startsWith(
+        "multipart/form-data"
+      ) ? requestBodyToMultipartFormData(
+        req.body,
+        requestHeaders["content-type"].split("; boundary=")[1]
+      ) : await requestBodyToString(req);
+      const data = {
+        url: req.url,
+        headers: requestHeaders,
+        method: req.method,
+        files: Object.fromEntries(
+          Object.entries(req.files || {}).map(
+            ([key, file]) => [
+              key,
+              {
+                key,
+                name: file.name,
+                size: file.size,
+                type: file.mimetype,
+                arrayBuffer: () => file.data.buffer
+              }
+            ]
+          )
+        ),
+        body
+      };
+      const resp = await php.request(data);
+      res.statusCode = resp.httpStatusCode;
+      Object.keys(resp.headers).forEach((key) => {
+        res.setHeader(key, resp.headers[key]);
+      });
+      res.end(resp.bytes);
+    } catch (e) {
+      output?.trace(e);
+    }
+  });
+  const url = options.absoluteUrl;
+  app.listen(port, () => {
+    output?.log(`Server running at ${url}`);
+  });
+  return {
+    url,
+    php,
+    options: wpNowOptions
+  };
+}
+
+// src/execute-php.ts
+async function executePHP(phpArgs, options = {}) {
+  if (phpArgs[0] !== "php") {
+    throw new Error(
+      'The first argument to executePHP must be the string "php".'
+    );
+  }
+  disableOutput();
+  const { phpInstances } = await startWPNow({
+    ...options,
+    numberOfPhpInstances: 2
+  });
+  const [, php] = phpInstances;
+  try {
+    php.useHostFilesystem();
+    await php.cli(phpArgs);
+  } catch (resultOrError) {
+    const success = resultOrError.name === "ExitStatus" && resultOrError.status === 0;
+    if (!success) {
+      throw resultOrError;
+    }
+  }
+}
+
+// src/run-cli.ts
+var MODE_CHOICES = [
+  "auto",
+  "plugin",
+  "theme",
+  "wordpress",
+  "wordpress-develop",
+  "wp-content",
+  "index",
+  "playground"
+];
+function startSpinner(message) {
+  process.stdout.write(`${message}...
+`);
+  return {
+    succeed: (text) => {
+      output?.log(`${text}`);
+    },
+    fail: (text) => {
+      output?.error(`${text}`);
+    }
+  };
+}
+function commonParameters(yargs2) {
+  return yargs2.option("path", {
+    describe: "Path to the PHP or WordPress project. Defaults to the current working directory.",
+    type: "string"
+  }).option("php", {
+    describe: "PHP version to use.",
+    type: "string"
+  });
+}
+function serverParameters(yargs2) {
+  commonParameters(yargs2);
+  yargs2.option("wp", {
+    describe: "WordPress version to use, e.g. '--wp=6.4'. Use '--wp=classicpress' for ClassicPress.",
+    type: "string"
+  });
+  yargs2.option("port", {
+    describe: "Server port",
+    type: "number"
+  });
+  yargs2.option("mode", {
+    describe: "Project mode. Defaults to auto-detection from the project directory.",
+    type: "string",
+    choices: MODE_CHOICES
+  });
+}
+async function runCli() {
+  return yargs(hideBin(process.argv)).scriptName("wp-app").usage("$0 <cmd> [args]").check(async (argv) => {
+    if (["build", "dev"].includes(argv._[0])) {
+      return true;
+    }
+    const config = {
+      php: argv.php,
+      path: argv.path
+    };
+    if (argv._[0] !== "php") {
+      config.wp = argv.wp;
+      config.port = argv.port;
+      config.mode = argv.mode;
+    }
+    try {
+      await getWpNowConfig(config);
+    } catch (error) {
+      return error.message;
+    }
+    return true;
+  }).command(
+    "start",
+    "Start the server",
+    (yargs2) => {
+      serverParameters(yargs2);
+      yargs2.option("reset", {
+        describe: "Create a new project environment, destroying the old one (wp-content and database).",
+        type: "boolean",
+        default: false
+      });
+      yargs2.option("open", {
+        describe: "Open the site in the default browser.",
+        type: "boolean",
+        default: true
+      });
+    },
+    async (argv) => {
+      const spinner = startSpinner("Starting the server...");
+      try {
+        const options = await getWpNowConfig({
+          path: argv.path,
+          php: argv.php,
+          wp: argv.wp,
+          port: argv.port,
+          mode: argv.mode
+        });
+        portFinder.setPort(options.port);
+        if (argv.reset) {
+          fs11.removeSync(options.wpContentPath);
+          output?.log("Project environment reset.");
+        }
+        const { url } = await startServer(options);
+        if (argv.open) {
+          openInDefaultBrowser(url);
+        }
+      } catch (error) {
+        output?.error(error);
+        spinner.fail(
+          `Failed to start the server: ${error.message}`
+        );
+      }
+    }
+  ).command(
+    "php [..args]",
+    "Run the php command passing the arguments to php cli",
+    (yargs2) => {
+      commonParameters(yargs2);
+      yargs2.strict(false);
+    },
+    async (argv) => {
+      try {
+        const args = process.argv.slice(2);
+        const options = await getWpNowConfig({
+          path: argv.path,
+          php: argv.php
+        });
+        const phpArgs = args.includes("--") ? argv._ : args;
+        await executePHP(phpArgs, options);
+        process.exit(0);
+      } catch (error) {
+        console.error(error);
+        process.exit(error.status || -1);
+      }
+    }
+  ).command(
+    "build",
+    "Build the project: composer install plus the npm build script, when present",
+    (yargs2) => {
+      commonParameters(yargs2);
+    },
+    async (argv) => {
+      const projectPath = argv.path ? path14.resolve(argv.path) : process.cwd();
+      console.log(`Building project at ${projectPath}`);
+      if (fs11.existsSync(path14.join(projectPath, "composer.json"))) {
+        console.log("Running composer install...");
+        try {
+          execSync(
+            "composer install --no-dev --optimize-autoloader",
+            { cwd: projectPath, stdio: "inherit" }
+          );
+        } catch (error) {
+          console.error(
+            `composer install failed: ${error.message}`
+          );
+        }
+      }
+      const packageJsonPath = path14.join(projectPath, "package.json");
+      if (fs11.existsSync(packageJsonPath)) {
+        const pkg = fs11.readJsonSync(packageJsonPath);
+        if (pkg.scripts?.build) {
+          console.log("Running npm build...");
+          execSync("npm run build", {
+            cwd: projectPath,
+            stdio: "inherit"
+          });
+        }
+      }
+      console.log("Build complete.");
+    }
+  ).command(
+    "dev",
+    "Start the server and restart it when project files change",
+    (yargs2) => {
+      serverParameters(yargs2);
+    },
+    async (argv) => {
+      const selfScript = process.argv[1];
+      const watchDir = path14.resolve(
+        argv.path || process.cwd()
+      );
+      const IGNORED = ["node_modules", "vendor", ".git", "dist"];
+      let child = null;
+      let restartTimer = null;
+      let firstRun = true;
+      const startChild = () => {
+        const args = [selfScript, "start"];
+        if (argv.path) args.push(`--path=${argv.path}`);
+        if (argv.php) args.push(`--php=${argv.php}`);
+        if (argv.wp) args.push(`--wp=${argv.wp}`);
+        if (argv.port) args.push(`--port=${argv.port}`);
+        if (argv.mode) args.push(`--mode=${argv.mode}`);
+        if (!firstRun) args.push("--no-open");
+        firstRun = false;
+        child = spawn(process.execPath, args, {
+          stdio: "inherit"
+        });
+      };
+      startChild();
+      fs11.watch(
+        watchDir,
+        { recursive: true },
+        (_eventType, filename) => {
+          if (!filename) return;
+          const parts = filename.split(/[\\/]/);
+          if (parts.some(
+            (part) => IGNORED.includes(part) || part.startsWith(".")
+          )) {
+            return;
+          }
+          clearTimeout(restartTimer);
+          restartTimer = setTimeout(() => {
+            console.log(
+              `Change detected: ${filename}. Restarting...`
+            );
+            child?.kill();
+            startChild();
+          }, 500);
+        }
+      );
+      console.log("Dev mode: watching for file changes...");
+    }
+  ).demandCommand(1, "You must provide a valid command").help().alias("h", "help").strict().argv;
+}
+function openInDefaultBrowser(url) {
+  if (isGitHubCodespace) {
+    return;
+  }
+  let cmd, args;
+  switch (process.platform) {
+    case "darwin":
+      cmd = "open";
+      args = [url];
+      break;
+    case "linux":
+      cmd = "xdg-open";
+      args = [url];
+      break;
+    case "win32":
+      cmd = "cmd";
+      args = ["/c", `start ${url}`];
+      break;
+    default:
+      output?.log(`Platform '${process.platform}' not supported`);
+      return;
+  }
+  spawn(cmd, args).on("error", function(err) {
+    console.error(err.message);
+  });
+}
+
+// src/main.ts
+var requiredMajorVersion = 18;
+var currentNodeVersion = parseInt(process.versions?.node?.split(".")?.[0]);
+if (currentNodeVersion < requiredMajorVersion) {
+  console.warn(
+    `You are running Node.js version ${currentNodeVersion}, but this application recommends at least Node.js ${requiredMajorVersion} and isn't guaranteed to work on lower versions. Please upgrade your Node.js version.`
+  );
+}
+runCli();