@wp-operations/wp-app 0.2.0 → 0.4.0

package/dist/index.js

@@ -10,48 +10,211 @@ function getCodeSpaceURL(port) {
 }
 
 // src/engine.ts
-import fs10 from "fs";
-import path9 from "path";
-import { createNodeFsMountHandler, loadNodeRuntime } from "@php-wasm/node";
-import { bootWordPressAndRequestHandler } from "@wp-playground/wordpress";
+import fs11 from "fs";
+import path10 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,
+    // Route unmatched URLs (permalinks, admin-ajax) to index.php, not 404.
+    getFileNotFoundAction: () => ({
+      type: "internal-redirect",
+      uri: "/index.php"
+    }),
+    // Let Set-Cookie pass through to the real HTTP server (express).
+    cookieStore: false
+  });
+}
+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);
+  php.defineConstant("DISABLE_WP_CRON", true);
+}
+async function runInstaller(requestHandler) {
+  const adminUser = process.env.WP_ADMIN_USER || "admin";
+  const adminPassword = process.env.WP_ADMIN_PASSWORD || "password";
+  const adminEmail = process.env.WP_ADMIN_EMAIL || "admin@localhost.com";
+  const fields = new URLSearchParams({
+    language: "en",
+    prefix: "wp_",
+    weblog_title: "My WordPress Website",
+    user_name: adminUser,
+    admin_password: adminPassword,
+    admin_password2: adminPassword,
+    Submit: "Install WordPress",
+    pw_weak: "1",
+    admin_email: adminEmail
+  });
+  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
-import { RecommendedPHPVersion } from "@wp-playground/common";
 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 = RecommendedPHPVersion;
+var DEFAULT_PHP_VERSION = "8.3";
 var DEFAULT_WORDPRESS_VERSION = "latest";
 var DOCROOT = "/wordpress";
 
 // src/download.ts
-import fs9 from "fs";
-import path8 from "path";
+import fs10 from "fs";
+import path9 from "path";
 
-// src/wp-playground-wordpress/has-index-file.ts
+// 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+))?)?$/;
+  const classicPressPattern = /^classicpress(?:-(\d+)\.(\d+)(?:\.(\d+))?(?:-rc(?:\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
+// src/detect/get-plugin-file.ts
 import fs3 from "fs";
 import path2, { basename } from "path";
 
-// src/wp-playground-wordpress/read-file-head.ts
+// src/detect/read-file-head.ts
 import fs2 from "fs";
 function readFileHead(filePath, length = 8192) {
   const buffer = Buffer.alloc(length);
@@ -62,7 +225,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);
@@ -86,13 +249,13 @@ 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
+// src/detect/is-theme-directory.ts
 import fs4 from "fs";
 import path3 from "path";
 function isThemeDirectory(projectPath) {
@@ -105,43 +268,54 @@ function isThemeDirectory(projectPath) {
   return themeNameRegex.test(styleCSS);
 }
 
-// src/wp-playground-wordpress/is-wp-content-directory.ts
+// src/detect/is-wp-app-project.ts
 import fs5 from "fs";
 import path4 from "path";
+function isWpAppProject(projectPath) {
+  const composerJsonPath = path4.join(projectPath, "composer.json");
+  if (!fs5.existsSync(composerJsonPath)) {
+    return false;
+  }
+  try {
+    const composerJson = JSON.parse(fs5.readFileSync(composerJsonPath, "utf8"));
+    return composerJson.type === "wp-app";
+  } catch {
+    return false;
+  }
+}
+
+// src/detect/is-wp-content-directory.ts
+import fs6 from "fs";
+import path5 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"));
+  const muPluginsExists = fs6.existsSync(path5.join(projectPath, "mu-plugins"));
+  const pluginsExists = fs6.existsSync(path5.join(projectPath, "plugins"));
+  const themesExists = fs6.existsSync(path5.join(projectPath, "themes"));
   if (muPluginsExists || pluginsExists || themesExists) {
     return true;
   }
   return false;
 }
 
-// src/wp-playground-wordpress/is-wordpress-directory.ts
-import fs6 from "fs";
-import path5 from "path";
+// src/detect/is-wordpress-directory.ts
+import fs7 from "fs";
+import path6 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"));
+  return fs7.existsSync(path6.join(projectPath, "wp-content")) && fs7.existsSync(path6.join(projectPath, "wp-includes")) && fs7.existsSync(path6.join(projectPath, "wp-load.php"));
 }
 
-// src/wp-playground-wordpress/is-wordpress-develop-directory.ts
-import fs7 from "fs";
-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/detect/is-classicpress-directory.ts
+import fs8 from "fs";
+import path7 from "path";
+function isClassicPressDirectory(projectPath) {
+  if (!isWordPressDirectory(projectPath)) {
+    return false;
+  }
+  const versionFile = path7.join(projectPath, "wp-includes", "version.php");
+  if (!fs8.existsSync(versionFile)) {
+    return false;
+  }
+  return fs8.readFileSync(versionFile, "utf8").includes("classicpress_version");
 }
 
 // src/output.ts
@@ -152,24 +326,54 @@ var output = shouldOutput() ? console : null;
 
 // src/paths.ts
 import crypto from "crypto";
-import fs8 from "fs";
+import fs9 from "fs";
 import os from "os";
-import path7 from "path";
+import path8 from "path";
 function getWpAppHome() {
-  return process.env[WP_APP_HOME_ENV] || path7.join(os.homedir(), WP_APP_HIDDEN_FOLDER);
+  const home = process.env[WP_APP_HOME_ENV] || path8.join(os.homedir(), WP_APP_HIDDEN_FOLDER);
+  cleanupLegacyHome(home);
+  return home;
 }
 function getCachePath() {
-  return ensureDir(path7.join(getWpAppHome(), "cache"));
+  return ensureDir(path8.join(getWpAppHome(), "cache"));
+}
+function getCorePath(wordPressVersion) {
+  const key = wordPressVersion.replace(/[^a-zA-Z0-9.-]/g, "_");
+  return path8.join(getWpAppHome(), "core", key);
 }
 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}`);
+  const resolved = path8.resolve(projectPath);
+  const identity = process.platform === "win32" ? resolved.toLowerCase() : resolved;
+  const projectName = path8.basename(resolved);
+  const hash = crypto.createHash("sha1").update(identity).digest("hex");
+  return path8.join(getWpAppHome(), "sites", `${projectName}-${hash}`);
+}
+function getProjectLocalPath(projectPath) {
+  return path8.join(path8.resolve(projectPath), ".local", "wp-app");
 }
 function ensureDir(dir) {
-  fs8.mkdirSync(dir, { recursive: true });
+  fs9.mkdirSync(dir, { recursive: true });
   return dir;
 }
+var LEGACY_TOP_LEVEL_DIRS = [
+  "wordpress-versions",
+  "wp-content",
+  "mu-plugins",
+  "sqlite-database-integration-main"
+];
+var legacyCleanupDone = false;
+function cleanupLegacyHome(home) {
+  if (legacyCleanupDone) {
+    return;
+  }
+  legacyCleanupDone = true;
+  for (const name of LEGACY_TOP_LEVEL_DIRS) {
+    const dir = path8.join(home, name);
+    if (fs9.existsSync(dir)) {
+      fs9.rmSync(dir, { recursive: true, force: true });
+    }
+  }
+}
 
 // src/download.ts
 function getWordPressVersionUrl(version) {
@@ -188,8 +392,8 @@ function getClassicPressVersionUrl(version) {
   return `https://github.com/ClassicPress/ClassicPress-release/archive/refs/tags/${tag}.zip`;
 }
 async function cachedZip(url, cacheKey) {
-  const cacheFile = path8.join(getCachePath(), cacheKey);
-  if (!fs9.existsSync(cacheFile)) {
+  const cacheFile = path9.join(getCachePath(), cacheKey);
+  if (!fs10.existsSync(cacheFile)) {
     output?.log(`Downloading ${cacheKey}...`);
     const response = await fetch(url, { redirect: "follow" });
     if (!response.ok) {
@@ -198,11 +402,11 @@ async function cachedZip(url, cacheKey) {
       );
     }
     const bytes = Buffer.from(await response.arrayBuffer());
-    fs9.writeFileSync(`${cacheFile}.partial`, bytes);
-    fs9.renameSync(`${cacheFile}.partial`, cacheFile);
+    fs10.writeFileSync(`${cacheFile}.partial`, bytes);
+    fs10.renameSync(`${cacheFile}.partial`, cacheFile);
     output?.log(`Cached ${cacheKey} (${bytes.length} bytes).`);
   }
-  return new File([fs9.readFileSync(cacheFile)], cacheKey);
+  return new File([fs10.readFileSync(cacheFile)], cacheKey);
 }
 async function getCoreZip(version) {
   if (isClassicPressVersion(version)) {
@@ -216,43 +420,71 @@ async function getSqliteIntegrationZip() {
 
 // src/engine.ts
 async function startWPApp(options) {
-  const projectPath = path9.resolve(options.projectPath);
+  const projectPath = path10.resolve(options.projectPath);
   const mode = options.mode;
   output?.log(`directory: ${options.projectPath}`);
   output?.log(`mode: ${mode}`);
   output?.log(`php: ${options.phpVersion}`);
-  const hostDocroot = mode === "index" /* INDEX */ || mode === "wordpress" /* WORDPRESS */ ? projectPath : mode === "wordpress-develop" /* WORDPRESS_DEVELOP */ ? path9.join(projectPath, "build") : ensureDir(getSitePath(projectPath));
+  const sharesCore = mode === "wp-app" /* WP_APP */ || mode === "theme" /* THEME */ || mode === "plugin" /* PLUGIN */ || mode === "wp-content" /* WP_CONTENT */;
+  const hostDocroot = mode === "index" /* INDEX */ || mode === "wordpress" /* WORDPRESS */ || mode === "classicpress" /* CLASSICPRESS */ ? projectPath : ensureDir(getCorePath(options.wordPressVersion));
+  const projectDataRoot = sharesCore ? ensureDir(
+    mode === "wp-app" /* WP_APP */ ? getProjectLocalPath(projectPath) : getSitePath(projectPath)
+  ) : null;
   const isWordPressBacked = mode !== "index" /* INDEX */;
-  const freshSite = isWordPressBacked && !fs10.existsSync(path9.join(hostDocroot, "wp-load.php"));
+  const freshCore = isWordPressBacked && !fs11.existsSync(path10.join(hostDocroot, "wp-load.php"));
+  const freshSite = sharesCore ? !fs11.existsSync(path10.join(projectDataRoot, "database", ".ht.sqlite")) : freshCore;
   if (isWordPressBacked) {
     output?.log(`wp: ${options.wordPressVersion}`);
-    output?.log(`site data: ${hostDocroot}`);
-  }
-  const requestHandler = await bootWordPressAndRequestHandler({
-    siteUrl: options.absoluteUrl,
-    documentRoot: DOCROOT,
-    phpVersion: options.phpVersion,
-    maxPhpInstances: 1,
-    sapiName: "cli",
-    cookieStore: false,
-    createPhpRuntime: () => loadNodeRuntime(options.phpVersion, {
-      emscriptenOptions: { processId: process.pid }
-    }),
-    hooks: {
-      beforeWordPressFiles: async (php2) => {
-        php2.mkdir(DOCROOT);
-        await php2.mount(
-          DOCROOT,
-          createNodeFsMountHandler(hostDocroot)
-        );
-      }
-    },
-    wordPressZip: freshSite ? await getCoreZip(options.wordPressVersion) : void 0,
-    sqliteIntegrationPluginZip: isWordPressBacked ? await getSqliteIntegrationZip() : void 0,
-    dataSqlPath: isWordPressBacked ? `${DOCROOT}/wp-content/database/.ht.sqlite` : void 0,
-    wordpressInstallMode: isWordPressBacked ? "install-from-existing-files-if-needed" : "do-not-attempt-installing"
-  });
-  const php = await requestHandler.getPrimaryPhp();
+    output?.log(`site data: ${projectDataRoot ?? hostDocroot}`);
+  }
+  const php = await createPhp(options.phpVersion);
+  php.mkdir(DOCROOT);
+  await php.mount(DOCROOT, createNodeFsMountHandler(hostDocroot));
+  const requestHandler = createRequestHandler(
+    php,
+    DOCROOT,
+    options.absoluteUrl
+  );
+  if (freshCore) {
+    await installCore(
+      php,
+      await getCoreZip(options.wordPressVersion),
+      DOCROOT
+    );
+  }
+  if (isWordPressBacked) {
+    if (!php.fileExists(`${DOCROOT}/wp-content/db.php`)) {
+      await installSqliteIntegration(
+        php,
+        await getSqliteIntegrationZip(),
+        DOCROOT
+      );
+    }
+  }
+  if (projectDataRoot) {
+    const databaseDir = ensureDir(path10.join(projectDataRoot, "database"));
+    const uploadsDir = ensureDir(path10.join(projectDataRoot, "uploads"));
+    php.mkdir(`${DOCROOT}/wp-content/database`);
+    await php.mount(
+      `${DOCROOT}/wp-content/database`,
+      createNodeFsMountHandler(databaseDir)
+    );
+    php.mkdir(`${DOCROOT}/wp-content/uploads`);
+    await php.mount(
+      `${DOCROOT}/wp-content/uploads`,
+      createNodeFsMountHandler(uploadsDir)
+    );
+  }
+  if (isWordPressBacked) {
+    defineSiteConstants(
+      php,
+      options.absoluteUrl,
+      `${DOCROOT}/wp-content/database`
+    );
+  }
+  if (freshSite) {
+    await runInstaller(requestHandler);
+  }
   await applyProjectMounts(php, mode, projectPath);
   if (freshSite) {
     await activateProject(php, mode, projectPath);
@@ -260,8 +492,9 @@ async function startWPApp(options) {
   return { requestHandler, php, options, freshSite };
 }
 async function applyProjectMounts(php, mode, projectPath) {
-  const projectName = path9.basename(projectPath);
+  const projectName = path10.basename(projectPath);
   switch (mode) {
+    case "wp-app" /* WP_APP */:
     case "theme" /* THEME */:
       await mountAt(
         php,
@@ -277,13 +510,13 @@ async function applyProjectMounts(php, mode, projectPath) {
       );
       break;
     case "wp-content" /* WP_CONTENT */:
-      for (const entry of fs10.readdirSync(projectPath)) {
+      for (const entry of fs11.readdirSync(projectPath)) {
         if (entry === "index.php") {
           continue;
         }
         await mountAt(
           php,
-          path9.join(projectPath, entry),
+          path10.join(projectPath, entry),
           `${DOCROOT}/wp-content/${entry}`
         );
       }
@@ -293,14 +526,14 @@ async function applyProjectMounts(php, mode, projectPath) {
   }
 }
 async function mountAt(php, hostPath, vfsPath) {
-  if (fs10.statSync(hostPath).isDirectory()) {
+  if (fs11.statSync(hostPath).isDirectory()) {
     php.mkdir(vfsPath);
   }
   await php.mount(vfsPath, createNodeFsMountHandler(hostPath));
 }
 async function activateProject(php, mode, projectPath) {
-  const projectName = path9.basename(projectPath);
-  if (mode === "theme" /* THEME */) {
+  const projectName = path10.basename(projectPath);
+  if (mode === "wp-app" /* WP_APP */ || mode === "theme" /* THEME */) {
     await runWordPressCode(
       php,
       `switch_theme(${phpString(projectName)});`
@@ -327,15 +560,17 @@ async function activateProject(php, mode, projectPath) {
   }
 }
 async function runWordPressCode(php, code) {
-  const response = await php.run({
-    code: `<?php
+  try {
+    await runPhp(
+      php,
+      `
 			require ${phpString(`${DOCROOT}/wp-load.php`)};
 			require_once ${phpString(`${DOCROOT}/wp-admin/includes/plugin.php`)};
 			${code}
-		`
-  });
-  if (response.exitCode !== 0) {
-    output?.error(`Activation step failed: ${response.errors}`);
+			`
+    );
+  } catch (error) {
+    output?.error(`Activation step failed: ${error.message}`);
   }
 }
 function phpString(value) {
@@ -343,11 +578,11 @@ function phpString(value) {
 }
 function findPluginFile(projectPath) {
   const pluginNameRegex = /^(?:[ \t]*<\?php)?[ \t/*#@]*Plugin Name:(.*)$/im;
-  for (const file of fs10.readdirSync(projectPath)) {
+  for (const file of fs11.readdirSync(projectPath)) {
     if (!file.endsWith(".php")) {
       continue;
     }
-    const content = fs10.readFileSync(path9.join(projectPath, file), "utf8");
+    const content = fs11.readFileSync(path10.join(projectPath, file), "utf8");
     if (pluginNameRegex.test(content)) {
       return file;
     }
@@ -355,8 +590,10 @@ function findPluginFile(projectPath) {
   return null;
 }
 function inferMode(projectPath) {
-  if (isWordPressDevelopDirectory(projectPath)) {
-    return "wordpress-develop" /* WORDPRESS_DEVELOP */;
+  if (isWpAppProject(projectPath)) {
+    return "wp-app" /* WP_APP */;
+  } else if (isClassicPressDirectory(projectPath)) {
+    return "classicpress" /* CLASSICPRESS */;
   } else if (isWordPressDirectory(projectPath)) {
     return "wordpress" /* WORDPRESS */;
   } else if (isWpContentDirectory(projectPath)) {
@@ -368,7 +605,7 @@ function inferMode(projectPath) {
   } else if (hasIndexFile(projectPath)) {
     return "index" /* INDEX */;
   }
-  return "playground" /* PLAYGROUND */;
+  return null;
 }
 
 // src/port-finder.ts
@@ -399,11 +636,6 @@ var PortFinder = class _PortFinder {
       });
     });
   }
-  /**
-   * 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;
@@ -455,7 +687,11 @@ async function getWpAppConfig(args) {
     }
   });
   if (!options.mode || options.mode === "auto") {
-    options.mode = inferMode(options.projectPath);
+    const inferred = inferMode(options.projectPath);
+    if (!inferred) {
+      process.exit(1);
+    }
+    options.mode = inferred;
   }
   if (!options.absoluteUrl) {
     options.absoluteUrl = await getAbsoluteURL();
@@ -474,12 +710,12 @@ async function getWpAppConfig(args) {
 }
 
 // src/start-server.ts
-import fs11 from "fs";
+import fs12 from "fs";
 import { Readable } from "stream";
 import { pipeline } from "stream/promises";
 import express from "express";
 async function startServer(options = {}) {
-  if (!fs11.existsSync(options.projectPath)) {
+  if (!fs12.existsSync(options.projectPath)) {
     throw new Error(
       `The given path "${options.projectPath}" does not exist.`
     );