@wp-playground/cli 3.0.54 → 3.1.1

package/worker-thread-v2.js

@@ -1,59 +1,58 @@
-import { logger as M, errorLogPath as S } from "@php-wasm/logger";
-import { createNodeFsMountHandler as R, loadNodeRuntime as F } from "@php-wasm/node";
-import { EmscriptenDownloadMonitor as B } from "@php-wasm/progress";
-import { exposeAPI as _, PHPWorker as L, consumeAPI as I, consumeAPISync as q, sandboxedSpawnHandlerFactory as x, PHPResponse as E, PHPExecutionFailureError as C } from "@php-wasm/universal";
-import { sprintf as N } from "@php-wasm/util";
+import { logger as T, errorLogPath as H } from "@php-wasm/logger";
+import { createNodeFsMountHandler as W, loadNodeRuntime as M, bindUserSpace as $ } from "@php-wasm/node";
+import { EmscriptenDownloadMonitor as I } from "@php-wasm/progress";
+import { exposeAPI as v, PHPWorker as A, consumeAPISync as S, setPhpIniEntries as L, writeFiles as B, sandboxedSpawnHandlerFactory as C, PHPResponse as E, PHPExecutionFailureError as F, consumeAPI as g, releaseApiProxy as U } from "@php-wasm/universal";
+import { joinPaths as q, sprintf as D } from "@php-wasm/util";
 import { runBlueprintV2 as O } from "@wp-playground/blueprints";
-import { bootRequestHandler as j } from "@wp-playground/wordpress";
-import { existsSync as V } from "fs";
-import W from "path";
-import { rootCertificates as D } from "tls";
-import { MessageChannel as U, parentPort as Y } from "worker_threads";
-import { jspi as z } from "wasm-feature-detect";
-import { s as K, b as G } from "./run-cli-Cxpf7CoX.js";
-async function m(s, e) {
-  for (const r of e)
+import { setupPlatformLevelMuPlugins as j, preloadPhpInfoRoute as V, bootRequestHandler as N } from "@wp-playground/wordpress";
+import { existsSync as G } from "fs";
+import m from "path";
+import { rootCertificates as Y } from "tls";
+import { MessageChannel as z, parentPort as K } from "worker_threads";
+import { s as J, b as Q } from "./run-cli-FHDubnX7.js";
+async function b(s, e) {
+  for (const t of e)
     try {
-      s.mkdir(r.vfsPath), await s.mount(
-        r.vfsPath,
-        R(r.hostPath)
+      s.mkdir(t.vfsPath), await s.mount(
+        t.vfsPath,
+        W(t.hostPath)
       );
     } catch {
-      i.stderr(
-        `\x1B[31m\x1B[1mError mounting path ${r.hostPath} at ${r.vfsPath}\x1B[0m
+      a.stderr(
+        `\x1B[31m\x1B[1mError mounting path ${t.hostPath} at ${t.vfsPath}\x1B[0m
 `
       ), process.exit(1);
     }
 }
-function J(s, e, ...r) {
+function X(s, e, ...t) {
   console.log(
     performance.now().toFixed(6).padStart(15, "0"),
     s.toString().padStart(16, "0"),
-    N(e, ...r)
+    D(e, ...t)
   );
 }
 Object.defineProperty(process.stdout, "isTTY", { value: !0 });
 Object.defineProperty(process.stderr, "isTTY", { value: !0 });
-const i = {
+const a = {
   lastWriteWasProgress: !1,
   progress(s) {
-    G(process.stdout) && (process.stdout.isTTY ? (i.lastWriteWasProgress || process.stdout.write(`
-`), process.stdout.write("\r\x1B[K" + s), i.lastWriteWasProgress = !0) : console.log(s));
+    Q(process.stdout) && (process.stdout.isTTY ? (a.lastWriteWasProgress || process.stdout.write(`
+`), process.stdout.write("\r\x1B[K" + s), a.lastWriteWasProgress = !0) : console.log(s));
   },
   stdout(s) {
     process.stdout.write(`
 
 
-`), i.lastWriteWasProgress && (i.lastWriteWasProgress = !1), process.stdout.write(s);
+`), a.lastWriteWasProgress && (a.lastWriteWasProgress = !1), process.stdout.write(s);
   },
   stderr(s) {
     process.stdout.write(`
 
 
-`), i.lastWriteWasProgress && (i.lastWriteWasProgress = !1), process.stderr.write(s);
+`), a.lastWriteWasProgress && (a.lastWriteWasProgress = !1), process.stderr.write(s);
   }
 };
-class Q extends L {
+class Z extends A {
   constructor(e) {
     super(void 0, e), this.booted = !1, this.blueprintTargetResolved = !1, this.phpInstancesThatNeedMountsAfterTargetResolved = /* @__PURE__ */ new Set();
   }
@@ -67,76 +66,67 @@ class Q extends L {
    * @see phpwasm-emscripten-library-file-locking-for-node.js
    */
   async useFileLockManager(e) {
-    await z() ? this.fileLockManager = I(e) : this.fileLockManager = await q(e);
+    this.fileLockManager = await S(e);
   }
-  async bootAndSetUpInitialWorker(e) {
-    const r = {
-      ...e.constants || {}
-    }, c = {
-      ...e,
-      createFiles: {
-        "/internal/shared/ca-bundle.crt": D.join(`
+  async bootWordPress(e, t) {
+    const o = await this.__internal_getRequestHandler().getPrimaryPhp();
+    if (o.defineConstant("WP_DEBUG", "true"), o.defineConstant("WP_DEBUG_LOG", "true"), o.defineConstant("WP_DEBUG_DISPLAY", "false"), o.defineConstant("WP_HOME", e.siteUrl), o.defineConstant("WP_SITEURL", e.siteUrl), await L(o, {
+      "openssl.cafile": "/internal/shared/ca-bundle.crt",
+      allow_url_fopen: "1",
+      disable_functions: ""
+    }), await j(o), await B(o, "/", {
+      "/internal/shared/ca-bundle.crt": Y.join(`
 `)
-      },
-      constants: r,
-      phpIniEntries: {
-        "openssl.cafile": "/internal/shared/ca-bundle.crt"
-      },
-      onPHPInstanceCreated: async (o) => {
-        await m(o, e.mountsBeforeWpInstall || []), this.blueprintTargetResolved ? await m(o, e.mountsAfterWpInstall || []) : (this.phpInstancesThatNeedMountsAfterTargetResolved.add(o), o.addEventListener("runtime.beforeExit", () => {
-          this.phpInstancesThatNeedMountsAfterTargetResolved.delete(
-            o
-          );
-        }));
-      },
-      spawnHandler: () => x(
-        () => T(e, this.fileLockManager)
-      )
-    };
-    await this.bootRequestHandler(c);
-    const p = this.__internal_getPHP();
-    if (e.mode === "mount-only") {
-      await m(p, e.mountsAfterWpInstall || []);
+    }), await V(
+      o,
+      q(new URL(e.siteUrl).pathname, "phpinfo.php")
+    ), e.mode === "mount-only") {
+      await this.applyPostInstallMountsToAllWorkers(
+        t
+      );
       return;
     }
-    await this.runBlueprintV2({
-      ...e,
-      mountsAfterWpInstall: e.mountsAfterWpInstall || []
-    });
+    await this.runBlueprintV2(
+      {
+        // TODO: Do we really want to create a new object or can we pass args directly?
+        ...e
+      },
+      t
+    );
   }
   async bootWorker(e) {
     await this.bootRequestHandler({
       ...e,
-      onPHPInstanceCreated: async (r) => {
-        await m(r, e.mountsBeforeWpInstall || []), await m(r, e.mountsAfterWpInstall || []), r.isDir("/wordpress/wp-content") || r.mkdir("/wordpress/wp-content"), r.isDir("/wordpress/wp-content/database") || r.mkdir("/wordpress/wp-content/database"), r.isFile("/wordpress/wp-content/database/.htaccess") || r.writeFile(
+      onPHPInstanceCreated: async (t) => {
+        await b(t, e.mountsBeforeWpInstall || []), await b(t, e.mountsAfterWpInstall || []), t.isDir("/wordpress/wp-content") || t.mkdir("/wordpress/wp-content"), t.isDir("/wordpress/wp-content/database") || t.mkdir("/wordpress/wp-content/database"), t.isFile("/wordpress/wp-content/database/.htaccess") || t.writeFile(
           "/wordpress/wp-content/database/.htaccess",
           "deny from all"
-        ), r.isFile("/wordpress/wp-content/database/index.php") || r.writeFile(
+        ), t.isFile("/wordpress/wp-content/database/index.php") || t.writeFile(
           "/wordpress/wp-content/database/index.php",
           "deny from all"
         );
       },
-      spawnHandler: () => x(
-        () => T(e, this.fileLockManager)
+      spawnHandler: () => C(
+        () => ee(e, this.fileLockManager)
       )
     });
   }
-  async runBlueprintV2(e) {
-    const r = this.__internal_getRequestHandler(), { php: c, reap: p } = await r.instanceManager.acquirePHPInstance(), o = this.__internal_getPHP();
-    let u = () => {
+  async runBlueprintV2(e, t) {
+    const o = this.__internal_getRequestHandler(), { php: u, reap: h } = await o.instanceManager.acquirePHPInstance(), w = this.__internal_getPHP();
+    let f = () => {
     };
     if (typeof e.blueprint == "string") {
-      const n = W.resolve(process.cwd(), e.blueprint);
-      V(n) && (o.mkdir("/internal/shared/cwd"), u = await o.mount(
+      const n = m.resolve(process.cwd(), e.blueprint);
+      G(n) && (w.mkdir("/internal/shared/cwd"), f = await w.mount(
         "/internal/shared/cwd",
-        R(W.dirname(n))
-      ), e.blueprint = W.join(
+        W(m.dirname(n))
+      ), e.blueprint = m.join(
         "/internal/shared/cwd",
-        W.basename(e.blueprint)
+        m.basename(e.blueprint)
       ));
     }
     try {
-      const l = [
+      const i = [
         "mode",
         "db-engine",
         "db-host",
@@ -146,47 +136,40 @@ class Q extends L {
         "db-path",
         "truncate-new-site-directory",
         "allow"
-      ].filter((t) => t in e).map((t) => `--${t}=${e[t]}`);
-      l.push(`--site-url=${e.siteUrl}`);
-      const d = await O({
-        php: c,
+      ].filter((r) => r in e).map((r) => `--${r}=${e[r]}`);
+      i.push(`--site-url=${e.siteUrl}`);
+      const l = await O({
+        php: u,
         blueprint: e.blueprint,
         blueprintOverrides: {
           additionalSteps: e["additional-blueprint-steps"],
           wordpressVersion: e.wp
         },
-        cliArgs: l,
-        onMessage: async (t) => {
-          switch (t.type) {
+        cliArgs: i,
+        onMessage: async (r) => {
+          switch (r.type) {
             case "blueprint.target_resolved": {
-              if (!this.blueprintTargetResolved) {
-                this.blueprintTargetResolved = !0;
-                for (const a of this.phpInstancesThatNeedMountsAfterTargetResolved)
-                  this.phpInstancesThatNeedMountsAfterTargetResolved.delete(
-                    a
-                  ), await m(
-                    a,
-                    e.mountsAfterWpInstall || []
-                  );
-              }
+              this.blueprintTargetResolved || (this.blueprintTargetResolved = !0, await this.applyPostInstallMountsToAllWorkers(
+                t
+              ));
               break;
             }
             case "blueprint.progress": {
-              const a = `${t.caption.trim()} – ${t.progress.toFixed(
+              const p = `${r.caption.trim()} – ${r.progress.toFixed(
                 2
               )}%`;
-              i.progress(a);
+              a.progress(p);
               break;
             }
             case "blueprint.error": {
-              const a = "\x1B[31m", w = "\x1B[1m", f = "\x1B[0m";
-              e.verbosity === "debug" && t.details ? i.stderr(
-                `${a}${w}Fatal error:${f} Uncaught ${t.details.exception}: ${t.details.message}
-  at ${t.details.file}:${t.details.line}
-` + (t.details.trace ? t.details.trace + `
+              const p = "\x1B[31m", c = "\x1B[1m", d = "\x1B[0m";
+              e.verbosity === "debug" && r.details ? a.stderr(
+                `${p}${c}Fatal error:${d} Uncaught ${r.details.exception}: ${r.details.message}
+  at ${r.details.file}:${r.details.line}
+` + (r.details.trace ? r.details.trace + `
 ` : "")
-              ) : i.stderr(
-                `${a}${w}Error:${f} ${t.message}
+              ) : a.stderr(
+                `${p}${c}Error:${d} ${r.message}
 `
               );
               break;
@@ -194,169 +177,173 @@ class Q extends L {
           }
         }
       });
-      if (e.verbosity === "debug" && (d.stdout.pipeTo(
+      if (e.verbosity === "debug" && (l.stdout.pipeTo(
         new WritableStream({
-          write(t) {
-            process.stdout.write(t);
+          write(r) {
+            process.stdout.write(r);
           }
         })
-      ), d.stderr.pipeTo(
+      ), l.stderr.pipeTo(
         new WritableStream({
-          write(t) {
-            process.stderr.write(t);
+          write(r) {
+            process.stderr.write(r);
           }
         })
-      )), await d.finished, await d.exitCode !== 0) {
-        const t = await E.fromStreamedResponse(d);
-        throw new C(
-          `PHP.run() failed with exit code ${t.exitCode}. ${t.errors} ${t.text}`,
-          t,
+      )), await l.finished, await l.exitCode !== 0) {
+        const r = await E.fromStreamedResponse(l);
+        throw new F(
+          `PHP.run() failed with exit code ${r.exitCode}. ${r.errors} ${r.text}`,
+          r,
           "request"
         );
       }
     } catch (n) {
-      let l = "";
+      let i = "";
       try {
-        l = c.readFileAsText(S);
+        i = u.readFileAsText(H);
       } catch {
       }
-      throw n.phpLogs = l, n;
+      throw n.phpLogs = i, n;
     } finally {
-      p(), u();
+      h(), f();
     }
   }
   async bootRequestHandler({
     siteUrl: e,
-    allow: r,
-    phpVersion: c,
-    createFiles: p,
-    constants: o,
-    phpIniEntries: u,
-    firstProcessId: n,
-    processIdSpaceLength: l,
-    trace: d,
-    nativeInternalDirPath: t,
-    withIntl: a,
-    withRedis: w,
-    withMemcached: f,
-    withXdebug: k,
-    pathAliases: b,
-    onPHPInstanceCreated: h,
-    spawnHandler: v
+    allow: t,
+    phpVersion: o,
+    processId: u,
+    createFiles: h,
+    constants: w,
+    phpIniEntries: f,
+    trace: n,
+    nativeInternalDirPath: i,
+    withIntl: l,
+    withRedis: r,
+    withMemcached: p,
+    withXdebug: c,
+    pathAliases: d,
+    onPHPInstanceCreated: k,
+    spawnHandler: x
   }) {
     if (this.booted)
       throw new Error("Playground already booted");
     this.booted = !0;
-    let y = n;
-    const H = n + l - 1;
     try {
-      const P = await j({
+      const P = await N({
         siteUrl: e,
-        createPhpRuntime: async () => {
-          const $ = y;
-          return y < H ? y++ : y = n, await F(c, {
-            emscriptenOptions: {
-              fileLockManager: this.fileLockManager,
-              processId: $,
-              trace: d ? J : void 0,
-              ENV: {
-                DOCROOT: "/wordpress"
-              },
-              phpWasmInitOptions: { nativeInternalDirPath: t }
+        createPhpRuntime: async () => await M(o, {
+          fileLockManager: this.fileLockManager,
+          emscriptenOptions: {
+            processId: u,
+            trace: n ? X : void 0,
+            ENV: {
+              DOCROOT: "/wordpress"
             },
-            followSymlinks: r?.includes("follow-symlinks"),
-            withIntl: a,
-            withRedis: w,
-            withMemcached: f,
-            withXdebug: k
-          });
-        },
+            nativeInternalDirPath: i,
+            bindUserSpace: (R) => $(
+              {
+                fileLockManager: this.fileLockManager
+              },
+              R
+            )
+          },
+          followSymlinks: t?.includes("follow-symlinks"),
+          withIntl: l,
+          withRedis: r,
+          withMemcached: p,
+          withXdebug: c
+        }),
         maxPhpInstances: 1,
-        onPHPInstanceCreated: h,
+        onPHPInstanceCreated: k,
         sapiName: "cli",
-        createFiles: p,
-        constants: o,
-        phpIniEntries: u,
-        pathAliases: b,
+        createFiles: h,
+        constants: w,
+        phpIniEntries: f,
+        pathAliases: d,
         cookieStore: !1,
-        spawnHandler: v
+        spawnHandler: x
       });
       this.__internal_setRequestHandler(P);
-      const A = await P.getPrimaryPhp();
-      await this.setPrimaryPHP(A), X();
+      const _ = await P.getPrimaryPhp();
+      await this.setPrimaryPHP(_), te();
     } catch (P) {
-      throw Z(P), P;
+      throw re(P), P;
     }
   }
+  async mountAfterWordPressInstall(e) {
+    await b(this.__internal_getPHP(), e);
+  }
+  async applyPostInstallMountsToAllWorkers(e) {
+    const t = g(e);
+    await t(), t[U]();
+  }
   // Provide a named disposal method that can be invoked via comlink.
   async dispose() {
     await this[Symbol.asyncDispose]();
   }
 }
-async function T({
+async function ee({
   siteUrl: s,
   allow: e,
-  phpVersion: r,
-  createFiles: c,
-  constants: p,
-  phpIniEntries: o,
-  firstProcessId: u,
-  processIdSpaceLength: n,
-  trace: l,
-  nativeInternalDirPath: d,
-  withXdebug: t,
-  pathAliases: a,
-  mountsBeforeWpInstall: w,
-  mountsAfterWpInstall: f
-}, k) {
-  const b = await K("v2"), h = I(
-    b.phpPort
+  phpVersion: t,
+  createFiles: o,
+  constants: u,
+  phpIniEntries: h,
+  trace: w,
+  nativeInternalDirPath: f,
+  withXdebug: n,
+  pathAliases: i,
+  mountsBeforeWpInstall: l,
+  mountsAfterWpInstall: r
+}, p) {
+  const c = await J("v2"), d = g(
+    c.phpPort
   );
-  return h.useFileLockManager(k), await h.bootWorker({
+  return d.useFileLockManager(p), await d.bootWorker({
     siteUrl: s,
     allow: e,
-    phpVersion: r,
-    createFiles: c,
-    constants: p,
-    phpIniEntries: o,
-    firstProcessId: u,
-    processIdSpaceLength: n,
-    trace: l,
-    nativeInternalDirPath: d,
-    withXdebug: t,
-    pathAliases: a,
-    mountsBeforeWpInstall: w,
-    mountsAfterWpInstall: f
+    phpVersion: t,
+    createFiles: o,
+    constants: u,
+    phpIniEntries: h,
+    processId: c.processId,
+    trace: w,
+    nativeInternalDirPath: f,
+    withXdebug: n,
+    pathAliases: i,
+    mountsBeforeWpInstall: l,
+    mountsAfterWpInstall: r
   }), {
-    php: h,
+    php: d,
     reap: () => {
       try {
-        h.dispose();
+        d.dispose();
       } catch {
       }
       try {
-        b.worker.terminate();
+        c.worker.terminate();
       } catch {
       }
     }
   };
 }
 process.on("unhandledRejection", (s) => {
-  M.error("Unhandled rejection:", s);
+  T.error("Unhandled rejection:", s);
 });
-const g = new U(), [X, Z] = _(
-  new Q(new B()),
+const y = new z(), [te, re] = v(
+  new Z(new I()),
   void 0,
-  g.port1
+  y.port1
 );
-Y?.postMessage(
+K?.postMessage(
   {
     command: "worker-script-initialized",
-    phpPort: g.port2
+    phpPort: y.port2
   },
-  [g.port2]
+  [y.port2]
 );
 export {
-  Q as PlaygroundCliBlueprintV2Worker
+  Z as PlaygroundCliBlueprintV2Worker
 };
 //# sourceMappingURL=worker-thread-v2.js.map