@faststore/cli 4.4.0-dev.3 → 4.4.0-dev.5

package/dist/index.js

@@ -315,18 +315,239 @@ async function checkDeps(basePath) {
 
 // src/commands/cms-sync.ts
 import { Args as Args2, Command as Command2, Flags as Flags2 } from "@oclif/core";
+import chalk9 from "chalk";
 import { spawn } from "child_process";
+import { existsSync as existsSync9 } from "fs";
+import path9 from "path";
+import { pathToFileURL as pathToFileURL7 } from "url";
 
-// src/utils/generate.ts
+// src/utils/config.ts
+import chalk3 from "chalk";
+import { existsSync as existsSync4 } from "fs";
+import path3 from "path";
+import { pathToFileURL as pathToFileURL3 } from "url";
+var configFileName = "discovery.config.js";
+function isMyAccountEnabled(config) {
+  return config?.experimental?.enableFaststoreMyAccount === true;
+}
+function resolveContentSource(rawType) {
+  const normalized = rawType?.toUpperCase();
+  switch (normalized) {
+    case void 0:
+    case "CMS":
+      return "CMS";
+    case "CP":
+      return "CP";
+    default: {
+      logger.error(
+        `${chalk3.red("[Error]")} - Unsupported contentSource.type "${rawType}". Expected "CMS" or "CP".`
+      );
+      process.exit(1);
+    }
+  }
+}
+async function getDiscoveryConfig(basePath) {
+  const { tmpDir } = withBasePath(basePath);
+  const configPaths = [
+    path3.join(tmpDir, configFileName),
+    path3.join(basePath, configFileName)
+  ];
+  for (const configPath of configPaths) {
+    if (existsSync4(configPath)) {
+      try {
+        const discoveryConfig = await import(pathToFileURL3(configPath).href);
+        return discoveryConfig?.default ?? discoveryConfig;
+      } catch (error) {
+        logger.warn(
+          `${chalk3.yellow("warning")} - Could not read config file: ${configPath}.`
+        );
+      }
+    }
+  }
+  return null;
+}
+function isLocalizationEnabled(config) {
+  return config?.localization?.enabled === true;
+}
+function validateContentSourceForLocalization(config) {
+  if (!isLocalizationEnabled(config)) {
+    return;
+  }
+  const currentContentSourceType = config?.contentSource?.type?.toUpperCase();
+  if (currentContentSourceType !== "CP") {
+    logger.error(
+      `
+${chalk3.red("[Error]")} - Localization is enabled but contentSource is set to "${currentContentSourceType}".
+
+${chalk3.cyan("Required Action:")}
+Update your ${chalk3.bold("discovery.config.js")} file:
+
+  contentSource: {
+    type: ${chalk3.green('"CP"')}
+  },
+
+${chalk3.dim("When localization is enabled, Content Platform (CP) is required.")}
+`
+    );
+    process.exit(1);
+  }
+}
+async function checkAndValidateLocalization(basePath) {
+  const config = await getDiscoveryConfig(basePath);
+  if (!config) {
+    return false;
+  }
+  validateContentSourceForLocalization(config);
+  return isLocalizationEnabled(config);
+}
+
+// src/utils/cp-schema.ts
+import chalk5 from "chalk";
+import { cpSync, existsSync as existsSync5, mkdirSync, mkdtempSync, rmSync } from "fs";
+import path4 from "path";
+
+// src/utils/runCommandSync.ts
 import chalk4 from "chalk";
+import { execSync } from "child_process";
+var showError = ({
+  message,
+  cmd,
+  output
+}) => {
+  logger.error(`${chalk4.red("error")} - ${message}`);
+  if (cmd && output) {
+    logger.error(`${chalk4.magenta("$")} ${cmd}`);
+    logger.error(output);
+  }
+  process.exit(1);
+};
+var showWarning = ({
+  message,
+  cmd,
+  output
+}) => {
+  logger.warn(`${chalk4.yellow("warn")} - ${message}`);
+  if (cmd && output) {
+    logger.warn(`${chalk4.magenta("$")} ${cmd}`);
+    logger.warn(output);
+  }
+};
+var runCommandSync = ({
+  cmd,
+  errorMessage,
+  throws,
+  cwd,
+  interactive = false
+}) => {
+  try {
+    logger.log(`[STARTED] ${cmd}`);
+    const res = execSync(interactive ? cmd : `${cmd} 2>&1`, {
+      stdio: interactive ? "inherit" : "pipe",
+      cwd
+    });
+    logger.log(`[STATUS] ${res?.toString() ?? "Unknown"}`);
+    logger.log(`[FINISHED] ${cmd}`);
+  } catch (error) {
+    const execError = error;
+    const output = execError?.stdout?.toString() || execError?.stderr?.toString() || void 0;
+    if (throws === "warning") {
+      showWarning({ message: errorMessage, cmd, output });
+    } else {
+      showError({ message: errorMessage, cmd, output });
+    }
+  }
+};
+
+// src/utils/cp-schema.ts
+var MY_ACCOUNT_SUBDIRS = ["components", "pages"];
+function getExistingCpDirs(basePath) {
+  const { userCMSDir } = withBasePath(basePath);
+  const componentsDir = path4.join(userCMSDir, "components");
+  const pagesDir = path4.join(userCMSDir, "pages");
+  return [componentsDir, pagesDir].filter((dir) => existsSync5(dir)).map((dir) => path4.relative(basePath, dir));
+}
+function errorNoCustomization() {
+  logger.error(
+    `${chalk5.red("[Error]")} - No CMS customization found. Expected cms/faststore/components and/or cms/faststore/pages.`
+  );
+  process.exit(1);
+}
+function getCpSchemaOutputPath(basePath) {
+  return path4.relative(
+    basePath,
+    path4.join(withBasePath(basePath).userCMSDir, "schema.json")
+  );
+}
+function prepareMyAccountMergeDir(basePath) {
+  const { coreCMSDir, userCMSDir, tmpDir } = withBasePath(basePath);
+  const coreMyAccountDir = path4.join(coreCMSDir, "my-account");
+  if (!existsSync5(coreMyAccountDir)) {
+    logger.error(
+      `${chalk5.red("[Error]")} - My Account is enabled but the core My Account schemas were not found at ${coreMyAccountDir}. Update @faststore/core or disable experimental.enableFaststoreMyAccount.`
+    );
+    process.exit(1);
+  }
+  mkdirSync(tmpDir, { recursive: true });
+  const mergeDir = mkdtempSync(path4.join(tmpDir, "cms-myaccount-"));
+  try {
+    const dirs = [];
+    for (const subdir of MY_ACCOUNT_SUBDIRS) {
+      const dest = path4.join(mergeDir, subdir);
+      mkdirSync(dest, { recursive: true });
+      const coreSource = path4.join(coreMyAccountDir, subdir);
+      if (existsSync5(coreSource)) {
+        cpSync(coreSource, dest, { recursive: true });
+      }
+      const storeSource = path4.join(userCMSDir, subdir);
+      if (existsSync5(storeSource)) {
+        cpSync(storeSource, dest, { recursive: true });
+      }
+      dirs.push(path4.relative(basePath, dest));
+    }
+    return { mergeDir, dirs };
+  } catch (error) {
+    cleanupMyAccountMergeDir(mergeDir);
+    throw error;
+  }
+}
+function cleanupMyAccountMergeDir(mergeDir) {
+  rmSync(mergeDir, { recursive: true, force: true });
+}
+function generateAndUploadSchema({
+  basePath,
+  dirs,
+  schemaOut,
+  dryRun
+}) {
+  runCommandSync({
+    cmd: `vtex content generate-schema ${dirs.join(" ")} -o ${schemaOut}`,
+    cwd: basePath,
+    throws: "error",
+    errorMessage: "Failed to generate CMS schema",
+    interactive: true
+  });
+  if (dryRun) {
+    return;
+  }
+  runCommandSync({
+    cmd: `vtex content upload-schema ${schemaOut}`,
+    cwd: basePath,
+    throws: "error",
+    errorMessage: "Failed to upload CMS schema",
+    interactive: true
+  });
+}
+
+// src/utils/generate.ts
+import chalk6 from "chalk";
 import fsExtra4 from "fs-extra";
-import path5 from "path";
+import path7 from "path";
 import ora from "ora";
-import { pathToFileURL as pathToFileURL4 } from "url";
+import { pathToFileURL as pathToFileURL5 } from "url";
 
 // src/utils/createNextjsPages.ts
 import fs from "fs";
-import path3 from "path";
+import path5 from "path";
 
 // src/utils/templates/myAccountPage.ts
 var myAccountPageTemplate = (pagePath) => `
@@ -377,8 +598,8 @@ var createExternalPages = ({
   baseCustomizationPagesDir
 }) => {
   fs.readdirSync(customizationPagesDir).forEach((file) => {
-    const filePath = path3.join(customizationPagesDir, file);
-    const destinationPath = path3.join(corePagesDir, file);
+    const filePath = path5.join(customizationPagesDir, file);
+    const destinationPath = path5.join(corePagesDir, file);
     if (fs.statSync(filePath).isDirectory()) {
       if (!fs.existsSync(destinationPath)) {
         fs.mkdirSync(destinationPath, { recursive: true });
@@ -391,7 +612,7 @@ var createExternalPages = ({
     }
     const isReactFile = filePath.endsWith(".tsx");
     const isDestinationAvailable = !fs.existsSync(destinationPath) && !fs.existsSync(
-      path3.join(destinationPath.replace(".tsx", ""), "index.tsx")
+      path5.join(destinationPath.replace(".tsx", ""), "index.tsx")
     );
     if (isReactFile && isDestinationAvailable) {
       const externalPagePath = `src/customizations/src/pages${filePath.replace(baseCustomizationPagesDir, "").replace(".tsx", "")}`;
@@ -405,8 +626,8 @@ function isAllowedPrefixPage(file) {
 }
 function createNextJsPages(basePath) {
   const { tmpDir } = withBasePath(basePath);
-  const corePagesDir = path3.join(tmpDir, "src/pages");
-  const customizationPagesDir = path3.join(
+  const corePagesDir = path5.join(tmpDir, "src/pages");
+  const customizationPagesDir = path5.join(
     tmpDir,
     "src/customizations/src/pages"
   );
@@ -419,7 +640,7 @@ function createNextJsPages(basePath) {
   }) => {
     const items = fs.readdirSync(dirPath, { withFileTypes: true });
     return items.every((item) => {
-      const itemPath = path3.join(dirPath, item.name);
+      const itemPath = path5.join(dirPath, item.name);
       if (item.isDirectory()) {
         return allPagesAreAllowed({ basePath: basePath2, dirPath: itemPath });
       }
@@ -430,7 +651,7 @@ function createNextJsPages(basePath) {
       if (!isNextPage) {
         return false;
       }
-      const relativePath = path3.relative(basePath2, itemPath);
+      const relativePath = path5.relative(basePath2, itemPath);
       const normalizedPath = "/" + relativePath.replace(/\\/g, "/").replace(/\.(js|jsx|ts|tsx)$/, "");
       return isAllowedPrefixPage(normalizedPath);
     });
@@ -451,61 +672,6 @@ function createNextJsPages(basePath) {
   });
 }
 
-// src/utils/runCommandSync.ts
-import chalk3 from "chalk";
-import { execSync } from "child_process";
-var showError = ({
-  message,
-  cmd,
-  output
-}) => {
-  logger.error(`${chalk3.red("error")} - ${message}`);
-  if (cmd && output) {
-    logger.log(`${chalk3.magenta("DEBUG")} - $ ${JSON.stringify(cmd)} error \u2193`);
-    logger.log(output);
-  }
-  process.exit(1);
-};
-var showWarning = ({
-  message,
-  cmd,
-  output
-}) => {
-  logger.warn(`${chalk3.yellow("warn")} - ${message}`);
-  if (cmd && output) {
-    logger.log(`${chalk3.magenta("DEBUG")} - $ ${JSON.stringify(cmd)} warn \u2193`);
-    logger.log(output);
-  }
-};
-var runCommandSync = ({
-  cmd,
-  errorMessage,
-  throws,
-  cwd
-}) => {
-  const debug = process.env.DISCOVERY_DEBUG === "true" ? true : false;
-  try {
-    logger.log(`[STARTED] ${cmd}`);
-    const res = execSync(
-      debug ? `${cmd} --debug --verbose 2>&1` : `${cmd} 2>&1`,
-      {
-        stdio: "pipe",
-        cwd
-      }
-    );
-    logger.log(`[STATUS] ${res?.toString() ?? "Unknown"}`);
-    logger.log(`[FINISHED] ${cmd}`);
-  } catch (error) {
-    const execError = error;
-    const output = execError?.stdout?.toString() || execError?.stderr?.toString() || void 0;
-    if (throws === "warning") {
-      showWarning({ message: errorMessage, cmd, output });
-    } else {
-      showError({ message: errorMessage, cmd, output });
-    }
-  }
-};
-
 // src/utils/dependencies.ts
 async function installDependencies({
   dependencies,
@@ -524,9 +690,9 @@ async function installDependencies({
 
 // src/utils/plugins.ts
 import fsExtra3 from "fs-extra";
-import path4 from "path";
-import { pathToFileURL as pathToFileURL3 } from "url";
-var { copySync: copySync2, existsSync: existsSync4, mkdirSync, readdirSync: readdirSync2, writeFileSync } = fsExtra3;
+import path6 from "path";
+import { pathToFileURL as pathToFileURL4 } from "url";
+var { copySync: copySync2, existsSync: existsSync6, mkdirSync: mkdirSync2, readdirSync: readdirSync2, writeFileSync } = fsExtra3;
 var PLUGIN_CONFIG_FILE = "plugin.config.js";
 var sanitizePluginName = (pluginName, pascalCase = false) => {
   const sanitized = pluginName.split("/")[1];
@@ -556,7 +722,7 @@ var getPluginsList = async (basePath) => {
   try {
     const {
       default: { plugins = [] }
-    } = await import(pathToFileURL3(tmpStoreConfigFile).href);
+    } = await import(pathToFileURL4(tmpStoreConfigFile).href);
     return plugins;
   } catch (error) {
     logger.error(`Could not load plugins from store config`);
@@ -572,7 +738,7 @@ var copyPluginsSrc = async (basePath, plugins) => {
       basePath,
       getPluginName(pluginName)
     );
-    const pluginDestPath = path4.join(
+    const pluginDestPath = path6.join(
       tmpPluginsDir,
       sanitizePluginName(pluginName)
     );
@@ -587,7 +753,7 @@ var copyPluginPublicFiles = async (basePath, plugins) => {
     const pluginName = getPluginName(plugin);
     const pluginPath = getPackagePath(getPluginName(pluginName));
     try {
-      if (existsSync4(`${pluginPath}/public`)) {
+      if (existsSync6(`${pluginPath}/public`)) {
         copySync2(`${pluginPath}/public`, `${tmpDir}/public`, {
           dereference: true,
           overwrite: true
@@ -633,7 +799,7 @@ var generatePluginPages = async (basePath, plugins) => {
   plugins.forEach(async (plugin) => {
     const pluginName = getPluginName(plugin);
     const pluginConfigPath = getPackagePath(pluginName, PLUGIN_CONFIG_FILE);
-    const { default: pluginConfig } = await import(pathToFileURL3(pluginConfigPath).href);
+    const { default: pluginConfig } = await import(pathToFileURL4(pluginConfigPath).href);
     const { pages: pagesCustom } = getPluginCustomConfig(plugin);
     const pagesConfig = {
       ...pluginConfig.pages ?? {},
@@ -644,13 +810,13 @@ var generatePluginPages = async (basePath, plugins) => {
       const paths = pagesConfig[pageName].path.split("/");
       const pageFile = paths.pop();
       const pagePaths = paths;
-      const pagePath = path4.join(tmpPagesDir, ...pagePaths, pageFile + ".tsx");
+      const pagePath = path6.join(tmpPagesDir, ...pagePaths, pageFile + ".tsx");
       const fileContent = getPluginPageFileContent(
         sanitizePluginName(pluginName),
         pageName,
         pagesConfig[pageName].appLayout
       );
-      mkdirSync(path4.dirname(pagePath), { recursive: true });
+      mkdirSync2(path6.dirname(pagePath), { recursive: true });
       writeFileSync(pagePath, fileContent);
     });
   });
@@ -659,7 +825,7 @@ async function addPluginsSections(basePath, plugins) {
   const { tmpPluginsDir, getPackagePath } = withBasePath(basePath);
   logger.log("Adding plugin sections");
   const indexPluginsOverrides = plugins.filter(
-    (plugin) => existsSync4(
+    (plugin) => existsSync6(
       getPackagePath(getPluginName(plugin), "src", "components", "index.ts")
     )
   ).map((plugin) => {
@@ -676,7 +842,7 @@ async function addPluginsSections(basePath, plugins) {
     ${indexPluginsOverrides.map((plugin) => `...${plugin.pluginReference}`).join(",\n")}
   }
   `;
-  const sectionPath = path4.join(tmpPluginsDir, "index.ts");
+  const sectionPath = path6.join(tmpPluginsDir, "index.ts");
   writeFileSync(sectionPath, pluginsImportFileContent);
   logger.log("Writing plugins overrides");
   logger.log(sectionPath);
@@ -693,14 +859,14 @@ async function addPluginsOverrides(basePath, plugins) {
       "components",
       "overrides"
     )
-  })).filter(({ pluginOverridesPath }) => existsSync4(pluginOverridesPath)).reverse().forEach(({ pluginName, pluginOverridesPath }) => {
+  })).filter(({ pluginOverridesPath }) => existsSync6(pluginOverridesPath)).reverse().forEach(({ pluginName, pluginOverridesPath }) => {
     const overrideFilesAlreadyCopied = [];
     const sanitizedPluginName = sanitizePluginName(pluginName);
     const overrideFiles = readdirSync2(pluginOverridesPath);
     overrideFiles.filter((file) => !overrideFilesAlreadyCopied.includes(file)).forEach((overrideFileName) => {
       const overrideFileContent = `export { override } from 'src/plugins/${sanitizedPluginName}/components/overrides/${overrideFileName.split(".")[0]}'`;
       writeFileSync(
-        path4.join(tmpPluginsDir, "overrides", overrideFileName),
+        path6.join(tmpPluginsDir, "overrides", overrideFileName),
         overrideFileContent
       );
       overrideFilesAlreadyCopied.push(overrideFileName);
@@ -710,7 +876,7 @@ async function addPluginsOverrides(basePath, plugins) {
 var addPluginsTheme = async (basePath, plugins) => {
   const { getPackagePath, tmpThemesPluginsFile } = withBasePath(basePath);
   const pluginImportsContent = plugins.filter(
-    (plugin) => existsSync4(
+    (plugin) => existsSync6(
       getPackagePath(getPluginName(plugin), "src", "themes", "index.scss")
     )
   ).map(
@@ -734,7 +900,7 @@ var generatePluginApis = async (basePath, plugins) => {
   plugins.forEach(async (plugin) => {
     const pluginName = getPluginName(plugin);
     const pluginConfigPath = getPackagePath(pluginName, PLUGIN_CONFIG_FILE);
-    const { default: pluginConfig } = await import(pathToFileURL3(pluginConfigPath).href);
+    const { default: pluginConfig } = await import(pathToFileURL4(pluginConfigPath).href);
     const { apis: apisCustom } = getPluginCustomConfig(plugin);
     const apisConfig = {
       ...pluginConfig.apis ?? {},
@@ -745,7 +911,7 @@ var generatePluginApis = async (basePath, plugins) => {
       const paths = apisConfig[apiName].path.split("/");
       const apiFile = paths.pop();
       const apiPaths = paths;
-      const apiPath = path4.join(
+      const apiPath = path6.join(
         tmpApiDir,
         "plugins",
         ...apiPaths,
@@ -755,7 +921,7 @@ var generatePluginApis = async (basePath, plugins) => {
         sanitizePluginName(pluginName),
         apiName
       );
-      mkdirSync(path4.dirname(apiPath), { recursive: true });
+      mkdirSync2(path6.dirname(apiPath), { recursive: true });
       writeFileSync(apiPath, fileContent);
     });
   });
@@ -775,7 +941,7 @@ var installPlugins = async (basePath) => {
 var {
   copyFileSync,
   copySync: copySync3,
-  existsSync: existsSync5,
+  existsSync: existsSync7,
   mkdirsSync,
   readFileSync,
   readdirSync: readdirSync3,
@@ -793,17 +959,17 @@ var ignorePaths = [
 function createTmpFolder(basePath) {
   const { tmpDir, tmpFolderName } = withBasePath(basePath);
   try {
-    if (existsSync5(tmpDir)) {
+    if (existsSync7(tmpDir)) {
       removeSync2(tmpDir);
     }
     mkdirsSync(tmpDir);
     logger.log(
-      `${chalk4.green("success")} - Temporary folder ${chalk4.dim(
+      `${chalk6.green("success")} - Temporary folder ${chalk6.dim(
         tmpFolderName
       )} created`
     );
   } catch (err) {
-    logger.error(`${chalk4.red("error")} - ${err}`);
+    logger.error(`${chalk6.red("error")} - ${err}`);
   }
 }
 function buildFaststorePackageJson(coreManifest, voltaConfig) {
@@ -831,8 +997,8 @@ function buildFaststorePackageJson(coreManifest, voltaConfig) {
 }
 function readRootVoltaConfig(rootDir) {
   try {
-    const rootManifestPath = path5.join(rootDir, "package.json");
-    if (!existsSync5(rootManifestPath)) {
+    const rootManifestPath = path7.join(rootDir, "package.json");
+    if (!existsSync7(rootManifestPath)) {
       return void 0;
     }
     const rootManifest = JSON.parse(readFileSync(rootManifestPath, "utf8"));
@@ -844,27 +1010,27 @@ function readRootVoltaConfig(rootDir) {
 function filterAndCopyPackageJson(basePath) {
   const { coreDir, tmpDir, getRoot } = withBasePath(basePath);
   const coreManifest = JSON.parse(
-    readFileSync(path5.join(coreDir, "package.json"), "utf8")
+    readFileSync(path7.join(coreDir, "package.json"), "utf8")
   );
   const voltaConfig = readRootVoltaConfig(getRoot());
   const filteredFileContent = buildFaststorePackageJson(
     coreManifest,
     voltaConfig
   );
-  writeJsonSync(path5.join(tmpDir, "package.json"), filteredFileContent, {
+  writeJsonSync(path7.join(tmpDir, "package.json"), filteredFileContent, {
     spaces: 2
   });
 }
 var TS_CONFIG_STRICT_RULES_ENABLED = ["noImplicitAny"];
 function disableTsConfigStrictRules(basePath) {
   const { coreDir, tmpDir } = withBasePath(basePath);
-  const coreTsConfigPath = path5.join(coreDir, "tsconfig.json");
+  const coreTsConfigPath = path7.join(coreDir, "tsconfig.json");
   const coreTsConfigFile = readFileSync(coreTsConfigPath, "utf8");
   const tsConfig = JSON.parse(coreTsConfigFile);
   TS_CONFIG_STRICT_RULES_ENABLED.forEach((strictRule) => {
     tsConfig.compilerOptions[strictRule] = false;
   });
-  writeJsonSync(path5.join(tmpDir, "tsconfig.json"), tsConfig, {
+  writeJsonSync(path7.join(tmpDir, "tsconfig.json"), tsConfig, {
     spaces: 2
   });
 }
@@ -874,14 +1040,14 @@ function copyCoreFiles(basePath) {
     copySync3(coreDir, tmpDir, {
       dereference: true,
       filter(src) {
-        const fileOrDirName = path5.basename(src);
+        const fileOrDirName = path7.basename(src);
         const shouldCopy = fileOrDirName ? !ignorePaths.includes(fileOrDirName) : true;
         return shouldCopy;
       }
     });
     filterAndCopyPackageJson(basePath);
     disableTsConfigStrictRules(basePath);
-    logger.log(`${chalk4.green("success")} - Core files copied`);
+    logger.log(`${chalk6.green("success")} - Core files copied`);
   } catch (e) {
     logger.error(e);
   }
@@ -890,7 +1056,7 @@ function copyPublicFiles(basePath) {
   const { userDir, tmpDir } = withBasePath(basePath);
   const allowList = ["json", "txt", "xml", "ico", "public", "svg"];
   try {
-    if (existsSync5(`${userDir}/public`)) {
+    if (existsSync7(`${userDir}/public`)) {
       copySync3(`${userDir}/public`, `${tmpDir}/public`, {
         dereference: true,
         overwrite: true,
@@ -899,7 +1065,7 @@ function copyPublicFiles(basePath) {
           return allow;
         }
       });
-      logger.log(`${chalk4.green("success")} - Public files copied`);
+      logger.log(`${chalk6.green("success")} - Public files copied`);
     }
   } catch (e) {
     logger.error(e);
@@ -908,34 +1074,34 @@ function copyPublicFiles(basePath) {
 async function copyCypressFiles(basePath) {
   const { userDir, userStoreConfigFile, userLegacyStoreConfigFile, tmpDir } = withBasePath(basePath);
   try {
-    if (existsSync5(`${userDir}/cypress.json`)) {
+    if (existsSync7(`${userDir}/cypress.json`)) {
       copySync3(`${userDir}/cypress.json`, `${tmpDir}/cypress.json`, {
         dereference: true
       });
     }
-    if (existsSync5(`${userDir}/cypress.config.ts`)) {
+    if (existsSync7(`${userDir}/cypress.config.ts`)) {
       copySync3(`${userDir}/cypress.config.ts`, `${tmpDir}/cypress.config.ts`, {
         dereference: true
       });
     }
     let userStoreConfig;
-    if (existsSync5(userStoreConfigFile)) {
-      userStoreConfig = (await import(pathToFileURL4(path5.resolve(userStoreConfigFile)).href))?.default;
-    } else if (existsSync5(userLegacyStoreConfigFile)) {
-      userStoreConfig = (await import(pathToFileURL4(path5.resolve(userLegacyStoreConfigFile)).href))?.default;
+    if (existsSync7(userStoreConfigFile)) {
+      userStoreConfig = (await import(pathToFileURL5(path7.resolve(userStoreConfigFile)).href))?.default;
+    } else if (existsSync7(userLegacyStoreConfigFile)) {
+      userStoreConfig = (await import(pathToFileURL5(path7.resolve(userLegacyStoreConfigFile)).href))?.default;
     } else {
       logger.info(
-        `${chalk4.blue(
+        `${chalk6.blue(
           "info"
         )} - No store config file was found in the root directory`
       );
     }
-    if (existsSync5(`${userDir}/cypress`) && userStoreConfig?.experimental?.enableCypressExtension) {
+    if (existsSync7(`${userDir}/cypress`) && userStoreConfig?.experimental?.enableCypressExtension) {
       copySync3(`${userDir}/cypress`, `${tmpDir}/cypress`, {
         overwrite: true,
         dereference: true
       });
-      logger.log(`${chalk4.green("success")} - Cypress test files copied`);
+      logger.log(`${chalk6.green("success")} - Cypress test files copied`);
     }
     if (userStoreConfig?.experimental?.cypressVersion > 9) {
       copySync3(
@@ -957,27 +1123,27 @@ function copyUserStarterToCustomizations(basePath) {
     tmpStoreConfigFile
   } = withBasePath(basePath);
   try {
-    if (existsSync5(userSrcDir) && readdirSync3(userSrcDir).length > 0) {
+    if (existsSync7(userSrcDir) && readdirSync3(userSrcDir).length > 0) {
       copySync3(userSrcDir, tmpCustomizationsSrcDir, { dereference: true });
       createNextJsPages(basePath);
     }
   } catch (err) {
-    logger.error(`${chalk4.red("error")} - ${err}`);
+    logger.error(`${chalk6.red("error")} - ${err}`);
   }
-  if (existsSync5(userStoreConfigFile)) {
+  if (existsSync7(userStoreConfigFile)) {
     copySync3(userStoreConfigFile, tmpStoreConfigFile, { dereference: true });
-  } else if (existsSync5(userLegacyStoreConfigFile)) {
+  } else if (existsSync7(userLegacyStoreConfigFile)) {
     copySync3(userLegacyStoreConfigFile, tmpStoreConfigFile, {
       dereference: true
     });
   } else {
     logger.info(
-      `${chalk4.blue(
+      `${chalk6.blue(
         "info"
       )} - No store config file was found in the root directory`
     );
   }
-  logger.log(`${chalk4.green("success")} - Starter files copied`);
+  logger.log(`${chalk6.green("success")} - Starter files copied`);
 }
 async function createCmsWebhookUrlsJsonFile(basePath) {
   const {
@@ -986,13 +1152,13 @@ async function createCmsWebhookUrlsJsonFile(basePath) {
     tmpCMSWebhookUrlsFile
   } = withBasePath(basePath);
   let userStoreConfig;
-  if (existsSync5(userStoreConfigFile)) {
-    userStoreConfig = (await import(pathToFileURL4(path5.resolve(userStoreConfigFile)).href))?.default;
-  } else if (existsSync5(userLegacyStoreConfigFile)) {
-    userStoreConfig = (await import(pathToFileURL4(path5.resolve(userLegacyStoreConfigFile)).href))?.default;
+  if (existsSync7(userStoreConfigFile)) {
+    userStoreConfig = (await import(pathToFileURL5(path7.resolve(userStoreConfigFile)).href))?.default;
+  } else if (existsSync7(userLegacyStoreConfigFile)) {
+    userStoreConfig = (await import(pathToFileURL5(path7.resolve(userLegacyStoreConfigFile)).href))?.default;
   } else {
     logger.info(
-      `${chalk4.blue(
+      `${chalk6.blue(
         "info"
       )} - No store config file was found in the root directory`
     );
@@ -1001,12 +1167,12 @@ async function createCmsWebhookUrlsJsonFile(basePath) {
     const { webhookUrls } = userStoreConfig?.vtexHeadlessCms;
     try {
       writeJsonSync(tmpCMSWebhookUrlsFile, { urls: webhookUrls }, { spaces: 2 });
-      logger.log(`${chalk4.green("success")} - CMS webhook URLs file created`);
+      logger.log(`${chalk6.green("success")} - CMS webhook URLs file created`);
     } catch (err) {
-      logger.error(`${chalk4.red("error")} - ${err}`);
+      logger.error(`${chalk6.red("error")} - ${err}`);
     }
   } else {
-    logger.info(`${chalk4.blue("info")} - No CMS webhook URLs were provided`);
+    logger.info(`${chalk6.blue("info")} - No CMS webhook URLs were provided`);
   }
 }
 async function copyTheme(basePath) {
@@ -1016,38 +1182,38 @@ async function copyTheme(basePath) {
     tmpThemesCustomizationsFile,
     userLegacyStoreConfigFile
   } = withBasePath(basePath);
-  const storeConfigFile = existsSync5(userStoreConfigFile) && userStoreConfigFile || existsSync5(userLegacyStoreConfigFile) && userLegacyStoreConfigFile;
-  const userStoreConfigFilePath = storeConfigFile && path5.resolve(storeConfigFile);
-  const importedStoreConfig = userStoreConfigFilePath && await import(pathToFileURL4(userStoreConfigFilePath).href);
+  const storeConfigFile = existsSync7(userStoreConfigFile) && userStoreConfigFile || existsSync7(userLegacyStoreConfigFile) && userLegacyStoreConfigFile;
+  const userStoreConfigFilePath = storeConfigFile && path7.resolve(storeConfigFile);
+  const importedStoreConfig = userStoreConfigFilePath && await import(pathToFileURL5(userStoreConfigFilePath).href);
   const storeConfig = userStoreConfigFilePath && (importedStoreConfig?.default || importedStoreConfig);
   if (!storeConfig)
     logger.info(
-      `${chalk4.blue(
+      `${chalk6.blue(
         "info"
       )} - No store config file was found in the root directory`
     );
   if (storeConfig.theme) {
-    const customTheme = path5.join(
+    const customTheme = path7.join(
       userThemesFileDir,
       `${storeConfig.theme}.scss`
     );
-    if (existsSync5(customTheme)) {
+    if (existsSync7(customTheme)) {
       try {
         copyFileSync(customTheme, tmpThemesCustomizationsFile);
         logger.log(
-          `${chalk4.green("success")} - ${storeConfig.theme} theme has been applied`
+          `${chalk6.green("success")} - ${storeConfig.theme} theme has been applied`
         );
       } catch (err) {
-        logger.error(`${chalk4.red("error")} - ${err}`);
+        logger.error(`${chalk6.red("error")} - ${err}`);
       }
     } else {
       logger.info(
-        `${chalk4.blue("info")} - The ${storeConfig.theme} theme was added to the config file but the ${storeConfig.theme}.scss file does not exist in the themes folder. Read more: https://developers.vtex.com/docs/guides/faststore/themes-overview`
+        `${chalk6.blue("info")} - The ${storeConfig.theme} theme was added to the config file but the ${storeConfig.theme}.scss file does not exist in the themes folder. Read more: https://developers.vtex.com/docs/guides/faststore/themes-overview`
       );
     }
-  } else if (existsSync5(userThemesFileDir) && readdirSync3(userThemesFileDir).length > 0) {
+  } else if (existsSync7(userThemesFileDir) && readdirSync3(userThemesFileDir).length > 0) {
     logger.info(
-      `${chalk4.blue(
+      `${chalk6.blue(
         "info"
       )} - The theme needs to be added to the config file to be applied. Read more: https://www.faststore.dev/docs/themes/overview`
     );
@@ -1063,19 +1229,19 @@ function updateBuildTime(basePath) {
       `const buildTime = '${newBuildTime}';`
     );
     writeFileSync2(tmpSeoConfig, config);
-    logger.log(`${chalk4.green("success")} - Build time updated`, newBuildTime);
+    logger.log(`${chalk6.green("success")} - Build time updated`, newBuildTime);
   } catch (error) {
-    logger.error(`${chalk4.red("error")} - Updating build time:`, error);
+    logger.error(`${chalk6.red("error")} - Updating build time:`, error);
   }
 }
 async function checkDependencies(basePath, packagesToCheck) {
   const { coreDir, getRoot } = withBasePath(basePath);
-  const corePackageJsonPath = path5.join(coreDir, "package.json");
-  const rootPackageJsonPath = path5.join(getRoot(), "package.json");
-  const { default: corePackageJson } = await import(pathToFileURL4(corePackageJsonPath).href, {
+  const corePackageJsonPath = path7.join(coreDir, "package.json");
+  const rootPackageJsonPath = path7.join(getRoot(), "package.json");
+  const { default: corePackageJson } = await import(pathToFileURL5(corePackageJsonPath).href, {
     with: { type: "json" }
   });
-  const { default: rootPackageJson } = await import(pathToFileURL4(rootPackageJsonPath).href, {
+  const { default: rootPackageJson } = await import(pathToFileURL5(rootPackageJsonPath).href, {
     with: { type: "json" }
   });
   packagesToCheck.forEach((packageName) => {
@@ -1083,13 +1249,13 @@ async function checkDependencies(basePath, packagesToCheck) {
     const rootVersion = rootPackageJson.devDependencies[packageName] || rootPackageJson.dependencies[packageName];
     if (!coreVersion || !rootVersion) {
       logger.warn(
-        `${chalk4.yellow(
+        `${chalk6.yellow(
           "warning"
         )} - Package ${packageName} not found in both core or root dependencies.`
       );
     } else if (coreVersion !== rootVersion) {
       logger.warn(
-        `${chalk4.yellow(
+        `${chalk6.yellow(
           "warning"
         )} - Version mismatch detected for ${packageName}.
           Core: ${coreVersion}, Customization: ${rootVersion}. Please align both versions to prevent issues`
@@ -1099,7 +1265,7 @@ async function checkDependencies(basePath, packagesToCheck) {
 }
 function updateNextConfig(basePath) {
   const { tmpDir } = withBasePath(basePath);
-  const nextConfigPath = path5.join(tmpDir, "next.config.js");
+  const nextConfigPath = path7.join(tmpDir, "next.config.js");
   let nextConfigData = String(readFileSync(nextConfigPath));
   nextConfigData = nextConfigData.replace(
     /outputFileTracingRoot\:\s+(.*),/,
@@ -1109,10 +1275,10 @@ function updateNextConfig(basePath) {
 }
 function getCurrentUserStoreConfigFile(basePath) {
   const { userStoreConfigFile, userLegacyStoreConfigFile } = withBasePath(basePath);
-  if (existsSync5(userStoreConfigFile)) {
+  if (existsSync7(userStoreConfigFile)) {
     return userStoreConfigFile;
   }
-  if (existsSync5(userLegacyStoreConfigFile)) {
+  if (existsSync7(userLegacyStoreConfigFile)) {
     return userLegacyStoreConfigFile;
   }
   return null;
@@ -1123,8 +1289,8 @@ async function validateAndInstallMissingDependencies(basePath) {
   if (!currentUserStoreConfigFile) {
     return;
   }
-  const { default: userStoreConfig } = await import(pathToFileURL4(currentUserStoreConfigFile).href);
-  const { default: userPackageJson } = await import(pathToFileURL4(path5.join(userDir, "package.json")).href, {
+  const { default: userStoreConfig } = await import(pathToFileURL5(currentUserStoreConfigFile).href);
+  const { default: userPackageJson } = await import(pathToFileURL5(path7.join(userDir, "package.json")).href, {
     with: { type: "json" }
   });
   const missingDependencies = [];
@@ -1158,12 +1324,12 @@ async function enableSearchSSR(basePath) {
   if (!storeConfigPath) {
     return;
   }
-  const { default: storeConfig } = await import(pathToFileURL4(storeConfigPath).href);
+  const { default: storeConfig } = await import(pathToFileURL5(storeConfigPath).href);
   if (!storeConfig.experimental.enableSearchSSR) {
     return;
   }
   const { tmpDir } = withBasePath(basePath);
-  const searchPagePath = path5.join(tmpDir, "src", "pages", "s.tsx");
+  const searchPagePath = path7.join(tmpDir, "src", "pages", "s.tsx");
   const searchPageData = String(readFileSync(searchPagePath));
   const searchPageWithSSR = searchPageData.replaceAll(
     "getStaticProps",
@@ -1197,12 +1363,12 @@ async function generate(options) {
 }
 
 // src/utils/hcms.ts
-import chalk5 from "chalk";
-import path6 from "path";
+import chalk7 from "chalk";
+import path8 from "path";
 import { confirm } from "@inquirer/prompts";
 import fsExtra5 from "fs-extra";
-import { pathToFileURL as pathToFileURL5 } from "url";
-var { readFileSync: readFileSync2, existsSync: existsSync6, writeFileSync: writeFileSync3, mkdirSync: mkdirSync2 } = fsExtra5;
+import { pathToFileURL as pathToFileURL6 } from "url";
+var { readFileSync: readFileSync2, existsSync: existsSync8, writeFileSync: writeFileSync3, mkdirSync: mkdirSync3 } = fsExtra5;
 function splitCustomDefinitions(coreDefinitions, customDefinitions, primaryIdentifier) {
   const coreDefinitionIdentifiers = new Set(
     coreDefinitions.map((definition) => definition[primaryIdentifier] ?? "")
@@ -1266,10 +1432,10 @@ async function mergeCMSFile(fileName, basePath) {
     getPackagePath,
     userStoreConfigFile
   } = withBasePath(basePath);
-  const { default: userStoreConfig } = await import(pathToFileURL5(path6.resolve(userStoreConfigFile)).href);
+  const { default: userStoreConfig } = await import(pathToFileURL6(path8.resolve(userStoreConfigFile)).href);
   const cmsProjectName = userStoreConfig.contentSource?.project ?? "faststore";
-  const coreFilePath = path6.join(coreCMSDir, fileName);
-  const customFilePath = path6.join(userCMSDir, fileName);
+  const coreFilePath = path8.join(coreCMSDir, fileName);
+  const customFilePath = path8.join(userCMSDir, fileName);
   const coreFile = readFileSync2(coreFilePath, "utf8");
   const coreDefinitions = JSON.parse(coreFile);
   const primaryIdentifierForDefinitions = fileName === "content-types.json" ? "id" : "name";
@@ -1279,7 +1445,7 @@ async function mergeCMSFile(fileName, basePath) {
     (plugin) => getPackagePath(getPluginName(plugin), "cms", "faststore", fileName)
   );
   const customizations = [...pluginCMSFilePaths, customFilePath].filter(
-    (pluginCMSFilePath) => existsSync6(pluginCMSFilePath)
+    (pluginCMSFilePath) => existsSync8(pluginCMSFilePath)
   );
   for (const newFilePath of customizations) {
     const customFile = readFileSync2(newFilePath, "utf8");
@@ -1308,7 +1474,7 @@ async function mergeCMSFile(fileName, basePath) {
     } catch (err) {
       if (err instanceof SyntaxError) {
         console.info(
-          `${chalk5.red(
+          `${chalk7.red(
             "error"
           )} - ${fileName} is a malformed JSON file, ignoring its contents.`
         );
@@ -1318,18 +1484,18 @@ async function mergeCMSFile(fileName, basePath) {
     }
   }
   try {
-    if (!existsSync6(tmpCMSDir(cmsProjectName))) {
-      mkdirSync2(tmpCMSDir(cmsProjectName));
+    if (!existsSync8(tmpCMSDir(cmsProjectName))) {
+      mkdirSync3(tmpCMSDir(cmsProjectName));
     }
     writeFileSync3(
-      path6.join(tmpCMSDir(cmsProjectName), fileName),
+      path8.join(tmpCMSDir(cmsProjectName), fileName),
       JSON.stringify(output)
     );
     console.log(
-      `${chalk5.green("success")} - CMS file ${chalk5.dim(fileName)} created`
+      `${chalk7.green("success")} - CMS file ${chalk7.dim(fileName)} created`
     );
   } catch (err) {
-    console.error(`${chalk5.red("error")} - ${err}`);
+    console.error(`${chalk7.red("error")} - ${err}`);
   }
 }
 async function mergeCMSFiles(basePath) {
@@ -1337,13 +1503,83 @@ async function mergeCMSFiles(basePath) {
     await mergeCMSFile("content-types.json", basePath);
     await mergeCMSFile("sections.json", basePath);
   } catch (err) {
-    console.error(`${chalk5.red("error")} - ${err}`);
+    console.error(`${chalk7.red("error")} - ${err}`);
+  }
+}
+
+// src/utils/vtex.ts
+import { execSync as execSync2 } from "child_process";
+import chalk8 from "chalk";
+function runCapture(cmd) {
+  try {
+    return execSync2(`${cmd} 2>&1`, { stdio: "pipe" }).toString();
+  } catch {
+    return null;
+  }
+}
+function isVtexCliInstalled() {
+  return runCapture("vtex --version") !== null;
+}
+function parseAccountFromWhoami(output) {
+  if (/not logged|isn't logged|no user|please login/i.test(output)) {
+    return null;
+  }
+  const patterns = [
+    /@\s+([\w.-]+)\s*\//,
+    // "user@vtex.com @ brandless / master"
+    /logged in(?:to)?\s+(?:account\s+)?([\w.-]+)/i,
+    // "Logged into brandless ..."
+    /account[:\s]+([\w.-]+)/i
+    // "... account brandless ..."
+  ];
+  for (const pattern of patterns) {
+    const match = output.match(pattern);
+    if (match?.[1]) {
+      return match[1];
+    }
+  }
+  return null;
+}
+function getLoggedVtexAccount() {
+  const output = runCapture("vtex whoami");
+  if (!output) {
+    return null;
+  }
+  return parseAccountFromWhoami(output);
+}
+function assertVtexReadyForAccount(account) {
+  if (!isVtexCliInstalled()) {
+    logger.error(
+      `${chalk8.red("[Error]")} - The VTEX toolbelt (\`vtex\`) was not found. Install it with ${chalk8.bold("npm i -g vtex")} and try again.
+${chalk8.dim("Docs: https://developers.vtex.com/docs/guides/vtex-io-documentation-vtex-io-cli-installation-and-command-reference")}`
+    );
+    process.exit(1);
+    return;
+  }
+  const loggedAccount = getLoggedVtexAccount();
+  const loginHint = account ? `vtex login ${account}` : "vtex login <account>";
+  if (!loggedAccount) {
+    logger.error(
+      `${chalk8.red("[Error]")} - You are not logged into the VTEX toolbelt.
+${chalk8.cyan("Required Action:")} log into the store account by running ${chalk8.bold(loginHint)}.`
+    );
+    process.exit(1);
+    return;
+  }
+  if (account && loggedAccount.toLowerCase() !== account.toLowerCase()) {
+    logger.error(
+      `${chalk8.red("[Error]")} - You are logged into ${chalk8.bold(loggedAccount)}, but this store targets ${chalk8.bold(account)} (\`api.storeId\` in discovery.config.js).
+${chalk8.cyan("Required Action:")} switch accounts with ${chalk8.bold(`vtex switch ${account}`)} or ${chalk8.bold(loginHint)}.`
+    );
+    process.exit(1);
   }
 }
 
 // src/commands/cms-sync.ts
-import path7 from "path";
-import { pathToFileURL as pathToFileURL6 } from "url";
+var CONTENT_SOURCE_ACTION = {
+  CMS: "merging and syncing CMS content",
+  CP: "generating and uploading schema"
+};
 var CmsSync = class _CmsSync extends Command2 {
   static flags = {
     ["dry-run"]: Flags2.boolean({ char: "d" })
@@ -1357,20 +1593,86 @@ var CmsSync = class _CmsSync extends Command2 {
   async run() {
     const { flags, args } = await this.parse(_CmsSync);
     const basePath = getBasePath(args.path);
-    const { tmpDir, userStoreConfigFile } = withBasePath(basePath);
-    const { default: userStoreConfig } = await import(pathToFileURL6(path7.resolve(userStoreConfigFile)).href);
-    const cmsProjectName = userStoreConfig.contentSource?.project ?? "faststore";
+    const { userStoreConfigFile } = withBasePath(basePath);
+    const storeConfig = existsSync9(userStoreConfigFile) ? (await import(pathToFileURL7(path9.resolve(userStoreConfigFile)).href)).default : null;
+    const source = resolveContentSource(storeConfig?.contentSource?.type);
+    logger.info(
+      `${chalk9.blue("[Info]")} - Detected contentSource "${source}" \u2014 ${CONTENT_SOURCE_ACTION[source]}`
+    );
+    switch (source) {
+      case "CMS":
+        return this.runLegacySync({
+          basePath,
+          storeConfig,
+          dryRun: flags["dry-run"]
+        });
+      case "CP":
+        return this.runCpSync({
+          basePath,
+          storeConfig,
+          dryRun: flags["dry-run"]
+        });
+      default: {
+        return source;
+      }
+    }
+  }
+  async runLegacySync({
+    basePath,
+    storeConfig,
+    dryRun
+  }) {
+    const { tmpDir } = withBasePath(basePath);
+    const project = storeConfig?.contentSource?.project ?? "faststore";
     await generate({ setup: true, basePath });
     await mergeCMSFiles(basePath);
-    if (flags["dry-run"]) {
+    if (dryRun) {
       return;
     }
-    return spawn(`vtex cms sync ${cmsProjectName}`, {
+    return spawn(`vtex cms sync ${project}`, {
       shell: true,
       cwd: tmpDir,
       stdio: "inherit"
     });
   }
+  runCpSync({
+    basePath,
+    storeConfig,
+    dryRun
+  }) {
+    assertVtexReadyForAccount(storeConfig?.api?.storeId);
+    let merge;
+    if (isMyAccountEnabled(storeConfig)) {
+      logger.info(
+        `${chalk9.blue("[Info]")} - Merging My Account sections and content-types into the schema`
+      );
+      merge = prepareMyAccountMergeDir(basePath);
+    }
+    const dirs = merge ? merge.dirs : getExistingCpDirs(basePath);
+    if (dirs.length === 0) {
+      errorNoCustomization();
+    }
+    const schemaOut = getCpSchemaOutputPath(basePath);
+    let cleanup;
+    if (merge) {
+      const { mergeDir } = merge;
+      cleanup = () => cleanupMyAccountMergeDir(mergeDir);
+      process.once("exit", cleanup);
+    }
+    try {
+      generateAndUploadSchema({
+        basePath,
+        dirs,
+        schemaOut,
+        dryRun: dryRun ?? false
+      });
+    } finally {
+      if (cleanup) {
+        process.removeListener("exit", cleanup);
+        cleanup();
+      }
+    }
+  }
 };
 
 // src/commands/create.ts
@@ -1412,12 +1714,12 @@ var Create = class _Create extends Command3 {
 
 // src/commands/dev.ts
 import { Args as Args4, Command as Command4, Flags as Flags3 } from "@oclif/core";
-import chalk6 from "chalk";
+import chalk10 from "chalk";
 import { spawn as spawn2, spawnSync as spawnSync3 } from "child_process";
 import chokidar from "chokidar";
 import dotenv from "dotenv";
-import { cpSync, existsSync as existsSync7, readFileSync as readFileSync3 } from "fs";
-import path8 from "path";
+import { cpSync as cpSync2, existsSync as existsSync10, readFileSync as readFileSync3 } from "fs";
+import path10 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 var stabilityThreshold = process.platform === "darwin" ? 100 : 200;
 var defaultPatterns = ["*/**", "**"];
@@ -1437,13 +1739,13 @@ var defaultNodeModulesIgnoredExceptVtexPackages = [
 var devAbortController = new AbortController();
 async function storeDev(rootDir, tmpDir, coreDir, port) {
   let envVars = {};
-  const vtexEnvPath = path8.join(rootDir, "vtex.env");
-  if (existsSync7(vtexEnvPath)) {
+  const vtexEnvPath = path10.join(rootDir, "vtex.env");
+  if (existsSync10(vtexEnvPath)) {
     try {
       envVars = dotenv.parse(readFileSync3(vtexEnvPath));
     } catch (err) {
       logger.log(
-        `${chalk6.yellow("warn")} - Error parsing vtex.env file: ${err}`
+        `${chalk10.yellow("warn")} - Error parsing vtex.env file: ${err}`
       );
     }
   }
@@ -1455,15 +1757,15 @@ async function storeDev(rootDir, tmpDir, coreDir, port) {
     cwd: tmpDir
   });
   const { success } = copyGenerated(
-    path8.join(tmpDir, "@generated"),
-    path8.join(coreDir, "@generated")
+    path10.join(tmpDir, "@generated"),
+    path10.join(coreDir, "@generated")
   );
   if (!success) {
     logger.log(
-      `${chalk6.yellow("warn")} - Failed to copy @generated schema back to node_modules, autocomplete and DX might be impacted.`
+      `${chalk10.yellow("warn")} - Failed to copy @generated schema back to node_modules, autocomplete and DX might be impacted.`
     );
     logger.log(
-      `Attempted to copy from ${path8.join(tmpDir, "@generated")} to ${path8.join(coreDir, "@generated")}`
+      `Attempted to copy from ${path10.join(tmpDir, "@generated")} to ${path10.join(coreDir, "@generated")}`
     );
   }
   const devProcess = spawn2(`${packageManager} dev-only --port ${port}`, {
@@ -1495,7 +1797,7 @@ async function storeDev(rootDir, tmpDir, coreDir, port) {
 }
 function copyGenerated(from, to) {
   try {
-    cpSync(from, to, { recursive: true, force: true, dereference: true });
+    cpSync2(from, to, { recursive: true, force: true, dereference: true });
     return { success: true };
   } catch (err) {
     return { success: false };
@@ -1580,13 +1882,13 @@ var Dev = class _Dev extends Command4 {
 
 // src/commands/generate.ts
 import { Args as Args5, Command as Command5 } from "@oclif/core";
-import chalk7 from "chalk";
+import chalk11 from "chalk";
 
 // src/utils/file.ts
 import fs3 from "fs";
-import path9 from "path";
+import path11 from "path";
 function saveFile(fileLocation) {
-  fs3.mkdirSync(path9.dirname(fileLocation), { recursive: true });
+  fs3.mkdirSync(path11.dirname(fileLocation), { recursive: true });
   return (content) => {
     fs3.writeFileSync(fileLocation, content);
   };
@@ -1600,17 +1902,17 @@ import {
 import { mergeTypeDefs } from "@graphql-tools/merge";
 import { printSchemaWithDirectives } from "@graphql-tools/utils";
 import { buildASTSchema, Kind, parse } from "graphql";
-import fs4, { existsSync as existsSync8 } from "fs";
-import path10 from "path";
+import fs4, { existsSync as existsSync11 } from "fs";
+import path12 from "path";
 var schemaFileName = "schema.graphql";
 async function genTsTypes(at) {
   await generateSchemaFile(at);
   generateSchemaTSTypes(at);
 }
 function generateSchemaTSTypes(root) {
-  let finalRootPath = path10.resolve(root);
-  if (existsSync8(path10.resolve(root, ".faststore"))) {
-    finalRootPath = path10.resolve(root, ".faststore");
+  let finalRootPath = path12.resolve(root);
+  if (existsSync11(path12.resolve(root, ".faststore"))) {
+    finalRootPath = path12.resolve(root, ".faststore");
   }
   const documents = [`${finalRootPath}/src/**/*.{ts,tsx}`];
   const config = {
@@ -1619,7 +1921,7 @@ function generateSchemaTSTypes(root) {
     errorsOnly: false,
     debug: false,
     verbose: true,
-    schema: path10.resolve(finalRootPath, "@generated", schemaFileName),
+    schema: path12.resolve(finalRootPath, "@generated", schemaFileName),
     generates: {
       [`${finalRootPath}/@generated/`]: {
         preset: "client",
@@ -1670,7 +1972,7 @@ function getOperationName(document) {
 async function generateSchemaFile(rootPath) {
   const faststoreSchema = printSchemaWithDirectives(GraphqlVtexSchema());
   const getMergedSchema = async () => {
-    const root = path10.join(
+    const root = path12.join(
       rootPath.endsWith(".faststore") ? [rootPath, ".."].join("/") : rootPath
     );
     const customizations = [
@@ -1689,9 +1991,9 @@ async function generateSchemaFile(rootPath) {
       throw e;
     }
   };
-  let pathToSave = path10.resolve(rootPath, "@generated", schemaFileName);
-  if (existsSync8(path10.resolve(rootPath, ".faststore"))) {
-    pathToSave = path10.resolve(
+  let pathToSave = path12.resolve(rootPath, "@generated", schemaFileName);
+  if (existsSync11(path12.resolve(rootPath, ".faststore"))) {
+    pathToSave = path12.resolve(
       rootPath,
       ".faststore",
       "@generated",
@@ -1706,7 +2008,7 @@ async function getTypeDefsFromFolder(root, customPath) {
   const globby = await import("globby");
   const basePath = [root, "src", "graphql"];
   const pathArray = Array.isArray(customPath) ? customPath : [customPath];
-  return (globby.default ?? globby).globbySync(path10.join(...[...basePath, ...pathArray]), {
+  return (globby.default ?? globby).globbySync(path12.join(...[...basePath, ...pathArray]), {
     expandDirectories: {
       extensions: ["graphql"]
     }
@@ -1732,7 +2034,7 @@ var Generate = class _Generate extends Command5 {
     await generate({ setup: true, basePath });
     genTsTypes(args.path ?? tmpDir);
     logger.log(
-      `${chalk7.green(
+      `${chalk11.green(
         "success"
       )} - GraphQL schema, types, and optimizations successfully generated \u{1F389}`
     );
@@ -1742,7 +2044,7 @@ var Generate = class _Generate extends Command5 {
 // src/commands/prepare.ts
 import { Args as Args6, Command as Command6 } from "@oclif/core";
 import fs5 from "fs";
-import path11 from "path";
+import path13 from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 var Prepare = class _Prepare extends Command6 {
   static args = {
@@ -1754,10 +2056,10 @@ var Prepare = class _Prepare extends Command6 {
   async run() {
     const { args } = await this.parse(_Prepare);
     const basePath = getBasePath(args.path);
-    const clientPublicDir = path11.join(basePath, "public/");
-    const corePublicDir = path11.resolve(
+    const clientPublicDir = path13.join(basePath, "public/");
+    const corePublicDir = path13.resolve(
       fileURLToPath4(
-        path11.dirname(import.meta.resolve("@faststore/core", import.meta.url))
+        path13.dirname(import.meta.resolve("@faststore/core", import.meta.url))
       ),
       "public"
     );
@@ -1773,8 +2075,8 @@ function copyFolder(sourceDir, targetDir) {
   }
   const files = fs5.readdirSync(sourceDir);
   for (const file of files) {
-    const sourcePath = path11.join(sourceDir, file);
-    const targetPath = path11.join(targetDir, file);
+    const sourcePath = path13.join(sourceDir, file);
+    const targetPath = path13.join(targetDir, file);
     const stat = fs5.statSync(sourcePath);
     if (stat.isFile()) {
       fs5.copyFileSync(sourcePath, targetPath);
@@ -1789,8 +2091,8 @@ function copyFolder(sourceDir, targetDir) {
 import { Args as Args7, Command as Command7 } from "@oclif/core";
 import { spawn as spawn3, spawnSync as spawnSync4 } from "child_process";
 import fsExtra6 from "fs-extra";
-import path12 from "path";
-var { existsSync: existsSync9 } = fsExtra6;
+import path14 from "path";
+var { existsSync: existsSync12 } = fsExtra6;
 var Start = class _Start extends Command7 {
   static args = {
     account: Args7.string({
@@ -1809,7 +2111,7 @@ var Start = class _Start extends Command7 {
     const port = args.port ?? 3e3;
     const { getRoot, tmpDir } = withBasePath(basePath);
     const packageManager = await getPreferredPackageManager();
-    if (!existsSync9(path12.join(getRoot(), ".next"))) {
+    if (!existsSync12(path14.join(getRoot(), ".next"))) {
       spawnSync4(`${packageManager} faststore build`, {
         shell: true,
         stdio: "inherit"
@@ -1892,9 +2194,9 @@ var Test = class _Test extends Command8 {
 };
 
 // src/commands/generate-types.ts
-import path13 from "path";
+import path15 from "path";
 import { Args as Args9, Command as Command9 } from "@oclif/core";
-import chalk8 from "chalk";
+import chalk12 from "chalk";
 var Generate2 = class _Generate extends Command9 {
   static hidden = true;
   static flags = {};
@@ -1908,10 +2210,10 @@ var Generate2 = class _Generate extends Command9 {
   async run() {
     const { args } = await this.parse(_Generate);
     await genTsTypes(
-      path13.isAbsolute(args.path) ? args.path : path13.resolve(process.env.PWD ?? process.cwd(), args.path)
+      path15.isAbsolute(args.path) ? args.path : path15.resolve(process.env.PWD ?? process.cwd(), args.path)
     );
     logger.log(
-      `${chalk8.green(
+      `${chalk12.green(
         "success"
       )} - GraphQL schema, types, and optimizations successfully generated \u{1F389}`
     );
@@ -1920,14 +2222,14 @@ var Generate2 = class _Generate extends Command9 {
 
 // src/commands/cache-graphql.ts
 import { Args as Args10, Command as Command10, Flags as Flags4 } from "@oclif/core";
-import chalk9 from "chalk";
+import chalk13 from "chalk";
 import fsExtra7 from "fs-extra";
 import graphql from "graphql";
-import path14 from "path";
-import { pathToFileURL as pathToFileURL7 } from "url";
+import path16 from "path";
+import { pathToFileURL as pathToFileURL8 } from "url";
 var { Kind: Kind2, OperationTypeNode, parse: parseGraphql } = graphql;
 var persistedDocumentsName = "persisted-documents.json";
-var configFileName = "discovery.config.default.js";
+var configFileName2 = "discovery.config.default.js";
 var cachedOperationsFileName = "cached-operations.json";
 var CacheGraphql = class _CacheGraphql extends Command10 {
   static flags = {
@@ -1949,15 +2251,15 @@ var CacheGraphql = class _CacheGraphql extends Command10 {
   async run() {
     const { args, flags } = await this.parse(_CacheGraphql);
     const rootPath = getBasePath();
-    const argPath = args?.store && path14.resolve(rootPath, args.store) || rootPath;
+    const argPath = args?.store && path16.resolve(rootPath, args.store) || rootPath;
     const { tmpDir } = withBasePath(argPath);
-    const configPath = this.getConfigFile(flags.config && path14.resolve(argPath, flags.config)) || this.getConfigFile(tmpDir) || this.getConfigFile(argPath);
+    const configPath = this.getConfigFile(flags.config && path16.resolve(argPath, flags.config)) || this.getConfigFile(tmpDir) || this.getConfigFile(argPath);
     const persistedDocumentsPath = this.getPersistedDocument(
-      flags?.queries && path14.resolve(argPath, flags?.queries) || argPath
+      flags?.queries && path16.resolve(argPath, flags?.queries) || argPath
     ) || this.getPersistedDocument(tmpDir);
     if (!configPath) {
       return this.errorFileNotFound(
-        configFileName,
+        configFileName2,
         `
     ${tmpDir}
     ${argPath}`
@@ -1969,28 +2271,28 @@ var CacheGraphql = class _CacheGraphql extends Command10 {
         flags?.queries ?? argPath
       );
     }
-    const cachedOperationsPath = path14.join(
-      path14.dirname(persistedDocumentsPath),
+    const cachedOperationsPath = path16.join(
+      path16.dirname(persistedDocumentsPath),
       cachedOperationsFileName
     );
     const saveCachedOperationsFile = saveFile(cachedOperationsPath);
     if (fsExtra7.pathExistsSync(tmpDir))
-      logger.info(`${chalk9.blue("[Info]")} - .faststore Path at: ${tmpDir}`);
-    logger.info(`${chalk9.blue("[Info]")} - Config file location: ${configPath}`);
+      logger.info(`${chalk13.blue("[Info]")} - .faststore Path at: ${tmpDir}`);
+    logger.info(`${chalk13.blue("[Info]")} - Config file location: ${configPath}`);
     logger.info(
-      `${chalk9.blue("[Info]")} - Persisted documents at: ${persistedDocumentsPath}`
+      `${chalk13.blue("[Info]")} - Persisted documents at: ${persistedDocumentsPath}`
     );
     logger.info(
-      `${chalk9.blue("[Info]")} - Cached operations output: ${cachedOperationsPath}`
+      `${chalk13.blue("[Info]")} - Cached operations output: ${cachedOperationsPath}`
     );
-    const { default: persistedDocuments } = await import(pathToFileURL7(persistedDocumentsPath).href, { with: { type: "json" } });
+    const { default: persistedDocuments } = await import(pathToFileURL8(persistedDocumentsPath).href, { with: { type: "json" } });
     const cachedQueries = getQueries(persistedDocuments);
     saveCachedOperationsFile(
       `${JSON.stringify(cachedQueries ?? [], null, 2)}
 `
     );
     logger.info(
-      `${chalk9.green("[Success]")} - GraphQL queries cached with success: \u{1F389}
+      `${chalk13.green("[Success]")} - GraphQL queries cached with success: \u{1F389}
       Queries: ${cachedQueries.join(", ")}`
     );
   }
@@ -2001,7 +2303,7 @@ var CacheGraphql = class _CacheGraphql extends Command10 {
     ])(rootPath);
   }
   getConfigFile(rootPath) {
-    return this.getFile(configFileName, [configFileName])(rootPath);
+    return this.getFile(configFileName2, [configFileName2])(rootPath);
   }
   getFile(fileName, pathFromRoot) {
     return (rootPath) => {
@@ -2010,11 +2312,11 @@ var CacheGraphql = class _CacheGraphql extends Command10 {
           return;
         case (rootPath?.endsWith(fileName) && fsExtra7.existsSync(rootPath)):
           return rootPath;
-        case fsExtra7.existsSync(path14.join(rootPath ?? "", fileName)):
-          return path14.join(rootPath, fileName);
+        case fsExtra7.existsSync(path16.join(rootPath ?? "", fileName)):
+          return path16.join(rootPath, fileName);
         default:
           if (!pathFromRoot) return;
-          const filePath = path14.join(
+          const filePath = path16.join(
             rootPath,
             ...Array.isArray(pathFromRoot) ? pathFromRoot : [pathFromRoot]
           );
@@ -2027,7 +2329,7 @@ var CacheGraphql = class _CacheGraphql extends Command10 {
   }
   errorFileNotFound(fileName, rootDir) {
     logger.error(
-      `${chalk9.red("[Error]")} - Couldn't find ${fileName} at ${rootDir}`
+      `${chalk13.red("[Error]")} - Couldn't find ${fileName} at ${rootDir}`
     );
     process.exit(1);
   }
@@ -2058,75 +2360,12 @@ var getQueries = (persistedDocuments) => {
 // src/commands/generate-i18n.ts
 import { Args as Args11, Command as Command11, Flags as Flags5 } from "@oclif/core";
 import { FastStoreSDK } from "@vtex/faststore-sdk";
-import chalk11 from "chalk";
+import chalk14 from "chalk";
 import dotenv2 from "dotenv";
 import fsExtra8 from "fs-extra";
-import { existsSync as existsSync11 } from "fs";
-import path16 from "path";
+import { existsSync as existsSync13 } from "fs";
+import path17 from "path";
 import { format } from "prettier";
-
-// src/utils/config.ts
-import chalk10 from "chalk";
-import { existsSync as existsSync10 } from "fs";
-import path15 from "path";
-import { pathToFileURL as pathToFileURL8 } from "url";
-var configFileName2 = "discovery.config.js";
-async function getDiscoveryConfig(basePath) {
-  const { tmpDir } = withBasePath(basePath);
-  const configPaths = [
-    path15.join(tmpDir, configFileName2),
-    path15.join(basePath, configFileName2)
-  ];
-  for (const configPath of configPaths) {
-    if (existsSync10(configPath)) {
-      try {
-        const discoveryConfig = await import(pathToFileURL8(configPath).href);
-        return discoveryConfig?.default ?? discoveryConfig;
-      } catch (error) {
-        logger.warn(
-          `${chalk10.yellow("warning")} - Could not read config file: ${configPath}.`
-        );
-      }
-    }
-  }
-  return null;
-}
-function isLocalizationEnabled(config) {
-  return config?.localization?.enabled === true;
-}
-function validateContentSourceForLocalization(config) {
-  if (!isLocalizationEnabled(config)) {
-    return;
-  }
-  const currentContentSourceType = config?.contentSource?.type?.toUpperCase();
-  if (currentContentSourceType !== "CP") {
-    logger.error(
-      `
-${chalk10.red("[Error]")} - Localization is enabled but contentSource is set to "${currentContentSourceType}".
-
-${chalk10.cyan("Required Action:")}
-Update your ${chalk10.bold("discovery.config.js")} file:
-
-  contentSource: {
-    type: ${chalk10.green('"CP"')}
-  },
-
-${chalk10.dim("When localization is enabled, Content Platform (CP) is required.")}
-`
-    );
-    process.exit(1);
-  }
-}
-async function checkAndValidateLocalization(basePath) {
-  const config = await getDiscoveryConfig(basePath);
-  if (!config) {
-    return false;
-  }
-  validateContentSourceForLocalization(config);
-  return isLocalizationEnabled(config);
-}
-
-// src/commands/generate-i18n.ts
 import { pathToFileURL as pathToFileURL9 } from "url";
 var configFileName3 = "discovery.config.default.js";
 var GenerateI18n = class _GenerateI18n extends Command11 {
@@ -2153,11 +2392,11 @@ var GenerateI18n = class _GenerateI18n extends Command11 {
           return;
         case (rootPath?.endsWith(fileName) && fsExtra8.existsSync(rootPath)):
           return rootPath;
-        case fsExtra8.existsSync(path16.join(rootPath ?? "", fileName)):
-          return path16.join(rootPath, fileName);
+        case fsExtra8.existsSync(path17.join(rootPath ?? "", fileName)):
+          return path17.join(rootPath, fileName);
         default:
           if (!pathFromRoot) return;
-          const filePath = path16.join(
+          const filePath = path17.join(
             rootPath,
             ...Array.isArray(pathFromRoot) ? pathFromRoot : [pathFromRoot]
           );
@@ -2170,37 +2409,37 @@ var GenerateI18n = class _GenerateI18n extends Command11 {
   }
   errorFileNotFound(fileName, rootDir) {
     logger.error(
-      `${chalk11.red("[Error]")} - Couldn't find ${fileName} at ${rootDir}`
+      `${chalk14.red("[Error]")} - Couldn't find ${fileName} at ${rootDir}`
     );
     process.exit(1);
   }
   async run() {
     const { args, flags } = await this.parse(_GenerateI18n);
     const rootPath = getBasePath();
-    const argPath = args?.path && path16.resolve(rootPath, args.path) || rootPath;
+    const argPath = args?.path && path17.resolve(rootPath, args.path) || rootPath;
     const localizationEnabled = await checkAndValidateLocalization(argPath);
     if (!localizationEnabled) {
       return;
     }
-    const vtexEnvPath = path16.join(argPath, "vtex.env");
-    if (existsSync11(vtexEnvPath)) {
+    const vtexEnvPath = path17.join(argPath, "vtex.env");
+    if (existsSync13(vtexEnvPath)) {
       dotenv2.config({ path: vtexEnvPath });
     }
     const { VTEX_ACCOUNT, FS_DISCOVERY_APP_KEY, FS_DISCOVERY_APP_TOKEN } = process.env;
     const hasCredentials = VTEX_ACCOUNT && FS_DISCOVERY_APP_KEY && FS_DISCOVERY_APP_TOKEN;
     if (!hasCredentials) {
-      logger.error(`${chalk11.red("[Error]")} - Missing VTEX credentials.
+      logger.error(`${chalk14.red("[Error]")} - Missing VTEX credentials.
 
-      ${chalk11.cyan("Required Action:")}
+      ${chalk14.cyan("Required Action:")}
 
-      Check your FastStore WebOps Settings page - to work in production, it should contain the following variables: ${chalk11.cyan("VTEX_ACCOUNT")}, ${chalk11.cyan("FS_DISCOVERY_APP_KEY")}, ${chalk11.cyan("FS_DISCOVERY_APP_TOKEN")}.
+      Check your FastStore WebOps Settings page - to work in production, it should contain the following variables: ${chalk14.cyan("VTEX_ACCOUNT")}, ${chalk14.cyan("FS_DISCOVERY_APP_KEY")}, ${chalk14.cyan("FS_DISCOVERY_APP_TOKEN")}.
 
-      If running locally, please check your ${chalk11.bold("vtex.env")} file, it should also contain those variables.
+      If running locally, please check your ${chalk14.bold("vtex.env")} file, it should also contain those variables.
       `);
       process.exit(1);
     }
     const { tmpDir } = withBasePath(argPath);
-    const configPath = this.getConfigFile(flags.config && path16.resolve(argPath, flags.config)) || this.getConfigFile(tmpDir) || this.getConfigFile(argPath);
+    const configPath = this.getConfigFile(flags.config && path17.resolve(argPath, flags.config)) || this.getConfigFile(tmpDir) || this.getConfigFile(argPath);
     if (!configPath) {
       return this.errorFileNotFound(
         configFileName3,
@@ -2211,8 +2450,8 @@ var GenerateI18n = class _GenerateI18n extends Command11 {
     }
     const saveConfigFile = saveFile(configPath);
     if (fsExtra8.pathExistsSync(tmpDir))
-      logger.info(`${chalk11.blue("[Info]")} - .faststore Path at: ${tmpDir}`);
-    logger.info(`${chalk11.blue("[Info]")} - Config file location: ${configPath}`);
+      logger.info(`${chalk14.blue("[Info]")} - .faststore Path at: ${tmpDir}`);
+    logger.info(`${chalk14.blue("[Info]")} - Config file location: ${configPath}`);
     const discoveryConfig = await import(pathToFileURL9(configPath).href);
     const faststore = new FastStoreSDK({
       account: VTEX_ACCOUNT,
@@ -2241,7 +2480,7 @@ var GenerateI18n = class _GenerateI18n extends Command11 {
       )
     );
     logger.info(
-      `${chalk11.green("success")} - i18n configuration successfully generated \u{1F389}`
+      `${chalk14.green("success")} - i18n configuration successfully generated \u{1F389}`
     );
   }
 };