@blinkk/root-cms 2.4.4 → 2.4.7

package/dist/cli.js

@@ -2,23 +2,363 @@
 import { Command } from "commander";
 import { bgGreen, black } from "kleur/colors";
 
-// cli/generate-types.ts
-import { promises as fs } from "fs";
+// cli/export.ts
+import fs from "fs";
 import path from "path";
+import { loadRootConfig } from "@blinkk/root/node";
+
+// core/client.ts
+import crypto from "crypto";
+import {
+  FieldValue as FieldValue2,
+  Timestamp as Timestamp2
+} from "firebase-admin/firestore";
+
+// core/translations-manager.ts
+import {
+  FieldValue,
+  Timestamp
+} from "firebase-admin/firestore";
+
+// shared/strings.ts
+import fnv from "fnv-plus";
+
+// core/translations-manager.ts
+var TRANSLATIONS_DB_PATH_FORMAT = "/Projects/{project}/TranslationsManager/{mode}/Translations";
+var TRANSLATIONS_LOCALE_DOC_DB_PATH_FORMAT = `${TRANSLATIONS_DB_PATH_FORMAT}/{id}:{locale}`;
+
+// core/client.ts
+function getCmsPlugin(rootConfig) {
+  const plugins = rootConfig.plugins || [];
+  const plugin = plugins.find((plugin2) => plugin2.name === "root-cms");
+  if (!plugin) {
+    throw new Error("could not find root-cms plugin config in root.config.ts");
+  }
+  return plugin;
+}
+
+// cli/utils.ts
+function parseFilters(filterStr) {
+  if (!filterStr) {
+    return { includes: [], excludes: [] };
+  }
+  const parts = filterStr.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+  const includes = parts.filter((p) => !p.startsWith("!"));
+  const excludes = parts.filter((p) => p.startsWith("!")).map((p) => p.slice(1));
+  return { includes, excludes };
+}
+function getPathStatus(path4, includes, excludes) {
+  for (const pattern of excludes) {
+    if (globMatch(path4, pattern)) {
+      return "EXCLUDE";
+    }
+  }
+  if (includes.length === 0) {
+    return "INCLUDE";
+  }
+  let isIncluded = false;
+  let shouldTraverse = false;
+  for (const pattern of includes) {
+    const match = checkMatch(path4, pattern);
+    if (match === "FULL") {
+      isIncluded = true;
+    } else if (match === "PARTIAL") {
+      shouldTraverse = true;
+    }
+  }
+  if (isIncluded) {
+    return "INCLUDE";
+  }
+  if (shouldTraverse) {
+    return "TRAVERSE";
+  }
+  return "SKIP";
+}
+function globMatch(path4, pattern) {
+  return checkMatch(path4, pattern) === "FULL";
+}
+function checkMatch(path4, pattern) {
+  const pathParts = path4.split("/");
+  const patternParts = pattern.split("/");
+  if (matchSegments(pathParts, patternParts)) {
+    return "FULL";
+  }
+  if (pathParts.length < patternParts.length) {
+    const patternPrefix = patternParts.slice(0, pathParts.length);
+    if (matchSegments(pathParts, patternPrefix)) {
+      return "PARTIAL";
+    }
+  }
+  return "NONE";
+}
+function matchSegments(pathParts, patternParts) {
+  if (patternParts[patternParts.length - 1] === "**") {
+    const basePattern = patternParts.slice(0, -1);
+    if (pathParts.length < basePattern.length) {
+      return false;
+    }
+    return matchSegments(pathParts.slice(0, basePattern.length), basePattern);
+  }
+  if (pathParts.length !== patternParts.length) {
+    return false;
+  }
+  for (let i = 0; i < pathParts.length; i++) {
+    const pathPart = pathParts[i];
+    const patternPart = patternParts[i];
+    if (patternPart === "*") {
+      continue;
+    }
+    if (pathPart !== patternPart) {
+      return false;
+    }
+  }
+  return true;
+}
+function pLimit(concurrency) {
+  const queue = [];
+  let activeCount = 0;
+  const next = () => {
+    activeCount--;
+    if (queue.length > 0) {
+      const job = queue.shift();
+      if (job) job();
+    }
+  };
+  return async (fn) => {
+    if (activeCount >= concurrency) {
+      await new Promise((resolve) => {
+        queue.push(resolve);
+      });
+    }
+    activeCount++;
+    try {
+      return await fn();
+    } finally {
+      next();
+    }
+  };
+}
+
+// cli/export.ts
+async function exportData(options) {
+  const rootDir = process.cwd();
+  const rootConfig = await loadRootConfig(rootDir, { command: "root-cms" });
+  const cmsPlugin = getCmsPlugin(rootConfig);
+  const cmsPluginOptions = cmsPlugin.getConfig();
+  const siteId = options.site || cmsPluginOptions.id || "default";
+  const databaseId = options.database || "(default)";
+  const db = cmsPlugin.getFirestore({ databaseId });
+  const projectPath = `Projects/${siteId}`;
+  const projectRef = db.doc(projectPath);
+  const collections = await projectRef.listCollections();
+  const allCollectionIds = collections.map((c) => c.id);
+  const { includes, excludes } = parseFilters(options.filter);
+  const collectionsToExport = allCollectionIds.filter((id) => {
+    const status = getPathStatus(id, includes, excludes);
+    return status !== "SKIP" && status !== "EXCLUDE";
+  });
+  const now = /* @__PURE__ */ new Date();
+  const timestamp = formatTimestamp(now);
+  const gcpProjectId = options.project || cmsPluginOptions.firebaseConfig?.projectId || "default";
+  const exportDir = `export_${gcpProjectId}_${databaseId}_${siteId}_${timestamp}`.replace(/\(/g, "").replace(/\)/g, "");
+  console.log("");
+  console.table({
+    Directory: exportDir,
+    "GCP Project": gcpProjectId,
+    Database: `${databaseId}/Projects/${siteId}`,
+    Site: siteId,
+    Collections: collectionsToExport.join(", "),
+    Filter: options.filter || "(none)"
+  });
+  console.log("");
+  if (!fs.existsSync(exportDir)) {
+    fs.mkdirSync(exportDir, { recursive: true });
+  }
+  if (!options.filter) {
+    const projectDoc = await projectRef.get();
+    if (projectDoc.exists) {
+      const projectData = projectDoc.data();
+      const projectFilePath = path.join(exportDir, "__data.json");
+      fs.writeFileSync(
+        projectFilePath,
+        JSON.stringify(convertForExport(projectData), null, 2)
+      );
+      console.log("Exported project document to __data.json");
+    }
+  }
+  const limit = pLimit(10);
+  for (const collectionType of collectionsToExport) {
+    console.log(`Exporting ${collectionType}...`);
+    const collectionPath = `Projects/${siteId}/${collectionType}`;
+    const collectionDir = path.join(exportDir, collectionType);
+    await exportCollection(
+      db,
+      collectionPath,
+      collectionDir,
+      collectionType,
+      collectionType,
+      includes,
+      excludes,
+      limit
+    );
+  }
+  console.log(`
+\u2705 Export complete! Data saved to: ${exportDir}`);
+}
+var Spinner = class {
+  constructor(text) {
+    this.timer = null;
+    this.frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+    this.currentFrame = 0;
+    this.text = text;
+  }
+  start() {
+    this.render();
+    this.timer = setInterval(() => {
+      this.currentFrame = (this.currentFrame + 1) % this.frames.length;
+      this.render();
+    }, 80);
+  }
+  update(text) {
+    this.text = text;
+    this.render();
+  }
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    process.stdout.write("\r\x1B[K");
+  }
+  render() {
+    process.stdout.write(`\r${this.frames[this.currentFrame]} ${this.text}`);
+  }
+};
+async function exportCollection(db, collectionPath, outputDir, displayName, relativePath, includes, excludes, limit) {
+  const stats = { count: 0 };
+  const spinner = new Spinner(`Exporting ${displayName}...`);
+  spinner.start();
+  await exportCollectionRecursive(
+    db,
+    collectionPath,
+    outputDir,
+    stats,
+    spinner,
+    relativePath,
+    includes,
+    excludes,
+    limit
+  );
+  spinner.stop();
+  console.log(`  - ${displayName}: ${stats.count} documents`);
+}
+async function exportCollectionRecursive(db, collectionPath, outputDir, stats, spinner, relativePath, includes, excludes, limit) {
+  if (!fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true });
+  }
+  const collection = db.collection(collectionPath);
+  const refs = await limit(() => collection.listDocuments());
+  if (refs.length === 0) {
+    return;
+  }
+  const snapshot = await limit(() => collection.get());
+  const docMap = /* @__PURE__ */ new Map();
+  snapshot.docs.forEach((doc) => {
+    docMap.set(doc.id, doc);
+  });
+  await Promise.all(
+    refs.map(async (ref) => {
+      const doc = docMap.get(ref.id);
+      const subcollections = await limit(() => ref.listCollections());
+      const hasSubcollections = subcollections.length > 0;
+      const docRelativePath = `${relativePath}/${ref.id}`;
+      const docStatus = getPathStatus(docRelativePath, includes, excludes);
+      if (doc && docStatus !== "SKIP" && docStatus !== "EXCLUDE") {
+        const docData = doc.data();
+        let filePath;
+        if (hasSubcollections) {
+          const docDir = path.join(outputDir, doc.id);
+          if (!fs.existsSync(docDir)) {
+            fs.mkdirSync(docDir, { recursive: true });
+          }
+          filePath = path.join(docDir, "__data.json");
+        } else {
+          filePath = path.join(outputDir, `${doc.id}.json`);
+        }
+        fs.writeFileSync(
+          filePath,
+          JSON.stringify(convertForExport(docData), null, 2)
+        );
+        stats.count++;
+        spinner.update(`Exporting ${stats.count} documents...`);
+      }
+      for (const subcollection of subcollections) {
+        const subRelativePath = `${docRelativePath}/${subcollection.id}`;
+        const status = getPathStatus(subRelativePath, includes, excludes);
+        if (status === "SKIP" || status === "EXCLUDE") {
+          continue;
+        }
+        const subcollectionDir = path.join(outputDir, ref.id, subcollection.id);
+        await exportCollectionRecursive(
+          db,
+          subcollection.path,
+          subcollectionDir,
+          stats,
+          spinner,
+          subRelativePath,
+          includes,
+          excludes,
+          limit
+        );
+      }
+    })
+  );
+}
+function formatTimestamp(date) {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  const hour = String(date.getHours()).padStart(2, "0");
+  const minute = String(date.getMinutes()).padStart(2, "0");
+  return `${year}${month}${day}t${hour}${minute}`;
+}
+function convertForExport(obj) {
+  if (obj === null || obj === void 0) {
+    return obj;
+  }
+  if (typeof obj === "object" && typeof obj.path === "string" && obj.constructor.name === "DocumentReference") {
+    return { _referencePath: obj.path };
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => convertForExport(item));
+  }
+  if (typeof obj === "object") {
+    const converted = {};
+    for (const [key, value] of Object.entries(obj)) {
+      converted[key] = convertForExport(value);
+    }
+    return converted;
+  }
+  return obj;
+}
+
+// cli/generate-types.ts
+import { promises as fs2 } from "fs";
+import path2 from "path";
 import { fileURLToPath } from "url";
-import { loadRootConfig, viteSsrLoadModule } from "@blinkk/root/node";
+import { loadRootConfig as loadRootConfig2, viteSsrLoadModule } from "@blinkk/root/node";
 import * as dom from "dts-dom";
-var __dirname = path.dirname(fileURLToPath(import.meta.url));
+var __dirname = path2.dirname(fileURLToPath(import.meta.url));
 async function generateTypes() {
   const rootDir = process.cwd();
-  const rootConfig = await loadRootConfig(rootDir, { command: "root-cms" });
-  const modulePath = path.resolve(__dirname, "./project.js");
+  const rootConfig = await loadRootConfig2(rootDir, { command: "root-cms" });
+  const modulePath = path2.resolve(__dirname, "./project.js");
   const project = await viteSsrLoadModule(
     rootConfig,
     modulePath
   );
   const schemas = await project.getProjectSchemas();
-  const outputPath = path.resolve(rootDir, "root-cms.d.ts");
+  const outputPath = path2.resolve(rootDir, "root-cms.d.ts");
   await generateSchemaDts(outputPath, schemas);
   console.log("saved root-cms.d.ts!");
 }
@@ -95,7 +435,7 @@ var DtsFormatter = class {
   /** Adds the types for a `.schema.ts` file to the `.d.ts` file. */
   addSchemaFile(fileId, schema) {
     const jsdoc = `Generated from \`${fileId}\`.`;
-    const typeId = alphanumeric(path.parse(fileId).name.split(".")[0]);
+    const typeId = alphanumeric(path2.parse(fileId).name.split(".")[0]);
     const oneOfTypes = {};
     const fieldsTypeId = `${typeId}Fields`;
     const fieldsType = dom.create.interface(
@@ -178,7 +518,7 @@ async function generateSchemaDts(outputPath, schemas) {
     dtsFormatter.addSchemaFile(fileId, schema);
   }
   const output = dtsFormatter.toString();
-  await fs.writeFile(outputPath, output, "utf-8");
+  await fs2.writeFile(outputPath, output, "utf-8");
 }
 function fieldProperty(field, options) {
   const prop = dom.create.property(
@@ -300,39 +640,269 @@ function alphanumeric(input) {
   return input.replace(/[^a-zA-Z0-9]/g, "");
 }
 
-// cli/init-firebase.ts
-import { loadRootConfig as loadRootConfig2 } from "@blinkk/root/node";
-
-// core/client.ts
-import crypto from "crypto";
-import {
-  FieldValue as FieldValue2,
-  Timestamp as Timestamp2
-} from "firebase-admin/firestore";
-
-// core/translations-manager.ts
-import {
-  FieldValue,
-  Timestamp
-} from "firebase-admin/firestore";
-
-// shared/strings.ts
-import fnv from "fnv-plus";
-
-// core/translations-manager.ts
-var TRANSLATIONS_DB_PATH_FORMAT = "/Projects/{project}/TranslationsManager/{mode}/Translations";
-var TRANSLATIONS_LOCALE_DOC_DB_PATH_FORMAT = `${TRANSLATIONS_DB_PATH_FORMAT}/{id}:{locale}`;
-
-// core/client.ts
-function getCmsPlugin(rootConfig) {
-  const plugins = rootConfig.plugins || [];
-  const plugin = plugins.find((plugin2) => plugin2.name === "root-cms");
-  if (!plugin) {
-    throw new Error("could not find root-cms plugin config in root.config.ts");
+// cli/import.ts
+import fs3 from "fs";
+import path3 from "path";
+import * as readline from "readline";
+import { loadRootConfig as loadRootConfig3 } from "@blinkk/root/node";
+import cliProgress from "cli-progress";
+import { Timestamp as Timestamp3, GeoPoint } from "firebase-admin/firestore";
+async function importData(options) {
+  if (!options.dir) {
+    throw new Error(
+      "Error: --dir flag is required. Usage: root-cms import --dir=export_siteId_timestamp"
+    );
   }
-  return plugin;
+  const importDir = options.dir;
+  if (!fs3.existsSync(importDir)) {
+    throw new Error(`Error: Directory not found: ${importDir}`);
+  }
+  const rootDir = process.cwd();
+  const rootConfig = await loadRootConfig3(rootDir, { command: "root-cms" });
+  const cmsPlugin = getCmsPlugin(rootConfig);
+  const cmsPluginOptions = cmsPlugin.getConfig();
+  const siteId = options.site || cmsPluginOptions.id || "default";
+  const databaseId = options.database || "(default)";
+  const gcpProjectId = options.project || cmsPluginOptions.firebaseConfig?.projectId || "unknown";
+  const db = cmsPlugin.getFirestore({ databaseId });
+  const entries = fs3.readdirSync(importDir, { withFileTypes: true });
+  const availableCollections = entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+  const { includes, excludes } = parseFilters(options.filter);
+  const collectionsToImport = availableCollections.filter((id) => {
+    const status = getPathStatus(id, includes, excludes);
+    return status !== "SKIP" && status !== "EXCLUDE";
+  });
+  if (collectionsToImport.length === 0) {
+    throw new Error(
+      `No valid collection types found matching filter. Available types: ${availableCollections.join(
+        ", "
+      )}`
+    );
+  }
+  const summary = [];
+  for (const collectionType of collectionsToImport) {
+    const collectionDir = path3.join(importDir, collectionType);
+    if (fs3.existsSync(collectionDir)) {
+      const count = countJsonFilesRecursive(
+        collectionDir,
+        collectionType,
+        includes,
+        excludes
+      );
+      if (count > 0) {
+        summary.push({
+          collectionType,
+          count
+        });
+      }
+    }
+  }
+  if (summary.length === 0) {
+    console.log("No data found to import.");
+    return;
+  }
+  const tableData = {};
+  tableData["Import Directory"] = importDir;
+  tableData["GCP Project"] = gcpProjectId;
+  tableData["Database"] = `${databaseId}/Projects/${siteId}`;
+  tableData["Site"] = siteId;
+  for (const item of summary) {
+    tableData[item.collectionType] = `${item.count} documents`;
+  }
+  console.log("");
+  console.table(tableData);
+  console.log("");
+  const proceed = await promptYesNo("Proceed with import? (yes/no): ");
+  if (!proceed) {
+    console.log("Import cancelled.");
+    return;
+  }
+  console.log("\nStarting import...\n");
+  const limit = pLimit(10);
+  for (const item of summary) {
+    const collectionPath = `Projects/${siteId}/${item.collectionType}`;
+    const collectionDir = path3.join(importDir, item.collectionType);
+    await importCollection(
+      db,
+      collectionPath,
+      collectionDir,
+      item.collectionType,
+      item.count,
+      item.collectionType,
+      includes,
+      excludes,
+      limit
+    );
+  }
+  const projectFilePath = path3.join(importDir, "__data.json");
+  if (fs3.existsSync(projectFilePath)) {
+    console.log("Importing project document...");
+    const rawData = JSON.parse(fs3.readFileSync(projectFilePath, "utf-8"));
+    const projectData = convertFirestoreTypes(rawData, db);
+    const projectPath = `Projects/${siteId}`;
+    await db.doc(projectPath).set(projectData, { merge: true });
+    console.log("  - Project document updated");
+  }
+  console.log("\n\u2705 Import complete!");
+}
+function countJsonFilesRecursive(dir, relativePath, includes, excludes) {
+  let count = 0;
+  const entries = fs3.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      const subRelativePath = `${relativePath}/${entry.name}`;
+      const status = getPathStatus(subRelativePath, includes, excludes);
+      if (status !== "SKIP" && status !== "EXCLUDE") {
+        count += countJsonFilesRecursive(
+          path3.join(dir, entry.name),
+          subRelativePath,
+          includes,
+          excludes
+        );
+      }
+    } else if (entry.isFile() && entry.name.endsWith(".json")) {
+      if (entry.name === "__data.json") {
+        const status2 = getPathStatus(relativePath, includes, excludes);
+        if (status2 === "INCLUDE") {
+          count++;
+        }
+        continue;
+      }
+      const docId = path3.basename(entry.name, ".json");
+      const docRelativePath = `${relativePath}/${docId}`;
+      const status = getPathStatus(docRelativePath, includes, excludes);
+      if (status !== "SKIP" && status !== "EXCLUDE") {
+        count++;
+      }
+    }
+  }
+  return count;
+}
+async function importCollection(db, collectionPath, inputDir, displayName, totalDocs, relativePath, includes, excludes, limit) {
+  console.log(`Importing ${displayName}...`);
+  const progressBar = new cliProgress.SingleBar({
+    format: `Importing ${displayName} [{bar}] {percentage}% | {value}/{total}`,
+    barCompleteChar: "\u2588",
+    barIncompleteChar: "\u2591",
+    hideCursor: true
+  });
+  progressBar.start(totalDocs, 0);
+  await importCollectionRecursive(
+    db,
+    collectionPath,
+    inputDir,
+    progressBar,
+    relativePath,
+    includes,
+    excludes,
+    limit
+  );
+  progressBar.stop();
+  console.log(`  - ${displayName}: ${totalDocs} documents`);
+}
+function convertFirestoreTypes(obj, db) {
+  if (obj === null || obj === void 0) {
+    return obj;
+  }
+  if (typeof obj === "object" && "_seconds" in obj && "_nanoseconds" in obj && Object.keys(obj).length === 2) {
+    return new Timestamp3(obj._seconds, obj._nanoseconds);
+  }
+  if (typeof obj === "object" && "_latitude" in obj && "_longitude" in obj && Object.keys(obj).length === 2) {
+    return new GeoPoint(obj._latitude, obj._longitude);
+  }
+  if (typeof obj === "object" && "_referencePath" in obj && Object.keys(obj).length === 1) {
+    return db.doc(obj._referencePath);
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => convertFirestoreTypes(item, db));
+  }
+  if (typeof obj === "object") {
+    const converted = {};
+    for (const [key, value] of Object.entries(obj)) {
+      converted[key] = convertFirestoreTypes(value, db);
+    }
+    return converted;
+  }
+  return obj;
+}
+async function importCollectionRecursive(db, collectionPath, inputDir, progressBar, relativePath, includes, excludes, limit) {
+  if (!fs3.existsSync(inputDir)) {
+    return;
+  }
+  const entries = fs3.readdirSync(inputDir, { withFileTypes: true });
+  await Promise.all(
+    entries.map(async (entry) => {
+      if (entry.isFile() && entry.name.endsWith(".json")) {
+        const rawData = JSON.parse(
+          fs3.readFileSync(path3.join(inputDir, entry.name), "utf-8")
+        );
+        const docData = convertFirestoreTypes(rawData, db);
+        if (entry.name === "__data.json") {
+          const status = includes && excludes ? getPathStatus(relativePath || "", includes, excludes) : "INCLUDE";
+          if (status === "INCLUDE") {
+            if (limit) {
+              await limit(
+                () => db.doc(collectionPath).set(docData, { merge: true })
+              );
+            } else {
+              await db.doc(collectionPath).set(docData, { merge: true });
+            }
+          }
+        } else {
+          const docId = path3.basename(entry.name, ".json");
+          const docRelativePath = relativePath ? `${relativePath}/${docId}` : docId;
+          const status = includes && excludes ? getPathStatus(docRelativePath, includes, excludes) : "INCLUDE";
+          if (status !== "SKIP" && status !== "EXCLUDE") {
+            if (limit) {
+              await limit(
+                () => db.doc(`${collectionPath}/${docId}`).set(docData)
+              );
+            } else {
+              await db.doc(`${collectionPath}/${docId}`).set(docData);
+            }
+            if (progressBar) {
+              progressBar.increment();
+            }
+          }
+        }
+      } else if (entry.isDirectory()) {
+        const subCollectionPath = `${collectionPath}/${entry.name}`;
+        const subCollectionDir = path3.join(inputDir, entry.name);
+        const subRelativePath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
+        const status = includes && excludes ? getPathStatus(subRelativePath, includes, excludes) : "INCLUDE";
+        if (status !== "SKIP" && status !== "EXCLUDE") {
+          await importCollectionRecursive(
+            db,
+            subCollectionPath,
+            subCollectionDir,
+            progressBar,
+            subRelativePath,
+            includes,
+            excludes,
+            limit
+          );
+        }
+      }
+    })
+  );
+}
+async function promptYesNo(question) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      const normalized = answer.trim().toLowerCase();
+      resolve(normalized === "yes" || normalized === "y");
+    });
+  });
 }
 
+// cli/init-firebase.ts
+import { loadRootConfig as loadRootConfig4 } from "@blinkk/root/node";
+
 // core/security.ts
 import { initializeApp } from "firebase-admin/app";
 import { getSecurityRules } from "firebase-admin/security-rules";
@@ -397,7 +967,7 @@ async function applySecurityRules(projectId) {
 // cli/init-firebase.ts
 async function initFirebase(options) {
   const rootDir = process.cwd();
-  const rootConfig = await loadRootConfig2(rootDir, { command: "root-cms" });
+  const rootConfig = await loadRootConfig4(rootDir, { command: "root-cms" });
   const cmsPlugin = getCmsPlugin(rootConfig);
   const cmsPluginOptions = cmsPlugin.getConfig();
   const gcpProjectId = options.project || cmsPluginOptions.firebaseConfig.projectId;
@@ -453,11 +1023,31 @@ var CliRunner = class {
     program.command("generate-types").alias("types").description(
       "generates root-cms.d.ts from *.schema.ts files in the project"
     ).action(generateTypes);
+    program.command("export").description(
+      'exports firestore data to a local directory\n\nBy default, all content in the Firestore database associated with the CMS will be exported.\n\nA unique new directory will be created for each export.\n\nFile naming conventions:\n- Documents that act as containers for subcollections are exported as directories containing a `__data.json` file for the document\'s own data.\n- Standalone documents are exported as JSON files named after their document ID (e.g. `page.json`).\n- For collections like ActionLogs and Translations, the document ID (often a hash) is used as the filename.\n\nUsage examples:\n  $ root-cms export\n  $ root-cms export --filter "Collections/Pages/**"\n  $ root-cms export --filter "Collections/Pages/**,!Collections/Pages/Draft/**"\n\nExample output:\n  <output>/Collections/Pages/Draft/...\n  <output>/Collections/Pages/Published/...\n  <output>/ActionLogs/...'
+    ).option(
+      "--filter <pattern>",
+      "comma-separated list of glob patterns to filter content (e.g. Collections/Pages/**, !ActionLogs/**)"
+    ).option("--site <siteId>", "site id to export (overrides root config)").option(
+      "--database <databaseId>",
+      'firestore database id (overrides root config, default: "(default)")'
+    ).option("--project <projectId>", "gcp project id (overrides root config)").action(exportData);
+    program.command("import").description(
+      'imports firestore data from a local directory\n\nUsage examples:\n  $ root-cms import --dir export_project_site_20251209t1305\n  $ root-cms import --dir export_project_site_20251209t1305 --filter "Collections/Pages/**"'
+    ).option("--dir <directory>", "directory to import from (required)").option(
+      "--filter <pattern>",
+      "comma-separated list of glob patterns to filter content (e.g. Collections/Pages/**, !ActionLogs/**)"
+    ).option("--site <siteId>", "site id to import to (overrides root config)").option(
+      "--database <databaseId>",
+      'firestore database id (overrides root config, default: "(default)")'
+    ).option("--project <projectId>", "gcp project id (overrides root config)").action(importData);
     await program.parseAsync(argv);
   }
 };
 export {
   CliRunner,
+  exportData,
   generateTypes,
+  importData,
   initFirebase
 };