contensis-cli 1.0.0-beta.10 → 1.0.0-beta.100

package/src/services/ContensisCliService.ts

@@ -1,72 +1,81 @@
+import to from 'await-to-js';
+import chalk from 'chalk';
 import fs from 'fs';
-import path from 'path';
-import fetch from 'node-fetch';
 import inquirer from 'inquirer';
-import to from 'await-to-js';
-import { Component, ContentType } from 'contensis-core-api';
-import { isPassword, isSharedSecret, isUuid, url } from '~/util';
-import SessionCacheProvider from '../providers/SessionCacheProvider';
-import ContensisAuthService from './ContensisAuthService';
-import CredentialProvider from '~/providers/CredentialProvider';
-import { logError, Logger } from '~/util/logger';
-import { LogMessages } from '~/localisation/en-GB';
+import fetch from 'node-fetch';
+import path from 'path';
+
+import { Component, ContentType, Project } from 'contensis-core-api';
+import { Node } from 'contensis-delivery-api/lib/models';
+import { Entry, Role } from 'contensis-management-api/lib/models';
 import {
   ContensisMigrationService,
   MigrateRequest,
   PushBlockParams,
   SourceCms,
   logEntriesTable,
+  ContentTypesResult,
+  Model,
+  MigrateModelsResult,
+  BlockActionType,
 } from 'migratortron';
-import { Entry } from 'contensis-management-api/lib/models';
 
-import { csvFormatter } from '~/util/csv.formatter';
-import { xmlFormatter } from '~/util/xml.formatter';
-import { jsonFormatter } from '~/util/json.formatter';
-import { printBlockVersion, printMigrateResult } from '~/util/console.printer';
-import { readJsonFile } from '~/providers/file-provider';
-
-type OutputFormat = 'json' | 'csv' | 'xml';
+import ContensisAuthService from './ContensisAuthService';
 
-type OutputOptions = {
-  format?: OutputFormat;
-  output?: string;
-};
+import { LogMessages } from '~/localisation/en-GB';
+import { OutputFormat, OutputOptionsConstructorArg } from '~/models/CliService';
 
-interface IConnectOptions extends IAuthOptions {
-  alias?: string;
-  projectId?: string;
-}
+import { readJsonFile } from '~/providers/file-provider';
+import SessionCacheProvider from '../providers/SessionCacheProvider';
+import CredentialProvider from '~/providers/CredentialProvider';
 
-interface IAuthOptions {
-  user?: string;
-  password?: string;
-  clientId?: string;
-  sharedSecret?: string;
-}
+import {
+  isPassword,
+  isSharedSecret,
+  isUuid,
+  tryParse,
+  tryStringify,
+  url,
+} from '~/util';
+import {
+  printBlockVersion,
+  printMigrateResult,
+  printModelMigrationAnalysis,
+  printModelMigrationResult,
+} from '~/util/console.printer';
+import { csvFormatter } from '~/util/csv.formatter';
+import { xmlFormatter } from '~/util/xml.formatter';
+import { jsonFormatter } from '~/util/json.formatter';
+import { diffLogStrings } from '~/util/diff';
+import { logError, Logger } from '~/util/logger';
+import { promiseDelay } from '~/util/timers';
+import { findByIdOrName } from '~/util/find';
 
-interface IImportOptions {
-  sourceEnv?: string;
-  sourceProjectId?: string;
-}
+let insecurePasswordWarningShown = false;
 
 class ContensisCli {
   static quit = (error?: Error) => {
     process.removeAllListeners('exit');
     const exitCode = error ? 1 : 0;
 
-    console.info(`\nExiting contensis-cli with exit code: ${exitCode}\n`);
+    // console.info(`\nExiting contensis-cli with exit code: ${exitCode}\n`);
     process.exit(exitCode);
   };
 
-  cache: SessionCache;
+  private command: CliCommand;
+  private format?: OutputFormat;
+  private output?: string;
+  private session: SessionCacheProvider;
+
   contensis?: ContensisMigrationService;
   contensisOpts: Partial<MigrateRequest>;
-  contentTypes?: ContentType[];
-  components?: Component[];
-  currentEnv: string;
   currentProject: string;
-  env: EnvironmentCache;
-  sourceEnv?: string;
+
+  clientDetailsLocation?: 'env' | 'git';
+  clientId?: string;
+  clientSecret?: string;
+
+  sourceAlias?: string;
   targetEnv?: string;
   urls:
     | {
@@ -78,20 +87,50 @@ class ContensisCli {
         iisPreviewWeb: string;
       }
     | undefined;
-  private command: CliCommand;
-  private format?: OutputFormat;
-  private output?: string;
   log = Logger;
   messages = LogMessages;
-  private session: SessionCacheProvider;
 
   verb: string;
   noun: string;
   thirdArg: string;
 
+  get cache() {
+    return this.session.Get();
+  }
+
+  get currentEnv() {
+    return this.cache.currentEnvironment || '';
+  }
+
+  set currentEnv(currentEnvironment: string) {
+    this.session.Update({ currentEnvironment });
+  }
+
+  get env() {
+    const currentEnvironment = this.currentEnv;
+    const environments = this.cache.environments || {};
+
+    if (!currentEnvironment) return {} as EnvironmentCache;
+    else if (!!environments[currentEnvironment])
+      return environments[currentEnvironment];
+    else {
+      return {
+        history: [],
+        lastUserId: '',
+        projects: [],
+        versionStatus: 'latest',
+      } as EnvironmentCache;
+    }
+  }
+
   constructor(
     args: string[],
-    outputOpts?: OutputOptions & IConnectOptions & IImportOptions,
+    outputOpts?: OutputOptionsConstructorArg,
+    contensisOpts?: Partial<MigrateRequest>
+  );
+  constructor(
+    args: string[],
+    outputOpts?: OutputOptionsConstructorArg,
     contensisOpts: Partial<MigrateRequest> = {}
   ) {
     // console.log('args: ', JSON.stringify(args, null, 2));
@@ -106,40 +145,28 @@ class ContensisCli {
     }`.trim();
 
     this.session = new SessionCacheProvider();
-    this.cache = this.session.Get();
+
     this.contensisOpts = contensisOpts;
     this.format = outputOpts?.format;
     this.output =
       outputOpts?.output && path.join(process.cwd(), outputOpts.output);
 
-    const currentEnvironment =
-      outputOpts?.alias || this.cache.currentEnvironment || '';
+    const currentEnvironment = outputOpts?.alias || this.currentEnv;
     const environments = this.cache.environments || {};
-
-    if (!currentEnvironment) this.env = {} as EnvironmentCache;
-    else if (!!environments[currentEnvironment])
-      this.env = environments[currentEnvironment];
-    else {
-      this.env = {
-        history: [],
-        lastUserId: '',
-        projects: [],
-        versionStatus: 'latest',
-      };
-    }
+    this.currentEnv = currentEnvironment;
 
     const env = this.env;
 
     if (outputOpts?.projectId) env.currentProject = outputOpts.projectId;
     if (outputOpts?.user) env.lastUserId = outputOpts.user;
+    // setting this in env means passwordFallback is written to environments.json
     if (outputOpts?.password) env.passwordFallback = outputOpts.password;
     if (outputOpts?.clientId) env.lastUserId = outputOpts.clientId;
     if (outputOpts?.sharedSecret)
       env.passwordFallback = outputOpts.sharedSecret;
 
-    this.currentEnv = currentEnvironment;
     this.currentProject = env?.currentProject || 'null';
-    this.sourceEnv = outputOpts?.sourceEnv || currentEnvironment;
+    this.sourceAlias = outputOpts?.sourceAlias || currentEnvironment;
 
     if (currentEnvironment) {
       this.urls = url(currentEnvironment, env?.currentProject || 'website');
@@ -154,7 +181,7 @@ class ContensisCli {
     if (currentEnvironment) {
       env.history = [this.command];
       if (commandText) {
-        environments[currentEnvironment] = this.env;
+        environments[currentEnvironment] = env;
         this.session.Update({
           currentEnvironment,
           environments,
@@ -181,45 +208,24 @@ class ContensisCli {
   };
 
   Connect = async (environment: string) => {
-    const { cache, log, messages, session } = this;
+    const { log, messages, session } = this;
 
     if (environment) {
-      const envCache = cache.environments[environment];
-      if (!envCache)
-        cache.environments[environment] = {
-          versionStatus: 'published',
-          history: [],
-          lastUserId: '',
-          projects: [],
-          ...(!this.currentEnv ? this.env : {}),
-        };
-
-      this.env = cache.environments[environment];
       this.currentEnv = environment;
       this.urls = url(environment, 'website');
 
       const [fetchErr, response] = await to(fetch(this.urls.cms));
       if (response && response?.status < 400) {
         log.success(messages.connect.connected(environment));
+        session.UpdateEnv(this.env, environment);
 
         if (this.env?.lastUserId) {
-          await this.ConnectContensis();
+          // await this.ConnectContensis();
           await this.PrintProjects();
         } else {
           log.warning(messages.projects.noList());
           log.help(messages.connect.tip());
-          // cache.environments[environment] = {
-          //   versionStatus: 'published',
-          //   history: [],
-          //   lastUserId: '',
-          //   projects: [],
-          // };
         }
-
-        session.Update({
-          currentEnvironment: environment,
-          environments: cache.environments,
-        });
       } else {
         // Cannot reach environment - status X
         log.error(
@@ -233,68 +239,76 @@ class ContensisCli {
   };
 
   ConnectContensis = async ({ commit = false } = {}) => {
-    const { contensisOpts, currentEnv, env, log, messages } = this;
-    const userId = env?.lastUserId;
-    const isGuidId = userId && isUuid(userId);
+    if (!this.contensis) {
+      const { contensisOpts, currentEnv, env, log, messages } = this;
+      const userId = env?.lastUserId;
+      const isGuidId = userId && isUuid(userId);
 
-    if (currentEnv && userId) {
-      const [credentialError, credentials] = await new CredentialProvider(
-        {
+      if (currentEnv && userId) {
+        const credentials = await this.GetCredentials(
           userId,
-          alias: currentEnv,
-        },
-        env.passwordFallback
-      ).Init();
+          env.passwordFallback
+        );
 
-      if (credentialError && !credentials.current) {
-        // Log problem with Credential Provider
-        log.error(credentialError as any);
-        return;
-      }
-      const cachedPassword = credentials?.current?.password;
-
-      if (cachedPassword) {
-        this.contensis = new ContensisMigrationService(
-          {
-            ...contensisOpts,
-            source: {
-              url: this.urls?.cms || '',
-              username: !isGuidId ? userId : undefined,
-              password: !isGuidId ? cachedPassword : undefined,
-              clientId: isGuidId ? userId : undefined,
-              sharedSecret: isGuidId ? cachedPassword : undefined,
-              project: env?.currentProject || '',
-              assetHostname: this.urls?.previewWeb,
+        const cachedPassword = credentials?.current?.password;
+
+        if (cachedPassword) {
+          this.contensis = new ContensisMigrationService(
+            {
+              ...contensisOpts,
+              source: {
+                url: this.urls?.cms || '',
+                username: !isGuidId ? userId : undefined,
+                password: !isGuidId ? cachedPassword : undefined,
+                clientId: isGuidId ? userId : undefined,
+                sharedSecret: isGuidId ? cachedPassword : undefined,
+                project: env?.currentProject || '',
+                assetHostname: this.urls?.previewWeb,
+              },
+              concurrency:
+                typeof contensisOpts.concurrency !== 'undefined'
+                  ? contensisOpts.concurrency
+                  : 3,
+              outputProgress: true,
             },
-            concurrency:
-              typeof contensisOpts.concurrency !== 'undefined'
-                ? contensisOpts.concurrency
-                : 3,
-            outputProgress: true,
-          },
-          !commit
-        );
+            !commit
+          );
+        }
+      } else {
+        if (!currentEnv) log.help(messages.connect.help());
+        if (!userId) log.help(messages.connect.tip());
       }
-    } else {
-      if (!currentEnv) log.help(messages.connect.help());
-      if (!userId) log.help(messages.connect.tip());
     }
+    return this.contensis;
   };
 
   ConnectContensisImport = async ({
-    commit,
-    source,
-    fileData,
-    fileDataType,
+    commit = false,
+    fromFile,
+    importDataType,
   }: {
-    commit: boolean;
-    source: 'contensis' | 'file' | 'input';
-    fileData?: any[] | string;
-    fileDataType?: 'entries' | 'contentTypes' | 'components';
+    commit?: boolean;
+    fromFile?: string;
+    importDataType?:
+      | 'entries'
+      | 'contentTypes'
+      | 'components'
+      | 'models'
+      | 'nodes'
+      | 'user-input';
   }) => {
-    const { contensisOpts, currentEnv, env, log, messages, sourceEnv } = this;
+    const source: 'contensis' | 'file' = fromFile ? 'file' : 'contensis';
+
+    const fileData = fromFile
+      ? readJsonFile<(Entry | ContentType | Component)[]>(fromFile) || []
+      : [];
+
+    if (typeof fileData === 'string')
+      throw new Error(`Import file format must be of type JSON`);
+
+    const { contensisOpts, currentEnv, env, log, messages, sourceAlias } = this;
     const environments = this.cache.environments || {};
-    const sourceEnvironment = environments[sourceEnv || ''] || {};
+    const sourceEnvironment = environments[sourceAlias || ''] || {};
     const sourceCms =
       ('source' in contensisOpts && contensisOpts.source) ||
       ({} as Partial<SourceCms>);
@@ -303,7 +317,7 @@ class ContensisCli {
     const sourceProjectId =
       sourceCms.project || sourceEnvironment.currentProject || 'website';
     const isSourceGuidId = sourceUserId && isUuid(sourceUserId);
-    const sourceUrls = url(sourceEnv || '', sourceProjectId);
+    const sourceUrls = url(sourceAlias || '', sourceProjectId);
 
     const sourcePassword =
       sourceCms.sharedSecret ||
@@ -314,40 +328,24 @@ class ContensisCli {
     const isTargetGuidId = targetUserId && isUuid(targetUserId);
 
     if (sourceUserId && currentEnv && targetUserId) {
-      const [sourceCredentialError, sourceCredentials] =
-        await new CredentialProvider(
-          {
-            userId: sourceUserId,
-            alias: currentEnv,
-          },
-          sourcePassword
-        ).Init();
-
-      if (sourceCredentialError && !sourceCredentials.current) {
-        // Log problem with Credential Provider
-        logError(sourceCredentialError);
-        return;
-      }
+      const sourceCredentials = await this.GetCredentials(
+        sourceUserId,
+        sourcePassword,
+        sourceAlias,
+        false
+      );
+
       const cachedSourcePassword = sourceCredentials?.current?.password;
 
-      const [targetCredentialError, targetCredentials] =
-        await new CredentialProvider(
-          {
-            userId: targetUserId,
-            alias: currentEnv,
-          },
-          env.passwordFallback
-        ).Init();
+      const targetCredentials = await this.GetCredentials(
+        targetUserId,
+        env.passwordFallback
+      );
 
-      if (targetCredentialError && !targetCredentials.current) {
-        // Log problem with Credential Provider
-        log.error(targetCredentialError as any);
-        return;
-      }
       const cachedTargetPassword = targetCredentials?.current?.password;
 
       if (cachedSourcePassword && cachedTargetPassword) {
-        if (source === 'file' || source === 'input') {
+        if (source === 'file' || importDataType === 'user-input') {
           this.contensis = new ContensisMigrationService(
             {
               concurrency: 3,
@@ -362,12 +360,11 @@ class ContensisCli {
                 targetProjects: [env.currentProject || ''],
                 assetHostname: this.urls?.previewWeb,
               },
-              ...(fileDataType ? { [fileDataType]: fileData } : {}),
+              ...(importDataType ? { [importDataType]: fileData } : {}),
             },
             !commit
           );
-        }
-        if (source === 'contensis') {
+        } else if (source === 'contensis') {
           this.contensis = new ContensisMigrationService(
             {
               concurrency: 3,
@@ -400,6 +397,40 @@ class ContensisCli {
       if (!currentEnv) log.help(messages.connect.help());
       if (!targetUserId) log.help(messages.connect.tip());
     }
+    return this.contensis;
+  };
+
+  GetCredentials = async (
+    userId: string,
+    password?: string,
+    currentEnv = this.currentEnv,
+    saveCurrentEnv = true
+  ): Promise<CredentialProvider | undefined> => {
+    const { log, messages } = this;
+    if (userId) {
+      const [credentialError, credentials] = await new CredentialProvider(
+        { userId, alias: currentEnv },
+        password
+      ).Init();
+
+      if (credentialError && !credentials.current) {
+        // Log problem with Credential Provider
+        log.error(credentialError as any);
+        return;
+      }
+
+      if (credentials.remarks.secure !== true) {
+        if (!insecurePasswordWarningShown) {
+          log.warning(messages.login.insecurePassword());
+          insecurePasswordWarningShown = true;
+        }
+      } else {
+        const env = this.cache.environments[currentEnv];
+        env.passwordFallback = undefined;
+        this.session.UpdateEnv(env, currentEnv, saveCurrentEnv);
+      }
+      return credentials;
+    }
   };
 
   Login = async (
@@ -409,111 +440,102 @@ class ContensisCli {
       promptPassword = true,
       sharedSecret = isSharedSecret(this.env.passwordFallback),
       silent = false,
+      attempt = 1,
     }: {
       password?: string;
       promptPassword?: boolean;
       sharedSecret?: string;
       silent?: boolean;
-    }
+      attempt?: number;
+    } = {}
   ): Promise<string | undefined> => {
-    let inputPassword = password;
+    let inputPassword = password || sharedSecret;
     const { log, messages } = this;
 
     if (userId) {
-      const { cache, currentEnv, env } = this;
+      const { currentEnv, env } = this;
 
       if (currentEnv) {
-        const [credentialError, credentials] = await new CredentialProvider(
-          { userId, alias: currentEnv },
-          inputPassword || sharedSecret
-        ).Init();
-
-        if (credentialError && !credentials.current) {
-          // Log problem with Credential Provider
-          log.error(credentialError as any);
-          return;
-        }
-
-        if (credentials.remarks.secure !== true)
-          log.warning(messages.login.insecurePassword());
-
-        const cachedPassword = isPassword(credentials?.current?.password);
-        const cachedSecret = isSharedSecret(credentials?.current?.password);
-
-        if (
-          !sharedSecret &&
-          !inputPassword &&
-          !cachedPassword &&
-          !cachedSecret &&
-          promptPassword
-        ) {
-          // Password prompt
-          ({ inputPassword } = await inquirer.prompt([
-            {
-              type: 'password',
-              message: messages.login.passwordPrompt(currentEnv, userId),
-              name: 'inputPassword',
-              mask: '*',
-              prefix: undefined,
-            },
-          ]));
-        }
+        const credentials = await this.GetCredentials(userId, inputPassword);
+
+        if (credentials) {
+          const cachedPassword = isPassword(credentials.current?.password);
+          const cachedSecret = isSharedSecret(credentials.current?.password);
+
+          if (!cachedPassword && !cachedSecret && promptPassword) {
+            // Password prompt
+            ({ inputPassword } = await inquirer.prompt([
+              {
+                type: 'password',
+                message: messages.login.passwordPrompt(currentEnv, userId),
+                name: 'inputPassword',
+                mask: '*',
+                prefix: undefined,
+              },
+            ]));
+          }
 
-        if (sharedSecret || cachedSecret || inputPassword || cachedPassword) {
-          const authService = new ContensisAuthService({
-            username: userId,
-            password: inputPassword || cachedPassword,
-            projectId: env?.currentProject || 'website',
-            rootUrl: this.urls?.cms || '',
-            clientId: userId,
-            clientSecret: sharedSecret || cachedSecret,
-          });
+          if (inputPassword || cachedPassword || cachedSecret) {
+            const authService = new ContensisAuthService({
+              username: userId,
+              password: inputPassword || cachedPassword,
+              projectId: env?.currentProject || 'website',
+              rootUrl: this.urls?.cms || '',
+              clientId: userId,
+              clientSecret: sharedSecret || cachedSecret,
+            });
+
+            const [authError, bearerToken] = await to(
+              authService.BearerToken()
+            );
 
-          const [authError, bearerToken] = await to(authService.BearerToken());
-
-          // Login successful
-          if (bearerToken) {
-            // Set env vars
-            env.authToken = bearerToken;
-            env.lastUserId = userId;
-            env.passwordFallback =
-              credentials.remarks.secure !== true
-                ? credentials.current?.password
-                : undefined;
-
-            if (!silent) {
-              Logger.success(messages.login.success(currentEnv, userId));
-              await this.PrintProjects();
+            // Login successful
+            if (bearerToken) {
+              // Set env vars
+              env.authToken = bearerToken;
+              env.lastUserId = userId;
+              env.passwordFallback =
+                credentials.remarks.secure !== true
+                  ? credentials.current?.password
+                  : undefined;
+
+              // Persist env before finding projects or doing anything else
+              this.session.UpdateEnv(env);
+              if (inputPassword) await credentials.Save(inputPassword);
+              if (sharedSecret) await credentials.Save(sharedSecret);
+
+              if (!silent) {
+                Logger.success(messages.login.success(currentEnv, userId));
+                await this.PrintProjects();
+              }
+            } else if (authError) {
+              Logger.error(authError.toString());
+              // Clear env vars
+              env.authToken = '';
+              env.lastUserId = '';
+              env.passwordFallback = undefined;
+              // Persist env to remove cleared values
+              this.session.UpdateEnv(env);
+
+              // If the auth error was raised using a cached password
+              if (
+                (cachedPassword || cachedSecret) &&
+                credentials.remarks.secure
+              ) {
+                // Remove any bad stored credential and trigger login prompt again
+                await credentials.Delete();
+                return await this.Login(userId, { password, sharedSecret });
+              } else {
+                throw new Error(messages.login.failed(currentEnv, userId));
+              }
             }
-            if (inputPassword) await credentials.Save(inputPassword);
-            if (sharedSecret) await credentials.Save(sharedSecret);
-          } else if (authError) {
-            Logger.error(authError.toString());
-            // Clear env vars
-            env.authToken = '';
-            env.lastUserId = '';
-            env.passwordFallback = undefined;
-
-            // If the auth error was raised using a cached password
-            if (
-              (cachedPassword || cachedSecret) &&
-              credentials.remarks.secure
-            ) {
-              // Remove any bad stored credential and trigger login prompt again
-              await credentials.Delete();
-              return await this.Login(userId, { password, sharedSecret });
-            } else {
-              throw new Error(messages.login.failed(currentEnv, userId));
-            }
-          }
 
-          // Persist env
-          this.session.Update({
-            environments: cache.environments,
-          });
-          return env.authToken;
-        } else {
-          Logger.error(messages.login.passwordPrompt(currentEnv, userId));
+            return env.authToken;
+          } else {
+            Logger.error(messages.login.passwordPrompt());
+            if (attempt < 2)
+              return await this.Login(userId, { attempt: attempt + 1 });
+          }
         }
       } else {
         // No environment set, use `contensis connect {alias}` first
@@ -525,19 +547,65 @@ class ContensisCli {
     }
   };
 
+  PrintContensisVersion = async () => {
+    const { log, messages } = this;
+    const contensis = await this.ConnectContensis();
+
+    if (contensis) {
+      // Retrieve projects list for env
+      const [projectsErr, projects] = await to(
+        contensis.projects.GetSourceProjects()
+      );
+
+      if (Array.isArray(projects)) {
+        // Print contensis version to console
+        this.HandleFormattingAndOutput(contensis.contensisVersion, () =>
+          log.raw(log.highlightText(contensis.contensisVersion))
+        );
+      }
+
+      if (projectsErr) {
+        log.error(messages.projects.noList());
+        log.error(projectsErr.message);
+      }
+    }
+  };
+
+  PrintBearerToken = async () => {
+    const { log, messages } = this;
+    const contensis = await this.ConnectContensis();
+
+    if (contensis) {
+      // Retrieve token for env
+      const [error, token] = await to(
+        contensis.content.sourceRepo.repo.BearerToken()
+      );
+      if (token) {
+        // Print bearer token to console
+        this.HandleFormattingAndOutput(token, () =>
+          log.raw(log.highlightText(token))
+        );
+      }
+
+      if (error) {
+        log.error(messages.projects.noList());
+        log.error(error.message);
+      }
+    }
+  };
+
   PrintProjects = async () => {
-    const { cache, currentEnv, currentProject, log, messages, session } = this;
-    if (!this.contensis) await this.ConnectContensis();
+    const { currentProject, log, messages, session } = this;
+    const contensis = await this.ConnectContensis();
 
-    if (this.contensis) {
+    if (contensis) {
       // Retrieve projects list for env
       const [projectsErr, projects] = await to(
-        this.contensis.projects.GetSourceProjects()
+        contensis.projects.GetSourceProjects()
       );
 
       if (Array.isArray(projects)) {
         // save these projects in cache
-        const currentVals = cache.environments[currentEnv] || {};
         const nextCurrentProject =
           currentProject && currentProject !== 'null'
             ? currentProject
@@ -545,46 +613,80 @@ class ContensisCli {
             ? 'website'
             : undefined;
 
-        cache.environments[currentEnv] = {
-          ...currentVals,
+        session.UpdateEnv({
           projects: projects.map(p => p.id),
           currentProject: nextCurrentProject,
-        };
+        });
 
         log.success(messages.projects.list());
+        log.raw('');
+
         this.HandleFormattingAndOutput(projects, () => {
           // print the projects to console
-          for (const project of projects) {
+          for (const project of projects.sort((a, b) =>
+            a.id.localeCompare(b.id)
+          )) {
+            let color;
+            try {
+              color = chalk.keyword((project as any).color);
+            } catch (ex) {
+              color = chalk.white;
+            }
             console.log(
-              `  - ${nextCurrentProject === project.id ? '* ' : ''}[${
-                project.primaryLanguage
-              }] ${project.id}`
+              `${
+                nextCurrentProject === project.id
+                  ? `>> ${log.boldText(color(project.id))}`
+                  : `    ${color(project.id)}`
+              } ${log.infoText(
+                `[${project.supportedLanguages
+                  .map(l =>
+                    l === project.primaryLanguage ? `*${log.boldText(l)}` : l
+                  )
+                  .join(' ')}]`
+              )}`
             );
           }
         });
 
-        session.Update({
-          environments: cache.environments,
-        });
+        if (!this.SetProject(nextCurrentProject))
+          log.warning(messages.projects.tip());
+      }
 
-        if (nextCurrentProject) {
-          this.env = cache.environments[currentEnv];
-          this.SetProject(nextCurrentProject);
-        }
+      if (projectsErr) {
+        log.error(messages.projects.noList());
+        log.error(projectsErr.message);
+      }
+    }
+  };
+
+  PrintProject = async (projectId = this.currentProject) => {
+    const { log, messages, session } = this;
+    const contensis = await this.ConnectContensis();
+
+    if (contensis) {
+      // Retrieve projects list for env
+      const [projectsErr, projects] = await to(
+        contensis.projects.GetSourceProjects()
+      );
+
+      const foundProject = projects?.find(
+        p => p.id.toLowerCase() === projectId.toLowerCase()
+      );
+
+      if (foundProject) {
+        log.raw('');
+        this.HandleFormattingAndOutput(foundProject, log.object);
       }
 
       if (projectsErr) {
         log.error(messages.projects.noList());
         log.error(projectsErr.message);
       }
-      // } else {
-      //   log.warning(messages.projects.noList());
-      //   log.help(messages.connect.tip());
     }
   };
 
-  SetProject = async (projectId = '') => {
-    const { cache, env, log, messages, session } = this;
+  SetProject = (projectId = 'website') => {
+    const { env, log, messages, session } = this;
     let nextProjectId: string | undefined;
     if (env?.projects.length > 0 && env?.lastUserId) {
       nextProjectId = env.projects.find(
@@ -592,10 +694,9 @@ class ContensisCli {
       );
       if (nextProjectId) {
         env.currentProject = nextProjectId;
-        session.Update({
-          environments: cache.environments,
-        });
+        session.UpdateEnv(env);
         log.success(messages.projects.set(projectId));
+        log.raw('');
       } else {
         log.error(messages.projects.failedSet(projectId));
       }
@@ -607,8 +708,8 @@ class ContensisCli {
     return nextProjectId;
   };
 
-  SetVersion = async (versionStatus: 'latest' | 'published') => {
-    const { cache, env, log, messages, session } = this;
+  SetVersion = (versionStatus: 'latest' | 'published') => {
+    const { env, log, messages, session } = this;
     if (!['latest', 'published'].includes(versionStatus)) {
       log.error(messages.version.invalid(versionStatus));
       return false;
@@ -618,10 +719,7 @@ class ContensisCli {
       return false;
     }
     if (env?.projects.length > 0 && env?.lastUserId) {
-      env.versionStatus = versionStatus;
-      session.Update({
-        environments: cache.environments,
-      });
+      session.UpdateEnv({ versionStatus });
       log.success(messages.version.set(this.currentEnv, versionStatus));
       return true;
     } else {
@@ -632,30 +730,13 @@ class ContensisCli {
     }
   };
 
-  HydrateContensis = async () => {
-    const { log } = this;
-    if (!this.contensis) await this.ConnectContensis();
-
-    if (this.contensis) {
-      // Retrieve content types list for env
-      const [contensisErr, models] = await to(
-        this.contensis.models.HydrateContensisRepositories()
-      );
-
-      if (contensisErr) {
-        log.error(contensisErr.message);
-        return contensisErr;
-      }
-    }
-  };
-
   PrintApiKeys = async () => {
     const { currentEnv, log, messages } = this;
-    if (!this.contensis) await this.ConnectContensis();
+    const contensis = await this.ConnectContensis();
 
-    if (this.contensis) {
+    if (contensis) {
       // Retrieve keys list for env
-      const [keysErr, apiKeys] = await this.contensis.apiKeys.GetKeys();
+      const [keysErr, apiKeys] = await contensis.apiKeys.GetKeys();
 
       if (Array.isArray(apiKeys)) {
         log.success(messages.keys.list(currentEnv));
@@ -689,27 +770,29 @@ class ContensisCli {
 
   CreateApiKey = async (name: string, description?: string) => {
     const { currentEnv, log, messages } = this;
-    if (!this.contensis) await this.ConnectContensis();
+    const contensis = await this.ConnectContensis();
 
-    if (this.contensis) {
-      const [err, key] = await this.contensis.apiKeys.CreateKey(
-        name,
-        description
-      );
+    if (contensis) {
+      const [err, key] = await contensis.apiKeys.CreateKey(name, description);
 
       if (key) {
         log.success(messages.keys.created(currentEnv, name));
 
         // print the key details to console
         console.log(
-          `  - ${key.name}${
-            key.description ? ` (${key.description})` : ''
-          } [${key.dateModified.toString().substring(0, 10)} ${key.modifiedBy}]`
+          `  - ${chalk.bold(key.name)} [${key.dateModified
+            .toString()
+            .substring(0, 10)} ${key.modifiedBy}]`
         );
-        console.log(`  - id: ${key.id}`);
-        console.log(`  - sharedSecret: ${key.sharedSecret}`);
+        if (key.description)
+          console.log(`    ${log.infoText(key.description)}`);
+        console.log(`    ${chalk.bold.grey`id`}: ${key.id}`);
+        console.log(
+          `    ${chalk.bold.grey`sharedSecret`}: ${key.sharedSecret}`
+        );
+        console.log('');
+        log.help(messages.keys.tip());
       }
-      console.log('');
 
       if (err) {
         log.error(messages.keys.failedCreate(currentEnv, name), err);
@@ -719,10 +802,10 @@ class ContensisCli {
 
   RemoveApiKey = async (id: string) => {
     const { currentEnv, log, messages } = this;
-    if (!this.contensis) await this.ConnectContensis({ commit: true });
+    const contensis = await this.ConnectContensis({ commit: true });
 
-    if (this.contensis) {
-      const [err, key] = await this.contensis.apiKeys.RemoveKey(id);
+    if (contensis) {
+      const [err, key] = await contensis.apiKeys.RemoveKey(id);
 
       if (!err) {
         log.success(messages.keys.removed(currentEnv, id));
@@ -733,26 +816,431 @@ class ContensisCli {
     }
   };
 
-  GetContentTypes = async () => {
+  PrintRoles = async () => {
+    const { currentEnv, log, messages } = this;
+    const contensis = await this.ConnectContensis();
+
+    if (contensis) {
+      // Retrieve roles list for env
+      const [rolesErr, roles] = await to(contensis.roles.GetRoles());
+
+      if (Array.isArray(roles)) {
+        log.success(messages.roles.list(currentEnv));
+
+        if (!roles.length) log.help(messages.roles.noneExist());
+
+        this.HandleFormattingAndOutput(roles, () => {
+          // print the roles to console
+          for (const {
+            id,
+            name,
+            description,
+            enabled,
+            assignments,
+            permissions,
+          } of roles) {
+            const color = enabled ? (s: string) => s : log.infoText;
+
+            console.log(color(`  - ${chalk.bold(name)} ${log.infoText(id)}`));
+            if (description) console.log(log.infoText(`    ${description}`));
+            if (enabled === false)
+              console.log(`      ${chalk.bold.grey('enabled')}: false`);
+            if (assignments.groups?.length)
+              console.log(
+                `      ${chalk.bold.grey('groups')}: ${assignments.groups.join(
+                  ', '
+                )}`
+              );
+            if (assignments.users?.length)
+              console.log(
+                `      ${chalk.bold.grey('users')}: ${assignments.users.join(
+                  ', '
+                )}`
+              );
+            if (assignments.apiKeys?.length)
+              console.log(
+                `      ${chalk.bold.grey('keys')}: ${assignments.apiKeys.join(
+                  ', '
+                )}`
+              );
+
+            if (permissions.entries?.length) {
+              console.log(`      ${chalk.bold.grey('entries')}:`);
+              for (const p of permissions.entries)
+                console.log(
+                  `        ${p.id}: ${log.infoText(
+                    p.actions.length > 2
+                      ? p.actions.length
+                      : p.actions.join(', ')
+                  )}`
+                );
+            }
+            if (permissions.contentTypes?.length)
+              console.log(
+                `      ${chalk.bold.grey(
+                  'contentTypes'
+                )}: ${permissions.contentTypes
+                  .map(
+                    p =>
+                      `${p.id} [${p.actions.join(',')}] ${p.languages.join(
+                        ' '
+                      )}`
+                  )
+                  .join(', ')}`
+              );
+          }
+        });
+      }
+
+      if (rolesErr) {
+        log.error(messages.roles.noList(currentEnv));
+        log.error(jsonFormatter(rolesErr));
+      }
+    }
+  };
+
+  PrintRole = async (roleNameOrId: string) => {
+    const { currentEnv, log, messages } = this;
+    const contensis = await this.ConnectContensis();
+
+    if (contensis) {
+      // Retrieve roles list for env
+      const [rolesErr, roles] = await to(contensis.roles.GetRoles());
+
+      if (Array.isArray(roles)) {
+        log.success(messages.roles.list(currentEnv));
+
+        const role = findByIdOrName(roles, roleNameOrId);
+
+        if (role) this.HandleFormattingAndOutput(role, log.object);
+        else log.error(messages.roles.failedGet(currentEnv, roleNameOrId));
+      }
+
+      if (rolesErr) {
+        log.error(messages.roles.noList(currentEnv));
+        log.error(jsonFormatter(rolesErr));
+      }
+    }
+  };
+
+  CreateRole = async (role: Partial<Role>) => {
+    const { currentEnv, log, messages } = this;
+    const contensis = await this.ConnectContensis();
+
+    if (contensis) {
+      const [err, created] = await contensis.roles.CreateRole(role as Role);
+
+      if (created) {
+        log.success(
+          messages.roles.created(currentEnv, role.id || role.name || '')
+        );
+
+        this.HandleFormattingAndOutput(created, log.object);
+
+        log.help(messages.roles.tip());
+        return role.id;
+      }
+
+      if (err) {
+        log.error(
+          messages.roles.failedCreate(currentEnv, role.id || role.name || ''),
+          err
+        );
+      }
+    }
+  };
+
+  UpdateRole = async (roleNameOrId: string, role: Partial<Role>) => {
+    const { currentEnv, log, messages } = this;
+    const contensis = await this.ConnectContensis();
+
+    if (contensis) {
+      // Retrieve roles list for env
+      const [rolesErr, roles] = await to(contensis.roles.GetRoles());
+
+      if (Array.isArray(roles)) {
+        log.success(messages.roles.list(currentEnv));
+
+        const existingRole = findByIdOrName(roles, roleNameOrId, true);
+        if (existingRole) {
+          log.info(messages.roles.setPayload());
+          log.object(role);
+          log.raw(``);
+          const [updateErr, updated] = await contensis.roles.UpdateRole(
+            existingRole.id,
+            role
+          );
+          if (updateErr)
+            log.error(messages.roles.failedSet(currentEnv, roleNameOrId));
+          else {
+            log.success(messages.roles.set());
+
+            this.HandleFormattingAndOutput(updated, log.object);
+          }
+        } else {
+          // Role does not exist
+          log.error(messages.roles.failedGet(currentEnv, roleNameOrId));
+        }
+      }
+
+      if (rolesErr) {
+        log.error(messages.roles.noList(currentEnv));
+        log.error(jsonFormatter(rolesErr));
+      }
+    }
+  };
+
+  RemoveRole = async (roleNameOrId: string) => {
+    const { currentEnv, log, messages } = this;
+    const contensis = await this.ConnectContensis();
+
+    if (contensis) {
+      // Retrieve roles list for env
+      const [rolesErr, roles] = await to(contensis.roles.GetRoles());
+
+      if (Array.isArray(roles)) {
+        log.success(messages.roles.list(currentEnv));
+
+        const existingRole = findByIdOrName(roles, roleNameOrId, true);
+
+        if (existingRole) {
+          const [deleteErr] = await contensis.roles.RemoveRole(existingRole.id);
+
+          if (deleteErr)
+            log.error(messages.roles.failedRemove(currentEnv, roleNameOrId));
+          else log.success(messages.roles.removed(currentEnv, roleNameOrId));
+        } else {
+          // Role does not exist
+          log.error(messages.roles.failedGet(currentEnv, roleNameOrId));
+        }
+      }
+
+      if (rolesErr) {
+        log.error(messages.roles.noList(currentEnv));
+        log.error(jsonFormatter(rolesErr));
+      }
+    }
+  };
+
+  CreateProject = async (project: Project) => {
+    const { currentEnv, log, messages } = this;
+    const contensis = await this.ConnectContensis();
+
+    if (contensis) {
+      const [err, created] = await contensis.projects.CreateProject(project);
+
+      if (created) {
+        log.success(messages.projects.created(currentEnv, project.id));
+
+        this.HandleFormattingAndOutput(created, () => {
+          // set the CLI project to the newly created project
+          this.SetProject(project.id);
+          // print all the projects to console
+          this.PrintProjects();
+        });
+        return project.id;
+      }
+
+      if (err) {
+        log.error(messages.projects.failedCreate(currentEnv, project.id), err);
+      }
+    }
+  };
+
+  UpdateProject = async (project: Partial<Project>) => {
+    const { currentEnv, currentProject, log, messages } = this;
+    const contensis = await this.ConnectContensis();
+
+    if (contensis) {
+      const [err, updated] = await contensis.projects.UpdateProject({
+        id: currentProject,
+        ...project,
+      });
+
+      if (updated) {
+        log.success(messages.projects.updated(currentEnv, currentProject));
+
+        this.HandleFormattingAndOutput(updated, log.object);
+        return updated.id;
+      }
+
+      if (err) {
+        log.error(
+          messages.projects.failedUpdate(currentEnv, currentProject),
+          err
+        );
+      }
+    }
+  };
+
+  PrintContentModels = async (modelIds: string[] = []) => {
     const { currentProject, log, messages } = this;
-    let err;
-    if (!this.contensis) err = await this.HydrateContensis();
+    const contensis = await this.ConnectContensis();
+    if (contensis) {
+      // Retrieve models list for env
+      const models = await contensis.models.contentModels();
+      const contentTypes = await contensis.models.contentTypes();
+      const components = await contensis.models.components();
+
+      // Models to output to console
+      const returnModels = modelIds?.length
+        ? models?.filter((m: Model) =>
+            modelIds.some(id => id.toLowerCase() === m.id.toLowerCase())
+          )
+        : undefined;
+
+      // Generate a list of contentTypeIds and componentIds from all models
+      // and dependencies
+      const contentTypeIds = Array.from(
+        new Set([
+          ...(returnModels || models || []).map(m => m.id),
+          ...(returnModels || models || [])
+            .map(m => m.dependencies?.contentTypes?.map(c => c[0]) || [])
+            .flat(),
+        ])
+      );
+      const componentIds = Array.from(
+        new Set(
+          (returnModels || models || [])
+            .map(m => m.dependencies?.components?.map(c => c[0]) || [])
+            .flat()
+        )
+      );
 
-    if (err) log.error(messages.contenttypes.noList(currentProject));
-    if (this.contensis) {
-      this.contentTypes = this.contensis.models.contentTypes();
-      this.components = this.contensis.models.components();
+      // Create an array of all the content types and component definitions
+      // we will use this when outputting to a file
+      const contentModelBackup = [
+        ...contentTypes.filter(c =>
+          contentTypeIds.map(i => i.toLowerCase()).includes(c.id.toLowerCase())
+        ),
+        ...components.filter(c =>
+          componentIds.map(i => i.toLowerCase()).includes(c.id.toLowerCase())
+        ),
+      ];
+
+      if (Array.isArray(returnModels)) {
+        log.success(messages.models.list(currentProject));
+        this.HandleFormattingAndOutput(contentModelBackup, () => {
+          // print the content models to console
+          for (const model of returnModels) {
+            log.raw('');
+            log.object(model);
+          }
+          log.raw('');
+        });
+      } else {
+        log.success(
+          messages.models.get(currentProject, models?.length.toString() || '0')
+        );
+        log.raw('');
+        if (models?.length) {
+          this.HandleFormattingAndOutput(contentModelBackup, () => {
+            // print the content models to console
+            for (const model of models) {
+              const components = model.components?.length || 0;
+              const contentTypes = model.contentTypes?.length || 0;
+              const dependencies =
+                (model.dependencies?.components?.length || 0) +
+                (model.dependencies?.contentTypes?.length || 0);
+              const dependencyOf =
+                (model.dependencyOf?.components?.length || 0) +
+                (model.dependencyOf?.contentTypes?.length || 0);
+
+              const hasAny =
+                components + contentTypes + dependencies + dependencyOf;
+              log.raw(
+                `  - ${log.highlightText(log.boldText(model.id))} ${
+                  hasAny
+                    ? log.infoText(
+                        `{ ${components ? `components: ${components}, ` : ''}${
+                          contentTypes ? `contentTypes: ${contentTypes}, ` : ''
+                        }${
+                          dependencies ? `references: ${dependencies}, ` : ''
+                        }${
+                          dependencyOf ? `required by: ${dependencyOf}` : ''
+                        } }`
+                      )
+                    : ''
+                }`
+              );
+            }
+            log.raw('');
+          });
+        }
+      }
+    }
+  };
+
+  ImportContentModels = async ({
+    commit,
+    fromFile,
+  }: {
+    commit: boolean;
+    fromFile: string;
+  }) => {
+    const { currentProject, log, messages } = this;
+
+    const fileData = fromFile
+      ? readJsonFile<(ContentType | Component)[]>(fromFile) || []
+      : [];
+    if (typeof fileData === 'string')
+      throw new Error(`Import file format must be of type JSON`);
+
+    const contensis = await this.ConnectContensisImport({
+      commit,
+      fromFile,
+      importDataType: 'models',
+    });
+
+    if (contensis) {
+      log.line();
+      if (contensis.isPreview) {
+        console.log(log.successText(` -- IMPORT PREVIEW -- `));
+      } else {
+        console.log(log.warningText(` *** COMMITTING IMPORT *** `));
+      }
+
+      const [migrateErr, result] = await contensis.MigrateContentModels();
+
+      if (migrateErr) logError(migrateErr);
+      else
+        this.HandleFormattingAndOutput(result, () => {
+          // print the results to console
+          if (!commit) {
+            log.raw(log.boldText(`\nContent types:`));
+            if (!result.contentTypes) log.info(`- None returned\n`);
+            else printModelMigrationAnalysis(this, result.contentTypes);
+
+            log.raw(log.boldText(`\nComponents:`));
+            if (!result.components) log.info(`- None returned\n`);
+            else printModelMigrationAnalysis(this, result.components);
+          } else {
+            const migrateResult = result as MigrateModelsResult;
+            log.raw(log.boldText(`\nContent types:`));
+            printModelMigrationResult(
+              this,
+              migrateResult[currentProject].contentTypes
+            );
+
+            log.raw(log.boldText(`\nComponents:`));
+            printModelMigrationResult(
+              this,
+              migrateResult[currentProject].components
+            );
+          }
+        });
     } else {
-      log.warning(messages.contenttypes.noList(currentProject));
+      log.warning(messages.models.noList(currentProject));
+      log.help(messages.connect.tip());
     }
   };
 
   PrintContentTypes = async () => {
     const { currentProject, log, messages } = this;
-    await this.GetContentTypes();
-    if (this.contensis) {
+    const contensis = await this.ConnectContensis();
+    if (contensis) {
       // Retrieve content types list for env
-      const { contentTypes } = this;
+      const contentTypes = await contensis.models.contentTypes();
 
       if (Array.isArray(contentTypes)) {
         log.success(messages.contenttypes.list(currentProject));
@@ -773,10 +1261,10 @@ class ContensisCli {
 
   PrintContentType = async (contentTypeId: string) => {
     const { currentProject, log, messages } = this;
-    await this.GetContentTypes();
-    if (this.contensis) {
+    const contensis = await this.ConnectContensis();
+    if (contensis) {
       // Retrieve content types list for env
-      const { contentTypes } = this;
+      const contentTypes = await contensis.models.contentTypes();
 
       if (Array.isArray(contentTypes)) {
         const contentType = contentTypes.find(
@@ -798,16 +1286,13 @@ class ContensisCli {
   };
 
   RemoveContentTypes = async (contentTypeIds: string[], commit = false) => {
-    const { currentProject, log, messages } = this;
-    if (!this.contensis)
-      await this.ConnectContensisImport({
-        source: 'input',
-        commit,
-      });
-    if (this.contensis) {
-      const [err, result] = await this.contensis.DeleteContentTypes(
-        contentTypeIds
-      );
+    const { currentProject, log, messages } = this;
+    const contensis = await this.ConnectContensisImport({
+      commit,
+      importDataType: 'user-input',
+    });
+    if (contensis) {
+      const [err, result] = await contensis.DeleteContentTypes(contentTypeIds);
 
       if (err) {
         log.error(
@@ -822,7 +1307,7 @@ class ContensisCli {
           messages.contenttypes.removed(
             currentProject,
             contentTypeIds.join('", "'),
-            !this.contensis.isPreview
+            !contensis.isPreview
           )
         );
         // print the results to console
@@ -851,22 +1336,21 @@ class ContensisCli {
 
     if (!Array.isArray(fileData)) fileData = [fileData];
 
-    await this.ConnectContensisImport({
+    const contensis = await this.ConnectContensisImport({
       commit,
-      source: fromFile ? 'file' : 'contensis',
+      importDataType: fromFile ? 'user-input' : undefined,
     });
 
-    if (this.contensis) {
+    if (contensis) {
       // Pass each content type to the target repo
       for (const contentType of fileData) {
         // Fix invalid data
         contentType.projectId = currentProject;
         delete contentType.uuid;
 
-        const [err, created, createStatus] =
-          await this.contensis.models.targetRepos[
-            currentProject
-          ].repo.UpsertContentType(false, contentType);
+        const [err, created, createStatus] = await contensis.models.targetRepos[
+          currentProject
+        ].repo.UpsertContentType(false, contentType);
 
         if (err) log.error(err.message, err);
         if (createStatus) {
@@ -884,12 +1368,59 @@ class ContensisCli {
     }
   };
 
+  DiffModels = async (
+    {
+      fromFile,
+    }: {
+      fromFile: string;
+    },
+    modelIds: string[] = []
+  ) => {
+    const { log } = this;
+
+    let fileData = fromFile ? readJsonFile<ContentType[]>(fromFile) || [] : [];
+    if (typeof fileData === 'string')
+      throw new Error(`Import file format must be of type JSON`);
+
+    if (!Array.isArray(fileData)) fileData = [fileData];
+
+    const contensis = await this.ConnectContensisImport({
+      fromFile,
+      importDataType: 'models',
+    });
+
+    if (contensis) {
+      const [err, result] = (await to(
+        contensis.models.Diff(fileData.length ? fileData : modelIds)
+      )) as [Error | null, ContentTypesResult | undefined];
+
+      if (err) log.error(err.message, err);
+      if (result)
+        // print the content type to console
+        this.HandleFormattingAndOutput(result, () => {
+          log.success(
+            `Queried models ${log.infoText(
+              `"${result.query.modelIds?.join(', ')}"`
+            )}\n`
+          );
+
+          log.raw(log.boldText(`Content types:`));
+          if (!result.contentTypes) log.info(`- None returned\n`);
+          else printModelMigrationAnalysis(this, result.contentTypes);
+
+          log.raw(log.boldText(`Components:`));
+          if (!result.components) log.info(`- None returned\n`);
+          else printModelMigrationAnalysis(this, result.components);
+        });
+    }
+  };
+
   PrintComponents = async () => {
     const { currentProject, log, messages } = this;
-    await this.GetContentTypes();
-    if (this.contensis) {
+    const contensis = await this.ConnectContensis();
+    if (contensis) {
       // Retrieve components list for env
-      const { components } = this;
+      const components = await contensis.models.components();
 
       if (Array.isArray(components)) {
         log.success(messages.components.list(currentProject));
@@ -911,10 +1442,10 @@ class ContensisCli {
 
   PrintComponent = async (componentId: string) => {
     const { currentProject, log, messages } = this;
-    await this.GetContentTypes();
-    if (this.contensis) {
+    const contensis = await this.ConnectContensis();
+    if (contensis) {
       // Retrieve content types list for env
-      const { components } = this;
+      const components = await contensis.models.components();
 
       if (Array.isArray(components)) {
         const component = components.find(
@@ -933,13 +1464,12 @@ class ContensisCli {
 
   RemoveComponents = async (componentIds: string[], commit = false) => {
     const { currentProject, log, messages } = this;
-    if (!this.contensis)
-      await this.ConnectContensisImport({
-        source: 'input',
-        commit,
-      });
-    if (this.contensis) {
-      const [err, result] = await this.contensis.DeleteContentTypes(
+    const contensis = await this.ConnectContensisImport({
+      commit,
+      importDataType: 'user-input',
+    });
+    if (contensis) {
+      const [err, result] = await contensis.DeleteContentTypes(
         undefined,
         componentIds
       );
@@ -957,7 +1487,7 @@ class ContensisCli {
           messages.components.removed(
             currentProject,
             componentIds.join('", "'),
-            !this.contensis.isPreview
+            !contensis.isPreview
           )
         );
         // print the results to console
@@ -986,22 +1516,21 @@ class ContensisCli {
 
     if (!Array.isArray(fileData)) fileData = [fileData];
 
-    await this.ConnectContensisImport({
+    const contensis = await this.ConnectContensisImport({
       commit,
-      source: fromFile ? 'file' : 'contensis',
+      importDataType: fromFile ? 'user-input' : undefined,
     });
 
-    if (this.contensis) {
+    if (contensis) {
       // Pass each component to the target repo
       for (const component of fileData) {
         // Fix invalid data
         component.projectId = currentProject;
         delete component.uuid;
 
-        const [err, created, createStatus] =
-          await this.contensis.models.targetRepos[
-            currentProject
-          ].repo.UpsertComponent(false, component);
+        const [err, created, createStatus] = await contensis.models.targetRepos[
+          currentProject
+        ].repo.UpsertComponent(false, component);
 
         if (err) log.error(err.message, err);
         if (createStatus) {
@@ -1019,38 +1548,42 @@ class ContensisCli {
     }
   };
 
-  RemoveEntry = async (id: string, commit = false) => {
-    const { currentEnv, log, messages } = this;
-    if (!this.contensis)
-      await this.ConnectContensisImport({
-        source: 'input',
-        commit,
-      });
+  RemoveEntries = async (commit = false) => {
+    const { currentEnv, currentProject, log, messages } = this;
+    const contensis = await this.ConnectContensisImport({
+      commit,
+      importDataType: 'user-input',
+    });
 
-    if (this.contensis) {
-      if (this.contensis.isPreview) {
+    if (contensis) {
+      if (contensis.isPreview) {
         console.log(log.successText(` -- PREVIEW -- `));
       } else {
         console.log(log.warningText(` *** COMMITTING DELETE *** `));
       }
-      const [err, result] = await this.contensis.DeleteEntries();
+      const [err, result] = await contensis.DeleteEntries();
       if (result)
         this.HandleFormattingAndOutput(result, () => {
           // print the migrateResult to console
-          printMigrateResult(this, result, { action: 'delete' });
+          printMigrateResult(this, result, {
+            action: 'delete',
+            showAllEntries: true,
+          });
         });
       if (
         !err &&
-        ((!commit &&
-          Object.values(result.entriesToMigrate)?.[0].totalCount > 0) ||
+        ((!commit && result.entriesToMigrate[currentProject].totalCount) ||
           (commit && result.migrateResult?.deleted))
       ) {
-        log.success(messages.entries.removed(currentEnv, id, commit));
-        if (!commit) log.help(messages.entries.commitTip());
+        log.success(messages.entries.removed(currentEnv, commit));
+        if (!commit) {
+          log.raw(``);
+          log.help(messages.entries.commitTip());
+        }
       } else {
-        log.error(messages.entries.failedRemove(currentEnv, id), err);
-        if (!Object.values(result.entriesToMigrate)?.[0].totalCount)
-          log.help(messages.entries.notFound(id));
+        log.error(messages.entries.failedRemove(currentEnv), err);
+        if (!result.entriesToMigrate[currentProject].totalCount)
+          log.help(messages.entries.notFound(currentEnv));
       }
     }
   };
@@ -1061,21 +1594,21 @@ class ContensisCli {
     withDependents?: boolean;
   }) => {
     const { currentProject, log, messages } = this;
-    await this.ConnectContensis();
+    const contensis = await this.ConnectContensis();
 
-    if (this.contensis) {
+    if (contensis) {
       log.line();
-      const entries = await this.contensis.GetEntries({ withDependents });
+      const entries = await contensis.GetEntries({ withDependents });
       this.HandleFormattingAndOutput(entries, () =>
         // print the entries to console
         logEntriesTable(
           entries,
           currentProject,
-          this.contensis?.payload.query?.fields
+          contensis.payload.query?.fields
         )
       );
     } else {
-      log.warning(messages.contenttypes.noList(currentProject));
+      log.warning(messages.models.noList(currentProject));
       log.help(messages.connect.tip());
     }
   };
@@ -1083,89 +1616,295 @@ class ContensisCli {
   ImportEntries = async ({
     commit,
     fromFile,
+    logOutput,
   }: {
     commit: boolean;
     fromFile: string;
+    logOutput: string;
   }) => {
+    const { currentEnv, currentProject, log, messages } = this;
+
+    const contensis = await this.ConnectContensisImport({
+      commit,
+      fromFile,
+      importDataType: 'entries',
+    });
+
+    if (contensis) {
+      log.line();
+      if (contensis.isPreview) {
+        console.log(log.successText(` -- IMPORT PREVIEW -- `));
+      } else {
+        console.log(log.warningText(` *** COMMITTING IMPORT *** `));
+      }
+
+      const [err, result] = await contensis.MigrateEntries();
+
+      if (err) logError(err);
+      else
+        this.HandleFormattingAndOutput(result, () => {
+          // print the migrateResult to console
+          printMigrateResult(this, result, {
+            showAllEntries: logOutput === 'all',
+            showChangedEntries: logOutput === 'changes',
+          });
+        });
+
+      if (
+        !err &&
+        !result.errors?.length &&
+        ((!commit && result.entriesToMigrate[currentProject].totalCount) ||
+          (commit &&
+            (result.migrateResult?.created || result.migrateResult?.updated)))
+      ) {
+        log.success(
+          messages.entries.imported(
+            currentEnv,
+            commit,
+            commit
+              ? (result.migrateResult?.created || 0) +
+                  (result.migrateResult?.updated || 0)
+              : result.entriesToMigrate[currentProject].totalCount
+          )
+        );
+        if (!commit) {
+          log.raw(``);
+          log.help(messages.entries.commitTip());
+        }
+      } else {
+        log.error(messages.entries.failedImport(currentEnv), err);
+        if (!result.entriesToMigrate[currentProject].totalCount)
+          log.help(messages.entries.notFound(currentEnv));
+      }
+    } else {
+      log.warning(messages.models.noList(currentProject));
+      log.help(messages.connect.tip());
+    }
+  };
+
+  GetNodes = async (rootPath: string, depth = 0) => {
     const { currentProject, log, messages } = this;
+    const contensis = await this.ConnectContensis();
 
-    const fileData = fromFile ? readJsonFile<Entry[]>(fromFile) || [] : [];
-    if (typeof fileData === 'string')
-      throw new Error(`Import file format must be of type JSON`);
+    if (contensis) {
+      log.line();
+      const [err] = await to(
+        contensis.content.sourceRepo.nodes.GetNodes(rootPath, depth)
+      );
+      if (err) {
+        log.error(messages.nodes.failedGet(currentProject), err);
+        return;
+      }
+      const root = contensis.content.sourceRepo.nodes.tree;
+
+      log.success(messages.nodes.get(currentProject, rootPath, depth));
+
+      const outputNode = (node: Node | any, spaces: string) =>
+        `${node.entry ? log.highlightText('e') : log.infoText('-')}${
+          node.isCanonical ? log.highlightText('c') : log.infoText('-')
+        }${
+          node.includeInMenu ? log.highlightText('m') : log.infoText('-')
+        }${spaces}${
+          node.isCanonical ? log.boldText(`/${node.slug}`) : `/${node.slug}`
+        }${node.entry ? ` ${log.helpText(node.entry.sys.contentTypeId)}` : ''}${
+          node.childCount ? ` +${node.childCount}` : ``
+        } ${log.infoText(node.displayName)}`;
+
+      this.HandleFormattingAndOutput(root, () => {
+        // print the nodes to console
+        log.object({ ...root, children: undefined });
+        log.raw('');
+        log.info(
+          `${log.highlightText('e')} = has entry; ${log.highlightText(
+            'c'
+          )} = canonical; ${log.highlightText('m')} = include in menu`
+        );
+        log.line();
+        const outputChildren = (root: Node | undefined, depth = 2) => {
+          let str = '';
+          for (const node of (root as any)?.children as Node[]) {
+            str += `${outputNode(node, Array(depth + 1).join('  '))}\n`;
+            if ('children' in node) str += outputChildren(node, depth + 1);
+          }
+          return str;
+        };
+
+        const children = outputChildren(root);
+        log.limits(
+          `${outputNode(root, '  ')}${children ? `\n${children}` : ''}`,
+          100
+        );
+      });
+    } else {
+      log.warning(messages.models.noList(currentProject));
+      log.help(messages.connect.tip());
+    }
+  };
+
+  ImportNodes = async ({
+    commit,
+    fromFile,
+    logOutput,
+  }: {
+    commit: boolean;
+    fromFile: string;
+    logOutput: string;
+  }) => {
+    const { currentEnv, currentProject, log, messages } = this;
 
-    await this.ConnectContensisImport({
+    const contensis = await this.ConnectContensisImport({
       commit,
-      source: fromFile ? 'file' : 'contensis',
-      fileData,
-      fileDataType: 'entries',
+      fromFile,
+      importDataType: 'nodes',
     });
 
-    if (this.contensis) {
+    if (contensis) {
       log.line();
-      if (this.contensis.isPreview) {
+      if (contensis.isPreview) {
         console.log(log.successText(` -- IMPORT PREVIEW -- `));
       } else {
         console.log(log.warningText(` *** COMMITTING IMPORT *** `));
       }
 
-      const [migrateErr, migrateResult] = await this.contensis.MigrateEntries();
+      const [err, result] = await contensis.MigrateNodes();
 
-      if (migrateErr) logError(migrateErr);
+      if (err) logError(err);
       else
-        this.HandleFormattingAndOutput(migrateResult, () => {
+        this.HandleFormattingAndOutput(result, () => {
           // print the migrateResult to console
-          printMigrateResult(this, migrateResult);
+          // TODO: fix
+          printMigrateResult(this, result, {
+            showAllEntries: logOutput === 'all',
+            showChangedEntries: logOutput === 'changes',
+          });
         });
+
+      const nodesTotalCount = result?.nodesToMigrate[currentProject].totalCount;
+      const nodesCreated = result?.nodesResult?.['created'] || 0;
+      const nodesUpdated = result?.nodesResult?.['updated'] || 0;
+      const noChange = result.nodesToMigrate[currentProject]['no change'] !== 0;
+
+      if (
+        !err &&
+        !result.errors?.length &&
+        ((!commit && nodesTotalCount) ||
+          (commit && (nodesCreated || nodesUpdated)))
+      ) {
+        let totalCount: number;
+        if (commit) {
+          let created = typeof nodesCreated === 'number' ? nodesCreated : 0;
+          let updated = typeof nodesUpdated === 'number' ? nodesUpdated : 0;
+
+          totalCount = created + updated;
+        } else {
+          totalCount =
+            typeof nodesTotalCount === 'number' ? nodesTotalCount : 0;
+        }
+
+        log.success(messages.nodes.imported(currentEnv, commit, totalCount));
+        if (!commit) {
+          log.raw(``);
+          log.help(messages.nodes.commitTip());
+        }
+      } else {
+        if (noChange) {
+          log.help(messages.nodes.noChange(currentEnv), err);
+        } else {
+          log.error(messages.nodes.failedImport(currentEnv), err);
+          if (!nodesTotalCount) log.help(messages.nodes.notFound(currentEnv));
+        }
+      }
     } else {
-      log.warning(messages.contenttypes.noList(currentProject));
+      log.warning(messages.models.noList(currentProject));
       log.help(messages.connect.tip());
     }
   };
 
-  PrintWebhookSubscriptions = async (
-    subscriptionIds?: string[],
-    name?: string
-  ) => {
+  PrintWebhookSubscriptions = async (subscriptionIdsOrNames?: string[]) => {
     const { currentEnv, log, messages } = this;
-    if (!this.contensis) await this.ConnectContensis();
-    if (this.contensis) {
+    const contensis = await this.ConnectContensis();
+    if (contensis) {
       // Retrieve webhooks list for env
       const [webhooksErr, webhooks] =
-        await this.contensis.subscriptions.webhooks.GetSubscriptions();
-
-      const filteredResults =
-        typeof name === 'string'
-          ? webhooks.filter(w =>
-              w.name?.toLowerCase().includes(name.toLowerCase())
-            )
-          : Array.isArray(subscriptionIds)
-          ? webhooks.filter(w => subscriptionIds?.some(id => id === w.id))
-          : webhooks;
+        await contensis.subscriptions.webhooks.GetSubscriptions();
+
+      const filteredResults = subscriptionIdsOrNames?.length
+        ? webhooks?.filter(
+            w =>
+              subscriptionIdsOrNames?.some(idname =>
+                w.name?.toLowerCase().includes(idname.toLowerCase())
+              ) ||
+              subscriptionIdsOrNames?.some(
+                id => id.toLowerCase() === w.id.toLowerCase()
+              )
+          )
+        : webhooks;
 
       if (Array.isArray(filteredResults)) {
-        this.HandleFormattingAndOutput(filteredResults, () => {
-          // print the keys to console
-          log.success(messages.webhooks.list(currentEnv));
-          for (const {
-            id,
-            description,
-            method,
-            name,
-            version,
-            url,
-          } of filteredResults) {
-            console.log(
-              `  - ${name}${
-                description ? ` (${description})` : ''
-              } [${version.modified.toString().substring(0, 10)} ${
-                version.modifiedBy
-              }]`
-            );
-            console.log(`      ${id}`);
-            console.log(`      [${method}] ${url}`);
-          }
-          console.log('');
-        });
+        log.success(messages.webhooks.list(currentEnv));
+        if (!webhooks?.length) log.warning(messages.webhooks.noneExist());
+        else {
+          this.HandleFormattingAndOutput(filteredResults, () => {
+            // print the keys to console
+            for (const {
+              id,
+              description,
+              method,
+              name,
+              version,
+              url,
+              enabled,
+              topics,
+              templates,
+              headers,
+            } of filteredResults) {
+              console.log(
+                log.infoText(
+                  `  ${chalk.bold.white`- ${name}`} ${id} [${(
+                    version.modified || version.created
+                  )
+                    .toString()
+                    .substring(0, 10)} ${
+                    version.modifiedBy || version.createdBy
+                  }]`
+                )
+              );
+              if (description) console.log(log.infoText`    ${description}`);
+              console.log(`    ${log.infoText`[${method}]`} ${url}`);
+              if (headers && Object.keys(headers).length) {
+                console.log(`    ${log.infoText`headers`}:`);
+
+                for (const [key, { value, secret }] of Object.entries(headers))
+                  console.log(
+                    `      ${chalk.bold.gray(key)}: ${secret ? '🤐' : value}`
+                  );
+              }
+              if (topics?.length)
+                if (topics?.length === 1)
+                  console.log(
+                    `    ${log.infoText`topics`}: ${topics
+                      .map(t => JSON.stringify(t))
+                      .join(' ')
+                      .replaceAll('"', '')
+                      .replaceAll(',', ' ')
+                      .replaceAll('{', '')
+                      .replaceAll('}', '')}`
+                  );
+                else {
+                  console.log(`    ${log.infoText`topics`}:`);
+                  log.objectRecurse(topics, 1, '    ');
+                }
+              if (templates && Object.keys(templates).length)
+                console.log(
+                  `    ${log.infoText`templates`}: ${Object.keys(
+                    templates
+                  ).join(' ')}`
+                );
+              if (enabled === false)
+                console.log(`    ${log.infoText`enabled`}: ${enabled}`);
+            }
+          });
+        }
       }
 
       if (webhooksErr) {
@@ -1176,16 +1915,16 @@ class ContensisCli {
   };
 
   PrintBlocks = async () => {
-    const { currentEnv, log, messages } = this;
-    if (!this.contensis) await this.ConnectContensis();
-    if (this.contensis) {
+    const { currentEnv, env, log, messages } = this;
+    const contensis = await this.ConnectContensis();
+    if (contensis) {
       // Retrieve blocks list for env
-      const [err, blocks] = await this.contensis.blocks.GetBlocks();
+      const [err, blocks] = await contensis.blocks.GetBlocks();
 
       if (Array.isArray(blocks)) {
         this.HandleFormattingAndOutput(blocks, () => {
           // print the blocks to console
-          log.success(messages.blocks.list(currentEnv));
+          log.success(messages.blocks.list(currentEnv, env.currentProject));
           for (const {
             id,
             description,
@@ -1211,6 +1950,8 @@ class ContensisCli {
               );
           }
         });
+
+        return blocks;
       }
 
       if (err) {
@@ -1226,10 +1967,10 @@ class ContensisCli {
     version: string
   ) => {
     const { currentEnv, env, log, messages } = this;
-    if (!this.contensis) await this.ConnectContensis();
-    if (this.contensis) {
+    const contensis = await this.ConnectContensis();
+    if (contensis) {
       // Retrieve block version
-      const [err, blocks] = await this.contensis.blocks.GetBlockVersions(
+      const [err, blocks] = await contensis.blocks.GetBlockVersions(
         blockId,
         branch,
         version
@@ -1239,7 +1980,7 @@ class ContensisCli {
         this.HandleFormattingAndOutput(blocks, () => {
           // print the version detail to console
           log.success(
-            messages.blocks.get(`${currentEnv}:${env.currentProject}`)
+            messages.blocks.get(blockId, currentEnv, env.currentProject)
           );
           for (const block of blocks)
             printBlockVersion(
@@ -1255,6 +1996,8 @@ class ContensisCli {
                 : undefined
             );
         });
+
+        return blocks;
       }
 
       if (err) {
@@ -1268,18 +2011,20 @@ class ContensisCli {
     const { currentEnv, env, log, messages } = this;
 
     // Output request to console
-    messages.blocks.tryPush(
-      block.id,
-      block.source.branch,
-      currentEnv,
-      env.currentProject
+    log.info(
+      messages.blocks.tryPush(
+        block.id,
+        block.source.branch,
+        currentEnv,
+        env.currentProject
+      )
     );
     console.log(jsonFormatter(block));
 
-    if (!this.contensis) await this.ConnectContensis();
-    if (this.contensis) {
+    const contensis = await this.ConnectContensis();
+    if (contensis) {
       // Push new block version
-      const [err, blockVersion] = await this.contensis.blocks.PushBlockVersion(
+      const [err, blockVersion] = await contensis.blocks.PushBlockVersion(
         block
       );
       if (!err) {
@@ -1291,7 +2036,6 @@ class ContensisCli {
             env.currentProject
           )
         );
-        console.log(jsonFormatter(blockVersion));
       }
       if (blockVersion) {
         this.HandleFormattingAndOutput(blockVersion, () => {
@@ -1303,6 +2047,113 @@ class ContensisCli {
         throw new Error(
           messages.blocks.failedPush(block.id, currentEnv, env.currentProject)
         );
+    } else {
+      throw new Error(
+        messages.blocks.failedPush(block.id, currentEnv, env.currentProject)
+      );
+    }
+  };
+
+  GetLatestBlockVersion = async (
+    blockId: string,
+    branch = 'default'
+  ): Promise<[AppError | null, string | undefined]> => {
+    const { contensis, log, messages } = this;
+
+    // Look for block versions pushed to "default" branch
+    const [getErr, blockVersions] =
+      (await contensis?.blocks.GetBlockVersions(blockId, branch)) || [];
+
+    if (getErr) {
+      return [getErr, undefined];
+    }
+
+    // Parse versionNo from response
+    let blockVersionNo = 'latest';
+    // The first blockVersion should be the latest one
+    try {
+      blockVersionNo = `${blockVersions?.[0]?.version.versionNo}`;
+
+      if (!Number.isNaN(blockVersionNo) && Number(blockVersionNo) > 0)
+        // Is a valid versionNo
+        return [null, blockVersionNo];
+      else throw new Error(`'${blockVersionNo}' is not a valid version number`);
+    } catch (parseVersionEx: any) {
+      // Catch parsing errors in case of an unexpected response
+      log.info(
+        `Request for blockId: ${blockId}, branch: ${branch}, version: latest`
+      );
+      log.info(
+        `Get block versions response was: ${tryStringify(blockVersions)}`
+      );
+      log.error(messages.blocks.failedParsingVersion());
+      return [parseVersionEx, undefined];
+    }
+  };
+
+  ExecuteBlockAction = async (
+    action: BlockActionType,
+    blockId: string,
+    version = 'latest'
+  ) => {
+    const { currentEnv, env, log, messages } = this;
+    const contensis = await this.ConnectContensis();
+    if (contensis) {
+      let actionOnBlockVersion = version;
+
+      // If action is release and version is latest, find the latest version number
+      if (action === 'release' && version === 'latest') {
+        const [getErr, blockVersion] = await this.GetLatestBlockVersion(
+          blockId
+        );
+
+        if (getErr) {
+          // Log error getting latest block version no
+          // and throw the error message so the process can exit with a failure
+          throw new Error(
+            `${messages.blocks.noList(
+              currentEnv,
+              env.currentProject
+            )} (${getErr})`
+          );
+        } else if (blockVersion) {
+          actionOnBlockVersion = blockVersion;
+        }
+      }
+
+      // Execute block action
+      const [err, blockVersion] = await contensis.blocks.BlockAction(
+        blockId,
+        action,
+        actionOnBlockVersion
+      );
+
+      if (blockVersion) {
+        this.HandleFormattingAndOutput(blockVersion, () => {
+          // print the version detail to console
+          log.success(
+            messages.blocks.actionComplete(
+              action,
+              blockId,
+              currentEnv,
+              env.currentProject
+            )
+          );
+          printBlockVersion(this, blockVersion);
+        });
+      }
+
+      if (err) {
+        log.error(jsonFormatter(err));
+        throw new Error(
+          messages.blocks.actionFailed(
+            action,
+            blockId,
+            currentEnv,
+            env.currentProject
+          )
+        );
+      }
     }
   };
 
@@ -1310,79 +2161,252 @@ class ContensisCli {
     blockId: string,
     branch: string,
     version: string,
-    dataCenter: 'hq' | 'manchester' | 'london'
+    dataCenter: 'hq' | 'manchester' | 'london' | undefined,
+    follow = false
   ) => {
-    const { currentEnv, log, messages } = this;
-    if (!this.contensis) await this.ConnectContensis();
-    if (this.contensis) {
+    const { currentEnv, env, log, messages } = this;
+    const contensis = await this.ConnectContensis();
+    if (contensis) {
       // Retrieve block logs
-      const [err, blockLogs] = await this.contensis.blocks.GetBlockLogs({
+      log.success(
+        messages.blocks.getLogs(blockId, branch, currentEnv, env.currentProject)
+      );
+
+      const [err, blockLogs] = await contensis.blocks.GetBlockLogs({
         blockId,
         branchId: branch,
         version,
         dataCenter,
       });
 
-      if (blockLogs) {
-        this.HandleFormattingAndOutput(blockLogs, () => {
-          // print the  logs to console
-          log.success(messages.blocks.list(currentEnv));
+      if (err) {
+        log.error(
+          messages.blocks.failedGetLogs(blockId, currentEnv, env.currentProject)
+        );
+        log.error(jsonFormatter(err));
+      } else if (blockLogs) {
+        const removeTrailingNewline = (logs: string) =>
+          logs.endsWith('\n') ? logs.slice(0, logs.length - 1) : logs;
+        const renderLogs = removeTrailingNewline(blockLogs);
+
+        this.HandleFormattingAndOutput(renderLogs, () => {
+          // print the logs to console
           console.log(
             `  - ${blockId} ${branch} ${
               Number(version) ? `v${version}` : version
-            } [${dataCenter}]`
+            } ${dataCenter ? `[${dataCenter}]` : ''}`
           );
           log.line();
-          console.log(log.infoText(blockLogs));
-          log.line();
+          console.log(log.infoText(renderLogs));
+        });
+
+        // Code for the `--follow` options
+        let following = follow;
+        let alreadyShown = blockLogs;
+        let needsNewLine = false;
+        let counter = 0;
+
+        // remove existing listeners and add them back afterwards
+        const listeners = process.listeners('SIGINT');
+
+        process.removeAllListeners('SIGINT');
+        // add listener to update following to false and break out
+        process.on('SIGINT', () => {
+          Logger.warning(
+            messages.blocks.stopFollow(blockId, currentEnv, env.currentProject)
+          );
+          stopFollowing();
+        });
+
+        let delay = promiseDelay(5 * 1000, null);
+        const stopFollowing = () => {
+          following = false;
+          delay.cancel();
+
+          // Add back the listeners we removed previously
+          process.removeAllListeners('SIGINT');
+          for (const listener of listeners)
+            process.addListener('SIGINT', listener);
+        };
+
+        while (following) {
+          if (counter++ > 300) {
+            Logger.warning(
+              messages.blocks.timeoutFollow(
+                blockId,
+                currentEnv,
+                env.currentProject
+              )
+            );
+            stopFollowing();
+          }
+
+          // wait n. seconds then poll for logs again
+          await delay.wait();
+
+          const [lastErr, lastLogs] = following
+            ? await contensis.blocks.GetBlockLogs({
+                blockId,
+                branchId: branch,
+                version,
+                dataCenter,
+              })
+            : [null, null];
+
+          if (lastLogs) {
+            // Find the difference and output it next
+            const difference = diffLogStrings(lastLogs, alreadyShown);
+            if (difference) {
+              if (needsNewLine) {
+                console.log('');
+              }
+              // Take the trailing newline off of the logged output to
+              // avoid blank lines inbetween logs fetched sequentially
+              const render = removeTrailingNewline(difference);
+              console.log(log.infoText(render));
+
+              // Add what we've just rendered to already shown "cache"
+              alreadyShown += `${render}\n`;
+              needsNewLine = false;
+            } else {
+              // If no difference output a dot
+              process.stdout.write('.');
+              needsNewLine = true;
+            }
+          } else if (lastErr) {
+            // If error output an x
+            process.stdout.write('x');
+            needsNewLine = true;
+          }
+        }
+      }
+    }
+  };
+
+  PrintProxies = async (proxyId?: string) => {
+    const { currentEnv, env, log, messages } = this;
+    const contensis = await this.ConnectContensis();
+    if (contensis) {
+      // Retrieve proxies list for env
+      const [err, proxies] = await (contensis.proxies.GetProxies as any)(
+        proxyId
+      ); // TODO: resolve any cast;
+
+      if (Array.isArray(proxies)) {
+        this.HandleFormattingAndOutput(proxies, () => {
+          // print the proxies to console
+          log.success(messages.proxies.list(currentEnv, env.currentProject));
+          for (const { id, name, description, endpoints, version } of proxies) {
+            console.log(
+              `  - ${name} [${
+                version.versionNo
+              }] ${id} ${log.infoText`${description}`}`
+            );
+            for (const [language, endpoint] of Object.entries(
+              endpoints as { [k: string]: any }
+            )) // TODO: resolve any cast
+              console.log(
+                `      - ${log.infoText`language: ${language}
+        server: ${endpoint.server}
+        headers.host: ${endpoint.headers.host}
+        ssl: ${endpoint.ssl}`}`
+              );
+          }
         });
       }
 
       if (err) {
-        log.error(messages.blocks.noList(currentEnv));
+        log.error(messages.proxies.noList(currentEnv, env.currentProject));
         log.error(jsonFormatter(err));
       }
     }
   };
 
+  PrintRenderers = async (rendererId?: string) => {
+    const { currentEnv, env, log, messages } = this;
+    const contensis = await this.ConnectContensis();
+    if (contensis) {
+      // Retrieve renderers list for env
+      const [err, renderers] = await (contensis.renderers.GetRenderers as any)(
+        rendererId
+      ); // TODO: resolve any cast
+
+      if (Array.isArray(renderers)) {
+        this.HandleFormattingAndOutput(renderers, () => {
+          // print the renderers to console
+          log.success(messages.renderers.list(currentEnv, env.currentProject));
+          for (const {
+            id,
+            description,
+            assignedContentTypes,
+            rules,
+            version,
+          } of renderers) {
+            console.log(
+              `  - ${id} [${version.versionNo}] ${log.infoText`${description}`}`
+            );
+            if (assignedContentTypes?.length)
+              console.log(
+                log.infoText`      assignedContentTypes: ${assignedContentTypes.join(
+                  ', '
+                )}`
+              );
+            for (const rule of rules)
+              if (rule.return)
+                console.log(
+                  log.infoText`      ${
+                    rule.return.endpointId ? 'endpointId' : 'blockId'
+                  }: ${rule.return.endpointId || rule.return.blockId}`
+                );
+          }
+        });
+      }
+
+      if (err) {
+        log.error(messages.renderers.noList(currentEnv, env.currentProject));
+        log.error(jsonFormatter(err));
+      }
+    }
+  };
   HandleFormattingAndOutput = <T>(obj: T, logFn: (obj: T) => void) => {
     const { format, log, messages, output } = this;
+    if (!format) {
+      // print the object to console
+      logFn(obj);
+    } else if (format === 'csv') {
+      log.raw('');
+      log.raw(log.infoText(csvFormatter(obj)));
+    } else if (format === 'xml') {
+      log.raw('');
+      log.raw(log.infoText(xmlFormatter(obj)));
+    } else if (format === 'json') {
+      log.raw('');
+      log.raw(log.infoText(jsonFormatter(obj)));
+    }
+    log.raw('');
+
     if (output) {
       let writeString = '';
+      const isText = !tryParse(obj) && typeof obj === 'string';
       if (format === 'csv') {
         writeString = csvFormatter(obj as any);
       } else if (format === 'xml') {
         writeString = xmlFormatter(obj as any);
-      } else writeString = jsonFormatter(obj);
+      } else writeString = isText ? (obj as string) : jsonFormatter(obj);
       // write output to file
       if (writeString) {
         fs.writeFileSync(output, writeString);
-        log.success(messages.app.fileOutput(format, output));
+        log.success(messages.app.fileOutput(isText ? 'text' : format, output));
       } else {
         log.info(messages.app.noFileOutput());
       }
-    } else {
-      if (!format) {
-        // print the object to console
-        logFn(obj);
-      } else if (format === 'csv') {
-        log.raw('');
-        log.raw(log.infoText(csvFormatter(obj)));
-      } else if (format === 'xml') {
-        log.raw('');
-        log.raw(log.infoText(xmlFormatter(obj)));
-      } else if (format === 'json') {
-        log.raw('');
-        log.raw(log.infoText(jsonFormatter(obj)));
-      }
-      log.raw('');
     }
   };
 }
 
 export const cliCommand = (
   commandArgs: string[],
-  outputOpts: OutputOptions & IConnectOptions = {},
+  outputOpts?: OutputOptionsConstructorArg,
   contensisOpts: Partial<MigrateRequest> = {}
 ) => {
   return new ContensisCli(['', '', ...commandArgs], outputOpts, contensisOpts);