@slicemachine/init 1.1.4 → 1.1.5-alpha.11

package/build/index.js

@@ -3,14 +3,19 @@
 'use strict';
 
 const core = require('@slicemachine/core');
+const Prismic = require('@slicemachine/core/build/prismic');
 const ServerAnalytics = require('analytics-node');
 const uuid = require('uuid');
 const path = require('path');
 const util = require('util');
 const child_process = require('child_process');
+const chalk = require('chalk');
+const ora = require('ora');
+const hapi = require('@hapi/hapi');
+const open = require('open');
+const NodeUtils = require('@slicemachine/core/build/node-utils');
 const inquirer = require('inquirer');
 const Separator = require('inquirer/lib/objects/separator');
-const cookie = require('@slicemachine/core/build/src/utils/cookie');
 const axios = require('axios');
 const _function = require('fp-ts/function');
 const Either = require('fp-ts/Either');
@@ -18,9 +23,6 @@ const tmp = require('tmp');
 const AdmZip = require('adm-zip');
 const fsExtra = require('fs-extra');
 const fs = require('fs');
-const PackageJson = require('@slicemachine/core/build/src/utils/PackageJson');
-const Manifest = require('@slicemachine/core/build/src/models/Manifest');
-const Files = require('@slicemachine/core/build/src/utils/files');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -42,9 +44,16 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
+const Prismic__namespace = /*#__PURE__*/_interopNamespace(Prismic);
+const Prismic__default = /*#__PURE__*/_interopDefaultLegacy(Prismic);
 const ServerAnalytics__default = /*#__PURE__*/_interopDefaultLegacy(ServerAnalytics);
 const path__default = /*#__PURE__*/_interopDefaultLegacy(path);
 const util__default = /*#__PURE__*/_interopDefaultLegacy(util);
+const chalk__default = /*#__PURE__*/_interopDefaultLegacy(chalk);
+const ora__default = /*#__PURE__*/_interopDefaultLegacy(ora);
+const hapi__namespace = /*#__PURE__*/_interopNamespace(hapi);
+const open__default = /*#__PURE__*/_interopDefaultLegacy(open);
+const NodeUtils__namespace = /*#__PURE__*/_interopNamespace(NodeUtils);
 const inquirer__namespace = /*#__PURE__*/_interopNamespace(inquirer);
 const Separator__default = /*#__PURE__*/_interopDefaultLegacy(Separator);
 const axios__default = /*#__PURE__*/_interopDefaultLegacy(axios);
@@ -52,7 +61,6 @@ const tmp__default = /*#__PURE__*/_interopDefaultLegacy(tmp);
 const AdmZip__default = /*#__PURE__*/_interopDefaultLegacy(AdmZip);
 const fsExtra__default = /*#__PURE__*/_interopDefaultLegacy(fsExtra);
 const fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
-const Files__default = /*#__PURE__*/_interopDefaultLegacy(Files);
 
 var __accessCheck = (obj, member, msg) => {
   if (!member.has(obj))
@@ -129,8 +137,11 @@ class InitTracker {
   trackDownloadLibrary(library) {
     this._trackEvent("SliceMachine Download Library" /* DownloadLibrary */, { library });
   }
-  trackInitStart() {
-    this._trackEvent("SliceMachine Init Start" /* InitStart */);
+  trackInitIdentify(repoDomain) {
+    this._trackEvent("SliceMachine Init Identify" /* InitIdentify */, { repo: repoDomain });
+  }
+  trackInitStart(repoDomain) {
+    this._trackEvent("SliceMachine Init Start" /* InitStart */, { repo: repoDomain });
   }
   trackInitDone(framework, repoDomain) {
     this._trackEvent("SliceMachine Init Done" /* InitDone */, { framework, repo: repoDomain });
@@ -152,6 +163,193 @@ const Tracker = (() => {
   };
 })();
 
+const purple = chalk__default["default"].hex("8c76fc");
+const error = chalk__default["default"].hex("FF6868");
+const warning = chalk__default["default"].hex("F3AD38");
+const underline$1 = chalk__default["default"].underline;
+const bold$1 = chalk__default["default"].bold;
+const dim = chalk__default["default"].dim;
+const cyan = chalk__default["default"].cyan;
+const yellow = chalk__default["default"].yellow;
+const white = chalk__default["default"].white;
+const spinner$1 = ora__default["default"];
+const writeError$1 = (msg, prefix = "Error!") => console.error(`${error(prefix)} ${msg}`);
+const writeWarning = (msg, prefix = "Warning!") => console.warn(`${warning(prefix)} ${msg}`);
+const writeCheck = (msg) => {
+  ora__default["default"]().succeed(msg);
+};
+const writeInfo = (msg) => {
+  console.log(`${yellow("\u2139")} ${dim(msg)}`);
+};
+
+const logs = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  purple: purple,
+  error: error,
+  warning: warning,
+  underline: underline$1,
+  bold: bold$1,
+  dim: dim,
+  cyan: cyan,
+  yellow: yellow,
+  white: white,
+  spinner: spinner$1,
+  writeError: writeError$1,
+  writeWarning: writeWarning,
+  writeCheck: writeCheck,
+  writeInfo: writeInfo
+});
+
+const { Cookie } = core.Utils;
+const { DEFAULT_BASE: DEFAULT_BASE$1, DEFAULT_SERVER_PORT } = core.CONSTS;
+const { bold, underline, spinner, writeError } = logs;
+const isHandlerData = (data) => {
+  if (typeof data != "object")
+    return false;
+  const { email, cookies } = data;
+  return Boolean(email && cookies) && Array.isArray(cookies) && !cookies.some((c) => typeof c !== "string");
+};
+const Routes = {
+  authentication: (server) => (onSuccess, onFail) => ({
+    method: "POST",
+    path: "/",
+    handler: authenticationHandler(server)(onSuccess, onFail)
+  }),
+  notFound: {
+    method: ["GET", "POST"],
+    path: "/{any*}",
+    handler: (request, h) => {
+      return h.response(`not found: [${request.method}]: ${request.url.toString()}`).code(404);
+    }
+  }
+};
+function validatePayload(payload) {
+  if (Buffer.isBuffer(payload))
+    return null;
+  return isHandlerData(payload) ? payload : null;
+}
+const authenticationHandler = (server) => (onSuccess, onFail) => {
+  return (request, h) => {
+    try {
+      const data = validatePayload(request.payload);
+      if (!data) {
+        onFail();
+        h.response("Error with cookies").code(400);
+        throw new Error("It seems the server didn't respond properly, please contact us.");
+      }
+      onSuccess(data);
+      return h.response(data).code(200);
+    } finally {
+      void server.stop({ timeout: 1e4 });
+    }
+  };
+};
+function buildServer(base, port, host) {
+  const server = hapi__namespace.server({
+    port,
+    host,
+    routes: {
+      cors: {
+        origin: [base],
+        headers: ["Origin", "X-Requested-With", "Content-Type", "Accept"]
+      }
+    }
+  });
+  return server;
+}
+function askSingleChar(title) {
+  return new Promise((resolve) => {
+    process.stdout.write(title);
+    const rawMode = process.stdin.isRaw;
+    if (process.stdin.setRawMode)
+      process.stdin.setRawMode(true);
+    function handler(key) {
+      const response = key.toString("utf-8");
+      if (process.stdin.setRawMode)
+        process.stdin.setRawMode(Boolean(rawMode));
+      process.stdin.removeListener("data", handler);
+      resolve(response);
+    }
+    process.stdin.on("data", handler);
+  });
+}
+async function startServerAndOpenBrowser(url, action, base = DEFAULT_BASE$1, port = DEFAULT_SERVER_PORT) {
+  const confirmation = await askSingleChar(`>> Press any key to open the browser to ${action} or q to exit:`);
+  if (confirmation === "q" || confirmation === "")
+    return process.exit(-1);
+  const s = spinner("Waiting for the browser response");
+  const onLoginFail = () => {
+    s.stop();
+    writeError(`We failed to log you into your Prismic account`);
+    console.log(`Run ${bold("npx slicemachine init")} again!`);
+    process.exit(-1);
+  };
+  function onSuccess(data) {
+    s.succeed(`Logged in as ${bold(data.email)}`).stop();
+    Prismic.PrismicSharedConfigManager.setProperties({
+      cookies: Cookie.serializeCookies(data.cookies),
+      base
+    });
+  }
+  function onFail() {
+    onLoginFail();
+  }
+  const server = buildServer(base, port, "localhost");
+  server.route([
+    Routes.authentication(server)(onSuccess, onFail),
+    Routes.notFound
+  ]);
+  return server.start().then(() => {
+    console.log("\nOpening browser to " + underline(url));
+    s.start();
+    void open__default["default"](url);
+    return {
+      onLoginFail
+    };
+  });
+}
+
+async function startAuth({
+  base,
+  url,
+  action
+}) {
+  const { onLoginFail } = await startServerAndOpenBrowser(url, action, base);
+  try {
+    await core.Utils.Poll.startPolling(() => Auth.validateSession(base), (user) => !!user, 3e3, 60);
+    return;
+  } catch (e) {
+    onLoginFail();
+  }
+}
+const Auth = {
+  login: async (base) => {
+    const endpoints = Prismic.Endpoints.buildEndpoints(base);
+    return startAuth({
+      base,
+      url: endpoints.Dashboard.cliLogin,
+      action: "login"
+    });
+  },
+  signup: async (base) => {
+    const endpoints = Prismic.Endpoints.buildEndpoints(base);
+    return startAuth({
+      base,
+      url: endpoints.Dashboard.cliSignup,
+      action: "signup"
+    });
+  },
+  logout: () => Prismic.PrismicSharedConfigManager.remove(),
+  validateSession: async (requiredBase) => {
+    const config = Prismic.PrismicSharedConfigManager.get();
+    if (!config.cookies.length)
+      return Promise.resolve(null);
+    if (requiredBase != config.base)
+      return Promise.resolve(null);
+    return Prismic.Communication.validateSession(config.cookies, requiredBase).catch(() => null);
+  }
+};
+
 function findArgument(args, name) {
   const flagIndex = args.indexOf(`--${name}`);
   if (flagIndex === -1)
@@ -175,7 +373,7 @@ const {
   SLICE_SIMULATOR_REACT,
   SLICE_SIMULATOR_VUE,
   PRISMIC_HELPERS
-} = core.Utils.CONSTS;
+} = core.CONSTS;
 function depsForFramework(framework) {
   switch (framework) {
     case core.Models.Frameworks.react:
@@ -193,41 +391,41 @@ function depsForFramework(framework) {
   }
 }
 async function installRequiredDependencies(cwd, framework) {
-  const yarnLock = core.Utils.Files.exists(core.FileSystem.YarnLockPath(cwd));
+  const yarnLock = NodeUtils__namespace.Files.exists(NodeUtils__namespace.YarnLockPath(cwd));
   const installDevDependencyCommand = yarnLock ? "yarn add -D" : "npm install --save-dev";
   const installDependencyCommand = yarnLock ? "yarn add" : "npm install --save";
-  const spinner = core.Utils.spinner("Downloading Slice Machine");
+  const spinner = spinner$1("Downloading Slice Machine");
   spinner.start();
   const { stderr } = await execCommand(`${installDevDependencyCommand} ${SM_PACKAGE_NAME}`);
   const deps = depsForFramework(framework);
   if (deps)
     await execCommand(`${installDependencyCommand} ${deps}`);
-  const pathToPkg = path__default["default"].join(core.FileSystem.PackagePaths(cwd).value(), SM_PACKAGE_NAME);
-  const isPackageInstalled = core.Utils.Files.exists(pathToPkg);
+  const pathToPkg = path__default["default"].join(NodeUtils__namespace.PackagePaths(cwd).value(), SM_PACKAGE_NAME);
+  const isPackageInstalled = NodeUtils__namespace.Files.exists(pathToPkg);
   if (isPackageInstalled || !stderr.length) {
     spinner.succeed("Slice Machine was installed successfully");
     return;
   }
   spinner.fail();
-  core.Utils.writeWarning(`could not install ${SM_PACKAGE_NAME}. Please do it manually!`);
+  writeWarning(`could not install ${SM_PACKAGE_NAME}. Please do it manually!`);
 }
 
 function validatePkg(cwd) {
-  const jsonPackage = core.FileSystem.retrieveJsonPackage(cwd);
+  const jsonPackage = NodeUtils__namespace.retrieveJsonPackage(cwd);
   if (!jsonPackage.exists) {
-    core.Utils.writeError(`package.json not found. Are you in the right folder?`);
+    writeError$1(`package.json not found. Are you in the right folder?`);
     return process.exit(-1);
   }
   if (!jsonPackage.content) {
-    core.Utils.writeError(`could not parse package.json.`);
+    writeError$1(`could not parse package.json.`);
     return process.exit(-1);
   }
 }
 
 function createRepository(domain, framework, cookies, base) {
-  const spinner = core.Utils.spinner("Creating Prismic Repository");
+  const spinner = spinner$1("Creating Prismic Repository");
   spinner.start();
-  return core.Communication.createRepository(domain, cookies, framework, base).then((res) => {
+  return Prismic__namespace.Communication.createRepository(domain, cookies, framework, base).then((res) => {
     const addressUrl = new URL(base);
     const repoDomainName = res.data.domain || domain;
     addressUrl.hostname = `${repoDomainName}.${addressUrl.hostname}`;
@@ -237,23 +435,23 @@ function createRepository(domain, framework, cookies, base) {
   }).catch((error) => {
     spinner.fail(`Error creating repository ${domain}`);
     if (error.message) {
-      core.Utils.writeError(error.message);
+      writeError$1(error.message);
     }
-    core.Utils.writeError(`We failed to create you new prismic repository`);
-    console.log(`Run ${core.Utils.bold("npx @slicemachine/init")} again!`);
+    writeError$1(`We failed to create you new prismic repository`);
+    console.log(`Run ${bold$1("npx @slicemachine/init")} again!`);
     process.exit(-1);
   });
 }
 
 const CREATE_REPO = "$_CREATE_REPO";
-const DEFAULT_BASE = core.Utils.CONSTS.DEFAULT_BASE;
+const DEFAULT_BASE = core.CONSTS.DEFAULT_BASE;
 function prettyRepoName(address, value) {
-  const repoName = value ? core.Utils.cyan(value) : core.Utils.dim.cyan("repo-name");
-  return `${core.Utils.cyan.dim(`${address.protocol}//`)}${repoName}${core.Utils.cyan.dim(`.${address.hostname}`)}`;
+  const repoName = value ? cyan(value) : dim.cyan("repo-name");
+  return `${cyan.dim(`${address.protocol}//`)}${repoName}${cyan.dim(`.${address.hostname}`)}`;
 }
 async function promptForRepoDomain(base, defaultValue) {
   const address = new URL(base);
-  core.Utils.writeInfo("The name acts as a domain/endpoint for your content repo and should be completely unique.");
+  writeInfo("The name acts as a domain/endpoint for your content repo and should be completely unique.");
   return inquirer__namespace.prompt([
     {
       name: "repoDomain",
@@ -261,9 +459,9 @@ async function promptForRepoDomain(base, defaultValue) {
       type: "input",
       required: true,
       default: defaultValue,
-      transformer: (value) => prettyRepoName(address, String(value || defaultValue)),
+      transformer: (value) => prettyRepoName(address, value || defaultValue),
       async validate(name) {
-        const result = await core.Communication.validateRepositoryName(name, base, false);
+        const result = await Prismic__namespace.Communication.validateRepositoryName(name, base, false);
         return result === name || result;
       }
     }
@@ -275,13 +473,13 @@ function makeReposPretty(base) {
     address.hostname = `${domain}.${address.hostname}`;
     if (core.Models.canUpdateCustomTypes(role) === false) {
       return {
-        name: `${core.Utils.purple.dim("Use")} ${core.Utils.bold.dim(name)} ${core.Utils.purple.dim(`"${address.hostname}"`)}`,
+        name: `${purple.dim("Use")} ${bold$1.dim(name)} ${purple.dim(`"${address.hostname}"`)}`,
         value: domain,
         disabled: "Unauthorized"
       };
     }
     return {
-      name: `${core.Utils.purple("Use")} ${core.Utils.bold(name)} ${core.Utils.purple(`"${address.hostname}"`)}`,
+      name: `${purple("Use")} ${bold$1(name)} ${purple(`"${address.hostname}"`)}`,
       value: domain
     };
   };
@@ -311,17 +509,17 @@ function maybeStickTheRepoToTheTopOfTheList(repoName) {
 }
 function sortReposForPrompt(repos, base, cwd) {
   const createNew = {
-    name: `${core.Utils.purple("Create a")} ${core.Utils.bold("new")} ${core.Utils.purple("Repository")}`,
+    name: `${purple("Create a")} ${bold$1("new")} ${purple("Repository")}`,
     value: CREATE_REPO
   };
-  const maybeConfiguredRepoName = core.FileSystem.maybeRepoNameFromSMFile(cwd, base);
+  const maybeConfiguredRepoName = NodeUtils__namespace.maybeRepoNameFromSMFile(cwd, base);
   return repos.reverse().map(makeReposPretty(base)).reduce(maybeStickTheRepoToTheTopOfTheList(maybeConfiguredRepoName), [
     createNew
   ]).sort(orderPrompts(maybeConfiguredRepoName));
 }
 async function chooseOrCreateARepository(cwd, framework, cookies, base = DEFAULT_BASE, domain) {
-  const token = cookie.parsePrismicAuthToken(cookies);
-  const repos = await core.Communication.listRepositories(token, base);
+  const token = core.Utils.Cookie.parsePrismicAuthToken(cookies);
+  const repos = await Prismic__namespace.Communication.listRepositories(token, base);
   const hasRepo = domain && repos.find((d) => d.domain === domain);
   if (hasRepo)
     return domain;
@@ -356,7 +554,7 @@ async function chooseOrCreateARepository(cwd, framework, cookies, base = DEFAULT
 async function promptForFramework() {
   const choices = core.Models.SupportedFrameworks.map((framework) => {
     return {
-      name: core.Utils.Framework.fancyName(framework),
+      name: NodeUtils__namespace.Framework.fancyName(framework),
       value: framework
     };
   });
@@ -376,26 +574,26 @@ async function promptForFramework() {
   });
 }
 async function detectFramework(cwd) {
-  const failMessage = `Please run ${core.Utils.bold("npx @slicemachine/init")} in a Nuxt or Next.js project`;
-  const spinner = core.Utils.spinner("Detecting framework to install correct dependencies");
+  const failMessage = `Please run ${bold$1("npx @slicemachine/init")} in a Nuxt or Next.js project`;
+  const spinner = spinner$1("Detecting framework to install correct dependencies");
   spinner.start();
   try {
-    const maybeFramework = core.Utils.Framework.defineFramework({
+    const maybeFramework = NodeUtils__namespace.Framework.defineFramework({
       cwd,
       supportedFrameworks: Object.values(core.Models.Frameworks)
     });
     spinner.stop();
     if (!maybeFramework || maybeFramework === core.Models.Frameworks.vanillajs) {
-      core.Utils.writeError("Framework not detected");
+      writeError$1("Framework not detected");
       return await promptForFramework();
     }
-    const nameToPrint = core.Utils.Framework.fancyName(maybeFramework);
-    if (!core.Utils.Framework.isFrameworkSupported(maybeFramework)) {
-      core.Utils.writeError(`${nameToPrint} is currently not supported`);
+    const nameToPrint = NodeUtils__namespace.Framework.fancyName(maybeFramework);
+    if (!NodeUtils__namespace.Framework.isFrameworkSupported(maybeFramework)) {
+      writeError$1(`${nameToPrint} is currently not supported`);
       console.log(failMessage);
       process.exit(1);
     }
-    core.Utils.writeCheck(`${nameToPrint} detected`);
+    writeCheck(`${nameToPrint} detected`);
     return {
       value: maybeFramework,
       manuallyAdded: false
@@ -403,7 +601,7 @@ async function detectFramework(cwd) {
   } catch (error) {
     spinner.fail("package.json not found");
     if (error instanceof Error && error.message) {
-      core.Utils.writeError(error.message);
+      writeError$1(error.message);
     } else {
       console.log(failMessage);
     }
@@ -411,8 +609,8 @@ async function detectFramework(cwd) {
   }
 }
 
-async function getUserProfile(cookies, base = core.Utils.CONSTS.DEFAULT_BASE) {
-  const userServiceBase = core.Utils.CONSTS.DEFAULT_BASE === base ? core.Utils.CONSTS.USER_SERVICE_BASE : core.Utils.CONSTS.USER_SERVICE_STAGING_BASE;
+async function getUserProfile(cookies, base = core.CONSTS.DEFAULT_BASE) {
+  const userServiceBase = core.CONSTS.DEFAULT_BASE === base ? core.CONSTS.USER_SERVICE_BASE : core.CONSTS.USER_SERVICE_STAGING_BASE;
   const url = new URL(userServiceBase);
   url.pathname = "profile";
   const endpoint = url.toString();
@@ -425,17 +623,17 @@ async function getUserProfile(cookies, base = core.Utils.CONSTS.DEFAULT_BASE) {
     throw new Error("Can't parse user profile");
   }, (data) => data)));
 }
-async function validateSessionAndGetProfile(base = core.Utils.CONSTS.DEFAULT_BASE) {
-  const config = core.FileSystem.PrismicSharedConfigManager.get();
+async function validateSessionAndGetProfile(base = core.CONSTS.DEFAULT_BASE) {
+  const config = Prismic__namespace.PrismicSharedConfigManager.get();
   if (!config.cookies.length)
     return Promise.resolve(null);
   if (base != config.base)
     return Promise.resolve(null);
   try {
-    const info = await core.Communication.validateSession(config.cookies, base);
+    const info = await Prismic__namespace.Communication.validateSession(config.cookies, base);
     const profile = await getUserProfile(config.cookies, base).catch(() => null);
     if (profile == null ? void 0 : profile.shortId) {
-      core.FileSystem.PrismicSharedConfigManager.setProperties({
+      Prismic__namespace.PrismicSharedConfigManager.setProperties({
         shortId: profile.shortId
       });
     }
@@ -449,10 +647,10 @@ async function loginOrBypass(base) {
   const user = await validateSessionAndGetProfile(base).catch((err) => console.log(err));
   if (user) {
     const email = user.info.email;
-    core.Utils.writeCheck(`Logged in as ${core.Utils.bold(email)}`);
+    writeCheck(`Logged in as ${bold$1(email)}`);
     return user;
   } else {
-    await core.Auth.login(base);
+    await Auth.login(base);
     const user2 = await validateSessionAndGetProfile(base);
     return user2;
   }
@@ -460,28 +658,29 @@ async function loginOrBypass(base) {
 
 const defaultSliceMachineVersion = "0.0.41";
 function configureProject(cwd, base, repositoryDomainName, framework, sliceLibPath = [], tracking = true) {
-  const spinner = core.Utils.spinner(`Configuring your ${framework.value} & Prismic project...`);
+  const spinner = spinner$1(`Configuring your ${framework.value} & Prismic project...`);
   spinner.start();
   try {
-    const manifest = core.FileSystem.retrieveManifest(cwd);
-    const packageJson = core.FileSystem.retrieveJsonPackage(cwd);
+    const manifest = NodeUtils__namespace.retrieveManifest(cwd);
+    const packageJson = NodeUtils__namespace.retrieveJsonPackage(cwd);
     const sliceMachineVersionInstalled = getTheSliceMachineVersionInstalled(packageJson);
     const manifestAlreadyExistWithContent = manifest.exists && manifest.content;
     const manifestUpdated = {
       ...manifestAlreadyExistWithContent ? manifest.content : { _latest: sliceMachineVersionInstalled },
-      apiEndpoint: core.Utils.Endpoints.buildRepositoryEndpoint(base, repositoryDomainName),
+      apiEndpoint: Prismic__namespace.Endpoints.buildRepositoryEndpoint(base, repositoryDomainName),
       libraries: ["@/slices", ...sliceLibPath],
       ...framework.manuallyAdded ? { framework: framework.value } : {},
       ...!tracking ? { tracking } : {}
     };
     if (!manifest.exists)
-      core.FileSystem.createManifest(cwd, manifestUpdated);
+      NodeUtils__namespace.createManifest(cwd, manifestUpdated);
     else
-      core.FileSystem.patchManifest(cwd, manifestUpdated);
-    const pathToSlicesFolder = core.FileSystem.CustomPaths(cwd).library("slices").value();
-    if (!core.Utils.Files.exists(pathToSlicesFolder))
-      core.Utils.Files.mkdir(pathToSlicesFolder, { recursive: true });
-    core.FileSystem.addJsonPackageSmScript(cwd);
+      NodeUtils__namespace.patchManifest(cwd, manifestUpdated);
+    const pathToSlicesFolder = NodeUtils__namespace.CustomPaths(cwd).library("slices").value();
+    if (!NodeUtils__namespace.Files.exists(pathToSlicesFolder)) {
+      NodeUtils__namespace.Files.mkdir(pathToSlicesFolder, { recursive: true });
+    }
+    NodeUtils__namespace.addJsonPackageSmScript(cwd);
     spinner.succeed("Project configured! Ready to start");
   } catch (e) {
     spinner.fail("Failed to configure Slice Machine");
@@ -491,7 +690,7 @@ function configureProject(cwd, base, repositoryDomainName, framework, sliceLibPa
 const getTheSliceMachineVersionInstalled = (packageJson) => {
   var _a;
   const sliceMachinePackageInstalled = Object.entries(((_a = packageJson.content) == null ? void 0 : _a.devDependencies) || {}).find((devDependency) => {
-    if (devDependency[0] === core.Utils.CONSTS.SM_PACKAGE_NAME) {
+    if (devDependency[0] === core.CONSTS.SM_PACKAGE_NAME) {
       return devDependency;
     }
   });
@@ -513,9 +712,9 @@ const extractVersionNumberFromSemver = (semver) => {
 };
 
 function displayFinalMessage(cwd) {
-  const yarnLock = core.Utils.Files.exists(core.FileSystem.YarnLockPath(cwd));
-  const command = `${yarnLock ? "yarn" : "npm"} run ${core.Utils.CONSTS.SCRIPT_NAME}`;
-  console.log(`${core.Utils.white("\u25A0")} Run ${core.Utils.purple(command)} to now launch Slice Machine`);
+  const yarnLock = NodeUtils__namespace.Files.exists(NodeUtils__namespace.YarnLockPath(cwd));
+  const command = `${yarnLock ? "yarn" : "npm"} run ${core.CONSTS.SCRIPT_NAME}`;
+  console.log(`${white("\u25A0")} Run ${purple(command)} to now launch Slice Machine`);
 }
 
 const Dependencies = {
@@ -537,7 +736,7 @@ function formatDeps(dependencies) {
 }
 const PackageManager = {
   get(cwd) {
-    if (core.Utils.Files.exists(core.FileSystem.YarnLockPath(cwd))) {
+    if (NodeUtils__namespace.Files.exists(NodeUtils__namespace.YarnLockPath(cwd))) {
       return Yarn;
     }
     return Npm;
@@ -560,6 +759,7 @@ const Npm = {
   }
 };
 
+const { PackageJsonHelper } = NodeUtils__namespace;
 const downloadFile = async (reqUrl) => {
   const res = await axios__default["default"].get(reqUrl, { responseType: "arraybuffer" });
   return new Promise((resolve, reject) => {
@@ -577,7 +777,7 @@ function toGithubSource(githubPath, branch) {
   return `https://codeload.github.com/${githubPath}/zip/${branch}`;
 }
 async function installLib(cwd, libGithubPath, branch = "HEAD") {
-  const spinner = core.Utils.spinner(`Installing the ${libGithubPath} lib in your project...`);
+  const spinner = spinner$1(`Installing the ${libGithubPath} lib in your project...`);
   try {
     spinner.start();
     const [githubUserName, githubProjectName] = libGithubPath.split("/");
@@ -593,21 +793,21 @@ async function installLib(cwd, libGithubPath, branch = "HEAD") {
     }
     fsExtra__default["default"].moveSync(path__default["default"].join(projectPath, "src"), libDestinationFolder);
     const pkgManager = PackageManager.get(cwd);
-    const pkgJson = PackageJson.PackageJsonHelper.fromPath(path__default["default"].join(projectPath, "package.json"));
+    const pkgJson = PackageJsonHelper.fromPath(path__default["default"].join(projectPath, "package.json"));
     if (pkgJson instanceof Error)
       throw pkgJson;
     const dependencies = Dependencies.fromPkgFormat(pkgJson.dependencies);
     if (dependencies)
       await pkgManager.install(dependencies);
-    Files__default["default"].write(path__default["default"].join(libDestinationFolder, "meta.json"), {
+    NodeUtils__namespace.Files.write(path__default["default"].join(libDestinationFolder, "meta.json"), {
       name: pkgJson.name
     });
-    const manifest = Files__default["default"].readEntity(path__default["default"].join(projectPath, "sm.json"), (payload) => {
-      return Either.getOrElseW(() => new Error(`Unable to parse sm.json from lib ${libGithubPath}`))(Manifest.Manifest.decode(payload));
+    const manifest = NodeUtils__namespace.Files.readEntity(path__default["default"].join(projectPath, "sm.json"), (payload) => {
+      return Either.getOrElseW(() => new Error(`Unable to parse sm.json from lib ${libGithubPath}`))(core.Models.Manifest.decode(payload));
     });
     if (manifest instanceof Error)
       throw manifest;
-    const localLibs = Manifest.ManifestHelper.localLibraries(manifest).map(({ path: path2 }) => {
+    const localLibs = core.Models.ManifestHelper.localLibraries(manifest).map(({ path: path2 }) => {
       return `~/${name}/${path2.replace("src/", "")}`;
     });
     spinner.succeed(`Slice library "${libGithubPath}" was installed successfully`);
@@ -624,14 +824,14 @@ async function installLib(cwd, libGithubPath, branch = "HEAD") {
 
 async function init() {
   const cwd = findArgument(process.argv, "cwd") || process.cwd();
-  const base = findArgument(process.argv, "base") || core.Utils.CONSTS.DEFAULT_BASE;
+  const base = findArgument(process.argv, "base") || core.CONSTS.DEFAULT_BASE;
   const lib = findArgument(process.argv, "library");
   const branch = findArgument(process.argv, "branch");
   const isTrackingAvailable = findArgument(process.argv, "tracking") !== "false";
   const maybeRepositorySubdomain = findArgument(process.argv, "repository");
-  Tracker.get().initialize("ED3O1FVsa8DteNyRmAuDyMcPoftJ6VdP" , isTrackingAvailable);
-  Tracker.get().trackInitStart();
-  console.log(core.Utils.purple("You're about to configure Slicemachine... Press ctrl + C to cancel"));
+  Tracker.get().initialize("JfTfmHaATChc4xueS7RcCBsixI71dJIJ" , isTrackingAvailable);
+  Tracker.get().trackInitStart(maybeRepositorySubdomain);
+  console.log(purple("You're about to configure Slicemachine... Press ctrl + C to cancel"));
   validatePkg(cwd);
   const user = await loginOrBypass(base);
   if (!user)
@@ -639,7 +839,8 @@ async function init() {
   if (user.profile) {
     Tracker.get().identifyUser(user.profile.shortId);
   }
-  const config = core.FileSystem.PrismicSharedConfigManager.get();
+  Tracker.get().trackInitIdentify(maybeRepositorySubdomain);
+  const config = Prismic__default["default"].PrismicSharedConfigManager.get();
   const frameworkResult = await detectFramework(cwd);
   const repositoryDomainName = await chooseOrCreateARepository(cwd, frameworkResult.value, config.cookies, config.base, maybeRepositorySubdomain);
   await installRequiredDependencies(cwd, frameworkResult.value);
@@ -652,7 +853,7 @@ try {
   void init();
 } catch (error) {
   if (error instanceof Error)
-    core.Utils.writeError(error.message);
+    writeError$1(error.message);
   else
     console.error(error);
 }