@slicemachine/init 1.0.2-alpha.4 → 1.0.2-alpha.44

package/build/utils/tracker.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tracker = exports.EventType = void 0;
+const analytics_node_1 = __importDefault(require("analytics-node"));
+var EventType;
+(function (EventType) {
+    EventType["DownloadLibrary"] = "SliceMachine Download Library";
+})(EventType = exports.EventType || (exports.EventType = {}));
+class Tracker {
+    constructor(analytics, repo, identifier, tracking = true) {
+        this.analytics = analytics;
+        this.repo = repo;
+        this.identifier = identifier;
+        this.tracking = tracking;
+        this.Track = {
+            downloadLibrary: (library) => {
+                this.trackEvent(EventType.DownloadLibrary, { library });
+            },
+        };
+    }
+    static build(writeKey, repo, identifier, tracking = true) {
+        try {
+            if (!repo)
+                return;
+            const analytics = new analytics_node_1.default(writeKey);
+            return new Tracker(analytics, repo, identifier, tracking);
+        }
+        catch (error) {
+            console.warn(error);
+            return;
+        }
+    }
+    trackEvent(eventType, attributes = {}) {
+        this.tracking &&
+            this.analytics.track({
+                event: eventType,
+                ...this.identifier,
+                properties: attributes,
+            });
+    }
+}
+exports.Tracker = Tracker;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhY2tlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlscy90cmFja2VyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7OztBQVFBLG9FQUE2QztBQUU3QyxJQUFZLFNBRVg7QUFGRCxXQUFZLFNBQVM7SUFDbkIsOERBQWlELENBQUE7QUFDbkQsQ0FBQyxFQUZXLFNBQVMsR0FBVCxpQkFBUyxLQUFULGlCQUFTLFFBRXBCO0FBRUQsTUFBYSxPQUFPO0lBQ2xCLFlBQ1csU0FBMEIsRUFDMUIsSUFBWSxFQUNaLFVBQXdELEVBQ3hELFdBQVcsSUFBSTtRQUhmLGNBQVMsR0FBVCxTQUFTLENBQWlCO1FBQzFCLFNBQUksR0FBSixJQUFJLENBQVE7UUFDWixlQUFVLEdBQVYsVUFBVSxDQUE4QztRQUN4RCxhQUFRLEdBQVIsUUFBUSxDQUFPO1FBK0IxQixVQUFLLEdBQUc7WUFFTixlQUFlLEVBQUUsQ0FBQyxPQUFlLEVBQVEsRUFBRTtnQkFDekMsSUFBSSxDQUFDLFVBQVUsQ0FBQyxTQUFTLENBQUMsZUFBZSxFQUFFLEVBQUUsT0FBTyxFQUFFLENBQUMsQ0FBQztZQUMxRCxDQUFDO1NBQ0YsQ0FBQztJQW5DQyxDQUFDO0lBRUosTUFBTSxDQUFDLEtBQUssQ0FDVixRQUFnQixFQUNoQixJQUF3QixFQUN4QixVQUF3RCxFQUN4RCxRQUFRLEdBQUcsSUFBSTtRQUVmLElBQUk7WUFDRixJQUFJLENBQUMsSUFBSTtnQkFBRSxPQUFPO1lBQ2xCLE1BQU0sU0FBUyxHQUFHLElBQUksd0JBQWUsQ0FBQyxRQUFRLENBQUMsQ0FBQztZQUNoRCxPQUFPLElBQUksT0FBTyxDQUFDLFNBQVMsRUFBRSxJQUFJLEVBQUUsVUFBVSxFQUFFLFFBQVEsQ0FBQyxDQUFDO1NBQzNEO1FBQUMsT0FBTyxLQUFLLEVBQUU7WUFDZCxPQUFPLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDO1lBQ3BCLE9BQU87U0FDUjtJQUNILENBQUM7SUFFTyxVQUFVLENBQ2hCLFNBQW9CLEVBQ3BCLGFBQXNDLEVBQUU7UUFFeEMsSUFBSSxDQUFDLFFBQVE7WUFDWCxJQUFJLENBQUMsU0FBUyxDQUFDLEtBQUssQ0FBQztnQkFDbkIsS0FBSyxFQUFFLFNBQVM7Z0JBQ2hCLEdBQUcsSUFBSSxDQUFDLFVBQVU7Z0JBQ2xCLFVBQVUsRUFBRSxVQUFVO2FBQ3ZCLENBQUMsQ0FBQztJQUNQLENBQUM7Q0FRRjtBQTFDRCwwQkEwQ0MifQ==

package/jest.config.js

@@ -13,4 +13,5 @@ module.exports = {
     "^.+\\.(ts|tsx)$": "ts-jest",
     "^.+\\.js$": "babel-jest",
   },
+  testTimeout: 15000,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slicemachine/init",
-  "version": "1.0.2-alpha.4",
+  "version": "1.0.2-alpha.44",
   "license": "MIT",
   "description": "The easiest way to add Slice Machine to your project",
   "bin": {
@@ -23,10 +23,14 @@
     "@babel/core": "^7.15.8",
     "@babel/preset-env": "^7.15.8",
     "@babel/preset-typescript": "^7.15.0",
+    "@types/adm-zip": "^0.4.34",
+    "@types/analytics-node": "^3.1.7",
+    "@types/fs-extra": "^9.0.13",
     "@types/inquirer": "^8.1.3",
     "@types/jest": "^27.0.2",
-    "@typescript-eslint/eslint-plugin": "^4.29.1",
-    "@typescript-eslint/parser": "^4.29.1",
+    "@types/tmp": "^0.2.2",
+    "@typescript-eslint/eslint-plugin": "^5.10.0",
+    "@typescript-eslint/parser": "^5.10.0",
     "babel-jest": "^27.0.2",
     "better-npm-audit": "^3.4.0",
     "eslint": "^7.32.0",
@@ -42,10 +46,15 @@
     "typescript": "^4.4.3"
   },
   "dependencies": {
-    "@slicemachine/core": "1.0.2-alpha.4",
+    "@slicemachine/core": "1.0.2-alpha.44",
+    "adm-zip": "^0.5.9",
+    "analytics-node": "^6.0.0",
+    "axios": "^0.24.0",
     "fp-ts": "^2.11.5",
+    "fs-extra": "^10.0.0",
     "inquirer": "^8.2.0",
-    "io-ts": "^2.2.16"
+    "io-ts": "^2.2.16",
+    "tmp": "^0.2.1"
   },
-  "gitHead": "d095d34843c9246acaae1070798806afa28527d3"
+  "gitHead": "17a73ae5e18d51ebdbd7980bed67dad93dcec95b"
 }

package/src/index.ts

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 
 import { Utils, FileSystem } from "@slicemachine/core";
+import { Tracker } from "./utils/tracker";
 import {
   installRequiredDependencies,
   validatePkg,
@@ -10,13 +11,17 @@ import {
   configureProject,
   displayFinalMessage,
   detectFramework,
+  installLib,
 } from "./steps";
 import { findArgument } from "./utils";
 
 async function init() {
   const cwd = findArgument(process.argv, "cwd") || process.cwd();
-  const base = (findArgument(process.argv, "base") ||
-    Utils.CONSTS.DEFAULT_BASE) as Utils.Endpoints.Base;
+  const base = findArgument(process.argv, "base") || Utils.CONSTS.DEFAULT_BASE;
+  const lib: string | undefined = findArgument(process.argv, "library");
+  const branch: string | undefined = findArgument(process.argv, "branch");
+  const isTrackingAvailable =
+    findArgument(process.argv, "tracking") === "false" ? false : true;
 
   console.log(
     Utils.purple(
@@ -28,10 +33,11 @@ async function init() {
   validatePkg(cwd);
 
   // login
-  await loginOrBypass(base);
+  const user = await loginOrBypass(base);
+  if (!user) throw new Error("The user should be logged in!");
 
   // retrieve tokens for api calls
-  const config = FileSystem.getOrCreateAuthConfig();
+  const config = FileSystem.PrismicSharedConfigManager.get();
 
   // detect the framework used by the project
   const frameworkResult = await detectFramework(cwd);
@@ -47,11 +53,33 @@ async function init() {
     await createRepository(name, frameworkResult.value, config);
   }
 
+  const tracker = user.profile?.shortId
+    ? Tracker.build(
+        "JfTfmHaATChc4xueS7RcCBsixI71dJIJ",
+        name,
+        {
+          userId: user.profile.shortId,
+        },
+        isTrackingAvailable
+      )
+    : undefined;
+
   // install the required dependencies in the project.
   await installRequiredDependencies(cwd, frameworkResult.value);
 
+  const sliceLibPath = lib
+    ? await installLib(tracker, cwd, lib, branch)
+    : undefined;
+
   // configure the SM.json file and the json package file of the project..
-  configureProject(cwd, base, name, frameworkResult);
+  configureProject(
+    cwd,
+    base,
+    name,
+    frameworkResult,
+    sliceLibPath,
+    isTrackingAvailable
+  );
 
   // ask the user to run slice-machine.
   displayFinalMessage(cwd);

package/src/steps/configure-project.ts

@@ -1,4 +1,5 @@
 import { FileSystem, Utils } from "@slicemachine/core";
+import type { Models } from "@slicemachine/core";
 import { FrameworkResult } from "./detect-framework";
 
 type Base = Utils.Endpoints.Base;
@@ -7,7 +8,9 @@ export function configureProject(
   cwd: string,
   base: Base,
   repository: string,
-  framework: FrameworkResult
+  framework: FrameworkResult,
+  sliceLibPath: string[] = [],
+  tracking = true
 ): void {
   const spinner = Utils.spinner(
     `Configuring your ${framework.value} & Prismic project...`
@@ -17,16 +20,25 @@ export function configureProject(
   try {
     const manifest = FileSystem.retrieveManifest(cwd);
 
-    const manifestUpdated: FileSystem.Manifest = {
+    const manifestUpdated: Models.Manifest = {
       ...(manifest.exists && manifest.content ? manifest.content : {}),
       apiEndpoint: Utils.Endpoints.buildRepositoryEndpoint(base, repository),
-      libraries: ["@/slices"],
+      libraries: ["@/slices", ...sliceLibPath],
       ...(framework.manuallyAdded ? { framework: framework.value } : {}),
+      ...(!tracking ? { tracking } : {}),
     };
 
     if (!manifest.exists) FileSystem.createManifest(cwd, manifestUpdated);
     else FileSystem.patchManifest(cwd, manifestUpdated);
 
+    // create the default slices folder if it doesn't exist.
+    const pathToSlicesFolder = FileSystem.CustomPaths(cwd)
+      .library("slices")
+      .value();
+    if (!Utils.Files.exists(pathToSlicesFolder))
+      Utils.Files.mkdir(pathToSlicesFolder, { recursive: true });
+
+    // add slicemachine script to package.json.
     FileSystem.addJsonPackageSmScript(cwd);
 
     spinner.succeed("Project configured! Ready to start");

package/src/steps/create-repo.ts

@@ -1,9 +1,10 @@
-import { Communication, Utils, FileSystem } from "@slicemachine/core";
+import { Communication, Utils } from "@slicemachine/core";
+import type { Models } from "@slicemachine/core";
 
 export function createRepository(
   domain: string,
-  framework: Utils.Framework.FrameworkEnum,
-  config: FileSystem.AuthConfig
+  framework: Models.Frameworks,
+  config: Models.PrismicSharedConfig
 ): Promise<void> {
   const spinner = Utils.spinner("Creating Prismic Repository");
   spinner.start();

package/src/steps/detect-framework.ts

@@ -1,13 +1,14 @@
 import { Utils } from "@slicemachine/core";
+import { Models } from "@slicemachine/core";
 import * as inquirer from "inquirer";
 
 export type FrameworkResult = {
-  value: Utils.Framework.FrameworkEnum;
+  value: Models.Frameworks;
   manuallyAdded: boolean;
 };
 
 export async function promptForFramework(): Promise<FrameworkResult> {
-  const choices = Utils.Framework.SupportedFrameworks.map((framework) => {
+  const choices = Models.SupportedFrameworks.map((framework) => {
     return {
       name: Utils.Framework.fancyName(framework),
       value: framework,
@@ -15,7 +16,7 @@ export async function promptForFramework(): Promise<FrameworkResult> {
   });
 
   return inquirer
-    .prompt<{ framework: Utils.Framework.FrameworkEnum }>([
+    .prompt<{ framework: Models.Frameworks }>([
       {
         name: "framework",
         type: "list",
@@ -44,13 +45,13 @@ export async function detectFramework(cwd: string): Promise<FrameworkResult> {
   spinner.start();
 
   try {
-    const maybeFramework = Utils.Framework.detectFramework(cwd);
+    const maybeFramework = Utils.Framework.detectFramework(
+      cwd,
+      Object.values(Models.Frameworks)
+    );
     spinner.stop();
 
-    if (
-      !maybeFramework ||
-      maybeFramework === Utils.Framework.FrameworkEnum.vanillajs
-    ) {
+    if (!maybeFramework || maybeFramework === Models.Frameworks.vanillajs) {
       Utils.writeError("Framework not detected");
       return await promptForFramework();
     }

package/src/steps/index.ts

@@ -6,3 +6,4 @@ export { detectFramework } from "./detect-framework";
 export { loginOrBypass } from "./loginOrBypass";
 export { configureProject } from "./configure-project";
 export { displayFinalMessage } from "./display-final-message";
+export { installLib } from "./install-lib";

package/src/steps/install-lib.ts

@@ -0,0 +1,115 @@
+import { Utils } from "@slicemachine/core";
+import tmp from "tmp";
+import AdmZip from "adm-zip";
+import fsExtra from "fs-extra";
+import axios from "axios";
+
+import fs from "fs";
+import path from "path";
+import { getOrElseW } from "fp-ts/Either";
+import { PackageManager, Dependencies } from "../utils/PackageManager";
+import { PackageJsonHelper } from "@slicemachine/core/build/src/utils/PackageJson";
+import {
+  Manifest,
+  ManifestHelper,
+} from "@slicemachine/core/build/src/models/Manifest";
+import Files from "@slicemachine/core/build/src/utils/files";
+import { Tracker } from "../utils/tracker";
+
+const downloadFile = async (reqUrl: string): Promise<string> => {
+  const res = await axios.get<Buffer>(reqUrl, { responseType: "arraybuffer" });
+
+  return new Promise((resolve, reject) => {
+    if (res.status == 200) {
+      const tmpZipFile = tmp.tmpNameSync();
+      const zip = new AdmZip(res.data);
+      zip.extractAllTo(tmpZipFile);
+      resolve(tmpZipFile);
+    } else {
+      reject();
+    }
+  });
+};
+
+function toGithubSource(githubPath: string, branch: string): string {
+  return `https://codeload.github.com/${githubPath}/zip/${branch}`;
+}
+
+export async function installLib(
+  tracker: Tracker | undefined,
+  cwd: string,
+  libGithubPath: string,
+  branch = "HEAD"
+): Promise<string[] | undefined> {
+  const spinner = Utils.spinner(
+    `Installing the ${libGithubPath} lib in your project...`
+  );
+
+  try {
+    spinner.start();
+
+    const [githubUserName, githubProjectName] = libGithubPath.split("/");
+    const source = toGithubSource(libGithubPath, branch);
+
+    const zipFilePath = await downloadFile(source);
+    const outputFolder = `${githubProjectName}-${branch}`;
+    const projectPath = path.join(zipFilePath, outputFolder);
+
+    const name = `${githubUserName}-${githubProjectName}`;
+    const libDestinationFolder = path.join(cwd, name);
+
+    // We should be able to offer the ability to override or not an existing library
+    if (fs.existsSync(libDestinationFolder)) {
+      spinner.succeed(`Lib "${libGithubPath}" was already installed (skipped)`);
+      return;
+    }
+
+    // We copy all the slices into the the user project minus the src folder
+    fsExtra.moveSync(path.join(projectPath, "src"), libDestinationFolder);
+
+    // handle dependencies
+    const pkgManager = PackageManager.get(cwd);
+    const pkgJson = PackageJsonHelper.fromPath(
+      path.join(projectPath, "package.json")
+    );
+    if (pkgJson instanceof Error) throw pkgJson;
+
+    const dependencies = Dependencies.fromPkgFormat(pkgJson.dependencies);
+    if (dependencies) await pkgManager.install(dependencies);
+
+    // generate meta file
+    Files.write(path.join(libDestinationFolder, "meta.json"), {
+      name: pkgJson.name,
+    });
+
+    // retrieve all slices lib paths
+    const manifest = Files.readEntity<Error | Manifest>(
+      path.join(projectPath, "sm.json"),
+      (payload: unknown) => {
+        return getOrElseW(
+          () => new Error(`Unable to parse sm.json from lib ${libGithubPath}`)
+        )(Manifest.decode(payload));
+      }
+    );
+    if (manifest instanceof Error) throw manifest;
+
+    const localLibs = ManifestHelper.localLibraries(manifest).map(
+      ({ path }) => {
+        return `~/${name}/${path.replace("src/", "")}`;
+      }
+    );
+
+    spinner.succeed(
+      `Slice library "${libGithubPath}" was installed successfully`
+    );
+
+    tracker?.Track.downloadLibrary(libGithubPath);
+    return localLibs;
+  } catch (error) {
+    spinner.fail(`Error installing ${libGithubPath} lib!`);
+    if (error instanceof Error) {
+      console.error(error.message);
+    }
+    process.exit(-1);
+  }
+}

package/src/steps/install-required-dependencies.ts

@@ -1,6 +1,6 @@
 import path from "path";
 import { execCommand } from "../utils";
-import { Utils, FileSystem } from "@slicemachine/core";
+import { Utils, FileSystem, Models } from "@slicemachine/core";
 
 const {
   PRISMIC_CLIENT,
@@ -12,20 +12,22 @@ const {
   NUXT_SM,
   VUE_SLICEZONE,
   PRISMIC_VUE,
+  SLICE_SIMULATOR_REACT,
+  SLICE_SIMULATOR_VUE,
 } = Utils.CONSTS;
 
-function depsForFramework(framework: Utils.Framework.FrameworkEnum): string {
+function depsForFramework(framework: Models.Frameworks): string {
   switch (framework) {
-    case Utils.Framework.FrameworkEnum.react:
+    case Models.Frameworks.react:
       return `${PRISMIC_REACT_PACKAGE_NAME} ${PRISMIC_CLIENT}`;
-    case Utils.Framework.FrameworkEnum.next:
-      return `${PRISMIC_REACT_PACKAGE_NAME} ${PRISMIC_CLIENT} ${NEXT_SLICEZONE}`;
-    case Utils.Framework.FrameworkEnum.svelte:
+    case Models.Frameworks.next:
+      return `${PRISMIC_REACT_PACKAGE_NAME} ${PRISMIC_CLIENT}@v5.1.1 ${NEXT_SLICEZONE} ${SLICE_SIMULATOR_REACT}`;
+    case Models.Frameworks.svelte:
       return `${PRISMIC_DOM_PACKAGE_NAME} ${PRISMIC_CLIENT}`;
-    case Utils.Framework.FrameworkEnum.nuxt:
-      return `${NUXT_PRISMIC} ${NUXT_SM} ${VUE_SLICEZONE}`;
-    case Utils.Framework.FrameworkEnum.vue:
-      return `${PRISMIC_VUE} ${PRISMIC_CLIENT} ${PRISMIC_DOM_PACKAGE_NAME} ${VUE_SLICEZONE}`;
+    case Models.Frameworks.nuxt:
+      return `${NUXT_PRISMIC} ${NUXT_SM} ${VUE_SLICEZONE} ${SLICE_SIMULATOR_VUE}`;
+    case Models.Frameworks.vue:
+      return `${PRISMIC_VUE} ${PRISMIC_CLIENT}@v5.1.1 ${PRISMIC_DOM_PACKAGE_NAME} ${VUE_SLICEZONE}`;
     default:
       return "";
   }
@@ -33,7 +35,7 @@ function depsForFramework(framework: Utils.Framework.FrameworkEnum): string {
 
 export async function installRequiredDependencies(
   cwd: string,
-  framework: Utils.Framework.FrameworkEnum
+  framework: Models.Frameworks
 ): Promise<void> {
   const yarnLock = Utils.Files.exists(FileSystem.YarnLockPath(cwd));
   const installDevDependencyCommand = yarnLock

package/src/steps/loginOrBypass.ts

@@ -1,7 +1,23 @@
-import { Utils, Auth } from "@slicemachine/core";
+import { Utils, Communication, Auth } from "@slicemachine/core";
+import {
+  validateSessionAndGetProfile,
+  UserProfile,
+} from "../utils/communication";
 
-export async function loginOrBypass(base: string): Promise<void> {
-  const user = await Auth.validateSession(base);
-  if (user) return Utils.writeCheck(`Logged in as ${Utils.bold(user.email)}`);
-  else await Auth.login(base);
+export async function loginOrBypass(base: string): Promise<{
+  info: Communication.UserInfo;
+  profile: UserProfile | null;
+} | null> {
+  const user = await validateSessionAndGetProfile(base).catch((err) =>
+    console.log(err)
+  );
+  if (user) {
+    const email = user.info.email;
+    Utils.writeCheck(`Logged in as ${Utils.bold(email)}`);
+    return user;
+  } else {
+    await Auth.login(base);
+    const user = await validateSessionAndGetProfile(base);
+    return user;
+  }
 }

package/src/steps/maybe-existing-repo.ts

@@ -1,7 +1,9 @@
 import * as inquirer from "inquirer";
 import Separator from "inquirer/lib/objects/separator";
 import { Communication, Utils, FileSystem } from "@slicemachine/core";
-import { RepoData } from "@slicemachine/core/src/core/communication";
+import { Repositories } from "@slicemachine/core/src/models/Repositories";
+import { Repository } from "@slicemachine/core/src/models/Repository";
+import { parsePrismicAuthToken } from "@slicemachine/core/build/src/utils/cookie";
 
 export const CREATE_REPO = "$_CREATE_REPO"; // not a valid domain name
 const DEFAULT_BASE = Utils.CONSTS.DEFAULT_BASE;
@@ -28,7 +30,7 @@ export async function promptForRepoName(base: string): Promise<string> {
         type: "input",
         required: true,
         transformer: (value) => prettyRepoName(address, String(value)),
-        async validate(name) {
+        async validate(name: string) {
           const result = await Communication.validateRepositoryName(
             name,
             base,
@@ -48,30 +50,24 @@ export type PromptOrSeparator = RepoPrompt | Separator;
 export type RepoPrompts = Array<PromptOrSeparator>;
 
 export function makeReposPretty(base: string) {
-  return function (
-    arg: [
-      string,
-      { role: Utils.roles.Roles | Record<string, Utils.roles.Roles> }
-    ]
-  ): RepoPrompt {
-    const [repoName, { role }] = arg;
+  return function ({ name, domain, role }: Repository): RepoPrompt {
     const address = new URL(base);
-    address.hostname = `${repoName}.${address.hostname}`;
+    address.hostname = `${domain}.${address.hostname}`;
     if (Utils.roles.canUpdateCustomTypes(role) === false) {
       return {
         name: `${Utils.purple.dim("Use")} ${Utils.bold.dim(
-          repoName
+          name
         )} ${Utils.purple.dim(`"${address.hostname}"`)}`,
-        value: repoName,
+        value: domain,
         disabled: "Unauthorized",
       };
     }
 
     return {
-      name: `${Utils.purple("Use")} ${Utils.bold(repoName)} ${Utils.purple(
+      name: `${Utils.purple("Use")} ${Utils.bold(name)} ${Utils.purple(
         `"${address.hostname}"`
       )}`,
-      value: repoName,
+      value: name,
     };
   };
 }
@@ -97,7 +93,7 @@ export function maybeStickTheRepoToTheTopOfTheList(repoName?: string | null) {
 }
 
 export function sortReposForPrompt(
-  repos: RepoData,
+  repos: Repositories,
   base: string,
   cwd: string
 ): RepoPrompts {
@@ -110,7 +106,7 @@ export function sortReposForPrompt(
 
   const maybeConfiguredRepoName = FileSystem.maybeRepoNameFromSMFile(cwd, base);
 
-  return Object.entries(repos)
+  return repos
     .reverse()
     .map(makeReposPretty(base))
     .reduce(maybeStickTheRepoToTheTopOfTheList(maybeConfiguredRepoName), [
@@ -120,13 +116,14 @@ export function sortReposForPrompt(
 }
 
 export async function maybeExistingRepo(
-  cookie: string,
+  cookies: string,
   cwd: string,
   base = DEFAULT_BASE
 ): Promise<{ name: string; existing: boolean }> {
-  const repos = await Communication.listRepositories(cookie, base);
+  const token = parsePrismicAuthToken(cookies);
+  const repos = await Communication.listRepositories(token);
 
-  if (Object.keys(repos).length === 0) {
+  if (repos.length === 0) {
     const name = await promptForRepoName(base);
     return { existing: false, name };
   }

package/src/utils/PackageManager.ts

@@ -0,0 +1,66 @@
+import { Utils, FileSystem } from "@slicemachine/core";
+import { execCommand } from "../utils";
+
+export type Dependency = string | { name: string; version: string };
+export const Dependencies = {
+  fromPkgFormat(
+    pkgDeps: Record<string, string> | undefined
+  ): ReadonlyArray<Dependency> | undefined {
+    if (!pkgDeps) return;
+
+    return Object.entries(pkgDeps).map(([name, version]) => ({
+      name,
+      version,
+    }));
+  },
+};
+function formatDeps(dependencies: ReadonlyArray<Dependency>): string {
+  return dependencies
+    .map((dep) => {
+      if (typeof dep === "string") return dep;
+      return `${dep.name}@${dep.version}`;
+    })
+    .join(" ");
+}
+
+export interface PackageManager {
+  install(dependencies: ReadonlyArray<Dependency>): Promise<{ stderr: string }>;
+  installDev(
+    dependencies: ReadonlyArray<Dependency>
+  ): Promise<{ stderr: string }>;
+}
+
+export const PackageManager = {
+  get(cwd: string): PackageManager {
+    if (Utils.Files.exists(FileSystem.YarnLockPath(cwd))) {
+      return Yarn;
+    }
+    return Npm;
+  },
+};
+
+export const Yarn: PackageManager = {
+  install(
+    dependencies: ReadonlyArray<Dependency>
+  ): Promise<{ stderr: string }> {
+    return execCommand(`yarn add ${formatDeps(dependencies)}`);
+  },
+  installDev(
+    dependencies: ReadonlyArray<Dependency>
+  ): Promise<{ stderr: string }> {
+    return execCommand(`yarn add --dev ${formatDeps(dependencies)}`);
+  },
+};
+
+export const Npm: PackageManager = {
+  install(
+    dependencies: ReadonlyArray<Dependency>
+  ): Promise<{ stderr: string }> {
+    return execCommand(`npm i --save ${formatDeps(dependencies)}`);
+  },
+  installDev(
+    dependencies: ReadonlyArray<Dependency>
+  ): Promise<{ stderr: string }> {
+    return execCommand(`npm i --save-dev ${formatDeps(dependencies)}`);
+  },
+};