@wp-operations/wp-app 0.2.0 → 0.4.0

package/dist/main.js

@@ -1,59 +1,527 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/exec-command.ts
+import { execFileSync } from "child_process";
+function runCommand(command, args, options) {
+  return execFileSync(command, args, {
+    ...options,
+    shell: process.platform === "win32"
+  });
+}
+var init_exec_command = __esm({
+  "src/exec-command.ts"() {
+  }
+});
+
+// src/create.ts
+var create_exports = {};
+__export(create_exports, {
+  runCreateCommand: () => runCreateCommand
+});
+import fs14 from "fs";
+import path12 from "path";
+import readline from "readline/promises";
+async function ask(question, defaultValue = "") {
+  const suffix = defaultValue ? ` (${defaultValue})` : "";
+  const answer = (await rl.question(`? ${question}${suffix}: `)).trim();
+  return answer || defaultValue;
+}
+async function askChoice(question, choices, defaultIndex = 0) {
+  console.log(`? ${question}`);
+  choices.forEach((choice, i) => {
+    const marker = i === defaultIndex ? ">" : " ";
+    console.log(`  ${marker} ${i + 1}) ${choice}`);
+  });
+  const answer = (await rl.question(`  Choice (${defaultIndex + 1}): `)).trim();
+  const index = answer ? parseInt(answer, 10) - 1 : defaultIndex;
+  return choices[index] ?? choices[defaultIndex];
+}
+async function askPassword(question, defaultValue) {
+  if (!process.stdin.isTTY) {
+    return defaultValue;
+  }
+  process.stdout.write(`? ${question} (${defaultValue}): `);
+  return new Promise((resolve) => {
+    let value = "";
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.setEncoding("utf8");
+    const onData = (char) => {
+      if (char === "\r" || char === "\n") {
+        process.stdin.setRawMode(false);
+        process.stdin.pause();
+        process.stdin.removeListener("data", onData);
+        process.stdout.write("\n");
+        resolve(value || defaultValue);
+      } else if (char === CTRL_C) {
+        process.stdin.setRawMode(false);
+        process.exit(1);
+      } else if (char === BACKSPACE_DEL || char === BACKSPACE_BS) {
+        if (value.length > 0) {
+          value = value.slice(0, -1);
+          process.stdout.write("\b \b");
+        }
+      } else if (char.charCodeAt(0) >= 32) {
+        value += char;
+        process.stdout.write("*");
+      }
+    };
+    process.stdin.on("data", onData);
+  });
+}
+function toPascalCase(value) {
+  return value.split(/[^a-zA-Z0-9]+/).filter(Boolean).map((word) => word[0].toUpperCase() + word.slice(1)).join("");
+}
+async function collectAnswers() {
+  const projectName = await ask("Project name", "my-app");
+  const author = await ask("Author (composer vendor)", "my-name");
+  const cssTool = (await askChoice("CSS tooling", ["Tailwind", "SCSS"], 0)).toLowerCase().startsWith("tailwind") ? "tailwind" : "scss";
+  const npmPackagesRaw = await ask(
+    "npm packages (comma-separated, optional)"
+  );
+  const composerPackagesRaw = await ask(
+    "composer packages (comma-separated, optional)"
+  );
+  const adminUser = await ask("Admin username", "admin");
+  const adminPassword = await askPassword("Admin password", "password");
+  return {
+    projectName,
+    author,
+    cssTool,
+    npmPackages: splitList(npmPackagesRaw),
+    composerPackages: splitList(composerPackagesRaw),
+    adminUser,
+    adminPassword
+  };
+}
+function splitList(value) {
+  return value.split(",").map((entry) => entry.trim()).filter(Boolean);
+}
+function printPreview(answers) {
+  console.log("\nReview:");
+  console.log(`  1) Project name:        ${answers.projectName}`);
+  console.log(`  2) Author:               ${answers.author}`);
+  console.log(`  3) CSS tooling:          ${answers.cssTool}`);
+  console.log(
+    `  4) npm packages:         ${answers.npmPackages.join(", ") || "(none)"}`
+  );
+  console.log(
+    `  5) composer packages:    ${answers.composerPackages.join(", ") || "(none)"}`
+  );
+  console.log(`  6) Admin username:       ${answers.adminUser}`);
+  console.log(`  7) Admin password:       ${"*".repeat(answers.adminPassword.length)}`);
+}
+async function editAnswers(answers) {
+  for (; ; ) {
+    printPreview(answers);
+    const choice = await ask(
+      "Edit a field (number), or press enter to confirm"
+    );
+    if (!choice) {
+      return answers;
+    }
+    switch (choice) {
+      case "1":
+        answers.projectName = await ask("Project name", answers.projectName);
+        break;
+      case "2":
+        answers.author = await ask("Author (composer vendor)", answers.author);
+        break;
+      case "3":
+        answers.cssTool = (await askChoice(
+          "CSS tooling",
+          ["Tailwind", "SCSS"],
+          answers.cssTool === "tailwind" ? 0 : 1
+        )).toLowerCase().startsWith("tailwind") ? "tailwind" : "scss";
+        break;
+      case "4":
+        answers.npmPackages = splitList(
+          await ask(
+            "npm packages (comma-separated, optional)",
+            answers.npmPackages.join(", ")
+          )
+        );
+        break;
+      case "5":
+        answers.composerPackages = splitList(
+          await ask(
+            "composer packages (comma-separated, optional)",
+            answers.composerPackages.join(", ")
+          )
+        );
+        break;
+      case "6":
+        answers.adminUser = await ask("Admin username", answers.adminUser);
+        break;
+      case "7":
+        answers.adminPassword = await askPassword(
+          "Admin password",
+          answers.adminPassword
+        );
+        break;
+      default:
+        console.log("Not a valid field number.");
+    }
+  }
+}
+function scaffoldFiles(dir, answers) {
+  const namespace = toPascalCase(answers.author) + "\\" + toPascalCase(answers.projectName);
+  fs14.mkdirSync(path12.join(dir, "src", "js"), { recursive: true });
+  fs14.mkdirSync(path12.join(dir, "assets", "css"), { recursive: true });
+  fs14.mkdirSync(path12.join(dir, "assets", "js"), { recursive: true });
+  writeJson(path12.join(dir, "composer.json"), {
+    name: `${answers.author}/${answers.projectName}`,
+    type: "wp-app",
+    license: "proprietary",
+    require: { php: ">=8.0" },
+    autoload: { "psr-4": { [`${namespace}\\`]: "src/php/" } }
+  });
+  const cssDeps = answers.cssTool === "tailwind" ? { tailwindcss: "^4.3.0", "@tailwindcss/cli": "^4.3.0" } : { sass: "^1.103.0" };
+  const cssBuild = answers.cssTool === "tailwind" ? "tailwindcss -i src/css/main.css -o assets/css/main.css --minify" : "sass src/css/main.scss assets/css/main.css --style=compressed";
+  const cssWatch = answers.cssTool === "tailwind" ? "tailwindcss -i src/css/main.css -o assets/css/main.css --watch" : "sass src/css/main.scss assets/css/main.css --watch";
+  writeJson(path12.join(dir, "package.json"), {
+    name: answers.projectName,
+    private: true,
+    scripts: {
+      "build:css": cssBuild,
+      "watch:css": cssWatch,
+      "build:js": "esbuild src/js/main.js --bundle --minify --outfile=assets/js/main.js",
+      "watch:js": "esbuild src/js/main.js --bundle --outfile=assets/js/main.js --watch",
+      build: "npm run build:css && npm run build:js"
+    },
+    devDependencies: { esbuild: "^0.28.0", ...cssDeps }
+  });
+  fs14.writeFileSync(
+    path12.join(dir, ".env"),
+    `WP_ADMIN_USER=${answers.adminUser}
+WP_ADMIN_PASSWORD=${answers.adminPassword}
+`
+  );
+  fs14.writeFileSync(
+    path12.join(dir, "style.css"),
+    `/*
+Theme Name: ${answers.projectName}
+Author: ${answers.author}
+Version: 0.1.0
+*/
+`
+  );
+  fs14.writeFileSync(
+    path12.join(dir, "functions.php"),
+    `<?php
+declare(strict_types=1);
+
+$autoload = __DIR__ . '/vendor/autoload.php';
+if (file_exists($autoload)) {
+	require_once $autoload;
+}
+
+add_action('wp_enqueue_scripts', function (): void {
+	wp_enqueue_style('${answers.projectName}', get_stylesheet_directory_uri() . '/assets/css/main.css');
+	wp_enqueue_script('${answers.projectName}', get_stylesheet_directory_uri() . '/assets/js/main.js', [], false, true);
+});
+`
+  );
+  fs14.writeFileSync(
+    path12.join(dir, "index.php"),
+    `<?php
+declare(strict_types=1);
+get_header();
+while (have_posts()) : the_post();
+	the_content();
+endwhile;
+get_footer();
+`
+  );
+  const cssEntry = answers.cssTool === "tailwind" ? '@import "tailwindcss";\n' : "// entry stylesheet\n";
+  fs14.mkdirSync(path12.join(dir, "src", "css"), { recursive: true });
+  fs14.writeFileSync(
+    path12.join(
+      dir,
+      "src",
+      "css",
+      answers.cssTool === "tailwind" ? "main.css" : "main.scss"
+    ),
+    cssEntry
+  );
+  fs14.writeFileSync(path12.join(dir, "src", "js", "main.js"), "// entry script\n");
+  fs14.mkdirSync(path12.join(dir, "src", "php"), { recursive: true });
+}
+function writeJson(filePath, data) {
+  fs14.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n");
+}
+async function runCreateCommand(targetPath) {
+  const dir = path12.resolve(targetPath);
+  fs14.mkdirSync(dir, { recursive: true });
+  let answers = await collectAnswers();
+  answers = await editAnswers(answers);
+  rl.close();
+  scaffoldFiles(dir, answers);
+  const run = (cmd, args) => runCommand(cmd, args, { cwd: dir, stdio: "inherit" });
+  if (answers.npmPackages.length) {
+    console.log("Installing additional npm packages...");
+    run("npm", ["install", "--save", ...answers.npmPackages]);
+  } else {
+    console.log("Installing npm dependencies...");
+    run("npm", ["install"]);
+  }
+  if (answers.composerPackages.length) {
+    console.log("Requiring additional composer packages...");
+    run("composer", ["require", ...answers.composerPackages]);
+  } else {
+    console.log("Installing composer dependencies...");
+    try {
+      run("composer", ["install"]);
+    } catch {
+      console.log("(composer not available or nothing to install yet \u2014 skipped)");
+    }
+  }
+  console.log(`
+Done. cd ${targetPath} && wp-app start`);
+}
+var rl, CTRL_C, BACKSPACE_DEL, BACKSPACE_BS;
+var init_create = __esm({
+  "src/create.ts"() {
+    init_exec_command();
+    rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    CTRL_C = "";
+    BACKSPACE_DEL = "\x7F";
+    BACKSPACE_BS = "\b";
+  }
+});
+
 // src/run-cli.ts
-import fs13 from "fs";
-import path11 from "path";
-import yargs from "yargs";
-import { hideBin } from "yargs/helpers";
+init_exec_command();
+import fs15 from "fs";
+import path13 from "path";
+import { parseArgs } from "util";
 import { spawn, execSync } from "child_process";
 
 // 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";
 
 // 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);
@@ -64,7 +532,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);
@@ -88,13 +556,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) {
@@ -107,43 +575,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
@@ -154,24 +633,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) {
@@ -190,8 +699,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) {
@@ -200,11 +709,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)) {
@@ -255,11 +764,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;
@@ -311,7 +815,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();
@@ -331,43 +839,71 @@ async function getWpAppConfig(args) {
 
 // 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);
@@ -375,8 +911,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,
@@ -392,13 +929,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}`
         );
       }
@@ -408,14 +945,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)});`
@@ -442,15 +979,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) {
@@ -458,11 +997,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;
     }
@@ -470,8 +1009,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)) {
@@ -483,12 +1024,12 @@ function inferMode(projectPath) {
   } else if (hasIndexFile(projectPath)) {
     return "index" /* INDEX */;
   }
-  return "playground" /* PLAYGROUND */;
+  return null;
 }
 
 // src/start-server.ts
 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.`
     );
@@ -559,23 +1100,23 @@ var parseHeaders = (req) => {
 };
 
 // src/execute-php.ts
-import fs12 from "fs";
-import path10 from "path";
+import fs13 from "fs";
+import path11 from "path";
 import { loadNodeRuntime as loadNodeRuntime2 } from "@php-wasm/node";
-import { PHP } from "@php-wasm/universal";
+import { PHP as PHP2 } from "@php-wasm/universal";
 async function executePHP(phpArgs, options) {
   const args = phpArgs.filter((arg) => arg !== "php" && arg !== "--");
   let code;
   if (args[0] === "-r" && typeof args[1] === "string") {
     code = `<?php ${args[1]}`;
-  } else if (args[0] && fs12.existsSync(path10.resolve(args[0]))) {
-    code = fs12.readFileSync(path10.resolve(args[0]), "utf8");
+  } else if (args[0] && fs13.existsSync(path11.resolve(args[0]))) {
+    code = fs13.readFileSync(path11.resolve(args[0]), "utf8");
   } else {
     throw new Error(
       'Usage: wp-app php -- -r "<code>" | wp-app php -- <script.php>'
     );
   }
-  const php = new PHP(
+  const php = new PHP2(
     await loadNodeRuntime2(options.phpVersion, {
       emscriptenOptions: { processId: process.pid }
     })
@@ -591,14 +1132,42 @@ async function executePHP(phpArgs, options) {
 // src/run-cli.ts
 var MODE_CHOICES = [
   "auto",
+  "wp-app",
   "plugin",
   "theme",
   "wordpress",
-  "wordpress-develop",
+  "classicpress",
   "wp-content",
-  "index",
-  "playground"
+  "index"
 ];
+var SERVER_OPTIONS = {
+  path: { type: "string" },
+  php: { type: "string" },
+  wp: { type: "string" },
+  port: { type: "string" },
+  mode: { type: "string" }
+};
+var HELP = `wp-app <command> [args]
+
+Commands:
+  wp-app start    Start the server
+  wp-app php      Run the php command passing the arguments to php cli
+  wp-app build    Regenerate the composer autoloader (if vendor/ exists) and run the npm build script, when present
+  wp-app dev      Start the server; watch CSS/JS source files and rebuild + refresh on change
+  wp-app install  Run npm install and composer install
+  wp-app update   Run composer update (optionally scoped to specific packages)
+  wp-app create   Scaffold a new wp-app project
+
+Options:
+  --path=<dir>   Path to the PHP or WordPress project. Defaults to the current working directory.
+  --php=<ver>    PHP version to use.
+  --wp=<ver>     WordPress version to use, e.g. '--wp=6.4'. Use '--wp=classicpress' for ClassicPress.
+  --port=<n>     Server port
+  --mode=<mode>  Project mode (${MODE_CHOICES.join("|")}). Defaults to auto-detection.
+  --reset        (start) Create a new site environment, destroying the old one.
+  --no-open      (start/dev) Don't open the site in the default browser.
+  -h, --help     Show this help
+`;
 function startSpinner(message) {
   process.stdout.write(`${message}...
 `);
@@ -611,218 +1180,219 @@ function startSpinner(message) {
     }
   };
 }
-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 fail(message) {
+  console.error(`wp-app: ${message}
+`);
+  console.error(HELP);
+  process.exit(1);
 }
-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
-  });
+function hasNegatedFlag(args, flag) {
+  return args.includes(`--no-${flag}`);
 }
 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 rawArgs = process.argv.slice(2);
+  if (rawArgs.includes("-h") || rawArgs.includes("--help")) {
+    console.log(HELP);
+    return;
+  }
+  const command = rawArgs[0];
+  if (!command || command.startsWith("-")) {
+    fail("You must provide a valid command");
+  }
+  if (command === "php") {
+    return runPhpCommand(rawArgs);
+  }
+  if (command === "create") {
+    const { runCreateCommand: runCreateCommand2 } = await Promise.resolve().then(() => (init_create(), create_exports));
+    const target = rawArgs[1] || ".";
+    return runCreateCommand2(target);
+  }
+  const { values } = parseArgs({
+    args: rawArgs.slice(1),
+    options: { ...SERVER_OPTIONS, reset: { type: "boolean" } },
+    allowPositionals: true,
+    strict: false
+  });
+  if (command === "install") {
+    return runInstallCommand(values);
+  }
+  if (command === "update") {
+    return runUpdateCommand(values, rawArgs);
+  }
+  if (values.mode && !MODE_CHOICES.includes(values.mode)) {
+    fail(
+      `Invalid mode "${values.mode}". Choices: ${MODE_CHOICES.join(", ")}`
+    );
+  }
+  const config = {
+    php: values.php,
+    path: values.path
+  };
+  config.wp = values.wp;
+  config.port = values.port ? Number(values.port) : void 0;
+  config.mode = values.mode;
+  try {
+    await getWpAppConfig(config);
+  } catch (error) {
+    fail(error.message);
+  }
+  switch (command) {
+    case "start":
+      return runStartCommand(values, rawArgs);
+    case "build":
+      return runBuildCommand(values);
+    case "dev":
+      return runDevCommand(values, rawArgs);
+    default:
+      fail(`Unknown command "${command}"`);
+  }
+}
+async function runStartCommand(values, rawArgs) {
+  const spinner = startSpinner("Starting the server...");
+  try {
+    const options = await getWpAppConfig({
+      path: values.path,
+      php: values.php,
+      wp: values.wp,
+      port: values.port ? Number(values.port) : void 0,
+      mode: values.mode
+    });
+    portFinder.setPort(options.port);
+    if (values.reset) {
+      if (["wordpress", "classicpress", "index"].includes(
+        options.mode
+      )) {
+        output?.log(
+          "--reset only applies to wp-app managed sites; your project files are never touched."
+        );
+      } else {
+        fs15.rmSync(getSitePath(options.projectPath), {
+          recursive: true,
+          force: true,
+          maxRetries: 10,
+          retryDelay: 100
+        });
+        output?.log("Site environment reset.");
+      }
     }
-    const config = {
-      php: argv.php,
-      path: argv.path
-    };
-    if (argv._[0] !== "php") {
-      config.wp = argv.wp;
-      config.port = argv.port;
-      config.mode = argv.mode;
+    const { url } = await startServer(options);
+    if (!hasNegatedFlag(rawArgs, "open")) {
+      openInDefaultBrowser(url);
     }
+  } catch (error) {
+    output?.error(error);
+    spinner.fail(`Failed to start the server: ${error.message}`);
+  }
+}
+async function runPhpCommand(rawArgs) {
+  const args = rawArgs.slice(1);
+  const pathIndex = args.findIndex((arg) => arg.startsWith("--path="));
+  const phpIndex = args.findIndex((arg) => arg.startsWith("--php="));
+  try {
+    const options = await getWpAppConfig({
+      path: pathIndex >= 0 ? args[pathIndex].split("=")[1] : void 0,
+      php: phpIndex >= 0 ? args[phpIndex].split("=")[1] : void 0
+    });
+    const phpArgs = args.filter(
+      (arg, i) => i !== pathIndex && i !== phpIndex
+    );
+    await executePHP(phpArgs, options);
+    process.exit(0);
+  } catch (error) {
+    console.error(error);
+    process.exit(error.status || -1);
+  }
+}
+async function runBuildCommand(values) {
+  const projectPath = values.path ? path13.resolve(values.path) : process.cwd();
+  if (fs15.existsSync(path13.join(projectPath, "vendor"))) {
     try {
-      await getWpAppConfig(config);
+      execSync("composer dump-autoload --optimize --classmap-authoritative", {
+        cwd: projectPath,
+        stdio: "inherit"
+      });
     } catch (error) {
-      return error.message;
+      console.error(
+        `composer dump-autoload failed: ${error.message}`
+      );
     }
-    return true;
-  }).command(
-    "start",
-    "Start the server",
-    (yargs2) => {
-      serverParameters(yargs2);
-      yargs2.option("reset", {
-        describe: "Create a new site environment, destroying the old one (WordPress files 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 getWpAppConfig({
-          path: argv.path,
-          php: argv.php,
-          wp: argv.wp,
-          port: argv.port,
-          mode: argv.mode
-        });
-        portFinder.setPort(options.port);
-        if (argv.reset) {
-          if (["wordpress", "wordpress-develop", "index"].includes(
-            options.mode
-          )) {
-            output?.log(
-              "--reset only applies to wp-app managed sites; your project files are never touched."
-            );
-          } else {
-            fs13.rmSync(getSitePath(options.projectPath), {
-              recursive: true,
-              force: true,
-              maxRetries: 10,
-              retryDelay: 100
-            });
-            output?.log("Site 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}`
-        );
-      }
+  }
+  const packageJsonPath = path13.join(projectPath, "package.json");
+  if (fs15.existsSync(packageJsonPath)) {
+    const pkg = JSON.parse(fs15.readFileSync(packageJsonPath, "utf8"));
+    if (pkg.scripts?.build) {
+      execSync("npm run build", { cwd: projectPath, stdio: "inherit" });
     }
-  ).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 getWpAppConfig({
-          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);
-      }
+  }
+  console.log("Build complete.");
+}
+async function runInstallCommand(values) {
+  const projectPath = values.path ? path13.resolve(values.path) : process.cwd();
+  if (fs15.existsSync(path13.join(projectPath, "package.json"))) {
+    execSync("npm install", { cwd: projectPath, stdio: "inherit" });
+  }
+  if (fs15.existsSync(path13.join(projectPath, "composer.json"))) {
+    execSync("composer install", { cwd: projectPath, stdio: "inherit" });
+  }
+}
+async function runUpdateCommand(values, rawArgs) {
+  const projectPath = values.path ? path13.resolve(values.path) : process.cwd();
+  const packages = rawArgs.slice(1).filter((arg) => !arg.startsWith("--"));
+  const args = ["update", ...packages];
+  runCommand("composer", args, { cwd: projectPath, stdio: "inherit" });
+}
+var WATCHED_EXTENSIONS = [".css", ".scss", ".js", ".ts", ".jsx", ".tsx"];
+var IGNORED_DIRS = ["node_modules", "vendor", ".git", "dist", "assets"];
+async function runDevCommand(values, rawArgs) {
+  const projectPath = path13.resolve(values.path || process.cwd());
+  const spinner = startSpinner("Starting the server...");
+  try {
+    const options = await getWpAppConfig({
+      path: values.path,
+      php: values.php,
+      wp: values.wp,
+      port: values.port ? Number(values.port) : void 0,
+      mode: values.mode
+    });
+    portFinder.setPort(options.port);
+    const { url } = await startServer(options);
+    if (!hasNegatedFlag(rawArgs, "open")) {
+      openInDefaultBrowser(url);
     }
-  ).command(
-    "build",
-    "Build the project: composer install plus the npm build script, when present",
-    (yargs2) => {
-      commonParameters(yargs2);
-    },
-    async (argv) => {
-      const projectPath = argv.path ? path11.resolve(argv.path) : process.cwd();
-      console.log(`Building project at ${projectPath}`);
-      if (fs13.existsSync(path11.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 = path11.join(projectPath, "package.json");
-      if (fs13.existsSync(packageJsonPath)) {
-        const pkg = JSON.parse(
-          fs13.readFileSync(packageJsonPath, "utf8")
-        );
-        if (pkg.scripts?.build) {
-          console.log("Running npm build...");
-          execSync("npm run build", {
-            cwd: projectPath,
-            stdio: "inherit"
-          });
-        }
-      }
-      console.log("Build complete.");
+  } catch (error) {
+    output?.error(error);
+    spinner.fail(`Failed to start the server: ${error.message}`);
+    return;
+  }
+  const packageJsonPath = path13.join(projectPath, "package.json");
+  const hasBuildScript = fs15.existsSync(packageJsonPath) && JSON.parse(fs15.readFileSync(packageJsonPath, "utf8")).scripts?.build;
+  if (!hasBuildScript) {
+    console.log("Dev mode: no npm build script found, nothing to watch.");
+    return;
+  }
+  let rebuildTimer = null;
+  const rebuild = (filename) => {
+    console.log(`Change detected: ${filename}. Rebuilding...`);
+    try {
+      execSync("npm run build", { cwd: projectPath, stdio: "inherit" });
+      console.log("Rebuild complete. Refresh your browser to see changes.");
+    } catch (error) {
+      console.error(`Rebuild failed: ${error.message}`);
     }
-  ).command(
-    "dev",
-    "Start the server and restart it when project files change",
-    (yargs2) => {
-      serverParameters(yargs2);
-    },
-    async (argv) => {
-      const selfScript = process.argv[1];
-      const watchDir = path11.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();
-      fs13.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...");
+  };
+  fs15.watch(projectPath, { recursive: true }, (_eventType, filename) => {
+    if (!filename) return;
+    const parts = filename.split(/[\\/]/);
+    if (parts.some((part) => IGNORED_DIRS.includes(part) || part.startsWith("."))) {
+      return;
     }
-  ).demandCommand(1, "You must provide a valid command").help().alias("h", "help").strict().argv;
+    if (!WATCHED_EXTENSIONS.includes(path13.extname(filename))) {
+      return;
+    }
+    if (rebuildTimer) clearTimeout(rebuildTimer);
+    rebuildTimer = setTimeout(() => rebuild(filename), 300);
+  });
+  console.log("Dev mode: watching CSS/JS source files for changes...");
 }
 function openInDefaultBrowser(url) {
   if (isGitHubCodespace) {
@@ -859,4 +1429,8 @@ if (currentNodeVersion < requiredMajorVersion) {
     `You are running Node.js version ${currentNodeVersion}, but this application requires at least Node.js ${requiredMajorVersion}. Please upgrade your Node.js version.`
   );
 }
+try {
+  process.loadEnvFile();
+} catch {
+}
 runCli();