@wp-playground/cli 3.0.15 → 3.0.17

package/run-cli-BBfr5tmj.js

@@ -0,0 +1,1336 @@
+import { logger as h, LogSeverity as A, errorLogPath as q } from "@php-wasm/logger";
+import { PHPResponse as V, consumeAPI as j, SupportedPHPVersions as ue, printDebugDetails as de, exposeAPI as fe, exposeSyncAPI as me } from "@php-wasm/universal";
+import { resolveRemoteBlueprint as he, resolveRuntimeConfiguration as ge, compileBlueprintV1 as ye, isBlueprintBundle as we, runBlueprintV1Steps as be } from "@wp-playground/blueprints";
+import { zipDirectory as ve, RecommendedPHPVersion as G } from "@wp-playground/common";
+import u, { mkdirSync as z } from "fs";
+import { Worker as X, MessageChannel as Pe } from "worker_threads";
+import { p as J, a as Se, e as ke } from "./mounts-D1_eXSTw.js";
+import xe from "express";
+import { FileLockManagerForNode as Ee } from "@php-wasm/node";
+import K, { cpus as Ie } from "os";
+import { jspi as Ce } from "wasm-feature-detect";
+import Le from "yargs";
+import g, { basename as $e } from "path";
+import { NodeJsFilesystem as We, OverlayFilesystem as Te, InMemoryFilesystem as Be, ZipFilesystem as je } from "@wp-playground/storage";
+import { EmscriptenDownloadMonitor as Re, ProgressTracker as Fe } from "@php-wasm/progress";
+import { resolveWordPressRelease as Me } from "@wp-playground/wordpress";
+import $ from "fs-extra";
+import { startBridge as De } from "@php-wasm/xdebug-bridge";
+import { dir as Ae, setGracefulCleanup as Ue } from "tmp-promise";
+import Ne from "ps-man";
+import { XMLParser as Q, XMLBuilder as ee } from "fast-xml-parser";
+import P from "jsonc-parser";
+async function Ve(e) {
+  const o = xe(), t = await new Promise((n, r) => {
+    const a = o.listen(e.port, () => {
+      const l = a.address();
+      l === null || typeof l == "string" ? r(new Error("Server address is not available")) : n(a);
+    });
+  });
+  o.use("/", async (n, r) => {
+    let a;
+    try {
+      a = await e.handleRequest({
+        url: n.url,
+        headers: _e(n),
+        method: n.method,
+        body: await Oe(n)
+      });
+    } catch (l) {
+      h.error(l), a = V.forHttpCode(500);
+    }
+    r.statusCode = a.httpStatusCode;
+    for (const l in a.headers)
+      r.setHeader(l, a.headers[l]);
+    r.end(a.bytes);
+  });
+  const s = t.address().port;
+  return await e.onBind(t, s);
+}
+const Oe = async (e) => await new Promise((o) => {
+  const t = [];
+  e.on("data", (i) => {
+    t.push(i);
+  }), e.on("end", () => {
+    o(new Uint8Array(Buffer.concat(t)));
+  });
+}), _e = (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 He {
+  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 s = 1; s < this.workerLoads.length; s++) {
+      const n = this.workerLoads[s];
+      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 qe(e) {
+  return /^latest$|^trunk$|^nightly$|^(?:(\d+)\.(\d+)(?:\.(\d+))?)((?:-beta(?:\d+)?)|(?:-RC(?:\d+)?))?$/.test(e);
+}
+async function ze({
+  sourceString: e,
+  blueprintMayReadAdjacentFiles: o
+}) {
+  if (!e)
+    return;
+  if (e.startsWith("http://") || e.startsWith("https://"))
+    return await he(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 s = g.extname(t);
+  switch (s) {
+    case ".zip":
+      return je.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 r = g.dirname(t), a = new We(r);
+      return new Te([
+        new Be({
+          "blueprint.json": n
+        }),
+        /**
+         * Wrap the NodeJS filesystem to prevent access to local files
+         * unless the user explicitly allowed it.
+         */
+        {
+          read(l) {
+            if (!o)
+              throw new Error(
+                `Error: Blueprint contained tried to read a local file at path "${l}" (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 a.read(l);
+          }
+        }
+      ]);
+    }
+    default:
+      throw new Error(
+        `Unsupported blueprint file extension: ${s}. Only .zip and .json files are supported.`
+      );
+  }
+}
+class Xe {
+  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 s = j(o);
+    await s.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 s.bootAsPrimaryWorker(n), s;
+  }
+  async bootSecondaryWorker({
+    worker: o,
+    fileLockManagerPort: t,
+    firstProcessId: i,
+    nativeInternalDirPath: s
+  }) {
+    const n = j(o.phpPort);
+    await n.useFileLockManager(t);
+    const r = {
+      ...this.args,
+      phpVersion: this.phpVersion,
+      siteUrl: this.siteUrl,
+      firstProcessId: i,
+      processIdSpaceLength: this.processIdSpaceLength,
+      trace: this.args.debug || !1,
+      withXdebug: !!this.args.xdebug,
+      nativeInternalDirPath: s,
+      mountsBeforeWpInstall: this.args["mount-before-install"] || [],
+      mountsAfterWpInstall: this.args.mount || []
+    };
+    return await n.bootAsSecondaryWorker(r), 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 O = g.join(K.homedir(), ".wordpress-playground");
+async function Je(e) {
+  return await te(
+    "https://github.com/WordPress/sqlite-database-integration/archive/refs/heads/develop.zip",
+    "sqlite.zip",
+    e
+  );
+}
+async function te(e, o, t) {
+  const i = g.join(O, o);
+  return $.existsSync(i) || ($.ensureDirSync(O), await Ze(e, i, t)), oe(i);
+}
+async function Ze(e, o, t) {
+  const s = (await t.monitorFetch(fetch(e))).body.getReader(), n = `${o}.partial`, r = $.createWriteStream(n);
+  for (; ; ) {
+    const { done: a, value: l } = await s.read();
+    if (l && r.write(l), a)
+      break;
+  }
+  r.close(), r.closed || await new Promise((a, l) => {
+    r.on("finish", () => {
+      $.renameSync(n, o), a(null);
+    }), r.on("error", (p) => {
+      $.removeSync(n), l(p);
+    });
+  });
+}
+function oe(e, o) {
+  return new File([$.readFileSync(e)], $e(e));
+}
+class Ye {
+  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 s;
+    const n = new Re();
+    if (!this.args.skipWordPressSetup) {
+      let I = !1;
+      n.addEventListener("progress", (k) => {
+        if (I)
+          return;
+        const { loaded: x, total: f } = k.detail, W = Math.floor(
+          Math.min(100, 100 * x / f)
+        );
+        I = W === 100, this.writeProgressUpdate(
+          process.stdout,
+          `Downloading WordPress ${W}%...`,
+          I
+        );
+      }), s = await Me(this.args.wp), h.log(
+        `Resolved WordPress release URL: ${s?.releaseUrl}`
+      );
+    }
+    const r = s && g.join(
+      O,
+      `prebuilt-wp-content-for-wp-${s.version}.zip`
+    ), a = s ? u.existsSync(r) ? oe(r) : await te(
+      s.releaseUrl,
+      `${s.version}.zip`,
+      n
+    ) : void 0;
+    h.log("Fetching SQLite integration plugin...");
+    const l = this.args.skipSqliteSetup ? void 0 : await Je(n), p = this.args.followSymlinks === !0, c = this.args.experimentalTrace === !0, d = this.args["mount-before-install"] || [], m = this.args.mount || [], b = j(o);
+    await b.isConnected(), h.log("Booting WordPress...");
+    const v = await ge(
+      this.getEffectiveBlueprint()
+    );
+    return await b.useFileLockManager(t), await b.bootAsPrimaryWorker({
+      phpVersion: v.phpVersion,
+      wpVersion: v.wpVersion,
+      siteUrl: this.siteUrl,
+      mountsBeforeWpInstall: d,
+      mountsAfterWpInstall: m,
+      wordPressZip: a && await a.arrayBuffer(),
+      sqliteIntegrationPluginZip: await l?.arrayBuffer(),
+      firstProcessId: 0,
+      processIdSpaceLength: this.processIdSpaceLength,
+      followSymlinks: p,
+      trace: c,
+      internalCookieStore: this.args.internalCookieStore,
+      withXdebug: !!this.args.xdebug,
+      nativeInternalDirPath: i
+    }), s && !this.args["mount-before-install"] && !u.existsSync(r) && (h.log("Caching preinstalled WordPress for the next boot..."), u.writeFileSync(
+      r,
+      await ve(b, "/wordpress")
+    ), h.log("Cached!")), b;
+  }
+  async bootSecondaryWorker({
+    worker: o,
+    fileLockManagerPort: t,
+    firstProcessId: i,
+    nativeInternalDirPath: s
+  }) {
+    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: s
+    }), await n.isReady(), n;
+  }
+  async compileInputBlueprint(o) {
+    const t = this.getEffectiveBlueprint(), i = new Fe();
+    let s = "", n = !1;
+    return i.addEventListener("progress", (r) => {
+      if (n)
+        return;
+      n = r.detail.progress === 100;
+      const a = Math.floor(r.detail.progress);
+      s = r.detail.caption || s || "Running the Blueprint";
+      const l = `${s.trim()} – ${a}%`;
+      this.writeProgressUpdate(
+        process.stdout,
+        l,
+        n
+      );
+    }), await ye(t, {
+      progress: i,
+      additionalSteps: o
+    });
+  }
+  getEffectiveBlueprint() {
+    const o = this.args.blueprint;
+    return we(o) ? o : {
+      login: this.args.login,
+      ...o || {},
+      preferredVersions: {
+        php: this.args.php ?? o?.preferredVersions?.php ?? G,
+        wp: this.args.wp ?? o?.preferredVersions?.wp ?? "latest",
+        ...o?.preferredVersions || {}
+      }
+    };
+  }
+  writeProgressUpdate(o, t, i) {
+    this.args.verbosity !== _.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 Ge(e, o = !0) {
+  const i = `${g.basename(process.argv0)}${e}${process.pid}-`, s = await Ae({
+    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
+  });
+  return o && Ue(), s;
+}
+async function Ke(e, o, t) {
+  const s = (await Qe(
+    e,
+    o,
+    t
+  )).map(
+    (n) => new Promise((r) => {
+      u.rm(n, { recursive: !0 }, (a) => {
+        a ? h.warn(
+          `Failed to delete stale Playground temp dir: ${n}`,
+          a
+        ) : h.info(
+          `Deleted stale Playground temp dir: ${n}`
+        ), r();
+      });
+    })
+  );
+  await Promise.all(s);
+}
+async function Qe(e, o, t) {
+  try {
+    const i = u.readdirSync(t).map((n) => g.join(t, n)), s = [];
+    for (const n of i)
+      await et(
+        e,
+        o,
+        n
+      ) && s.push(n);
+    return s;
+  } catch (i) {
+    return h.warn(`Failed to find stale Playground temp dirs: ${i}`), [];
+  }
+}
+async function et(e, o, t) {
+  if (!u.lstatSync(t).isDirectory())
+    return !1;
+  const s = g.basename(t);
+  if (!s.includes(e))
+    return !1;
+  const n = s.match(
+    new RegExp(`^(.+)${e}(\\d+)-`)
+  );
+  if (!n)
+    return !1;
+  const r = {
+    executableName: n[1],
+    pid: n[2]
+  };
+  if (await tt(r.pid, r.executableName))
+    return !1;
+  const a = Date.now() - o;
+  return u.statSync(t).mtime.getTime() < a;
+}
+async function tt(e, o) {
+  const [t] = await new Promise(
+    (i, s) => {
+      Ne.list(
+        {
+          pid: e,
+          name: o,
+          // Remove path from executable name in the results.
+          clean: !0
+        },
+        (n, r) => {
+          n ? s(n) : i(r);
+        }
+      );
+    }
+  );
+  return !!t && t.pid === e && t.command === o;
+}
+async function ot(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 rt(e) {
+  try {
+    u.lstatSync(e).isSymbolicLink() && u.unlinkSync(e);
+  } catch {
+  }
+}
+function nt(e, o) {
+  return o.filter((t) => {
+    const i = g.resolve(t.hostPath), s = g.join(e, g.sep);
+    return (
+      // If auto-mounting from the current directory,
+      // the entire project directory can be mapped.
+      i === e || i.startsWith(s)
+    );
+  });
+}
+const E = {
+  ignoreAttributes: !1,
+  attributeNamePrefix: "",
+  preserveOrder: !0,
+  cdataPropName: "__cdata",
+  commentPropName: "__xmlComment",
+  allowBooleanAttributes: !0,
+  trimValues: !0
+}, re = {
+  ignoreAttributes: E.ignoreAttributes,
+  attributeNamePrefix: E.attributeNamePrefix,
+  preserveOrder: E.preserveOrder,
+  cdataPropName: E.cdataPropName,
+  commentPropName: E.commentPropName,
+  suppressBooleanAttributes: !E.allowBooleanAttributes,
+  format: !0,
+  indentBy: "	"
+}, R = {
+  allowEmptyContent: !0,
+  allowTrailingComma: !0
+};
+function it(e, o) {
+  const { name: t, host: i, port: s, mappings: n, ideKey: r } = o, a = new Q(E), l = (() => {
+    try {
+      return a.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}:${s}`,
+      use_path_mappings: "true"
+    }
+  };
+  let c = l?.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" }
+  }, l.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 m = d.component?.find(
+    (f) => !!f?.servers
+  );
+  m === void 0 && (m = { servers: [] }, d.component === void 0 && (d.component = []), d.component.push(m));
+  const b = m.servers?.findIndex(
+    (f) => !!f?.server && f?.[":@"]?.name === t
+  );
+  (b === void 0 || b < 0) && (m.servers === void 0 && (m.servers = []), m.servers.push(p));
+  let v = c.project?.find(
+    (f) => !!f?.component && f?.[":@"]?.name === "RunManager"
+  );
+  if (v === void 0 && (v = {
+    component: [],
+    ":@": { name: "RunManager" }
+  }, c.project === void 0 && (c.project = []), c.project.push(v)), (v.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: r
+      }
+    };
+    v.component === void 0 && (v.component = []), v.component.push(f);
+  }
+  const x = new ee(re).build(l);
+  try {
+    a.parse(x, !0);
+  } catch {
+    throw new Error(
+      "The resulting PhpStorm configuration file is not valid XML."
+    );
+  }
+  return x;
+}
+function st(e, o) {
+  const { name: t, mappings: i } = o, s = [];
+  let n = e, r = P.parseTree(n, s, R);
+  if (r === void 0 || s.length)
+    throw new Error("VS Code configuration file is not valid JSON.");
+  let a = P.findNodeAtLocation(r, ["configurations"]);
+  if (a === void 0 || a.children === void 0) {
+    const p = P.modify(n, ["configurations"], [], {});
+    n = P.applyEdits(n, p), r = P.parseTree(n, [], R), a = P.findNodeAtLocation(r, [
+      "configurations"
+    ]);
+  }
+  const l = a?.children?.findIndex(
+    (p) => P.findNodeAtLocation(p, ["name"])?.value === t
+  );
+  if (l === void 0 || l < 0) {
+    const p = {
+      name: t,
+      type: "php",
+      request: "launch",
+      port: 9003,
+      pathMappings: i.reduce((m, b) => (m[b.vfsPath] = `\${workspaceFolder}/${b.hostPath.replace(
+        /^\.\/?/,
+        ""
+      )}`, m), {})
+    }, c = a?.children?.length || 0, d = P.modify(
+      n,
+      ["configurations", c],
+      p,
+      {
+        formattingOptions: {
+          insertSpaces: !0,
+          tabSize: 4,
+          eol: `
+`
+        }
+      }
+    );
+    n = ne(n, d);
+  }
+  return n;
+}
+async function at({
+  name: e,
+  ides: o,
+  host: t,
+  port: i,
+  cwd: s,
+  mounts: n,
+  ideKey: r = "PLAYGROUNDCLI"
+}) {
+  const a = nt(s, n), l = [];
+  if (o.includes("phpstorm")) {
+    const p = ".idea/workspace.xml", c = g.join(
+      s,
+      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"), m = it(d, {
+        name: e,
+        host: t,
+        port: i,
+        mappings: a,
+        ideKey: r
+      });
+      u.writeFileSync(c, m);
+    }
+    l.push(p);
+  }
+  if (o.includes("vscode")) {
+    const p = ".vscode/launch.json", c = g.join(
+      s,
+      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"), m = st(d, {
+        name: e,
+        mappings: a
+      });
+      m !== d && (u.writeFileSync(c, m), l.push(p));
+    }
+  }
+  return l;
+}
+async function lt(e, o) {
+  const t = g.join(o, ".idea/workspace.xml");
+  if (u.existsSync(t)) {
+    const s = u.readFileSync(t, "utf8"), n = new Q(E), r = (() => {
+      try {
+        return n.parse(s, !0);
+      } catch {
+        throw new Error(
+          "PhpStorm configuration file is not valid XML."
+        );
+      }
+    })(), p = r.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 m = new ee(re).build(r);
+      try {
+        n.parse(m, !0);
+      } catch {
+        throw new Error(
+          "The resulting PhpStorm configuration file is not valid XML."
+        );
+      }
+      m === `<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+	<component name="PhpServers">
+		<servers></servers>
+	</component>
+</project>` ? u.unlinkSync(t) : u.writeFileSync(t, m);
+    }
+  }
+  const i = g.join(o, ".vscode/launch.json");
+  if (u.existsSync(i)) {
+    const s = [], n = u.readFileSync(i, "utf-8"), r = P.parseTree(n, s, R);
+    if (r === void 0 || s.length)
+      throw new Error("VS Code configuration file is not valid JSON.");
+    const l = P.findNodeAtLocation(r, [
+      "configurations"
+    ])?.children?.findIndex(
+      (p) => P.findNodeAtLocation(p, ["name"])?.value === e
+    );
+    if (l !== void 0 && l >= 0) {
+      const p = P.modify(
+        n,
+        ["configurations", l],
+        void 0,
+        {
+          formattingOptions: {
+            insertSpaces: !0,
+            tabSize: 4,
+            eol: `
+`
+          }
+        }
+      ), c = ne(n, p);
+      c === `{
+    "configurations": []
+}` ? u.unlinkSync(i) : u.writeFileSync(i, c);
+    }
+  }
+}
+function ne(e, o) {
+  const t = [], i = P.applyEdits(e, o);
+  if (t.length = 0, P.parseTree(i, t, R), t.length) {
+    const s = t.map((r) => ({
+      message: P.printParseErrorCode(r.error),
+      offset: r.offset,
+      length: r.length,
+      fragment: i.slice(
+        Math.max(0, r.offset - 20),
+        Math.min(i.length, r.offset + r.length + 10)
+      )
+    })).map(
+      (r) => `${r.message} at ${r.offset}:${r.length} (${r.fragment})`
+    ), n = o.map(
+      (r) => `At ${r.offset}:${r.length} - (${r.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: ${s.join(`
+`)}`
+    );
+  }
+  return i;
+}
+const _ = {
+  Quiet: { name: "quiet", severity: A.Fatal },
+  Normal: { name: "normal", severity: A.Info },
+  Debug: { name: "debug", severity: A.Debug }
+};
+async function Dt() {
+  try {
+    const e = Le(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: G,
+      choices: ue
+    }).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: J
+    }).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: J
+    }).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: Se
+    }).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(_).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 ?? Ie().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 && !qe(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 a = !1;
+        try {
+          a = u.statSync(r["auto-mount"]).isDirectory();
+        } catch {
+          a = !1;
+        }
+        if (!a)
+          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 a = r.allow || [];
+        r.followSymlinks === !0 && a.push("follow-symlinks"), r["blueprint-may-read-adjacent-files"] === !0 && a.push("read-local-fs"), r.allow = a;
+      } 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"] || []
+      ]
+    }, s = await pt(i);
+    s === void 0 && process.exit(0);
+    const n = /* @__PURE__ */ (() => {
+      let r;
+      return async () => {
+        r !== void 0 && (r = s[Symbol.asyncDispose]()), await r, process.exit(0);
+      };
+    })();
+    process.on("SIGINT", n), process.on("SIGTERM", n);
+  } catch (e) {
+    if (!(e instanceof Error))
+      throw e;
+    if (process.argv.includes("--debug"))
+      de(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 U = (e) => process.stdout.isTTY ? "\x1B[1m" + e + "\x1B[0m" : e, ct = (e) => process.stdout.isTTY ? `\x1B[2m${e}\x1B[0m` : e, N = (e) => process.stdout.isTTY ? `\x1B[3m${e}\x1B[0m` : e, Z = (e) => process.stdout.isTTY ? `\x1B[33m${e}\x1B[0m` : e;
+async function pt(e) {
+  let o, t;
+  const i = [];
+  if (e.autoMount !== void 0 && (e.autoMount === "" && (e = { ...e, autoMount: process.cwd() }), e = ke(e)), e.quiet && (e.verbosity = "quiet", delete e.quiet), e.debug ? e.verbosity = "debug" : e.verbosity === "debug" && (e.debug = !0), e.verbosity) {
+    const l = Object.values(_).find(
+      (p) => p.name === e.verbosity
+    ).severity;
+    h.setSeverityFilterLevel(l);
+  }
+  const s = K.platform() === "win32" ? (
+    // @TODO: Enable fs-ext here when it works with Windows.
+    void 0
+  ) : await import("fs-ext").then((l) => l.flockSync).catch(() => {
+    h.warn(
+      "The fs-ext package is not installed. Internal file locking will not be integrated with host OS file locking."
+    );
+  }), n = new Ee(s);
+  let r = !1, a = !0;
+  return h.log("Starting a PHP server..."), Ve({
+    port: e.port,
+    onBind: async (l, p) => {
+      const c = "127.0.0.1", d = `http://${c}:${p}`, m = e["site-url"] || d, b = e.experimentalMultiWorker ?? 1, v = Math.floor(
+        Number.MAX_SAFE_INTEGER / b
+      ), I = "-playground-cli-site-", k = await Ge(
+        I
+      );
+      h.debug(`Native temp dir for VFS root: ${k.path}`);
+      const x = "WP Playground CLI - Listen for Xdebug", f = ".playground-xdebug-root", W = g.join(process.cwd(), f);
+      if (await rt(W), e.xdebug && e.experimentalUnsafeIdeIntegration) {
+        await ot(
+          k.path,
+          W,
+          process.platform
+        );
+        const y = {
+          hostPath: `./${f}`,
+          vfsPath: "/"
+        };
+        try {
+          await lt(x, process.cwd());
+          const w = typeof e.xdebug == "object" ? e.xdebug : void 0, L = await at({
+            name: x,
+            host: c,
+            port: p,
+            ides: e.experimentalUnsafeIdeIntegration,
+            cwd: process.cwd(),
+            mounts: [
+              y,
+              ...e["mount-before-install"] || [],
+              ...e.mount || []
+            ],
+            ideKey: w?.ideKey
+          }), S = e.experimentalUnsafeIdeIntegration, T = S.includes("vscode"), B = S.includes("phpstorm");
+          console.log(""), console.log(U("Xdebug configured successfully")), console.log(
+            Z("Updated IDE config: ") + L.join(" ")
+          ), console.log(
+            Z("Playground source root: ") + ".playground-xdebug-root" + N(
+              ct(
+                " – you can set breakpoints and preview Playground's VFS structure in there."
+              )
+            )
+          ), console.log(""), T && (console.log(U("VS Code / Cursor instructions:")), console.log(
+            "  1. Open the Run and Debug panel on the left sidebar"
+          ), console.log(
+            `  2. Select "${N(
+              x
+            )}" 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"
+          ), B && console.log("")), B && (console.log(U("PhpStorm instructions:")), console.log(
+            `  1. Choose "${N(
+              x
+            )}" debug configuration in the toolbar`
+          ), console.log("  2. Click the debug button (bug icon)`"), console.log(
+            "  3. Set a breakpoint. For example, in .playground-xdebug-root/wordpress/index.php"
+          ), console.log(
+            "  4. Visit Playground in your browser to hit the breakpoint"
+          )), console.log("");
+        } catch (w) {
+          throw new Error("Could not configure Xdebug", {
+            cause: w
+          });
+        }
+      }
+      const ie = g.dirname(k.path), se = 2 * 24 * 60 * 60 * 1e3;
+      Ke(
+        I,
+        se,
+        ie
+      );
+      const F = g.join(k.path, "internal");
+      z(F);
+      const ae = [
+        "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 ae) {
+        const w = (S) => S.vfsPath === `/${y}`;
+        if (!(e["mount-before-install"]?.some(w) || e.mount?.some(w))) {
+          const S = g.join(
+            k.path,
+            y
+          );
+          z(S), e["mount-before-install"] === void 0 && (e["mount-before-install"] = []), e["mount-before-install"].unshift({
+            vfsPath: `/${y}`,
+            hostPath: S
+          });
+        }
+      }
+      if (e["mount-before-install"])
+        for (const y of e["mount-before-install"])
+          h.debug(
+            `Mount before WP install: ${y.vfsPath} -> ${y.hostPath}`
+          );
+      if (e.mount)
+        for (const y of e.mount)
+          h.debug(
+            `Mount after WP install: ${y.vfsPath} -> ${y.hostPath}`
+          );
+      let C;
+      e["experimental-blueprints-v2-runner"] ? C = new Xe(e, {
+        siteUrl: m,
+        processIdSpaceLength: v
+      }) : (C = new Ye(e, {
+        siteUrl: m,
+        processIdSpaceLength: v
+      }), typeof e.blueprint == "string" && (e.blueprint = await ze({
+        sourceString: e.blueprint,
+        blueprintMayReadAdjacentFiles: e["blueprint-may-read-adjacent-files"] === !0
+      })));
+      let M = !1;
+      const D = async function() {
+        M || (M = !0, await Promise.all(
+          i.map(async ({ playground: w, worker: L }) => {
+            await w.dispose(), await L.terminate();
+          })
+        ), l && await new Promise((w) => l.close(w)), await k.cleanup());
+      }, le = ut(
+        b,
+        C.getWorkerType(),
+        ({ exitCode: y, workerIndex: w }) => {
+          M || y === 0 && h.error(
+            `Worker ${w} exited with code ${y}
+`
+          );
+        }
+      );
+      h.log(`Setting up WordPress ${e.wp}`);
+      try {
+        const [y, ...w] = await le, L = await Y(
+          n
+        );
+        if (t = await C.bootPrimaryWorker(
+          y.phpPort,
+          L,
+          F
+        ), i.push({
+          playground: t,
+          worker: y.worker
+        }), await t.isReady(), r = !0, h.log("Booted!"), o = new He(t), !e["experimental-blueprints-v2-runner"]) {
+          const S = await C.compileInputBlueprint(
+            e["additional-blueprint-steps"] || []
+          );
+          S && (h.log("Running the Blueprint..."), await be(
+            S,
+            t
+          ), h.log("Finished running the blueprint"));
+        }
+        if (e.command === "build-snapshot") {
+          await ft(t, e.outfile), h.log(`WordPress exported to ${e.outfile}`), await D();
+          return;
+        } else if (e.command === "run-blueprint") {
+          h.log("Blueprint executed"), await D();
+          return;
+        }
+        if (e.experimentalMultiWorker && e.experimentalMultiWorker > 1) {
+          h.log("Preparing additional workers...");
+          const S = v;
+          await Promise.all(
+            w.map(async (T, B) => {
+              const ce = S + B * v, pe = await Y(n), H = await C.bootSecondaryWorker({
+                worker: T,
+                fileLockManagerPort: pe,
+                firstProcessId: ce,
+                nativeInternalDirPath: F
+              });
+              i.push({
+                playground: H,
+                worker: T.worker
+              }), o.addWorker(H);
+            })
+          );
+        }
+        return h.log(
+          `WordPress is running on ${d} with ${b} worker(s)`
+        ), e.xdebug && e.experimentalDevtools && (await De({
+          phpInstance: t,
+          phpRoot: "/wordpress"
+        })).start(), {
+          playground: t,
+          server: l,
+          serverUrl: d,
+          [Symbol.asyncDispose]: D,
+          workerThreadCount: b
+        };
+      } catch (y) {
+        if (!e.debug)
+          throw y;
+        let w = "";
+        throw await t?.fileExists(q) && (w = await t.readFileAsText(q)), new Error(w, { cause: y });
+      }
+    },
+    async handleRequest(l) {
+      if (!r)
+        return V.forHttpCode(
+          502,
+          "WordPress is not ready yet"
+        );
+      if (a) {
+        a = !1;
+        const p = {
+          "Content-Type": ["text/plain"],
+          "Content-Length": ["0"],
+          Location: [l.url]
+        };
+        return l.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 V(302, p, new Uint8Array());
+      }
+      return await o.handleRequest(l);
+    }
+  });
+}
+async function ut(e, o, t) {
+  const i = [];
+  for (let s = 0; s < e; s++) {
+    const n = await dt(o), r = (a) => {
+      t({
+        exitCode: a,
+        workerIndex: s
+      });
+    };
+    i.push(
+      new Promise(
+        (a, l) => {
+          n.once("message", function(p) {
+            p.command === "worker-script-initialized" && a({ 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}` : ""}`
+            );
+            l(c);
+          }), n.once("exit", r);
+        }
+      )
+    );
+  }
+  return Promise.all(i);
+}
+async function dt(e) {
+  return e === "v1" ? new X(new URL("./worker-thread-v1.js", import.meta.url)) : new X(new URL("./worker-thread-v2.js", import.meta.url));
+}
+async function Y(e) {
+  const { port1: o, port2: t } = new Pe();
+  return await Ce() ? fe(e, null, o) : await me(e, o), t;
+}
+async function ft(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 {
+  _ as L,
+  Dt as p,
+  pt as r
+};
+//# sourceMappingURL=run-cli-BBfr5tmj.js.map