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

package/dist/SliceMachineInitProcess.js

@@ -1,742 +0,0 @@
-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 { detectFramework } from "./lib/framework.js";
-import { getRunScriptCommand, getExecuteCommand, installDependencies, detectPackageManager } from "./lib/packageManager.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
-`);
-    await this.manager.telemetry.initTelemetry();
-    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) => {
-              try {
-                this.context.packageManager = await detectPackageManager(this.options.cwd);
-              } catch (error) {
-                if (error instanceof Error && (error.message.match(/failed to detect/i) || error.message.match(/command failed/i))) {
-                  this.context.packageManager = "npm";
-                } else {
-                  throw error;
-                }
-              }
-              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 installDependencies({
-            agent: this.context.packageManager,
-            dependencies: this.context.framework.devDependencies,
-            dev: true
-          });
-          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 pkg = JSON.parse(await fs.readFile(pkgJSONPath, "utf-8"));
-      const maybeSuggestion = await trySuggestName(pkg.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: {
-                // TODO: Update _latest to a real value or make it optional
-                _latest: "legacy",
-                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 pkg = JSON.parse(pkgRaw);
-                pkg.scripts || (pkg.scripts = {});
-                if (!pkg.scripts[START_SCRIPT_KEY]) {
-                  pkg.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(pkg, null, indent && indent !== " " ? indent : "  "));
-                } else if (!pkg.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;
-            }
-          };
-          const { errors } = await this.manager.plugins.dangerouslyCallHook("command:init", {
-            log: updateOutput,
-            installDependencies: async (args) => {
-              var _a, _b;
-              assertExists(this.context.packageManager, "Project package manager must be available through context to run `initializePlugins`");
-              try {
-                const { execaProcess } = await installDependencies({
-                  ...args,
-                  agent: this.context.packageManager
-                });
-                if (process.stdout.isTTY || process.env.NODE_ENV === "test") {
-                  (_a = execaProcess.stdout) == null ? void 0 : _a.on("data", updateOutput);
-                }
-                (_b = execaProcess.stderr) == null ? void 0 : _b.on("data", updateOutput);
-                await execaProcess;
-              } catch (error) {
-                if (error instanceof Error && "shortMessage" in error && "stderr" in error) {
-                  throw new Error(`
-
-${error.shortMessage}
-${error.stderr}
-
-${logSymbols.error} Plugins dependency installation failed`, { cause: error });
-                }
-                throw error;
-              }
-            }
-          });
-          if (errors.length > 0) {
-            throw new Error(`Failed to initialize plugins: ${errors.join(", ")}`);
-          }
-          task.title = "Initialized plugins";
-        }
-      }
-    ]);
-  }
-}
-export {
-  SliceMachineInitProcess,
-  createSliceMachineInitProcess
-};
-//# sourceMappingURL=SliceMachineInitProcess.js.map