wp-studio 1.7.7-alpha1

package/dist/cli/wordpress-server-child.js

@@ -0,0 +1,514 @@
+import { dirname } from "path";
+import { D as DEFAULT_PHP_VERSION, i as isWordPressDirectory } from "./appdata-07CF2rhg.js";
+import { c as cleanupLegacyMuPlugins, g as getMuPlugins } from "./mu-plugins-GEfKsl5U.js";
+import { d as decodePassword } from "./passwords-DyzWd9Xi.js";
+import { __ } from "@wordpress/i18n";
+import { s as sequential } from "./sequential-BQFuixXz.js";
+import { i as isWordPressDevVersion } from "./wordpress-version-utils-B6UVeTh_.js";
+import { runCLI } from "@wp-playground/cli";
+import { InMemoryFilesystem, OverlayFilesystem, FetchFilesystem, NodeJsFilesystem } from "@wp-playground/storage";
+import { z } from "zod";
+import { isStepDefinition } from "@wp-playground/blueprints";
+import { g as getWpCliPharPath, a as getSqliteCommandPath } from "./server-files-C_oy-mnI.js";
+import { i as isSqliteIntegrationInstalled } from "./sqlite-integration-H4OwSlwR.js";
+import { m as managerMessageSchema } from "./wordpress-server-ipc-Dwsg9jSb.js";
+function formatPlaygroundCliMessage(message) {
+  if (message.includes("WordPress is running")) {
+    return __("WordPress is running");
+  }
+  if (message.includes("Resolved WordPress release URL")) {
+    return __("Downloading WordPress…");
+  }
+  if (message.includes("Downloading WordPress")) {
+    return __("Downloading WordPress…");
+  }
+  if (message.includes("Starting up workers")) {
+    return __("Starting up workers…");
+  }
+  if (message.includes("Booting WordPress")) {
+    return __("Booting WordPress…");
+  }
+  if (message.includes("Running the Blueprint")) {
+    return __("Running the Blueprint…");
+  }
+  if (message.includes("Finished running the blueprint")) {
+    return "";
+  }
+  if (message.includes("Preparing workers")) {
+    return __("Preparing workers…");
+  }
+  return message;
+}
+function sanitizeBlueprintStep(step) {
+  const baseStep = { step: step.step };
+  switch (step.step) {
+    case "login":
+      return { ...baseStep, hasLogin: true };
+    case "runPHP":
+    case "runPHPWithOptions":
+      return { ...baseStep, hasCode: "code" in step };
+    case "defineWpConfigConsts":
+      return {
+        ...baseStep,
+        constCount: "consts" in step ? Object.keys(step.consts).length : void 0
+      };
+    case "runSql":
+      return { ...baseStep, hasSql: "sql" in step };
+    case "writeFile":
+      return {
+        ...baseStep,
+        path: "path" in step ? step.path : void 0,
+        hasData: "data" in step
+      };
+    case "request":
+      return {
+        ...baseStep,
+        url: "request" in step ? step.request.url : void 0,
+        method: "request" in step ? step.request.method : void 0
+      };
+    case "setSiteOptions":
+    case "updateUserMeta": {
+      let keys = [];
+      if ("options" in step && step.options) {
+        keys = Object.keys(step.options);
+      } else if ("meta" in step) {
+        keys = Object.keys(step.meta);
+      }
+      return {
+        ...baseStep,
+        keys
+      };
+    }
+    case "installPlugin":
+    case "installTheme":
+      return step;
+    default:
+      return step;
+  }
+}
+function sanitizeBlueprint(blueprint) {
+  if (!blueprint) {
+    return void 0;
+  }
+  return {
+    // Keep metadata but omit author (triggers Sentry's "auth" filter)
+    meta: blueprint.meta ? {
+      title: blueprint.meta.title,
+      description: blueprint.meta.description
+    } : void 0,
+    // Sanitize each step individually
+    steps: blueprint.steps?.filter(isStepDefinition).map(sanitizeBlueprintStep),
+    // Safe configuration
+    features: blueprint.features,
+    preferredVersions: blueprint.preferredVersions,
+    landingPage: blueprint.landingPage,
+    login: typeof blueprint.login === "boolean" ? blueprint.login : "<credentials>"
+  };
+}
+function sanitizeRunCLIArgs(args) {
+  return {
+    command: args.command,
+    php: args.php,
+    wp: args.wp,
+    port: args.port,
+    debug: args.debug,
+    verbosity: args.verbosity,
+    wordpressInstallMode: args.wordpressInstallMode,
+    skipSqliteSetup: args.skipSqliteSetup,
+    followSymlinks: args.followSymlinks,
+    internalCookieStore: args.internalCookieStore,
+    xdebug: args.xdebug,
+    experimentalDevtools: args.experimentalDevtools,
+    "site-url": args["site-url"],
+    outfile: args.outfile,
+    blueprintJson: args.blueprint ? (
+      // This isn't a fully safe type assertion, but by the time we execute this, the blueprint
+      // content will already have been validated to conform to the V1 spec, so it's fine.
+      JSON.stringify(sanitizeBlueprint(args.blueprint))
+    ) : void 0
+  };
+}
+let server = null;
+let lastCliArgs = null;
+const originalConsoleLog = console.log;
+const originalConsoleError = console.error;
+const originalConsoleWarn = console.warn;
+console.log = (...args) => {
+  originalConsoleLog("[playground-cli]", ...args);
+  const message = args.join(" ");
+  process.send({ topic: "activity" });
+  const formattedMessage = formatPlaygroundCliMessage(message);
+  if (formattedMessage !== message) {
+    process.send({ topic: "console-message", message: formattedMessage });
+  }
+};
+console.error = (...args) => {
+  originalConsoleError("[playground-cli]", ...args);
+  process.send({ topic: "activity" });
+};
+console.warn = (...args) => {
+  originalConsoleWarn("[playground-cli]", ...args);
+  process.send({ topic: "activity" });
+};
+const originalStdoutWrite = process.stdout.write.bind(process.stdout);
+const originalStderrWrite = process.stderr.write.bind(process.stderr);
+process.stdout.write = function(...args) {
+  process.send({ topic: "activity" });
+  return originalStdoutWrite(...args);
+};
+process.stderr.write = function(...args) {
+  process.send({ topic: "activity" });
+  return originalStderrWrite(...args);
+};
+function logToConsole(...args) {
+  originalConsoleLog(`[WordPress Server Child]`, ...args);
+}
+function errorToConsole(...args) {
+  originalConsoleError(`[WordPress Server Child]`, ...args);
+}
+function escapePhpString(str) {
+  return str.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+}
+async function setAdminCredentials(server2, adminPassword, adminUsername, adminEmail) {
+  await server2.playground.request({
+    url: "/?studio-admin-api",
+    method: "POST",
+    body: {
+      action: "set_admin_password",
+      ...adminPassword && {
+        password: escapePhpString(decodePassword(adminPassword))
+      },
+      ...adminUsername && { username: escapePhpString(adminUsername) },
+      ...adminEmail && { email: escapePhpString(adminEmail) }
+    }
+  });
+}
+async function getWordPressInstallMode(sitePath) {
+  const hasWordPress = isWordPressDirectory(sitePath);
+  const hasSqlite = await isSqliteIntegrationInstalled(sitePath);
+  if (!hasWordPress) {
+    return "download-and-install";
+  }
+  if (hasSqlite) {
+    return "install-from-existing-files-if-needed";
+  }
+  return "do-not-attempt-installing";
+}
+async function getBaseRunCLIArgs(command, config) {
+  const wordpressInstallMode = await getWordPressInstallMode(config.sitePath);
+  await cleanupLegacyMuPlugins(config.sitePath);
+  const [studioMuPluginsHostPath, loaderMuPluginHostPath] = await getMuPlugins({
+    isWpAutoUpdating: config.isWpAutoUpdating
+  });
+  const mounts = [
+    {
+      hostPath: config.sitePath,
+      vfsPath: "/wordpress"
+    },
+    {
+      hostPath: studioMuPluginsHostPath,
+      vfsPath: "/internal/studio/mu-plugins"
+    },
+    {
+      hostPath: loaderMuPluginHostPath,
+      vfsPath: "/internal/shared/mu-plugins/99-studio-loader.php"
+    },
+    {
+      hostPath: getWpCliPharPath(),
+      vfsPath: "/tmp/wp-cli.phar"
+    },
+    {
+      hostPath: getSqliteCommandPath(),
+      vfsPath: "/tmp/sqlite-command"
+    }
+  ];
+  const enableDebugLog = config.enableDebugLog ?? false;
+  const enableDebugDisplay = config.enableDebugDisplay ?? false;
+  const defaultConstants = {
+    WP_SQLITE_AST_DRIVER: true,
+    WP_DEBUG: enableDebugLog || enableDebugDisplay,
+    WP_DEBUG_LOG: enableDebugLog,
+    WP_DEBUG_DISPLAY: enableDebugDisplay
+  };
+  let blueprintBundle;
+  const preferredVersions = {
+    php: config.phpVersion || config.blueprint?.contents.preferredVersions?.php || DEFAULT_PHP_VERSION,
+    wp: config.wpVersion || config.blueprint?.contents.preferredVersions?.wp || "latest"
+  };
+  if (config.blueprint) {
+    config.blueprint.contents.constants = {
+      ...config.blueprint.contents.constants,
+      ...defaultConstants
+    };
+    config.blueprint.contents.preferredVersions = preferredVersions;
+    const blueprintFs = new InMemoryFilesystem({
+      "blueprint.json": JSON.stringify(config.blueprint.contents)
+    });
+    if (config.blueprint.uri.startsWith("http://") || config.blueprint.uri.startsWith("https://")) {
+      blueprintBundle = new OverlayFilesystem([
+        blueprintFs,
+        new FetchFilesystem({ baseUrl: config.blueprint.uri })
+      ]);
+    } else {
+      blueprintBundle = new OverlayFilesystem([
+        blueprintFs,
+        new NodeJsFilesystem(dirname(config.blueprint.uri))
+      ]);
+    }
+  } else {
+    blueprintBundle = new InMemoryFilesystem({
+      "blueprint.json": JSON.stringify({
+        constants: defaultConstants,
+        preferredVersions
+      })
+    });
+  }
+  const args = {
+    command,
+    internalCookieStore: false,
+    login: false,
+    followSymlinks: true,
+    skipSqliteSetup: true,
+    port: config.port,
+    "mount-before-install": mounts,
+    "site-url": config.absoluteUrl || `http://localhost:${config.port}`,
+    blueprint: blueprintBundle,
+    wordpressInstallMode,
+    redis: true,
+    memcached: true
+  };
+  if (config.wpVersion) {
+    if (isWordPressDevVersion(config.wpVersion)) {
+      args.wp = "nightly";
+    } else {
+      args.wp = config.wpVersion;
+    }
+  }
+  if (config.enableXdebug) {
+    logToConsole("Enabling Xdebug support");
+    args.xdebug = true;
+  }
+  lastCliArgs = sanitizeRunCLIArgs(args);
+  return args;
+}
+let startupAbortController = null;
+let startingPromise = null;
+function wrapWithStartingPromise(callback) {
+  return async (...args) => {
+    if (startingPromise) {
+      return startingPromise;
+    }
+    startingPromise = callback(...args);
+    return startingPromise;
+  };
+}
+const startServer = wrapWithStartingPromise(
+  async (config, signal) => {
+    if (server) {
+      logToConsole(`Server already running for site ${config.siteId}`);
+      return;
+    }
+    startupAbortController = new AbortController();
+    const stopSignal = AbortSignal.any([signal, startupAbortController.signal]);
+    try {
+      stopSignal.throwIfAborted();
+      const args = await getBaseRunCLIArgs("server", config);
+      server = await runCLI(args);
+      stopSignal.throwIfAborted();
+      if (config.adminPassword || config.adminUsername || config.adminEmail) {
+        await setAdminCredentials(
+          server,
+          config.adminPassword,
+          config.adminUsername,
+          config.adminEmail
+        );
+      }
+      stopSignal.throwIfAborted();
+    } catch (error) {
+      if (server) {
+        await server[Symbol.asyncDispose]();
+        server = null;
+      }
+      if (error instanceof Error && error.name === "AbortError") {
+        logToConsole(`Aborted start server operation:`, error);
+      } else {
+        errorToConsole(`Failed to start server:`, error);
+      }
+      throw error;
+    } finally {
+      startupAbortController = null;
+    }
+  }
+);
+const STOP_SERVER_TIMEOUT = 5e3;
+async function stopServer() {
+  if (startupAbortController) {
+    logToConsole("Startup operation in progress. Aborting it to stop the server…");
+    startupAbortController.abort();
+    return "ABORTED_STARTUP";
+  }
+  if (!server) {
+    logToConsole("No server running, nothing to stop");
+    return "OK";
+  }
+  try {
+    const disposalTimeout = new Promise(
+      (_, reject) => setTimeout(() => reject(new Error("Server disposal timeout")), STOP_SERVER_TIMEOUT)
+    );
+    await Promise.race([server[Symbol.asyncDispose](), disposalTimeout]);
+    logToConsole("Server stopped gracefully");
+    return "OK";
+  } catch (error) {
+    errorToConsole("Error during server disposal:", error);
+    throw error;
+  } finally {
+    server = null;
+  }
+}
+async function runBlueprint(config, signal) {
+  try {
+    signal.throwIfAborted();
+    const args = await getBaseRunCLIArgs("run-blueprint", config);
+    await runCLI(args);
+    signal.throwIfAborted();
+    logToConsole(`Blueprint applied successfully for site ${config.siteId}`);
+  } catch (error) {
+    errorToConsole(`Failed to run Blueprint:`, error);
+    throw error;
+  }
+}
+const runWpCliCommand = sequential(
+  async (args, signal) => {
+    await Promise.allSettled([startingPromise]);
+    if (!server) {
+      throw new Error(`Failed to run WP CLI command because server is not running`);
+    }
+    logToConsole(`Running WP-CLI command:`, args);
+    signal.addEventListener(
+      "abort",
+      () => {
+        throw new Error("Operation aborted");
+      },
+      { once: true }
+    );
+    const response = await server.playground.cli([
+      "php",
+      "/tmp/wp-cli.phar",
+      `--path=${await server.playground.documentRoot}`,
+      ...args
+    ]);
+    return {
+      stdout: await response.stdoutText,
+      stderr: await response.stderrText,
+      exitCode: await response.exitCode
+    };
+  },
+  { concurrent: 3, max: 100, deduplicateKey: (args) => args.join(" ") }
+);
+function parsePhpError(error) {
+  if (!(error instanceof Error)) {
+    return String(error);
+  }
+  const message = error.message;
+  const wpDieMatch = message.match(/<div class="wp-die-message"[^>]*>([\s\S]*?)<\/div>/);
+  if (wpDieMatch) {
+    const htmlContent = wpDieMatch[1];
+    const textContent = htmlContent.replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
+    if (textContent) {
+      return `WordPress error: ${textContent}`;
+    }
+  }
+  const fatalMatch = message.match(/PHP Fatal error:\s*(.+?)(?:\sin\s|$)/i);
+  if (fatalMatch) {
+    return `PHP Fatal error: ${fatalMatch[1].trim()}`;
+  }
+  if (message.includes("PHP.run() failed with exit code")) {
+    const exitCodeMatch = message.match(/exit code (\d+)/);
+    const exitCode = exitCodeMatch ? exitCodeMatch[1] : "unknown";
+    return `WordPress failed to start (PHP exit code ${exitCode}). Check the site's debug.log for details.`;
+  }
+  return message;
+}
+function sendErrorMessage(messageId, error) {
+  return new Promise((resolve) => {
+    const errorResponse = {
+      originalMessageId: messageId,
+      topic: "error",
+      errorMessage: parsePhpError(error),
+      errorStack: error instanceof Error ? error.stack : void 0,
+      cliArgs: lastCliArgs ?? void 0
+    };
+    process.send(errorResponse, () => {
+      resolve();
+    });
+  });
+}
+const abortControllers = {};
+async function ipcMessageHandler(packet) {
+  const messageResult = managerMessageSchema.safeParse(packet);
+  if (!messageResult.success) {
+    errorToConsole("Invalid message received:", messageResult.error);
+    const minimalMessageSchema = z.object({ id: z.string() });
+    const minimalMessage = minimalMessageSchema.safeParse(packet);
+    if (minimalMessage.success) {
+      await sendErrorMessage(minimalMessage.data.id, messageResult.error);
+    }
+    return;
+  }
+  const validMessage = messageResult.data;
+  if (validMessage.topic !== "abort") {
+    abortControllers[validMessage.messageId] = new AbortController();
+  }
+  const abortController = abortControllers[validMessage.messageId];
+  logToConsole(`Received ${validMessage.topic} message`);
+  try {
+    let result;
+    switch (validMessage.topic) {
+      case "abort":
+        abortController?.abort();
+        return;
+      case "start-server":
+        result = await startServer(validMessage.data.config, abortController.signal);
+        break;
+      case "run-blueprint":
+        result = await runBlueprint(validMessage.data.config, abortController.signal);
+        break;
+      case "stop-server":
+        result = await stopServer();
+        break;
+      case "wp-cli-command":
+        try {
+          result = await runWpCliCommand(validMessage.data.args, abortController.signal);
+        } catch (wpCliError) {
+          errorToConsole(`WP-CLI error:`, wpCliError);
+          await sendErrorMessage(validMessage.messageId, wpCliError);
+          return;
+        }
+        break;
+      default:
+        throw new Error(`Unknown message.`);
+    }
+    const response = {
+      originalMessageId: validMessage.messageId,
+      topic: "result",
+      result
+    };
+    process.send(response);
+    if (validMessage.topic === "stop-server" && result === "OK") {
+      process.disconnect();
+    }
+  } catch (error) {
+    errorToConsole(`Error handling message ${validMessage.topic}:`, error);
+    await sendErrorMessage(validMessage.messageId, error);
+    originalConsoleLog("Killing process because of", error);
+    process.exit(1);
+  } finally {
+    delete abortControllers[validMessage.messageId];
+  }
+}
+if (process.send) {
+  process.on("message", ipcMessageHandler);
+  process.send({ topic: "ready" });
+} else {
+  throw new Error("process.send is not available");
+}

package/dist/cli/wordpress-server-ipc-Dwsg9jSb.js

@@ -0,0 +1,140 @@
+import { z } from "zod";
+const serverConfig = z.object({
+  siteId: z.string(),
+  sitePath: z.string(),
+  port: z.number(),
+  phpVersion: z.string().optional(),
+  wpVersion: z.string().optional(),
+  absoluteUrl: z.string().optional(),
+  adminUsername: z.string().optional(),
+  adminPassword: z.string().optional(),
+  adminEmail: z.string().optional(),
+  siteTitle: z.string().optional(),
+  siteLanguage: z.string().optional(),
+  isWpAutoUpdating: z.boolean().optional(),
+  enableXdebug: z.boolean().optional(),
+  enableDebugLog: z.boolean().optional(),
+  enableDebugDisplay: z.boolean().optional(),
+  blueprint: z.object({
+    contents: z.any(),
+    // Blueprint type is complex, allow any for now
+    uri: z.string()
+  }).optional()
+});
+const managerMessageAbort = z.object({
+  topic: z.literal("abort"),
+  data: z.object({})
+});
+const managerMessageStartServer = z.object({
+  topic: z.literal("start-server"),
+  data: z.object({
+    config: serverConfig
+  })
+});
+const managerMessageRunBlueprint = z.object({
+  topic: z.literal("run-blueprint"),
+  data: z.object({
+    config: serverConfig
+  })
+});
+const managerMessageStopServer = z.object({
+  topic: z.literal("stop-server"),
+  data: z.object({})
+});
+const managerMessageWpCliCommand = z.object({
+  topic: z.literal("wp-cli-command"),
+  data: z.object({
+    args: z.array(z.string())
+  })
+});
+z.discriminatedUnion("topic", [
+  managerMessageAbort,
+  managerMessageStartServer,
+  managerMessageRunBlueprint,
+  managerMessageStopServer,
+  managerMessageWpCliCommand
+]);
+const managerMessageBase = z.object({ messageId: z.string() });
+const managerMessageSchema = z.discriminatedUnion("topic", [
+  managerMessageBase.extend(managerMessageAbort.shape),
+  managerMessageBase.extend(managerMessageStartServer.shape),
+  managerMessageBase.extend(managerMessageRunBlueprint.shape),
+  managerMessageBase.extend(managerMessageStopServer.shape),
+  managerMessageBase.extend(managerMessageWpCliCommand.shape)
+]);
+const childMessageReady = z.object({
+  topic: z.literal("ready")
+});
+const childMessageActivity = z.object({
+  topic: z.literal("activity")
+});
+const childMessageResult = z.object({
+  originalMessageId: z.string(),
+  topic: z.literal("result"),
+  result: z.unknown()
+});
+const childMessageError = z.object({
+  originalMessageId: z.string(),
+  topic: z.literal("error"),
+  errorMessage: z.string(),
+  errorStack: z.string().optional(),
+  cliArgs: z.record(z.string(), z.unknown()).optional()
+});
+const childMessageConsole = z.object({
+  topic: z.literal("console-message"),
+  message: z.string()
+});
+const childMessageSiteCreated = z.object({
+  topic: z.literal("site-created"),
+  data: z.object({
+    siteId: z.string()
+  })
+});
+const childMessageSiteUpdated = z.object({
+  topic: z.literal("site-updated"),
+  data: z.object({
+    siteId: z.string()
+  })
+});
+const childMessageSiteDeleted = z.object({
+  topic: z.literal("site-deleted"),
+  data: z.object({
+    siteId: z.string()
+  })
+});
+const childMessageSiteStarted = z.object({
+  topic: z.literal("site-started"),
+  data: z.object({
+    siteId: z.string(),
+    url: z.string()
+  })
+});
+const childMessageSiteStopped = z.object({
+  topic: z.literal("site-stopped"),
+  data: z.object({
+    siteId: z.string()
+  })
+});
+const childMessageRaw = z.discriminatedUnion("topic", [
+  childMessageReady,
+  childMessageActivity,
+  childMessageResult,
+  childMessageError,
+  childMessageConsole,
+  childMessageSiteCreated,
+  childMessageSiteUpdated,
+  childMessageSiteDeleted,
+  childMessageSiteStarted,
+  childMessageSiteStopped
+]);
+const childMessageFromProcessManagerSchema = z.object({
+  process: z.object({
+    name: z.string(),
+    pm_id: z.number()
+  }),
+  raw: childMessageRaw
+});
+export {
+  childMessageFromProcessManagerSchema as c,
+  managerMessageSchema as m
+};