@wp-operations/wp-app 0.1.0

package/dist/index.js

@@ -0,0 +1,802 @@
+// 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/wp-now.ts
+import fs9 from "fs-extra";
+import { NodePHP } from "@php-wasm/node";
+import path12 from "path";
+
+// 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/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;
+
+// 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";
+function seemsLikeAPHPFile(path14) {
+  return path14.endsWith(".php") || path14.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: (path14) => {
+        try {
+          const fullPath = options.documentRoot + path14;
+          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 = path12.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(path12.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 = path12.join(
+    getWordpressVersionsPath(),
+    wordPressVersion
+  );
+  php.mount(wordPressPath, documentRoot);
+  await initWordPress(php, wordPressVersion, documentRoot, absoluteUrl);
+  fs9.ensureDirSync(wpContentPath);
+  fs9.copySync(
+    path12.join(getWordpressVersionsPath(), wordPressVersion, "wp-content"),
+    wpContentPath
+  );
+  php.mount(wpContentPath, `${documentRoot}/wp-content`);
+  const pluginName = path12.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 = path12.join(
+    getWordpressVersionsPath(),
+    wordPressVersion
+  );
+  php.mount(wordPressPath, documentRoot);
+  await initWordPress(php, wordPressVersion, documentRoot, absoluteUrl);
+  fs9.ensureDirSync(wpContentPath);
+  fs9.copySync(
+    path12.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 = path12.basename(projectPath);
+    await activateTheme(php, { themeFolderName });
+  }
+}
+function mountMuPlugins(php, vfsDocumentRoot) {
+  php.mount(
+    path12.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(
+      path12.join(getSqlitePath(), "db.copy"),
+      `${vfsDocumentRoot}/wp-content/db.php`
+    );
+  }
+}
+function mountSqliteDatabaseDirectory(php, vfsDocumentRoot, wpContentPath) {
+  fs9.ensureDirSync(path12.join(wpContentPath, "database"));
+  php.mount(
+    path12.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/port-finder.ts
+import http from "http";
+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/config.ts
+import path13 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 = path13.basename(projectPath);
+  const directoryHash = crypto.createHash("sha1").update(projectPath).digest("hex");
+  const projectDirectory = mode === "playground" /* PLAYGROUND */ ? "playground" : `${basename2}-${directoryHash}`;
+  return path13.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/start-server.ts
+import fs10 from "fs";
+import express from "express";
+import fileUpload from "express-fileupload";
+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
+  };
+}
+export {
+  getWpNowConfig,
+  startServer
+};