@wp-operations/wp-app 0.1.1 → 0.3.0

package/dist/index.js

@@ -1,8 +1,5 @@
 // src/config.ts
-import {
-  SupportedPHPVersionsList
-} from "@php-wasm/universal";
-import crypto from "crypto";
+import { SupportedPHPVersionsList } from "@php-wasm/universal";
 
 // src/github-codespaces.ts
 var isGitHubCodespace = Boolean(
@@ -12,35 +9,183 @@ 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/engine.ts
+import fs10 from "fs";
+import path9 from "path";
+import { createNodeFsMountHandler } from "@php-wasm/node";
+
+// src/boot.ts
+import { rootCertificates } from "tls";
+import { loadNodeRuntime } from "@php-wasm/node";
+import { PHP, PHPRequestHandler, setPhpIniEntries } from "@php-wasm/universal";
+var CA_BUNDLE_PATH = "/internal/ca-bundle.crt";
+async function createPhp(phpVersion) {
+  const php = new PHP(
+    await loadNodeRuntime(phpVersion, {
+      emscriptenOptions: { processId: process.pid }
+    })
+  );
+  php.setSapiName("cli");
+  php.mkdir("/internal");
+  php.writeFile(CA_BUNDLE_PATH, rootCertificates.join("\n"));
+  await setPhpIniEntries(php, {
+    "openssl.cafile": CA_BUNDLE_PATH,
+    "curl.cainfo": CA_BUNDLE_PATH,
+    allow_url_fopen: "1",
+    disable_functions: ""
+  });
+  return php;
+}
+function createRequestHandler(php, documentRoot, absoluteUrl) {
+  return new PHPRequestHandler({ php, documentRoot, absoluteUrl });
+}
+async function runPhp(php, code) {
+  const response = await php.run({ code: `<?php ${code}` });
+  if (response.exitCode !== 0) {
+    throw new Error(response.errors || `PHP exited ${response.exitCode}`);
+  }
+  return response;
+}
+async function unzipTo(php, zip, destination) {
+  const tmpZip = `/internal/upload-${Date.now()}.zip`;
+  php.writeFile(tmpZip, new Uint8Array(await zip.arrayBuffer()));
+  await runPhp(
+    php,
+    `
+		$zip = new ZipArchive();
+		if ($zip->open(${str(tmpZip)}) !== true) exit(1);
+		if (!is_dir(${str(destination)})) mkdir(${str(destination)}, 0777, true);
+		if (!$zip->extractTo(${str(destination)})) exit(1);
+		$zip->close();
+		unlink(${str(tmpZip)});
+		`
+  );
+}
+async function installCore(php, coreZip, docroot) {
+  const staging = `${docroot}/.wpapp-staging`;
+  await unzipTo(php, coreZip, staging);
+  await runPhp(
+    php,
+    `
+		function wpapp_core_root($dir) {
+			if (file_exists("$dir/wp-config-sample.php")) return $dir;
+			foreach (scandir($dir) as $entry) {
+				if ($entry === '.' || $entry === '..') continue;
+				$candidate = "$dir/$entry";
+				if (is_dir($candidate) && file_exists("$candidate/wp-config-sample.php")) {
+					return $candidate;
+				}
+			}
+			exit(1);
+		}
+		function wpapp_rrmdir($dir) {
+			foreach (scandir($dir) as $entry) {
+				if ($entry === '.' || $entry === '..') continue;
+				$path = "$dir/$entry";
+				is_dir($path) ? wpapp_rrmdir($path) : unlink($path);
+			}
+			rmdir($dir);
+		}
+		$root = wpapp_core_root(${str(staging)});
+		foreach (scandir($root) as $entry) {
+			if ($entry === '.' || $entry === '..') continue;
+			rename("$root/$entry", ${str(docroot)} . "/$entry");
+		}
+		wpapp_rrmdir(${str(staging)});
+		if (!file_exists(${str(docroot)} . '/wp-config.php')) {
+			copy(
+				${str(docroot)} . '/wp-config-sample.php',
+				${str(docroot)} . '/wp-config.php'
+			);
+		}
+		`
+  );
+}
+async function installSqliteIntegration(php, pluginZip, docroot) {
+  const pluginDir = `${docroot}/wp-content/plugins/sqlite-database-integration`;
+  const staging = `${docroot}/wp-content/.wpapp-sqlite-staging`;
+  await unzipTo(php, pluginZip, staging);
+  await runPhp(
+    php,
+    `
+		$root = ${str(staging)};
+		$entries = array_values(array_diff(scandir($root), ['.', '..']));
+		if (count($entries) === 1 && is_dir("$root/$entries[0]")) {
+			$root = "$root/$entries[0]";
+		}
+		if (!is_dir(${str(pluginDir)})) {
+			rename($root, ${str(pluginDir)});
+		}
+		if (is_dir(${str(staging)})) {
+			@rmdir(${str(staging)});
+		}
+		$dropIn = file_get_contents(${str(pluginDir)} . '/db.copy');
+		$dropIn = str_replace(
+			'{SQLITE_IMPLEMENTATION_FOLDER_PATH}',
+			${str(pluginDir)},
+			$dropIn
+		);
+		$dropIn = str_replace(
+			'{SQLITE_PLUGIN}',
+			'sqlite-database-integration/load.php',
+			$dropIn
+		);
+		file_put_contents(${str(docroot)} . '/wp-content/db.php', $dropIn);
+		`
+  );
+}
+function defineSiteConstants(php, siteUrl, databaseDir) {
+  php.defineConstant("WP_HOME", siteUrl);
+  php.defineConstant("WP_SITEURL", siteUrl);
+  php.defineConstant("DB_DIR", databaseDir);
+  php.defineConstant("DB_FILE", ".ht.sqlite");
+  php.defineConstant("WP_SQLITE_AST_DRIVER", true);
+}
+async function runInstaller(requestHandler) {
+  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 requestHandler.request({
+    url: "/wp-admin/install.php?step=2",
+    method: "POST",
+    headers: { "content-type": "application/x-www-form-urlencoded" },
+    body: new TextEncoder().encode(fields.toString())
+  });
+}
+function str(value) {
+  return `'${value.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+}
 
 // src/constants.ts
-var WP_NOW_HIDDEN_FOLDER = ".wp-app";
-var SQLITE_FILENAME = "sqlite-database-integration";
+var WP_APP_HIDDEN_FOLDER = ".wp-app";
+var WP_APP_HOME_ENV = "WP_APP_HOME";
 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_PHP_VERSION = "8.3";
 var DEFAULT_WORDPRESS_VERSION = "latest";
+var DOCROOT = "/wordpress";
 
 // 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";
+import fs9 from "fs";
+import path8 from "path";
 
-// src/wp-playground-wordpress/has-index-file.ts
-import fs from "fs-extra";
+// src/detect/has-index-file.ts
+import fs from "fs";
 import path from "path";
 function hasIndexFile(projectPath) {
   return fs.existsSync(path.join(projectPath, "index.php"));
 }
 
-// src/wp-playground-wordpress/is-valid-wordpress-version.ts
+// src/detect/is-valid-wordpress-version.ts
 function isValidWordPressVersion(version) {
   const versionPattern = /^latest$|^(?:(\d+)\.(\d+)(?:\.(\d+))?)((?:-beta(?:\d+)?)|(?:-RC(?:\d+)?))?$/;
   const classicPressPattern = /^classicpress(?:-(\d+)\.(\d+)(?:\.(\d+))?)?$/;
@@ -50,12 +195,12 @@ function isClassicPressVersion(version) {
   return version === "classicpress" || version.startsWith("classicpress-");
 }
 
-// src/wp-playground-wordpress/get-plugin-file.ts
-import fs3 from "fs-extra";
+// src/detect/get-plugin-file.ts
+import fs3 from "fs";
 import path2, { basename } from "path";
 
-// src/wp-playground-wordpress/read-file-head.ts
-import fs2 from "fs-extra";
+// src/detect/read-file-head.ts
+import fs2 from "fs";
 function readFileHead(filePath, length = 8192) {
   const buffer = Buffer.alloc(length);
   const fd = fs2.openSync(filePath, "r");
@@ -65,7 +210,7 @@ function readFileHead(filePath, length = 8192) {
   return fileContentBuffer.toString();
 }
 
-// src/wp-playground-wordpress/get-plugin-file.ts
+// src/detect/get-plugin-file.ts
 function heuristicSort(files, projectPath) {
   const heuristicsBestGuess = `${basename(projectPath)}.php`;
   const heuristicsBestGuessIndex = files.indexOf(heuristicsBestGuess);
@@ -89,14 +234,14 @@ function getPluginFile(projectPath) {
   return null;
 }
 
-// src/wp-playground-wordpress/is-plugin-directory.ts
+// src/detect/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";
+// src/detect/is-theme-directory.ts
+import fs4 from "fs";
 import path3 from "path";
 function isThemeDirectory(projectPath) {
   const styleCSSExists = fs4.existsSync(path3.join(projectPath, "style.css"));
@@ -108,8 +253,8 @@ function isThemeDirectory(projectPath) {
   return themeNameRegex.test(styleCSS);
 }
 
-// src/wp-playground-wordpress/is-wp-content-directory.ts
-import fs5 from "fs-extra";
+// src/detect/is-wp-content-directory.ts
+import fs5 from "fs";
 import path4 from "path";
 function isWpContentDirectory(projectPath) {
   const muPluginsExists = fs5.existsSync(path4.join(projectPath, "mu-plugins"));
@@ -121,15 +266,15 @@ function isWpContentDirectory(projectPath) {
   return false;
 }
 
-// src/wp-playground-wordpress/is-wordpress-directory.ts
-import fs6 from "fs-extra";
+// src/detect/is-wordpress-directory.ts
+import fs6 from "fs";
 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";
+// src/detect/is-wordpress-develop-directory.ts
+import fs7 from "fs";
 import path6 from "path";
 function isWordPressDevelopDirectory(projectPath) {
   const requiredFiles = [
@@ -153,40 +298,29 @@ function shouldOutput() {
 }
 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";
+// src/paths.ts
+import crypto from "crypto";
+import fs8 from "fs";
 import os from "os";
-function getWpNowTmpPath() {
-  const tmpDirectory = os.tmpdir();
-  return path7.join(tmpDirectory, `wp-now-tests-hidden-folder`);
+import path7 from "path";
+function getWpAppHome() {
+  return process.env[WP_APP_HOME_ENV] || path7.join(os.homedir(), WP_APP_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();
+function getCachePath() {
+  return ensureDir(path7.join(getWpAppHome(), "cache"));
 }
-
-// src/get-wordpress-versions-path.ts
-import path9 from "path";
-function getWordpressVersionsPath() {
-  return path9.join(getWpNowPath(), "wordpress-versions");
+function getSitePath(projectPath) {
+  const projectName = path7.basename(path7.resolve(projectPath));
+  const hash = crypto.createHash("sha1").update(path7.resolve(projectPath)).digest("hex");
+  return path7.join(getWpAppHome(), "sites", `${projectName}-${hash}`);
 }
-
-// src/get-sqlite-path.ts
-import path10 from "path";
-function getSqlitePath() {
-  return path10.join(getWpNowPath(), `${SQLITE_FILENAME}-main`);
+function ensureDir(dir) {
+  fs8.mkdirSync(dir, { recursive: true });
+  return dir;
 }
 
 // src/download.ts
-function getWordPressVersionUrl(version = DEFAULT_WORDPRESS_VERSION) {
+function getWordPressVersionUrl(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".'
@@ -201,357 +335,181 @@ function getClassicPressVersionUrl(version) {
   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) {
+async function cachedZip(url, cacheKey) {
+  const cacheFile = path8.join(getCachePath(), cacheKey);
+  if (!fs9.existsSync(cacheFile)) {
+    output?.log(`Downloading ${cacheKey}...`);
+    const response = await fetch(url, { redirect: "follow" });
+    if (!response.ok) {
       throw new Error(
-        `Failed to download file (Status code ${response.statusCode}).`
+        `Failed to download ${url} (HTTP ${response.status}).`
       );
     }
-    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);
+    const bytes = Buffer.from(await response.arrayBuffer());
+    fs9.writeFileSync(`${cacheFile}.partial`, bytes);
+    fs9.renameSync(`${cacheFile}.partial`, cacheFile);
+    output?.log(`Cached ${cacheKey} (${bytes.length} bytes).`);
   }
+  return new File([fs9.readFileSync(cacheFile)], cacheKey);
 }
-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 getCoreZip(version) {
+  if (isClassicPressVersion(version)) {
+    return cachedZip(getClassicPressVersionUrl(version), `${version}.zip`);
   }
+  return cachedZip(getWordPressVersionUrl(version), `wordpress-${version}.zip`);
 }
-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',
-		);
-	} );`
-  );
+async function getSqliteIntegrationZip() {
+  return cachedZip(SQLITE_URL, "sqlite-database-integration.zip");
 }
 
-// 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!';`
-    );
-  });
+// src/engine.ts
+async function startWPApp(options) {
+  const projectPath = path9.resolve(options.projectPath);
+  const mode = options.mode;
   output?.log(`directory: ${options.projectPath}`);
-  output?.log(`mode: ${options.mode}`);
+  output?.log(`mode: ${mode}`);
   output?.log(`php: ${options.phpVersion}`);
-  if (options.mode === "index" /* INDEX */) {
-    await applyToInstances(phpInstances, async (_php) => {
-      runIndexMode(_php, options);
-    });
-    return { php, phpInstances, options };
+  const hostDocroot = mode === "index" /* INDEX */ || mode === "wordpress" /* WORDPRESS */ ? projectPath : mode === "wordpress-develop" /* WORDPRESS_DEVELOP */ ? path9.join(projectPath, "build") : ensureDir(getSitePath(projectPath));
+  const isWordPressBacked = mode !== "index" /* INDEX */;
+  const freshSite = isWordPressBacked && !fs10.existsSync(path9.join(hostDocroot, "wp-load.php"));
+  if (isWordPressBacked) {
+    output?.log(`wp: ${options.wordPressVersion}`);
+    output?.log(`site data: ${hostDocroot}`);
+  }
+  const php = await createPhp(options.phpVersion);
+  php.mkdir(DOCROOT);
+  await php.mount(DOCROOT, createNodeFsMountHandler(hostDocroot));
+  const requestHandler = createRequestHandler(
+    php,
+    DOCROOT,
+    options.absoluteUrl
+  );
+  if (freshSite) {
+    await installCore(
+      php,
+      await getCoreZip(options.wordPressVersion),
+      DOCROOT
+    );
   }
-  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;
+  if (isWordPressBacked) {
+    if (!php.fileExists(`${DOCROOT}/wp-content/db.php`)) {
+      await installSqliteIntegration(
+        php,
+        await getSqliteIntegrationZip(),
+        DOCROOT
+      );
     }
-  });
-  await installationStep2(php);
-  await login(php, {
-    username: "admin",
-    password: "password"
-  });
-  if (isFirstTimeProject && ["plugin" /* PLUGIN */, "theme" /* THEME */].includes(options.mode)) {
-    await activatePluginOrTheme(php, options);
+    defineSiteConstants(
+      php,
+      options.absoluteUrl,
+      `${DOCROOT}/wp-content/database`
+    );
   }
-  return {
-    php,
-    phpInstances,
-    options
-  };
+  if (freshSite) {
+    await runInstaller(requestHandler);
+  }
+  await applyProjectMounts(php, mode, projectPath);
+  if (freshSite) {
+    await activateProject(php, mode, projectPath);
+  }
+  return { requestHandler, php, options, freshSite };
 }
-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 applyProjectMounts(php, mode, projectPath) {
+  const projectName = path9.basename(projectPath);
+  switch (mode) {
+    case "theme" /* THEME */:
+      await mountAt(
+        php,
+        projectPath,
+        `${DOCROOT}/wp-content/themes/${projectName}`
+      );
+      break;
+    case "plugin" /* PLUGIN */:
+      await mountAt(
+        php,
+        projectPath,
+        `${DOCROOT}/wp-content/plugins/${projectName}`
+      );
+      break;
+    case "wp-content" /* WP_CONTENT */:
+      for (const entry of fs10.readdirSync(projectPath)) {
+        if (entry === "index.php") {
+          continue;
+        }
+        await mountAt(
+          php,
+          path9.join(projectPath, entry),
+          `${DOCROOT}/wp-content/${entry}`
+        );
+      }
+      break;
+    default:
+      break;
+  }
 }
-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 mountAt(php, hostPath, vfsPath) {
+  if (fs10.statSync(hostPath).isDirectory()) {
+    php.mkdir(vfsPath);
+  }
+  await php.mount(vfsPath, createNodeFsMountHandler(hostPath));
 }
-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`)
+async function activateProject(php, mode, projectPath) {
+  const projectName = path9.basename(projectPath);
+  if (mode === "theme" /* THEME */) {
+    await runWordPressCode(
+      php,
+      `switch_theme(${phpString(projectName)});`
+    );
+  } else if (mode === "plugin" /* PLUGIN */) {
+    const pluginFile = findPluginFile(projectPath);
+    if (pluginFile) {
+      await runWordPressCode(
+        php,
+        `activate_plugin(${phpString(`${projectName}/${pluginFile}`)});`
+      );
+    }
+  } else if (mode === "wp-content" /* WP_CONTENT */) {
+    await runWordPressCode(
+      php,
+      `$theme = wp_get_theme();
+			if (!$theme->exists()) {
+				$themes = wp_get_themes();
+				if (count($themes) > 0) {
+					switch_theme(array_keys($themes)[0]);
+				}
+			}`
     );
-    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`
+async function runWordPressCode(php, code) {
+  try {
+    await runPhp(
+      php,
+      `
+			require ${phpString(`${DOCROOT}/wp-load.php`)};
+			require_once ${phpString(`${DOCROOT}/wp-admin/includes/plugin.php`)};
+			${code}
+			`
     );
+  } catch (error) {
+    output?.error(`Activation step failed: ${error.message}`);
   }
 }
-function mountSqliteDatabaseDirectory(php, vfsDocumentRoot, wpContentPath) {
-  fs9.ensureDirSync(path12.join(wpContentPath, "database"));
-  php.mount(
-    path12.join(wpContentPath, "database"),
-    `${vfsDocumentRoot}/wp-content/database`
-  );
+function phpString(value) {
+  return `'${value.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+}
+function findPluginFile(projectPath) {
+  const pluginNameRegex = /^(?:[ \t]*<\?php)?[ \t/*#@]*Plugin Name:(.*)$/im;
+  for (const file of fs10.readdirSync(projectPath)) {
+    if (!file.endsWith(".php")) {
+      continue;
+    }
+    const content = fs10.readFileSync(path9.join(projectPath, file), "utf8");
+    if (pluginNameRegex.test(content)) {
+      return file;
+    }
+  }
+  return null;
 }
 function inferMode(projectPath) {
   if (isWordPressDevelopDirectory(projectPath)) {
@@ -569,27 +527,6 @@ function inferMode(projectPath) {
   }
   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: new TextEncoder().encode(fields.toString())
-  });
-}
 
 // src/port-finder.ts
 import http from "http";
@@ -641,14 +578,11 @@ var PortFinder = class _PortFinder {
 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
+  mode: "auto" /* AUTO */
 };
 async function getAbsoluteURL() {
   const port = await portFinder.getOpenPort();
@@ -657,13 +591,7 @@ async function getAbsoluteURL() {
   }
   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) {
+async function getWpAppConfig(args) {
   if (args.port) {
     portFinder.setPort(args.port);
   }
@@ -686,12 +614,6 @@ async function getWpNowConfig(args) {
   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();
   }
@@ -709,94 +631,83 @@ async function getWpNowConfig(args) {
 }
 
 // src/start-server.ts
-import fs10 from "fs";
+import fs11 from "fs";
+import { Readable } from "stream";
+import { pipeline } from "stream/promises";
 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)) {
+  if (!fs11.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);
+  const site = await startWPApp(options);
+  const app = express();
   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 = {
+      const phpRequest = {
         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
+        headers: parseHeaders(req),
+        body: await bufferRequestBody(req)
       };
-      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 response = await site.requestHandler.requestStreamed(phpRequest);
+      await sendStreamedResponse(response, res);
+    } catch (error) {
+      output?.trace(error);
+      if (!res.headersSent) {
+        res.statusCode = 500;
+        res.end("Internal Server Error");
+      }
     }
   });
   const url = options.absoluteUrl;
   app.listen(port, () => {
     output?.log(`Server running at ${url}`);
   });
-  return {
-    url,
-    php,
-    options: wpNowOptions
-  };
+  return { ...site, url };
+}
+async function sendStreamedResponse(streamedResponse, res) {
+  const [headers, httpStatusCode] = await Promise.all([
+    streamedResponse.headers,
+    streamedResponse.httpStatusCode
+  ]);
+  res.statusCode = httpStatusCode;
+  for (const key in headers) {
+    res.setHeader(key, headers[key]);
+  }
+  const nodeStream = Readable.fromWeb(streamedResponse.stdout);
+  try {
+    await pipeline(nodeStream, res);
+  } catch (error) {
+    if (error instanceof Error && "code" in error && (error.code === "ERR_STREAM_PREMATURE_CLOSE" || error.code === "ERR_STREAM_UNABLE_TO_PIPE")) {
+      return;
+    }
+    throw error;
+  }
 }
+var bufferRequestBody = async (req) => await new Promise((resolve) => {
+  const body = [];
+  req.on("data", (chunk) => {
+    body.push(chunk);
+  });
+  req.on("end", () => {
+    resolve(new Uint8Array(Buffer.concat(body)));
+  });
+});
+var parseHeaders = (req) => {
+  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];
+    }
+  }
+  return requestHeaders;
+};
 export {
-  getWpNowConfig,
-  startServer
+  getWpAppConfig,
+  inferMode,
+  startServer,
+  startWPApp
 };