wp-studio 1.7.7-alpha1

package/dist/cli/sqlite-integration-H4OwSlwR.js

@@ -0,0 +1,83 @@
+import path from "path";
+import { f as fs } from "./index-BXRYeCYG.js";
+import { c as getServerFilesPath } from "./server-files-C_oy-mnI.js";
+class SqliteIntegrationProvider {
+  getSqlitePluginSourcePath() {
+    return path.join(this.getServerFilesPath(), this.getSqliteDirname());
+  }
+  async isSqliteIntegrationAvailable() {
+    const sqliteSourcePath = this.getSqlitePluginSourcePath();
+    const dbCopyPath = path.join(sqliteSourcePath, "db.copy");
+    return await fs.pathExists(sqliteSourcePath) && await fs.pathExists(dbCopyPath);
+  }
+  // Returns true if site has db.php or no wp-config.php
+  async needsSqliteSetup(sitePath) {
+    const hasDbPhp = await fs.pathExists(path.join(sitePath, "wp-content", "db.php"));
+    const hasWpConfig = await fs.pathExists(path.join(sitePath, "wp-config.php"));
+    return hasDbPhp || !hasWpConfig;
+  }
+  async getSqliteVersionFromInstallation(sqliteMuPluginPath) {
+    try {
+      const versionFileContent = await fs.readFile(
+        path.join(sqliteMuPluginPath, "load.php"),
+        "utf8"
+      );
+      const matches = versionFileContent.match(/\s\*\sVersion:\s*([0-9a-zA-Z.-]+)/);
+      return matches?.[1] || "";
+    } catch (err) {
+      return "";
+    }
+  }
+  async installSqliteIntegration(sitePath) {
+    if (!await this.isSqliteIntegrationAvailable()) {
+      throw new Error("SQLite integration files not found. Please ensure Studio is installed.");
+    }
+    const wpContentPath = path.join(sitePath, "wp-content");
+    const databasePath = path.join(wpContentPath, "database");
+    await fs.mkdir(databasePath, { recursive: true });
+    const sqliteSourcePath = this.getSqlitePluginSourcePath();
+    const dbCopyContent = await fs.readFile(path.join(sqliteSourcePath, "db.copy"), "utf8");
+    const sqliteDirname = this.getSqliteDirname();
+    const updatedContent = dbCopyContent.replace(
+      "'{SQLITE_IMPLEMENTATION_FOLDER_PATH}'",
+      `realpath( __DIR__ . '/mu-plugins/${sqliteDirname}' )`
+    ).replace(
+      "define( 'SQLITE_DB_DROPIN_VERSION'",
+      `define( 'SQLITE_MAIN_FILE', __FILE__ );
+define( 'SQLITE_DB_DROPIN_VERSION'`
+    );
+    await fs.writeFile(path.join(wpContentPath, "db.php"), updatedContent);
+    const sqliteDestPath = path.join(wpContentPath, "mu-plugins", sqliteDirname);
+    await fs.copy(sqliteSourcePath, sqliteDestPath);
+  }
+  async keepSqliteIntegrationUpdated(sitePath) {
+    if (await this.needsSqliteSetup(sitePath)) {
+      await this.installSqliteIntegration(sitePath);
+      return true;
+    }
+    return false;
+  }
+  async isSqliteInstalled(sitePath) {
+    return fs.existsSync(path.join(sitePath, "wp-content", "mu-plugins", this.getSqliteDirname())) && fs.existsSync(path.join(sitePath, "wp-content", "db.php"));
+  }
+}
+const SQLITE_FILENAME = "sqlite-database-integration";
+class CliSqliteProvider extends SqliteIntegrationProvider {
+  getServerFilesPath() {
+    return getServerFilesPath();
+  }
+  getSqliteDirname() {
+    return SQLITE_FILENAME;
+  }
+}
+const provider = new CliSqliteProvider();
+async function keepSqliteIntegrationUpdated(sitePath) {
+  return provider.keepSqliteIntegrationUpdated(sitePath);
+}
+async function isSqliteIntegrationInstalled(sitePath) {
+  return provider.isSqliteInstalled(sitePath);
+}
+export {
+  isSqliteIntegrationInstalled as i,
+  keepSqliteIntegrationUpdated as k
+};

package/dist/cli/start-CRJqm09_.js

@@ -0,0 +1,90 @@
+import { S as SiteCommandLoggerAction } from "./logger-actions-OaIvl-ai.js";
+import { __ } from "@wordpress/i18n";
+import { L as LoggerError, a as Logger, k as getSiteByFolder, H as updateSiteLatestCliPid, I as updateSiteAutoStart } from "./appdata-07CF2rhg.js";
+import { c as connectToDaemon, i as isServerRunning, s as startWordPressServer, d as disconnectFromDaemon } from "./wordpress-server-manager-CtiuJqEb.js";
+import { o as openSiteInBrowser, l as logSiteDetails, s as setupCustomDomain } from "./site-utils-CfsabjUn.js";
+import { k as keepSqliteIntegrationUpdated } from "./sqlite-integration-H4OwSlwR.js";
+const logger = new Logger();
+async function runCommand(sitePath, skipBrowser = false, skipLogDetails = false) {
+  try {
+    logger.reportStart(SiteCommandLoggerAction.START_DAEMON, __("Starting process daemon…"));
+    await connectToDaemon();
+    logger.reportSuccess(__("Process daemon started"));
+    logger.reportStart(SiteCommandLoggerAction.LOAD_SITES, __("Loading site…"));
+    const site = await getSiteByFolder(sitePath);
+    logger.reportSuccess(__("Site loaded"));
+    const runningProcess = await isServerRunning(site.id);
+    if (runningProcess) {
+      logger.reportSuccess(__("WordPress server is already running"));
+      if (runningProcess.status === "online") {
+        await updateSiteLatestCliPid(site.id, runningProcess.pid);
+      }
+      if (!skipBrowser) {
+        await openSiteInBrowser(site);
+      }
+      if (!skipLogDetails) {
+        logSiteDetails(site);
+      }
+      return;
+    }
+    await setupCustomDomain(site, logger);
+    logger.reportStart(
+      SiteCommandLoggerAction.INSTALL_SQLITE,
+      __("Setting up SQLite integration, if needed…")
+    );
+    await keepSqliteIntegrationUpdated(sitePath);
+    logger.reportSuccess(__("SQLite integration configured as needed"));
+    logger.reportStart(SiteCommandLoggerAction.START_SITE, __("Starting WordPress server…"));
+    try {
+      const processDesc = await startWordPressServer(site, logger);
+      logger.reportSuccess(__("WordPress server started"));
+      if (processDesc.status === "online") {
+        await updateSiteLatestCliPid(site.id, processDesc.pid);
+      }
+      await updateSiteAutoStart(site.id, true);
+      if (!skipLogDetails) {
+        logSiteDetails(site);
+      }
+      if (!skipBrowser) {
+        await openSiteInBrowser(site);
+      }
+    } catch (error) {
+      throw new LoggerError(__("Failed to start WordPress server"), error);
+    }
+  } finally {
+    await disconnectFromDaemon();
+  }
+}
+const registerCommand = (yargs) => {
+  return yargs.command({
+    command: "start",
+    describe: __("Start site"),
+    builder: (yargs2) => {
+      return yargs2.option("skip-browser", {
+        type: "boolean",
+        describe: __("Skip opening the site in browser after starting"),
+        default: false
+      }).option("skip-log-details", {
+        type: "boolean",
+        describe: __("Skip printing site URL and admin credentials after starting"),
+        default: false
+      });
+    },
+    handler: async (argv) => {
+      try {
+        await runCommand(argv.path, argv.skipBrowser, argv.skipLogDetails);
+      } catch (error) {
+        if (error instanceof LoggerError) {
+          logger.reportError(error);
+        } else {
+          const loggerError = new LoggerError(__("Failed to start site"), error);
+          logger.reportError(loggerError);
+        }
+      }
+    }
+  });
+};
+export {
+  registerCommand,
+  runCommand
+};

package/dist/cli/status-CWNHIOaY.js

@@ -0,0 +1,44 @@
+import { A as AuthCommandLoggerAction } from "./logger-actions-OaIvl-ai.js";
+import { __, sprintf } from "@wordpress/i18n";
+import { a as Logger, g as getAuthToken, L as LoggerError, c as getUserInfo } from "./appdata-07CF2rhg.js";
+async function runCommand() {
+  const logger = new Logger();
+  logger.reportStart(AuthCommandLoggerAction.STATUS_CHECK, __("Checking authentication status…"));
+  let token;
+  try {
+    token = await getAuthToken();
+  } catch (error) {
+    logger.reportError(new LoggerError(__("Authentication token is invalid or expired")));
+    return;
+  }
+  try {
+    const userData = await getUserInfo(token.accessToken);
+    logger.reportSuccess(
+      sprintf(__("Authenticated with WordPress.com as `%s`"), userData.username)
+    );
+  } catch (error) {
+    if (error instanceof LoggerError) {
+      logger.reportError(error);
+    } else {
+      logger.reportError(new LoggerError(__("Failed to check authentication status"), error));
+    }
+  }
+}
+const registerCommand = (yargs) => {
+  return yargs.command({
+    command: "status",
+    describe: __("Check authentication status"),
+    builder: (yargs2) => {
+      return yargs2.option("path", {
+        hidden: true
+      });
+    },
+    handler: async () => {
+      await runCommand();
+    }
+  });
+};
+export {
+  registerCommand,
+  runCommand
+};

package/dist/cli/status-CWWx9jYF.js

@@ -0,0 +1,110 @@
+import { g as getWordPressVersion } from "./get-wordpress-version-BwSCJujO.js";
+import { d as decodePassword } from "./passwords-DyzWd9Xi.js";
+import { S as SiteCommandLoggerAction } from "./logger-actions-OaIvl-ai.js";
+import { __ } from "@wordpress/i18n";
+import CliTable3 from "cli-table3";
+import { L as LoggerError, a as Logger, k as getSiteByFolder, A as getSiteUrl } from "./appdata-07CF2rhg.js";
+import { c as connectToDaemon, i as isServerRunning, d as disconnectFromDaemon } from "./wordpress-server-manager-CtiuJqEb.js";
+import { c as getPrettyPath } from "./index-7pbG_s_U.js";
+const logger = new Logger();
+async function runCommand(siteFolder, format) {
+  try {
+    logger.reportStart(SiteCommandLoggerAction.START_DAEMON, __("Starting process daemon…"));
+    await connectToDaemon();
+    logger.reportSuccess(__("Process daemon started"));
+    logger.reportStart(SiteCommandLoggerAction.LOAD_SITES, __("Loading site…"));
+    const site = await getSiteByFolder(siteFolder);
+    logger.reportSuccess(__("Site loaded"));
+    const isOnline = Boolean(await isServerRunning(site.id));
+    const status = isOnline ? `🟢 ${__("Online")}` : `🔴 ${__("Offline")}`;
+    const siteUrl = getSiteUrl(site);
+    const sitePath = getPrettyPath(site.path);
+    const wpVersion = getWordPressVersion(site.path);
+    const autoLoginUrl = new URL(siteUrl);
+    autoLoginUrl.pathname = `/studio-auto-login`;
+    autoLoginUrl.searchParams.set("redirect_to", `/wp-admin/`);
+    const xdebugStatus = site.enableXdebug ? __("Enabled") : __("Disabled");
+    const siteData = [
+      {
+        key: __("Site URL"),
+        jsonKey: "siteUrl",
+        value: new URL(siteUrl).toString(),
+        type: "url"
+      },
+      {
+        key: __("Auto-login URL"),
+        jsonKey: "autoLoginUrl",
+        value: autoLoginUrl.toString(),
+        type: "url",
+        hidden: !isOnline
+      },
+      { key: __("Site Path"), jsonKey: "sitePath", value: sitePath },
+      { key: __("Status"), jsonKey: "status", value: status },
+      { key: __("PHP version"), jsonKey: "phpVersion", value: site.phpVersion },
+      { key: __("WP version"), jsonKey: "wpVersion", value: wpVersion },
+      { key: __("Xdebug"), jsonKey: "xdebug", value: xdebugStatus },
+      {
+        key: __("Admin username"),
+        jsonKey: "adminUsername",
+        value: site.adminUsername ?? "admin"
+      },
+      {
+        key: __("Admin password"),
+        jsonKey: "adminPassword",
+        value: site.adminPassword ? decodePassword(site.adminPassword) : void 0
+      },
+      { key: __("Admin email"), jsonKey: "adminEmail", value: site.adminEmail }
+    ].filter(({ value, hidden }) => value && !hidden);
+    if (format === "table") {
+      const table = new CliTable3({
+        wordWrap: true,
+        wrapOnWordBoundary: false,
+        style: {
+          head: [],
+          border: []
+        }
+      });
+      for (const { key, value, type } of siteData) {
+        table.push([key, type === "url" ? { href: value, content: value } : value]);
+      }
+      console.table(table.toString());
+    } else {
+      const logData = Object.fromEntries(
+        siteData.map(({ jsonKey, value }) => [jsonKey, value])
+      );
+      console.log(JSON.stringify(logData, null, 2));
+    }
+  } finally {
+    await disconnectFromDaemon();
+  }
+}
+const registerCommand = (yargs) => {
+  return yargs.command({
+    command: "status",
+    describe: __("Get status of site"),
+    builder: (yargs2) => {
+      return yargs2.option("format", {
+        type: "string",
+        choices: ["table", "json"],
+        default: "table",
+        description: __("Output format")
+      });
+    },
+    handler: async (argv) => {
+      try {
+        await runCommand(argv.path, argv.format);
+      } catch (error) {
+        if (error instanceof LoggerError) {
+          logger.reportError(error);
+        } else {
+          const loggerError = new LoggerError(__("Failed to load site status"), error);
+          logger.reportError(loggerError);
+        }
+      }
+    }
+  });
+};
+export {
+  registerCommand,
+  runCommand
+};

package/dist/cli/stop-CQosmjqA.js

@@ -0,0 +1,117 @@
+import { S as SiteCommandLoggerAction } from "./logger-actions-OaIvl-ai.js";
+import { __, sprintf, _n } from "@wordpress/i18n";
+import { L as LoggerError, a as Logger, k as getSiteByFolder, K as clearSiteLatestCliPid, I as updateSiteAutoStart, r as readAppdata, l as lockAppdata, s as saveAppdata, u as unlockAppdata } from "./appdata-07CF2rhg.js";
+import { c as connectToDaemon, i as isServerRunning, a as stopWordPressServer, k as killDaemonAndChildren, d as disconnectFromDaemon } from "./wordpress-server-manager-CtiuJqEb.js";
+import { a as stopProxyIfNoSitesNeedIt } from "./site-utils-CfsabjUn.js";
+const logger = new Logger();
+var Mode = /* @__PURE__ */ ((Mode2) => {
+  Mode2[Mode2["STOP_SINGLE_SITE"] = 0] = "STOP_SINGLE_SITE";
+  Mode2[Mode2["STOP_ALL_SITES"] = 1] = "STOP_ALL_SITES";
+  return Mode2;
+})(Mode || {});
+async function runCommand(target, siteFolder, autoStart) {
+  try {
+    await connectToDaemon();
+    if (target === 0 && siteFolder) {
+      const site = await getSiteByFolder(siteFolder);
+      const runningProcess = await isServerRunning(site.id);
+      if (!runningProcess) {
+        logger.reportSuccess(__("WordPress server is not running"));
+        return;
+      }
+      logger.reportStart(SiteCommandLoggerAction.STOP_SITE, __("Stopping WordPress servers…"));
+      try {
+        await stopWordPressServer(site.id);
+        await clearSiteLatestCliPid(site.id);
+        await updateSiteAutoStart(site.id, autoStart);
+        logger.reportSuccess(__("WordPress server stopped"));
+        await stopProxyIfNoSitesNeedIt(site.id, logger);
+      } catch (error) {
+        throw new LoggerError(__("Failed to stop WordPress server"), error);
+      }
+    } else {
+      const appdata = await readAppdata();
+      const runningSites = [];
+      for (const site of appdata.sites) {
+        const runningProcess = await isServerRunning(site.id);
+        if (runningProcess) {
+          runningSites.push(site);
+        }
+      }
+      if (!runningSites.length) {
+        await killDaemonAndChildren();
+        logger.reportSuccess(__("No sites are currently running"));
+      } else {
+        try {
+          await lockAppdata();
+          const appdata2 = await readAppdata();
+          for (const site of appdata2.sites) {
+            if (runningSites.find((r) => r.id === site.id)) {
+              delete site.latestCliPid;
+              site.autoStart = autoStart;
+            }
+          }
+          await saveAppdata(appdata2);
+        } finally {
+          await unlockAppdata();
+        }
+        logger.reportStart(SiteCommandLoggerAction.STOP_ALL_SITES, __("Stopping all WordPress servers…"));
+        await killDaemonAndChildren();
+        logger.reportSuccess(
+          sprintf(
+            _n(
+              "Successfully stopped %d site",
+              "Successfully stopped %d sites",
+              runningSites.length
+            ),
+            runningSites.length
+          )
+        );
+      }
+    }
+  } finally {
+    await disconnectFromDaemon();
+  }
+}
+const registerCommand = (yargs) => {
+  return yargs.command({
+    command: "stop",
+    describe: __("Stop site(s)"),
+    builder: (yargs2) => {
+      return yargs2.option("all", {
+        type: "boolean",
+        describe: __("Stop all sites"),
+        default: false
+      }).option("auto-start", {
+        type: "boolean",
+        describe: __("Set auto-start flag for the site(s)"),
+        default: false,
+        hidden: true
+      });
+    },
+    handler: async (argv) => {
+      try {
+        if (argv.all) {
+          await runCommand(1, void 0, argv.autoStart);
+        } else {
+          await runCommand(0, argv.path, argv.autoStart);
+        }
+      } catch (error) {
+        if (error instanceof LoggerError) {
+          logger.reportError(error);
+        } else {
+          const loggerError = new LoggerError(
+            argv.all ? __("Failed to stop sites") : __("Failed to stop site"),
+            error
+          );
+          logger.reportError(loggerError);
+        }
+      }
+    }
+  });
+};
+export {
+  Mode,
+  registerCommand,
+  runCommand
+};

package/dist/cli/update-BgL2HKHW.js

@@ -0,0 +1,101 @@
+import os from "node:os";
+import path from "node:path";
+import { a as Logger, g as getAuthToken, o as DEMO_SITE_EXPIRATION_DAYS, L as LoggerError, m as uploadArchive, w as waitForSiteReady, k as getSiteByFolder } from "./appdata-07CF2rhg.js";
+import { g as getWordPressVersion } from "./get-wordpress-version-BwSCJujO.js";
+import { P as PreviewCommandLoggerAction } from "./logger-actions-OaIvl-ai.js";
+import { __, sprintf } from "@wordpress/i18n";
+import { a as archiveSiteContent, c as cleanup } from "./archive-xDmkN4wb.js";
+import { g as getSnapshotsFromAppdata, b as addDays, u as updateSnapshotInAppdata } from "./snapshots-6XE53y_F.js";
+import { n as normalizeHostname } from "./index-7pbG_s_U.js";
+async function getSnapshotToUpdate(snapshots, host, siteFolder, overwrite) {
+  const site = await getSiteByFolder(siteFolder);
+  const currentSiteId = site.id;
+  const snapshotToUpdate = snapshots.find((s) => s.url === host);
+  if (!snapshotToUpdate) {
+    throw new LoggerError("Preview site not found");
+  }
+  if (snapshotToUpdate.localSiteId !== currentSiteId && !overwrite) {
+    throw new LoggerError(
+      __(
+        "The specified directory does not match the original site for this preview. If you want to overwrite, run the command with --overwrite."
+      )
+    );
+  }
+  return snapshotToUpdate;
+}
+async function runCommand(siteFolder, host, overwrite) {
+  const archivePath = path.join(
+    os.tmpdir(),
+    `${path.basename(siteFolder)}-${Date.now()}.zip`
+  );
+  const logger = new Logger();
+  try {
+    logger.reportStart(PreviewCommandLoggerAction.VALIDATE, __("Validating…"));
+    const token = await getAuthToken();
+    const snapshots = await getSnapshotsFromAppdata(token.id);
+    const snapshotToUpdate = await getSnapshotToUpdate(snapshots, host, siteFolder, overwrite);
+    const now = /* @__PURE__ */ new Date();
+    const endDate = addDays(snapshotToUpdate.date, DEMO_SITE_EXPIRATION_DAYS);
+    if (endDate < now) {
+      throw new LoggerError(__("Cannot update an expired preview site."));
+    }
+    logger.reportSuccess(__("Validation successful"), true);
+    logger.reportStart(PreviewCommandLoggerAction.ARCHIVE, __("Creating archive…"));
+    await archiveSiteContent(siteFolder, archivePath);
+    logger.reportSuccess(__("Archive created"));
+    logger.reportStart(PreviewCommandLoggerAction.UPLOAD, __("Uploading archive…"));
+    const wordpressVersion = getWordPressVersion(siteFolder);
+    const uploadResponse = await uploadArchive(
+      archivePath,
+      token.accessToken,
+      wordpressVersion,
+      snapshotToUpdate.atomicSiteId
+    );
+    logger.reportSuccess(__("Archive uploaded"));
+    logger.reportStart(PreviewCommandLoggerAction.READY, __("Updating preview site…"));
+    await waitForSiteReady(uploadResponse.site_id, token.accessToken);
+    logger.reportSuccess(
+      sprintf(__("Preview site available at: %s"), `https://${uploadResponse.site_url}`)
+    );
+    logger.reportStart(PreviewCommandLoggerAction.APPDATA, __("Saving preview site to Studio…"));
+    const snapshot = await updateSnapshotInAppdata(uploadResponse.site_id, siteFolder);
+    logger.reportSuccess(__("Preview site saved to Studio"));
+    logger.reportKeyValuePair("name", snapshot.name ?? "");
+    logger.reportKeyValuePair("url", snapshot.url);
+  } catch (error) {
+    if (error instanceof LoggerError) {
+      logger.reportError(error);
+    } else {
+      const loggerError = new LoggerError(__("Failed to update preview site"), error);
+      logger.reportError(loggerError);
+    }
+  } finally {
+    void cleanup(archivePath);
+  }
+}
+const registerCommand = (yargs) => {
+  return yargs.command({
+    command: "update <host>",
+    describe: __("Update preview site"),
+    builder: (yargs2) => {
+      return yargs2.positional("host", {
+        type: "string",
+        description: __("Hostname of the preview site to update"),
+        demandOption: true
+      }).option("overwrite", {
+        alias: "o",
+        type: "boolean",
+        default: false,
+        description: __("Allow updating a preview site from a different directory")
+      });
+    },
+    handler: async (argv) => {
+      const normalizedHost = normalizeHostname(argv.host);
+      await runCommand(argv.path, normalizedHost, argv.overwrite);
+    }
+  });
+};
+export {
+  registerCommand,
+  runCommand
+};

package/dist/cli/validation-error-DqLxqQuA.js

@@ -0,0 +1,40 @@
+import { __ } from "@wordpress/i18n";
+const DOMAIN_PATTERN = /^(?!-)[\p{L}\p{N}][\p{L}\p{N}-]{0,61}[\p{L}\p{N}](?<!-)(?:\.(?!-)[\p{L}\p{N}-]{1,61}[\p{L}\p{N}](?<!-))+$/u;
+const getDomainNameValidationError = (useCustomDomain, domainName, existingDomainNames) => {
+  if (!useCustomDomain) {
+    return "";
+  }
+  if (!domainName) {
+    return __("The domain name is required");
+  }
+  if (existingDomainNames.includes(domainName)) {
+    return __("The domain name is already in use");
+  }
+  if (!DOMAIN_PATTERN.test(domainName)) {
+    return __("Please enter a valid domain name");
+  }
+  if (domainName.length > 253) {
+    return __("The domain name is too long");
+  }
+  if (!domainName.endsWith(".local")) {
+    return __("The domain name must end with .local");
+  }
+  return "";
+};
+class ValidationError extends Error {
+  constructor(optionName, givenValue, validationMessage) {
+    super();
+    this.name = "ValidationError";
+    this.optionName = optionName;
+    this.givenValue = givenValue;
+    this.validationMessage = validationMessage;
+  }
+  get message() {
+    return `Invalid values: 
+ - Argument: ${this.optionName}, Given: "${this.givenValue}", ${this.validationMessage}.`;
+  }
+}
+export {
+  ValidationError as V,
+  getDomainNameValidationError as g
+};