@wp-playground/cli 3.0.41 → 3.0.42

package/{run-cli-vem_UKTF.js → run-cli-NcKUE5gJ.js}

@@ -1,38 +1,38 @@
-import { logger as u, LogSeverity as N, errorLogPath as ee } from "@php-wasm/logger";
-import { PHPResponse as j, consumeAPI as D, SupportedPHPVersions as te, printDebugDetails as ye, exposeAPI as be, exposeSyncAPI as Pe } from "@php-wasm/universal";
-import { resolveRemoteBlueprint as ve, resolveRuntimeConfiguration as oe, compileBlueprintV1 as ke, isBlueprintBundle as xe, runBlueprintV1Steps as Se } from "@wp-playground/blueprints";
-import { zipDirectory as Ie, RecommendedPHPVersion as q } from "@wp-playground/common";
-import f, { existsSync as Y, rmdirSync as $e, mkdirSync as z, readdirSync as Te } from "fs";
-import { MessageChannel as Ee, Worker as re } from "worker_threads";
-import { createNodeFsMountHandler as Ce, FileLockManagerForNode as We } from "@php-wasm/node";
-import h, { basename as R, join as de } from "path";
-import Be from "express";
-import U, { cpus as Me } from "os";
-import { jspi as Le } from "wasm-feature-detect";
+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 Ue, InMemoryFilesystem as Fe, ZipFilesystem as Ae } from "@wp-playground/storage";
-import { EmscriptenDownloadMonitor as He, ProgressTracker as Ve } from "@php-wasm/progress";
-import { resolveWordPressRelease as Ne } from "@wp-playground/wordpress";
-import C from "fs-extra";
-import { startBridge as Oe } from "@php-wasm/xdebug-bridge";
-import { exec as _e } from "child_process";
-import { dir as je, setGracefulCleanup as qe } from "tmp-promise";
-import ze from "ps-man";
-import { removeTempDirSymlink as Xe, createTempDirSymlink as Ye, clearXdebugIDEConfig as Ze, addXdebugIDEConfig as Ge } from "@php-wasm/cli-util";
-import { createHash as Je } from "crypto";
-function O(e) {
+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 o of e) {
-    const n = o.split(":");
-    if (n.length !== 2)
-      throw new Error(`Invalid mount format: ${o}.
+  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 [r, s] = n;
-    if (!Y(r))
-      throw new Error(`Host path does not exist: ${r}`);
-    t.push({ hostPath: r, vfsPath: s });
+    const [o, i] = s;
+    if (!X(o))
+      throw new Error(`Host path does not exist: ${o}`);
+    t.push({ hostPath: o, vfsPath: i });
   }
   return t;
 }
@@ -40,25 +40,25 @@ function se(e) {
   if (e.length % 2 !== 0)
     throw new Error("Invalid mount format. Expected: /host/path /vfs/path");
   const t = [];
-  for (let o = 0; o < e.length; o += 2) {
-    const n = e[o], r = e[o + 1];
-    if (!Y(n))
-      throw new Error(`Host path does not exist: ${n}`);
+  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(), n),
-      vfsPath: r
+      hostPath: h.resolve(process.cwd(), s),
+      vfsPath: o
     });
   }
   return t;
 }
-async function Zt(e, t) {
-  for (const o of t)
+async function Gt(e, t) {
+  for (const r of t)
     await e.mount(
-      o.vfsPath,
-      Ce(o.hostPath)
+      r.vfsPath,
+      Ee(r.hostPath)
     );
 }
-const ne = {
+const ie = {
   step: "runPHP",
   code: {
     filename: "activate-theme.php",
@@ -77,112 +77,119 @@ const ne = {
 		`
   }
 };
-function ue(e) {
-  const t = e.autoMount, o = [...e.mount || []], n = [...e["mount-before-install"] || []], r = {
+function de(e) {
+  const t = e.autoMount, r = [...e.mount || []], s = [...e["mount-before-install"] || []], o = {
     ...e,
-    mount: o,
-    "mount-before-install": n,
+    mount: r,
+    "mount-before-install": s,
     "additional-blueprint-steps": [
       ...e["additional-blueprint-steps"] || []
     ]
   };
   if (tt(t)) {
-    const s = R(t);
-    o.push({
+    const n = `/wordpress/wp-content/plugins/${A(t)}`;
+    r.push({
       hostPath: t,
-      vfsPath: `/wordpress/wp-content/plugins/${s}`
-    }), r["additional-blueprint-steps"].push({
+      vfsPath: n,
+      autoMounted: !0
+    }), o["additional-blueprint-steps"].push({
       step: "activatePlugin",
-      pluginPath: `/wordpress/wp-content/plugins/${R(t)}`
+      pluginPath: `/wordpress/wp-content/plugins/${A(t)}`
     });
   } else if (et(t)) {
-    const s = R(t);
-    o.push({
+    const i = A(t), n = `/wordpress/wp-content/themes/${i}`;
+    r.push({
       hostPath: t,
-      vfsPath: `/wordpress/wp-content/themes/${s}`
-    }), r["additional-blueprint-steps"].push(
+      vfsPath: n,
+      autoMounted: !0
+    }), o["additional-blueprint-steps"].push(
       e["experimental-blueprints-v2-runner"] ? {
         step: "activateTheme",
-        themeDirectoryName: s
+        themeDirectoryName: i
       } : {
         step: "activateTheme",
-        themeFolderName: s
+        themeFolderName: i
       }
     );
   } else if (Ke(t)) {
-    const s = f.readdirSync(t);
-    for (const i of s)
-      i !== "index.php" && o.push({
-        hostPath: `${t}/${i}`,
-        vfsPath: `/wordpress/wp-content/${i}`
+    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
       });
-    r["additional-blueprint-steps"].push(ne);
-  } else Qe(t) && (n.push({ hostPath: t, vfsPath: "/wordpress" }), r.mode = "apply-to-existing-site", r["additional-blueprint-steps"].push(ne), r.wordpressInstallMode || (r.wordpressInstallMode = "install-from-existing-files-if-needed"));
-  return r;
+    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 Qe(e) {
-  const t = f.readdirSync(e);
+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 = f.readdirSync(e);
+  const t = p.readdirSync(e);
   return t.includes("themes") || t.includes("plugins") || t.includes("mu-plugins") || t.includes("uploads");
 }
 function et(e) {
-  if (!f.readdirSync(e).includes("style.css"))
+  if (!p.readdirSync(e).includes("style.css"))
     return !1;
-  const o = f.readFileSync(de(e, "style.css"), "utf8");
-  return !!/^(?:[ \t]*<\?php)?[ \t/*#@]*Theme Name:(.*)$/im.exec(o);
+  const r = p.readFileSync(ue(e, "style.css"), "utf8");
+  return !!/^(?:[ \t]*<\?php)?[ \t/*#@]*Theme Name:(.*)$/im.exec(r);
 }
 function tt(e) {
-  const t = f.readdirSync(e), o = /^(?:[ \t]*<\?php)?[ \t/*#@]*Plugin Name:(.*)$/im;
-  return !!t.filter((r) => r.endsWith(".php")).find((r) => {
-    const s = f.readFileSync(de(e, r), "utf8");
-    return !!o.exec(s);
+  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 ot(e) {
-  const t = Be(), o = await new Promise((s, i) => {
+async function rt(e) {
+  const t = We(), r = await new Promise((i, n) => {
     const l = t.listen(e.port, () => {
-      const d = l.address();
-      d === null || typeof d == "string" ? i(new Error("Server address is not available")) : s(l);
+      const u = l.address();
+      u === null || typeof u == "string" ? n(new Error("Server address is not available")) : i(l);
     });
   });
-  t.use("/", async (s, i) => {
+  t.use("/", async (i, n) => {
     let l;
     try {
       l = await e.handleRequest({
-        url: s.url,
-        headers: st(s),
-        method: s.method,
-        body: await rt(s)
+        url: i.url,
+        headers: st(i),
+        method: i.method,
+        body: await ot(i)
       });
-    } catch (d) {
-      u.error(d), l = j.forHttpCode(500);
+    } catch (u) {
+      g.error(u), l = Y.forHttpCode(500);
     }
-    i.statusCode = l.httpStatusCode;
-    for (const d in l.headers)
-      i.setHeader(d, l.headers[d]);
-    i.end(l.bytes);
+    n.statusCode = l.httpStatusCode;
+    for (const u in l.headers)
+      n.setHeader(u, l.headers[u]);
+    n.end(l.bytes);
   });
-  const r = o.address().port;
-  return await e.onBind(o, r);
+  const o = r.address().port;
+  return await e.onBind(r, o);
 }
-const rt = async (e) => await new Promise((t) => {
-  const o = [];
-  e.on("data", (n) => {
-    o.push(n);
+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(o)));
+    t(new Uint8Array(Buffer.concat(r)));
   });
 }), st = (e) => {
   const t = {};
   if (e.rawHeaders && e.rawHeaders.length)
-    for (let o = 0; o < e.rawHeaders.length; o += 2)
-      t[e.rawHeaders[o].toLowerCase()] = e.rawHeaders[o + 1];
+    for (let r = 0; r < e.rawHeaders.length; r += 2)
+      t[e.rawHeaders[r].toLowerCase()] = e.rawHeaders[r + 1];
   return t;
 };
-class nt {
+class it {
   constructor(t) {
     this.workerLoads = [], this.addWorker(t);
   }
@@ -193,27 +200,27 @@ class nt {
     });
   }
   async removeWorker(t) {
-    const o = this.workerLoads.findIndex(
-      (r) => r.worker === t
+    const r = this.workerLoads.findIndex(
+      (o) => o.worker === t
     );
-    if (o === -1)
+    if (r === -1)
       return;
-    const [n] = this.workerLoads.splice(o, 1);
-    await Promise.allSettled(n.activeRequests);
+    const [s] = this.workerLoads.splice(r, 1);
+    await Promise.allSettled(s.activeRequests);
   }
   async handleRequest(t) {
-    let o = this.workerLoads[0];
-    for (let r = 1; r < this.workerLoads.length; r++) {
-      const s = this.workerLoads[r];
-      s.activeRequests.size < o.activeRequests.size && (o = s);
+    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 n = o.worker.request(t);
-    return o.activeRequests.add(n), n.url = t.url, n.finally(() => {
-      o.activeRequests.delete(n);
+    const s = r.worker.request(t);
+    return r.activeRequests.add(s), s.url = t.url, s.finally(() => {
+      r.activeRequests.delete(s);
     });
   }
 }
-function it(e) {
+function nt(e) {
   return /^latest$|^trunk$|^nightly$|^(?:(\d+)\.(\d+)(?:\.(\d+))?)((?:-beta(?:\d+)?)|(?:-RC(?:\d+)?))?$/.test(e);
 }
 async function at({
@@ -223,72 +230,69 @@ async function at({
   if (!e)
     return;
   if (e.startsWith("http://") || e.startsWith("https://"))
-    return await ve(e);
-  let o = h.resolve(process.cwd(), e);
-  if (!f.existsSync(o))
-    throw new Error(`Blueprint file does not exist: ${o}`);
-  const n = f.statSync(o);
-  if (n.isDirectory() && (o = h.join(o, "blueprint.json")), !n.isFile() && n.isSymbolicLink())
+    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: ${o}`
+      `Blueprint path is neither a file nor a directory: ${r}`
     );
-  const r = h.extname(o);
-  switch (r) {
+  const o = h.extname(r);
+  switch (o) {
     case ".zip":
-      return Ae.fromArrayBuffer(
-        f.readFileSync(o).buffer
+      return Ue.fromArrayBuffer(
+        p.readFileSync(r).buffer
       );
     case ".json": {
-      const s = f.readFileSync(o, "utf-8");
+      const i = p.readFileSync(r, "utf-8");
       try {
-        JSON.parse(s);
+        JSON.parse(i);
       } catch {
         throw new Error(
-          `Blueprint file at ${o} is not a valid JSON file`
+          `Blueprint file at ${r} is not a valid JSON file`
         );
       }
-      const i = h.dirname(o), l = new De(i);
-      return new Ue([
+      const n = h.dirname(r), l = new De(n);
+      return new Ae([
         new Fe({
-          "blueprint.json": s
+          "blueprint.json": i
         }),
         /**
          * Wrap the NodeJS filesystem to prevent access to local files
          * unless the user explicitly allowed it.
          */
         {
-          read(d) {
+          read(u) {
             if (!t)
               throw new Error(
-                `Error: Blueprint contained tried to read a local file at path "${d}" (via a resource of type "bundled"). Playground restricts access to local resources by default as a security measure. 
+                `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(d);
+            return l.read(u);
           }
         }
       ]);
     }
     default:
       throw new Error(
-        `Unsupported blueprint file extension: ${r}. Only .zip and .json files are supported.`
+        `Unsupported blueprint file extension: ${o}. Only .zip and .json files are supported.`
       );
   }
 }
-function ce(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 lt {
-  constructor(t, o) {
-    this.lastProgressMessage = "", this.args = t, this.siteUrl = o.siteUrl, this.processIdSpaceLength = o.processIdSpaceLength, this.phpVersion = t.php;
+  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, o, n) {
-    const r = D(t);
-    await r.useFileLockManager(o);
-    const s = {
+  async bootAndSetUpInitialPlayground(t, r, s) {
+    const o = F(t);
+    await o.useFileLockManager(r);
+    const i = {
       ...this.args,
       phpVersion: this.phpVersion,
       siteUrl: this.siteUrl,
@@ -303,125 +307,119 @@ class lt {
       // TODO: Consider supporting Xdebug for the initial worker via a dedicated flag.
       withXdebug: !1,
       xdebug: void 0,
-      nativeInternalDirPath: n,
+      nativeInternalDirPath: s,
       mountsBeforeWpInstall: this.args["mount-before-install"] || [],
       mountsAfterWpInstall: this.args.mount || []
     };
-    return await r.bootAndSetUpInitialWorker(s), r;
+    return await o.bootAndSetUpInitialWorker(i), o;
   }
   async bootPlayground({
     worker: t,
-    fileLockManagerPort: o,
-    firstProcessId: n,
-    nativeInternalDirPath: r
+    fileLockManagerPort: r,
+    firstProcessId: s,
+    nativeInternalDirPath: o
   }) {
-    const s = D(t.phpPort);
-    await s.useFileLockManager(o);
-    const i = {
+    const i = F(t.phpPort);
+    await i.useFileLockManager(r);
+    const n = {
       ...this.args,
       phpVersion: this.phpVersion,
       siteUrl: this.siteUrl,
-      firstProcessId: n,
+      firstProcessId: s,
       processIdSpaceLength: this.processIdSpaceLength,
       trace: this.args.verbosity === "debug",
       withIntl: this.args.intl,
       withXdebug: !!this.args.xdebug,
-      nativeInternalDirPath: r,
+      nativeInternalDirPath: o,
       mountsBeforeWpInstall: this.args["mount-before-install"] || [],
       mountsAfterWpInstall: this.args.mount || []
     };
-    return await s.bootWorker(i), s;
-  }
-  writeProgressUpdate(t, o, n) {
-    ce(t) && o !== this.lastProgressMessage && (this.lastProgressMessage = o, t.isTTY ? (t.cursorTo(0), t.write(o), t.clearLine(1), n && t.write(`
-`)) : t.write(`${o}
-`));
+    return await i.bootWorker(n), i;
   }
 }
-const X = h.join(U.homedir(), ".wordpress-playground");
-async function dt(e) {
+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, o) {
-  const n = h.join(X, t);
-  return C.existsSync(n) || (C.ensureDirSync(X), await ut(e, n, o)), fe(n);
+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 ut(e, t, o) {
-  const r = (await o.monitorFetch(fetch(e))).body.getReader(), s = `${t}.partial`, i = C.createWriteStream(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: d } = await r.read();
-    if (d && i.write(d), l)
+    const { done: l, value: u } = await o.read();
+    if (u && n.write(u), l)
       break;
   }
-  i.close(), i.closed || await new Promise((l, d) => {
-    i.on("finish", () => {
-      C.renameSync(s, t), l(null);
-    }), i.on("error", (b) => {
-      C.removeSync(s), d(b);
+  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 fe(e, t) {
-  return new File([C.readFileSync(e)], R(e));
+function ce(e, t) {
+  return new File([B.readFileSync(e)], A(e));
 }
-class ct {
-  constructor(t, o) {
-    this.lastProgressMessage = "", this.args = t, this.siteUrl = o.siteUrl, this.processIdSpaceLength = o.processIdSpaceLength;
+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, o, n) {
-    let r, s, i;
-    const l = new He();
+  async bootAndSetUpInitialPlayground(t, r, s) {
+    let o, i, n;
+    const l = new Oe();
     if (this.args.wordpressInstallMode === "download-and-install") {
-      let v = !1;
-      l.addEventListener("progress", (W) => {
-        if (v)
+      let E = !1;
+      l.addEventListener("progress", (k) => {
+        if (E)
           return;
-        const { loaded: G, total: F } = W.detail, k = Math.floor(
-          Math.min(100, 100 * G / F)
+        const { loaded: W, total: Z } = k.detail, C = Math.floor(
+          Math.min(100, 100 * W / Z)
         );
-        v = k === 100, this.writeProgressUpdate(
-          process.stdout,
-          `Downloading WordPress ${k}%...`,
-          v
+        E = C === 100, this.cliOutput.updateProgress(
+          "Downloading WordPress",
+          C
         );
-      }), r = await Ne(this.args.wp), i = h.join(
-        X,
-        `prebuilt-wp-content-for-wp-${r.version}.zip`
-      ), s = f.existsSync(i) ? fe(i) : await pe(
-        r.releaseUrl,
-        `${r.version}.zip`,
+      }), 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
-      ), u.log(
-        `Resolved WordPress release URL: ${r?.releaseUrl}`
+      ), g.debug(
+        `Resolved WordPress release URL: ${o?.releaseUrl}`
       );
     }
-    let d;
-    this.args.skipSqliteSetup ? (u.log("Skipping SQLite integration plugin setup..."), d = void 0) : (u.log("Fetching SQLite integration plugin..."), d = await dt(l));
-    const b = this.args.followSymlinks === !0, g = this.args.experimentalTrace === !0, a = this.args["mount-before-install"] || [], y = this.args.mount || [], p = D(t);
-    await p.isConnected(), u.log("Booting WordPress...");
-    const I = await oe(
+    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 p.useFileLockManager(o), await p.bootAndSetUpInitialWorker({
-      phpVersion: I.phpVersion,
-      wpVersion: I.wpVersion,
+    return await c.useFileLockManager(r), await c.bootAndSetUpInitialWorker({
+      phpVersion: S.phpVersion,
+      wpVersion: S.wpVersion,
       siteUrl: this.siteUrl,
       mountsBeforeWpInstall: a,
-      mountsAfterWpInstall: y,
+      mountsAfterWpInstall: f,
       wordpressInstallMode: this.args.wordpressInstallMode || "download-and-install",
-      wordPressZip: s && await s.arrayBuffer(),
-      sqliteIntegrationPluginZip: await d?.arrayBuffer(),
+      wordPressZip: i && await i.arrayBuffer(),
+      sqliteIntegrationPluginZip: await u?.arrayBuffer(),
       firstProcessId: 0,
       processIdSpaceLength: this.processIdSpaceLength,
       followSymlinks: b,
-      trace: g,
+      trace: v,
       internalCookieStore: this.args.internalCookieStore,
       withIntl: this.args.intl,
       // We do not enable Xdebug by default for the initial worker
@@ -429,31 +427,31 @@ class ct {
       // until Playground has fully booted.
       // TODO: Consider supporting Xdebug for the initial worker via a dedicated flag.
       withXdebug: !1,
-      nativeInternalDirPath: n
-    }), i && !this.args["mount-before-install"] && !f.existsSync(i) && (u.log("Caching preinstalled WordPress for the next boot..."), f.writeFileSync(
-      i,
-      await Ie(p, "/wordpress")
-    ), u.log("Cached!")), p;
+      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: o,
-    firstProcessId: n,
-    nativeInternalDirPath: r
+    fileLockManagerPort: r,
+    firstProcessId: s,
+    nativeInternalDirPath: o
   }) {
-    const s = D(
+    const i = F(
       t.phpPort
     );
-    await s.isConnected();
-    const i = await oe(
+    await i.isConnected();
+    const n = await re(
       this.getEffectiveBlueprint()
     );
-    return await s.useFileLockManager(o), await s.bootWorker({
-      phpVersion: i.phpVersion,
+    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: n,
+      firstProcessId: s,
       processIdSpaceLength: this.processIdSpaceLength,
       followSymlinks: this.args.followSymlinks === !0,
       trace: this.args.experimentalTrace === !0,
@@ -462,26 +460,20 @@ class ct {
       internalCookieStore: this.args.internalCookieStore,
       withIntl: this.args.intl,
       withXdebug: !!this.args.xdebug,
-      nativeInternalDirPath: r
-    }), await s.isReady(), s;
+      nativeInternalDirPath: o
+    }), await i.isReady(), i;
   }
   async compileInputBlueprint(t) {
-    const o = this.getEffectiveBlueprint(), n = new Ve();
-    let r = "", s = !1;
-    return n.addEventListener("progress", (i) => {
-      if (s)
+    const r = this.getEffectiveBlueprint(), s = new He();
+    let o = "", i = !1;
+    return s.addEventListener("progress", (n) => {
+      if (i)
         return;
-      s = i.detail.progress === 100;
-      const l = Math.floor(i.detail.progress);
-      r = i.detail.caption || r || "Running the Blueprint";
-      const d = `${r.trim()} – ${l}%`;
-      this.writeProgressUpdate(
-        process.stdout,
-        d,
-        s
-      );
-    }), await ke(o, {
-      progress: n,
+      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
     });
   }
@@ -491,21 +483,16 @@ class ct {
       login: this.args.login,
       ...t || {},
       preferredVersions: {
-        php: this.args.php ?? t?.preferredVersions?.php ?? q,
+        php: this.args.php ?? t?.preferredVersions?.php ?? U,
         wp: this.args.wp ?? t?.preferredVersions?.wp ?? "latest",
         ...t?.preferredVersions || {}
       }
     };
   }
-  writeProgressUpdate(t, o, n) {
-    this.args.verbosity !== Z.Quiet.name && ce(t) && o !== this.lastProgressMessage && (this.lastProgressMessage = o, t.isTTY ? (t.cursorTo(0), t.write(o), t.clearLine(1), n && t.write(`
-`)) : t.write(`${o}
-`));
-  }
 }
-async function pt(e, t = !0) {
-  const n = `${h.basename(process.argv0)}${e}${process.pid}-`, r = await je({
-    prefix: n,
+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.
      *
@@ -516,85 +503,241 @@ async function pt(e, t = !0) {
      */
     unsafeCleanup: !0
   });
-  return t && qe(), r;
+  return t && qe(), o;
 }
-async function ft(e, t, o) {
-  const r = (await ht(
+async function ht(e, t, r) {
+  const o = (await mt(
     e,
     t,
-    o
+    r
   )).map(
-    (s) => new Promise((i) => {
-      f.rm(s, { recursive: !0 }, (l) => {
-        l ? u.warn(
-          `Failed to delete stale Playground temp dir: ${s}`,
+    (i) => new Promise((n) => {
+      p.rm(i, { recursive: !0 }, (l) => {
+        l ? g.warn(
+          `Failed to delete stale Playground temp dir: ${i}`,
           l
-        ) : u.info(
-          `Deleted stale Playground temp dir: ${s}`
-        ), i();
+        ) : g.info(
+          `Deleted stale Playground temp dir: ${i}`
+        ), n();
       });
     })
   );
-  await Promise.all(r);
+  await Promise.all(o);
 }
-async function ht(e, t, o) {
+async function mt(e, t, r) {
   try {
-    const n = f.readdirSync(o).map((s) => h.join(o, s)), r = [];
-    for (const s of n)
-      await mt(
+    const s = p.readdirSync(r).map((i) => h.join(r, i)), o = [];
+    for (const i of s)
+      await ft(
         e,
         t,
-        s
-      ) && r.push(s);
-    return r;
-  } catch (n) {
-    return u.warn(`Failed to find stale Playground temp dirs: ${n}`), [];
+        i
+      ) && o.push(i);
+    return o;
+  } catch (s) {
+    return g.warn(`Failed to find stale Playground temp dirs: ${s}`), [];
   }
 }
-async function mt(e, t, o) {
-  if (!f.lstatSync(o).isDirectory())
+async function ft(e, t, r) {
+  if (!p.lstatSync(r).isDirectory())
     return !1;
-  const r = h.basename(o);
-  if (!r.includes(e))
+  const o = h.basename(r);
+  if (!o.includes(e))
     return !1;
-  const s = r.match(
+  const i = o.match(
     new RegExp(`^(.+)${e}(\\d+)-`)
   );
-  if (!s)
+  if (!i)
     return !1;
-  const i = {
-    executableName: s[1],
-    pid: s[2]
+  const n = {
+    executableName: i[1],
+    pid: i[2]
   };
-  if (await wt(i.pid, i.executableName))
+  if (await wt(n.pid, n.executableName))
     return !1;
   const l = Date.now() - t;
-  return f.statSync(o).mtime.getTime() < l;
+  return p.statSync(r).mtime.getTime() < l;
 }
 async function wt(e, t) {
-  const [o] = await new Promise(
-    (n, r) => {
-      ze.list(
+  const [r] = await new Promise(
+    (s, o) => {
+      Ye.list(
         {
           pid: e,
           name: t,
           // Remove path from executable name in the results.
           clean: !0
         },
-        (s, i) => {
-          s ? r(s) : n(i);
+        (i, n) => {
+          i ? o(i) : s(n);
         }
       );
     }
   );
-  return !!o && o.pid === e && o.command === t;
+  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;
 }
-const Z = {
-  Quiet: { name: "quiet", severity: N.Fatal },
-  Normal: { name: "normal", severity: N.Info },
-  Debug: { name: "debug", severity: N.Debug }
+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 Gt(e) {
+async function Jt(e) {
   try {
     const t = {
       "site-url": {
@@ -604,7 +747,7 @@ async function Gt(e) {
       php: {
         describe: "PHP version to use.",
         type: "string",
-        default: q,
+        default: U,
         choices: te
       },
       wp: {
@@ -618,13 +761,13 @@ async function Gt(e) {
         describe: "Mount a directory to the PHP runtime (can be used multiple times). Format: /host/path:/vfs/path",
         type: "array",
         string: !0,
-        coerce: O
+        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: O
+        coerce: _
       },
       "mount-dir": {
         describe: 'Mount a directory to the PHP runtime (can be used multiple times). Format: "/host/path" "/vfs/path"',
@@ -685,7 +828,7 @@ async function Gt(e) {
       verbosity: {
         describe: "Output logs and progress messages.",
         type: "string",
-        choices: Object.values(Z).map(
+        choices: Object.values(he).map(
           (a) => a.name
         ),
         default: "normal"
@@ -752,7 +895,7 @@ Warning: Following symlinks will expose files outside mounted directories to Pla
         // Remove the "hidden" flag once Blueprint V2 is fully supported
         hidden: !0
       }
-    }, o = {
+    }, r = {
       port: {
         describe: "Port to listen on when serving.",
         type: "number",
@@ -761,13 +904,13 @@ Warning: Following symlinks will expose files outside mounted directories to Pla
       "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 ?? Me().length - 1
+        coerce: (a) => a ?? Ce().length - 1
       },
       "experimental-devtools": {
         describe: "Enable experimental browser development tools.",
         type: "boolean"
       }
-    }, n = {
+    }, 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",
@@ -776,7 +919,7 @@ Warning: Following symlinks will expose files outside mounted directories to Pla
       php: {
         describe: "PHP version to use.",
         type: "string",
-        default: q,
+        default: U,
         choices: te
       },
       wp: {
@@ -823,7 +966,7 @@ Warning: Following symlinks will expose files outside mounted directories to Pla
         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: O
+        coerce: _
       },
       reset: {
         describe: "Deletes the stored site directory and starts a new site from scratch.",
@@ -835,13 +978,13 @@ Warning: Following symlinks will expose files outside mounted directories to Pla
         type: "boolean",
         default: !1
       }
-    }, r = {
+    }, o = {
       outfile: {
         describe: "When building, write to this output file.",
         type: "string",
         default: "wordpress.zip"
       }
-    }, s = Re(e).usage("Usage: wp-playground <command> [options]").command(
+    }, i = Re(e).usage("Usage: wp-playground <command> [options]").command(
       "start",
       "Start a local WordPress server with automatic project detection (recommended)",
       (a) => a.usage(
@@ -857,13 +1000,13 @@ Examples:
   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(n)
+      ).options(s)
     ).command(
       "server",
       "Start a local WordPress server (advanced, low-level)",
       (a) => a.options({
         ...t,
-        ...o
+        ...r
       })
     ).command(
       "run-blueprint",
@@ -874,18 +1017,18 @@ Examples:
       "Build a ZIP snapshot of a WordPress site based on a Blueprint",
       (a) => a.options({
         ...t,
-        ...r
+        ...o
       })
     ).demandCommand(1, "Please specify a command").strictCommands().conflicts(
       "experimental-unsafe-ide-integration",
       "experimental-devtools"
-    ).showHelpOnFail(!1).fail((a, y, p) => {
-      if (y)
-        throw y;
-      a && a.includes("Please specify a command") && (p.showHelp(), console.error(`
+    ).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" && !it(a.wp))
+      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 {
@@ -893,25 +1036,25 @@ Examples:
             '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 y = a["site-url"];
-      if (typeof y == "string" && y.trim() !== "")
+      const f = a["site-url"];
+      if (typeof f == "string" && f.trim() !== "")
         try {
-          new URL(y);
+          new URL(f);
         } catch {
           throw new Error(
-            `Invalid site-url "${y}". Please provide a valid URL (e.g., http://localhost:8080 or https://example.com)`
+            `Invalid site-url "${f}". Please provide a valid URL (e.g., http://localhost:8080 or https://example.com)`
           );
         }
       if (a["auto-mount"]) {
-        let p = !1;
+        let c = !1;
         try {
-          p = f.statSync(
+          c = p.statSync(
             a["auto-mount"]
           ).isDirectory();
         } catch {
-          p = !1;
+          c = !1;
         }
-        if (!p)
+        if (!c)
           throw new Error(
             `The specified --auto-mount path is not a directory: '${a["auto-mount"]}'.`
           );
@@ -942,148 +1085,162 @@ Examples:
             );
         } else
           a["wordpress-install-mode"] === "do-not-attempt-installing" ? a.mode = "apply-to-existing-site" : a.mode = "create-new-site";
-        const p = a.allow || [];
-        a.followSymlinks === !0 && p.push("follow-symlinks"), a["blueprint-may-read-adjacent-files"] === !0 && p.push("read-local-fs"), a.allow = p;
+        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;
     });
-    s.wrap(s.terminalWidth());
-    const i = await s.argv, l = i._[0];
+    i.wrap(i.terminalWidth());
+    const n = await i.argv, l = n._[0];
     ["start", "run-blueprint", "server", "build-snapshot"].includes(
       l
-    ) || (s.showHelp(), process.exit(1));
-    const d = {
-      ...i,
+    ) || (i.showHelp(), process.exit(1));
+    const u = {
+      ...n,
       command: l,
       mount: [
-        ...i.mount || [],
-        ...i["mount-dir"] || []
+        ...n.mount || [],
+        ...n["mount-dir"] || []
       ],
       "mount-before-install": [
-        ...i["mount-before-install"] || [],
-        ...i["mount-dir-before-install"] || []
+        ...n["mount-before-install"] || [],
+        ...n["mount-dir-before-install"] || []
       ]
-    }, b = await Pt(d);
+    }, b = await St(u);
     b === void 0 && process.exit(0);
-    const g = /* @__PURE__ */ (() => {
+    const v = /* @__PURE__ */ (() => {
       let a;
       return async () => {
         a !== void 0 && (a = b[Symbol.asyncDispose]()), await a, process.exit(0);
       };
     })();
-    process.on("SIGINT", g), process.on("SIGTERM", g);
+    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 n = [];
-      let r = t;
+      const s = [];
+      let o = t;
       do
-        n.push(r.message), r = r.cause;
-      while (r instanceof Error);
+        s.push(o.message), o = o.cause;
+      while (o instanceof Error);
       console.error(
-        "\x1B[1m" + n.join(" caused by: ") + "\x1B[0m"
+        "\x1B[1m" + s.join(" caused by: ") + "\x1B[0m"
       );
     }
     process.exit(1);
   }
 }
-function ie(e, t) {
+function ne(e, t) {
   return e.find(
-    (o) => o.vfsPath.replace(/\/$/, "") === t.replace(/\/$/, "")
+    (r) => r.vfsPath.replace(/\/$/, "") === t.replace(/\/$/, "")
   );
 }
-const gt = Symbol("playground-cli-testing"), E = (e) => process.stdout.isTTY ? "\x1B[1m" + e + "\x1B[0m" : e, yt = (e) => process.stdout.isTTY ? "\x1B[31m" + e + "\x1B[0m" : e, bt = (e) => process.stdout.isTTY ? `\x1B[2m${e}\x1B[0m` : e, _ = (e) => process.stdout.isTTY ? `\x1B[3m${e}\x1B[0m` : e, ae = (e) => process.stdout.isTTY ? `\x1B[33m${e}\x1B[0m` : e;
-async function Pt(e) {
-  let t, o;
-  const n = /* @__PURE__ */ new Map();
-  if (e.command === "start" && (e = vt(e)), e.autoMount !== void 0 && (e.autoMount === "" && (e = { ...e, autoMount: process.cwd() }), e = ue(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 g = Object.values(Z).find(
-      (a) => a.name === e.verbosity
+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;
-    u.setSeverityFilterLevel(g);
+    g.setSeverityFilterLevel(a);
   }
   e.intl || (e.intl = !0);
-  const r = e.command === "server" ? e.port ?? 9400 : 0, s = U.platform() === "win32" ? (
+  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((g) => g.flockSync).catch(() => {
-    u.warn(
+  ) : 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."
     );
-  }), i = new We(s);
-  let l = !1, d = !0;
-  u.log("Starting a PHP server...");
-  const b = await ot({
-    port: r,
-    onBind: async (g, a) => {
-      const y = "127.0.0.1", p = `http://${y}:${a}`, I = e["site-url"] || p, v = e.command === "server" ? e.experimentalMultiWorker ?? 1 : 1, W = e.command === "server" ? (
+  }), 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.
-        v + 1
-      ) : v, F = 2 ** 31 - 1, k = Math.floor(
-        F / W
-      ), J = "-playground-cli-site-", $ = await pt(J);
-      u.debug(`Native temp dir for VFS root: ${$.path}`);
-      const B = "WP Playground CLI - Listen for Xdebug", Q = ".playground-xdebug-root", K = h.join(process.cwd(), Q);
-      if (await Xe(K), e.xdebug && e.experimentalUnsafeIdeIntegration) {
-        await Ye(
-          $.path,
+        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 c = {
-          hostPath: h.join(".", h.sep, Q),
+        const d = {
+          hostPath: h.join(".", h.sep, J),
           vfsPath: "/"
         };
         try {
-          await Ze(B, process.cwd());
-          const w = typeof e.xdebug == "object" ? e.xdebug : void 0, x = await Ge({
-            name: B,
-            host: y,
-            port: a,
+          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: [
-              c,
+              d,
               ...e["mount-before-install"] || [],
               ...e.mount || []
             ],
             ideKey: w?.ideKey
-          }), m = e.experimentalUnsafeIdeIntegration, P = m.includes("vscode"), S = m.includes("phpstorm"), L = Object.values(x);
-          console.log(""), L.length > 0 ? (console.log(E("Xdebug configured successfully")), console.log(
-            ae("Updated IDE config: ") + L.join(" ")
+          }), 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" + _(
-              bt(
+            ae("Playground source root: ") + ".playground-xdebug-root" + q(
+              Pt(
                 " – you can set breakpoints and preview Playground's VFS structure in there."
               )
             )
-          )) : (console.log(E("Xdebug configuration failed.")), console.log(
+          )) : (console.log(T("Xdebug configuration failed.")), console.log(
             "No IDE-specific project settings directory was found in the current working directory."
-          )), console.log(""), P && x.vscode && (console.log(E("VS Code / Cursor instructions:")), console.log(
+          )), 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 ${E("PHP Debug")} extension by ${E(
+            `     (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 "${_(
-              B
+            `  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"
-          ), S && console.log("")), S && x.phpstorm && (console.log(E("PhpStorm instructions:")), console.log(
-            `  1. Choose "${_(
-              B
+          ), 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"
@@ -1096,14 +1253,14 @@ async function Pt(e) {
           });
         }
       }
-      const he = h.dirname($.path), me = 2 * 24 * 60 * 60 * 1e3;
-      ft(
-        J,
-        me,
-        he
+      const me = h.dirname(I.path), fe = 2 * 24 * 60 * 60 * 1e3;
+      ht(
+        G,
+        fe,
+        me
       );
-      const A = h.join($.path, "internal");
-      z(A);
+      const H = h.join(I.path, "internal");
+      z(H);
       const we = [
         "wordpress",
         // Note: These dirs are from Emscripten's "default dirs" list:
@@ -1115,160 +1272,159 @@ async function Pt(e) {
         "tmp",
         "home"
       ];
-      for (const c of we) {
-        const w = (m) => m.vfsPath === `/${c}`;
+      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(
-            $.path,
-            c
+            I.path,
+            d
           );
           z(m), e["mount-before-install"] === void 0 && (e["mount-before-install"] = []), e["mount-before-install"].unshift({
-            vfsPath: `/${c}`,
+            vfsPath: `/${d}`,
             hostPath: m
           });
         }
       }
       if (e["mount-before-install"])
-        for (const c of e["mount-before-install"])
-          u.debug(
-            `Mount before WP install: ${c.vfsPath} -> ${c.hostPath}`
+        for (const d of e["mount-before-install"])
+          g.debug(
+            `Mount before WP install: ${d.vfsPath} -> ${d.hostPath}`
           );
       if (e.mount)
-        for (const c of e.mount)
-          u.debug(
-            `Mount after WP install: ${c.vfsPath} -> ${c.hostPath}`
+        for (const d of e.mount)
+          g.debug(
+            `Mount after WP install: ${d.vfsPath} -> ${d.hostPath}`
           );
-      let T;
-      e["experimental-blueprints-v2-runner"] ? T = new lt(e, {
-        siteUrl: I,
-        processIdSpaceLength: k
-      }) : (T = new ct(e, {
-        siteUrl: I,
-        processIdSpaceLength: k
+      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 H = !1;
-      const M = async function() {
-        H || (H = !0, await Promise.all(
-          [...n].map(
-            async ([w, x]) => {
-              await x.dispose(), await w.terminate();
+      let V = !1;
+      const R = async function() {
+        V || (V = !0, await Promise.all(
+          [...s].map(
+            async ([w, P]) => {
+              await P.dispose(), await w.terminate();
             }
           )
-        ), g && await new Promise((w) => g.close(w)), await $.cleanup());
+        ), a && await new Promise((w) => a.close(w)), await I.cleanup());
       }, ge = kt(
         W,
-        T.getWorkerType(),
-        ({ exitCode: c, workerIndex: w }) => {
-          H || c === 0 && u.error(
-            `Worker ${w} exited with code ${c}
+        $.getWorkerType(),
+        ({ exitCode: d, workerIndex: w }) => {
+          V || d === 0 && g.error(
+            `Worker ${w} exited with code ${d}
 `
           );
         }
       );
-      u.log("Starting up workers");
+      o.startProgress("Starting...");
       try {
-        const c = await ge, w = await le(i);
+        const d = await ge, w = await le(l);
         {
-          const m = c.shift(), P = await T.bootAndSetUpInitialPlayground(
+          const m = d.shift(), y = await $.bootAndSetUpInitialPlayground(
             m.phpPort,
             w,
-            A
+            H
           );
-          if (n.set(
+          if (s.set(
             m.worker,
-            P
-          ), await P.isReady(), l = !0, u.log("Booted!"), t = new nt(P), !e["experimental-blueprints-v2-runner"]) {
-            const S = await T.compileInputBlueprint(
+            y
+          ), await y.isReady(), u = !0, t = new it(y), !e["experimental-blueprints-v2-runner"]) {
+            const x = await $.compileInputBlueprint(
               e["additional-blueprint-steps"] || []
             );
-            S && (u.log("Running the Blueprint..."), await Se(
-              S,
-              P
-            ), u.log("Finished running the blueprint"));
+            x && await ke(
+              x,
+              y
+            );
           }
           if (e.command === "build-snapshot") {
-            await It(o, e.outfile), u.log(`WordPress exported to ${e.outfile}`), await M();
+            await Tt(r, e.outfile), o.printStatus(`Exported to ${e.outfile}`), await R();
             return;
           } else if (e.command === "run-blueprint") {
-            u.log("Blueprint executed"), await M();
+            o.finishProgress("Done"), await R();
             return;
           }
-          await t.removeWorker(P), await P.dispose(), await m.worker.terminate(), n.delete(m.worker);
+          await t.removeWorker(y), await y.dispose(), await m.worker.terminate(), s.delete(m.worker);
         }
-        u.log("Preparing workers...");
-        const x = k;
-        return [o] = await Promise.all(
-          c.map(async (m, P) => {
-            const S = x + P * k, L = await le(i), V = await T.bootPlayground({
+        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: L,
-              firstProcessId: S,
-              nativeInternalDirPath: A
+              fileLockManagerPort: D,
+              firstProcessId: x,
+              nativeInternalDirPath: H
             });
-            return n.set(
+            return s.set(
               m.worker,
-              V
-            ), t.addWorker(V), V;
+              N
+            ), t.addWorker(N), N;
           })
-        ), u.log(
-          `WordPress is running on ${p} with ${v} worker(s)`
-        ), e.xdebug && e.experimentalDevtools && (await Oe({
-          phpInstance: o,
+        ), o.finishProgress(), o.printReady(S, k), e.xdebug && e.experimentalDevtools && (await Ne({
+          phpInstance: r,
           phpRoot: "/wordpress"
         })).start(), {
-          playground: o,
-          server: g,
-          serverUrl: p,
-          [Symbol.asyncDispose]: M,
-          [gt]: {
-            workerThreadCount: v,
-            getWorkerNumberFromProcessId: (m) => Math.floor(m / k)
+          playground: r,
+          server: a,
+          serverUrl: S,
+          [Symbol.asyncDispose]: R,
+          [bt]: {
+            workerThreadCount: k,
+            getWorkerNumberFromProcessId: (m) => Math.floor(m / L)
           }
         };
-      } catch (c) {
+      } catch (d) {
         if (e.verbosity !== "debug")
-          throw c;
+          throw d;
         let w = "";
-        throw await o?.fileExists(ee) && (w = await o.readFileAsText(ee)), await M(), new Error(w, { cause: c });
+        throw await r?.fileExists(ee) && (w = await r.readFileAsText(ee)), await R(), new Error(w, { cause: d });
       }
     },
-    async handleRequest(g) {
-      if (!l)
-        return j.forHttpCode(
+    async handleRequest(a) {
+      if (!u)
+        return Y.forHttpCode(
           502,
           "WordPress is not ready yet"
         );
-      if (d) {
-        d = !1;
-        const a = {
+      if (b) {
+        b = !1;
+        const f = {
           "Content-Type": ["text/plain"],
           "Content-Length": ["0"],
-          Location: [g.url]
+          Location: [a.url]
         };
-        return g.headers?.cookie?.includes(
+        return a.headers?.cookie?.includes(
           "playground_auto_login_already_happened"
-        ) && (a["Set-Cookie"] = [
+        ) && (f["Set-Cookie"] = [
           "playground_auto_login_already_happened=1; Max-Age=0; Expires=Thu, 01 Jan 1970 00:00:00 GMT; Path=/"
-        ]), new j(302, a, new Uint8Array());
+        ]), new Y(302, f, new Uint8Array());
       }
-      return await t.handleRequest(g);
+      return await t.handleRequest(a);
     }
   });
-  return b && e.command === "start" && !e.skipBrowser && St(b.serverUrl), b;
+  return v && e.command === "start" && !e.skipBrowser && $t(v.serverUrl), v;
 }
-function vt(e) {
+function xt(e) {
   let t = { ...e, command: "server" };
-  e.noAutoMount || (t.autoMount = h.resolve(process.cwd(), t.path ?? ""), t = ue(t), delete t.autoMount);
-  const o = ie(
+  e.noAutoMount || (t.autoMount = h.resolve(process.cwd(), t.path ?? ""), t = de(t), delete t.autoMount);
+  const r = ne(
     t["mount-before-install"] || [],
     "/wordpress"
-  ) || ie(t.mount || [], "/wordpress");
-  if (o)
-    console.log("Site files stored at:", o?.hostPath), e.reset && (console.log(""), console.log(
-      yt(
+  ) || 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(
@@ -1277,15 +1433,15 @@ function vt(e) {
       "You may still remove the site's directory manually if you wish."
     ), process.exit(1));
   else {
-    const n = t.autoMount || process.cwd(), r = Je("sha256").update(n).digest("hex"), s = U.homedir(), i = h.join(
-      s,
+    const s = t.autoMount || process.cwd(), o = Ge("sha256").update(s).digest("hex"), i = O.homedir(), n = h.join(
+      i,
       ".wordpress-playground/sites",
-      r
+      o
     );
-    console.log("Site files stored at:", i), Y(i) && e.reset && (console.log("Resetting site..."), $e(i, { recursive: !0 })), z(i, { recursive: !0 }), t["mount-before-install"] = [
+    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: i }
-    ], t.wordpressInstallMode = Te(i).length === 0 ? (
+      { 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"
@@ -1296,62 +1452,62 @@ function vt(e) {
   }
   return t;
 }
-async function kt(e, t, o) {
-  const n = [];
-  for (let r = 0; r < e; r++) {
-    const i = xt(t, { onExit: (l) => {
-      o({
+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: r
+        workerIndex: o
       });
     } });
-    n.push(i);
+    s.push(n);
   }
-  return Promise.all(n);
+  return Promise.all(s);
 }
-function xt(e, { onExit: t } = {}) {
-  let o;
-  return e === "v1" ? o = new re(new URL("./worker-thread-v1.js", import.meta.url)) : o = new re(new URL("./worker-thread-v2.js", import.meta.url)), new Promise((n, r) => {
-    o.once("message", function(i) {
-      i.command === "worker-script-initialized" && n({ worker: o, phpPort: i.phpPort });
-    }), o.once("error", function(i) {
-      console.error(i);
+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. ${i.message ? `Original error: ${i.message}` : ""}`
+        `Worker failed to load worker. ${n.message ? `Original error: ${n.message}` : ""}`
       );
-      r(l);
+      o(l);
     });
-    let s = !1;
-    o.once("spawn", () => {
-      s = !0;
-    }), o.once("exit", (i) => {
-      s || r(new Error(`Worker exited before spawning: ${i}`)), t?.(i);
+    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: o } = new Ee();
-  return await Le() ? be(e, null, t) : await Pe(e, t), o;
+  const { port1: t, port2: r } = new Be();
+  return await Me() ? be(e, null, t) : await ve(e, t), r;
 }
-function St(e) {
-  const t = U.platform();
-  let o;
+function $t(e) {
+  const t = O.platform();
+  let r;
   switch (t) {
     case "darwin":
-      o = `open "${e}"`;
+      r = `open "${e}"`;
       break;
     case "win32":
-      o = `start "" "${e}"`;
+      r = `start "" "${e}"`;
       break;
     default:
-      o = `xdg-open "${e}"`;
+      r = `xdg-open "${e}"`;
       break;
   }
-  _e(o, (n) => {
-    n && u.debug(`Could not open browser: ${n.message}`);
+  je(r, (s) => {
+    s && g.debug(`Could not open browser: ${s.message}`);
   });
 }
-async function It(e, t) {
+async function Tt(e, t) {
   await e.run({
     code: `<?php
 		$zip = new ZipArchive();
@@ -1372,16 +1528,16 @@ async function It(e, t) {
 
 	`
   });
-  const o = await e.readFileAsBuffer("/tmp/build.zip");
-  f.writeFileSync(t, o);
+  const r = await e.readFileAsBuffer("/tmp/build.zip");
+  p.writeFileSync(t, r);
 }
 export {
-  Z as L,
-  ce as a,
-  gt as i,
-  Zt as m,
-  Gt as p,
-  Pt as r,
-  xt as s
+  he as L,
+  gt as a,
+  bt as i,
+  Gt as m,
+  Jt as p,
+  St as r,
+  It as s
 };
-//# sourceMappingURL=run-cli-vem_UKTF.js.map
+//# sourceMappingURL=run-cli-NcKUE5gJ.js.map