@slicemachine/init 1.1.9-alpha.3 → 1.1.10-alpha.10

package/build/index.js

@@ -2,7 +2,7 @@
 
 'use strict';
 
-const core = require('@slicemachine/core');
+const client = require('@slicemachine/client');
 const Prismic = require('@slicemachine/core/build/prismic');
 const ServerAnalytics = require('analytics-node');
 const uuid = require('uuid');
@@ -11,18 +11,24 @@ const util = require('util');
 const child_process = require('child_process');
 const chalk = require('chalk');
 const ora = require('ora');
+const core = require('@slicemachine/core');
 const hapi = require('@hapi/hapi');
 const open = require('open');
+const t = require('io-ts');
+const fs = require('fs');
 const NodeUtils = require('@slicemachine/core/build/node-utils');
 const inquirer = require('inquirer');
 const Separator = require('inquirer/lib/objects/separator');
-const axios = require('axios');
-const _function = require('fp-ts/function');
-const Either = require('fp-ts/Either');
 const tmp = require('tmp');
 const AdmZip = require('adm-zip');
 const fsExtra = require('fs-extra');
-const fs = require('fs');
+const axios = require('axios');
+const Either = require('fp-ts/Either');
+const models = require('@slicemachine/core/build/models');
+const Libraries = require('@slicemachine/core/build/libraries');
+const customtypes = require('@prismicio/types-internal/lib/customtypes');
+const Either$1 = require('fp-ts/lib/Either');
+const SharedConfig = require('@slicemachine/core/build/prismic/SharedConfig');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -53,14 +59,17 @@ 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 t__namespace = /*#__PURE__*/_interopNamespace(t);
+const fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
 const NodeUtils__namespace = /*#__PURE__*/_interopNamespace(NodeUtils);
 const inquirer__namespace = /*#__PURE__*/_interopNamespace(inquirer);
+const inquirer__default = /*#__PURE__*/_interopDefaultLegacy(inquirer);
 const Separator__default = /*#__PURE__*/_interopDefaultLegacy(Separator);
-const axios__default = /*#__PURE__*/_interopDefaultLegacy(axios);
 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 axios__default = /*#__PURE__*/_interopDefaultLegacy(axios);
+const Libraries__namespace = /*#__PURE__*/_interopNamespace(Libraries);
 
 var __accessCheck = (obj, member, msg) => {
   if (!member.has(obj))
@@ -81,6 +90,13 @@ var __privateSet = (obj, member, value, setter) => {
   return value;
 };
 var _client, _isTrackingActive, _anonymousId, _userId, _repository;
+var EventType;
+(function(EventType2) {
+  EventType2["DownloadLibrary"] = "SliceMachine Download Library";
+  EventType2["InitStart"] = "SliceMachine Init Start";
+  EventType2["InitIdentify"] = "SliceMachine Init Identify";
+  EventType2["InitDone"] = "SliceMachine Init Done";
+})(EventType || (EventType = {}));
 class InitTracker {
   constructor() {
     __privateAdd(this, _client, null);
@@ -147,16 +163,16 @@ class InitTracker {
     return this._identifyEvent(userId, intercomHash);
   }
   trackDownloadLibrary(library) {
-    return this._trackEvent("SliceMachine Download Library" /* DownloadLibrary */, { library });
+    return this._trackEvent(EventType.DownloadLibrary, { library });
   }
   trackInitIdentify() {
-    return this._trackEvent("SliceMachine Init Identify" /* InitIdentify */);
+    return this._trackEvent(EventType.InitIdentify);
   }
   trackInitStart(repoDomain) {
-    return this._trackEvent("SliceMachine Init Start" /* InitStart */, { repo: repoDomain });
+    return this._trackEvent(EventType.InitStart, { repo: repoDomain });
   }
   trackInitDone(framework) {
-    return this._trackEvent("SliceMachine Init Done" /* InitDone */, { framework });
+    return this._trackEvent(EventType.InitDone, { framework });
   }
 }
 _client = new WeakMap();
@@ -214,7 +230,7 @@ const logs = /*#__PURE__*/Object.freeze({
 });
 
 const { Cookie } = core.Utils;
-const { DEFAULT_BASE: DEFAULT_BASE$1, DEFAULT_SERVER_PORT } = core.CONSTS;
+const { DEFAULT_BASE, DEFAULT_SERVER_PORT } = core.CONSTS;
 const { bold, underline, spinner, writeError } = logs;
 const isHandlerData = (data) => {
   if (typeof data != "object")
@@ -257,13 +273,16 @@ const authenticationHandler = (server) => (onSuccess, onFail) => {
     }
   };
 };
+function stripTrailingSlash(str) {
+  return str.endsWith("/") ? str.slice(0, -1) : str;
+}
 function buildServer(base, port, host) {
   const server = hapi__namespace.server({
     port,
     host,
     routes: {
       cors: {
-        origin: [base],
+        origin: [stripTrailingSlash(base)],
         headers: ["Origin", "X-Requested-With", "Content-Type", "Accept"]
       }
     }
@@ -286,7 +305,7 @@ function askSingleChar(title) {
     process.stdin.on("data", handler);
   });
 }
-async function startServerAndOpenBrowser(url, action, base = DEFAULT_BASE$1, port = DEFAULT_SERVER_PORT) {
+async function startServerAndOpenBrowser(url, action, base = DEFAULT_BASE, 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);
@@ -323,46 +342,92 @@ async function startServerAndOpenBrowser(url, action, base = DEFAULT_BASE$1, por
 }
 
 async function startAuth({
-  base,
+  client,
   url,
   action
 }) {
-  const { onLoginFail } = await startServerAndOpenBrowser(url, action, base);
+  const { onLoginFail } = await startServerAndOpenBrowser(url, action, client.apisEndpoints.Wroom);
   try {
-    await core.Utils.Poll.startPolling(() => Auth.validateSession(base), (user) => !!user, 3e3, 60);
+    await core.Utils.Poll.startPolling(() => Auth.validateSession(client), (isSessionValid) => isSessionValid == true, 3e3, 60);
     return;
   } catch (e) {
     onLoginFail();
   }
 }
 const Auth = {
-  login: async (base) => {
-    const endpoints = Prismic.Endpoints.buildEndpoints(base);
+  login: async (client) => {
+    const endpoints = Prismic.Endpoints.buildEndpoints(client.apisEndpoints.Wroom);
     return startAuth({
-      base,
+      client,
       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);
+  validateSession: async (client) => {
+    const authToken = Prismic.PrismicSharedConfigManager.getAuth();
+    return client.updateAuthenticationToken(authToken).profile().then((userProfile) => {
+      Prismic.PrismicSharedConfigManager.setProperties({
+        shortId: userProfile.shortId,
+        intercomHash: userProfile.intercomHash
+      });
+      return true;
+    }).catch(() => false);
   }
 };
 
+class InitClient extends client.Client {
+  async listRepositories() {
+    return client.getAndValidateResponse(this._get(`${this.apisEndpoints.Users}repositories`), "repository list", t__namespace.array(core.Models.Repository));
+  }
+  async createRepository(domain, framework) {
+    const data = {
+      domain,
+      framework,
+      plan: "personal",
+      isAnnual: "false",
+      role: "developer"
+    };
+    return this._fetch({
+      method: "post",
+      url: `${this.apisEndpoints.Wroom}authentication/newrepository?app=slicemachine`,
+      data,
+      headers: {
+        Cookie: Prismic.PrismicSharedConfigManager.get().cookies,
+        "User-Agent": "prismic-cli/sm"
+      }
+    }).then(() => domain);
+  }
+  async domainExist(domain) {
+    return client.getAndValidateResponse(this._get(`${this.apisEndpoints.Wroom}app/dashboard/repositories/${domain}/exists`), "repository exists", t__namespace.boolean);
+  }
+  async pushDocuments(signature, documents, cookies) {
+    if (!this.repository)
+      throw new Error("Repository undefined in the client");
+    const repositoryDirectUrl = new URL(this.apisEndpoints.Wroom);
+    repositoryDirectUrl.hostname = `${this.repository}.${repositoryDirectUrl.hostname}`;
+    return this._fetch({
+      method: "post",
+      url: `${repositoryDirectUrl.toString()}starter/documents`,
+      data: { signature, documents: JSON.stringify(documents) },
+      headers: {
+        Cookie: cookies,
+        "User-Agent": "prismic-cli/0"
+      }
+    });
+  }
+}
+
+async function lsdir(dir) {
+  return fs__default["default"].promises.readdir(dir).then((dirs) => {
+    return dirs.filter((name) => fs__default["default"].statSync(path__default["default"].join(dir, name)).isDirectory()).map((subdirectory) => path__default["default"].join(dir, subdirectory));
+  });
+}
+async function lsfiles(dir) {
+  return fs__default["default"].promises.readdir(dir).then((dirs) => {
+    return dirs.filter((name) => fs__default["default"].statSync(path__default["default"].join(dir, name)).isFile()).map((file) => path__default["default"].join(dir, file));
+  });
+}
+
 function findArgument(args, name) {
   const flagIndex = args.indexOf(`--${name}`);
   if (flagIndex === -1)
@@ -374,7 +439,21 @@ function findArgument(args, name) {
     return;
   return flagValue;
 }
+function findFlag(args, name) {
+  const toFind = `--${name}`;
+  return args.includes(toFind);
+}
 const execCommand = util__default["default"].promisify(child_process.exec);
+function getApplicationMode(argumentValue) {
+  switch (argumentValue) {
+    case client.ApplicationMode.PROD:
+    case client.ApplicationMode.STAGE:
+    case client.ApplicationMode.DEV:
+      return argumentValue;
+    default:
+      return null;
+  }
+}
 
 const {
   PRISMIC_CLIENT,
@@ -403,16 +482,25 @@ function depsForFramework(framework) {
       return "";
   }
 }
-async function installRequiredDependencies(cwd, framework) {
-  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 = spinner$1("Downloading Slice Machine");
-  spinner.start();
+async function addAndInstallDeps(framework, useYarn = false) {
+  const installDevDependencyCommand = useYarn ? "yarn add -D" : "npm install --save-dev";
+  const installDependencyCommand = useYarn ? "yarn add" : "npm install --save";
   const { stderr } = await execCommand(`${installDevDependencyCommand} ${SM_PACKAGE_NAME}`);
   const deps = depsForFramework(framework);
   if (deps)
     await execCommand(`${installDependencyCommand} ${deps}`);
+  return stderr;
+}
+async function installDeps(useYarn = false) {
+  const installCommand = useYarn ? "yarn" : "npm install";
+  const { stderr } = await execCommand(installCommand);
+  return stderr;
+}
+async function installRequiredDependencies(cwd, framework, skipDependencies) {
+  const yarnLock = NodeUtils__namespace.Files.exists(NodeUtils__namespace.YarnLockPath(cwd));
+  const spinner = spinner$1("Installing Slice Machine");
+  spinner.start();
+  const stderr = await (skipDependencies ? installDeps(yarnLock) : addAndInstallDeps(framework, yarnLock));
   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) {
@@ -435,16 +523,15 @@ function validatePkg(cwd) {
   }
 }
 
-function createRepository(domain, framework, cookies, base) {
+function createRepository(client, domain, framework) {
   const spinner = spinner$1("Creating Prismic Repository");
   spinner.start();
-  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}`;
+  return client.createRepository(domain, framework).then((domain2) => {
+    const addressUrl = new URL(client.apisEndpoints.Wroom);
+    addressUrl.hostname = `${domain2}.${addressUrl.hostname}`;
     const address = addressUrl.toString();
     spinner.succeed(`We created your new repository ${address}`);
-    return repoDomainName;
+    return domain2;
   }).catch((error) => {
     spinner.fail(`Error creating repository ${domain}`);
     if (error.message) {
@@ -456,14 +543,38 @@ function createRepository(domain, framework, cookies, base) {
   });
 }
 
+async function validateRepositoryName(client, name) {
+  const domain = name.trim();
+  const errors = [];
+  const startsWithLetter = /^[a-zA-Z]/.test(domain);
+  if (!startsWithLetter)
+    errors.push("Must start with a letter.");
+  const acceptedChars = /^[a-z0-9-]+$/.test(domain);
+  if (!acceptedChars)
+    errors.push("Must contain only lowercase letters, numbers and hyphens.");
+  const fourCharactersOrMore = domain.length >= 4;
+  if (!fourCharactersOrMore)
+    errors.push("Must have four or more alphanumeric characters and/or hyphens.");
+  const endsWithALetterOrNumber = /[a-z0-9]$/.test(domain);
+  if (!endsWithALetterOrNumber)
+    errors.push("Must end in a letter or a number.");
+  const thirtyCharacterOrLess = domain.length <= 30;
+  if (!thirtyCharacterOrLess)
+    errors.push("Must be 30 characters or less");
+  if (errors.length > 0) {
+    const errorString = errors.map((d, i) => `(${i + 1}: ${d}`).join(" ");
+    const msg = `Validation errors: ${errorString}`;
+    return Promise.reject(new Error(msg));
+  }
+  return client.domainExist(domain).then((isAvailable) => isAvailable ? true : Promise.reject(new Error(`${name} is already in use`))).catch(() => Promise.reject(new Error(`${name} is already in use`)));
+}
+
 const CREATE_REPO = "$_CREATE_REPO";
-const DEFAULT_BASE = core.CONSTS.DEFAULT_BASE;
-function prettyRepoName(address, value) {
-  const repoName = value ? cyan(value) : dim.cyan("repo-name");
-  return `${cyan.dim(`${address.protocol}//`)}${repoName}${cyan.dim(`.${address.hostname}`)}`;
+function prettyRepoName(address, domain) {
+  return `${cyan.dim(`${address.protocol}//`)}${cyan(domain)}${cyan.dim(`.${address.hostname}`)}`;
 }
-async function promptForRepoDomain(base, defaultValue) {
-  const address = new URL(base);
+async function promptForRepoDomain(client, defaultValue) {
+  const address = new URL(client.apisEndpoints.Wroom);
   writeInfo("The name acts as a domain/endpoint for your content repo and should be completely unique.");
   return inquirer__namespace.prompt([
     {
@@ -472,11 +583,8 @@ async function promptForRepoDomain(base, defaultValue) {
       type: "input",
       required: true,
       default: defaultValue,
-      transformer: (value) => prettyRepoName(address, value || defaultValue),
-      async validate(name) {
-        const result = await Prismic__namespace.Communication.validateRepositoryName(name, base, false);
-        return result === name || result;
-      }
+      transformer: (value) => prettyRepoName(address, value || defaultValue || "repository"),
+      validate: (name) => validateRepositoryName(client, name)
     }
   ]).then((res) => res.repoDomain);
 }
@@ -530,26 +638,26 @@ function sortReposForPrompt(repos, base, cwd) {
     createNew
   ]).sort(orderPrompts(maybeConfiguredRepoName));
 }
-async function chooseOrCreateARepository(cwd, framework, cookies, base = DEFAULT_BASE, domain) {
-  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;
-  if (repos.length === 0) {
-    const domainName = await promptForRepoDomain(base, domain);
-    return await createRepository(domainName, framework, cookies, base);
-  }
-  const choices = sortReposForPrompt(repos, base, cwd);
+async function chooseOrCreateARepository(client, cwd, framework, preSelectedRepository) {
+  const repositories = await client.listRepositories();
+  const isPreSelectedValid = preSelectedRepository && repositories.find((repository) => repository.domain === preSelectedRepository);
+  if (isPreSelectedValid)
+    return preSelectedRepository;
+  if (repositories.length === 0) {
+    const domainName = await promptForRepoDomain(client, preSelectedRepository);
+    await createRepository(client, domainName, framework);
+    return domainName;
+  }
+  const choices = sortReposForPrompt(repositories, client.apisEndpoints.Wroom, cwd);
   const numberOfDisabledRepos = choices.filter((repo) => {
     if (repo instanceof Separator__default["default"])
       return false;
     return repo.disabled;
   }).length;
-  const res = await inquirer__namespace.prompt([
+  const promptResult = await inquirer__namespace.prompt([
     {
       type: "list",
-      name: "chosenRepo",
+      name: "chosenRepository",
       default: 0,
       required: true,
       message: "Connect a Prismic Repository or create a new one",
@@ -557,11 +665,12 @@ async function chooseOrCreateARepository(cwd, framework, cookies, base = DEFAULT
       pageSize: numberOfDisabledRepos + 2 <= 7 ? 7 : numberOfDisabledRepos + 2
     }
   ]);
-  if (res.chosenRepo === CREATE_REPO) {
-    const domainName = await promptForRepoDomain(base, domain);
-    return await createRepository(domainName, framework, cookies, base);
+  if (promptResult.chosenRepository === CREATE_REPO) {
+    const domainName = await promptForRepoDomain(client, preSelectedRepository);
+    await createRepository(client, domainName, framework);
+    return domainName;
   }
-  return res.chosenRepo;
+  return promptResult.chosenRepository;
 }
 
 async function promptForFramework() {
@@ -622,67 +731,34 @@ async function detectFramework(cwd) {
   }
 }
 
-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();
-  const token = core.Utils.Cookie.parsePrismicAuthToken(cookies);
-  return axios__default["default"].get(endpoint, {
-    headers: {
-      Authorization: `Bearer ${token}`
-    }
-  }).then((res) => _function.pipe(core.Models.UserProfile.decode(res.data), Either.fold(() => {
-    throw new Error("Can't parse user profile");
-  }, (data) => data)));
-}
-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 Prismic__namespace.Communication.validateSession(config.cookies, base);
-    const profile = await getUserProfile(config.cookies, base).catch(() => null);
-    if (profile == null ? void 0 : profile.shortId) {
-      Prismic__namespace.PrismicSharedConfigManager.setProperties({
-        shortId: profile.shortId,
-        intercomHash: profile.intercomHash
-      });
-    }
-    return { info, profile };
-  } catch (e) {
-    return null;
-  }
-}
-
-async function loginOrBypass(base) {
-  const user = await validateSessionAndGetProfile(base).catch((err) => console.log(err));
+async function loginOrBypass(client) {
+  const user = await client.profile().catch(() => null);
   if (user) {
-    const email = user.info.email;
+    const email = user.email;
     writeCheck(`Logged in as ${bold$1(email)}`);
     return user;
-  } else {
-    await Auth.login(base);
-    const user2 = await validateSessionAndGetProfile(base);
-    return user2;
   }
+  await Auth.login(client);
+  client.updateAuthenticationToken(Prismic.PrismicSharedConfigManager.getAuth());
+  const userAfterLogin = await client.profile();
+  return userAfterLogin;
 }
 
 const defaultSliceMachineVersion = "0.0.41";
-async function configureProject(cwd, base, repositoryDomainName, framework, sliceLibPath = [], tracking = true) {
-  const spinner = spinner$1(`Configuring your ${framework.value} & Prismic project...`);
+async function configureProject(client, cwd, repositoryDomainName, framework, sliceLibPath = [], tracking = true) {
+  const frameworkName = NodeUtils__namespace.Framework.fancyName(framework.value);
+  const spinner = spinner$1(`Configuring your ${frameworkName} and Prismic project...`);
   spinner.start();
   try {
     const manifest = NodeUtils__namespace.retrieveManifest(cwd);
     const packageJson = NodeUtils__namespace.retrieveJsonPackage(cwd);
     const sliceMachineVersionInstalled = getTheSliceMachineVersionInstalled(packageJson);
     const manifestAlreadyExistWithContent = manifest.exists && manifest.content;
+    const libs = manifest.content && manifest.content.libraries && manifest.content.libraries.length > 0 ? manifest.content.libraries : ["@/slices"];
     const manifestUpdated = {
       ...manifestAlreadyExistWithContent ? manifest.content : { _latest: sliceMachineVersionInstalled },
-      apiEndpoint: Prismic__namespace.Endpoints.buildRepositoryEndpoint(base, repositoryDomainName),
-      libraries: ["@/slices", ...sliceLibPath],
+      apiEndpoint: Prismic__namespace.Endpoints.buildRepositoryEndpoint(client.apisEndpoints.Wroom, repositoryDomainName),
+      libraries: [...libs, ...sliceLibPath],
       ...framework.manuallyAdded ? { framework: framework.value } : {},
       ...!tracking ? { tracking } : {}
     };
@@ -691,7 +767,7 @@ async function configureProject(cwd, base, repositoryDomainName, framework, slic
     else
       NodeUtils__namespace.patchManifest(cwd, manifestUpdated);
     const pathToSlicesFolder = NodeUtils__namespace.CustomPaths(cwd).library("slices").value();
-    if (!NodeUtils__namespace.Files.exists(pathToSlicesFolder)) {
+    if (!NodeUtils__namespace.Files.exists(pathToSlicesFolder) && libs.includes("@/slices")) {
       NodeUtils__namespace.Files.mkdir(pathToSlicesFolder, { recursive: true });
     }
     NodeUtils__namespace.addJsonPackageSmScript(cwd);
@@ -726,10 +802,19 @@ const extractVersionNumberFromSemver = (semver) => {
   return null;
 };
 
-function displayFinalMessage(cwd) {
+function displayFinalMessage(cwd, wasStarter, reponame, base) {
   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`);
+  console.log();
+  if (wasStarter) {
+    const repoUrl = new URL(base);
+    repoUrl.hostname = `${reponame}.${repoUrl.hostname}`;
+    const urlAsString = repoUrl.toString();
+    const message = `${white("\u25A0")} Start editing your content in Prismic ${purple(urlAsString)}`;
+    console.log(message);
+  } else {
+    console.log(`${white("\u25A0")} Run ${purple(command)} to launch Slice Machine and create your first Custom Type`);
+  }
 }
 
 const Dependencies = {
@@ -837,32 +922,237 @@ async function installLib(cwd, libGithubPath, branch = "HEAD") {
   }
 }
 
+async function promptToPushSlices() {
+  return inquirer__default["default"].prompt([
+    {
+      type: "confirm",
+      name: "pushSlices",
+      default: false,
+      message: "Your repository already contains Slices. Do you want to continue pushing your local Slices?"
+    }
+  ]).then((res) => res.pushSlices);
+}
+async function promptToPushCustomTypes() {
+  return inquirer__default["default"].prompt([
+    {
+      type: "confirm",
+      name: "pushCustomTypes",
+      default: false,
+      message: "Your repository already contains Custom Types. Do you want to continue pushing your local Slices?"
+    }
+  ]).then((res) => res.pushCustomTypes);
+}
+
+async function updateVariationWithScreenshot(client, acl, screenshotPaths, sliceName, variation) {
+  const screenshot = screenshotPaths[variation.id];
+  if (!screenshot || !screenshot.path)
+    return Promise.resolve(variation);
+  return client.uploadScreenshot({
+    acl,
+    sliceName,
+    variationId: variation.id,
+    filePath: screenshot.path
+  }).then((screenshotUrl) => {
+    return {
+      ...variation,
+      imageUrl: screenshotUrl
+    };
+  }).catch((error) => {
+    writeError$1(`Couldn't upload screenshot slice: ${sliceName} - variation: ${variation.id}`);
+    writeError$1(error.message, "Full error:");
+    return variation;
+  });
+}
+async function updateSlicesWithScreenshots(client, acl, components) {
+  return Promise.all(components.map(async (component) => {
+    const { screenshotPaths, model } = component;
+    const variationsUpdated = await Promise.all(model.variations.map(async (variation) => updateVariationWithScreenshot(client, acl, screenshotPaths, model.id, variation)));
+    return {
+      ...model,
+      variations: variationsUpdated
+    };
+  }));
+}
+
+async function sendSlices(client, cwd, manifest) {
+  if (!manifest.libraries)
+    return Promise.resolve(false);
+  const libraries = Libraries__namespace.libraries(cwd, manifest.libraries);
+  const components = libraries.reduce((acc, lib) => {
+    return [...acc, ...lib.components];
+  }, []);
+  if (components.length === 0)
+    return Promise.resolve(false);
+  const remoteSlicesIds = await client.getSlices().then((slices) => slices.map((slice) => slice.id));
+  if (remoteSlicesIds.length) {
+    const pushAnyway = await promptToPushSlices();
+    if (pushAnyway === false)
+      return Promise.resolve(true);
+  }
+  const spinner = spinner$1("Pushing existing Slice models to your repository");
+  spinner.start();
+  const acl = await client.createAcl().catch((error) => {
+    writeError$1("Uploading screenshots for your slices failed, please contact us.");
+    writeError$1(error.message, "Full error:");
+    return null;
+  });
+  const models$1 = acl ? await updateSlicesWithScreenshots(client, acl, components) : components.map((component) => component.model);
+  await Promise.all(models$1.map(async (model) => {
+    const slice = models.Slices.fromSM(model);
+    const promise = remoteSlicesIds.includes(slice.id) ? client.updateSlice(slice) : client.insertSlice(slice);
+    return promise.catch((error) => {
+      writeError$1(`Sending slice ${model.id} - ${error.message}`);
+      throw error;
+    });
+  })).catch(() => {
+    process.exit(1);
+  });
+  spinner.succeed();
+  return Promise.resolve(true);
+}
+
+function readLocalCustomTypes(cwd) {
+  const customTypePaths = NodeUtils.CustomTypesPaths(cwd);
+  const dir = customTypePaths.value();
+  if (NodeUtils.Files.isDirectory(dir) === false)
+    return [];
+  const fileNames = NodeUtils.Files.readDirectory(dir);
+  const files = fileNames.reduce((acc, fileName) => {
+    const filePath = customTypePaths.customType(fileName).model();
+    const json = NodeUtils.Files.safeReadJson(filePath);
+    if (!json)
+      return acc;
+    const file = customtypes.CustomType.decode(json);
+    if (file instanceof Error) {
+      writeError$1(`reading ${filePath}: ${file.message}`);
+      return acc;
+    }
+    if (Either$1.isLeft(file)) {
+      writeError$1(`validating ${filePath}: ${JSON.stringify(file.left)}`);
+      return acc;
+    }
+    return [...acc, file.right];
+  }, []);
+  return files;
+}
+async function sendCustomTypes(client, cwd) {
+  const localCustomTypes = readLocalCustomTypes(cwd);
+  if (localCustomTypes.length === 0)
+    return Promise.resolve(false);
+  const remoteCustomTypeIds = await client.getCustomTypes().then((customTypes) => customTypes.map((customType) => customType.id));
+  if (remoteCustomTypeIds.length) {
+    const shouldPush = await promptToPushCustomTypes();
+    if (shouldPush === false)
+      return Promise.resolve(false);
+  }
+  const spinner = spinner$1("Pushing existing custom types to your repository");
+  spinner.start();
+  await Promise.all(localCustomTypes.map(async (customType) => {
+    const promise = remoteCustomTypeIds.includes(customType.id) ? client.updateCustomType(customType) : client.insertCustomType(customType);
+    return promise.catch((error) => {
+      writeError$1(`Sending custom type ${customType.id} - ${error.message}`);
+      throw error;
+    });
+  })).catch(() => {
+    process.exit(1);
+  });
+  spinner.succeed();
+  return Promise.resolve(true);
+}
+
+const SignatureFileReader = t__namespace.type({
+  signature: t__namespace.string
+});
+async function readSignatureFile(cwd) {
+  const pathToFile = path__default["default"].join(cwd, "documents", "index.json");
+  return fs__default["default"].promises.readFile(pathToFile, "utf-8").then((res) => {
+    const data = JSON.parse(res);
+    return Either.getOrElseW(() => {
+      throw new Error("Unable to read document signature file");
+    })(SignatureFileReader.decode(data));
+  });
+}
+async function readDocuments(cwd) {
+  const documentDir = path__default["default"].join(cwd, "documents");
+  const dirs = await lsdir(documentDir);
+  const files = (await Promise.all(dirs.map((dir) => lsfiles(dir)))).flat();
+  const documentObj = files.reduce((acc, file) => {
+    const filename = path__default["default"].parse(file).name;
+    const fileContent = fs__default["default"].readFileSync(file, "utf-8");
+    const json = JSON.parse(fileContent);
+    return { ...acc, [filename]: json };
+  }, {});
+  return documentObj;
+}
+async function sendDocuments(client, cwd) {
+  const pathToDocuments = path__default["default"].join(cwd, "documents");
+  const pathToSignatureFile = path__default["default"].join(pathToDocuments, "index.json");
+  if (!fs__default["default"].existsSync(pathToSignatureFile))
+    return Promise.resolve(false);
+  const signatureObj = await readSignatureFile(cwd);
+  const documents = await readDocuments(cwd);
+  if (Object.keys(documents).length === 0)
+    return Promise.resolve(false);
+  const spinner = spinner$1("Pushing existing documents to your repository");
+  spinner.start();
+  return client.pushDocuments(signatureObj.signature, documents, SharedConfig.PrismicSharedConfigManager.get().cookies).then(() => {
+    spinner.succeed();
+    fs__default["default"].rmSync(pathToDocuments, { recursive: true, force: true });
+    return true;
+  }).catch((e) => {
+    var _a;
+    spinner.fail();
+    if (((_a = e.response) == null ? void 0 : _a.data) === "Repository should not contain documents") {
+      writeError$1("The selected repository is not empty, documents cannot be uploaded. Please choose an empty repository or delete the documents contained in your repository.");
+    } else {
+      writeError$1("Sending documents failed, please try again. If the problem persists, contact us.");
+      writeError$1(`Full error: ${e.code || 500} - ${e.message}`);
+    }
+    process.exit(1);
+  });
+}
+
+async function sendStarterData(client, cwd, pushDocuments = true) {
+  const manifest = NodeUtils.retrieveManifest(cwd);
+  const documentsPath = path__default["default"].join(cwd, "documents");
+  const hasDocuments = NodeUtils.Files.exists(documentsPath);
+  if (manifest.exists === false || hasDocuments === false)
+    return Promise.resolve(false);
+  if (manifest.content)
+    await sendSlices(client, cwd, manifest.content);
+  await sendCustomTypes(client, cwd);
+  if (!pushDocuments) {
+    fs__default["default"].rmSync(documentsPath, { recursive: true, force: true });
+    return Promise.resolve(true);
+  }
+  return sendDocuments(client, cwd);
+}
+
 async function init() {
   const cwd = findArgument(process.argv, "cwd") || process.cwd();
-  const base = findArgument(process.argv, "base") || core.CONSTS.DEFAULT_BASE;
+  const mode = getApplicationMode(findArgument(process.argv, "mode")) || client.ApplicationMode.PROD;
   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");
+  const preSelectedRepository = findArgument(process.argv, "repository");
+  const pushDocuments = !findFlag(process.argv, "no-docs");
   Tracker.get().initialize("JfTfmHaATChc4xueS7RcCBsixI71dJIJ" , isTrackingAvailable);
-  void Tracker.get().trackInitStart(maybeRepositorySubdomain);
+  void Tracker.get().trackInitStart(preSelectedRepository);
+  const client$1 = new InitClient(mode, null, Prismic__default["default"].PrismicSharedConfigManager.getAuth());
   console.log(purple("You're about to configure Slicemachine... Press ctrl + C to cancel"));
   validatePkg(cwd);
-  const user = await loginOrBypass(base);
-  if (!user)
-    throw new Error("The user should be logged in!");
-  if (user.profile) {
-    Tracker.get().identifyUser(user.profile.shortId, user.profile.intercomHash);
-  }
+  const user = await loginOrBypass(client$1);
+  Tracker.get().identifyUser(user.shortId, user.intercomHash);
   void Tracker.get().trackInitIdentify();
-  const config = Prismic__default["default"].PrismicSharedConfigManager.get();
   const frameworkResult = await detectFramework(cwd);
-  const repositoryDomainName = await chooseOrCreateARepository(cwd, frameworkResult.value, config.cookies, config.base, maybeRepositorySubdomain);
-  Tracker.get().setRepository(repositoryDomainName);
-  await installRequiredDependencies(cwd, frameworkResult.value);
+  const repository = await chooseOrCreateARepository(client$1, cwd, frameworkResult.value, preSelectedRepository);
+  Tracker.get().setRepository(repository);
+  client$1.updateRepository(repository);
   const sliceLibPath = lib ? await installLib(cwd, lib, branch) : void 0;
-  await configureProject(cwd, base, repositoryDomainName, frameworkResult, sliceLibPath, isTrackingAvailable);
-  displayFinalMessage(cwd);
+  const wasStarter = await sendStarterData(client$1, cwd, pushDocuments);
+  await configureProject(client$1, cwd, repository, frameworkResult, sliceLibPath, isTrackingAvailable);
+  await installRequiredDependencies(cwd, frameworkResult.value, wasStarter);
+  displayFinalMessage(cwd, wasStarter, repository, client$1.apisEndpoints.Wroom);
 }
 init().then(() => {
   process.exit(0);