@wp-playground/cli 3.0.15 → 3.0.16

package/run-cli-B59N7dQd.js

@@ -0,0 +1,1325 @@
+import { logger as m, LogSeverity as M, errorLogPath as _ } from "@php-wasm/logger";
+import { PHPResponse as U, consumeAPI as j, SupportedPHPVersions as ce, printDebugDetails as pe, exposeAPI as ue, exposeSyncAPI as de } from "@php-wasm/universal";
+import { resolveRemoteBlueprint as fe, resolveRuntimeConfiguration as me, compileBlueprintV1 as he, isBlueprintBundle as ge, runBlueprintV1Steps as ye } from "@wp-playground/blueprints";
+import { zipDirectory as we, RecommendedPHPVersion as Z } from "@wp-playground/common";
+import u, { mkdirSync as H } from "fs";
+import { Worker as q, MessageChannel as be } from "worker_threads";
+import { p as z, a as ve, e as Pe } from "./mounts-D1_eXSTw.js";
+import Se from "express";
+import { FileLockManagerForNode as ke } from "@php-wasm/node";
+import Y, { cpus as xe } from "os";
+import { jspi as Ee } from "wasm-feature-detect";
+import Ie from "yargs";
+import g, { basename as Ce } from "path";
+import { NodeJsFilesystem as Le, OverlayFilesystem as We, InMemoryFilesystem as $e, ZipFilesystem as Te } from "@wp-playground/storage";
+import { EmscriptenDownloadMonitor as Be, ProgressTracker as je } from "@php-wasm/progress";
+import { resolveWordPressRelease as Fe } from "@wp-playground/wordpress";
+import T from "fs-extra";
+import { startBridge as Re } from "@php-wasm/xdebug-bridge";
+import { dir as Me, setGracefulCleanup as De } from "tmp-promise";
+import Ae from "ps-man";
+import { XMLParser as K, XMLBuilder as Q } from "fast-xml-parser";
+import v from "jsonc-parser";
+async function Ue(e) {
+  const o = Se(), t = await new Promise((n, s) => {
+    const l = o.listen(e.port, () => {
+      const a = l.address();
+      a === null || typeof a == "string" ? s(new Error("Server address is not available")) : n(l);
+    });
+  });
+  o.use("/", async (n, s) => {
+    let l;
+    try {
+      l = await e.handleRequest({
+        url: n.url,
+        headers: Ve(n),
+        method: n.method,
+        body: await Ne(n)
+      });
+    } catch (a) {
+      m.error(a), l = U.forHttpCode(500);
+    }
+    s.statusCode = l.httpStatusCode;
+    for (const a in l.headers)
+      s.setHeader(a, l.headers[a]);
+    s.end(l.bytes);
+  });
+  const r = t.address().port;
+  return await e.onBind(t, r);
+}
+const Ne = async (e) => await new Promise((o) => {
+  const t = [];
+  e.on("data", (i) => {
+    t.push(i);
+  }), e.on("end", () => {
+    o(new Uint8Array(Buffer.concat(t)));
+  });
+}), Ve = (e) => {
+  const o = {};
+  if (e.rawHeaders && e.rawHeaders.length)
+    for (let t = 0; t < e.rawHeaders.length; t += 2)
+      o[e.rawHeaders[t].toLowerCase()] = e.rawHeaders[t + 1];
+  return o;
+};
+class Oe {
+  constructor(o) {
+    this.workerLoads = [], this.addWorker(o);
+  }
+  addWorker(o) {
+    this.workerLoads.push({
+      worker: o,
+      activeRequests: /* @__PURE__ */ new Set()
+    });
+  }
+  async handleRequest(o) {
+    let t = this.workerLoads[0];
+    for (let r = 1; r < this.workerLoads.length; r++) {
+      const n = this.workerLoads[r];
+      n.activeRequests.size < t.activeRequests.size && (t = n);
+    }
+    const i = t.worker.request(o);
+    return t.activeRequests.add(i), i.url = o.url, i.finally(() => {
+      t.activeRequests.delete(i);
+    });
+  }
+}
+function _e(e) {
+  return /^latest$|^trunk$|^nightly$|^(?:(\d+)\.(\d+)(?:\.(\d+))?)((?:-beta(?:\d+)?)|(?:-RC(?:\d+)?))?$/.test(e);
+}
+async function He({
+  sourceString: e,
+  blueprintMayReadAdjacentFiles: o
+}) {
+  if (!e)
+    return;
+  if (e.startsWith("http://") || e.startsWith("https://"))
+    return await fe(e);
+  let t = g.resolve(process.cwd(), e);
+  if (!u.existsSync(t))
+    throw new Error(`Blueprint file does not exist: ${t}`);
+  const i = u.statSync(t);
+  if (i.isDirectory() && (t = g.join(t, "blueprint.json")), !i.isFile() && i.isSymbolicLink())
+    throw new Error(
+      `Blueprint path is neither a file nor a directory: ${t}`
+    );
+  const r = g.extname(t);
+  switch (r) {
+    case ".zip":
+      return Te.fromArrayBuffer(
+        u.readFileSync(t).buffer
+      );
+    case ".json": {
+      const n = u.readFileSync(t, "utf-8");
+      try {
+        JSON.parse(n);
+      } catch {
+        throw new Error(
+          `Blueprint file at ${t} is not a valid JSON file`
+        );
+      }
+      const s = g.dirname(t), l = new Le(s);
+      return new We([
+        new $e({
+          "blueprint.json": n
+        }),
+        /**
+         * Wrap the NodeJS filesystem to prevent access to local files
+         * unless the user explicitly allowed it.
+         */
+        {
+          read(a) {
+            if (!o)
+              throw new Error(
+                `Error: Blueprint contained tried to read a local file at path "${a}" (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(a);
+          }
+        }
+      ]);
+    }
+    default:
+      throw new Error(
+        `Unsupported blueprint file extension: ${r}. Only .zip and .json files are supported.`
+      );
+  }
+}
+class qe {
+  constructor(o, t) {
+    this.lastProgressMessage = "", this.args = o, this.siteUrl = t.siteUrl, this.processIdSpaceLength = t.processIdSpaceLength, this.phpVersion = o.php;
+  }
+  getWorkerType() {
+    return "v2";
+  }
+  async bootPrimaryWorker(o, t, i) {
+    const r = j(o);
+    await r.useFileLockManager(t);
+    const n = {
+      ...this.args,
+      phpVersion: this.phpVersion,
+      siteUrl: this.siteUrl,
+      firstProcessId: 1,
+      processIdSpaceLength: this.processIdSpaceLength,
+      trace: this.args.debug || !1,
+      blueprint: this.args.blueprint,
+      withXdebug: !!this.args.xdebug,
+      xdebug: typeof this.args.xdebug == "object" ? this.args.xdebug : void 0,
+      nativeInternalDirPath: i
+    };
+    return await r.bootAsPrimaryWorker(n), r;
+  }
+  async bootSecondaryWorker({
+    worker: o,
+    fileLockManagerPort: t,
+    firstProcessId: i,
+    nativeInternalDirPath: r
+  }) {
+    const n = j(o.phpPort);
+    await n.useFileLockManager(t);
+    const s = {
+      ...this.args,
+      phpVersion: this.phpVersion,
+      siteUrl: this.siteUrl,
+      firstProcessId: i,
+      processIdSpaceLength: this.processIdSpaceLength,
+      trace: this.args.debug || !1,
+      withXdebug: !!this.args.xdebug,
+      nativeInternalDirPath: r,
+      mountsBeforeWpInstall: this.args["mount-before-install"] || [],
+      mountsAfterWpInstall: this.args.mount || []
+    };
+    return await n.bootAsSecondaryWorker(s), n;
+  }
+  writeProgressUpdate(o, t, i) {
+    t !== this.lastProgressMessage && (this.lastProgressMessage = t, o.isTTY ? (o.cursorTo(0), o.write(t), o.clearLine(1), i && o.write(`
+`)) : o.write(`${t}
+`));
+  }
+}
+const N = g.join(Y.homedir(), ".wordpress-playground");
+async function ze(e) {
+  return await G(
+    "https://github.com/WordPress/sqlite-database-integration/archive/refs/heads/develop.zip",
+    "sqlite.zip",
+    e
+  );
+}
+async function G(e, o, t) {
+  const i = g.join(N, o);
+  return T.existsSync(i) || (T.ensureDirSync(N), await Xe(e, i, t)), ee(i);
+}
+async function Xe(e, o, t) {
+  const r = (await t.monitorFetch(fetch(e))).body.getReader(), n = `${o}.partial`, s = T.createWriteStream(n);
+  for (; ; ) {
+    const { done: l, value: a } = await r.read();
+    if (a && s.write(a), l)
+      break;
+  }
+  s.close(), s.closed || await new Promise((l, a) => {
+    s.on("finish", () => {
+      T.renameSync(n, o), l(null);
+    }), s.on("error", (p) => {
+      T.removeSync(n), a(p);
+    });
+  });
+}
+function ee(e, o) {
+  return new File([T.readFileSync(e)], Ce(e));
+}
+class Je {
+  constructor(o, t) {
+    this.lastProgressMessage = "", this.args = o, this.siteUrl = t.siteUrl, this.processIdSpaceLength = t.processIdSpaceLength;
+  }
+  getWorkerType() {
+    return "v1";
+  }
+  async bootPrimaryWorker(o, t, i) {
+    let r;
+    const n = new Be();
+    if (!this.args.skipWordPressSetup) {
+      let C = !1;
+      n.addEventListener("progress", (x) => {
+        if (C)
+          return;
+        const { loaded: k, total: f } = x.detail, B = Math.floor(
+          Math.min(100, 100 * k / f)
+        );
+        C = B === 100, this.writeProgressUpdate(
+          process.stdout,
+          `Downloading WordPress ${B}%...`,
+          C
+        );
+      }), r = await Fe(this.args.wp), m.log(
+        `Resolved WordPress release URL: ${r?.releaseUrl}`
+      );
+    }
+    const s = r && g.join(
+      N,
+      `prebuilt-wp-content-for-wp-${r.version}.zip`
+    ), l = r ? u.existsSync(s) ? ee(s) : await G(
+      r.releaseUrl,
+      `${r.version}.zip`,
+      n
+    ) : void 0;
+    m.log("Fetching SQLite integration plugin...");
+    const a = this.args.skipSqliteSetup ? void 0 : await ze(n), p = this.args.followSymlinks === !0, c = this.args.experimentalTrace === !0, d = this.args["mount-before-install"] || [], h = this.args.mount || [], w = j(o);
+    await w.isConnected(), m.log("Booting WordPress...");
+    const b = await me(
+      this.getEffectiveBlueprint()
+    );
+    return await w.useFileLockManager(t), await w.bootAsPrimaryWorker({
+      phpVersion: b.phpVersion,
+      wpVersion: b.wpVersion,
+      siteUrl: this.siteUrl,
+      mountsBeforeWpInstall: d,
+      mountsAfterWpInstall: h,
+      wordPressZip: l && await l.arrayBuffer(),
+      sqliteIntegrationPluginZip: await a?.arrayBuffer(),
+      firstProcessId: 0,
+      processIdSpaceLength: this.processIdSpaceLength,
+      followSymlinks: p,
+      trace: c,
+      internalCookieStore: this.args.internalCookieStore,
+      withXdebug: !!this.args.xdebug,
+      nativeInternalDirPath: i
+    }), r && !this.args["mount-before-install"] && !u.existsSync(s) && (m.log("Caching preinstalled WordPress for the next boot..."), u.writeFileSync(
+      s,
+      await we(w, "/wordpress")
+    ), m.log("Cached!")), w;
+  }
+  async bootSecondaryWorker({
+    worker: o,
+    fileLockManagerPort: t,
+    firstProcessId: i,
+    nativeInternalDirPath: r
+  }) {
+    const n = j(
+      o.phpPort
+    );
+    return await n.isConnected(), await n.useFileLockManager(t), await n.bootAsSecondaryWorker({
+      phpVersion: this.phpVersion,
+      siteUrl: this.siteUrl,
+      mountsBeforeWpInstall: this.args["mount-before-install"] || [],
+      mountsAfterWpInstall: this.args.mount || [],
+      firstProcessId: i,
+      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,
+      withXdebug: !!this.args.xdebug,
+      nativeInternalDirPath: r
+    }), await n.isReady(), n;
+  }
+  async compileInputBlueprint(o) {
+    const t = this.getEffectiveBlueprint(), i = new je();
+    let r = "", n = !1;
+    return i.addEventListener("progress", (s) => {
+      if (n)
+        return;
+      n = s.detail.progress === 100;
+      const l = Math.floor(s.detail.progress);
+      r = s.detail.caption || r || "Running the Blueprint";
+      const a = `${r.trim()} – ${l}%`;
+      this.writeProgressUpdate(
+        process.stdout,
+        a,
+        n
+      );
+    }), await he(t, {
+      progress: i,
+      additionalSteps: o
+    });
+  }
+  getEffectiveBlueprint() {
+    const o = this.args.blueprint;
+    return ge(o) ? o : {
+      login: this.args.login,
+      ...o || {},
+      preferredVersions: {
+        php: this.args.php ?? o?.preferredVersions?.php ?? Z,
+        wp: this.args.wp ?? o?.preferredVersions?.wp ?? "latest",
+        ...o?.preferredVersions || {}
+      }
+    };
+  }
+  writeProgressUpdate(o, t, i) {
+    this.args.verbosity !== V.Quiet.name && t !== this.lastProgressMessage && (this.lastProgressMessage = t, o.isTTY ? (o.cursorTo(0), o.write(t), o.clearLine(1), i && o.write(`
+`)) : o.write(`${t}
+`));
+  }
+}
+async function Ze(e, o = !0) {
+  const i = `${g.basename(process.argv0)}${e}${process.pid}-`, r = (await Me({
+    prefix: i,
+    /*
+     * 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
+  })).path;
+  return o && De(), r;
+}
+async function Ye(e, o, t) {
+  const r = (await Ke(
+    e,
+    o,
+    t
+  )).map(
+    (n) => new Promise((s) => {
+      u.rm(n, { recursive: !0 }, (l) => {
+        l ? m.warn(
+          `Failed to delete stale Playground temp dir: ${n}`,
+          l
+        ) : m.info(
+          `Deleted stale Playground temp dir: ${n}`
+        ), s();
+      });
+    })
+  );
+  await Promise.all(r);
+}
+async function Ke(e, o, t) {
+  try {
+    const i = u.readdirSync(t).map((n) => g.join(t, n)), r = [];
+    for (const n of i)
+      await Qe(
+        e,
+        o,
+        n
+      ) && r.push(n);
+    return r;
+  } catch (i) {
+    return m.warn(`Failed to find stale Playground temp dirs: ${i}`), [];
+  }
+}
+async function Qe(e, o, t) {
+  if (!u.lstatSync(t).isDirectory())
+    return !1;
+  const r = g.basename(t);
+  if (!r.includes(e))
+    return !1;
+  const n = r.match(
+    new RegExp(`^(.+)${e}(\\d+)-`)
+  );
+  if (!n)
+    return !1;
+  const s = {
+    executableName: n[1],
+    pid: n[2]
+  };
+  if (await Ge(s.pid, s.executableName))
+    return !1;
+  const l = Date.now() - o;
+  return u.statSync(t).mtime.getTime() < l;
+}
+async function Ge(e, o) {
+  const [t] = await new Promise(
+    (i, r) => {
+      Ae.list(
+        {
+          pid: e,
+          name: o,
+          // Remove path from executable name in the results.
+          clean: !0
+        },
+        (n, s) => {
+          n ? r(n) : i(s);
+        }
+      );
+    }
+  );
+  return !!t && t.pid === e && t.command === o;
+}
+async function et(e, o, t) {
+  const i = t === "win32" ? (
+    // On Windows, creating a 'dir' symlink can require elevated permissions.
+    // In this case, let's make junction points because they function like
+    // symlinks and do not require elevated permissions.
+    "junction"
+  ) : "dir";
+  u.symlinkSync(e, o, i);
+}
+async function tt(e) {
+  try {
+    u.lstatSync(e).isSymbolicLink() && u.unlinkSync(e);
+  } catch {
+  }
+}
+function ot(e, o) {
+  return o.filter((t) => {
+    const i = g.resolve(t.hostPath), r = g.join(e, g.sep);
+    return (
+      // If auto-mounting from the current directory,
+      // the entire project directory can be mapped.
+      i === e || i.startsWith(r)
+    );
+  });
+}
+const I = {
+  ignoreAttributes: !1,
+  attributeNamePrefix: "",
+  preserveOrder: !0,
+  cdataPropName: "__cdata",
+  commentPropName: "__xmlComment",
+  allowBooleanAttributes: !0,
+  trimValues: !0
+}, te = {
+  ignoreAttributes: I.ignoreAttributes,
+  attributeNamePrefix: I.attributeNamePrefix,
+  preserveOrder: I.preserveOrder,
+  cdataPropName: I.cdataPropName,
+  commentPropName: I.commentPropName,
+  suppressBooleanAttributes: !I.allowBooleanAttributes,
+  format: !0,
+  indentBy: "	"
+}, F = {
+  allowEmptyContent: !0,
+  allowTrailingComma: !0
+};
+function rt(e, o) {
+  const { name: t, host: i, port: r, mappings: n, ideKey: s } = o, l = new K(I), a = (() => {
+    try {
+      return l.parse(e, !0);
+    } catch {
+      throw new Error("PhpStorm configuration file is not valid XML.");
+    }
+  })(), p = {
+    server: [
+      {
+        path_mappings: n.map((f) => ({
+          mapping: [],
+          ":@": {
+            "local-root": `$PROJECT_DIR$/${f.hostPath.replace(
+              /^\.\/?/,
+              ""
+            )}`,
+            "remote-root": f.vfsPath
+          }
+        }))
+      }
+    ],
+    ":@": {
+      name: t,
+      // NOTE: PhpStorm quirk: Xdebug only works when the full URL (including port)
+      // is provided in `host`. The separate `port` field is ignored or misinterpreted,
+      // so we rely solely on host: "host:port".
+      host: `${i}:${r}`,
+      use_path_mappings: "true"
+    }
+  };
+  let c = a?.find((f) => !!f?.project);
+  if (c) {
+    const f = c[":@"]?.version;
+    if (f === void 0)
+      throw new Error(
+        'PhpStorm IDE integration only supports <project version="4"> in workspace.xml, but the <project> configuration has no version number.'
+      );
+    if (f !== "4")
+      throw new Error(
+        `PhpStorm IDE integration only supports <project version="4"> in workspace.xml, but we found a <project> configuration with version "${f}".`
+      );
+  }
+  c === void 0 && (c = {
+    project: [],
+    ":@": { version: "4" }
+  }, a.push(c));
+  let d = c.project?.find(
+    (f) => !!f?.component && f?.[":@"]?.name === "PhpServers"
+  );
+  d === void 0 && (d = {
+    component: [],
+    ":@": { name: "PhpServers" }
+  }, c.project === void 0 && (c.project = []), c.project.push(d));
+  let h = d.component?.find(
+    (f) => !!f?.servers
+  );
+  h === void 0 && (h = { servers: [] }, d.component === void 0 && (d.component = []), d.component.push(h));
+  const w = h.servers?.findIndex(
+    (f) => !!f?.server && f?.[":@"]?.name === t
+  );
+  (w === void 0 || w < 0) && (h.servers === void 0 && (h.servers = []), h.servers.push(p));
+  let b = c.project?.find(
+    (f) => !!f?.component && f?.[":@"]?.name === "RunManager"
+  );
+  if (b === void 0 && (b = {
+    component: [],
+    ":@": { name: "RunManager" }
+  }, c.project === void 0 && (c.project = []), c.project.push(b)), (b.component?.findIndex(
+    (f) => !!f?.configuration && f?.[":@"]?.name === t
+  ) ?? -1) < 0) {
+    const f = {
+      configuration: [
+        {
+          method: [],
+          ":@": { v: "2" }
+        }
+      ],
+      ":@": {
+        name: t,
+        type: "PhpRemoteDebugRunConfigurationType",
+        factoryName: "PHP Remote Debug",
+        filter_connections: "FILTER",
+        server_name: t,
+        session_id: s
+      }
+    };
+    b.component === void 0 && (b.component = []), b.component.push(f);
+  }
+  const k = new Q(te).build(a);
+  try {
+    l.parse(k, !0);
+  } catch {
+    throw new Error(
+      "The resulting PhpStorm configuration file is not valid XML."
+    );
+  }
+  return k;
+}
+function nt(e, o) {
+  const { name: t, mappings: i } = o, r = [];
+  let n = e, s = v.parseTree(n, r, F);
+  if (s === void 0 || r.length)
+    throw new Error("VS Code configuration file is not valid JSON.");
+  let l = v.findNodeAtLocation(s, ["configurations"]);
+  if (l === void 0 || l.children === void 0) {
+    const p = v.modify(n, ["configurations"], [], {});
+    n = v.applyEdits(n, p), s = v.parseTree(n, [], F), l = v.findNodeAtLocation(s, [
+      "configurations"
+    ]);
+  }
+  const a = l?.children?.findIndex(
+    (p) => v.findNodeAtLocation(p, ["name"])?.value === t
+  );
+  if (a === void 0 || a < 0) {
+    const p = {
+      name: t,
+      type: "php",
+      request: "launch",
+      port: 9003,
+      pathMappings: i.reduce((h, w) => (h[w.vfsPath] = `\${workspaceFolder}/${w.hostPath.replace(
+        /^\.\/?/,
+        ""
+      )}`, h), {})
+    }, c = l?.children?.length || 0, d = v.modify(
+      n,
+      ["configurations", c],
+      p,
+      {
+        formattingOptions: {
+          insertSpaces: !0,
+          tabSize: 4,
+          eol: `
+`
+        }
+      }
+    );
+    n = oe(n, d);
+  }
+  return n;
+}
+async function it({
+  name: e,
+  ides: o,
+  host: t,
+  port: i,
+  cwd: r,
+  mounts: n,
+  ideKey: s = "PLAYGROUNDCLI"
+}) {
+  const l = ot(r, n), a = [];
+  if (o.includes("phpstorm")) {
+    const p = ".idea/workspace.xml", c = g.join(
+      r,
+      p
+    );
+    if (!u.existsSync(c)) {
+      if (u.existsSync(g.dirname(c)))
+        u.writeFileSync(
+          c,
+          `<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+</project>`
+        );
+      else if (o.length == 1)
+        throw new Error(
+          "PhpStorm IDE integration requested, but no '.idea' directory was found in the current working directory."
+        );
+    }
+    if (u.existsSync(c)) {
+      const d = u.readFileSync(c, "utf8"), h = rt(d, {
+        name: e,
+        host: t,
+        port: i,
+        mappings: l,
+        ideKey: s
+      });
+      u.writeFileSync(c, h);
+    }
+    a.push(p);
+  }
+  if (o.includes("vscode")) {
+    const p = ".vscode/launch.json", c = g.join(
+      r,
+      p
+    );
+    if (!u.existsSync(c)) {
+      if (u.existsSync(g.dirname(c)))
+        u.writeFileSync(
+          c,
+          `{
+    "configurations": []
+}`
+        );
+      else if (o.length == 1)
+        throw new Error(
+          "VS Code IDE integration requested, but no '.vscode' directory was found in the current working directory."
+        );
+    }
+    if (u.existsSync(c)) {
+      const d = u.readFileSync(c, "utf-8"), h = nt(d, {
+        name: e,
+        mappings: l
+      });
+      h !== d && (u.writeFileSync(c, h), a.push(p));
+    }
+  }
+  return a;
+}
+async function st(e, o) {
+  const t = g.join(o, ".idea/workspace.xml");
+  if (u.existsSync(t)) {
+    const r = u.readFileSync(t, "utf8"), n = new K(I), s = (() => {
+      try {
+        return n.parse(r, !0);
+      } catch {
+        throw new Error(
+          "PhpStorm configuration file is not valid XML."
+        );
+      }
+    })(), p = s.find(
+      (d) => !!d?.project
+    )?.project?.find(
+      (d) => !!d?.component && d?.[":@"]?.name === "PhpServers"
+    )?.component?.find(
+      (d) => !!d?.servers
+    ), c = p?.servers?.findIndex(
+      (d) => !!d?.server && d?.[":@"]?.name === e
+    );
+    if (c !== void 0 && c >= 0) {
+      p.servers.splice(c, 1);
+      const h = new Q(te).build(s);
+      try {
+        n.parse(h, !0);
+      } catch {
+        throw new Error(
+          "The resulting PhpStorm configuration file is not valid XML."
+        );
+      }
+      h === `<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+	<component name="PhpServers">
+		<servers></servers>
+	</component>
+</project>` ? u.unlinkSync(t) : u.writeFileSync(t, h);
+    }
+  }
+  const i = g.join(o, ".vscode/launch.json");
+  if (u.existsSync(i)) {
+    const r = [], n = u.readFileSync(i, "utf-8"), s = v.parseTree(n, r, F);
+    if (s === void 0 || r.length)
+      throw new Error("VS Code configuration file is not valid JSON.");
+    const a = v.findNodeAtLocation(s, [
+      "configurations"
+    ])?.children?.findIndex(
+      (p) => v.findNodeAtLocation(p, ["name"])?.value === e
+    );
+    if (a !== void 0 && a >= 0) {
+      const p = v.modify(
+        n,
+        ["configurations", a],
+        void 0,
+        {
+          formattingOptions: {
+            insertSpaces: !0,
+            tabSize: 4,
+            eol: `
+`
+          }
+        }
+      ), c = oe(n, p);
+      c === `{
+    "configurations": []
+}` ? u.unlinkSync(i) : u.writeFileSync(i, c);
+    }
+  }
+}
+function oe(e, o) {
+  const t = [], i = v.applyEdits(e, o);
+  if (t.length = 0, v.parseTree(i, t, F), t.length) {
+    const r = t.map((s) => ({
+      message: v.printParseErrorCode(s.error),
+      offset: s.offset,
+      length: s.length,
+      fragment: i.slice(
+        Math.max(0, s.offset - 20),
+        Math.min(i.length, s.offset + s.length + 10)
+      )
+    })).map(
+      (s) => `${s.message} at ${s.offset}:${s.length} (${s.fragment})`
+    ), n = o.map(
+      (s) => `At ${s.offset}:${s.length} - (${s.content})`
+    );
+    throw new Error(
+      `VS Code configuration file (.vscode/launch.json) is not valid a JSONC after Playground CLI modifications. This is likely a Playground CLI bug. Please report it at https://github.com/WordPress/wordpress-playground/issues and include the contents of your ".vscode/launch.json" file. 
+
+ Applied edits: ${n.join(
+        `
+`
+      )}
+
+ The errors are: ${r.join(`
+`)}`
+    );
+  }
+  return i;
+}
+const V = {
+  Quiet: { name: "quiet", severity: M.Fatal },
+  Normal: { name: "normal", severity: M.Info },
+  Debug: { name: "debug", severity: M.Debug }
+};
+async function Rt() {
+  try {
+    const e = Ie(process.argv.slice(2)).usage("Usage: wp-playground <command> [options]").positional("command", {
+      describe: "Command to run",
+      choices: ["server", "run-blueprint", "build-snapshot"],
+      demandOption: !0
+    }).option("outfile", {
+      describe: "When building, write to this output file.",
+      type: "string",
+      default: "wordpress.zip"
+    }).option("port", {
+      describe: "Port to listen on when serving.",
+      type: "number",
+      default: 9400
+    }).option("site-url", {
+      describe: "Site URL to use for WordPress. Defaults to http://127.0.0.1:{port}",
+      type: "string"
+    }).option("php", {
+      describe: "PHP version to use.",
+      type: "string",
+      default: Z,
+      choices: ce
+    }).option("wp", {
+      describe: "WordPress version to use.",
+      type: "string",
+      default: "latest"
+    }).option("mount", {
+      describe: "Mount a directory to the PHP runtime (can be used multiple times). Format: /host/path:/vfs/path",
+      type: "array",
+      string: !0,
+      coerce: z
+    }).option("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: z
+    }).option("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: parseMountDirArguments,
+    }).option("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: ve
+    }).option("login", {
+      describe: "Should log the user in",
+      type: "boolean",
+      default: !1
+    }).option("blueprint", {
+      describe: "Blueprint to execute.",
+      type: "string"
+    }).option("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
+    }).option("skip-wordpress-setup", {
+      describe: "Do not download, unzip, and install WordPress. Useful for mounting a pre-configured WordPress directory at /wordpress.",
+      type: "boolean",
+      default: !1
+    }).option("skip-sqlite-setup", {
+      describe: "Skip the SQLite integration plugin setup to allow the WordPress site to use MySQL.",
+      type: "boolean",
+      default: !1
+    }).option("quiet", {
+      describe: "Do not output logs and progress messages.",
+      type: "boolean",
+      default: !1,
+      hidden: !0
+    }).option("verbosity", {
+      describe: "Output logs and progress messages.",
+      type: "string",
+      choices: Object.values(V).map(
+        (r) => r.name
+      ),
+      default: "normal"
+    }).option("debug", {
+      describe: "Print PHP error log content if an error occurs during Playground boot.",
+      type: "boolean",
+      default: !1
+    }).option("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"
+    }).option("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
+    }).option("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
+    }).option("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
+    }).option("xdebug", {
+      describe: "Enable Xdebug.",
+      type: "boolean",
+      default: !1
+    }).option("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: (r) => r === "" ? ["vscode", "phpstorm"] : [r]
+    }).option("experimental-devtools", {
+      describe: "Enable experimental browser development tools.",
+      type: "boolean"
+    }).conflicts(
+      "experimental-unsafe-ide-integration",
+      "experimental-devtools"
+    ).option("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: (r) => r ?? xe().length - 1
+    }).option("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
+    }).option("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
+    }).showHelpOnFail(!1).strictOptions().check(async (r) => {
+      if ((r["skip-wordpress-setup"] || r.skipWordpressSetup) && (r.skipWordPressSetup = !0), r.wp !== void 0 && !_e(r.wp))
+        try {
+          new URL(r.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"'
+          );
+        }
+      if (r["site-url"] !== void 0 && r["site-url"] !== "")
+        try {
+          new URL(r["site-url"]);
+        } catch {
+          throw new Error(
+            `Invalid site-url "${r["site-url"]}". Please provide a valid URL (e.g., http://localhost:8080 or https://example.com)`
+          );
+        }
+      if (r["auto-mount"]) {
+        let n = !1;
+        try {
+          n = u.statSync(r["auto-mount"]).isDirectory();
+        } catch {
+          n = !1;
+        }
+        if (!n)
+          throw new Error(
+            `The specified --auto-mount path is not a directory: '${r["auto-mount"]}'.`
+          );
+      }
+      if (r["experimental-multi-worker"] !== void 0 && r["experimental-multi-worker"] <= 1)
+        throw new Error(
+          "The --experimental-multi-worker flag must be a positive integer greater than 1."
+        );
+      if (r["experimental-blueprints-v2-runner"] === !0) {
+        if (r.mode !== void 0) {
+          if ("skip-wordpress-setup" in r)
+            throw new Error(
+              "The --skipWordPressSetup option cannot be used with the --mode option. Use one or the other."
+            );
+          if ("skip-sqlite-setup" in r)
+            throw new Error(
+              "The --skipSqliteSetup option is not supported in Blueprint V2 mode."
+            );
+          if (r["auto-mount"] !== void 0)
+            throw new Error(
+              "The --mode option cannot be used with --auto-mount because --auto-mount automatically sets the mode."
+            );
+        } else
+          r["skip-wordpress-setup"] === !0 ? r.mode = "apply-to-existing-site" : r.mode = "create-new-site";
+        const n = r.allow || [];
+        r.followSymlinks === !0 && n.push("follow-symlinks"), r["blueprint-may-read-adjacent-files"] === !0 && n.push("read-local-fs"), r.allow = n;
+      } else if (r.mode !== void 0)
+        throw new Error(
+          "The --mode option requires the --experimentalBlueprintsV2Runner flag."
+        );
+      return !0;
+    });
+    e.wrap(e.terminalWidth());
+    const o = await e.argv, t = o._[0];
+    ["run-blueprint", "server", "build-snapshot"].includes(t) || (e.showHelp(), process.exit(1));
+    const i = {
+      ...o,
+      command: t,
+      mount: [...o.mount || [], ...o["mount-dir"] || []],
+      "mount-before-install": [
+        ...o["mount-before-install"] || [],
+        ...o["mount-dir-before-install"] || []
+      ]
+    };
+    await lt(i);
+  } catch (e) {
+    if (!(e instanceof Error))
+      throw e;
+    if (process.argv.includes("--debug"))
+      pe(e);
+    else {
+      const t = [];
+      let i = e;
+      do
+        t.push(i.message), i = i.cause;
+      while (i instanceof Error);
+      console.error(
+        "\x1B[1m" + t.join(" caused by ") + "\x1B[0m"
+      );
+    }
+    process.exit(1);
+  }
+}
+const D = (e) => process.stdout.isTTY ? "\x1B[1m" + e + "\x1B[0m" : e, at = (e) => process.stdout.isTTY ? `\x1B[2m${e}\x1B[0m` : e, A = (e) => process.stdout.isTTY ? `\x1B[3m${e}\x1B[0m` : e, X = (e) => process.stdout.isTTY ? `\x1B[33m${e}\x1B[0m` : e;
+async function lt(e) {
+  let o, t;
+  const i = [];
+  if (e.autoMount !== void 0 && (e.autoMount === "" && (e = { ...e, autoMount: process.cwd() }), e = Pe(e)), e.quiet && (e.verbosity = "quiet", delete e.quiet), e.debug ? e.verbosity = "debug" : e.verbosity === "debug" && (e.debug = !0), e.verbosity) {
+    const a = Object.values(V).find(
+      (p) => p.name === e.verbosity
+    ).severity;
+    m.setSeverityFilterLevel(a);
+  }
+  const r = Y.platform() === "win32" ? (
+    // @TODO: Enable fs-ext here when it works with Windows.
+    void 0
+  ) : await import("fs-ext").then((a) => a.flockSync).catch(() => {
+    m.warn(
+      "The fs-ext package is not installed. Internal file locking will not be integrated with host OS file locking."
+    );
+  }), n = new ke(r);
+  let s = !1, l = !0;
+  return m.log("Starting a PHP server..."), Ue({
+    port: e.port,
+    onBind: async (a, p) => {
+      const c = "127.0.0.1", d = `http://${c}:${p}`, h = e["site-url"] || d, w = e.experimentalMultiWorker ?? 1, b = Math.floor(
+        Number.MAX_SAFE_INTEGER / w
+      ), C = "-playground-cli-site-", x = await Ze(
+        C
+      );
+      m.debug(`Native temp dir for VFS root: ${x}`);
+      const k = "WP Playground CLI - Listen for Xdebug", f = ".playground-xdebug-root", B = g.join(process.cwd(), f);
+      if (await tt(B), e.xdebug && e.experimentalUnsafeIdeIntegration) {
+        await et(
+          x,
+          B,
+          process.platform
+        );
+        const y = {
+          hostPath: `./${f}`,
+          vfsPath: "/"
+        };
+        try {
+          await st(k, process.cwd());
+          const S = typeof e.xdebug == "object" ? e.xdebug : void 0, W = await it({
+            name: k,
+            host: c,
+            port: p,
+            ides: e.experimentalUnsafeIdeIntegration,
+            cwd: process.cwd(),
+            mounts: [
+              y,
+              ...e["mount-before-install"] || [],
+              ...e.mount || []
+            ],
+            ideKey: S?.ideKey
+          }), P = e.experimentalUnsafeIdeIntegration, E = P.includes("vscode"), $ = P.includes("phpstorm");
+          console.log(""), console.log(D("Xdebug configured successfully")), console.log(
+            X("Updated IDE config: ") + W.join(" ")
+          ), console.log(
+            X("Playground source root: ") + ".playground-xdebug-root" + A(
+              at(
+                " – you can set breakpoints and preview Playground's VFS structure in there."
+              )
+            )
+          ), console.log(""), E && (console.log(D("VS Code / Cursor instructions:")), console.log(
+            "  1. Open the Run and Debug panel on the left sidebar"
+          ), console.log(
+            `  2. Select "${A(
+              k
+            )}" from the dropdown`
+          ), console.log('  3. Click "start debugging"'), console.log(
+            "  4. Set a breakpoint. For example, in .playground-xdebug-root/wordpress/index.php"
+          ), console.log(
+            "  5. Visit Playground in your browser to hit the breakpoint"
+          ), $ && console.log("")), $ && (console.log(D("PhpStorm instructions:")), console.log(
+            `  1. Choose "${A(
+              k
+            )}" 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 (S) {
+          m.error(
+            "Could not configure Xdebug:",
+            S?.message
+          ), process.exit(1);
+        }
+      }
+      const re = g.dirname(x), ne = 2 * 24 * 60 * 60 * 1e3;
+      Ye(
+        C,
+        ne,
+        re
+      );
+      const R = g.join(x, "internal");
+      H(R);
+      const ie = [
+        "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 y of ie) {
+        const S = (P) => P.vfsPath === `/${y}`;
+        if (!(e["mount-before-install"]?.some(S) || e.mount?.some(S))) {
+          const P = g.join(
+            x,
+            y
+          );
+          H(P), e["mount-before-install"] === void 0 && (e["mount-before-install"] = []), e["mount-before-install"].unshift({
+            vfsPath: `/${y}`,
+            hostPath: P
+          });
+        }
+      }
+      if (e["mount-before-install"])
+        for (const y of e["mount-before-install"])
+          m.debug(
+            `Mount before WP install: ${y.vfsPath} -> ${y.hostPath}`
+          );
+      if (e.mount)
+        for (const y of e.mount)
+          m.debug(
+            `Mount after WP install: ${y.vfsPath} -> ${y.hostPath}`
+          );
+      let L;
+      e["experimental-blueprints-v2-runner"] ? L = new qe(e, {
+        siteUrl: h,
+        processIdSpaceLength: b
+      }) : (L = new Je(e, {
+        siteUrl: h,
+        processIdSpaceLength: b
+      }), typeof e.blueprint == "string" && (e.blueprint = await He({
+        sourceString: e.blueprint,
+        blueprintMayReadAdjacentFiles: e["blueprint-may-read-adjacent-files"] === !0
+      })));
+      const se = ct(
+        w,
+        L.getWorkerType(),
+        ({ exitCode: y, isMain: S, workerIndex: W }) => {
+          y !== 0 && (m.error(
+            `Worker ${W} exited with code ${y}
+`
+          ), S && e.exitOnPrimaryWorkerCrash && process.exit(1));
+        }
+      );
+      m.log(`Setting up WordPress ${e.wp}`);
+      try {
+        const [y, ...S] = await se, W = await J(
+          n
+        );
+        if (t = await L.bootPrimaryWorker(
+          y.phpPort,
+          W,
+          R
+        ), i.push({
+          playground: t,
+          worker: y.worker
+        }), await t.isReady(), s = !0, m.log("Booted!"), o = new Oe(t), !e["experimental-blueprints-v2-runner"]) {
+          const P = await L.compileInputBlueprint(
+            e["additional-blueprint-steps"] || []
+          );
+          P && (m.log("Running the Blueprint..."), await ye(
+            P,
+            t
+          ), m.log("Finished running the blueprint"));
+        }
+        if (e.command === "build-snapshot" ? (await ut(t, e.outfile), m.log(`WordPress exported to ${e.outfile}`), process.exit(0)) : e.command === "run-blueprint" && (m.log("Blueprint executed"), process.exit(0)), e.experimentalMultiWorker && e.experimentalMultiWorker > 1) {
+          m.log("Preparing additional workers...");
+          const P = b;
+          await Promise.all(
+            S.map(async (E, $) => {
+              const ae = P + $ * b, le = await J(n), O = await L.bootSecondaryWorker({
+                worker: E,
+                fileLockManagerPort: le,
+                firstProcessId: ae,
+                nativeInternalDirPath: R
+              });
+              i.push({
+                playground: O,
+                worker: E.worker
+              }), o.addWorker(O);
+            })
+          );
+        }
+        return m.log(
+          `WordPress is running on ${d} with ${w} worker(s)`
+        ), e.xdebug && e.experimentalDevtools && (await Re({
+          phpInstance: t,
+          phpRoot: "/wordpress"
+        })).start(), {
+          playground: t,
+          server: a,
+          serverUrl: d,
+          [Symbol.asyncDispose]: async function() {
+            await Promise.all(
+              i.map(
+                async ({ playground: E, worker: $ }) => {
+                  await E.dispose(), await $.terminate();
+                }
+              )
+            ), await new Promise((E) => a.close(E));
+          },
+          workerThreadCount: w
+        };
+      } catch (y) {
+        if (!e.debug)
+          throw y;
+        let S = "";
+        throw await t?.fileExists(_) && (S = await t.readFileAsText(_)), new Error(S, { cause: y });
+      }
+    },
+    async handleRequest(a) {
+      if (!s)
+        return U.forHttpCode(
+          502,
+          "WordPress is not ready yet"
+        );
+      if (l) {
+        l = !1;
+        const p = {
+          "Content-Type": ["text/plain"],
+          "Content-Length": ["0"],
+          Location: [a.url]
+        };
+        return a.headers?.cookie?.includes(
+          "playground_auto_login_already_happened"
+        ) && (p["Set-Cookie"] = [
+          "playground_auto_login_already_happened=1; Max-Age=0; Expires=Thu, 01 Jan 1970 00:00:00 GMT; Path=/"
+        ]), new U(302, p, new Uint8Array());
+      }
+      return await o.handleRequest(a);
+    }
+  });
+}
+async function ct(e, o, t) {
+  const i = [];
+  for (let r = 0; r < e; r++) {
+    const n = await pt(o), s = (l) => {
+      t({
+        exitCode: l,
+        isMain: r === 0,
+        workerIndex: r
+      });
+    };
+    i.push(
+      new Promise(
+        (l, a) => {
+          n.once("message", function(p) {
+            p.command === "worker-script-initialized" && l({ worker: n, phpPort: p.phpPort });
+          }), n.once("error", function(p) {
+            console.error(p);
+            const c = new Error(
+              `Worker failed to load worker. ${p.message ? `Original error: ${p.message}` : ""}`
+            );
+            a(c);
+          }), n.once("exit", s);
+        }
+      )
+    );
+  }
+  return Promise.all(i);
+}
+async function pt(e) {
+  return e === "v1" ? new q(new URL("./worker-thread-v1.js", import.meta.url)) : new q(new URL("./worker-thread-v2.js", import.meta.url));
+}
+async function J(e) {
+  const { port1: o, port2: t } = new be();
+  return await Ee() ? ue(e, null, o) : await de(e, o), t;
+}
+async function ut(e, o) {
+  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 t = await e.readFileAsBuffer("/tmp/build.zip");
+  u.writeFileSync(o, t);
+}
+export {
+  V as L,
+  Rt as p,
+  lt as r
+};
+//# sourceMappingURL=run-cli-B59N7dQd.js.map