@optimizely/ocp-cli 1.0.0-beta.2

package/src/lib/TerminalSpinner.ts

@@ -0,0 +1,76 @@
+import chalk from 'chalk';
+import * as cliSpinners from 'cli-spinners';
+import {Spinner} from 'cli-spinners';
+import {stringWidth, terminal, truncateString} from 'terminal-kit';
+
+const SPINNERS = [
+  cliSpinners.dots,
+  cliSpinners.dots2,
+  cliSpinners.dots3,
+  cliSpinners.dots4,
+  cliSpinners.dots5,
+  cliSpinners.dots6,
+  cliSpinners.dots7,
+  cliSpinners.dots8,
+  cliSpinners.dots10,
+  cliSpinners.dots11
+];
+
+export class TerminalSpinner {
+  private text = '';
+  private counter = 0;
+  private interval!: NodeJS.Timeout;
+  private spinner: Spinner;
+
+  constructor(private color: string = 'yellow', spinner?: Spinner) {
+    if (spinner) {
+      this.spinner = spinner;
+    } else {
+      this.spinner = SPINNERS[Math.floor(Math.random() * SPINNERS.length)];
+    }
+  }
+
+  public start(text: string) {
+    this.text = text;
+    terminal.on('resize', this.onResize).grabInput(true);
+    this.interval = setInterval(() => {
+      this.counter++;
+      terminal.saveCursor();
+      this.renderSpinner();
+      terminal.restoreCursor();
+    }, this.spinner.interval);
+    terminal.hideCursor();
+    this.render();
+    return this;
+  }
+
+  public update(text: string, spinnerColor = this.color) {
+    this.text = text;
+    this.color = spinnerColor;
+    this.render();
+  }
+
+  public stop() {
+    terminal.off('resize', this.onResize).grabInput(false);
+    clearInterval(this.interval);
+    terminal.hideCursor(false).eraseDisplayBelow();
+  }
+
+  private onResize = () => {
+    this.render();
+  }
+
+  private renderSpinner() {
+    terminal(` ${chalk.keyword(this.color)(this.spinner.frames[this.counter % this.spinner.frames.length])} `);
+  }
+
+  private render() {
+    terminal.eraseDisplayBelow().saveCursor();
+    let str = this.text;
+    if (stringWidth(this.text) + 3 > terminal.width) {
+      str = truncateString(this.text, terminal.width - 4) + '…';
+    }
+    this.renderSpinner();
+    terminal(str).restoreCursor();
+  }
+}

package/src/lib/build.ts

@@ -0,0 +1,36 @@
+import {Rivendell} from './Rivendell';
+import BuildState = Rivendell.BuildState;
+import BuildStatus = Rivendell.BuildStatus;
+
+export type ProgressCallback = (state: BuildState) => any;
+export type ErrorList = string[];
+
+export async function watchBuild(
+  id: number,
+  progressCallback: ProgressCallback,
+  pollInterval: number = 2000
+): Promise<ErrorList> {
+  return new Promise((resolve, reject) => {
+    const interval = setInterval(() => {
+      Rivendell.fetchBuild(id)
+        .then((build) => {
+          const state = build.state as BuildState;
+          if (state === BuildState.FINISHED) {
+            clearInterval(interval);
+            if (build.status as BuildStatus === BuildStatus.SUCCESS) {
+              resolve();
+            } else {
+              const errors = build.errors || [];
+              resolve(errors);
+            }
+          } else {
+            progressCallback(state);
+          }
+        })
+        .catch((error) => {
+          clearInterval(interval);
+          reject(error);
+        });
+    }, pollInterval);
+  });
+}

package/src/lib/checkForUpdate.ts

@@ -0,0 +1,63 @@
+import chalk from 'chalk';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import * as semver from 'semver';
+import { ManifestDefinition } from 'oo-cli/dist/types/manifest';
+import { TerminalOutput } from './TerminalOutput';
+import { TerminalConfirm } from './TerminalConfirm';
+import { TerminalPassthru } from './TeminalPassthru';
+
+interface LastCheck {
+  date: Date;
+  upToDate: boolean;
+}
+
+const LAST_VERSION_CHECK_FILE = '.lastcheck';
+const _24hours = 24 * 60 * 60 * 1000;
+
+export async function checkForUpdate(manifest: ManifestDefinition): Promise<void> {
+  const lastCheck = getLastCheck();
+  if (lastCheck) {
+    const now = new Date();
+    if (now.getTime() - lastCheck.date.getTime() < _24hours && lastCheck.upToDate) {
+      return;
+    }
+  }
+
+  try {
+    let upToDate = true;
+    const latest = await fetchLatest();
+    if (latest) {
+      const installed = manifest.package?.version!;
+      if (semver.gt(latest, installed)) {
+        upToDate = false;
+        if (await TerminalConfirm.ask(chalk.yellow('A new version of OCP CLI is available. Update now?'))) {
+          TerminalPassthru.exec('yarn global upgrade @optimizely/ocp-cli --latest');
+        }
+      }
+    }
+    setLastCheck(upToDate);
+  } catch (e) {
+    return;
+  }
+}
+
+async function fetchLatest() {
+  return TerminalOutput.exec('yarn info -s @optimizely/ocp-cli dist-tags.latest').stdout.trim();
+}
+
+function getLastCheck(): LastCheck | undefined {
+  const file = path.join(os.homedir(), `.ocp/${LAST_VERSION_CHECK_FILE}`);
+  if (fs.existsSync(file)) {
+    const stat = fs.statSync(file);
+    const upToDate = fs.readFileSync(file, {encoding: 'utf-8'}) === 'true';
+    return {date: stat.mtime, upToDate};
+  }
+  return undefined;
+}
+
+function setLastCheck(upToDate: boolean) {
+  const file = path.join(os.homedir(), `.ocp/${LAST_VERSION_CHECK_FILE}`);
+  fs.writeFileSync(file, upToDate.toString());
+}

package/src/lib/dev/app.ts

@@ -0,0 +1,58 @@
+import {ChildProcess, spawn} from 'child_process';
+import fetch from 'node-fetch';
+import {DevLogger} from './logger';
+import chalk from 'chalk';
+
+const logger = new DevLogger();
+
+export class App {
+  private baseUrl?: string;
+
+  public async install() {
+    const response = await fetch(`${this.baseUrl}/lifecycle/install`, {method: 'post'});
+    const json = await response.json();
+    if (!json.success) {
+      throw new Error('App installation failed');
+    }
+  }
+
+  public async fetchFunctionEndpoints(): Promise<string[]> {
+    const response = await fetch(`${this.baseUrl}/functions`);
+    const json = await response.json();
+    return Object.values(json);
+  }
+
+  public start(): Promise<ChildProcess> {
+    return new Promise((resolve, reject) => {
+      const app = spawn('yarn', ['run', 'start-app'], {shell: true});
+      process.on('exit', () => app.kill());
+
+      let started = false;
+      app.stdout.on('data', (data) => {
+        data.toString().trim().split('\n').forEach((str: string) => {
+          if (!started && str.startsWith('App listening on port')) {
+            started = true;
+            this.baseUrl = `http://localhost:${str.replace('App listening on port ', '')}`;
+            console.log(chalk.gray('App started successfully'));
+            console.log(chalk.gray(`App logs will be piped to ${logger.logFile}`));
+            resolve(app);
+          }
+          logger.log(str);
+        });
+      });
+
+      app.stderr.on('data', (data) => {
+        data.toString().split('\n').forEach(logger.log);
+      });
+
+      app.on('error', (e) => {
+        console.error(e);
+        reject('App failed to start');
+      });
+
+      app.on('close', (code) => {
+        console.log(`app exited with code ${code}`);
+      });
+    });
+  }
+}

package/src/lib/dev/index.ts

@@ -0,0 +1 @@
+export * from './app';

package/src/lib/dev/logger.ts

@@ -0,0 +1,77 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import {Readable, Writable} from 'stream';
+import chalk from 'chalk';
+
+type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'NEVER';
+
+export interface LogEntry {
+  level: LogLevel;
+  message: string;
+  stacktrace?: string;
+}
+
+export class DevLogger {
+  public readonly logFile: string;
+  private fileStream: fs.WriteStream;
+  private logs: Readable;
+
+  constructor() {
+    const logsDir = path.resolve(fs.realpathSync(process.cwd()), 'logs/');
+    if (!fs.existsSync(logsDir)) {
+      fs.mkdirSync(logsDir);
+    }
+    this.logFile = path.resolve(fs.realpathSync(process.cwd()), 'logs/dev.log');
+
+    this.logs = new Readable();
+    this.logs._read = () => {/* no op */};
+    this.fileStream = fs.createWriteStream(this.logFile, {encoding: 'utf8', flags: 'a+'});
+
+    const consoleWriter = new Writable({
+      write: (chunk, _encoding, next) => {
+        process.stdout.write(this.decorateLog(chunk.toString()));
+        next();
+      }
+    });
+    this.logs.pipe(consoleWriter);
+
+    this.logs.pipe(this.fileStream);
+  }
+
+  public log = (line: string) => {
+    let json: any;
+
+    try {
+      json = JSON.parse(line);
+    } catch (e) {
+      console.log(line);
+      return;
+    }
+
+    const level = json.level;
+    const message = json.message;
+    const stacktrace = json.stacktrace;
+
+    if (level === 'NEVER') {
+      return;
+    }
+
+    this.logs.push(`[${level}] ${message}${message.endsWith('\n') ? '' : '\n'}`);
+
+    if (stacktrace !== undefined) {
+      this.logs.push(`${stacktrace}${stacktrace.endsWith('\n') ? '' : '\n'}`);
+    }
+  }
+
+  private decorateLog(message: string): string {
+    if (message.startsWith('[warn]')) {
+      return message.replace('[warn]', chalk.yellow('[warn]'));
+    }
+
+    if (message.startsWith('[error]')) {
+      return message.replace('[error]', chalk.red('[error]'));
+    }
+
+    return message;
+  }
+}

package/src/lib/die.ts

@@ -0,0 +1,10 @@
+import chalk from 'chalk';
+
+/**
+ * Logs an error message (in red) then exits with code 1.
+ * @param message the error message
+ */
+export function die(message: string): void {
+  console.error(chalk.red(message));
+  process.exit(1);
+}

package/src/lib/directoryExists.ts

@@ -0,0 +1,5 @@
+import * as fs from 'fs';
+
+export function directoryExists(path: string): boolean {
+  return  fs.existsSync(path) && fs.lstatSync(path).isDirectory();
+}

package/src/lib/formatBuildState.ts

@@ -0,0 +1,20 @@
+import chalk from 'chalk';
+import {Rivendell} from './Rivendell';
+
+export function formatBuildState(state: Rivendell.BuildState): string {
+  switch (state) {
+    case Rivendell.BuildState.NEW:
+      return chalk.yellow('NEW');
+    case Rivendell.BuildState.QUEUED:
+      return chalk.yellow('QUEUED');
+    case Rivendell.BuildState.RUNNING:
+      return chalk.yellow('BUILDING');
+    case Rivendell.BuildState.FINISHED:
+      return chalk.yellow('FINISHED');
+
+    default: {
+      console.error(chalk.red(`Unrecognized BuildState ${state} `));
+      return chalk.red('UNKNOWN');
+    }
+  }
+}

package/src/lib/formatError.ts

@@ -0,0 +1,39 @@
+import {RivendellApi} from './RivendellApi';
+import {MoriaApi} from './MoriaApi';
+import RivendellApiError = RivendellApi.ApiError;
+import MoriaApiError = MoriaApi.ApiError;
+
+export function formatError(error: Error) {
+  if (error instanceof RivendellApiError) {
+    if (error.response?.status === 403) {
+      return 'Could not authenticate with the credential configured in ~/.ocp/credentials.json.';
+    } else {
+      return sanitize(errorMessageFromJsonResponse(error));
+    }
+  } else if (error instanceof MoriaApiError) {
+    return sanitize(errorMessageFromJsonResponse(error));
+  } else {
+    return sanitize(error.message);
+  }
+}
+
+function errorMessageFromJsonResponse(error: MoriaApiError | RivendellApiError) {
+  const contentType = error.response?.headers?.get('content-type');
+  if (contentType?.includes('application/json') && error.responseText) {
+    const response = JSON.parse(error.responseText);
+    // protocol is that detail will have either a `message` or an `invalids` child
+    if (response.detail) {
+      return response.detail.message
+        ? response.detail.message
+        : response.detail.invalids
+          .map((violation: { [key: string]: string }) => `* ${violation.field} ${violation.reason}`)
+          .join('\n');
+    }
+  }
+
+  return error.message;
+}
+
+function sanitize(body: any) {
+  return body.replace('FAILED_PRECONDITION: ', '').replace('INTERNAL: ', '');
+}

package/src/lib/formatJobStatus.ts

@@ -0,0 +1,24 @@
+import chalk from 'chalk';
+import {Rivendell} from './Rivendell';
+import JobStatus = Rivendell.JobStatus;
+
+export function formatJobStatus(status: JobStatus): string {
+  switch (status) {
+    case JobStatus.PENDING:
+      return chalk.gray('PENDING');
+    case JobStatus.SCHEDULED:
+      return chalk.gray('SCHEDULED');
+    case JobStatus.RUNNING:
+      return chalk.yellow('RUNNING');
+    case JobStatus.COMPLETE:
+      return chalk.green('COMPLETE');
+    case JobStatus.TERMINATED:
+      return chalk.green('TERMINATED');
+    case JobStatus.ERROR:
+      return chalk.red('ERROR');
+    default: {
+      console.error(chalk.red(`Unrecognized JobStatus ${status}`));
+      return chalk.red('UNKNOWN');
+    }
+  }
+}

package/src/lib/formatReviewStatus.ts

@@ -0,0 +1,27 @@
+import chalk from 'chalk';
+import {Rivendell} from './Rivendell';
+import AppVersionState = Rivendell.AppVersionState;
+import ReviewStatus = Rivendell.ReviewStatus;
+
+export function formatReviewStatus(
+  reviewStatus: ReviewStatus,
+  state: AppVersionState = AppVersionState.PUBLISHED
+): string {
+  if (state !== AppVersionState.PUBLISHED) {
+    return '';
+  }
+  switch (reviewStatus) {
+    case ReviewStatus.NOT_STARTED:
+      return chalk.yellow('NOT_STARTED');
+    case ReviewStatus.IN_REVIEW:
+      return chalk.hex('#EE7600')('IN_REVIEW');
+    case ReviewStatus.APPROVED:
+      return chalk.green('APPROVED');
+    case ReviewStatus.NOT_REQUIRED:
+      return chalk.green('NOT_REQUIRED');
+    default: {
+      console.error(chalk.red(`Unrecognized ReviewStatus ${reviewStatus} `));
+      return chalk.red('UNKNOWN');
+    }
+  }
+}

package/src/lib/formatTimstamp.ts

@@ -0,0 +1,21 @@
+
+export function timestampToDurationString(ms: number | undefined) {
+  if (!ms || ms <= 0) {
+    return '-';
+  }
+  const duration = ms / 1000;
+  const hours = Math.floor(duration / 3600);
+  const minutes = Math.floor((duration - (hours * 3600)) / 60);
+  const seconds = Math.trunc(duration - (hours * 3600) - (minutes * 60));
+  const out = [];
+  if (hours > 0) {
+    out.push(`${hours}h`);
+  }
+  if (minutes > 0) {
+    out.push(`${minutes}m`);
+  }
+  if (seconds > 0) {
+    out.push(`${seconds}s`);
+  }
+  return out.join(' ');
+}

package/src/lib/formatVersionState.ts

@@ -0,0 +1,31 @@
+import chalk from 'chalk';
+import {Rivendell} from './Rivendell';
+
+export function formatVersionState(state: Rivendell.AppVersionState): string {
+  switch (state) {
+    case Rivendell.AppVersionState.NEW:
+      return chalk.yellow('NEW');
+    case Rivendell.AppVersionState.PUBLISHED:
+      return chalk.yellow('BUILT');
+    case Rivendell.AppVersionState.BUILD_FAILED:
+      return chalk.red('BUILD_FAILED');
+    case Rivendell.AppVersionState.STARTING:
+      return chalk.yellow('PUBLISHING');
+    case Rivendell.AppVersionState.START_FAILED:
+      return chalk.red('PUBLISHING_FAILED');
+    case Rivendell.AppVersionState.RUNNING:
+      return chalk.green('PUBLISHED');
+    case Rivendell.AppVersionState.STOPPING:
+      return chalk.yellow('UNPUBLISHING');
+    case Rivendell.AppVersionState.STOP_FAILED:
+      return chalk.red('UNPUBLISHING_FAILED');
+    case Rivendell.AppVersionState.STOPPED:
+      return chalk.red('UNPUBLISHED');
+    case Rivendell.AppVersionState.UPGRADING_RUNTIME:
+      return chalk.yellow('UPGRADING_RUNTIME');
+    default: {
+      console.error(chalk.red(`Unrecognized AppVersionState ${state} `));
+      return chalk.red('UNKNOWN');
+    }
+  }
+}

package/src/lib/gatherAppEnv.ts

@@ -0,0 +1,75 @@
+import {DotenvParseOutput, parse} from 'dotenv';
+import * as fs from 'fs';
+import {readAppYaml} from './AppContext';
+import {getEnv} from './Config';
+import {die} from './die';
+
+export function gatherAppEnv(shard: string) {
+  return buildAppEnv(gatherEnvFiles(shard));
+}
+
+export function validateAppEnvs(shards: string[]) {
+  const manifest = readAppYaml();
+  const expected = (manifest && manifest.environment) || [];
+  if (getEnv() === 'production') {
+    validateEnvFiles(shards, manifest);
+  }
+  validateEnvContents(shards, expected);
+}
+
+function validateEnvFiles(shards: string[], manifest: any) {
+  const errors: string[] = [];
+  if (manifest.meta.availability && manifest.meta.availability.includes('all')) {
+    if (shards.map((s) => `.env.${s}`).some((f) => fs.existsSync(f))) {
+      errors.push("Shard specific .env files are not allowed for 'all' availability");
+    }
+  }
+  if (errors.length) {
+    die(errors.map((s) => `* ${s}`).join('\n'));
+  }
+}
+
+function validateEnvContents(shards: string[], expected: string[]) {
+  const errors: string[] = [];
+  for (const shard of shards) {
+    const files = gatherEnvFiles(shard);
+    errors.push(...validateAppEnv(buildAppEnv(files), expected, files));
+  }
+
+  if (errors.length) {
+    die(errors.map((s) => `* ${s}`).join('\n'));
+  }
+}
+
+function validateAppEnv(appEnv: DotenvParseOutput, expected: string[], envFiles: string[]) {
+  const errors: string[] = [];
+  Object.keys(appEnv).forEach((name) => {
+    if (!expected.includes(name)) {
+      errors.push(`${envFiles}: One of the env files contains a variable not listed in the app.yml: ${name}`);
+    }
+  });
+
+  expected.forEach((name) => {
+    if (!appEnv[name]) {
+      errors.push(`${envFiles}: None of the env files provide a value for the required variable: ${name}`);
+    }
+  });
+  return errors;
+}
+
+function gatherEnvFiles(shard: string) {
+  const files = ['.env', `.env.${getEnv()}`];
+  if (getEnv() === 'production') {
+    files.push(`.env.${shard}`);
+  }
+
+  return files;
+}
+
+function buildAppEnv(files: string[]) {
+  const appEnv: DotenvParseOutput = {};
+  files.filter((f) => fs.existsSync(f)).forEach((f) => {
+    Object.assign(appEnv, parse(fs.readFileSync(f)));
+  });
+  return appEnv;
+}

package/src/lib/handleInterrupt.ts

@@ -0,0 +1,13 @@
+import {terminal} from 'terminal-kit';
+
+export function handleInterrupt() {
+  terminal.on('key', (name: string) => {
+    if (name === 'CTRL_C') {
+      terminal.grabInput(false);
+      terminal.hideCursor(false);
+      console.log('^C');
+      terminal.eraseDisplayBelow();
+      process.exit(1);
+    }
+  });
+}

package/src/lib/jobRuntime.ts

@@ -0,0 +1,12 @@
+import {Rivendell} from './Rivendell';
+import Job = Rivendell.Job;
+
+export function jobRuntime(job: Job): number {
+  if (job.completedAt) {
+    return (new Date(job.completedAt).getTime() - new Date(job.triggeredAt).getTime());
+  } else if (job.terminatedAt) {
+    return (new Date(job.terminatedAt).getTime() - new Date(job.triggeredAt).getTime());
+  } else {
+    return (new Date().getTime() - new Date(job.triggeredAt).getTime());
+  }
+}

package/src/lib/parseDate.ts

@@ -0,0 +1,21 @@
+import {default as parseDuration} from 'parse-duration';
+import { fromUnixTime, parseISO } from 'date-fns';
+
+const EPOCH_TIMESTAMP_REGEX = /^\d+$/;
+
+export function parseDate(value: string): Date {
+  const iso = parseISO(value);
+  if (iso.getTime()) {
+    return iso;
+  } else if (EPOCH_TIMESTAMP_REGEX.test(value)) {
+    return fromUnixTime(parseInt(value, 10));
+  } else {
+    return new Date(Date.now() - parseDuration(value)!);
+  }
+}
+
+export function isValidDateOrEpochOrDurationString(value: string): boolean  {
+  return EPOCH_TIMESTAMP_REGEX.test(value) ||
+    parseISO(value).getTime() ||
+    parseDuration(value) ? true : false;
+}