wp-studio 1.7.9 → 1.7.10-beta1

package/dist/cli/{index-BiCiEz-r.mjs → index-upH2G_fw.mjs}

@@ -49,17 +49,17 @@ import semver from "semver";
 import yargs from "yargs";
 import * as path from "path";
 import path__default from "path";
-import { L as LoggerError, a as LOCKFILE_STALE_TIME, b as LOCKFILE_WAIT_TIME, g as getDefaultExportFromCjs, c as LatestSupportedPHPVersion, D as DEFAULT_PHP_VERSION, A as ARCHIVER_OPTIONS, d as Logger, S as SupportedPHPVersionsList, P as PLAYGROUND_CLI_MAX_TIMEOUT, e as PLAYGROUND_CLI_INACTIVITY_TIMEOUT, f as PLAYGROUND_CLI_ACTIVITY_CHECK_INTERVAL, h as getServerFilesPath, i as commonjsGlobal, j as getSharedConfigPath, k as getConfigDirectory, l as SHARED_CONFIG_LOCKFILE_NAME, m as DEMO_SITE_EXPIRATION_DAYS, H as HOUR_MS, n as DAY_MS, o as DEMO_SITE_SIZE_LIMIT_BYTES, p as DEMO_SITE_SIZE_LIMIT_GB, M as MINIMUM_WORDPRESS_VERSION, q as DEFAULT_WORDPRESS_VERSION$1, r as emitProgress, s as setProgressCallback, t as getProgressCallback, u as getCliConfigPath } from "./well-known-paths-CG_o9mSO.mjs";
-import { a as arePathsEqual, i as isWordPressDirectory, g as getWordPressVersionPath, r as recursiveCopyDirectory, b as getWordPressVersionUrl, I as IS_JSPI_AVAILABLE, c as cleanupLegacyMuPlugins, d as getMuPlugins, e as getWpCliPharPath, f as getSqliteCommandPath, k as keepSqliteIntegrationUpdated, h as createDeployIgnoreFilter, j as calculateDirectorySizeForArchive, p as pathExists, l as isWordPressBetaVersion, m as isWordPressDevVersion, n as getWpFilesPath, o as getSqlitePluginPath, q as getLanguagePacksPath, s as getAiInstructionsPath, t as getPhpMyAdminPath, u as getSqliteVersionFromInstallation, v as isEmptyDir, w as decodePassword, x as validateAdminUsername, y as validateAdminEmail, z as encodePassword, A as createPassword, B as isValidWordPressVersion, C as isWordPressVersionAtLeast, D as getUnsupportedWpCliPostContentMessage } from "./rewrite-wp-cli-post-content-DH3hRTU5.mjs";
-import { l as lockCliConfig, r as readCliConfig, s as saveCliConfig, u as unlockCliConfig, a as lockFileAsync, b as unlockFileAsync, c as authTokenSchema, h as hideDirectoryOnWindows, S as SNAPSHOT_EVENTS, d as requireSignalExit, e as StatsMetric, f as StatsGroup, g as updateCliConfigWithPartial, i as generateSiteCertificate, j as SITE_EVENTS, k as deleteSiteCertificate, m as updateCheckSchema } from "./certificate-manager-Bp1E0km4.mjs";
+import { L as LoggerError, a as LOCKFILE_STALE_TIME, b as LOCKFILE_WAIT_TIME, g as getDefaultExportFromCjs, c as LatestSupportedPHPVersion, D as DEFAULT_PHP_VERSION, A as ARCHIVER_OPTIONS, d as Logger, S as SupportedPHPVersionsList, P as PLAYGROUND_CLI_MAX_TIMEOUT, e as PLAYGROUND_CLI_INACTIVITY_TIMEOUT, f as PLAYGROUND_CLI_ACTIVITY_CHECK_INTERVAL, h as getServerFilesPath, i as commonjsGlobal, j as getSharedConfigPath, k as getConfigDirectory, l as SHARED_CONFIG_LOCKFILE_NAME, m as DEMO_SITE_EXPIRATION_DAYS, H as HOUR_MS, n as DAY_MS, o as DEMO_SITE_SIZE_LIMIT_BYTES, p as DEMO_SITE_SIZE_LIMIT_GB, M as MINIMUM_WORDPRESS_VERSION, q as DEFAULT_WORDPRESS_VERSION$1, r as emitProgress, s as setProgressCallback, t as getProgressCallback, u as getCliConfigPath } from "./well-known-paths-BYA1Bw5o.mjs";
+import { z } from "zod";
+import { a as arePathsEqual, i as isWordPressDirectory, g as getWordPressVersionPath, r as recursiveCopyDirectory, b as getWordPressVersionUrl, I as IS_JSPI_AVAILABLE, c as cleanupLegacyMuPlugins, d as getMuPlugins, e as getWpCliPharPath, f as getSqliteCommandPath, k as keepSqliteIntegrationUpdated, h as createDeployIgnoreFilter, j as calculateDirectorySizeForArchive, p as pathExists, l as isWordPressBetaVersion, m as isWordPressDevVersion, n as getWpFilesPath, o as getSqlitePluginPath, q as getLanguagePacksPath, s as getAiInstructionsPath, t as getPhpMyAdminPath, u as getSqliteVersionFromInstallation, v as isEmptyDir, w as decodePassword, x as validateAdminUsername, y as validateAdminEmail, z as encodePassword, A as createPassword, B as isValidWordPressVersion, C as isWordPressVersionAtLeast, D as getUnsupportedWpCliPostContentMessage } from "./rewrite-wp-cli-post-content-2zlfFnKT.mjs";
+import { l as lockCliConfig, r as readCliConfig, s as saveCliConfig, u as unlockCliConfig, a as lockFileAsync, b as unlockFileAsync, c as authTokenSchema, h as hideDirectoryOnWindows, S as SNAPSHOT_EVENTS, d as requireSignalExit, e as StatsMetric, f as StatsGroup, g as updateCliConfigWithPartial, i as generateSiteCertificate, j as SITE_EVENTS, k as deleteSiteCertificate, m as updateCheckSchema } from "./certificate-manager-SVYcCL_i.mjs";
 import require$$0$7, { spawn } from "child_process";
 import crypto$1 from "crypto";
 import { EventEmitter } from "events";
 import * as fs from "fs";
 import fs__default, { constants } from "fs";
 import { i as isErrnoException } from "./wordpress-server-ipc-D-8mLjOF.mjs";
-import { z } from "zod";
-import { P as PROCESS_MANAGER_HOME, p as processDescriptionSchema, S as SocketRequestClient, a as PROCESS_MANAGER_EVENTS_SOCKET_PATH, b as PROCESS_MANAGER_CONTROL_SOCKET_PATH, d as daemonResponseSchema, c as SocketMessageDecoder, e as SocketStreamClient, f as daemonEventSchema } from "./process-manager-ipc-heiF195f.mjs";
+import { P as PROCESS_MANAGER_HOME, p as processDescriptionSchema, S as SocketRequestClient, a as PROCESS_MANAGER_EVENTS_SOCKET_PATH, b as PROCESS_MANAGER_CONTROL_SOCKET_PATH, d as daemonResponseSchema, c as SocketMessageDecoder, e as SocketStreamClient, f as daemonEventSchema } from "./process-manager-ipc-BisO0qtU.mjs";
 import fs$1, { readFile as readFile$2, cp } from "fs/promises";
 import os, { tmpdir, platform } from "os";
 import archiver from "archiver";
@@ -102,10 +102,9 @@ import { readFile as readFile$1, writeFile as writeFile$1 } from "atomically";
 import CliTable3 from "cli-table3";
 import { search, confirm, input, select, password } from "@inquirer/prompts";
 import process$2 from "node:process";
-import chalk from "chalk";
+import { styleText, stripVTControlCharacters } from "node:util";
 import * as readline$1 from "node:readline";
 import { AsyncLocalStorage, AsyncResource } from "node:async_hooks";
-import { styleText, stripVTControlCharacters } from "node:util";
 import dns from "dns/promises";
 import { isStepDefinition } from "@wp-playground/blueprints";
 import { domainToASCII } from "node:url";
@@ -123,6 +122,149 @@ function suppressPunycodeWarning() {
     }
   });
 }
+const BackupExtractEvents = {
+  BACKUP_EXTRACT_START: "backup_extract_start",
+  BACKUP_EXTRACT_PROGRESS: "backup_extract_progress",
+  BACKUP_EXTRACT_FILE_START: "backup_extract_file_start",
+  BACKUP_EXTRACT_COMPLETE: "backup_extract_complete",
+  BACKUP_EXTRACT_WARNING: "backup_extract_warning",
+  BACKUP_EXTRACT_ERROR: "backup_extract_error"
+};
+const ValidatorEvents = {
+  IMPORT_VALIDATION_START: "import_validation_start",
+  IMPORT_VALIDATION_COMPLETE: "import_validation_complete",
+  IMPORT_VALIDATION_ERROR: "import_validation_error"
+};
+const ImporterEvents = {
+  IMPORT_START: "import_start",
+  IMPORT_DATABASE_START: "import_database_start",
+  IMPORT_DATABASE_PROGRESS: "import_database_progress",
+  IMPORT_DATABASE_COMPLETE: "import_database_complete",
+  IMPORT_WP_CONTENT_START: "import_wp_content_start",
+  IMPORT_WP_CONTENT_PROGRESS: "import_wp_content_progress",
+  IMPORT_WP_CONTENT_COMPLETE: "import_wp_content_complete",
+  IMPORT_META_START: "import_meta",
+  IMPORT_META_COMPLETE: "import_meta_complete",
+  IMPORT_COMPLETE: "import_complete",
+  IMPORT_ERROR: "import_error"
+};
+const ImportEvents = {
+  ...BackupExtractEvents,
+  ...ValidatorEvents,
+  ...ImporterEvents
+};
+const backupExtractProgressEventDataSchema = z.object({
+  progress: z.number().optional(),
+  processedFiles: z.number().optional(),
+  totalFiles: z.number().optional(),
+  currentFile: z.string().optional(),
+  extractedBytes: z.number().optional(),
+  totalBytes: z.number().optional()
+});
+const importDatabaseProgressEventDataSchema = z.object({
+  currentTable: z.string().optional(),
+  processedTables: z.number().optional(),
+  totalTables: z.number().optional(),
+  currentFile: z.string().optional(),
+  processedFiles: z.number().optional(),
+  totalFiles: z.number().optional()
+});
+const importWpContentProgressEventDataSchema = z.object({
+  type: z.enum(["plugins", "themes", "uploads", "other"]).optional(),
+  currentItem: z.string().optional(),
+  processedItems: z.number().optional(),
+  totalItems: z.number().optional(),
+  processedBytes: z.number().optional(),
+  totalBytes: z.number().optional()
+});
+z.union([
+  z.tuple([
+    z.literal(BackupExtractEvents.BACKUP_EXTRACT_START),
+    backupExtractProgressEventDataSchema.or(z.undefined())
+  ]),
+  z.tuple([
+    z.literal(BackupExtractEvents.BACKUP_EXTRACT_PROGRESS),
+    backupExtractProgressEventDataSchema
+  ]),
+  z.tuple([
+    z.literal(BackupExtractEvents.BACKUP_EXTRACT_FILE_START),
+    backupExtractProgressEventDataSchema
+  ]),
+  z.tuple([
+    z.literal(BackupExtractEvents.BACKUP_EXTRACT_COMPLETE),
+    backupExtractProgressEventDataSchema.or(z.undefined())
+  ]),
+  z.tuple([z.literal(BackupExtractEvents.BACKUP_EXTRACT_WARNING), z.string()]),
+  z.tuple([z.literal(BackupExtractEvents.BACKUP_EXTRACT_ERROR), z.unknown()]),
+  z.tuple([z.literal(ValidatorEvents.IMPORT_VALIDATION_START), z.undefined()]),
+  z.tuple([z.literal(ValidatorEvents.IMPORT_VALIDATION_COMPLETE), z.undefined()]),
+  z.tuple([z.literal(ValidatorEvents.IMPORT_VALIDATION_ERROR), z.unknown()]),
+  z.tuple([z.literal(ImporterEvents.IMPORT_START), z.undefined()]),
+  z.tuple([z.literal(ImporterEvents.IMPORT_DATABASE_START), z.undefined()]),
+  z.tuple([
+    z.literal(ImporterEvents.IMPORT_DATABASE_PROGRESS),
+    importDatabaseProgressEventDataSchema
+  ]),
+  z.tuple([z.literal(ImporterEvents.IMPORT_DATABASE_COMPLETE), z.undefined()]),
+  z.tuple([z.literal(ImporterEvents.IMPORT_WP_CONTENT_START), z.undefined()]),
+  z.tuple([
+    z.literal(ImporterEvents.IMPORT_WP_CONTENT_PROGRESS),
+    importWpContentProgressEventDataSchema
+  ]),
+  z.tuple([z.literal(ImporterEvents.IMPORT_WP_CONTENT_COMPLETE), z.undefined()]),
+  z.tuple([z.literal(ImporterEvents.IMPORT_META_START), z.undefined()]),
+  z.tuple([z.literal(ImporterEvents.IMPORT_META_COMPLETE), z.undefined()]),
+  z.tuple([z.literal(ImporterEvents.IMPORT_COMPLETE), z.undefined()]),
+  z.tuple([z.literal(ImporterEvents.IMPORT_ERROR), z.unknown()])
+]);
+const ExportEvents = {
+  EXPORT_START: "export_start",
+  EXPORT_COMPLETE: "export_complete",
+  EXPORT_ERROR: "export_error",
+  BACKUP_CREATE_START: "backup_create_start",
+  BACKUP_CREATE_PROGRESS: "backup_create_progress",
+  BACKUP_CREATE_COMPLETE: "backup_create_complete",
+  WP_CONTENT_EXPORT_START: "wp_content_export_start",
+  WP_CONTENT_EXPORT_PROGRESS: "wp_content_export_progress",
+  WP_CONTENT_EXPORT_COMPLETE: "wp_content_export_complete",
+  DATABASE_EXPORT_START: "database_export_start",
+  DATABASE_EXPORT_PROGRESS: "database_export_progress",
+  DATABASE_EXPORT_COMPLETE: "database_export_complete",
+  CONFIG_EXPORT_START: "config_export_start",
+  CONFIG_EXPORT_COMPLETE: "config_export_complete"
+};
+const backupCreateProgressEventDataSchema = z.object({
+  // This schema is derived from the `archiver.ProgressData` type
+  progress: z.object({
+    entries: z.object({
+      total: z.number(),
+      processed: z.number()
+    }),
+    fs: z.object({
+      totalBytes: z.number(),
+      processedBytes: z.number()
+    })
+  })
+});
+z.union([
+  z.tuple([z.literal(ExportEvents.EXPORT_START), z.undefined()]),
+  z.tuple([z.literal(ExportEvents.EXPORT_COMPLETE), z.undefined()]),
+  z.tuple([z.literal(ExportEvents.EXPORT_ERROR), z.unknown().nullable()]),
+  z.tuple([z.literal(ExportEvents.BACKUP_CREATE_START), z.undefined()]),
+  z.tuple([
+    z.literal(ExportEvents.BACKUP_CREATE_PROGRESS),
+    backupCreateProgressEventDataSchema
+  ]),
+  z.tuple([z.literal(ExportEvents.BACKUP_CREATE_COMPLETE), z.undefined()]),
+  z.tuple([z.literal(ExportEvents.WP_CONTENT_EXPORT_START), z.undefined()]),
+  z.tuple([z.literal(ExportEvents.WP_CONTENT_EXPORT_PROGRESS), z.undefined()]),
+  z.tuple([z.literal(ExportEvents.WP_CONTENT_EXPORT_COMPLETE), z.undefined()]),
+  z.tuple([z.literal(ExportEvents.DATABASE_EXPORT_START), z.undefined()]),
+  z.tuple([z.literal(ExportEvents.DATABASE_EXPORT_PROGRESS), z.undefined()]),
+  z.tuple([z.literal(ExportEvents.DATABASE_EXPORT_COMPLETE), z.undefined()]),
+  z.tuple([z.literal(ExportEvents.CONFIG_EXPORT_START), z.undefined()]),
+  z.tuple([z.literal(ExportEvents.CONFIG_EXPORT_COMPLETE), z.undefined()])
+]);
 var AuthCommandLoggerAction = /* @__PURE__ */ ((AuthCommandLoggerAction2) => {
   AuthCommandLoggerAction2["LOGIN"] = "login";
   AuthCommandLoggerAction2["LOGOUT"] = "logout";
@@ -272,8 +414,10 @@ const PROXY_PROCESS_NAME = "studio-proxy";
 const CONNECTION_TIMEOUT_MS = 1e4;
 const PROCESS_MANAGER_LOCKFILE_PATH = path__default.join(PROCESS_MANAGER_HOME, "pm-connection.lock");
 const SITE_EVENTS_SOCKET_PATH = process.platform === "win32" ? "\\\\.\\pipe\\studio-events.sock" : path__default.join(PROCESS_MANAGER_HOME, "events.sock");
-if (!fs__default.existsSync(PROCESS_MANAGER_HOME)) {
-  fs__default.mkdirSync(PROCESS_MANAGER_HOME, { recursive: true });
+function ensureProcessManagerHome() {
+  if (!fs__default.existsSync(PROCESS_MANAGER_HOME)) {
+    fs__default.mkdirSync(PROCESS_MANAGER_HOME, { recursive: true });
+  }
 }
 class DaemonBusEventEmitter extends EventEmitter {
   on(event, listener) {
@@ -409,6 +553,7 @@ async function connectToDaemon() {
   if (isConnected) {
     return;
   }
+  ensureProcessManagerHome();
   await lockFileAsync(PROCESS_MANAGER_LOCKFILE_PATH, {
     wait: LOCKFILE_WAIT_TIME,
     stale: LOCKFILE_STALE_TIME
@@ -504,38 +649,6 @@ async function emitCliEvent(payload) {
   } catch {
   }
 }
-const ExportEvents = {
-  EXPORT_START: "export_start",
-  EXPORT_COMPLETE: "export_complete",
-  EXPORT_ERROR: "export_error",
-  BACKUP_CREATE_START: "backup_create_start",
-  BACKUP_CREATE_PROGRESS: "backup_create_progress",
-  BACKUP_CREATE_COMPLETE: "backup_create_complete",
-  WP_CONTENT_EXPORT_START: "wp_content_export_start",
-  WP_CONTENT_EXPORT_PROGRESS: "wp_content_export_progress",
-  WP_CONTENT_EXPORT_COMPLETE: "wp_content_export_complete",
-  DATABASE_EXPORT_START: "database_export_start",
-  DATABASE_EXPORT_PROGRESS: "database_export_progress",
-  DATABASE_EXPORT_COMPLETE: "database_export_complete",
-  CONFIG_EXPORT_START: "config_export_start",
-  CONFIG_EXPORT_COMPLETE: "config_export_complete"
-};
-const handleEvents = (emitter2, onEvent, events) => {
-  const removeListeners = [];
-  Object.values(events).forEach((eventName) => {
-    const listener = (data2) => {
-      onEvent({
-        event: eventName,
-        data: data2
-      });
-    };
-    emitter2.on?.(eventName, listener);
-    removeListeners.push(() => emitter2.off?.(eventName, listener));
-  });
-  return () => {
-    removeListeners.forEach((remove) => remove());
-  };
-};
 function parseJsonFromPhpOutput(output) {
   try {
     return JSON.parse(output);
@@ -1268,6 +1381,17 @@ async function runGlobalWpCliCommand(args) {
     throw new Error(__("An error occurred while running the WP-CLI command."));
   }
 }
+class ImportExportEventEmitter extends EventEmitter {
+  on(eventName, listener) {
+    return super.on(eventName, listener);
+  }
+  off(eventName, listener) {
+    return super.off(eventName, listener);
+  }
+  emit(eventName, ...args) {
+    return super.emit(eventName, ...args);
+  }
+}
 const LATIN = "a-z";
 const CYRILLIC = "а-яё";
 const ARABIC = "\\u0600-\\u06FF";
@@ -3112,7 +3236,7 @@ async function exportDatabaseToMultipleFiles(siteFolder, finalDestinationDir) {
     _promise2 && await _promise2;
   }
 }
-class DefaultExporter extends EventEmitter {
+class DefaultExporter extends ImportExportEventEmitter {
   isExactPathExcluded(pathToCheck) {
     const PATHS_TO_EXCLUDE = [
       "wp-content/mu-plugins/sqlite-database-integration",
@@ -3420,7 +3544,7 @@ class DefaultExporter extends EventEmitter {
     }
   }
 }
-class SqlExporter extends EventEmitter {
+class SqlExporter extends ImportExportEventEmitter {
   constructor(options) {
     super();
     this.options = options;
@@ -3442,26 +3566,14 @@ class SqlExporter extends EventEmitter {
     return this.options.includes.database;
   }
 }
-async function exportBackup(exportOptions, onEvent, exporters = defaultExporterOptions) {
-  let foundValidExporter;
-  for (const Exporter of exporters) {
-    const exporterInstance = new Exporter(exportOptions);
-    const removeExportListeners = handleEvents(exporterInstance, onEvent, ExportEvents);
-    foundValidExporter = await exporterInstance.canHandle();
-    if (foundValidExporter) {
-      try {
-        await exporterInstance.export();
-      } finally {
-        removeExportListeners();
-      }
-      break;
+async function getExporter(exportOptions, exporters = defaultExporterOptions) {
+  for (const Exporter2 of exporters) {
+    const exporterInstance = new Exporter2(exportOptions);
+    if (await exporterInstance.canHandle()) {
+      return exporterInstance;
     }
   }
-  if (!foundValidExporter) {
-    onEvent({ event: ExportEvents.EXPORT_ERROR, data: null });
-    return false;
-  }
-  return true;
+  return null;
 }
 const defaultExporterOptions = [DefaultExporter, SqlExporter];
 function normalizeHostname(hostname) {
@@ -3495,54 +3607,49 @@ function untildify(path2) {
   return process.platform === "win32" ? path2 : path2.replace(/^~/, os$1.homedir());
 }
 const logger$c = new Logger();
-function exportEventHandler({ event, data: data2 }) {
-  switch (event) {
-    case ExportEvents.EXPORT_START:
-      logger$c.reportStart(SiteCommandLoggerAction.EXPORT_SITE, __("Starting export…"));
-      break;
-    case ExportEvents.BACKUP_CREATE_START:
-      logger$c.reportStart(SiteCommandLoggerAction.CREATE_BACKUP, __("Creating backup file…"));
-      break;
-    case ExportEvents.WP_CONTENT_EXPORT_START:
-      logger$c.reportStart(SiteCommandLoggerAction.EXPORT_WP_CONTENT, __("Traversing WordPress content…"));
-      break;
-    case ExportEvents.WP_CONTENT_EXPORT_COMPLETE:
-      logger$c.reportSuccess(__("WordPress content traversed"));
-      break;
-    case ExportEvents.DATABASE_EXPORT_START:
-      logger$c.reportStart(SiteCommandLoggerAction.EXPORT_DATABASE, __("Exporting database…"));
-      break;
-    case ExportEvents.DATABASE_EXPORT_COMPLETE:
-      logger$c.reportSuccess(__("Database exported"));
-      break;
-    case ExportEvents.BACKUP_CREATE_PROGRESS: {
-      const progressData = data2;
-      const processed = progressData?.progress?.entries?.processed;
-      if (processed != null) {
-        logger$c.reportProgress(
-          sprintf(
-            _n("Backing up file… (%d processed)", "Backing up files… (%d processed)", processed),
-            processed
-          )
-        );
-      }
-      break;
-    }
-    case ExportEvents.BACKUP_CREATE_COMPLETE:
-      logger$c.reportSuccess(__("Backup file created"));
-      break;
-    case ExportEvents.CONFIG_EXPORT_START:
-      logger$c.reportStart(SiteCommandLoggerAction.EXPORT_CONFIG, __("Exporting configuration…"));
-      break;
-    case ExportEvents.CONFIG_EXPORT_COMPLETE:
-      logger$c.reportSuccess(__("Configuration exported"));
-      break;
-    case ExportEvents.EXPORT_COMPLETE:
-      logger$c.reportSuccess(__("Site exported successfully"));
-      break;
-    case ExportEvents.EXPORT_ERROR:
-      throw new LoggerError(__("Export failed"), data2 instanceof Error ? data2 : void 0);
-  }
+function handleExportEvents(emitter2) {
+  emitter2.on(ExportEvents.EXPORT_START, () => {
+    logger$c.reportStart(SiteCommandLoggerAction.EXPORT_SITE, __("Starting export…"));
+  });
+  emitter2.on(ExportEvents.BACKUP_CREATE_START, () => {
+    logger$c.reportStart(SiteCommandLoggerAction.CREATE_BACKUP, __("Creating backup file…"));
+  });
+  emitter2.on(ExportEvents.WP_CONTENT_EXPORT_START, () => {
+    logger$c.reportStart(SiteCommandLoggerAction.EXPORT_WP_CONTENT, __("Traversing WordPress content…"));
+  });
+  emitter2.on(ExportEvents.WP_CONTENT_EXPORT_COMPLETE, () => {
+    logger$c.reportSuccess(__("WordPress content traversed"));
+  });
+  emitter2.on(ExportEvents.DATABASE_EXPORT_START, () => {
+    logger$c.reportStart(SiteCommandLoggerAction.EXPORT_DATABASE, __("Exporting database…"));
+  });
+  emitter2.on(ExportEvents.DATABASE_EXPORT_COMPLETE, () => {
+    logger$c.reportSuccess(__("Database exported"));
+  });
+  emitter2.on(ExportEvents.BACKUP_CREATE_PROGRESS, (progressData) => {
+    const processed = progressData.progress.entries.processed;
+    logger$c.reportProgress(
+      sprintf(
+        _n("Backing up file… (%d processed)", "Backing up files… (%d processed)", processed),
+        processed
+      )
+    );
+  });
+  emitter2.on(ExportEvents.BACKUP_CREATE_COMPLETE, () => {
+    logger$c.reportSuccess(__("Backup file created"));
+  });
+  emitter2.on(ExportEvents.CONFIG_EXPORT_START, () => {
+    logger$c.reportStart(SiteCommandLoggerAction.EXPORT_CONFIG, __("Exporting configuration…"));
+  });
+  emitter2.on(ExportEvents.CONFIG_EXPORT_COMPLETE, () => {
+    logger$c.reportSuccess(__("Configuration exported"));
+  });
+  emitter2.on(ExportEvents.EXPORT_COMPLETE, () => {
+    logger$c.reportSuccess(__("Site exported successfully"));
+  });
+  emitter2.on(ExportEvents.EXPORT_ERROR, (error2) => {
+    throw new LoggerError(__("Export failed"), error2 instanceof Error ? error2 : void 0);
+  });
 }
 async function runCommand$e(siteFolder, exportPath, mode) {
   try {
@@ -3562,19 +3669,18 @@ async function runCommand$e(siteFolder, exportPath, mode) {
     if (mode === "db") {
       includes.wpContent = false;
     }
-    const isExported = await exportBackup(
-      {
-        site,
-        backupFile: exportPath,
-        phpVersion: DEFAULT_PHP_VERSION,
-        includes
-      },
-      exportEventHandler
-    );
-    logger$c.reportSuccess(sprintf(__("%s successfully exported"), exportPath));
-    if (!isExported) {
+    const exporter = await getExporter({
+      site,
+      backupFile: exportPath,
+      phpVersion: DEFAULT_PHP_VERSION,
+      includes
+    });
+    if (!exporter) {
       throw new LoggerError(__("No suitable exporter found for the provided backup file"));
     }
+    handleExportEvents(exporter);
+    await exporter.export();
+    logger$c.reportSuccess(sprintf(__("%s successfully exported"), exportPath));
   } finally {
     await disconnectFromDaemon();
   }
@@ -3648,41 +3754,7 @@ const registerCommand$e = (yargs2) => {
     }
   });
 };
-const BackupExtractEvents = {
-  BACKUP_EXTRACT_START: "backup_extract_start",
-  BACKUP_EXTRACT_PROGRESS: "backup_extract_progress",
-  BACKUP_EXTRACT_FILE_START: "backup_extract_file_start",
-  BACKUP_EXTRACT_COMPLETE: "backup_extract_complete",
-  BACKUP_EXTRACT_WARNING: "backup_extract_warning",
-  BACKUP_EXTRACT_ERROR: "backup_extract_error"
-};
-const ValidatorEvents = {
-  IMPORT_VALIDATION_START: "import_validation_start",
-  IMPORT_VALIDATION_COMPLETE: "import_validation_complete",
-  IMPORT_VALIDATION_ERROR: "import_validation_error"
-};
-const ImporterEvents = {
-  IMPORT_START: "import_start",
-  IMPORT_DATABASE_START: "import_database_start",
-  IMPORT_DATABASE_PROGRESS: "import_database_progress",
-  IMPORT_DATABASE_COMPLETE: "import_database_complete",
-  IMPORT_WP_CONTENT_START: "import_wp_content_start",
-  IMPORT_WP_CONTENT_PROGRESS: "import_wp_content_progress",
-  IMPORT_WP_CONTENT_COMPLETE: "import_wp_content_complete",
-  IMPORT_META_START: "import_meta",
-  IMPORT_META_COMPLETE: "import_meta_complete",
-  IMPORT_COMPLETE: "import_complete",
-  IMPORT_ERROR: "import_error"
-};
-const ImportEvents = {
-  ...BackupExtractEvents,
-  ...ValidatorEvents,
-  ...ImporterEvents
-};
-class BackupHandlerSql extends EventEmitter {
-  constructor() {
-    super();
-  }
+class BackupHandlerSql extends ImportExportEventEmitter {
   async listFiles(backup) {
     return [path__default.basename(backup.path)];
   }
@@ -3714,7 +3786,7 @@ class BackupHandlerSql extends EventEmitter {
     });
   }
 }
-class BackupHandlerTarGz extends EventEmitter {
+class BackupHandlerTarGz extends ImportExportEventEmitter {
   async listFiles(backup) {
     const filesSet = /* @__PURE__ */ new Set();
     await tar.t({
@@ -3808,8 +3880,17 @@ async function readHeader(fd) {
     prefix
   };
 }
+function isPathWithinDirectory(filePath, directory) {
+  const resolvedFile = path.resolve(filePath);
+  const resolvedDir = path.resolve(directory);
+  return resolvedFile.startsWith(resolvedDir + path.sep) || resolvedFile === resolvedDir;
+}
 async function readBlockToFile(fd, header, outputPath) {
   const outputFilePath = path.join(outputPath, header.prefix, header.name);
+  if (!isPathWithinDirectory(outputFilePath, outputPath)) {
+    await fd.read(Buffer.alloc(header.size), 0, header.size, null);
+    return;
+  }
   await fse.ensureDir(path.dirname(outputFilePath));
   const outputStream = fs.createWriteStream(outputFilePath);
   let totalBytesToRead = header.size;
@@ -3848,7 +3929,7 @@ async function readBlockToFile(fd, header, outputPath) {
     endStream();
   }
 }
-class BackupHandlerWpress extends EventEmitter {
+class BackupHandlerWpress extends ImportExportEventEmitter {
   constructor() {
     super();
     this.totalFiles = 0;
@@ -3883,7 +3964,10 @@ class BackupHandlerWpress extends EventEmitter {
       do {
         header = await readHeader(inputFile);
         if (header) {
-          fileNames.push(path.join(header.prefix, header.name));
+          const filePath = path.join(header.prefix, header.name);
+          if (!filePath.split(path.sep).includes("..")) {
+            fileNames.push(filePath);
+          }
           await inputFile.read(Buffer.alloc(header.size), 0, header.size, null);
         }
       } while (header);
@@ -3950,7 +4034,7 @@ class BackupHandlerWpress extends EventEmitter {
   }
 }
 const openZip = promisify(yauzl.open);
-class BackupHandlerZip extends EventEmitter {
+class BackupHandlerZip extends ImportExportEventEmitter {
   async listFiles(backup) {
     const zipFile = await openZip(backup.path, { lazyEntries: true });
     const fileNames = [];
@@ -4189,7 +4273,7 @@ const updateSiteUrl = async (site) => {
     _promise2 && await _promise2;
   }
 };
-class BaseImporter extends EventEmitter {
+class BaseImporter extends ImportExportEventEmitter {
   constructor(backup) {
     super();
     this.backup = backup;
@@ -4572,7 +4656,7 @@ class WpressImporter extends BaseBackupImporter {
     await super.importDatabase(site, sqlFiles);
   }
 }
-class JetpackValidator extends EventEmitter {
+class JetpackValidator extends ImportExportEventEmitter {
   canHandle(fileList) {
     const optionalDirs = [
       "sql",
@@ -4589,7 +4673,6 @@ class JetpackValidator extends EventEmitter {
     return hasOptionalDir || hasOptionalFile;
   }
   parseBackupContents(fileList, extractionDirectory) {
-    this.emit(ImportEvents.IMPORT_VALIDATION_START);
     const extractedBackup = {
       extractionDirectory,
       sqlFiles: [],
@@ -4605,7 +4688,7 @@ class JetpackValidator extends EventEmitter {
       }
       if (file.startsWith("sql/") && file.endsWith(".sql")) {
         extractedBackup.sqlFiles.push(fullPath);
-      } else if (file.startsWith("wp-content/")) {
+      } else if (file.startsWith("wp-content/") && !file.startsWith("wp-content/database/")) {
         extractedBackup.wpContentFiles.push(fullPath);
       } else if (file === "studio.json" || file === "meta.json") {
         extractedBackup.metaFile = fullPath;
@@ -4614,11 +4697,10 @@ class JetpackValidator extends EventEmitter {
     extractedBackup.sqlFiles.sort(
       (a, b) => path__default.basename(a).localeCompare(path__default.basename(b))
     );
-    this.emit(ImportEvents.IMPORT_VALIDATION_COMPLETE);
     return extractedBackup;
   }
 }
-class LocalValidator extends EventEmitter {
+class LocalValidator extends ImportExportEventEmitter {
   canHandle(fileList) {
     const requiredDirs = [
       "app/sql",
@@ -4629,7 +4711,6 @@ class LocalValidator extends EventEmitter {
     return requiredDirs.some((dir) => fileList.some((file) => file.startsWith(dir + "/"))) && fileList.some((file) => file.startsWith("app/sql/") && file.endsWith(".sql"));
   }
   parseBackupContents(fileList, extractionDirectory) {
-    this.emit(ImportEvents.IMPORT_VALIDATION_START);
     const extractedBackup = {
       extractionDirectory,
       sqlFiles: [],
@@ -4654,11 +4735,10 @@ class LocalValidator extends EventEmitter {
     extractedBackup.sqlFiles.sort(
       (a, b) => path__default.basename(a).localeCompare(path__default.basename(b))
     );
-    this.emit(ImportEvents.IMPORT_VALIDATION_COMPLETE);
     return extractedBackup;
   }
 }
-class PlaygroundValidator extends EventEmitter {
+class PlaygroundValidator extends ImportExportEventEmitter {
   canHandle(fileList) {
     const requiredDirs = [
       "wp-content/database",
@@ -4666,12 +4746,13 @@ class PlaygroundValidator extends EventEmitter {
       "wp-content/plugins",
       "wp-content/themes"
     ];
-    return requiredDirs.some((dir) => fileList.some((file) => file.startsWith(dir + "/"))) && fileList.some(
+    const hasSqliteDatabase = requiredDirs.some((dir) => fileList.some((file) => file.startsWith(dir + "/"))) && fileList.some(
       (file) => file.startsWith("wp-content/database") && file.endsWith(".ht.sqlite")
     );
+    const hasSqlDumps = fileList.some((file) => file.startsWith("sql/"));
+    return hasSqliteDatabase && !hasSqlDumps;
   }
   parseBackupContents(fileList, extractionDirectory) {
-    this.emit(ImportEvents.IMPORT_VALIDATION_START);
     const extractedBackup = {
       extractionDirectory,
       sqlFiles: [],
@@ -4691,16 +4772,14 @@ class PlaygroundValidator extends EventEmitter {
         extractedBackup.wpContentFiles.push(fullPath);
       }
     }
-    this.emit(ImportEvents.IMPORT_VALIDATION_COMPLETE);
     return extractedBackup;
   }
 }
-class SqlValidator extends EventEmitter {
+class SqlValidator extends ImportExportEventEmitter {
   canHandle(fileList) {
     return fileList.length === 1 && fileList[0].endsWith(".sql");
   }
   parseBackupContents(fileList, extractionDirectory) {
-    this.emit(ImportEvents.IMPORT_VALIDATION_START);
     const extractedBackup = {
       extractionDirectory,
       sqlFiles: [],
@@ -4714,18 +4793,16 @@ class SqlValidator extends EventEmitter {
         extractedBackup.sqlFiles.push(fullPath);
       }
     }
-    this.emit(ImportEvents.IMPORT_VALIDATION_COMPLETE);
     return extractedBackup;
   }
 }
-class WpressValidator extends EventEmitter {
+class WpressValidator extends ImportExportEventEmitter {
   canHandle(fileList) {
     const requiredFiles = ["database.sql", "package.json"];
     const optionalDirs = ["uploads", "plugins", "themes", "fonts"];
     return requiredFiles.every((file) => fileList.includes(file)) && optionalDirs.some((dir) => fileList.some((file) => file.startsWith(dir + path__default.sep)));
   }
   parseBackupContents(fileList, extractionDirectory) {
-    this.emit(ImportEvents.IMPORT_VALIDATION_START);
     const extractedBackup = {
       extractionDirectory,
       sqlFiles: [],
@@ -4746,47 +4823,56 @@ class WpressValidator extends EventEmitter {
     extractedBackup.sqlFiles.sort(
       (a, b) => path__default.basename(a).localeCompare(path__default.basename(b))
     );
-    this.emit(ImportEvents.IMPORT_VALIDATION_COMPLETE);
     return extractedBackup;
   }
 }
-function selectImporter(allFiles, extractionDirectory, onEvent, options) {
+function selectImporter(allFiles, extractionDirectory, options) {
   for (const { validator, importer } of options) {
     if (validator.canHandle(allFiles)) {
-      const removeValidatorListeners = handleEvents(validator, onEvent, ValidatorEvents);
       const files = validator.parseBackupContents(allFiles, extractionDirectory);
-      removeValidatorListeners();
       return new importer(files);
     }
   }
   return null;
 }
-async function importBackup(backupFile, site, onEvent, options) {
-  const backupHandler = BackupHandlerFactory.create(backupFile);
-  if (!backupHandler) {
-    throw new Error(__("No suitable backup handler found for the provided backup file"));
-  }
-  const extractionDirectory = await fs__default.promises.mkdtemp(
-    path__default.join(os.tmpdir(), "studio_backup")
-  );
-  const fileList = await backupHandler.listFiles(backupFile);
-  const importer = selectImporter(fileList, extractionDirectory, onEvent, options);
-  if (!importer) {
-    throw new Error(__("No suitable importer found for the provided backup contents"));
+class BackupImporter extends ImportExportEventEmitter {
+  constructor(backupFile, importerOptions) {
+    super();
+    this.backupFile = backupFile;
+    this.importerOptions = importerOptions;
   }
-  let removeBackupListeners;
-  let removeImportListeners;
-  try {
-    removeBackupListeners = handleEvents(backupHandler, onEvent, BackupExtractEvents);
-    removeImportListeners = handleEvents(importer, onEvent, ImporterEvents);
-    await backupHandler.extractFiles(backupFile, extractionDirectory);
-    return await importer.import(site);
-  } finally {
-    removeBackupListeners?.();
-    removeImportListeners?.();
-    await fs__default.promises.rm(extractionDirectory, { recursive: true });
+  async import(site) {
+    const backupHandler = BackupHandlerFactory.create(this.backupFile);
+    if (!backupHandler) {
+      throw new Error(__("No suitable backup handler found for the provided backup file"));
+    }
+    const extractionDirectory = await fs__default.promises.mkdtemp(
+      path__default.join(os.tmpdir(), "studio_backup")
+    );
+    try {
+      const fileList = await backupHandler.listFiles(this.backupFile);
+      this.emit(ValidatorEvents.IMPORT_VALIDATION_START);
+      const importer = selectImporter(fileList, extractionDirectory, this.importerOptions);
+      if (!importer) {
+        throw new Error(__("No suitable importer found for the provided backup contents"));
+      }
+      this.emit(ValidatorEvents.IMPORT_VALIDATION_COMPLETE);
+      for (const eventName of Object.values(BackupExtractEvents)) {
+        backupHandler.on(eventName, (data2) => this.emit(eventName, data2));
+      }
+      for (const eventName of Object.values(ImporterEvents)) {
+        importer.on(eventName, (data2) => this.emit(eventName, data2));
+      }
+      await backupHandler.extractFiles(this.backupFile, extractionDirectory);
+      return await importer.import(site);
+    } finally {
+      await fs__default.promises.rm(extractionDirectory, { recursive: true });
+    }
   }
 }
+function getImporter(backupFile, options) {
+  return new BackupImporter(backupFile, options);
+}
 const DEFAULT_IMPORTER_OPTIONS = [
   { validator: new PlaygroundValidator(), importer: PlaygroundImporter },
   { validator: new JetpackValidator(), importer: JetpackImporter },
@@ -5106,113 +5192,106 @@ async function setupWordPressFilesOnly(sitePath) {
   }
   await recursiveCopyDirectory(bundledWpPath, sitePath);
 }
-function importEventHandler({ event, data: data2 }) {
-  switch (event) {
-    case ValidatorEvents.IMPORT_VALIDATION_START:
-      logger$b.reportSuccess(sprintf(__("Started import…")));
-      logger$b.reportStart(SiteCommandLoggerAction.VALIDATE, __("Validating backup…"));
-      break;
-    case ValidatorEvents.IMPORT_VALIDATION_COMPLETE:
-      logger$b.reportSuccess(__("Backup validated"));
-      break;
-    case ValidatorEvents.IMPORT_VALIDATION_ERROR:
-      throw new LoggerError(
-        __("Backup validation failed"),
-        data2 instanceof Error ? data2 : void 0
-      );
-    case BackupExtractEvents.BACKUP_EXTRACT_START:
-      logger$b.reportStart(SiteCommandLoggerAction.EXTRACT_BACKUP, __("Extracting backup files…"));
-      break;
-    case BackupExtractEvents.BACKUP_EXTRACT_PROGRESS: {
-      const progressData = data2;
-      if (progressData.processedFiles != null && progressData.totalFiles != null && progressData.totalFiles > 0) {
-        logger$b.reportProgress(
-          sprintf(
-            _n(
-              "Extracting backup file… (%1$d/%2$d)",
-              "Extracting backup files… (%1$d/%2$d)",
-              progressData.totalFiles
-            ),
-            progressData.processedFiles,
+function handleImportEvents(emitter2) {
+  emitter2.on(ValidatorEvents.IMPORT_VALIDATION_START, () => {
+    logger$b.reportSuccess(sprintf(__("Started import…")));
+    logger$b.reportStart(SiteCommandLoggerAction.VALIDATE, __("Validating backup…"));
+  });
+  emitter2.on(ValidatorEvents.IMPORT_VALIDATION_COMPLETE, () => {
+    logger$b.reportSuccess(__("Backup validated"));
+  });
+  emitter2.on(ValidatorEvents.IMPORT_VALIDATION_ERROR, (error2) => {
+    throw new LoggerError(
+      __("Backup validation failed"),
+      error2 instanceof Error ? error2 : void 0
+    );
+  });
+  emitter2.on(BackupExtractEvents.BACKUP_EXTRACT_START, () => {
+    logger$b.reportStart(SiteCommandLoggerAction.EXTRACT_BACKUP, __("Extracting backup files…"));
+  });
+  emitter2.on(BackupExtractEvents.BACKUP_EXTRACT_PROGRESS, (progressData) => {
+    if (progressData.processedFiles !== void 0 && progressData.totalFiles !== void 0 && progressData.totalFiles > 0) {
+      logger$b.reportProgress(
+        sprintf(
+          _n(
+            "Extracting backup file… (%1$d/%2$d)",
+            "Extracting backup files… (%1$d/%2$d)",
             progressData.totalFiles
-          )
-        );
-      }
-      break;
-    }
-    case BackupExtractEvents.BACKUP_EXTRACT_COMPLETE:
-      logger$b.reportSuccess(__("Backup extraction completed"));
-      break;
-    case BackupExtractEvents.BACKUP_EXTRACT_WARNING:
-      logger$b.reportWarning(
-        typeof data2 === "string" ? data2 : __("A warning occurred while extracting backup")
-      );
-      break;
-    case BackupExtractEvents.BACKUP_EXTRACT_ERROR:
-      throw new LoggerError(
-        __("Failed to extract backup"),
-        data2 instanceof Error ? data2 : void 0
+          ),
+          progressData.processedFiles,
+          progressData.totalFiles
+        )
       );
-    case ImporterEvents.IMPORT_START:
-      logger$b.reportStart(SiteCommandLoggerAction.IMPORT_SITE, __("Importing backup…"));
-      break;
-    case ImporterEvents.IMPORT_DATABASE_START:
-      logger$b.reportStart(SiteCommandLoggerAction.IMPORT_DATABASE, __("Importing database…"));
-      break;
-    case ImporterEvents.IMPORT_DATABASE_PROGRESS: {
-      const progressData = data2;
-      if (progressData.processedFiles != null && progressData.totalFiles != null && progressData.totalFiles > 0) {
-        logger$b.reportProgress(
-          sprintf(
-            _n(
-              "Importing database file… (%1$d/%2$d)",
-              "Importing database files… (%1$d/%2$d)",
-              progressData.totalFiles
-            ),
-            progressData.processedFiles,
+    }
+  });
+  emitter2.on(BackupExtractEvents.BACKUP_EXTRACT_COMPLETE, () => {
+    logger$b.reportSuccess(__("Backup extraction completed"));
+  });
+  emitter2.on(BackupExtractEvents.BACKUP_EXTRACT_WARNING, (warningMessage) => {
+    logger$b.reportWarning(warningMessage || __("A warning occurred while extracting backup"));
+  });
+  emitter2.on(BackupExtractEvents.BACKUP_EXTRACT_ERROR, (error2) => {
+    throw new LoggerError(
+      __("Failed to extract backup"),
+      error2 instanceof Error ? error2 : void 0
+    );
+  });
+  emitter2.on(ImporterEvents.IMPORT_START, () => {
+    logger$b.reportStart(SiteCommandLoggerAction.IMPORT_SITE, __("Importing backup…"));
+  });
+  emitter2.on(ImporterEvents.IMPORT_DATABASE_START, () => {
+    logger$b.reportStart(SiteCommandLoggerAction.IMPORT_DATABASE, __("Importing database…"));
+  });
+  emitter2.on(ImporterEvents.IMPORT_DATABASE_PROGRESS, (progressData) => {
+    if (progressData.processedFiles !== void 0 && progressData.totalFiles !== void 0 && progressData.totalFiles > 0) {
+      logger$b.reportProgress(
+        sprintf(
+          _n(
+            "Importing database file… (%1$d/%2$d)",
+            "Importing database files… (%1$d/%2$d)",
             progressData.totalFiles
-          )
-        );
-      }
-      break;
+          ),
+          progressData.processedFiles,
+          progressData.totalFiles
+        )
+      );
     }
-    case ImporterEvents.IMPORT_DATABASE_COMPLETE:
-      logger$b.reportSuccess(__("Database import completed"));
-      break;
-    case ImporterEvents.IMPORT_WP_CONTENT_START:
-      logger$b.reportStart(SiteCommandLoggerAction.IMPORT_WP_CONTENT, __("Importing WordPress content…"));
-      break;
-    case ImporterEvents.IMPORT_WP_CONTENT_PROGRESS: {
-      const progressData = data2;
-      if (progressData.processedItems != null && progressData.totalItems != null && progressData.totalItems > 0) {
-        const baseMessage = WP_CONTENT_TYPE_LABELS[progressData.type || "other"] || __("Importing WordPress content…");
-        logger$b.reportProgress(
-          sprintf(
-            /* translators: %1$s is a content type label, %2$d is processed items, %3$d is total items */
-            __("%1$s (%2$d/%3$d)"),
-            baseMessage,
-            progressData.processedItems,
-            progressData.totalItems
-          )
-        );
-      }
-      break;
+  });
+  emitter2.on(ImporterEvents.IMPORT_DATABASE_COMPLETE, () => {
+    logger$b.reportSuccess(__("Database import completed"));
+  });
+  emitter2.on(ImporterEvents.IMPORT_WP_CONTENT_START, () => {
+    logger$b.reportStart(SiteCommandLoggerAction.IMPORT_WP_CONTENT, __("Importing WordPress content…"));
+  });
+  emitter2.on(ImporterEvents.IMPORT_WP_CONTENT_PROGRESS, (progressData) => {
+    if (progressData.processedItems !== void 0 && progressData.totalItems !== void 0 && progressData.totalItems > 0) {
+      const baseMessage = WP_CONTENT_TYPE_LABELS[progressData.type || "other"] || __("Importing WordPress content…");
+      logger$b.reportProgress(
+        sprintf(
+          /* translators: %1$s is a content type label, %2$d is processed items, %3$d is total items */
+          __("%1$s (%2$d/%3$d)"),
+          baseMessage,
+          progressData.processedItems,
+          progressData.totalItems
+        )
+      );
     }
-    case ImporterEvents.IMPORT_WP_CONTENT_COMPLETE:
-      logger$b.reportSuccess(__("WordPress content import completed"));
-      break;
-    case ImporterEvents.IMPORT_META_START:
-      logger$b.reportStart(SiteCommandLoggerAction.IMPORT_META, __("Importing metadata…"));
-      break;
-    case ImporterEvents.IMPORT_META_COMPLETE:
-      logger$b.reportSuccess(__("Metadata import completed"));
-      break;
-    case ImporterEvents.IMPORT_COMPLETE:
-      logger$b.reportSuccess(__("Site imported successfully"));
-      break;
-    case ImporterEvents.IMPORT_ERROR:
-      throw new LoggerError(__("Import failed"), data2 instanceof Error ? data2 : void 0);
-  }
+  });
+  emitter2.on(ImporterEvents.IMPORT_WP_CONTENT_COMPLETE, () => {
+    logger$b.reportSuccess(__("WordPress content import completed"));
+  });
+  emitter2.on(ImporterEvents.IMPORT_META_START, () => {
+    logger$b.reportStart(SiteCommandLoggerAction.IMPORT_META, __("Importing metadata…"));
+  });
+  emitter2.on(ImporterEvents.IMPORT_META_COMPLETE, () => {
+    logger$b.reportSuccess(__("Metadata import completed"));
+  });
+  emitter2.on(ImporterEvents.IMPORT_COMPLETE, () => {
+    logger$b.reportSuccess(__("Site imported successfully"));
+  });
+  emitter2.on(ImporterEvents.IMPORT_ERROR, (error2) => {
+    throw new LoggerError(__("Import failed"), error2 instanceof Error ? error2 : void 0);
+  });
 }
 async function runCommand$d(siteFolder, importFile) {
   let site;
@@ -5242,12 +5321,12 @@ async function runCommand$d(siteFolder, importFile) {
       logger$b.reportSuccess(__("WordPress files copied"));
     }
     logger$b.reportStart(SiteCommandLoggerAction.IMPORT_SITE, __("Starting import…"));
-    await importBackup(
+    const importer = getImporter(
       { path: importFile, type: getBackupFileType(importFile) },
-      site,
-      importEventHandler,
       DEFAULT_IMPORTER_OPTIONS
     );
+    handleImportEvents(importer);
+    await importer.import(site);
     const siteUrl = getSiteUrl(site);
     await fetch(siteUrl).catch(() => {
     });
@@ -28634,6 +28713,63 @@ function createPrompt(view) {
   };
   return prompt;
 }
+function supportsTrueColor() {
+  if (process.env.NO_COLOR) {
+    return false;
+  }
+  const force = process.env.FORCE_COLOR;
+  if (force === "3" || force === "true") {
+    return true;
+  }
+  if (force !== void 0) {
+    return false;
+  }
+  return (process.stdout.getColorDepth?.() ?? 1) >= 24;
+}
+function hexToRgb(hex) {
+  const h = hex.replace(/^#/, "");
+  return [
+    parseInt(h.slice(0, 2), 16),
+    parseInt(h.slice(2, 4), 16),
+    parseInt(h.slice(4, 6), 16)
+  ];
+}
+function wrapHex(hex, bg, text2) {
+  if (!supportsTrueColor()) {
+    return text2;
+  }
+  const [r, g, b] = hexToRgb(hex);
+  const open = bg ? 48 : 38;
+  const close = bg ? 49 : 39;
+  return `\x1B[${open};2;${r};${g};${b}m${text2}\x1B[${close}m`;
+}
+function createChalk(formats2, hexFg, hexBg) {
+  const fn = ((text2) => {
+    let out = formats2.length > 0 ? styleText(formats2, text2) : text2;
+    if (hexFg) {
+      out = wrapHex(hexFg, false, out);
+    }
+    if (hexBg) {
+      out = wrapHex(hexBg, true, out);
+    }
+    return out;
+  });
+  return new Proxy(fn, {
+    get(target, prop) {
+      if (typeof prop !== "string") {
+        return Reflect.get(target, prop);
+      }
+      if (prop === "hex") {
+        return (color) => createChalk(formats2, color, hexBg);
+      }
+      if (prop === "bgHex") {
+        return (color) => createChalk(formats2, hexFg, color);
+      }
+      return createChalk([...formats2, prop], hexFg, hexBg);
+    }
+  });
+}
+const chalk = createChalk([]);
 function flattenTree(nodes, path2 = []) {
   const result = [];
   for (let i = 0; i < nodes.length; i++) {
@@ -29287,12 +29423,12 @@ async function runCommand$8(siteFolder, syncOptions, siteIdentifier) {
         await clearSiteLatestCliPid(site.id);
         logger$9.reportSuccess(__("WordPress server stopped"));
       }
-      await importBackup(
+      const importer = getImporter(
         { path: destPath, type: "application/gzip" },
-        site,
-        importEventHandler,
         DEFAULT_IMPORTER_OPTIONS
       );
+      handleImportEvents(importer);
+      await importer.import(site);
       const siteUrl = getSiteUrl(site);
       await fetch(siteUrl).catch(() => {
       });
@@ -33933,20 +34069,19 @@ async function runCommand$7(siteFolder, syncOptions, remoteSiteIdentifier) {
         wpContent: optionsToSync.includes("uploads") || optionsToSync.includes("plugins") || optionsToSync.includes("themes") || optionsToSync.includes("contents")
       };
     }
-    const isExported = await exportBackup(
-      {
-        site,
-        backupFile: archivePath,
-        includes,
-        phpVersion: DEFAULT_PHP_VERSION,
-        splitDatabaseDumpByTable: true,
-        specificSelectionPaths
-      },
-      exportEventHandler
-    );
-    if (!isExported) {
+    const exporter = await getExporter({
+      site,
+      backupFile: archivePath,
+      includes,
+      phpVersion: DEFAULT_PHP_VERSION,
+      splitDatabaseDumpByTable: true,
+      specificSelectionPaths
+    });
+    if (!exporter) {
       throw new LoggerError(__("No suitable exporter found for the provided backup file"));
     }
+    handleExportEvents(exporter);
+    await exporter.export();
     const archiveSize = fs__default.statSync(archivePath).size;
     if (archiveSize > SYNC_PUSH_SIZE_LIMIT_BYTES) {
       throw new LoggerError(
@@ -76031,6 +76166,13 @@ async function resolveSite(nameOrPath) {
   if (siteByName) {
     return siteByName;
   }
+  if (!path__default.isAbsolute(nameOrPath)) {
+    const config = await readCliConfig();
+    const siteByFolder = config.sites.find((site) => path__default.basename(site.path) === nameOrPath);
+    if (siteByFolder) {
+      return siteByFolder;
+    }
+  }
   return getSiteByFolder(nameOrPath);
 }
 function errorResult(message2) {
@@ -76903,7 +77045,7 @@ function formatUpdateBanner(currentVersion, latestVersion) {
   });
   return ["", top, ...paddedLines, bottom, ""].join("\n");
 }
-const version = "1.7.9";
+const version = "1.7.10-beta1";
 suppressPunycodeWarning();
 async function main() {
   await setupUpdateNotifier(version);
@@ -76934,8 +77076,10 @@ async function main() {
     }
   }).middleware(async () => {
     const { runMigrations } = await import("./migration-B2m6ZEJz.mjs");
-    const { migrations } = await import("./index-CyYXE85k.mjs");
+    const { migrations } = await import("./index-4lan3TI_.mjs");
     await runMigrations(migrations);
+    const { prunePmLogs } = await import("./prune-pm-logs-COryxqeo.mjs");
+    await prunePmLogs();
   }).middleware(async (argv) => {
     if (!argv.avoidTelemetry) {
       const platformMetric = getPlatformMetric();
@@ -76966,9 +77110,9 @@ async function main() {
       { registerCommand: registerAuthLogoutCommand },
       { registerCommand: registerAuthStatusCommand }
     ] = await Promise.all([
-      import("./login-OvZJPTV5.mjs"),
-      import("./logout-BaG-QFSN.mjs"),
-      import("./status-CgY39wpU.mjs")
+      import("./login-IwZhKWzT.mjs"),
+      import("./logout-BJ7AzNzE.mjs"),
+      import("./status-CPcjT8jc.mjs")
     ]);
     registerAuthLoginCommand(authYargs);
     registerAuthLogoutCommand(authYargs);
@@ -76976,7 +77120,7 @@ async function main() {
     authYargs.version(false).demandCommand(1, __("You must provide a valid auth command"));
   });
   const studioCodeCommandBuilder = async (aiYargs) => {
-    const { registerCommand: registerAiCommand } = await import("./index-DBCpWm8k.mjs").then((n) => n.i);
+    const { registerCommand: registerAiCommand } = await import("./index-B-JMTSj2.mjs").then((n) => n.i);
     registerAiCommand(aiYargs);
     aiYargs.command("sessions", __("Manage code sessions"), async (sessionsYargs) => {
       const [
@@ -76984,9 +77128,9 @@ async function main() {
         { registerCommand: registerAiSessionsListCommand },
         { registerCommand: registerAiSessionsResumeCommand }
       ] = await Promise.all([
-        import("./delete-D1lAYFtg.mjs"),
-        import("./list-COLca0rr.mjs"),
-        import("./resume-DshNzC7q.mjs")
+        import("./delete-Br0zEYcv.mjs"),
+        import("./list-CqctqyGC.mjs"),
+        import("./resume-CNesCmkg.mjs")
       ]);
       sessionsYargs.option("path", {
         hidden: true
@@ -77023,7 +77167,7 @@ async function main() {
       Promise.resolve().then(() => list$2),
       Promise.resolve().then(() => _delete$1),
       Promise.resolve().then(() => update),
-      import("./set-DY9OcXFg.mjs")
+      import("./set-C4J6ru7I.mjs")
     ]);
     registerPreviewCreateCommand(previewYargs);
     registerPreviewListCommand(previewYargs);
@@ -77050,7 +77194,7 @@ async function main() {
       Promise.resolve().then(() => start),
       Promise.resolve().then(() => stop),
       Promise.resolve().then(() => _delete),
-      import("./set-BX9MWFxi.mjs")
+      import("./set-T8A1lBPU.mjs")
     ]);
     registerSiteStatusCommand(sitesYargs);
     registerSiteCreateCommand(sitesYargs);
@@ -77072,7 +77216,7 @@ async function main() {
       });
     },
     handler: async (argv) => {
-      const { commandHandler: wpCliCommandHandler } = await import("./wp-DeUSBbLc.mjs");
+      const { commandHandler: wpCliCommandHandler } = await import("./wp-A9VDe8QE.mjs");
       return wpCliCommandHandler(argv);
     }
   }).command({
@@ -77080,7 +77224,7 @@ async function main() {
     describe: false,
     // Hidden command
     handler: async () => {
-      const { commandHandler: eventsCommandHandler } = await import("./_events-ByiJRMQ1.mjs");
+      const { commandHandler: eventsCommandHandler } = await import("./_events-MbsmeZ64.mjs");
       return eventsCommandHandler();
     }
   }).demandCommand(1, __("You must provide a valid command")).strict();
@@ -77089,21 +77233,22 @@ async function main() {
 void main();
 export {
   AuthCommandLoggerAction as A,
-  isServerRunning as B,
-  stopWordPressServer as C,
-  validatePhpVersion as D,
-  runWpCliCommand as E,
-  setupCustomDomain as F,
-  startWordPressServer as G,
-  updateSiteLatestCliPid as H,
-  disconnectFromDaemon as I,
-  runGlobalWpCliCommand as J,
-  sendWpCliCommand as K,
-  SITE_EVENTS_SOCKET_PATH as L,
-  getDaemonBus as M,
-  SITE_PROCESS_PREFIX as N,
-  removeSiteFromConfig as O,
+  connectToDaemon as B,
+  isServerRunning as C,
+  stopWordPressServer as D,
+  validatePhpVersion as E,
+  runWpCliCommand as F,
+  setupCustomDomain as G,
+  startWordPressServer as H,
+  updateSiteLatestCliPid as I,
+  disconnectFromDaemon as J,
+  runGlobalWpCliCommand as K,
+  sendWpCliCommand as L,
+  SITE_EVENTS_SOCKET_PATH as M,
+  getDaemonBus as N,
+  SITE_PROCESS_PREFIX as O,
   PreviewCommandLoggerAction as P,
+  removeSiteFromConfig as Q,
   STUDIO_SITES_ROOT as S,
   ValidationError2 as V,
   createStudioTools as a,
@@ -77113,23 +77258,23 @@ export {
   runCommand$9 as e,
   runCommand$c as f,
   getUserInfo as g,
-  getSitesRunningStatus as h,
+  chalk as h,
   isSnapshotExpired as i,
-  getWpComSites as j,
-  isSiteRunning as k,
-  getSiteUrl as l,
-  closeSharedBrowser as m,
-  getAppLocale as n,
+  getSitesRunningStatus as j,
+  getWpComSites as k,
+  isSiteRunning as l,
+  getSiteUrl as m,
+  closeSharedBrowser as n,
   openBrowser as o,
-  emitCliEvent as p,
-  revokeAuthToken as q,
+  getAppLocale as p,
+  emitCliEvent as q,
   readAuthToken as r,
-  normalizeHostname as s,
-  setSnapshotInConfig as t,
+  revokeAuthToken as s,
+  normalizeHostname as t,
   updateSharedConfig as u,
-  SiteCommandLoggerAction as v,
-  getSiteByFolder as w,
-  getDomainNameValidationError as x,
-  updateDomainInHosts as y,
-  connectToDaemon as z
+  setSnapshotInConfig as v,
+  SiteCommandLoggerAction as w,
+  getSiteByFolder as x,
+  getDomainNameValidationError as y,
+  updateDomainInHosts as z
 };