@wp-playground/cli 1.2.2 → 2.0.0

package/run-cli-CY1lYIJH.js

@@ -0,0 +1,674 @@
+import { logger as p, errorLogPath as z } from "@php-wasm/logger";
+import { consumeAPI as L, SupportedPHPVersions as T, PHPResponse as F, exposeAPI as V, exposeSyncAPI as q } from "@php-wasm/universal";
+import { resolveRemoteBlueprint as j, isBlueprintBundle as O, compileBlueprint as D, runBlueprintSteps as Z } from "@wp-playground/blueprints";
+import { zipDirectory as M, RecommendedPHPVersion as B, unzipFile as _ } from "@wp-playground/common";
+import m from "fs";
+import { Worker as N, MessageChannel as J } from "worker_threads";
+import { p as R, a as Y, e as Q } from "./mounts-B-Qdcyyt.js";
+import X from "express";
+import { FileLockManagerForNode as G } from "@php-wasm/node";
+import K, { cpus as ee } from "os";
+import { jspi as te } from "wasm-feature-detect";
+import re from "yargs";
+import y, { basename as oe } from "path";
+import { NodeJsFilesystem as se, OverlayFilesystem as ie, InMemoryFilesystem as ne, ZipFilesystem as ae } from "@wp-playground/storage";
+import { EmscriptenDownloadMonitor as le, ProgressTracker as pe } from "@php-wasm/progress";
+import { resolveWordPressRelease as de } from "@wp-playground/wordpress";
+import P from "fs-extra";
+async function ce(t) {
+  const r = X(), e = await new Promise((i, n) => {
+    const l = r.listen(t.port, () => {
+      const a = l.address();
+      a === null || typeof a == "string" ? n(new Error("Server address is not available")) : i(l);
+    });
+  });
+  r.use("/", async (i, n) => {
+    const l = await t.handleRequest({
+      url: i.url,
+      headers: he(i),
+      method: i.method,
+      body: await ue(i)
+    });
+    n.statusCode = l.httpStatusCode;
+    for (const a in l.headers)
+      n.setHeader(a, l.headers[a]);
+    n.end(l.bytes);
+  });
+  const s = e.address().port;
+  return await t.onBind(e, s);
+}
+const ue = async (t) => await new Promise((r) => {
+  const e = [];
+  t.on("data", (o) => {
+    e.push(o);
+  }), t.on("end", () => {
+    r(new Uint8Array(Buffer.concat(e)));
+  });
+}), he = (t) => {
+  const r = {};
+  if (t.rawHeaders && t.rawHeaders.length)
+    for (let e = 0; e < t.rawHeaders.length; e += 2)
+      r[t.rawHeaders[e].toLowerCase()] = t.rawHeaders[e + 1];
+  return r;
+};
+class fe {
+  constructor(r) {
+    this.workerLoads = [], this.addWorker(r);
+  }
+  addWorker(r) {
+    this.workerLoads.push({
+      worker: r,
+      activeRequests: /* @__PURE__ */ new Set()
+    });
+  }
+  async handleRequest(r) {
+    let e = this.workerLoads[0];
+    for (let s = 1; s < this.workerLoads.length; s++) {
+      const i = this.workerLoads[s];
+      i.activeRequests.size < e.activeRequests.size && (e = i);
+    }
+    const o = e.worker.request(r);
+    return e.activeRequests.add(o), o.url = r.url, o.finally(() => {
+      e.activeRequests.delete(o);
+    });
+  }
+}
+function me(t) {
+  return /^latest$|^trunk$|^nightly$|^(?:(\d+)\.(\d+)(?:\.(\d+))?)((?:-beta(?:\d+)?)|(?:-RC(?:\d+)?))?$/.test(t);
+}
+async function we({
+  sourceString: t,
+  blueprintMayReadAdjacentFiles: r
+}) {
+  if (!t)
+    return;
+  if (t.startsWith("http://") || t.startsWith("https://"))
+    return await j(t);
+  let e = y.resolve(process.cwd(), t);
+  if (!m.existsSync(e))
+    throw new Error(`Blueprint file does not exist: ${e}`);
+  const o = m.statSync(e);
+  if (o.isDirectory() && (e = y.join(e, "blueprint.json")), !o.isFile() && o.isSymbolicLink())
+    throw new Error(
+      `Blueprint path is neither a file nor a directory: ${e}`
+    );
+  const s = y.extname(e);
+  switch (s) {
+    case ".zip":
+      return ae.fromArrayBuffer(
+        m.readFileSync(e).buffer
+      );
+    case ".json": {
+      const i = m.readFileSync(e, "utf-8");
+      try {
+        JSON.parse(i);
+      } catch {
+        throw new Error(
+          `Blueprint file at ${e} is not a valid JSON file`
+        );
+      }
+      const n = y.dirname(e), l = new se(n);
+      return new ie([
+        new ne({
+          "blueprint.json": i
+        }),
+        /**
+         * Wrap the NodeJS filesystem to prevent access to local files
+         * unless the user explicitly allowed it.
+         */
+        {
+          read(a) {
+            if (!r)
+              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: ${s}. Only .zip and .json files are supported.`
+      );
+  }
+}
+const ge = "" + new URL("worker-thread-v2-Pfv6UYF4.js", import.meta.url).href;
+class ye {
+  constructor(r, e) {
+    this.lastProgressMessage = "", this.args = r, this.siteUrl = e.siteUrl, this.processIdSpaceLength = e.processIdSpaceLength, this.phpVersion = r.php;
+  }
+  getWorkerUrl() {
+    return ge;
+  }
+  async bootPrimaryWorker(r, e) {
+    const o = L(r);
+    await o.useFileLockManager(e);
+    const s = {
+      ...this.args,
+      php: this.phpVersion,
+      siteUrl: this.siteUrl,
+      firstProcessId: 1,
+      processIdSpaceLength: this.processIdSpaceLength,
+      trace: this.args.debug || !1,
+      blueprint: this.args.blueprint
+    };
+    return await o.bootAsPrimaryWorker(s), o;
+  }
+  async bootSecondaryWorker({
+    worker: r,
+    fileLockManagerPort: e,
+    firstProcessId: o
+  }) {
+    const s = L(r.phpPort);
+    await s.useFileLockManager(e);
+    const i = {
+      ...this.args,
+      php: this.phpVersion,
+      siteUrl: this.siteUrl,
+      firstProcessId: o,
+      processIdSpaceLength: this.processIdSpaceLength,
+      trace: this.args.debug || !1,
+      blueprint: this.args.blueprint
+    };
+    return await s.bootAsSecondaryWorker(i), s;
+  }
+  writeProgressUpdate(r, e, o) {
+    e !== this.lastProgressMessage && (this.lastProgressMessage = e, r.isTTY ? (r.cursorTo(0), r.write(e), r.clearLine(1), o && r.write(`
+`)) : r.write(`${e}
+`));
+  }
+}
+const I = y.join(K.homedir(), ".wordpress-playground");
+async function be(t) {
+  return await $(
+    "https://github.com/WordPress/sqlite-database-integration/archive/refs/heads/develop.zip",
+    "sqlite.zip",
+    t
+  );
+}
+async function $(t, r, e) {
+  const o = y.join(I, r);
+  return P.existsSync(o) || (P.ensureDirSync(I), await Pe(t, o, e)), A(o);
+}
+async function Pe(t, r, e) {
+  const s = (await e.monitorFetch(fetch(t))).body.getReader(), i = `${r}.partial`, n = P.createWriteStream(i);
+  for (; ; ) {
+    const { done: l, value: a } = await s.read();
+    if (a && n.write(a), l)
+      break;
+  }
+  n.close(), n.closed || await new Promise((l, a) => {
+    n.on("finish", () => {
+      P.renameSync(i, r), l(null);
+    }), n.on("error", (c) => {
+      P.removeSync(i), a(c);
+    });
+  });
+}
+function A(t, r) {
+  return new File([P.readFileSync(t)], oe(t));
+}
+const ke = "" + new URL("worker-thread-v1-BTJIbQLy.js", import.meta.url).href;
+class ve {
+  constructor(r, e) {
+    this.lastProgressMessage = "", this.args = r, this.siteUrl = e.siteUrl, this.processIdSpaceLength = e.processIdSpaceLength;
+  }
+  getWorkerUrl() {
+    return ke;
+  }
+  async bootPrimaryWorker(r, e) {
+    const o = await this.compileInputBlueprint(
+      this.args["additional-blueprint-steps"] || []
+    );
+    this.phpVersion = o.versions.php;
+    let s;
+    const i = new le();
+    if (!this.args.skipWordPressSetup) {
+      let k = !1;
+      i.addEventListener("progress", (h) => {
+        if (k)
+          return;
+        const { loaded: g, total: v } = h.detail, f = Math.floor(
+          Math.min(100, 100 * g / v)
+        );
+        k = f === 100, this.args.quiet || this.writeProgressUpdate(
+          process.stdout,
+          `Downloading WordPress ${f}%...`,
+          k
+        );
+      }), s = await de(this.args.wp), p.log(
+        `Resolved WordPress release URL: ${s?.releaseUrl}`
+      );
+    }
+    const n = s && y.join(
+      I,
+      `prebuilt-wp-content-for-wp-${s.version}.zip`
+    ), l = s ? m.existsSync(n) ? A(n) : await $(
+      s.releaseUrl,
+      `${s.version}.zip`,
+      i
+    ) : void 0;
+    p.log("Fetching SQLite integration plugin...");
+    const a = this.args.skipSqliteSetup ? void 0 : await be(i), c = this.args.followSymlinks === !0, d = this.args.experimentalTrace === !0, w = this.args["mount-before-install"] || [], b = this.args.mount || [], u = L(r);
+    return await u.isConnected(), p.log("Booting WordPress..."), await u.useFileLockManager(e), await u.bootAsPrimaryWorker({
+      phpVersion: this.phpVersion,
+      wpVersion: o.versions.wp,
+      absoluteUrl: this.siteUrl,
+      mountsBeforeWpInstall: w,
+      mountsAfterWpInstall: b,
+      wordPressZip: l && await l.arrayBuffer(),
+      sqliteIntegrationPluginZip: await a.arrayBuffer(),
+      firstProcessId: 0,
+      processIdSpaceLength: this.processIdSpaceLength,
+      followSymlinks: c,
+      trace: d,
+      internalCookieStore: this.args.internalCookieStore,
+      withXdebug: this.args.xdebug
+    }), s && !this.args["mount-before-install"] && !m.existsSync(n) && (p.log("Caching preinstalled WordPress for the next boot..."), m.writeFileSync(
+      n,
+      await M(u, "/wordpress")
+    ), p.log("Cached!")), u;
+  }
+  async bootSecondaryWorker({
+    worker: r,
+    fileLockManagerPort: e,
+    firstProcessId: o
+  }) {
+    const s = L(
+      r.phpPort
+    );
+    return await s.isConnected(), await s.useFileLockManager(e), await s.bootAsSecondaryWorker({
+      phpVersion: this.phpVersion,
+      absoluteUrl: this.siteUrl,
+      mountsBeforeWpInstall: this.args["mount-before-install"] || [],
+      mountsAfterWpInstall: this.args.mount || [],
+      // Skip WordPress zip because we share the /wordpress directory
+      // populated by the initial worker.
+      wordPressZip: void 0,
+      // Skip SQLite integration plugin for now because we
+      // will copy it from primary's `/internal` directory.
+      sqliteIntegrationPluginZip: void 0,
+      dataSqlPath: "/wordpress/wp-content/database/.ht.sqlite",
+      firstProcessId: o,
+      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
+    }), await s.isReady(), s;
+  }
+  async compileInputBlueprint(r) {
+    const e = this.args, o = e.blueprint, s = O(o) ? o : {
+      login: e.login,
+      ...o || {},
+      preferredVersions: {
+        php: e.php ?? o?.preferredVersions?.php ?? B,
+        wp: e.wp ?? o?.preferredVersions?.wp ?? "latest",
+        ...o?.preferredVersions || {}
+      }
+    }, i = new pe();
+    let n = "", l = !1;
+    return i.addEventListener("progress", (a) => {
+      if (l)
+        return;
+      l = a.detail.progress === 100;
+      const c = Math.floor(a.detail.progress);
+      n = a.detail.caption || n || "Running the Blueprint";
+      const d = `${n.trim()} – ${c}%`;
+      e.quiet || this.writeProgressUpdate(
+        process.stdout,
+        d,
+        l
+      );
+    }), await D(s, {
+      progress: i,
+      additionalSteps: r
+    });
+  }
+  writeProgressUpdate(r, e, o) {
+    e !== this.lastProgressMessage && (this.lastProgressMessage = e, r.isTTY ? (r.cursorTo(0), r.write(e), r.clearLine(1), o && r.write(`
+`)) : r.write(`${e}
+`));
+  }
+}
+async function Oe() {
+  try {
+    const t = re(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("php", {
+      describe: "PHP version to use.",
+      type: "string",
+      default: B,
+      choices: T
+    }).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: R
+    }).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: R
+    }).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: Y
+    }).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
+    }).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 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: "boolean",
+      default: !1
+    }).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-multi-worker", {
+      describe: "Enable experimental multi-worker support which requires JSPI and 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: (s) => s ?? ee().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
+    }).showHelpOnFail(!1).strictOptions().check(async (s) => {
+      if (s.wp !== void 0 && !me(s.wp))
+        try {
+          new URL(s.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 (s["experimental-multi-worker"] !== void 0) {
+        if (s["experimental-multi-worker"] <= 1)
+          throw new Error(
+            "The --experimentalMultiWorker flag must be a positive integer greater than 1."
+          );
+        const i = (n) => n.vfsPath === "/wordpress";
+        if (!s.mount?.some(i) && !s["mount-before-install"]?.some(
+          i
+        ))
+          throw new Error(
+            "Please mount a real filesystem directory as the /wordpress directory before using the --experimentalMultiWorker flag. For example: --mount-dir-before-install ./empty-dir /wordpress"
+          );
+      }
+      return !0;
+    });
+    t.wrap(t.terminalWidth());
+    const r = await t.argv, e = r._[0];
+    ["run-blueprint", "server", "build-snapshot"].includes(e) || (t.showHelp(), process.exit(1));
+    const o = {
+      ...r,
+      command: e,
+      mount: [...r.mount || [], ...r["mount-dir"] || []],
+      "mount-before-install": [
+        ...r["mount-before-install"] || [],
+        ...r["mount-dir-before-install"] || []
+      ]
+    };
+    await We(o);
+  } catch (t) {
+    if (!(t instanceof Error))
+      throw t;
+    const r = process.argv.includes("--debug");
+    console.error(r ? t : t.message), process.exit(1);
+  }
+}
+async function We(t) {
+  let r, e;
+  const o = [];
+  t.autoMount && (t = Q(t)), t.quiet && (p.handlers = []);
+  const s = await import("fs-ext").then((a) => a.flockSync).catch(() => {
+    p.warn(
+      "The fs-ext package is not installed. Internal file locking will not be integrated with host OS file locking."
+    );
+  }), i = new G(s);
+  let n = !1, l = !0;
+  return p.log("Starting a PHP server..."), ce({
+    port: t.port,
+    onBind: async (a, c) => {
+      const d = `http://127.0.0.1:${c}`, w = t.experimentalMultiWorker ?? 1, b = Math.floor(
+        Number.MAX_SAFE_INTEGER / w
+      );
+      let u;
+      t["experimental-blueprints-v2-runner"] ? u = new ye(t, {
+        siteUrl: d,
+        processIdSpaceLength: b
+      }) : (u = new ve(t, {
+        siteUrl: d,
+        processIdSpaceLength: b
+      }), typeof t.blueprint == "string" && (t.blueprint = await we({
+        sourceString: t.blueprint,
+        blueprintMayReadAdjacentFiles: t["blueprint-may-read-adjacent-files"] === !0
+      })));
+      const k = Se(
+        u.getWorkerUrl(),
+        w,
+        ({ exitCode: h, isMain: g, workerIndex: v }) => {
+          h !== 0 && (p.error(
+            `Worker ${v} exited with code ${h}
+`
+          ), g && t.exitOnPrimaryWorkerCrash && process.exit(1));
+        }
+      );
+      p.log(`Setting up WordPress ${t.wp}`);
+      try {
+        const [h, ...g] = await k, v = await U(
+          i
+        );
+        if (e = await u.bootPrimaryWorker(
+          h.phpPort,
+          v
+        ), o.push({
+          playground: e,
+          worker: h.worker
+        }), await e.isReady(), n = !0, p.log("Booted!"), r = new fe(e), !t["experimental-blueprints-v2-runner"]) {
+          const f = await u.compileInputBlueprint(
+            t["additional-blueprint-steps"] || []
+          );
+          f && (p.log("Running the Blueprint..."), await Z(f, e), p.log("Finished running the blueprint"));
+        }
+        if (t.command === "build-snapshot" ? (await xe(e, t.outfile), p.log(`WordPress exported to ${t.outfile}`), process.exit(0)) : t.command === "run-blueprint" && (p.log("Blueprint executed"), process.exit(0)), t.experimentalMultiWorker && t.experimentalMultiWorker > 1) {
+          p.log("Preparing additional workers...");
+          const f = await M(
+            e,
+            "/internal"
+          ), W = b;
+          await Promise.all(
+            g.map(async (x, C) => {
+              const E = W + C * b, H = await U(i), S = await u.bootSecondaryWorker({
+                worker: x,
+                fileLockManagerPort: H,
+                firstProcessId: E
+              });
+              o.push({
+                playground: S,
+                worker: x.worker
+              }), await S.writeFile(
+                "/tmp/internal.zip",
+                f
+              ), await _(
+                S,
+                "/tmp/internal.zip",
+                "/internal"
+              ), await S.unlink(
+                "/tmp/internal.zip"
+              ), r.addWorker(S);
+            })
+          ), p.log("Ready!");
+        }
+        return p.log(`WordPress is running on ${d}`), {
+          playground: e,
+          server: a,
+          [Symbol.asyncDispose]: async function() {
+            await Promise.all(
+              o.map(
+                async ({ playground: W, worker: x }) => {
+                  await W.dispose(), await x.terminate();
+                }
+              )
+            ), await new Promise((W) => a.close(W));
+          }
+        };
+      } catch (h) {
+        if (!t.debug)
+          throw h;
+        const g = await e.readFileAsText(z);
+        throw new Error(g, { cause: h });
+      }
+    },
+    async handleRequest(a) {
+      if (!n)
+        return F.forHttpCode(
+          502,
+          "WordPress is not ready yet"
+        );
+      if (l) {
+        l = !1;
+        const c = {
+          "Content-Type": ["text/plain"],
+          "Content-Length": ["0"],
+          Location: ["/"]
+        };
+        return a.headers?.cookie?.includes(
+          "playground_auto_login_already_happened"
+        ) && (c["Set-Cookie"] = [
+          "playground_auto_login_already_happened=1; Max-Age=0; Expires=Thu, 01 Jan 1970 00:00:00 GMT; Path=/"
+        ]), new F(302, c, new Uint8Array());
+      }
+      return await r.handleRequest(a);
+    }
+  });
+}
+function Se(t, r, e) {
+  const o = new URL(t, import.meta.url), s = [];
+  for (let i = 0; i < r; i++) {
+    const n = new N(o), l = (a) => {
+      e({
+        exitCode: a,
+        isMain: i === 0,
+        workerIndex: i
+      });
+    };
+    s.push(
+      new Promise(
+        (a, c) => {
+          n.once("message", function(d) {
+            d.command === "worker-script-initialized" && a({ worker: n, phpPort: d.phpPort });
+          }), n.once("error", function(d) {
+            console.error(d);
+            const w = new Error(
+              `Worker failed to load at ${o}. ${d.message ? `Original error: ${d.message}` : ""}`
+            );
+            w.filename = o, c(w);
+          }), n.once("exit", l);
+        }
+      )
+    );
+  }
+  return Promise.all(s);
+}
+async function U(t) {
+  const { port1: r, port2: e } = new J();
+  return await te() ? V(t, null, r) : await q(t, r), e;
+}
+async function xe(t, r) {
+  await t.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 e = await t.readFileAsBuffer("/tmp/build.zip");
+  m.writeFileSync(r, e);
+}
+export {
+  Oe as p,
+  We as r
+};
+//# sourceMappingURL=run-cli-CY1lYIJH.js.map