@optimizely/ocp-cli 1.0.0-beta.2

package/src/commands/jobs/RuntimeStatus.ts

@@ -0,0 +1,49 @@
+import chalk from 'chalk';
+import {command, help, namespace, option, param} from 'oo-cli';
+import {die} from '../../lib/die';
+import {formatError} from '../../lib/formatError';
+import {formatJobStatus} from '../../lib/formatJobStatus';
+import {timestampToDurationString} from '../../lib/formatTimstamp';
+import { jobRuntime } from '../../lib/jobRuntime';
+import {Rivendell} from '../../lib/Rivendell';
+
+@namespace('jobs')
+export class RuntimeStatusCommand {
+
+  @param
+  @help('ID of Job to get the runtime status for')
+  private jobId!: string;
+
+  @option('a')
+  @help('The availability zone that will be targeted (default: us)')
+  private availability: string = '';
+
+  @command
+  @help('Show the runtime status of a job')
+  public async runtimeStatus(): Promise<void> {
+    try {
+      const job = await Rivendell.fetchJob(this.jobId, this.availability);
+      const status = await Rivendell.fetchJobRuntimeStatus(this.jobId, this.availability);
+      if (status.status) {
+        const jsonStatus = JSON.parse(status.status);
+        console.log(`\n${chalk.cyanBright('Id')}\t\t\t${job.id}`);
+        console.log(`${chalk.cyanBright('Status')}\t\t\t${formatJobStatus(job.status)}`);
+        console.log(`${chalk.cyanBright('Triggered At')}\t\t${job.triggeredAt}`);
+
+        if (job.completedAt) {
+          console.log(`${chalk.cyanBright('Completed At')}\t\t${job.completedAt}`);
+        } else if (job.terminatedAt) {
+          console.log(`${chalk.cyanBright('Terminated At')}\t\t${job.terminatedAt}`);
+        }
+
+        console.log(`${chalk.cyanBright('Duration')}\t\t${timestampToDurationString(jobRuntime(job))}`);
+        console.log(`${chalk.cyanBright('Runtime Status\n')}${JSON.stringify(jsonStatus, null, 2)}\n`);
+      } else {
+        die(`Runtime Status not available. This is normal for jobs that are not running.`);
+      }
+
+    } catch (e) {
+      die(formatError(e));
+    }
+  }
+}

package/src/commands/jobs/Terminate.ts

@@ -0,0 +1,29 @@
+import chalk from 'chalk';
+import {command, help, namespace, option, param} from 'oo-cli';
+import {die} from '../../lib/die';
+import {formatError} from '../../lib/formatError';
+import {Rivendell} from '../../lib/Rivendell';
+
+@namespace('jobs')
+export class TerminateCommand {
+
+  @param
+  @help('ID of Job to terminate')
+  private jobId!: string;
+
+  @option('a')
+  @help('The availability zone that will be targeted (default: us)')
+  private availability: string = '';
+
+  @command
+  @help('Terminate a job')
+  public async terminate(): Promise<void> {
+    try {
+      await Rivendell.terminateJob(this.jobId, this.availability);
+    } catch (e) {
+      die(formatError(e));
+    }
+
+    console.log(chalk.green(`Terminated job with ID ${this.jobId} (${this.availability || 'us'}).`));
+  }
+}

package/src/commands/jobs/Trigger.ts

@@ -0,0 +1,41 @@
+import chalk from 'chalk';
+import {command, help, namespace, option, param} from 'oo-cli';
+import {die} from '../../lib/die';
+import {formatError} from '../../lib/formatError';
+import {Rivendell} from '../../lib/Rivendell';
+
+@namespace('jobs')
+export class TriggerCommand {
+
+  @param
+  @help('The App ID (e.g. my_app)')
+  public appId!: string;
+
+  @param
+  @help('The Job Name')
+  public jobName!: string;
+
+  @param
+  @help('The Tracker ID to trigger the job for')
+  public trackerId!: string;
+
+  @option
+  @help('Parameters to pass to the Job')
+  public parameters: string = '{}';
+
+  @option('a')
+  @help('The availability zone that will be targeted (default: us)')
+  private availability: string = '';
+
+  @command
+  @help('Trigger a job')
+  public async trigger(): Promise<void> {
+    try {
+      await Rivendell.triggerJob(this.appId, this.jobName, this.trackerId, this.parameters, this.availability);
+    } catch (e) {
+      die(formatError(e));
+    }
+
+    console.log(chalk.green(`Triggered job for ${this.appId} ${this.jobName} ${this.trackerId} (${this.availability || 'us'}).`));
+  }
+}

package/src/commands/review/List.ts

@@ -0,0 +1,76 @@
+import chalk from 'chalk';
+import {command, help, namespace, optional, param} from 'oo-cli';
+import * as semver from 'semver';
+import * as table from 'text-table';
+import {die} from '../../lib/die';
+import {styledStringLength} from '../../lib/StringUtils';
+import {Rivendell} from '../../lib/Rivendell';
+import {formatReviewStatus} from '../../lib/formatReviewStatus';
+import {formatError} from '../../lib/formatError';
+import AppVersion = Rivendell.AppVersion;
+import AppVersionSearchCriteria = Rivendell.AppVersionSearchCriteria;
+import AppVersionState = Rivendell.AppVersionState;
+import ReviewStatus = Rivendell.ReviewStatus;
+
+@namespace('review')
+export class ListCommand {
+  @param
+  @optional
+  @help('A specific App ID to filter down to (lists all apps by default)')
+  private appId!: string;
+
+  @command
+  @help('List app versions currently under review')
+  public async list(): Promise<void> {
+    try {
+      const criteria: AppVersionSearchCriteria = {
+        states: [AppVersionState.PUBLISHED],
+        reviewStatuses: [ReviewStatus.IN_REVIEW, ReviewStatus.APPROVED]
+      };
+
+      if (this.appId) {
+        criteria.appId = this.appId;
+      }
+      this.render(await Rivendell.searchAppVersions(criteria, 'us'));
+    } catch (e) {
+      die(formatError(e));
+    }
+  }
+
+  private render(appVersions: AppVersion[]) {
+      const header = ['App ID', 'Version', 'Review Status', 'Created At', 'Updated At'].map((item) => chalk.grey(item));
+      const rows = appVersions
+        .sort((lhs, rhs) => {
+          let result = lhs.id.appId.localeCompare(rhs.id.appId);
+          if (result === 0) {
+            const lhsVersion = lhs.id.version;
+            const rhsVersion = rhs.id.version;
+            if (lhsVersion !== rhsVersion) {
+              result = semver.gt(lhsVersion, rhsVersion) ? -1 : 1;
+            }
+          }
+          return result;
+        })
+        .map((appVersion) => [
+          appVersion.id.appId,
+          appVersion.id.version,
+          formatReviewStatus(
+            appVersion.reviewStatus as Rivendell.ReviewStatus
+          ),
+          appVersion.createdAt,
+          appVersion.updatedAt
+        ]);
+
+      const t = table(
+        [
+          header,
+          ...rows
+        ],
+        {
+          hsep: ' '.repeat(8),
+          stringLength: styledStringLength
+        }
+      );
+      console.log(`\n${t}\n`);
+    }
+  }

package/src/commands/review/Open.ts

@@ -0,0 +1,28 @@
+import chalk from 'chalk';
+import {command, help, namespace, param} from 'oo-cli';
+import {die} from '../../lib/die';
+import {Rivendell} from '../../lib/Rivendell';
+import {formatError} from '../../lib/formatError';
+import AppReview = Rivendell.AppReview;
+import open = require('open');
+
+@namespace('review')
+export class OpenCommand {
+  @param
+  @help('App version of the review to open')
+  private appVersion!: string;
+
+  @command
+  @help('Open a review in your browser')
+  public async open() {
+    try {
+      const appReview = await Rivendell.getReviewUrl(this.appVersion);
+      const reviewUrl = (appReview as AppReview).url;
+      console.log(chalk.gray(`Review URL: ${chalk.white(`${reviewUrl}`)}`));
+      await open(reviewUrl);
+      console.log(chalk.gray(`Opened review of app ${this.appVersion}`));
+    } catch (e) {
+      die(formatError(e));
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,15 @@
+import { Runner } from 'oo-cli';
+import * as path from 'path';
+import { showEnvironment } from './lib/EnvironmentalOutput';
+import { checkForUpdate } from './lib/checkForUpdate';
+
+function run() {
+    showEnvironment();
+
+    const manifest = require(path.join(__dirname, './oo-cli.manifest.json'));
+    checkForUpdate(manifest)
+      .then(() => new Runner(__dirname, manifest).run())
+      .catch((e) => console.log(e.message));
+}
+
+run();

package/src/lib/AppContext.ts

@@ -0,0 +1,47 @@
+import * as fs from 'fs';
+import * as jsYaml from 'js-yaml';
+import * as path from 'path';
+
+export interface AppContext {
+  appId?: string;
+  displayName?: string;
+  version?: string;
+  vendor?: string;
+  runtime?: string;
+}
+
+export function appContext(appId?: string, vendor?: string, runtime?: string): AppContext {
+  if (appId) {
+    if (appId.includes('@')) {
+      const [id, version] = appId.split('@');
+      return {
+        appId: id,
+        version,
+        vendor,
+        runtime
+      };
+    } else {
+      return {appId, vendor, runtime};
+    }
+  }
+
+  const yaml = readAppYaml();
+  if (yaml && yaml.meta) {
+    return {
+      appId: yaml.meta.app_id,
+      displayName: yaml.meta.display_name,
+      version: yaml.meta.version,
+      vendor: yaml.meta.vendor,
+      runtime: yaml.runtime
+    };
+  }
+  return {};
+}
+
+export function readAppYaml() {
+  const file = path.join(process.cwd(), 'app.yml');
+  if (fs.existsSync(file)) {
+    return jsYaml.safeLoad(fs.readFileSync(file, 'utf8'));
+  }
+  return false;
+}

package/src/lib/AppPackager.ts

@@ -0,0 +1,47 @@
+import * as AdmZip from 'adm-zip';
+import chalk from 'chalk';
+import * as child_process from 'child_process';
+import * as fs from 'fs';
+import * as glob from 'glob';
+import * as path from 'path';
+
+export class AppPackager {
+  private rootPath: string;
+
+  constructor(rootPath: string) {
+    this.rootPath = path.resolve(rootPath);
+  }
+
+  public package() {
+    console.log(chalk.gray(`Packaging files in ${this.rootPath}`));
+    const files = glob.sync('**/*', {
+      cwd: this.rootPath,
+      dot: true,
+      ignore: ['node_modules/**/*', '*.zip', '.git/**/*'],
+      nodir: true
+    }).filter(this.filterGitIgnored);
+
+    return this.createZip(this.rootPath, files);
+  }
+
+  private createZip(srcPath: string, files: string[]): Buffer {
+    const zip = new AdmZip();
+    files.forEach((file) => {
+      const filePath = path.join(srcPath, file);
+      if (fs.existsSync(filePath)) {
+        console.log(chalk.gray(`${file}`));
+        zip.addFile(file, fs.readFileSync(filePath));
+      }
+    });
+
+    return zip.toBuffer();
+  }
+
+  private filterGitIgnored = (file: string) => {
+    return child_process.spawnSync(
+      'git',
+      ['check-ignore', '-q', file],
+      {cwd: this.rootPath}
+    ).status === 1;
+  }
+}

package/src/lib/AppUpdater.ts

@@ -0,0 +1,177 @@
+import chalk from 'chalk';
+import * as child_process from 'child_process';
+import fetch from 'node-fetch';
+import {compare, major} from 'semver';
+import {getDependencyFileUrl} from './Config';
+import {styledStringLength} from './StringUtils';
+import {TerminalPassthru} from './TeminalPassthru';
+import {TerminalConfirm} from './TerminalConfirm';
+import table = require('text-table');
+
+export namespace AppUpdater {
+  /**
+   * Assumes working dir is app dir
+   */
+  export async function ensureDependencies(
+    requireUpToDate: boolean, upgradeDeps: boolean, runtime: string, ignoreDevUpdates: boolean = true
+  ) {
+    ensurePublicPackageUsage();
+
+    const response = await fetch(getDependencyFileUrl(runtime));
+    const zipModules = await response.json();
+    const projectProdDeps = AppUpdater.getPackageDependencies(true);
+
+    // build a table of updates if any dependencies are missing or outdated
+    const updates: string[][] = [];
+    const prodUpdates: string[] = [];
+    for (const module of Object.keys(zipModules)) {
+      const moduleMajorVersion = Object.keys(module).map((i) => parseInt(i, 10)).sort().reverse()[0];
+      const projectModuleVersion = projectProdDeps[module];
+      const majorVersion = (projectModuleVersion ? major(projectModuleVersion) : moduleMajorVersion).toString();
+      if (!(majorVersion in zipModules[module])) {
+        console.log(chalk.red(
+          `Major version of ${module} not supported. Please use one of supported major versions.`
+        ));
+        process.exit(1);
+      }
+      const stable = zipModules[module][majorVersion]['stable'];
+      const rc = zipModules[module][majorVersion]['rc'];
+      if (!projectModuleVersion || !isCurrent(stable, rc, projectModuleVersion)) {
+        prodUpdates.push(`${module}@${stable}`);
+        updates.push([
+          module,
+          projectModuleVersion ? chalk.yellow(projectModuleVersion) : chalk.red('missing'),
+          '=>',
+          chalk.green(stable)
+        ]);
+      }
+    }
+
+    const devDependencies: any = {
+      '@zaiusinc/app-dev-runtime': 'latest'
+    };
+
+    const projectDevDeps = AppUpdater.getPackageDependencies();
+    const devUpdates: string[] = [];
+    if (!ignoreDevUpdates) {
+      for (const name of Object.keys(devDependencies)) {
+        const currentVersion = devDependencies[name];
+        let updated = false;
+        if (projectDevDeps[name] && currentVersion === 'latest') {
+          // skip it
+          continue;
+        } else if (!projectDevDeps[name] && currentVersion === 'latest') {
+          devUpdates.push(`${name}`);
+          updated = true;
+        } else if (!projectDevDeps[name] || compare(zipModules[name], projectDevDeps[name]) !== 0) {
+          devUpdates.push(`${name}@${currentVersion}`);
+          updated = true;
+        }
+
+        if (updated) {
+          updates.push([
+            name,
+            projectDevDeps[name] ? chalk.yellow(projectDevDeps[name]) : chalk.red('missing'),
+            '=>',
+            chalk.green(devDependencies[name])
+          ]);
+        }
+      }
+    }
+    if (updates.length > 0) {
+      console.log(chalk.yellow('\nThe following dependencies are out of date:'));
+      const t = table(
+        [
+          ['Module', 'Your Version', '', 'Current Version'],
+          ...updates
+        ],
+        {
+          hsep: '    ',
+          stringLength: styledStringLength
+        }
+      );
+      console.log(`\n${t}\n`);
+      if (upgradeDeps || await TerminalConfirm.ask('Do you want to update now?')) {
+        const updateCommand = `yarn add ${prodUpdates.join(' ')}`;
+        if (prodUpdates.length > 0 && !TerminalPassthru.exec(updateCommand)) {
+          console.log(chalk.red(
+            `Failed to update dependencies. Run \`${chalk.white(updateCommand)}\` to update manually.`
+          ));
+          process.exit(1);
+        }
+        console.log('');
+
+        const updateDev = `yarn add --dev ${devUpdates.join(' ')}`;
+        if (devUpdates.length > 0 && !TerminalPassthru.exec(updateDev)) {
+          console.log(chalk.red(
+            `Failed to update dev dependencies. Run \`${chalk.white(updateDev)}\` to update manually.`
+          ));
+          process.exit(1);
+        }
+        console.log('');
+      } else {
+        console.log(chalk.yellow('OCP apps always build and run against the current versions of the SDKs.'));
+        console.log(chalk.yellow('You must update your dependencies before uploading or remote validating your app.'));
+        if (requireUpToDate) {
+          process.exit(1);
+        } else {
+          console.log('');
+        }
+      }
+    }
+  }
+
+  export function getPackageDependencies(prod: boolean = false): {[name: string]: string} {
+    try {
+      const result = child_process.spawnSync(
+        `yarn --no-progress ${prod ? '--prod ' : ''}-s list --json --pattern=@zaiusinc/`,
+        {cwd: process.cwd(), shell: true}
+      );
+
+      if (result.status === 0) {
+        const tree = JSON.parse(result.stdout.toString());
+        const output: {[name: string]: string} = {};
+        for (const item of tree.data.trees) {
+          const [name, version] = item.name.split(/(?!^)@/);
+          output[name] = version;
+        }
+        return output;
+      } else {
+        console.error(result.stderr.toString());
+      }
+    } catch (e) {
+      console.error(e);
+    }
+    console.log(chalk.red("Unable to get package dependencies. Are you in your app's working directory?"));
+    process.exit(1);
+  }
+
+  function isCurrent(stable: string, rc: string, version: string) {
+    return compare(stable, version) === 0 || (rc && compare(rc, version) === 0);
+  }
+
+  function ensurePublicPackageUsage() {
+    const result = child_process.spawnSync(
+      'yarn --no-progress --prod -s list --json --pattern="@zaius/app-sdk|@zaius/node-sdk"',
+      {cwd: process.cwd(), shell: true}
+    );
+
+    if (result.status === 0) {
+      const tree = JSON.parse(result.stdout.toString());
+      if (!tree.data.trees.length) {
+        return;
+      }
+
+      console.log(
+        chalk.red(
+          '@zaius/app-sdk & @zaius/node-sdk are no longer supported.  ' +
+          'Please update your package.json to use the @zaiusinc scope for these packages.'
+        )
+      );
+      process.exit(1);
+    }
+
+    console.log(chalk.red("Unable to get package dependencies. Are you in your app's working directory?"));
+    process.exit(1);
+  }
+}

package/src/lib/AppUploader.ts

@@ -0,0 +1,39 @@
+import * as AWS from 'aws-sdk';
+import chalk from 'chalk';
+import * as crypto from 'crypto';
+import {AppContext} from './AppContext';
+import {runtimeConfig} from './Config';
+import {Rivendell} from './Rivendell';
+
+export class AppUploader {
+  constructor(private context: AppContext, private packageData: Buffer) {
+  }
+
+  public async upload(): Promise<string> {
+    console.log(chalk.gray('Uploading package...'));
+    const {vendor, appId, version} = this.context;
+    const md5 = crypto.createHash('md5').update(this.packageData).digest('hex');
+    const bucket = runtimeConfig().uploadBucket;
+    const s3Key = `${vendor}/${appId}@${version}-${md5}.zip`;
+    const credentials = await Rivendell.uploadCredentials(vendor!, appId!, version!, md5);
+
+    AWS.config.update({
+      region: runtimeConfig().awsRegion,
+      credentials: new AWS.Credentials(
+        credentials.accessKeyId,
+        credentials.secretAccessKey,
+        credentials.sessionToken
+      )
+    });
+
+    await new AWS.S3()
+      .putObject( {
+        Bucket: bucket,
+        Key: s3Key,
+        Body: this.packageData
+      })
+      .promise();
+
+    return `s3://${bucket}/${s3Key}`;
+  }
+}

package/src/lib/Config.ts

@@ -0,0 +1,60 @@
+import * as fs from 'fs';
+import * as jsYaml from 'js-yaml';
+import * as os from 'os';
+import * as path from 'path';
+
+import * as dotenv from 'dotenv';
+
+dotenv.config({path:  path.join(os.homedir(), '.ocp/.env')});
+
+const CREDENTIAL_FILE = 'credentials.json';
+
+const environmentConfig: EnvironmentConfig = {
+  rivendell: process.env.RIVENDELL || 'https://rivendell.zaius.com',
+  awsRegion: process.env.AWS_REGION || 'us-east-1',
+  uploadBucket: process.env.UPLOAD_BUCKET || 'zaius-apps'
+};
+
+export interface EnvironmentConfig {
+  rivendell: string;
+  awsRegion: string;
+  uploadBucket: string;
+}
+
+export interface Credential {
+  apiKey?: string;
+}
+
+export interface CredentialConfig {
+  [key: string]: Partial<Credential>;
+}
+
+export function getEnv() {
+  return process.env.OCP_ENV || 'production';
+}
+
+export function getDependencyFileUrl(runtime: string) {
+  return `http://s3.amazonaws.com/zaius-public/zip/.env/${getEnv()}/${runtime}/dependencies.json`;
+}
+
+export function runtimeConfig(): EnvironmentConfig {
+  return environmentConfig;
+}
+
+let cachedCredential: Credential;
+export function getActiveCredential(): Credential {
+  if (cachedCredential) {
+    return cachedCredential;
+  }
+  const file = path.join(os.homedir(), `.ocp/${CREDENTIAL_FILE}`);
+  if (fs.existsSync(file)) {
+    try {
+      const creds: CredentialConfig = jsYaml.safeLoad(fs.readFileSync(file, 'utf8')) || {};
+      cachedCredential = creds || {};
+    } catch (e) {
+      console.error(`Unable to parse credential file.`);
+      process.exit(1);
+    }
+  }
+  return cachedCredential || {};
+}

package/src/lib/EnvironmentalOutput.ts

@@ -0,0 +1,18 @@
+import chalk from 'chalk';
+import { existsSync } from 'fs';
+import { join } from 'path';
+import {getEnv} from './Config';
+
+const envColors = {
+  staging: chalk.yellow,
+  production: chalk.red,
+  other: chalk.gray
+};
+
+export function showEnvironment() {
+  if (existsSync(join(__dirname, '../commands/env'))) {
+    const env = getEnv();
+    const color = envColors[env as keyof typeof envColors] || envColors['other'];
+    console.log(chalk.gray(`Active environment: ${color(env)}`));
+  }
+}