@slicemachine/init 0.1.1-dev-plugins-validation.0 → 0.1.1-dev-plugins-m2-validation.0

package/dist/SliceMachineInitProcess.js

@@ -0,0 +1,721 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import chalk from "chalk";
+import open from "open";
+import logSymbols from "log-symbols";
+import { globby } from './_node_modules/globby/index.js';
+import { createSliceMachineManager } from "@slicemachine/manager";
+import pkg from "./packages/init/package.json.js";
+import { detectFramework } from "./lib/framework.js";
+import { getRunScriptCommand } from "./lib/getRunScriptCommand.js";
+import { getExecuteCommand } from "./lib/getExecuteCommand.js";
+import { formatRepositoryDomain, validateRepositoryDomainAndAvailability, getErrorMessageForRepositoryDomainValidation, getRandomRepositoryDomain, validateRepositoryDomain } from "./lib/repositoryDomain.js";
+import { listrRun, listr } from "./lib/listr.js";
+import { prompt } from "./lib/prompt.js";
+import { assertExists } from "./lib/assertExists.js";
+import { START_SCRIPT_KEY, START_SCRIPT_VALUE } from "./constants.js";
+const DEFAULT_OPTIONS = {
+  push: true,
+  pushSlices: true,
+  pushCustomTypes: true,
+  pushDocuments: true
+};
+const createSliceMachineInitProcess = (options) => {
+  return new SliceMachineInitProcess(options);
+};
+class SliceMachineInitProcess {
+  constructor(options) {
+    __publicField(this, "options");
+    __publicField(this, "manager");
+    __publicField(this, "context");
+    __publicField(this, "trackError", (error) => {
+      var _a, _b;
+      const safeError = (error instanceof Error ? error.message : `${error}`).slice(0, 512);
+      return this.manager.telemetry.track({
+        event: "command:init:end",
+        framework: ((_a = this.context.framework) == null ? void 0 : _a.prismicName) ?? "unknown",
+        repository: (_b = this.context.repository) == null ? void 0 : _b.domain,
+        success: false,
+        error: safeError
+      });
+    });
+    this.options = { ...DEFAULT_OPTIONS, ...options };
+    this.manager = createSliceMachineManager({ cwd: options == null ? void 0 : options.cwd });
+    this.context = {};
+  }
+  async run() {
+    var _a;
+    console.log(`
+${chalk.bgGray(` ${chalk.bold.white("Slice Machine")} `)} ${chalk.dim("→")} Init command started
+`);
+    if (await this.manager.telemetry.checkIsTelemetryEnabled()) {
+      console.log(`${logSymbols.info} We collect telemetry data to improve user experience.
+  Learn more: ${chalk.cyan("https://prismic.dev/slice-machine/telemetry")}
+`);
+    }
+    await this.manager.telemetry.initTelemetry({
+      appName: pkg.name,
+      appVersion: pkg.version
+    });
+    await this.manager.telemetry.track({
+      event: "command:init:start",
+      repository: this.options.repository
+    });
+    try {
+      await this.detectEnvironment();
+      assertExists(this.context.framework, "Project framework must be available through context to proceed");
+      await this.beginCoreDependenciesInstallation();
+      await this.loginAndFetchUserData();
+      if (this.options.repository) {
+        await this.useRepositoryFlag();
+      } else {
+        await this.selectRepository();
+      }
+      assertExists(this.context.repository, "Repository selection must be available through context to proceed");
+      if (!this.context.repository.exists) {
+        await this.createNewRepository();
+      }
+      await this.finishCoreDependenciesInstallation();
+      await this.upsertSliceMachineConfigurationAndStartPluginRunner();
+      await this.pushDataToPrismic();
+      await this.initializeProject();
+      await this.initializePlugins();
+    } catch (error) {
+      await this.trackError(error);
+      throw error;
+    }
+    await this.manager.telemetry.track({
+      event: "command:init:end",
+      framework: this.context.framework.prismicName,
+      repository: this.context.repository.domain,
+      success: true
+    });
+    console.log(`
+${chalk.bgGreen(` ${chalk.bold.white("Slice Machine")} `)} ${chalk.dim("→")} Init command successful!`);
+    try {
+      const apiEndpoints = this.manager.getAPIEndpoints();
+      const wroomHost = new URL(apiEndpoints.PrismicWroom).host;
+      const dashboardURL = new URL(`https://${this.context.repository.domain}.${wroomHost}`).toString().replace(/\/$/, "");
+      const apiURL = new URL("./api/v2", `https://${this.context.repository.domain}.cdn.${wroomHost}`).toString();
+      console.log(`
+  YOUR REPOSITORY
+    Dashboard            ${chalk.cyan(dashboardURL)}
+    API                  ${chalk.cyan(apiURL)}
+
+  RESOURCES
+    Documentation        ${chalk.cyan(this.context.framework.prismicDocumentation)}
+    Getting help         ${chalk.cyan("https://community.prismic.io")}
+
+  GETTING STARTED
+    Start Slice Machine  ${chalk.cyan(((_a = this.context.projectInitialization) == null ? void 0 : _a.patchedScript) ? await getRunScriptCommand({
+        agent: this.context.packageManager || "npm",
+        script: "slicemachine"
+      }) : await getExecuteCommand({
+        agent: this.context.packageManager || "npm",
+        script: "start-slicemachine"
+      }))}`);
+    } catch {
+    }
+  }
+  detectEnvironment() {
+    return listrRun([
+      {
+        title: "Detecting environment...",
+        task: (_, parentTask) => listr([
+          {
+            title: "Detecting framework...",
+            task: async (_2, task) => {
+              this.context.framework = await detectFramework(this.manager.cwd);
+              task.title = `Detected framework ${chalk.cyan(this.context.framework.name)}`;
+            }
+          },
+          {
+            title: "Detecting package manager...",
+            task: async (_2, task) => {
+              this.context.packageManager = await this.manager.project.detectPackageManager({
+                root: this.manager.cwd
+              });
+              task.title = `Detected package manager ${chalk.cyan(this.context.packageManager)}`;
+              assertExists(this.context.framework, "Project framework must be available through context to proceed");
+              parentTask.title = `Detected framework ${chalk.cyan(this.context.framework.name)} and package manager ${chalk.cyan(this.context.packageManager)}`;
+            }
+          }
+        ])
+      }
+    ]);
+  }
+  beginCoreDependenciesInstallation() {
+    return listrRun([
+      {
+        title: "Beginning core dependencies installation...",
+        task: async (_, task) => {
+          assertExists(this.context.packageManager, "Project package manager must be available through context to run `beginCoreDependenciesInstallation`");
+          assertExists(this.context.framework, "Project framework must be available through context to run `beginCoreDependenciesInstallation`");
+          const { execaProcess } = await this.manager.project.installDependencies({
+            packageManager: this.context.packageManager,
+            dependencies: this.context.framework.devDependencies,
+            dev: true,
+            // Picked up later
+            log: () => {
+            }
+          });
+          execaProcess.catch(async (error) => {
+            const [_2, ...argv1n] = process.argv;
+            let tryAgainCommand = [process.argv0, ...argv1n].join(" ");
+            if (!this.options.repository && this.context.repository) {
+              tryAgainCommand = `${tryAgainCommand} --repository=${this.context.repository.domain}`;
+            }
+            await this.trackError(error.shortMessage);
+            console.error(`
+
+${error.shortMessage}
+${error.stderr}
+
+${logSymbols.error} Dependency installation failed, try again with:
+
+  ${chalk.gray("$")} ${chalk.cyan(tryAgainCommand)}`);
+            process.exit(1);
+          });
+          this.context.installProcess = execaProcess;
+          task.title = `Began core dependencies installation with ${chalk.cyan(this.context.packageManager)} ... (running in background)`;
+        }
+      }
+    ]);
+  }
+  loginAndFetchUserData() {
+    return listrRun([
+      {
+        title: "Logging in to Prismic...",
+        task: async (_, parentTask) => {
+          parentTask.output = "Validating session...";
+          const isLoggedIn = await this.manager.user.checkIsLoggedIn();
+          if (!isLoggedIn) {
+            parentTask.output = "Press any key to open the browser to login...";
+            await new Promise((resolve) => {
+              var _a, _b;
+              const initialRawMode = !!process.stdin.isRaw;
+              (_b = (_a = process.stdin).setRawMode) == null ? void 0 : _b.call(_a, true);
+              process.stdin.once("data", (data) => {
+                var _a2, _b2;
+                (_b2 = (_a2 = process.stdin).setRawMode) == null ? void 0 : _b2.call(_a2, initialRawMode);
+                process.stdin.pause();
+                resolve(data.toString("utf-8"));
+              });
+            });
+            parentTask.output = "Browser opened, waiting for you to login...";
+            const { port, url } = await this.manager.user.getLoginSessionInfo();
+            await this.manager.user.nodeLoginSession({
+              port,
+              onListenCallback() {
+                open(url);
+              }
+            });
+          }
+          parentTask.output = "";
+          parentTask.title = `Logged in`;
+          return listr([
+            {
+              title: "Fetching user profile...",
+              task: async (_2, task) => {
+                var _a;
+                this.context.userProfile = await this.manager.user.getProfile();
+                await this.manager.telemetry.identify({
+                  userID: this.context.userProfile.shortId,
+                  intercomHash: this.context.userProfile.intercomHash
+                });
+                await this.manager.telemetry.track({
+                  event: "command:init:identify",
+                  repository: this.options.repository
+                });
+                parentTask.title = `Logged in as ${chalk.cyan((_a = this.context.userProfile) == null ? void 0 : _a.email)}`;
+                task.title = "Fetched user profile";
+              }
+            },
+            {
+              title: "Fetching user repositories...",
+              task: async (_2, task) => {
+                this.context.userRepositories = await this.manager.prismicRepository.readAll();
+                task.title = "Fetched user repositories";
+              }
+            }
+          ], { concurrent: true });
+        }
+      }
+    ]);
+  }
+  useRepositoryFlag() {
+    return listrRun([
+      {
+        title: `Flag ${chalk.cyan("repository")} used, validating input...`,
+        task: async (_, task) => {
+          assertExists(this.context.userRepositories, "User repositories must be available through context to run `useRepositoryFlag`");
+          assertExists(this.options.repository, "Flag `repository` must be set to run `useRepositoryFlag`");
+          const domain = formatRepositoryDomain(this.options.repository);
+          const maybeRepository = this.context.userRepositories.find((repository) => repository.domain === domain);
+          if (maybeRepository) {
+            if (!this.manager.prismicRepository.hasWriteAccess(maybeRepository)) {
+              throw new Error(`Cannot run init command with repository ${chalk.cyan(maybeRepository.domain)}: you are not a developer or admin of this repository`);
+            }
+          } else {
+            const validation = await validateRepositoryDomainAndAvailability({
+              domain,
+              existsFn: (domain2) => this.manager.prismicRepository.checkExists({ domain: domain2 })
+            });
+            const errorMessage = getErrorMessageForRepositoryDomainValidation({
+              validation,
+              displayDomain: chalk.cyan(domain)
+            });
+            if (errorMessage) {
+              throw new Error(errorMessage);
+            }
+          }
+          task.title = `Selected repository ${chalk.cyan(domain)} (flag ${chalk.cyan("repository")} used)`;
+          this.context.repository = {
+            domain,
+            exists: !!maybeRepository
+          };
+        }
+      }
+    ]);
+  }
+  async selectRepository() {
+    assertExists(this.context.userRepositories, "User repositories must be available through context to run `selectRepository`");
+    if (this.context.userRepositories.length) {
+      await this.trySelectExistingRepository();
+    }
+    if (!this.context.repository) {
+      await this.selectNewRepository();
+    }
+    assertExists(this.context.repository, "Repository selection must be available through context to proceed");
+    console.log(`${logSymbols.success} Selected repository ${chalk.cyan(this.context.repository.domain)}`);
+  }
+  async trySelectExistingRepository() {
+    assertExists(this.context.userRepositories, "User repositories must be available through context to run `trySelectExistingRepository`");
+    const { maybeDomain } = await prompt({
+      type: "select",
+      name: "maybeDomain",
+      message: "Pick a repository to connect to or choose to create a new one",
+      warn: "You are not a developer or admin of this repository",
+      choices: [
+        {
+          title: "CREATE NEW",
+          description: "Create a new Prismic repository\n",
+          value: ""
+        },
+        ...this.context.userRepositories.map((repository) => {
+          const hasWriteAccess = this.manager.prismicRepository.hasWriteAccess(repository);
+          return {
+            title: `${repository.domain}${hasWriteAccess ? "" : " (Unauthorized)"}`,
+            description: `Connect to ${chalk.cyan(repository.domain)}`,
+            value: repository.domain,
+            disabled: !hasWriteAccess
+          };
+        }).sort((a, b) => a.value > b.value ? 1 : -1)
+      ]
+    });
+    if (maybeDomain) {
+      this.context.repository = {
+        domain: maybeDomain,
+        exists: true
+      };
+    }
+  }
+  async selectNewRepository() {
+    var _a, _b, _c, _d;
+    let suggestedName = "";
+    const trySuggestName = async (name) => {
+      if (name) {
+        const formattedName = formatRepositoryDomain(name);
+        if (!validateRepositoryDomain({ domain: formattedName }).hasErrors && !await this.manager.prismicRepository.checkExists({
+          domain: formattedName
+        })) {
+          return formattedName;
+        }
+      }
+    };
+    try {
+      const pkgJSONPath = path.join(this.manager.cwd, "package.json");
+      const pkg2 = JSON.parse(await fs.readFile(pkgJSONPath, "utf-8"));
+      const maybeSuggestion = await trySuggestName(pkg2.name);
+      if (maybeSuggestion) {
+        suggestedName = maybeSuggestion;
+      }
+    } catch {
+    }
+    if (!suggestedName) {
+      const maybeSuggestion = await trySuggestName(path.basename(this.manager.cwd));
+      if (maybeSuggestion) {
+        suggestedName = maybeSuggestion;
+      }
+    }
+    if (!suggestedName) {
+      do {
+        suggestedName = getRandomRepositoryDomain();
+      } while (await this.manager.prismicRepository.checkExists({
+        domain: suggestedName
+      }));
+    }
+    const { domain } = await prompt({
+      type: "text",
+      name: "domain",
+      // Overriden by the `onRender` function, just used as a fallback
+      message: "Choose a name for your Prismic repository",
+      initial: suggestedName,
+      onRender() {
+        const rawDomain = this.value || this.initial || "";
+        const domain2 = formatRepositoryDomain(rawDomain);
+        const validation = validateRepositoryDomain({ domain: domain2 });
+        const minRule = validation.LessThan4 ? chalk.red(`1. Name must be ${chalk.bold("4 characters long or more")}`) : `1. Name must be ${chalk.cyan("4 characters long or more")}`;
+        const maxRule = validation.MoreThan30 ? chalk.red(`1. Name must be ${chalk.bold("30 characters long or less")}`) : `1. Name must be ${chalk.cyan("30 characters long or less")}`;
+        this.msg = chalk.reset(`
+Choose a name for your Prismic repository
+
+  NAMING RULES
+    ${minRule}
+    ${maxRule}
+    3. Name will be ${chalk.cyan("kebab-cased")} automatically
+
+  CONSIDERATIONS
+    1. Once picked, your repository name ${chalk.cyan("cannot be changed")}
+    2. A ${chalk.cyan("display name")} for the repository can be configured later on
+
+  PREVIEW
+    Dashboard  ${chalk.cyan(`https://${domain2}.prismic.io`)}
+    API        ${chalk.cyan(`https://${domain2}.cdn.prismic.io/api/v2`)}
+
+${chalk.cyan("?")} Your Prismic repository name`.replace("\n", ""));
+      },
+      validate: async (rawDomain) => {
+        const domain2 = formatRepositoryDomain(rawDomain);
+        const validation = await validateRepositoryDomainAndAvailability({
+          domain: domain2,
+          existsFn: (domain3) => this.manager.prismicRepository.checkExists({ domain: domain3 })
+        });
+        const errorMessage = getErrorMessageForRepositoryDomainValidation({
+          validation,
+          displayDomain: chalk.cyan(domain2)
+        });
+        return errorMessage || true;
+      },
+      format: (value) => {
+        return formatRepositoryDomain(value);
+      }
+    });
+    (_b = (_a = process.stdout).moveCursor) == null ? void 0 : _b.call(_a, 0, -16);
+    (_d = (_c = process.stdout).clearScreenDown) == null ? void 0 : _d.call(_c);
+    this.context.repository = {
+      domain,
+      exists: false
+    };
+  }
+  createNewRepository() {
+    assertExists(this.context.repository, "Repository selection must be available through context to run `createNewRepository`");
+    return listrRun([
+      {
+        title: `Creating new repository ${chalk.cyan(this.context.repository.domain)} ...`,
+        task: async (_, task) => {
+          assertExists(this.context.repository, "Repository selection must be available through context to run `createNewRepository`");
+          assertExists(this.context.framework, "Project framework must be available through context to run `createNewRepository`");
+          await this.manager.prismicRepository.create({
+            domain: this.context.repository.domain,
+            framework: this.context.framework.prismicName
+          });
+          this.context.repository.exists = true;
+          task.title = `Created new repository ${chalk.cyan(this.context.repository.domain)}`;
+        }
+      }
+    ]);
+  }
+  finishCoreDependenciesInstallation() {
+    return listrRun([
+      {
+        title: `Finishing core dependencies installation with ${chalk.cyan(this.context.packageManager)} ...`,
+        task: async (_, task) => {
+          var _a, _b;
+          assertExists(this.context.installProcess, "Initial dependencies installation process must be available through context to run `finishCoreDependenciesInstallation`");
+          const updateOutput = (data) => {
+            if (data instanceof Buffer) {
+              task.output = data.toString();
+            }
+          };
+          if (process.stdout.isTTY || process.env.NODE_ENV === "test") {
+            (_a = this.context.installProcess.stdout) == null ? void 0 : _a.on("data", updateOutput);
+          }
+          (_b = this.context.installProcess.stderr) == null ? void 0 : _b.on("data", updateOutput);
+          try {
+            await this.context.installProcess;
+          } catch (error) {
+            await new Promise((resolve) => setTimeout(resolve, 5e3));
+            throw error;
+          }
+          task.title = `Installed core dependencies with ${chalk.cyan(this.context.packageManager)}`;
+        }
+      }
+    ]);
+  }
+  upsertSliceMachineConfigurationAndStartPluginRunner() {
+    return listrRun([
+      {
+        title: "Resolving Slice Machine configuration...",
+        task: async (_, parentTask) => {
+          assertExists(this.context.framework, "Project framework must be available through context to run `upsertSliceMachineConfiguration`");
+          assertExists(this.context.repository, "Repository selection must be available through context to run `upsertSliceMachineConfiguration`");
+          let sliceMachineConfigExists = false;
+          try {
+            await this.manager.project.getSliceMachineConfigPath();
+            sliceMachineConfigExists = true;
+          } catch {
+          }
+          if (sliceMachineConfigExists) {
+            parentTask.title = "Updating Slice Machine configuration...";
+            const config = await this.manager.project.getSliceMachineConfig();
+            await this.manager.project.writeSliceMachineConfig({
+              config: {
+                ...config,
+                repositoryName: this.context.repository.domain,
+                adapter: this.context.framework.adapterName
+              }
+            });
+            parentTask.title = "Updated Slice Machine configuration";
+          } else {
+            parentTask.title = "Creating Slice Machine configuration...";
+            const sliceMachineConfigPath = await this.manager.project.suggestSliceMachineConfigPath();
+            await this.manager.project.writeSliceMachineConfig({
+              config: {
+                repositoryName: this.context.repository.domain,
+                adapter: this.context.framework.adapterName,
+                libraries: ["./slices"]
+              },
+              path: sliceMachineConfigPath
+            });
+            parentTask.title = "Created Slice Machine configuration";
+          }
+          return listr([
+            {
+              title: "Starting plugin runner...",
+              task: async (_2, task) => {
+                await this.manager.plugins.initPlugins();
+                task.title = "Started plugin runner";
+                parentTask.title = `${parentTask.title} and started plugin runner`;
+              }
+            }
+          ]);
+        }
+      }
+    ]);
+  }
+  pushDataToPrismic() {
+    return listrRun([
+      {
+        title: "Pushing data to Prismic...",
+        task: (_, parentTask) => listr([
+          {
+            title: "Pushing slices...",
+            skip: () => {
+              if (!this.options.push) {
+                return `--no-push used`;
+              } else if (!this.options.pushSlices) {
+                return `--no-push-slices used`;
+              }
+            },
+            task: async (_2, task) => {
+              const { libraries, errors } = await this.manager.slices.readAllSliceLibraries();
+              if (errors.length > 0) {
+                throw new Error(`Failed to read slice libraries: ${errors.join(", ")}`);
+              }
+              const slices = [];
+              for (const library of libraries) {
+                if (library.sliceIDs) {
+                  for (const sliceID of library.sliceIDs) {
+                    slices.push({
+                      libraryID: library.libraryID,
+                      sliceID
+                    });
+                  }
+                }
+              }
+              if (slices.length === 0) {
+                task.skip("No slice to push");
+                return;
+              }
+              let pushed = 0;
+              task.title = `Pushing slices... (0/${slices.length})`;
+              await Promise.all(slices.map(async (slice) => {
+                await this.manager.slices.pushSlice(slice);
+                pushed++;
+                task.title = `Pushing slices... (${pushed}/${slices.length})`;
+              }));
+              task.title = "Pushed all slices";
+            }
+          },
+          {
+            title: "Pushing custom types...",
+            skip: () => {
+              if (!this.options.push) {
+                return `--no-push used`;
+              } else if (!this.options.pushCustomTypes) {
+                return `--no-push-custom-types used`;
+              }
+            },
+            task: async (_2, task) => {
+              const { ids, errors } = await this.manager.customTypes.readCustomTypeLibrary();
+              if (errors.length > 0) {
+                throw new Error(`Failed to read custom type libraries: ${errors.join(", ")}`);
+              }
+              if (!ids || ids.length === 0) {
+                task.skip("No custom type to push");
+                return;
+              }
+              let pushed = 0;
+              task.title = `Pushing custom types... (0/${ids.length})`;
+              await Promise.all(ids.map(async (id) => {
+                await this.manager.customTypes.pushCustomType({ id });
+                pushed++;
+                task.title = `Pushing custom types... (${pushed}/${ids.length})`;
+              }));
+              task.title = "Pushed all custom types";
+            }
+          },
+          {
+            title: "Pushing documents...",
+            skip: () => {
+              if (!this.options.push) {
+                return `--no-push used`;
+              } else if (!this.options.pushDocuments) {
+                return `--no-push-documents used`;
+              }
+            },
+            task: async (_2, task) => {
+              assertExists(this.context.repository, "Repository selection must be available through context to run `pushDataToPrismic`");
+              const root = await this.manager.project.getRoot();
+              const documentsDirectoryPath = path.resolve(root, "documents");
+              try {
+                await fs.access(documentsDirectoryPath);
+              } catch {
+                parentTask.title = "Pushed data to Prismic";
+                task.skip("No document to push");
+                return;
+              }
+              const signaturePath = path.resolve(documentsDirectoryPath, "index.json");
+              const rawSignature = await fs.readFile(signaturePath, "utf-8");
+              const signature = JSON.parse(rawSignature).signature;
+              const documentsGlob = await globby("*/*.json", {
+                cwd: documentsDirectoryPath
+              });
+              if (documentsGlob.length === 0) {
+                parentTask.title = "Pushed data to Prismic";
+                task.skip("No document to push");
+                return;
+              }
+              const documents = {};
+              await Promise.all(documentsGlob.map(async (documentPath) => {
+                const filename = path.basename(documentPath, ".json");
+                const fileContent = await fs.readFile(path.resolve(documentsDirectoryPath, documentPath), "utf-8");
+                try {
+                  const parsedContents = JSON.parse(fileContent);
+                  documents[filename] = parsedContents;
+                } catch {
+                  console.log(`Skipped document due to its invalid format: ${documentPath}`);
+                }
+              }));
+              await this.manager.prismicRepository.pushDocuments({
+                domain: this.context.repository.domain,
+                documents,
+                signature
+              });
+              task.title = "Pushed all documents";
+              parentTask.title = "Pushed data to Prismic";
+            }
+          },
+          {
+            title: "Cleaning up data push artifacts",
+            task: async (_2, task) => {
+              const root = await this.manager.project.getRoot();
+              const documentsDirectoryPath = path.resolve(root, "documents");
+              try {
+                await fs.rm(documentsDirectoryPath, {
+                  force: true,
+                  recursive: true
+                });
+              } catch {
+              }
+              task.title = "Cleaned up data push artifacts";
+              parentTask.title = "Pushed data to Prismic";
+            }
+          }
+        ])
+      }
+    ]);
+  }
+  initializeProject() {
+    return listrRun([
+      {
+        title: "Initializing project...",
+        task: async (_, parentTask) => (
+          // We return another Listr instance in the event we have additional task to perform to initialize the project
+          listr([
+            {
+              title: `Patching ${chalk.cyan("package.json")} scripts...`,
+              task: async (_2, task) => {
+                var _a, _b;
+                const pkgPath = path.join(this.manager.cwd, "package.json");
+                try {
+                  const pkgRaw = await fs.readFile(pkgPath, "utf-8");
+                  const pkg2 = JSON.parse(pkgRaw);
+                  pkg2.scripts || (pkg2.scripts = {});
+                  if (!pkg2.scripts[START_SCRIPT_KEY]) {
+                    pkg2.scripts[START_SCRIPT_KEY] = START_SCRIPT_VALUE;
+                    const firstIndent = pkgRaw.split("\n").find((line) => line.match(/^(?:( )+|\t+)/));
+                    const indent = (_a = firstIndent == null ? void 0 : firstIndent.match(/^(?:( )+|\t+)/)) == null ? void 0 : _a[0];
+                    await fs.writeFile(pkgPath, JSON.stringify(pkg2, null, indent && indent !== " " ? indent : "  "));
+                  } else if (!pkg2.scripts["slicemachine"].startsWith(START_SCRIPT_VALUE)) {
+                    throw new Error("Script already exists");
+                  }
+                } catch (error) {
+                  task.title = `Could not patch ${chalk.cyan("package.json")} scripts (warning)`;
+                  parentTask.title = `Initialized project (could not patch ${chalk.cyan("package.json")} scripts)`;
+                  return;
+                }
+                (_b = this.context).projectInitialization || (_b.projectInitialization = {});
+                this.context.projectInitialization.patchedScript = true;
+                task.title = `Patched ${chalk.cyan("package.json")} scripts`;
+                parentTask.title = `Initialized project (patched ${chalk.cyan("package.json")} scripts)`;
+              }
+            }
+          ])
+        )
+      }
+    ]);
+  }
+  initializePlugins() {
+    return listrRun([
+      {
+        title: "Initializing plugins...",
+        task: async (_, task) => {
+          const updateOutput = (data) => {
+            if (data instanceof Buffer) {
+              task.output = data.toString();
+            } else if (typeof data === "string") {
+              task.output = data;
+            }
+          };
+          await this.manager.project.initProject({
+            log: updateOutput
+          });
+          task.title = "Initialized plugins";
+        }
+      }
+    ]);
+  }
+}
+export {
+  SliceMachineInitProcess,
+  createSliceMachineInitProcess
+};
+//# sourceMappingURL=SliceMachineInitProcess.js.map