@optimizely/ocp-cli 1.0.0-beta.2

package/src/commands/app/Init.ts

@@ -0,0 +1,303 @@
+import {APP_ID_FORMAT, VENDOR_FORMAT, VERSION_FORMAT} from '@zaiusinc/app-sdk';
+import chalk from 'chalk';
+import * as columnify from 'columnify';
+import * as fs from 'fs';
+import * as marked from 'marked';
+import * as MarkedTerminal from 'marked-terminal';
+import fetch from 'node-fetch';
+import {command, help, namespace, optional, param} from 'oo-cli';
+import * as path from 'path';
+import {terminal} from 'terminal-kit';
+import {handleInterrupt} from '../../lib/handleInterrupt';
+import {TerminalPassthru} from '../../lib/TeminalPassthru';
+import {fetchTemplatesManifest} from '../../lib/templating/fetchTemplatesManifest';
+import {TemplateRenderer} from '../../lib/templating/TemplateRenderer';
+import {TemplateManifest, TemplateVariable} from '../../lib/templating/types';
+import {TerminalConfirm} from '../../lib/TerminalConfirm';
+import {TerminalInput} from '../../lib/TerminalInput';
+import {TerminalMenu} from '../../lib/TerminalMenu';
+import {TerminalSpinner} from '../../lib/TerminalSpinner';
+import titleCase = require('title-case');
+import { getDependencyFileUrl } from '../../lib/Config';
+import {Rivendell} from '../../lib/Rivendell';
+import {die} from '../../lib/die';
+
+@namespace('app')
+export class CreateCommand {
+  @param
+  @optional
+  @help('The app id / directory to create')
+  public id?: string;
+
+  private variables!: TemplateVariable[];
+  private variableId = 0;
+  private manifest!: TemplateManifest;
+  private substitutions: {[key: string]: string} = {};
+  private warnings: any[] = [];
+
+  @command
+  @help('Create a new app project')
+  public async init() {
+    handleInterrupt();
+    this.manifest = await fetchTemplatesManifest();
+
+    // start with base variables
+    this.variables = this.manifest.baseTemplateVariables;
+
+    // setting developer vendor
+    this.variables.find((v) => v.name === 'vendor')!.suggest = (await Rivendell.whoami()).vendor;
+
+    this.variables.push({
+      name: 'template',
+      question: 'Select a template project'
+    });
+    if (!await this.askQuestion()) {
+      process.exit(1);
+    }
+  }
+
+  private async renderTemplate() {
+    const {app_id, template: templateName} = this.substitutions;
+    delete this.substitutions.template;
+
+    let fullPath: string | undefined;
+    if (fs.readdirSync(process.cwd()).length === 0) {
+      if (await TerminalConfirm.ask(`Use current directory (${chalk.yellow(process.cwd())})?`)) {
+        fullPath = process.cwd();
+        console.log(chalk.gray(`Using ${chalk.yellow(fullPath)}`));
+      }
+    }
+
+    if (!fullPath) {
+      const suggestion = app_id.replace(/_/g, '-');
+      let dirName = await TerminalInput.ask(`Project directory name:`, {defaultValue: suggestion});
+      while (fs.existsSync(path.resolve(dirName)) && fs.readdirSync(path.resolve(dirName)).length !== 0) {
+        console.log(chalk.red(`Directory ${path.resolve(dirName)} is not empty!`));
+        dirName = await TerminalInput.ask(`Project directory name:`, {defaultValue: suggestion});
+      }
+      fullPath = path.resolve(dirName);
+      console.log(chalk.gray('Creating directory', chalk.yellow(fullPath)));
+      fs.mkdirSync(fullPath);
+    }
+
+    // add latest sdk versions to the substitutions
+    const spinner = new TerminalSpinner().start(chalk.gray('Checking latest SDK versions...'));
+    await this.getSDKVersions();
+
+    const template = this.manifest.templates.find((t) => t.name === templateName);
+    await new TemplateRenderer(fullPath, template!, (status) => spinner.update(status))
+      .render(this.substitutions);
+
+    spinner.stop();
+
+    console.log(chalk.gray('Performing initial Yarn install'));
+    const result = TerminalPassthru.exec('yarn');
+    if (result.status !== 0) {
+      console.log(chalk.red(
+        'There was a problem running yarn. Make sure yarn is installed and then run '
+        + `${chalk.white('yarn install')} from ${chalk.white(fullPath)} to install dependencies.`
+      ));
+    }
+
+    if (this.warnings.length > 0) {
+      this.warnings.forEach((warning) => console.warn(warning));
+    }
+
+    marked.setOptions({renderer: new MarkedTerminal()});
+    console.log('\n' + marked(
+      `New OCP app project created at \`${fullPath}\`\n` +
+      '- View README.md for information on getting started\n' +
+      '- Check out the [documentation](https://docs.developers.optimizely.com/optimizely-connect-platform/docs)'
+    ));
+  }
+
+  private get variable() {
+    return this.variables[this.variableId];
+  }
+
+  private get templateOptions() {
+    return columnify(this.manifest.templates, {columns: ['name', 'sp', 'summary']}).split('\n').slice(1);
+  }
+
+  private get question() {
+    if (this.suggestion) {
+      return `${this.variable.question} [${chalk.gray(this.suggestion)}]`;
+    }
+    if (this.variable.hint) {
+      return `${this.variable.question} (${chalk.gray(this.variable.hint)})`;
+    }
+    return this.variable.question;
+  }
+
+  private async askQuestion() {
+    if (this.variables.length <= this.variableId) {
+      return false;
+    }
+
+    if (this.variable.hidden) {
+      await this.onAnswer(undefined, this.variable.suggest || '');
+      return true;
+    }
+
+    // special case questions:
+    switch (this.variable.name) {
+      case 'template':
+        const index = (await TerminalMenu.ask(`${this.question}:`, this.templateOptions, {layout: 'row'})).id as number;
+        await this.onAnswer(undefined, this.manifest.templates[index].name);
+        break;
+
+      case 'category':
+        const categories = ['Commerce Platform', 'Point of Sale', 'Lead Capture', 'Advertising', 'Marketing',
+          'Channel', 'Loyalty & Rewards', 'Customer Experience', 'Analytics & Reporting', 'Surveys & Feedback',
+          'Reviews & Ratings', 'Content Management', 'Data Quality & Enrichment', 'Productivity', 'CRM',
+          'Accounting & Finance', 'CDP / DMP', 'Attribution & Linking', 'Testing & Utilities',
+          'Personalization & Content', 'Offers', 'Merchandising & Products', 'Site & Content Experience',
+          'Subscriptions'].sort();
+        await this.onAnswer(undefined, (await TerminalMenu.ask(`${this.question}:`, categories)).text);
+        break;
+
+      // standard questions
+      default:
+        await this.onAnswer(undefined, await TerminalInput.ask(
+          `${this.question}:`, {getHint: this.getHint, validate: this.validateInput}
+        ));
+    }
+    return true;
+  }
+
+  private onAnswer = async (error: any, input: string) => {
+    if (error) {
+      terminal.eraseDisplayBelow().nextLine(1);
+      console.error(chalk.red(error));
+      process.exit(1);
+    }
+
+    input = input.trim();
+    if (this.suggestion && input === '') {
+      input = this.suggestion;
+    }
+
+    if (!this.validateInput(input)) {
+      if (this.variable.required && input.length === 0) {
+        terminal.red('  This value is required').nextLine(1);
+      } else {
+        terminal.red(`  Invalid value for ${this.variable.name}`).nextLine(1);
+      }
+      if (this.variable.hidden) {
+        die(`Invalid value of '${this.variable.name}' field: ${input}. Contact support`);
+      } else {
+        await this.askQuestion();
+      }
+    } else {
+      if (!this.variable.hidden) {
+        terminal(chalk.gray(this.question + ': ')).white(input).nextLine(1);
+      }
+      this.substitutions[this.variable.name] = input;
+      this.variableId++;
+      if (!await this.askQuestion()) {
+        await this.renderTemplate();
+      }
+    }
+  }
+
+  private getHint = (input: string): string => {
+    if (input.trim() === '' && this.suggestion) {
+      return `[Enter] to accept ${this.suggestion}`;
+    }
+    switch (this.variable.name) {
+      case 'display_name':
+        if (input.length === 0) {
+          return chalk.yellow('Display Name is required');
+        }
+        break;
+
+      case 'app_id':
+        if (!input) {
+          return chalk.yellow('App ID is required');
+        } else if (!input.match(/^[a-z]/)) {
+          return chalk.yellow('must start with a lower case letter');
+        } else if (!input.match(/^[a-z_0-9]+$/)) {
+          return chalk.yellow('can only contain lower case letters, numbers, and underscores');
+        } else if (input.match(/_$/)) {
+          return chalk.yellow('should not end with an underscore');
+        } else if (input.length < 3 || input.length > 32) {
+          return chalk.yellow('must be between 3 and 32 characters long');
+        }
+        break;
+
+      case 'version':
+        if (!input.match(VERSION_FORMAT)) {
+          return chalk.yellow('must be semver. -beta, -dev, -private pre-releases are allowed');
+        }
+        break;
+
+      case 'vendor':
+        if (!input.match(/^[a-z]/)) {
+          return chalk.yellow('must start with a lower case letter');
+        } else if (!input.match(VENDOR_FORMAT)) {
+          return chalk.yellow('must be snake_case');
+        }
+        break;
+    }
+    return '';
+  }
+
+  private validateInput = (input: string): boolean => {
+    if (!input) {
+      input = this.suggestion;
+    }
+    switch (this.variable.name) {
+      case 'app_id':
+        return APP_ID_FORMAT.test(input);
+      case 'version':
+        return VERSION_FORMAT.test(input);
+      case 'vendor':
+        return VENDOR_FORMAT.test(input);
+    }
+
+    if (this.variable.required && input.length === 0) {
+      return false;
+    }
+    return true;
+  }
+
+  private get suggestion(): string {
+    switch (this.variable.name) {
+      case 'display_name':
+        if (this.id || fs.readdirSync(process.cwd()).length === 0) {
+          const dir = titleCase(this.id || path.basename(process.cwd()).replace(/[^a-zA-Z0-9]+/g, ' ').trim());
+          if (dir && this.validateInput(dir)) {
+            return dir;
+          }
+        }
+        break;
+
+      case 'app_id':
+        const appId = (this.substitutions['display_name'] || '').toLowerCase().replace(/[^0-9a-z_]+/g, '_');
+        if (appId.length > 0 && this.validateInput(appId)) {
+          return appId;
+        }
+        break;
+    }
+    return this.variable.suggest || '';
+  }
+
+  private getLatestSDKVersion(versions: {[key: string]: {[key: string]: string}}) {
+    const major = Object.keys(versions).map((x) => parseInt(x, 10)).sort().reverse()[0].toString();
+    return versions[major].stable;
+  }
+
+  private async getSDKVersions() {
+    try {
+      // TODO: use semver to only get the latest allowable by the templates to avoid major version incompatibilities
+      const deps = await fetch(getDependencyFileUrl('node18'));
+      const json = await deps.json() as any;
+      this.substitutions['app_sdk_version'] = this.getLatestSDKVersion(json['@zaiusinc/app-sdk']);
+      this.substitutions['node_sdk_version'] = this.getLatestSDKVersion(json['@zaiusinc/node-sdk']);
+    } catch (e) {
+      this.warnings.push('Error fetching sdk versions, defaulting to latest: ', e.message);
+      this.substitutions['app_sdk_version'] = 'latest';
+      this.substitutions['node_sdk_version'] = 'latest';
+    }
+  }
+}

package/src/commands/app/Logs.ts

@@ -0,0 +1,241 @@
+import chalk from 'chalk';
+
+import {command, defaultValue, flag, help, multiple, namespace, option} from 'oo-cli';
+import {isValidDateOrEpochOrDurationString, parseDate} from '../../lib/parseDate';
+import {die} from '../../lib/die';
+import {handleInterrupt} from '../../lib/handleInterrupt';
+import {TerminalSpinner} from '../../lib/TerminalSpinner';
+import {Moria} from '../../lib/Moria';
+import {Rivendell} from '../../lib/Rivendell';
+import {formatError} from '../../lib/formatError';
+import LoggingSearchCriteria = Moria.LoggingSearchCriteria;
+import LoggingSearchResult = Moria.LoggingSearchResult;
+import LogEntry = Moria.LogEntry;
+import LogLevel = Moria.LogLevel;
+
+const TAIL_CONFIG = Object.freeze({
+  // Each pass of the tail query will cover at least tailminWindowMs.
+  // This is done to prevent gaps that may occur (i.e. should encourage at least once delivery).
+  minWindowMs: 30000,
+
+  // Each pass of the query will be up to Date.now - tailLag
+  // This is done to minimize ordering issue due to log ingest lag
+  lagMs: 15000,
+
+  queryIntervalMs: 5000,
+
+  // Size of the dedupe cache.
+  dedupeCacheSize: 5000
+});
+
+// Maximum page size for search results.
+const PAGE_SIZE = 5000;
+
+type LogEntryCallback = (entry: LogEntry) => void;
+
+@namespace('app')
+export class LogsCommand {
+  @option
+  @help('The App ID (e.g. my_app). Either App ID or Build ID must be specified.')
+  public appId?: string;
+
+  @option
+  @help('The ID of the build. Either App ID or Build ID must be specified. Build IDs are printed by \'ocp app prepare\' command.')
+  public buildId?: string;
+
+  @option
+  @help('The app version (e.g. 1.0.0)')
+  public appVersion?: string;
+
+  @option
+  @help('The Tracker ID of the ODP account')
+  public trackerId?: string;
+
+  @option
+  @help('Show logs for given execution of a job. Use \'ocp jobs list\' command to get the job ID')
+  public jobId?: string;
+
+  @option
+  @help(`Filter app logs by log level. Valid values: ${Object.values(LogLevel).join(', ')}`)
+  @defaultValue('debug')
+  public level!: string;
+
+  @option
+  @help('A start time as an ISO string, an epoch timestamp, or relative string (i.e. "5m" for 5 minutes.) Default: 24h')
+  @defaultValue('24h')
+  public from!: string;
+
+  @option
+  @help('A end time as an ISO string, an epoch timestamp, or relative string (i.e. "5m" for 5 minutes)')
+  public to?: string;
+
+  @flag
+  @help('Tails the logs')
+  @defaultValue(false)
+  public tail!: boolean;
+
+  @option
+  @help('String to search for in log messages.  Can be specified multiple times.')
+  @multiple
+  public search?: string[];
+
+  @option('a')
+  @help('The availability zone that will be targeted (default: us)')
+  private availability: string = '';
+
+  @command
+  @help('Fetch app logs')
+  public async logs() {
+    handleInterrupt();
+    if (!isValidDateOrEpochOrDurationString(this.from)) {
+      die(chalk.red('Invalid "--from" input, should be an ISO string,' +
+        'an epoch timestamp, or relative string (i.e. "5m" for 5 minutes.'));
+    }
+    const fromDate = parseDate(this.from);
+
+    let toDate: Date | undefined;
+
+    if (!this.appId && !this.buildId && !this.jobId) {
+      die('Either App ID, Build ID or Job ID must be specified.');
+    }
+
+    if ((this.appId && this.buildId) || (this.appId && this.jobId) ||
+      (this.buildId && this.jobId) || (this.appId && this.buildId && this.jobId)) {
+      die('Only App ID, Build ID or Job ID should be specified.');
+    }
+
+    if (this.appId && !this.trackerId) {
+      die('Tracker ID must be specified if App ID is specified.');
+    }
+
+    if (this.tail) {
+      if (this.to) {
+        die('Cannot specify --tail if specifying --to');
+      }
+    } else {
+      if (this.to && !isValidDateOrEpochOrDurationString(this.to)) {
+        die(chalk.red('Invalid "--to" input, should be an ISO string, ' +
+          'an epoch timestamp, or relative string (i.e. "5m" for 5 minutes.'));
+      }
+      toDate = this.to ? parseDate(this.to) : new Date();
+    }
+
+    this.availability = this.availability ? this.availability : 'us';
+    const shard = (await Rivendell.shards()).find((_shard) => _shard.id === this.availability);
+    if (!shard) {
+      die('Could not find the specified availability zone.');
+    }
+
+    if (this.level) {
+      if (!Object.values(LogLevel).includes(this.level.toUpperCase() as LogLevel)) {
+          die(`Invalid log level. Valid values: ${Object.values(LogLevel).join(', ')}`);
+      }
+    }
+
+    try {
+      if (this.tail) {
+        await this.tailLogs(shard!, parseDate('5m'));
+      } else {
+        const spinner = new TerminalSpinner().start('');
+        try {
+          await this.dumpLogs(shard!, fromDate, this.printLogEntry, toDate);
+        } finally {
+          spinner.stop();
+        }
+      }
+    } catch (e) {
+      die(formatError(e));
+    }
+  }
+
+  private printLogEntry = (entry: LogEntry) => {
+    const columns = [
+      new Date(entry.time).toISOString(),
+      this.formatLevel(entry.level),
+      entry.message
+    ];
+    console.log(columns.join(' '));
+  }
+
+  private formatLevel = (level: LogLevel) => {
+    const padding = 5;
+    switch (level.toUpperCase()) {
+      case LogLevel.DEBUG: {
+        return chalk.blue('DEBUG'.padEnd(padding));
+      }
+      case LogLevel.INFO: {
+        return chalk.gray('INFO'.padEnd(padding));
+      }
+      case LogLevel.WARN: {
+        return chalk.yellow('WARN'.padEnd(padding));
+      }
+      case LogLevel.ERROR: {
+        return chalk.red('ERROR'.padEnd(padding));
+      }
+      default:
+        return '';
+    }
+  }
+
+  private async dumpLogs(
+    shard: Rivendell.Shard,
+    from: Date | number,
+    cb: LogEntryCallback,
+    to?: Date | number
+  ): Promise<number> {
+    let result: LoggingSearchResult;
+    let count = 0;
+    const request = this.buildRequest(from, to);
+    do {
+      result = await Moria.searchLogging(request, shard);
+      result.entries.forEach(cb);
+      request.cursor = result.cursor;
+      count += result.entries.length;
+    } while (result.entries.length > 0);
+    return count;
+  }
+
+  private async tailLogs(shard: Rivendell.Shard, from: Date) {
+    const dedupeCache: Set<string> = new Set();
+    let start = from.valueOf();
+
+    const callback = (entry: LogEntry) => {
+      if (!dedupeCache.has(entry.id)) {
+        this.printLogEntry(entry);
+        dedupeCache.add(entry.id);
+        if (dedupeCache.size > TAIL_CONFIG.dedupeCacheSize) {
+          dedupeCache.delete(dedupeCache.entries().next().value);
+        }
+        start = Math.max(start, entry.time);
+      }
+    };
+
+    const spinner = new TerminalSpinner().start('');
+
+    const query = async () => {
+      const end = Date.now() - TAIL_CONFIG.lagMs;
+      start = Math.min(start, end + TAIL_CONFIG.minWindowMs);
+      await this.dumpLogs(shard, start, callback, end);
+      spinner.update(chalk.gray('Waiting for more logs...'));
+      setTimeout(query, TAIL_CONFIG.queryIntervalMs);
+    };
+    await query();
+  }
+
+  private buildRequest(from: Date | number, to?: Date | number): LoggingSearchCriteria {
+    return {
+      context: {
+        appId: this.appId,
+        appVersion: this.appVersion,
+        jobId: this.jobId,
+        trackerId: this.trackerId,
+        buildId: this.buildId,
+      },
+      pageSize: PAGE_SIZE,
+      start: typeof from === 'number' ? from : from.valueOf(),
+      end: to ? (typeof to === 'number' ? to : to.valueOf()) : undefined,
+      level: this.level as LogLevel,
+      terms: this.search
+    };
+  }
+}

package/src/commands/app/Package.ts

@@ -0,0 +1,39 @@
+import * as fs from 'fs';
+import {command, defaultValue, help, namespace, param} from 'oo-cli';
+import * as path from 'path';
+import {appContext} from '../../lib/AppContext';
+import {AppPackager} from '../../lib/AppPackager';
+import {die} from '../../lib/die';
+import {directoryExists} from '../../lib/directoryExists';
+
+@namespace('app')
+export class PackageCommand {
+  @param
+  @help('The root directory of the app')
+  @defaultValue('./')
+  public path!: string;
+
+  @command
+  @help('Prepare a package for manual upload')
+  public package() {
+    const workingDir = process.cwd();
+    if (!directoryExists(this.path)) {
+      die('Specified path to app does not exist');
+      return;
+    }
+    process.chdir(this.path);
+
+    const context = appContext();
+    if (!context.appId || !context.version) {
+      die('Unable to read App ID or version info. Ensure you are uploading the right directory.');
+      return;
+    }
+
+    if (context) {
+      const packageData = new AppPackager('./').package();
+      const zipFileName = `${context.appId}@${context.version}.zip`;
+      fs.writeFileSync(path.join(workingDir, zipFileName), packageData);
+      console.log(`Created package ${zipFileName}`);
+    }
+  }
+}

package/src/commands/app/Prepare.ts

@@ -0,0 +1,108 @@
+import chalk from 'chalk';
+import {command, flag, help, namespace} from 'oo-cli';
+import {appContext} from '../../lib/AppContext';
+import {PublishCommand} from '../directory/Publish';
+import {BaseBuildCommand} from './BaseBuildCommand';
+import {TerminalConfirm} from '../../lib/TerminalConfirm';
+import * as semver from 'semver';
+import * as fs from 'fs';
+import * as path from 'path';
+import {Rivendell} from '../../lib/Rivendell';
+import AppReview = Rivendell.AppReview;
+
+@namespace('app')
+export class PrepareCommand extends BaseBuildCommand {
+  @flag
+  @help('Automatically publish if the upload is successful')
+  public publish!: boolean;
+
+  @flag('use-previous-app-env-values')
+  @help('Use app env values (.env file) from the previous version of the app. Any values in local .env file will be ignored')
+  public usePreviousAppEnvValues: boolean = false;
+
+  @flag('bump-dev-version')
+  @help('Bump dev version before building. Allows quickly testing dev versions')
+  public bumpDevVersion!: boolean;
+
+  @command
+  @help('Validate, package, upload and build an app to prepare for publishing')
+  public async prepare() {
+    const context = appContext();
+    if (!context.appId || !context.version) {
+      console.log(chalk.gray('App id or version missing in the manifest\n'));
+      return;
+    }
+    const requiresReview = await this.requiresReview(context.version);
+    if (requiresReview) {
+      const isInReview = await this.isInReview(context.appId, context.version);
+      const reviewMessage = isInReview ?
+        chalk.gray(
+          'The app version is already in review. This will update the review and the app can\'t be published until it is approved. ' +
+          `${chalk.yellow('Are you sure?')}`
+        ) :
+        chalk.gray(
+          'You are uploading a release version of the app. ' +
+          'This will start a review process and the app can\'t be published until it is approved. ' +
+          `${chalk.yellow('Are you sure?')}`
+        );
+
+      const reviewConfirmation = await TerminalConfirm.ask(reviewMessage);
+      if (!reviewConfirmation) {
+        return;
+      }
+    }
+
+    if (context.version && this.bumpDevVersion) {
+      if (this.isDevVersion(context.version)) {
+        const bumpedVersion = semver.parse(context.version)?.inc('prerelease', 'dev').format();
+        if (!bumpedVersion) {
+          console.log(chalk.red(`Cannot parse app version: ${context.version}`));
+          return;
+        }
+
+        console.log(chalk.gray(`Bumping dev version to ${bumpedVersion}`));
+
+        this.updateVersionInAppManifest(context.version, bumpedVersion);
+        context.version = bumpedVersion;
+      } else {
+        console.log(chalk.yellow('Not a dev version. Ignoring --bump-dev-version flag'));
+      }
+    }
+
+    await this.run(true, true, this.usePreviousAppEnvValues);
+    await this.reviewAppVersion(context.appId as string, context.version as string);
+
+    if (this.publish) {
+      const cmd = new PublishCommand();
+      cmd.appVersion = `${context.appId}@${context.version}`;
+      await cmd.publish();
+    } else {
+      if (requiresReview) {
+        const appVersion = `${context.appId}@${context.version}`;
+        const appReview = await Rivendell.getReviewUrl(appVersion);
+        const reviewUrl = (appReview as AppReview).url;
+
+        console.log(chalk.gray(`\nYour app has been sent to review. Your code will be available in a private repository on GitHub, ` +
+        `and you will receive an invitation from GitHub by email for access.` +
+        `It is important you accept this invitation in order to receive communications about your app from the review team.`));
+        console.log(chalk.gray(`\nOnce the review is approved, your app can be deployed to app directory.\n`));
+        console.log(chalk.gray(`You can run ${chalk.white(`ocp review open ${appVersion}`)} to open the review URL at any time.`));
+        console.log(chalk.gray(`The URL for your repo is ${chalk.white(`${reviewUrl}`)}\n`));
+      } else {
+        console.log(chalk.gray(
+          `\nUse ${chalk.white(
+            `ocp directory publish ${context.appId}@${context.version}`
+          )} to publish and release your app\n`
+        ));
+      }
+    }
+
+    // explicitly exit because we're using terminal kit
+    process.exit(0);
+  }
+
+  private updateVersionInAppManifest(oldVersion: string, newVersion: string) {
+    const file = path.join(process.cwd(), 'app.yml');
+    fs.writeFileSync(file, fs.readFileSync(file, 'utf8').replace(new RegExp(`(version\\s*:\\s*)${oldVersion}`), `$1${newVersion}`));
+  }
+}