@wp-playground/cli 3.0.40 → 3.0.42

package/run-cli-NcKUE5gJ.js

@@ -0,0 +1,1543 @@
+import { logger as g, LogSeverity as j, errorLogPath as ee } from "@php-wasm/logger";
+import { PHPResponse as Y, consumeAPI as F, SupportedPHPVersions as te, printDebugDetails as ye, exposeAPI as be, exposeSyncAPI as ve } from "@php-wasm/universal";
+import { resolveRemoteBlueprint as Pe, resolveRuntimeConfiguration as re, compileBlueprintV1 as Se, isBlueprintBundle as xe, runBlueprintV1Steps as ke } from "@wp-playground/blueprints";
+import { zipDirectory as Ie, RecommendedPHPVersion as U } from "@wp-playground/common";
+import p, { existsSync as X, rmdirSync as $e, mkdirSync as z, readdirSync as Te } from "fs";
+import { MessageChannel as Be, Worker as oe } from "worker_threads";
+import { createNodeFsMountHandler as Ee, FileLockManagerForNode as Le } from "@php-wasm/node";
+import h, { basename as A, join as ue } from "path";
+import We from "express";
+import O, { cpus as Ce } from "os";
+import { jspi as Me } from "wasm-feature-detect";
+import Re from "yargs";
+import { NodeJsFilesystem as De, OverlayFilesystem as Ae, InMemoryFilesystem as Fe, ZipFilesystem as Ue } from "@wp-playground/storage";
+import { EmscriptenDownloadMonitor as Oe, ProgressTracker as He } from "@php-wasm/progress";
+import { resolveWordPressRelease as Ve } from "@wp-playground/wordpress";
+import B from "fs-extra";
+import { startBridge as Ne } from "@php-wasm/xdebug-bridge";
+import { exec as je } from "child_process";
+import { dir as _e, setGracefulCleanup as qe } from "tmp-promise";
+import Ye from "ps-man";
+import { removeTempDirSymlink as ze, createTempDirSymlink as Qe, clearXdebugIDEConfig as Xe, addXdebugIDEConfig as Ze } from "@php-wasm/cli-util";
+import { createHash as Ge } from "crypto";
+function _(e) {
+  const t = [];
+  for (const r of e) {
+    const s = r.split(":");
+    if (s.length !== 2)
+      throw new Error(`Invalid mount format: ${r}.
+				Expected format: /host/path:/vfs/path.
+				If your path contains a colon, e.g. C:\\myplugin, use the --mount-dir option instead.
+				Example: --mount-dir C:\\my-plugin /wordpress/wp-content/plugins/my-plugin`);
+    const [o, i] = s;
+    if (!X(o))
+      throw new Error(`Host path does not exist: ${o}`);
+    t.push({ hostPath: o, vfsPath: i });
+  }
+  return t;
+}
+function se(e) {
+  if (e.length % 2 !== 0)
+    throw new Error("Invalid mount format. Expected: /host/path /vfs/path");
+  const t = [];
+  for (let r = 0; r < e.length; r += 2) {
+    const s = e[r], o = e[r + 1];
+    if (!X(s))
+      throw new Error(`Host path does not exist: ${s}`);
+    t.push({
+      hostPath: h.resolve(process.cwd(), s),
+      vfsPath: o
+    });
+  }
+  return t;
+}
+async function Gt(e, t) {
+  for (const r of t)
+    await e.mount(
+      r.vfsPath,
+      Ee(r.hostPath)
+    );
+}
+const ie = {
+  step: "runPHP",
+  code: {
+    filename: "activate-theme.php",
+    // @TODO: Remove DOCROOT check after moving totally to Blueprints v2.
+    content: `<?php
+			$docroot = getenv('DOCROOT') ? getenv('DOCROOT') : '/wordpress';
+			require_once "$docroot/wp-load.php";
+			$theme = wp_get_theme();
+			if (!$theme->exists()) {
+				$themes = wp_get_themes();
+				if (count($themes) > 0) {
+					$themeName = array_keys($themes)[0];
+					switch_theme($themeName);
+				}
+			}
+		`
+  }
+};
+function de(e) {
+  const t = e.autoMount, r = [...e.mount || []], s = [...e["mount-before-install"] || []], o = {
+    ...e,
+    mount: r,
+    "mount-before-install": s,
+    "additional-blueprint-steps": [
+      ...e["additional-blueprint-steps"] || []
+    ]
+  };
+  if (tt(t)) {
+    const n = `/wordpress/wp-content/plugins/${A(t)}`;
+    r.push({
+      hostPath: t,
+      vfsPath: n,
+      autoMounted: !0
+    }), o["additional-blueprint-steps"].push({
+      step: "activatePlugin",
+      pluginPath: `/wordpress/wp-content/plugins/${A(t)}`
+    });
+  } else if (et(t)) {
+    const i = A(t), n = `/wordpress/wp-content/themes/${i}`;
+    r.push({
+      hostPath: t,
+      vfsPath: n,
+      autoMounted: !0
+    }), o["additional-blueprint-steps"].push(
+      e["experimental-blueprints-v2-runner"] ? {
+        step: "activateTheme",
+        themeDirectoryName: i
+      } : {
+        step: "activateTheme",
+        themeFolderName: i
+      }
+    );
+  } else if (Ke(t)) {
+    const i = p.readdirSync(t);
+    for (const n of i)
+      n !== "index.php" && r.push({
+        hostPath: `${t}/${n}`,
+        vfsPath: `/wordpress/wp-content/${n}`,
+        autoMounted: !0
+      });
+    o["additional-blueprint-steps"].push(ie);
+  } else Je(t) && (s.push({
+    hostPath: t,
+    vfsPath: "/wordpress",
+    autoMounted: !0
+  }), o.mode = "apply-to-existing-site", o["additional-blueprint-steps"].push(ie), o.wordpressInstallMode || (o.wordpressInstallMode = "install-from-existing-files-if-needed"));
+  return o;
+}
+function Je(e) {
+  const t = p.readdirSync(e);
+  return t.includes("wp-admin") && t.includes("wp-includes") && t.includes("wp-content");
+}
+function Ke(e) {
+  const t = p.readdirSync(e);
+  return t.includes("themes") || t.includes("plugins") || t.includes("mu-plugins") || t.includes("uploads");
+}
+function et(e) {
+  if (!p.readdirSync(e).includes("style.css"))
+    return !1;
+  const r = p.readFileSync(ue(e, "style.css"), "utf8");
+  return !!/^(?:[ \t]*<\?php)?[ \t/*#@]*Theme Name:(.*)$/im.exec(r);
+}
+function tt(e) {
+  const t = p.readdirSync(e), r = /^(?:[ \t]*<\?php)?[ \t/*#@]*Plugin Name:(.*)$/im;
+  return !!t.filter((o) => o.endsWith(".php")).find((o) => {
+    const i = p.readFileSync(ue(e, o), "utf8");
+    return !!r.exec(i);
+  });
+}
+async function rt(e) {
+  const t = We(), r = await new Promise((i, n) => {
+    const l = t.listen(e.port, () => {
+      const u = l.address();
+      u === null || typeof u == "string" ? n(new Error("Server address is not available")) : i(l);
+    });
+  });
+  t.use("/", async (i, n) => {
+    let l;
+    try {
+      l = await e.handleRequest({
+        url: i.url,
+        headers: st(i),
+        method: i.method,
+        body: await ot(i)
+      });
+    } catch (u) {
+      g.error(u), l = Y.forHttpCode(500);
+    }
+    n.statusCode = l.httpStatusCode;
+    for (const u in l.headers)
+      n.setHeader(u, l.headers[u]);
+    n.end(l.bytes);
+  });
+  const o = r.address().port;
+  return await e.onBind(r, o);
+}
+const ot = async (e) => await new Promise((t) => {
+  const r = [];
+  e.on("data", (s) => {
+    r.push(s);
+  }), e.on("end", () => {
+    t(new Uint8Array(Buffer.concat(r)));
+  });
+}), st = (e) => {
+  const t = {};
+  if (e.rawHeaders && e.rawHeaders.length)
+    for (let r = 0; r < e.rawHeaders.length; r += 2)
+      t[e.rawHeaders[r].toLowerCase()] = e.rawHeaders[r + 1];
+  return t;
+};
+class it {
+  constructor(t) {
+    this.workerLoads = [], this.addWorker(t);
+  }
+  addWorker(t) {
+    this.workerLoads.push({
+      worker: t,
+      activeRequests: /* @__PURE__ */ new Set()
+    });
+  }
+  async removeWorker(t) {
+    const r = this.workerLoads.findIndex(
+      (o) => o.worker === t
+    );
+    if (r === -1)
+      return;
+    const [s] = this.workerLoads.splice(r, 1);
+    await Promise.allSettled(s.activeRequests);
+  }
+  async handleRequest(t) {
+    let r = this.workerLoads[0];
+    for (let o = 1; o < this.workerLoads.length; o++) {
+      const i = this.workerLoads[o];
+      i.activeRequests.size < r.activeRequests.size && (r = i);
+    }
+    const s = r.worker.request(t);
+    return r.activeRequests.add(s), s.url = t.url, s.finally(() => {
+      r.activeRequests.delete(s);
+    });
+  }
+}
+function nt(e) {
+  return /^latest$|^trunk$|^nightly$|^(?:(\d+)\.(\d+)(?:\.(\d+))?)((?:-beta(?:\d+)?)|(?:-RC(?:\d+)?))?$/.test(e);
+}
+async function at({
+  sourceString: e,
+  blueprintMayReadAdjacentFiles: t
+}) {
+  if (!e)
+    return;
+  if (e.startsWith("http://") || e.startsWith("https://"))
+    return await Pe(e);
+  let r = h.resolve(process.cwd(), e);
+  if (!p.existsSync(r))
+    throw new Error(`Blueprint file does not exist: ${r}`);
+  const s = p.statSync(r);
+  if (s.isDirectory() && (r = h.join(r, "blueprint.json")), !s.isFile() && s.isSymbolicLink())
+    throw new Error(
+      `Blueprint path is neither a file nor a directory: ${r}`
+    );
+  const o = h.extname(r);
+  switch (o) {
+    case ".zip":
+      return Ue.fromArrayBuffer(
+        p.readFileSync(r).buffer
+      );
+    case ".json": {
+      const i = p.readFileSync(r, "utf-8");
+      try {
+        JSON.parse(i);
+      } catch {
+        throw new Error(
+          `Blueprint file at ${r} is not a valid JSON file`
+        );
+      }
+      const n = h.dirname(r), l = new De(n);
+      return new Ae([
+        new Fe({
+          "blueprint.json": i
+        }),
+        /**
+         * Wrap the NodeJS filesystem to prevent access to local files
+         * unless the user explicitly allowed it.
+         */
+        {
+          read(u) {
+            if (!t)
+              throw new Error(
+                `Error: Blueprint contained tried to read a local file at path "${u}" (via a resource of type "bundled"). Playground restricts access to local resources by default as a security measure. 
+
+You can allow this Blueprint to read files from the same parent directory by explicitly adding the --blueprint-may-read-adjacent-files option to your command.`
+              );
+            return l.read(u);
+          }
+        }
+      ]);
+    }
+    default:
+      throw new Error(
+        `Unsupported blueprint file extension: ${o}. Only .zip and .json files are supported.`
+      );
+  }
+}
+class lt {
+  constructor(t, r) {
+    this.args = t, this.siteUrl = r.siteUrl, this.processIdSpaceLength = r.processIdSpaceLength, this.phpVersion = t.php, this.cliOutput = r.cliOutput;
+  }
+  getWorkerType() {
+    return "v2";
+  }
+  async bootAndSetUpInitialPlayground(t, r, s) {
+    const o = F(t);
+    await o.useFileLockManager(r);
+    const i = {
+      ...this.args,
+      phpVersion: this.phpVersion,
+      siteUrl: this.siteUrl,
+      firstProcessId: 1,
+      processIdSpaceLength: this.processIdSpaceLength,
+      trace: this.args.verbosity === "debug",
+      blueprint: this.args.blueprint,
+      withIntl: this.args.intl,
+      // We do not enable Xdebug by default for the initial worker
+      // because we do not imagine users expect to hit breakpoints
+      // until Playground has fully booted.
+      // TODO: Consider supporting Xdebug for the initial worker via a dedicated flag.
+      withXdebug: !1,
+      xdebug: void 0,
+      nativeInternalDirPath: s,
+      mountsBeforeWpInstall: this.args["mount-before-install"] || [],
+      mountsAfterWpInstall: this.args.mount || []
+    };
+    return await o.bootAndSetUpInitialWorker(i), o;
+  }
+  async bootPlayground({
+    worker: t,
+    fileLockManagerPort: r,
+    firstProcessId: s,
+    nativeInternalDirPath: o
+  }) {
+    const i = F(t.phpPort);
+    await i.useFileLockManager(r);
+    const n = {
+      ...this.args,
+      phpVersion: this.phpVersion,
+      siteUrl: this.siteUrl,
+      firstProcessId: s,
+      processIdSpaceLength: this.processIdSpaceLength,
+      trace: this.args.verbosity === "debug",
+      withIntl: this.args.intl,
+      withXdebug: !!this.args.xdebug,
+      nativeInternalDirPath: o,
+      mountsBeforeWpInstall: this.args["mount-before-install"] || [],
+      mountsAfterWpInstall: this.args.mount || []
+    };
+    return await i.bootWorker(n), i;
+  }
+}
+const Q = h.join(O.homedir(), ".wordpress-playground");
+async function ut(e) {
+  return await pe(
+    "https://github.com/WordPress/sqlite-database-integration/archive/refs/heads/develop.zip",
+    "sqlite.zip",
+    e
+  );
+}
+async function pe(e, t, r) {
+  const s = h.join(Q, t);
+  return B.existsSync(s) || (B.ensureDirSync(Q), await dt(e, s, r)), ce(s);
+}
+async function dt(e, t, r) {
+  const o = (await r.monitorFetch(fetch(e))).body.getReader(), i = `${t}.partial`, n = B.createWriteStream(i);
+  for (; ; ) {
+    const { done: l, value: u } = await o.read();
+    if (u && n.write(u), l)
+      break;
+  }
+  n.close(), n.closed || await new Promise((l, u) => {
+    n.on("finish", () => {
+      B.renameSync(i, t), l(null);
+    }), n.on("error", (b) => {
+      B.removeSync(i), u(b);
+    });
+  });
+}
+function ce(e, t) {
+  return new File([B.readFileSync(e)], A(e));
+}
+class pt {
+  constructor(t, r) {
+    this.args = t, this.siteUrl = r.siteUrl, this.processIdSpaceLength = r.processIdSpaceLength, this.cliOutput = r.cliOutput;
+  }
+  getWorkerType() {
+    return "v1";
+  }
+  async bootAndSetUpInitialPlayground(t, r, s) {
+    let o, i, n;
+    const l = new Oe();
+    if (this.args.wordpressInstallMode === "download-and-install") {
+      let E = !1;
+      l.addEventListener("progress", (k) => {
+        if (E)
+          return;
+        const { loaded: W, total: Z } = k.detail, C = Math.floor(
+          Math.min(100, 100 * W / Z)
+        );
+        E = C === 100, this.cliOutput.updateProgress(
+          "Downloading WordPress",
+          C
+        );
+      }), o = await Ve(this.args.wp), n = h.join(
+        Q,
+        `prebuilt-wp-content-for-wp-${o.version}.zip`
+      ), i = p.existsSync(n) ? ce(n) : await pe(
+        o.releaseUrl,
+        `${o.version}.zip`,
+        l
+      ), g.debug(
+        `Resolved WordPress release URL: ${o?.releaseUrl}`
+      );
+    }
+    let u;
+    this.args.skipSqliteSetup ? (g.debug("Skipping SQLite integration plugin setup..."), u = void 0) : (this.cliOutput.updateProgress("Preparing SQLite database"), u = await ut(l));
+    const b = this.args.followSymlinks === !0, v = this.args.experimentalTrace === !0, a = this.args["mount-before-install"] || [], f = this.args.mount || [], c = F(t);
+    await c.isConnected(), this.cliOutput.updateProgress("Booting WordPress");
+    const S = await re(
+      this.getEffectiveBlueprint()
+    );
+    return await c.useFileLockManager(r), await c.bootAndSetUpInitialWorker({
+      phpVersion: S.phpVersion,
+      wpVersion: S.wpVersion,
+      siteUrl: this.siteUrl,
+      mountsBeforeWpInstall: a,
+      mountsAfterWpInstall: f,
+      wordpressInstallMode: this.args.wordpressInstallMode || "download-and-install",
+      wordPressZip: i && await i.arrayBuffer(),
+      sqliteIntegrationPluginZip: await u?.arrayBuffer(),
+      firstProcessId: 0,
+      processIdSpaceLength: this.processIdSpaceLength,
+      followSymlinks: b,
+      trace: v,
+      internalCookieStore: this.args.internalCookieStore,
+      withIntl: this.args.intl,
+      // We do not enable Xdebug by default for the initial worker
+      // because we do not imagine users expect to hit breakpoints
+      // until Playground has fully booted.
+      // TODO: Consider supporting Xdebug for the initial worker via a dedicated flag.
+      withXdebug: !1,
+      nativeInternalDirPath: s
+    }), n && !this.args["mount-before-install"] && !p.existsSync(n) && (this.cliOutput.updateProgress("Caching WordPress for next boot"), p.writeFileSync(
+      n,
+      await Ie(c, "/wordpress")
+    )), c;
+  }
+  async bootPlayground({
+    worker: t,
+    fileLockManagerPort: r,
+    firstProcessId: s,
+    nativeInternalDirPath: o
+  }) {
+    const i = F(
+      t.phpPort
+    );
+    await i.isConnected();
+    const n = await re(
+      this.getEffectiveBlueprint()
+    );
+    return await i.useFileLockManager(r), await i.bootWorker({
+      phpVersion: n.phpVersion,
+      siteUrl: this.siteUrl,
+      mountsBeforeWpInstall: this.args["mount-before-install"] || [],
+      mountsAfterWpInstall: this.args.mount || [],
+      firstProcessId: s,
+      processIdSpaceLength: this.processIdSpaceLength,
+      followSymlinks: this.args.followSymlinks === !0,
+      trace: this.args.experimentalTrace === !0,
+      // @TODO: Move this to the request handler or else every worker
+      //        will have a separate cookie store.
+      internalCookieStore: this.args.internalCookieStore,
+      withIntl: this.args.intl,
+      withXdebug: !!this.args.xdebug,
+      nativeInternalDirPath: o
+    }), await i.isReady(), i;
+  }
+  async compileInputBlueprint(t) {
+    const r = this.getEffectiveBlueprint(), s = new He();
+    let o = "", i = !1;
+    return s.addEventListener("progress", (n) => {
+      if (i)
+        return;
+      i = n.detail.progress === 100;
+      const l = Math.floor(n.detail.progress);
+      o = n.detail.caption || o || "Running Blueprint", this.cliOutput.updateProgress(o.trim(), l);
+    }), await Se(r, {
+      progress: s,
+      additionalSteps: t
+    });
+  }
+  getEffectiveBlueprint() {
+    const t = this.args.blueprint;
+    return xe(t) ? t : {
+      login: this.args.login,
+      ...t || {},
+      preferredVersions: {
+        php: this.args.php ?? t?.preferredVersions?.php ?? U,
+        wp: this.args.wp ?? t?.preferredVersions?.wp ?? "latest",
+        ...t?.preferredVersions || {}
+      }
+    };
+  }
+}
+async function ct(e, t = !0) {
+  const s = `${h.basename(process.argv0)}${e}${process.pid}-`, o = await _e({
+    prefix: s,
+    /*
+     * Allow recursive cleanup on process exit.
+     *
+     * NOTE: I worried about whether this cleanup would follow symlinks
+     * and delete target files instead of unlinking the symlink,
+     * but this feature uses rimraf under the hood which respects symlinks:
+     * https://github.com/raszi/node-tmp/blob/3d2fe387f3f91b13830b9182faa02c3231ea8258/lib/tmp.js#L318
+     */
+    unsafeCleanup: !0
+  });
+  return t && qe(), o;
+}
+async function ht(e, t, r) {
+  const o = (await mt(
+    e,
+    t,
+    r
+  )).map(
+    (i) => new Promise((n) => {
+      p.rm(i, { recursive: !0 }, (l) => {
+        l ? g.warn(
+          `Failed to delete stale Playground temp dir: ${i}`,
+          l
+        ) : g.info(
+          `Deleted stale Playground temp dir: ${i}`
+        ), n();
+      });
+    })
+  );
+  await Promise.all(o);
+}
+async function mt(e, t, r) {
+  try {
+    const s = p.readdirSync(r).map((i) => h.join(r, i)), o = [];
+    for (const i of s)
+      await ft(
+        e,
+        t,
+        i
+      ) && o.push(i);
+    return o;
+  } catch (s) {
+    return g.warn(`Failed to find stale Playground temp dirs: ${s}`), [];
+  }
+}
+async function ft(e, t, r) {
+  if (!p.lstatSync(r).isDirectory())
+    return !1;
+  const o = h.basename(r);
+  if (!o.includes(e))
+    return !1;
+  const i = o.match(
+    new RegExp(`^(.+)${e}(\\d+)-`)
+  );
+  if (!i)
+    return !1;
+  const n = {
+    executableName: i[1],
+    pid: i[2]
+  };
+  if (await wt(n.pid, n.executableName))
+    return !1;
+  const l = Date.now() - t;
+  return p.statSync(r).mtime.getTime() < l;
+}
+async function wt(e, t) {
+  const [r] = await new Promise(
+    (s, o) => {
+      Ye.list(
+        {
+          pid: e,
+          name: t,
+          // Remove path from executable name in the results.
+          clean: !0
+        },
+        (i, n) => {
+          i ? o(i) : s(n);
+        }
+      );
+    }
+  );
+  return !!r && r.pid === e && r.command === t;
+}
+function gt(e) {
+  return process.env.CI === "true" || process.env.CI === "1" || process.env.GITHUB_ACTIONS === "true" || process.env.GITHUB_ACTIONS === "1" || (process.env.TERM || "").toLowerCase() === "dumb" ? !1 : e ? !!e.isTTY : process.stdout.isTTY;
+}
+class yt {
+  constructor(t) {
+    this.lastProgressLine = "", this.progressActive = !1, this.verbosity = t.verbosity, this.writeStream = t.writeStream || process.stdout;
+  }
+  get isTTY() {
+    return !!this.writeStream.isTTY;
+  }
+  /**
+   * Determines if progress updates should be rendered.
+   *
+   * Returns false when output is piped, redirected, or in CI environments.
+   * This prevents progress spam in logs - users only see the final outcome.
+   */
+  get shouldRender() {
+    return gt(this.writeStream);
+  }
+  get isQuiet() {
+    return this.verbosity === "quiet";
+  }
+  /**
+   * ANSI formatting helpers.
+   *
+   * These only apply color codes when outputting to a terminal (TTY).
+   * When piped to files or non-TTY streams, they return plain text to
+   * avoid polluting logs with escape sequences.
+   */
+  bold(t) {
+    return this.isTTY ? `\x1B[1m${t}\x1B[0m` : t;
+  }
+  dim(t) {
+    return this.isTTY ? `\x1B[2m${t}\x1B[0m` : t;
+  }
+  green(t) {
+    return this.isTTY ? `\x1B[32m${t}\x1B[0m` : t;
+  }
+  cyan(t) {
+    return this.isTTY ? `\x1B[36m${t}\x1B[0m` : t;
+  }
+  yellow(t) {
+    return this.isTTY ? `\x1B[33m${t}\x1B[0m` : t;
+  }
+  red(t) {
+    return this.isTTY ? `\x1B[31m${t}\x1B[0m` : t;
+  }
+  printBanner() {
+    if (this.isQuiet) return;
+    const t = this.bold("WordPress Playground CLI");
+    this.writeStream.write(`
+${t}
+
+`);
+  }
+  /**
+   * Prints the configuration summary before starting the server.
+   *
+   * Displays PHP/WordPress versions, enabled extensions, all mounts
+   * (with auto-mounts labeled), and any loaded blueprint. This gives
+   * users a clear view of what's configured before the server boots.
+   */
+  printConfig(t) {
+    if (this.isQuiet) return;
+    const r = [];
+    r.push(
+      `${this.dim("PHP")} ${this.cyan(t.phpVersion)}  ${this.dim("WordPress")} ${this.cyan(t.wpVersion)}`
+    );
+    const s = [];
+    if (t.intl && s.push("intl"), t.xdebug && s.push(this.yellow("xdebug")), s.length > 0 && r.push(`${this.dim("Extensions")} ${s.join(", ")}`), t.mounts.length > 0)
+      for (const o of t.mounts) {
+        const i = o.autoMounted ? ` ${this.dim("(auto-mount)")}` : "";
+        r.push(
+          `${this.dim("Mount")} ${o.hostPath} ${this.dim("→")} ${o.vfsPath}${i}`
+        );
+      }
+    t.blueprint && r.push(`${this.dim("Blueprint")} ${t.blueprint}`), this.writeStream.write(r.join(`
+`) + `
+
+`);
+  }
+  /**
+   * Starts a progress indicator that updates in-place.
+   *
+   * Subsequent updateProgress() calls rewrite the same line in TTY mode.
+   * When output is piped or redirected, progress is completely skipped.
+   */
+  startProgress(t) {
+    this.isQuiet || this.shouldRender && (this.progressActive = !0, this.updateProgress(t));
+  }
+  /**
+   * Updates the current progress message and optional percentage.
+   *
+   * Rewrites the current line using ANSI cursor control in TTY mode.
+   * Identical messages are skipped to prevent flickering. When piped,
+   * this method does nothing (early return via shouldRender check).
+   */
+  updateProgress(t, r) {
+    if (this.isQuiet || !this.shouldRender) return;
+    this.progressActive || (this.progressActive = !0);
+    let s = `${t}`;
+    r !== void 0 && (s = `${t} ${this.dim(`${r}%`)}`), s !== this.lastProgressLine && (this.lastProgressLine = s, this.isTTY ? (this.writeStream.cursorTo(0), this.writeStream.write(s), this.writeStream.clearLine(1)) : this.writeStream.write(`${s}
+`));
+  }
+  /**
+   * Completes the progress indicator and moves to a new line.
+   *
+   * Optionally displays a final message before finishing. In TTY mode,
+   * this ensures the cursor moves to the next line after the progress.
+   */
+  finishProgress(t) {
+    this.isQuiet || this.shouldRender && (t && (this.isTTY ? (this.writeStream.cursorTo(0), this.writeStream.write(`${t}`), this.writeStream.clearLine(1)) : this.writeStream.write(`${t}
+`)), this.isTTY && this.writeStream.write(`
+`), this.progressActive = !1, this.lastProgressLine = "");
+  }
+  /**
+   * Prints a status message, interrupting any active progress.
+   *
+   * Unlike progress updates, status messages are always printed on their
+   * own line. Any active progress indicator is cleared before the message.
+   */
+  printStatus(t) {
+    this.isQuiet || (this.progressActive && this.isTTY && (this.writeStream.cursorTo(0), this.writeStream.clearLine(0)), this.writeStream.write(`${t}
+`), this.progressActive = !1, this.lastProgressLine = "");
+  }
+  /**
+   * Prints an error message.
+   *
+   * Errors are always shown, even in quiet mode, and interrupt any
+   * active progress display to ensure visibility.
+   */
+  printError(t) {
+    this.progressActive && this.isTTY && (this.writeStream.cursorTo(0), this.writeStream.clearLine(0), this.progressActive = !1), this.writeStream.write(`${this.red("Error:")} ${t}
+`);
+  }
+  /**
+   * Prints the final "server ready" message with the URL.
+   *
+   * Note: The exact wording "WordPress is running on" is checked by
+   * CI tests, so changes to this string will break test assertions.
+   */
+  printReady(t, r) {
+    if (this.isQuiet) return;
+    const s = r === 1 ? "worker" : "workers";
+    this.writeStream.write(
+      `
+${this.green("Ready!")} WordPress is running on ${this.bold(t)} ${this.dim(`(${r} ${s})`)}
+
+`
+    );
+  }
+  printWarning(t) {
+    this.isQuiet || this.writeStream.write(`${this.yellow("Warning:")} ${t}
+`);
+  }
+}
+const he = {
+  Quiet: { name: "quiet", severity: j.Fatal },
+  Normal: { name: "normal", severity: j.Info },
+  Debug: { name: "debug", severity: j.Debug }
+};
+async function Jt(e) {
+  try {
+    const t = {
+      "site-url": {
+        describe: "Site URL to use for WordPress. Defaults to http://127.0.0.1:{port}",
+        type: "string"
+      },
+      php: {
+        describe: "PHP version to use.",
+        type: "string",
+        default: U,
+        choices: te
+      },
+      wp: {
+        describe: "WordPress version to use.",
+        type: "string",
+        default: "latest"
+      },
+      // @TODO: Support read-only mounts, e.g. via WORKERFS, a custom
+      // ReadOnlyNODEFS, or by copying the files into MEMFS
+      mount: {
+        describe: "Mount a directory to the PHP runtime (can be used multiple times). Format: /host/path:/vfs/path",
+        type: "array",
+        string: !0,
+        coerce: _
+      },
+      "mount-before-install": {
+        describe: "Mount a directory to the PHP runtime before WordPress installation (can be used multiple times). Format: /host/path:/vfs/path",
+        type: "array",
+        string: !0,
+        coerce: _
+      },
+      "mount-dir": {
+        describe: 'Mount a directory to the PHP runtime (can be used multiple times). Format: "/host/path" "/vfs/path"',
+        type: "array",
+        nargs: 2,
+        array: !0,
+        coerce: se
+      },
+      "mount-dir-before-install": {
+        describe: 'Mount a directory before WordPress installation (can be used multiple times). Format: "/host/path" "/vfs/path"',
+        type: "string",
+        nargs: 2,
+        array: !0,
+        coerce: se
+      },
+      login: {
+        describe: "Should log the user in",
+        type: "boolean",
+        default: !1
+      },
+      blueprint: {
+        describe: "Blueprint to execute.",
+        type: "string"
+      },
+      "blueprint-may-read-adjacent-files": {
+        describe: 'Consent flag: Allow "bundled" resources in a local blueprint to read files in the same directory as the blueprint file.',
+        type: "boolean",
+        default: !1
+      },
+      "wordpress-install-mode": {
+        describe: "Control how Playground prepares WordPress before booting.",
+        type: "string",
+        default: "download-and-install",
+        choices: [
+          "download-and-install",
+          "install-from-existing-files",
+          "install-from-existing-files-if-needed",
+          "do-not-attempt-installing"
+        ]
+      },
+      "skip-wordpress-install": {
+        describe: "[Deprecated] Use --wordpress-install-mode instead.",
+        type: "boolean",
+        hidden: !0
+      },
+      "skip-sqlite-setup": {
+        describe: "Skip the SQLite integration plugin setup to allow the WordPress site to use MySQL.",
+        type: "boolean",
+        default: !1
+      },
+      // Hidden - Deprecated in favor of verbosity
+      quiet: {
+        describe: "Do not output logs and progress messages.",
+        type: "boolean",
+        default: !1,
+        hidden: !0
+      },
+      verbosity: {
+        describe: "Output logs and progress messages.",
+        type: "string",
+        choices: Object.values(he).map(
+          (a) => a.name
+        ),
+        default: "normal"
+      },
+      debug: {
+        describe: "Print PHP error log content if an error occurs during Playground boot.",
+        type: "boolean",
+        default: !1,
+        // Hide this deprecated option. Use verbosity=debug instead.
+        hidden: !0
+      },
+      "auto-mount": {
+        describe: "Automatically mount the specified directory. If no path is provided, mount the current working directory. You can mount a WordPress directory, a plugin directory, a theme directory, a wp-content directory, or any directory containing PHP and HTML files.",
+        type: "string"
+      },
+      "follow-symlinks": {
+        describe: `Allow Playground to follow symlinks by automatically mounting symlinked directories and files encountered in mounted directories. 
+Warning: Following symlinks will expose files outside mounted directories to Playground and could be a security risk.`,
+        type: "boolean",
+        default: !1
+      },
+      "experimental-trace": {
+        describe: "Print detailed messages about system behavior to the console. Useful for troubleshooting.",
+        type: "boolean",
+        default: !1,
+        // Hide this option because we want to replace with a more general log-level flag.
+        hidden: !0
+      },
+      "internal-cookie-store": {
+        describe: "Enable internal cookie handling. When enabled, Playground will manage cookies internally using an HttpCookieStore that persists cookies across requests. When disabled, cookies are handled externally (e.g., by a browser in Node.js environments).",
+        type: "boolean",
+        default: !1
+      },
+      intl: {
+        describe: "Enable Intl.",
+        type: "boolean",
+        default: !0
+      },
+      xdebug: {
+        describe: "Enable Xdebug.",
+        type: "boolean",
+        default: !1
+      },
+      "experimental-unsafe-ide-integration": {
+        describe: "Enable experimental IDE development tools. This option edits IDE config files to set Xdebug path mappings and web server details. CAUTION: If there are bugs, this feature may break your IDE config files. Please consider backing up your IDE configs before using this feature.",
+        type: "string",
+        // The empty value means the option is enabled for all
+        // supported IDEs and, if needed, will create the relevant
+        // config file for each.
+        choices: ["", "vscode", "phpstorm"],
+        coerce: (a) => a === "" ? ["vscode", "phpstorm"] : [a]
+      },
+      "experimental-blueprints-v2-runner": {
+        describe: "Use the experimental Blueprint V2 runner.",
+        type: "boolean",
+        default: !1,
+        // Remove the "hidden" flag once Blueprint V2 is fully supported
+        hidden: !0
+      },
+      mode: {
+        describe: "Blueprints v2 runner mode to use. This option is required when using the --experimental-blueprints-v2-runner flag with a blueprint.",
+        type: "string",
+        choices: ["create-new-site", "apply-to-existing-site"],
+        // Remove the "hidden" flag once Blueprint V2 is fully supported
+        hidden: !0
+      }
+    }, r = {
+      port: {
+        describe: "Port to listen on when serving.",
+        type: "number",
+        default: 9400
+      },
+      "experimental-multi-worker": {
+        describe: "Enable experimental multi-worker support which requires a /wordpress directory backed by a real filesystem. Pass a positive number to specify the number of workers to use. Otherwise, default to the number of CPUs minus 1.",
+        type: "number",
+        coerce: (a) => a ?? Ce().length - 1
+      },
+      "experimental-devtools": {
+        describe: "Enable experimental browser development tools.",
+        type: "boolean"
+      }
+    }, s = {
+      path: {
+        describe: "Path to the project directory. Playground will auto-detect if this is a plugin, theme, wp-content, or WordPress directory.",
+        type: "string",
+        default: process.cwd()
+      },
+      php: {
+        describe: "PHP version to use.",
+        type: "string",
+        default: U,
+        choices: te
+      },
+      wp: {
+        describe: "WordPress version to use.",
+        type: "string",
+        default: "latest"
+      },
+      port: {
+        describe: "Port to listen on.",
+        type: "number",
+        default: 9400
+      },
+      blueprint: {
+        describe: "Path to a Blueprint JSON file to execute on startup.",
+        type: "string"
+      },
+      login: {
+        describe: "Auto-login as the admin user.",
+        type: "boolean",
+        default: !0
+      },
+      xdebug: {
+        describe: "Enable Xdebug for debugging.",
+        type: "boolean",
+        default: !1
+      },
+      "experimental-unsafe-ide-integration": t["experimental-unsafe-ide-integration"],
+      "skip-browser": {
+        describe: "Do not open the site in your default browser on startup.",
+        type: "boolean",
+        default: !1
+      },
+      quiet: {
+        describe: "Suppress non-essential output.",
+        type: "boolean",
+        default: !1
+      },
+      // Advanced options for power users who need more control
+      "site-url": {
+        describe: "Override the site URL. By default, derived from the port (http://127.0.0.1:<port>).",
+        type: "string"
+      },
+      mount: {
+        describe: "Mount a directory to the PHP runtime (can be used multiple times). Format: /host/path:/vfs/path. Use this for additional mounts beyond auto-detection.",
+        type: "array",
+        string: !0,
+        coerce: _
+      },
+      reset: {
+        describe: "Deletes the stored site directory and starts a new site from scratch.",
+        type: "boolean",
+        default: !1
+      },
+      "no-auto-mount": {
+        describe: "Disable automatic project type detection. Use --mount to manually specify mounts instead.",
+        type: "boolean",
+        default: !1
+      }
+    }, o = {
+      outfile: {
+        describe: "When building, write to this output file.",
+        type: "string",
+        default: "wordpress.zip"
+      }
+    }, i = Re(e).usage("Usage: wp-playground <command> [options]").command(
+      "start",
+      "Start a local WordPress server with automatic project detection (recommended)",
+      (a) => a.usage(
+        `Usage: wp-playground start [options]
+
+The easiest way to run WordPress locally. Automatically detects
+if your directory contains a plugin, theme, wp-content, or
+WordPress installation and configures everything for you.
+
+Examples:
+  wp-playground start                    # Start in current directory
+  wp-playground start --path=./my-plugin # Start with a specific path
+  wp-playground start --wp=6.7 --php=8.3 # Use specific versions
+  wp-playground start --skip-browser     # Skip opening browser
+  wp-playground start --no-auto-mount    # Disable auto-detection`
+      ).options(s)
+    ).command(
+      "server",
+      "Start a local WordPress server (advanced, low-level)",
+      (a) => a.options({
+        ...t,
+        ...r
+      })
+    ).command(
+      "run-blueprint",
+      "Execute a Blueprint without starting a server",
+      (a) => a.options({ ...t })
+    ).command(
+      "build-snapshot",
+      "Build a ZIP snapshot of a WordPress site based on a Blueprint",
+      (a) => a.options({
+        ...t,
+        ...o
+      })
+    ).demandCommand(1, "Please specify a command").strictCommands().conflicts(
+      "experimental-unsafe-ide-integration",
+      "experimental-devtools"
+    ).showHelpOnFail(!1).fail((a, f, c) => {
+      if (f)
+        throw f;
+      a && a.includes("Please specify a command") && (c.showHelp(), console.error(`
+` + a), process.exit(1)), console.error(a), process.exit(1);
+    }).strictOptions().check(async (a) => {
+      if (a["skip-wordpress-install"] === !0 && (a["wordpress-install-mode"] = "do-not-attempt-installing", a.wordpressInstallMode = "do-not-attempt-installing"), a.wp !== void 0 && typeof a.wp == "string" && !nt(a.wp))
+        try {
+          new URL(a.wp);
+        } catch {
+          throw new Error(
+            'Unrecognized WordPress version. Please use "latest", a URL, or a numeric version such as "6.2", "6.0.1", "6.2-beta1", or "6.2-RC1"'
+          );
+        }
+      const f = a["site-url"];
+      if (typeof f == "string" && f.trim() !== "")
+        try {
+          new URL(f);
+        } catch {
+          throw new Error(
+            `Invalid site-url "${f}". Please provide a valid URL (e.g., http://localhost:8080 or https://example.com)`
+          );
+        }
+      if (a["auto-mount"]) {
+        let c = !1;
+        try {
+          c = p.statSync(
+            a["auto-mount"]
+          ).isDirectory();
+        } catch {
+          c = !1;
+        }
+        if (!c)
+          throw new Error(
+            `The specified --auto-mount path is not a directory: '${a["auto-mount"]}'.`
+          );
+      }
+      if (a["experimental-multi-worker"] !== void 0) {
+        if (a._[0] !== "server")
+          throw new Error(
+            "The --experimental-multi-worker flag is only supported when running the server command."
+          );
+        if (a["experimental-multi-worker"] !== void 0 && typeof a["experimental-multi-worker"] == "number" && a["experimental-multi-worker"] <= 1)
+          throw new Error(
+            "The --experimental-multi-worker flag must be a positive integer greater than 1."
+          );
+      }
+      if (a["experimental-blueprints-v2-runner"] === !0) {
+        if (a.mode !== void 0) {
+          if (a["wordpress-install-mode"] !== void 0)
+            throw new Error(
+              "The --wordpress-install-mode option cannot be used with the --mode option. Use one or the other."
+            );
+          if ("skip-sqlite-setup" in a)
+            throw new Error(
+              "The --skipSqliteSetup option is not supported in Blueprint V2 mode."
+            );
+          if (a["auto-mount"] !== void 0)
+            throw new Error(
+              "The --mode option cannot be used with --auto-mount because --auto-mount automatically sets the mode."
+            );
+        } else
+          a["wordpress-install-mode"] === "do-not-attempt-installing" ? a.mode = "apply-to-existing-site" : a.mode = "create-new-site";
+        const c = a.allow || [];
+        a.followSymlinks === !0 && c.push("follow-symlinks"), a["blueprint-may-read-adjacent-files"] === !0 && c.push("read-local-fs"), a.allow = c;
+      } else if (a.mode !== void 0)
+        throw new Error(
+          "The --mode option requires the --experimentalBlueprintsV2Runner flag."
+        );
+      return !0;
+    });
+    i.wrap(i.terminalWidth());
+    const n = await i.argv, l = n._[0];
+    ["start", "run-blueprint", "server", "build-snapshot"].includes(
+      l
+    ) || (i.showHelp(), process.exit(1));
+    const u = {
+      ...n,
+      command: l,
+      mount: [
+        ...n.mount || [],
+        ...n["mount-dir"] || []
+      ],
+      "mount-before-install": [
+        ...n["mount-before-install"] || [],
+        ...n["mount-dir-before-install"] || []
+      ]
+    }, b = await St(u);
+    b === void 0 && process.exit(0);
+    const v = /* @__PURE__ */ (() => {
+      let a;
+      return async () => {
+        a !== void 0 && (a = b[Symbol.asyncDispose]()), await a, process.exit(0);
+      };
+    })();
+    process.on("SIGINT", v), process.on("SIGTERM", v);
+  } catch (t) {
+    if (console.error(t), !(t instanceof Error))
+      throw t;
+    if (process.argv.includes("--debug"))
+      ye(t);
+    else {
+      const s = [];
+      let o = t;
+      do
+        s.push(o.message), o = o.cause;
+      while (o instanceof Error);
+      console.error(
+        "\x1B[1m" + s.join(" caused by: ") + "\x1B[0m"
+      );
+    }
+    process.exit(1);
+  }
+}
+function ne(e, t) {
+  return e.find(
+    (r) => r.vfsPath.replace(/\/$/, "") === t.replace(/\/$/, "")
+  );
+}
+const bt = Symbol("playground-cli-testing"), T = (e) => process.stdout.isTTY ? "\x1B[1m" + e + "\x1B[0m" : e, vt = (e) => process.stdout.isTTY ? "\x1B[31m" + e + "\x1B[0m" : e, Pt = (e) => process.stdout.isTTY ? `\x1B[2m${e}\x1B[0m` : e, q = (e) => process.stdout.isTTY ? `\x1B[3m${e}\x1B[0m` : e, ae = (e) => process.stdout.isTTY ? `\x1B[33m${e}\x1B[0m` : e;
+async function St(e) {
+  let t, r;
+  const s = /* @__PURE__ */ new Map();
+  if (e.command === "start" && (e = xt(e)), e.autoMount !== void 0 && (e.autoMount === "" && (e = { ...e, autoMount: process.cwd() }), e = de(e)), e.wordpressInstallMode === void 0 && (e.wordpressInstallMode = "download-and-install"), e.quiet && (e.verbosity = "quiet", delete e.quiet), e.debug && (e.verbosity = "debug", delete e.debug), e.verbosity) {
+    const a = Object.values(he).find(
+      (f) => f.name === e.verbosity
+    ).severity;
+    g.setSeverityFilterLevel(a);
+  }
+  e.intl || (e.intl = !0);
+  const o = new yt({
+    verbosity: e.verbosity || "normal"
+  });
+  e.command === "server" && (o.printBanner(), o.printConfig({
+    phpVersion: e.php || U,
+    wpVersion: e.wp || "latest",
+    port: e.port || 9400,
+    xdebug: !!e.xdebug,
+    intl: !!e.intl,
+    mounts: [
+      ...e.mount || [],
+      ...e["mount-before-install"] || []
+    ],
+    blueprint: typeof e.blueprint == "string" ? e.blueprint : void 0
+  }));
+  const i = e.command === "server" ? e.port ?? 9400 : 0, n = O.platform() === "win32" ? (
+    // @TODO: Enable fs-ext here when it works with Windows.
+    void 0
+  ) : await import("fs-ext").then((a) => a.flockSync).catch(() => {
+    g.debug(
+      "The fs-ext package is not installed. Internal file locking will not be integrated with host OS file locking."
+    );
+  }), l = new Le(n);
+  let u = !1, b = !0;
+  const v = await rt({
+    port: i,
+    onBind: async (a, f) => {
+      const c = "127.0.0.1", S = `http://${c}:${f}`, E = e["site-url"] || S, k = e.command === "server" ? e.experimentalMultiWorker ?? 1 : 1, W = e.command === "server" ? (
+        // Account for the initial worker which is discarded by the server after setup.
+        k + 1
+      ) : k, C = 2 ** 31 - 1, L = Math.floor(
+        C / W
+      ), G = "-playground-cli-site-", I = await ct(G);
+      g.debug(`Native temp dir for VFS root: ${I.path}`);
+      const M = "WP Playground CLI - Listen for Xdebug", J = ".playground-xdebug-root", K = h.join(process.cwd(), J);
+      if (await ze(K), e.xdebug && e.experimentalUnsafeIdeIntegration) {
+        await Qe(
+          I.path,
+          K,
+          process.platform
+        );
+        const d = {
+          hostPath: h.join(".", h.sep, J),
+          vfsPath: "/"
+        };
+        try {
+          await Xe(M, process.cwd());
+          const w = typeof e.xdebug == "object" ? e.xdebug : void 0, P = await Ze({
+            name: M,
+            host: c,
+            port: f,
+            ides: e.experimentalUnsafeIdeIntegration,
+            cwd: process.cwd(),
+            mounts: [
+              d,
+              ...e["mount-before-install"] || [],
+              ...e.mount || []
+            ],
+            ideKey: w?.ideKey
+          }), m = e.experimentalUnsafeIdeIntegration, y = m.includes("vscode"), x = m.includes("phpstorm"), D = Object.values(P);
+          console.log(""), D.length > 0 ? (console.log(T("Xdebug configured successfully")), console.log(
+            ae("Updated IDE config: ") + D.join(" ")
+          ), console.log(
+            ae("Playground source root: ") + ".playground-xdebug-root" + q(
+              Pt(
+                " – you can set breakpoints and preview Playground's VFS structure in there."
+              )
+            )
+          )) : (console.log(T("Xdebug configuration failed.")), console.log(
+            "No IDE-specific project settings directory was found in the current working directory."
+          )), console.log(""), y && P.vscode && (console.log(T("VS Code / Cursor instructions:")), console.log(
+            "  1. Ensure you have installed an IDE extension for PHP Debugging"
+          ), console.log(
+            `     (The ${T("PHP Debug")} extension by ${T(
+              "Xdebug"
+            )} has been a solid option)`
+          ), console.log(
+            "  2. Open the Run and Debug panel on the left sidebar"
+          ), console.log(
+            `  3. Select "${q(
+              M
+            )}" from the dropdown`
+          ), console.log('  3. Click "start debugging"'), console.log(
+            "  5. Set a breakpoint. For example, in .playground-xdebug-root/wordpress/index.php"
+          ), console.log(
+            "  6. Visit Playground in your browser to hit the breakpoint"
+          ), x && console.log("")), x && P.phpstorm && (console.log(T("PhpStorm instructions:")), console.log(
+            `  1. Choose "${q(
+              M
+            )}" debug configuration in the toolbar`
+          ), console.log("  2. Click the debug button (bug icon)`"), console.log(
+            "  3. Set a breakpoint. For example, in .playground-xdebug-root/wordpress/index.php"
+          ), console.log(
+            "  4. Visit Playground in your browser to hit the breakpoint"
+          )), console.log("");
+        } catch (w) {
+          throw new Error("Could not configure Xdebug", {
+            cause: w
+          });
+        }
+      }
+      const me = h.dirname(I.path), fe = 2 * 24 * 60 * 60 * 1e3;
+      ht(
+        G,
+        fe,
+        me
+      );
+      const H = h.join(I.path, "internal");
+      z(H);
+      const we = [
+        "wordpress",
+        // Note: These dirs are from Emscripten's "default dirs" list:
+        // https://github.com/emscripten-core/emscripten/blob/f431ec220e472e1f8d3db6b52fe23fb377facf30/src/lib/libfs.js#L1400-L1402
+        //
+        // Any Playground process with multiple workers may assume
+        // these are part of a shared filesystem, so let's recognize
+        // them explicitly here.
+        "tmp",
+        "home"
+      ];
+      for (const d of we) {
+        const w = (m) => m.vfsPath === `/${d}`;
+        if (!(e["mount-before-install"]?.some(w) || e.mount?.some(w))) {
+          const m = h.join(
+            I.path,
+            d
+          );
+          z(m), e["mount-before-install"] === void 0 && (e["mount-before-install"] = []), e["mount-before-install"].unshift({
+            vfsPath: `/${d}`,
+            hostPath: m
+          });
+        }
+      }
+      if (e["mount-before-install"])
+        for (const d of e["mount-before-install"])
+          g.debug(
+            `Mount before WP install: ${d.vfsPath} -> ${d.hostPath}`
+          );
+      if (e.mount)
+        for (const d of e.mount)
+          g.debug(
+            `Mount after WP install: ${d.vfsPath} -> ${d.hostPath}`
+          );
+      let $;
+      e["experimental-blueprints-v2-runner"] ? $ = new lt(e, {
+        siteUrl: E,
+        processIdSpaceLength: L,
+        cliOutput: o
+      }) : ($ = new pt(e, {
+        siteUrl: E,
+        processIdSpaceLength: L,
+        cliOutput: o
+      }), typeof e.blueprint == "string" && (e.blueprint = await at({
+        sourceString: e.blueprint,
+        blueprintMayReadAdjacentFiles: e["blueprint-may-read-adjacent-files"] === !0
+      })));
+      let V = !1;
+      const R = async function() {
+        V || (V = !0, await Promise.all(
+          [...s].map(
+            async ([w, P]) => {
+              await P.dispose(), await w.terminate();
+            }
+          )
+        ), a && await new Promise((w) => a.close(w)), await I.cleanup());
+      }, ge = kt(
+        W,
+        $.getWorkerType(),
+        ({ exitCode: d, workerIndex: w }) => {
+          V || d === 0 && g.error(
+            `Worker ${w} exited with code ${d}
+`
+          );
+        }
+      );
+      o.startProgress("Starting...");
+      try {
+        const d = await ge, w = await le(l);
+        {
+          const m = d.shift(), y = await $.bootAndSetUpInitialPlayground(
+            m.phpPort,
+            w,
+            H
+          );
+          if (s.set(
+            m.worker,
+            y
+          ), await y.isReady(), u = !0, t = new it(y), !e["experimental-blueprints-v2-runner"]) {
+            const x = await $.compileInputBlueprint(
+              e["additional-blueprint-steps"] || []
+            );
+            x && await ke(
+              x,
+              y
+            );
+          }
+          if (e.command === "build-snapshot") {
+            await Tt(r, e.outfile), o.printStatus(`Exported to ${e.outfile}`), await R();
+            return;
+          } else if (e.command === "run-blueprint") {
+            o.finishProgress("Done"), await R();
+            return;
+          }
+          await t.removeWorker(y), await y.dispose(), await m.worker.terminate(), s.delete(m.worker);
+        }
+        const P = L;
+        return [r] = await Promise.all(
+          d.map(async (m, y) => {
+            const x = P + y * L, D = await le(l), N = await $.bootPlayground({
+              worker: m,
+              fileLockManagerPort: D,
+              firstProcessId: x,
+              nativeInternalDirPath: H
+            });
+            return s.set(
+              m.worker,
+              N
+            ), t.addWorker(N), N;
+          })
+        ), o.finishProgress(), o.printReady(S, k), e.xdebug && e.experimentalDevtools && (await Ne({
+          phpInstance: r,
+          phpRoot: "/wordpress"
+        })).start(), {
+          playground: r,
+          server: a,
+          serverUrl: S,
+          [Symbol.asyncDispose]: R,
+          [bt]: {
+            workerThreadCount: k,
+            getWorkerNumberFromProcessId: (m) => Math.floor(m / L)
+          }
+        };
+      } catch (d) {
+        if (e.verbosity !== "debug")
+          throw d;
+        let w = "";
+        throw await r?.fileExists(ee) && (w = await r.readFileAsText(ee)), await R(), new Error(w, { cause: d });
+      }
+    },
+    async handleRequest(a) {
+      if (!u)
+        return Y.forHttpCode(
+          502,
+          "WordPress is not ready yet"
+        );
+      if (b) {
+        b = !1;
+        const f = {
+          "Content-Type": ["text/plain"],
+          "Content-Length": ["0"],
+          Location: [a.url]
+        };
+        return a.headers?.cookie?.includes(
+          "playground_auto_login_already_happened"
+        ) && (f["Set-Cookie"] = [
+          "playground_auto_login_already_happened=1; Max-Age=0; Expires=Thu, 01 Jan 1970 00:00:00 GMT; Path=/"
+        ]), new Y(302, f, new Uint8Array());
+      }
+      return await t.handleRequest(a);
+    }
+  });
+  return v && e.command === "start" && !e.skipBrowser && $t(v.serverUrl), v;
+}
+function xt(e) {
+  let t = { ...e, command: "server" };
+  e.noAutoMount || (t.autoMount = h.resolve(process.cwd(), t.path ?? ""), t = de(t), delete t.autoMount);
+  const r = ne(
+    t["mount-before-install"] || [],
+    "/wordpress"
+  ) || ne(t.mount || [], "/wordpress");
+  if (r)
+    console.log("Site files stored at:", r?.hostPath), e.reset && (console.log(""), console.log(
+      vt(
+        "This site is not managed by Playground CLI and cannot be reset."
+      )
+    ), console.log(
+      "(It's not stored in the ~/.wordpress-playground/sites/<site-id> directory.)"
+    ), console.log(""), console.log(
+      "You may still remove the site's directory manually if you wish."
+    ), process.exit(1));
+  else {
+    const s = t.autoMount || process.cwd(), o = Ge("sha256").update(s).digest("hex"), i = O.homedir(), n = h.join(
+      i,
+      ".wordpress-playground/sites",
+      o
+    );
+    console.log("Site files stored at:", n), X(n) && e.reset && (console.log("Resetting site..."), $e(n, { recursive: !0 })), z(n, { recursive: !0 }), t["mount-before-install"] = [
+      ...t["mount-before-install"] || [],
+      { vfsPath: "/wordpress", hostPath: n }
+    ], t.wordpressInstallMode = Te(n).length === 0 ? (
+      // Only download WordPress on the first run when the site directory is still
+      // empty.
+      "download-and-install"
+    ) : (
+      // After that, reuse the WordPress installation from the initial run.
+      "install-from-existing-files-if-needed"
+    );
+  }
+  return t;
+}
+async function kt(e, t, r) {
+  const s = [];
+  for (let o = 0; o < e; o++) {
+    const n = It(t, { onExit: (l) => {
+      r({
+        exitCode: l,
+        workerIndex: o
+      });
+    } });
+    s.push(n);
+  }
+  return Promise.all(s);
+}
+function It(e, { onExit: t } = {}) {
+  let r;
+  return e === "v1" ? r = new oe(new URL("./worker-thread-v1.js", import.meta.url)) : r = new oe(new URL("./worker-thread-v2.js", import.meta.url)), new Promise((s, o) => {
+    r.once("message", function(n) {
+      n.command === "worker-script-initialized" && s({ worker: r, phpPort: n.phpPort });
+    }), r.once("error", function(n) {
+      console.error(n);
+      const l = new Error(
+        `Worker failed to load worker. ${n.message ? `Original error: ${n.message}` : ""}`
+      );
+      o(l);
+    });
+    let i = !1;
+    r.once("spawn", () => {
+      i = !0;
+    }), r.once("exit", (n) => {
+      i || o(new Error(`Worker exited before spawning: ${n}`)), t?.(n);
+    });
+  });
+}
+async function le(e) {
+  const { port1: t, port2: r } = new Be();
+  return await Me() ? be(e, null, t) : await ve(e, t), r;
+}
+function $t(e) {
+  const t = O.platform();
+  let r;
+  switch (t) {
+    case "darwin":
+      r = `open "${e}"`;
+      break;
+    case "win32":
+      r = `start "" "${e}"`;
+      break;
+    default:
+      r = `xdg-open "${e}"`;
+      break;
+  }
+  je(r, (s) => {
+    s && g.debug(`Could not open browser: ${s.message}`);
+  });
+}
+async function Tt(e, t) {
+  await e.run({
+    code: `<?php
+		$zip = new ZipArchive();
+		if(false === $zip->open('/tmp/build.zip', ZipArchive::CREATE | ZipArchive::OVERWRITE)) {
+			throw new Exception('Failed to create ZIP');
+		}
+		$files = new RecursiveIteratorIterator(
+			new RecursiveDirectoryIterator('/wordpress')
+		);
+		foreach ($files as $file) {
+			echo $file . PHP_EOL;
+			if (!$file->isFile()) {
+				continue;
+			}
+			$zip->addFile($file->getPathname(), $file->getPathname());
+		}
+		$zip->close();
+
+	`
+  });
+  const r = await e.readFileAsBuffer("/tmp/build.zip");
+  p.writeFileSync(t, r);
+}
+export {
+  he as L,
+  gt as a,
+  bt as i,
+  Gt as m,
+  Jt as p,
+  St as r,
+  It as s
+};
+//# sourceMappingURL=run-cli-NcKUE5gJ.js.map