@optimizely/ocp-cli 1.0.0-beta.2

package/src/lib/RivendellApi.ts

@@ -0,0 +1,99 @@
+import fetch, {RequestInit, Response} from 'node-fetch';
+import * as path from 'path';
+import {getActiveCredential, runtimeConfig} from './Config';
+import {die} from './die';
+
+export type Method = 'POST' | 'PUT' | 'PATCH' | 'GET' | 'DELETE';
+
+/**
+ * Low level http handler for interacting with the Rivendell api.
+ */
+export namespace RivendellApi {
+  interface ApiResponse<T = any> {
+    response: Response;
+    body: T;
+  }
+
+  export class ApiError extends Error {
+    constructor(message: string, public responseText: string, public response?: Response) {
+      super(message);
+    }
+  }
+
+  export async function get<T>(uri: string): Promise<ApiResponse<T>> {
+    return request('GET', uri);
+  }
+
+  export async function post<T>(uri: string, body: any): Promise<ApiResponse<T>> {
+    return request('POST', uri, body);
+  }
+
+  export async function put<T>(uri: string, body: any): Promise<ApiResponse<T>> {
+    return request('PUT', uri, body);
+  }
+
+  export async function delete_<T>(uri: string): Promise<ApiResponse<T>> {
+    return request('DELETE', uri);
+  }
+
+  export async function request<T>(method: Method, uri: string, body?: any): Promise<ApiResponse<T>> {
+    const url = `${runtimeConfig().rivendell}/${uri}`;
+    const requestPayload: RequestInit = { method };
+
+    requestPayload.headers = {
+      'x-api-key': loadApiKey(),
+      'x-cli-version': require(path.join(__dirname, '../oo-cli.manifest.json'))['package']['version']
+    };
+    if (body && method !== 'GET') {
+      // @ts-ignore
+      requestPayload.headers['content-type'] = 'application/json';
+      requestPayload.body = JSON.stringify(body);
+    }
+
+    const response = await fetch(url, requestPayload);
+    const responseText = await response.text();
+
+    if (response.status < 200 || response.status >= 300) {
+      const errorMsg = `Received a ${response.status} from OCP: ${getErrorMessage(response.status)}`;
+      throw new ApiError(errorMsg, responseText, response);
+    }
+
+    return {
+      response,
+      body: responseText ? JSON.parse(responseText) : ''
+    };
+  }
+
+  function loadApiKey(): string {
+    const apiKey = getActiveCredential().apiKey;
+    if (apiKey == null) {
+      die(
+        'Your API key is not configured in ~/.ocp/credentials.json. ' +
+        'Please assign your API key to the property apiKey in the config file.'
+      );
+    }
+
+    return apiKey!;
+  }
+
+  function getErrorMessage(code: number): string {
+    switch (code) {
+      case 400:
+        return 'Bad request.';
+      case 403:
+        return 'Access denied.';
+      case 404:
+        return 'Not found.';
+      case 500:
+        return 'Internal service error.';
+      case 502:
+        return 'Bad gateway';
+      case 503:
+        return 'Service unavailable. Please try again.';
+      case 504:
+        return 'Request timed out. Please try again.';
+      default:
+        return 'Unhandled error.';
+    }
+  }
+}

package/src/lib/Shards.ts

@@ -0,0 +1,37 @@
+import { AppManifest } from '@zaiusinc/app-sdk';
+import { prerelease } from 'semver';
+import { readAppYaml } from './AppContext';
+import { getEnv } from './Config';
+import { Rivendell } from './Rivendell';
+
+export async function applicableShards(availability = '', fromManifest?: AppManifest): Promise<string[]> {
+  if (getEnv() === 'staging') {
+    return ['us'];
+  }
+
+  const manifest = fromManifest || readAppYaml();
+  const pre = prerelease(manifest.meta.version);
+
+  if (pre && pre[0] === 'dev') {
+    return ['us'];
+  }
+
+  if (availability) {
+    return [availability];
+  }
+
+  return resolveShards(manifest);
+}
+
+export async function targetShards(): Promise<string[]> {
+  return await resolveShards(readAppYaml());
+}
+
+async function resolveShards(manifest: AppManifest) {
+  let shards = manifest.meta.availability || ['us'];
+  if (shards.includes('all')) {
+    shards = (await Rivendell.shards()).map((s) => s.id);
+  }
+
+  return ['us'].concat(shards.filter((s) => s !== 'us').sort());
+}

package/src/lib/StringUtils.ts

@@ -0,0 +1,4 @@
+// Copied from https://github.com/zeit/now-cli/blob/45097563f09b412ccbbb5b07838b587ea669a531/src/util/strlen.ts
+export function styledStringLength(str: string): number {
+    return str.replace(/\u001b[^m]*m/g, '').length;
+}

package/src/lib/TeminalPassthru.ts

@@ -0,0 +1,7 @@
+import * as child_process from 'child_process';
+
+export namespace TerminalPassthru {
+  export function exec(command: string) {
+    return child_process.spawnSync(command, {cwd: process.cwd(), shell: true, stdio: 'inherit'});
+  }
+}

package/src/lib/TerminalConfirm.ts

@@ -0,0 +1,27 @@
+import {TerminalInput} from './TerminalInput';
+
+const yes = ['y', 'yes'];
+const no = ['n', 'no'];
+
+const validate = (value: string) => (
+  yes.includes(value.toLowerCase()) || no.includes(value.toLowerCase())
+);
+
+const getHint = (value: string) => {
+  if (value && !validate(value)) {
+    return 'Enter yes or no (y/n)';
+  }
+  return '';
+};
+
+export namespace TerminalConfirm {
+  export async function ask(question: string, hint: string = '') {
+    const result = await TerminalInput.ask(question, {
+      getHint: (value) => getHint(value) || hint,
+      validate,
+      clearOnInvalidInput: true
+    });
+
+    return yes.includes(result.toLowerCase());
+  }
+}

package/src/lib/TerminalInput.ts

@@ -0,0 +1,236 @@
+import chalk from 'chalk';
+import {stringWidth, terminal} from 'terminal-kit';
+
+interface Coordinates {
+  x: number;
+  y: number;
+}
+
+export interface InputOptions {
+  getHint?: (value: string) => string;
+  validate?: (value: string) => boolean;
+  clearAfter?: boolean;
+  defaultValue?: string;
+  clearOnInvalidInput?: boolean;
+}
+
+export class TerminalInput {
+  public static ask(question: string, options?: InputOptions): Promise<string> {
+    return new Promise(async (resolve, _reject) => {
+      // tslint:disable-next-line:no-unused-expression
+      await new TerminalInput(question, options || {}, (value) => resolve(value)).start();
+    });
+  }
+
+  private input = '';
+  private y = 0;
+  private inputCoords!: Coordinates;
+  private cursorOffset = 0;
+  private hint = '';
+  private hintY = 0;
+  private isValid = true;
+
+  constructor(
+    private question: string,
+    private options: InputOptions,
+    private onEnter: (value: string) => void,
+  ) {
+    this.hint = this.getHint();
+    if (this.options.validate) {
+      this.isValid = this.options.validate(options.defaultValue || '');
+    }
+  }
+
+  private async start() {
+    terminal.grabInput(true);
+    terminal.on('key', this.onKeyPress);
+    terminal.on('resize', this.onResize);
+    this.y = (await (terminal as any).getCursorLocation()).y;
+    await this.render();
+    this.placeCursor();
+  }
+
+  private async end() {
+    terminal.grabInput(false);
+    terminal.off('key', this.onKeyPress);
+    terminal.off('resize', this.onResize);
+    if (this.options.clearAfter === false) {
+      // use render to place cursor at end
+      await this.render();
+      terminal('\n').eraseDisplayBelow();
+    } else {
+      terminal.moveTo(1, this.y).eraseDisplayBelow();
+    }
+  }
+
+  private get defaultHint() {
+    if (!this.input && this.options.defaultValue) {
+      return `[Enter] to accept ${this.options.defaultValue}`;
+    }
+    return '';
+  }
+
+  private getHint() {
+    if (this.options.getHint) {
+      return this.options.getHint(this.input || this.options.defaultValue || '') || this.defaultHint;
+    }
+    return this.defaultHint;
+  }
+
+  private async updateInput(input: string, resetHint: boolean = true) {
+    if (this.input !== input) {
+      this.input = input;
+      let needsRerender = false;
+      if (resetHint) {
+        const hint = this.getHint();
+        if (hint !== this.hint) {
+          this.hint = hint;
+          needsRerender = true;
+        }
+      }
+      if (this.options.validate) {
+        const valid = this.options.validate(input || this.options.defaultValue || '');
+        if (valid !== this.isValid) {
+          needsRerender = true;
+          this.isValid = valid;
+        }
+      }
+
+      if (needsRerender) {
+        await this.render();
+      } else {
+        await this.renderPartial(this.cursorOffset);
+      }
+    }
+  }
+
+  private spliceInput(index: number, del: number, insert: string = '') {
+    return this.input.slice(0, index) + insert + this.input.slice(index + del);
+  }
+
+  private onKeyPress = async (key: string, _matches: string[], data: {isCharacter: boolean}) => {
+    if (data.isCharacter) {
+      await this.updateInput(this.spliceInput(this.cursorOffset, 0, key));
+      this.cursorOffset += stringWidth(key);
+      this.placeCursor();
+    } else {
+      switch (key) {
+        case 'LEFT':
+          this.cursorOffset = Math.max(0, this.cursorOffset - 1);
+          this.placeCursor();
+          break;
+
+        case 'RIGHT':
+          this.cursorOffset = Math.min(stringWidth(this.input), this.cursorOffset + 1);
+          this.placeCursor();
+          break;
+
+        case 'HOME':
+          this.cursorOffset = 0;
+          this.placeCursor();
+          break;
+
+        case 'END':
+          this.cursorOffset = stringWidth(this.input);
+          this.placeCursor();
+          break;
+
+        case 'DELETE':
+          await this.updateInput(this.spliceInput(this.cursorOffset, 1));
+          this.placeCursor();
+          break;
+
+        case 'BACKSPACE':
+          if (this.cursorOffset > 0) {
+            this.cursorOffset--;
+            await this.updateInput(this.spliceInput(this.cursorOffset, 1));
+            this.placeCursor();
+          }
+          break;
+
+        case 'ENTER':
+        case 'KP_ENTER':
+          if (this.isValid) {
+            await this.end();
+            this.onEnter(this.input || this.options.defaultValue || '');
+          } else if (this.options.clearOnInvalidInput) {
+            this.cursorOffset = 0;
+            await this.updateInput('', false);
+            this.placeCursor();
+          }
+          break;
+
+        case 'CTRL_D':
+        case 'CTRL_C':
+          terminal('\Bye...');
+          terminal.processExit(1);
+      }
+    }
+  }
+
+  private onResize = async () => {
+    terminal.moveTo(1, this.y).eraseDisplayBelow();
+    await this.render();
+    this.placeCursor();
+  }
+
+  private async render() {
+    const hint = '  ' + this.hint;
+    const question = this.question + ' ';
+
+    // compute where we should be after rendering
+    this.inputCoords = {
+      x: 1 + stringWidth(question) % terminal.width,
+      y: this.y + Math.floor((stringWidth(question) - 1) / terminal.width)
+    };
+    this.hintY = this.y
+      + Math.floor((stringWidth(question) + stringWidth(this.input) - 1) / terminal.width)
+      + 1;
+    let expectedY = this.hintY + Math.floor((stringWidth(hint) - 1) / terminal.width);
+    const inputEndX = (this.inputCoords.x - 1 + stringWidth(this.input)) % terminal.width;
+
+    // offset our start position to account for scrolling due to long input or hint
+    while (expectedY > terminal.height) {
+      terminal.moveTo(terminal.width, terminal.height);
+      terminal('\n');
+      expectedY--;
+      this.hintY--;
+      this.inputCoords.y--;
+      this.y--;
+    }
+
+    // render input and hint
+    terminal.moveTo(terminal.width, this.y - 1).defaultColor('\n');
+    terminal(question + (this.isValid ? this.input : chalk.red(this.input)));
+    if (inputEndX !== 0) {
+      terminal.eraseLineAfter();
+    }
+    terminal('\n').gray(hint).eraseDisplayBelow();
+  }
+
+  private async renderPartial(offset: number) {
+    const endY = this.inputCoords.y
+      + Math.floor((stringWidth(this.input) + this.inputCoords.x - 1) / terminal.width)
+      + 1;
+    const endX = (this.inputCoords.x - 1 + stringWidth(this.input)) % terminal.width;
+    if (endY >= this.hintY) {
+      await this.render();
+    } else {
+      const content = this.input.slice(offset);
+      terminal((this.isValid ? content : chalk.red(content)));
+      if (endX !== 0) {
+        terminal.eraseLineAfter();
+      }
+    }
+  }
+
+  private placeCursor() {
+    if (this.inputCoords.x + this.cursorOffset < terminal.width) {
+      terminal.moveTo(this.inputCoords.x + this.cursorOffset, this.inputCoords.y);
+    } else {
+      const x = 1 + (this.inputCoords.x - 1 + this.cursorOffset) % terminal.width;
+      const y = this.inputCoords.y + Math.floor((this.inputCoords.x - 1 + this.cursorOffset) / terminal.width);
+      terminal.moveTo(x, y);
+    }
+  }
+}

package/src/lib/TerminalMenu.ts

@@ -0,0 +1,221 @@
+import chalk from 'chalk';
+import {stringWidth, terminal, truncateString} from 'terminal-kit';
+
+export interface MenuOptions {
+  layout?: 'grid' | 'row';
+  clearAfter?: boolean;
+}
+
+export interface MenuChoice {
+  text: string;
+  id?: string | number;
+}
+
+interface Layout {
+  x: number;
+  y: number;
+  index: number;
+  text: string;
+}
+
+export class TerminalMenu {
+  public static ask(question: string, choices: MenuChoice[] | string[], options?: MenuOptions): Promise<MenuChoice> {
+    return new Promise(async (resolve, _reject) => {
+      await new TerminalMenu(question, choices, options || {}, (sel) => resolve(sel)).start();
+    });
+  }
+
+  private choices: MenuChoice[];
+  private y!: number;
+  private layout!: Layout[][]; // represented as a grid[x][y]
+  private questionHeight: number = 1;
+  private selected: number = 0;
+  private scrollOffset: number = 0;
+
+  constructor(
+    private question: string,
+    choices: MenuChoice[] | string[],
+    private options: MenuOptions,
+    private onSelect: (selection: MenuChoice) => void
+  ) {
+    if (choices.length > 0 && typeof choices[0] === 'string') {
+      this.choices = (choices as string[]).map((text, id) => ({text, id}));
+    } else {
+      this.choices = choices as MenuChoice[];
+    }
+  }
+
+  private async start() {
+    terminal.grabInput(true);
+    terminal.on('key', this.onKeyPress);
+    terminal.on('resize', this.onResize);
+    this.y = (await (terminal as any).getCursorLocation()).y;
+    await this.layoutChoices();
+    this.render();
+  }
+
+  private end() {
+    terminal.grabInput(false);
+    terminal.off('key', this.onKeyPress);
+    terminal.off('resize', this.onResize);
+    if (this.options.clearAfter === false) {
+      const {y} = this.getCoordinates(this.choices.length - 1);
+      terminal.moveTo(1, y).nextLine(1).eraseDisplayBelow();
+    } else {
+      terminal.moveTo(1, this.y).eraseDisplayBelow();
+    }
+  }
+
+  private get menuTop() {
+    return this.y + this.questionHeight;
+  }
+
+  private scrollSelectionIntoView() {
+    const previous = this.scrollOffset;
+    let {y} = this.getCoordinates(this.selected);
+    while (y < this.menuTop) {
+      y++;
+      this.scrollOffset--;
+    }
+    while (y > terminal.height) {
+      y--;
+      this.scrollOffset++;
+    }
+    if (previous !== this.scrollOffset) {
+      this.render();
+    }
+  }
+
+  private setSelection(index: number) {
+    const previous = this.selected;
+    this.selected = index;
+    this.scrollSelectionIntoView();
+    this.rerender(previous);
+    this.rerender(this.selected);
+    this.cursorToSelected();
+  }
+
+  private onResize = async () => {
+    await this.layoutChoices();
+    this.render();
+  }
+
+  private onKeyPress = (name: string, _matches: string[], _data: {code: string}) => {
+    const {x, y} = this.getOffset(this.selected);
+    switch (name) {
+      case 'UP':
+        if (y > 0) {
+          this.setSelection(this.layout[x][y - 1].index);
+        }
+        break;
+
+      case 'DOWN':
+        if (y < this.layout[x].length - 1) {
+          this.setSelection(this.layout[x][y + 1].index);
+        }
+        break;
+
+      case 'LEFT':
+        if (x > 0) {
+          this.setSelection(this.layout[x - 1][y].index);
+        }
+        break;
+
+      case 'RIGHT':
+        if (this.layout[x + 1] && this.layout[x + 1][y]) {
+          this.setSelection(this.layout[x + 1][y].index);
+        }
+        break;
+
+      case 'ENTER':
+      case 'KP_ENTER':
+        this.end();
+        this.onSelect(this.choices[this.selected]);
+        break;
+    }
+  }
+
+  private getOffset(index: number) {
+    for (let x = 0; x < this.layout.length; x++) {
+      for (let y = 0; y < this.layout[x].length; y++) {
+        if (this.layout[x][y].index === index) {
+          return {x, y};
+        }
+      }
+    }
+    return {x: 0, y: 0};
+  }
+
+  private getCoordinates(index: number) {
+    const {x, y} = this.getOffset(index);
+    const layout = this.layout[x][y];
+    return {
+      x: layout.x,
+      y: this.menuTop + layout.y - this.scrollOffset
+    };
+
+  }
+
+  private render() {
+    terminal.moveTo(1, this.y).eraseDisplayBelow();
+    this.questionHeight = Math.floor(stringWidth(this.question) / terminal.width) + 1;
+    terminal.moveTo(0, terminal.height);
+    while (this.y > 1 && this.menuTop + this.layout[0].length > terminal.height) {
+      this.y--;
+      console.log('');
+    }
+
+    terminal.moveTo(1, this.y).eraseDisplayBelow();
+    terminal(this.question);
+    for (const layouts of this.layout) {
+      for (const layout of layouts) {
+        const y = this.menuTop + layout.y - this.scrollOffset;
+        if (y >= this.menuTop && y <= terminal.height) {
+          terminal.moveTo(layout.x, y);
+          if (layout.index === this.selected) {
+            terminal(chalk.bgWhite.black(` ${layout.text} `));
+          } else {
+            terminal(` ${layout.text} `);
+          }
+        }
+      }
+    }
+    this.cursorToSelected();
+  }
+
+  private rerender(index: number) {
+    const {x, y} = this.getOffset(index);
+    const layout = this.layout[x][y];
+    terminal.moveTo(layout.x, this.menuTop + layout.y - this.scrollOffset);
+    if (layout.index === this.selected) {
+      terminal(chalk.bgWhite.black(` ${layout.text} `));
+    } else {
+      terminal(` ${layout.text} `);
+    }
+  }
+
+  private cursorToSelected() {
+    const {x, y} = this.getCoordinates(this.selected);
+    terminal.moveTo(x, y);
+  }
+
+  private async layoutChoices() {
+    const width = terminal.width;
+    const maxLength = this.choices.reduce((max, c) => Math.max(max, stringWidth(c.text)), 0);
+    const perRow = this.options.layout === 'row' ? 1 : Math.floor(width / (maxLength + 2));
+    this.layout = [];
+    this.choices.forEach((choice, index) => {
+      const x = index % perRow;
+      const y = Math.floor(index / perRow);
+      if (!this.layout[x]) {
+        this.layout[x] = [];
+      }
+      this.layout[x][y] = {
+        x: 1 + (maxLength + 2) * x,
+        y,
+        index,
+        text: stringWidth(choice.text) + 2 > width ? truncateString(choice.text, width - 3) + '…' : choice.text
+      };
+    });
+  }
+}

package/src/lib/TerminalOutput.ts

@@ -0,0 +1,7 @@
+import * as child_process from 'child_process';
+
+export namespace TerminalOutput {
+  export function exec(command: string) {
+    return child_process.spawnSync(command, {cwd: process.cwd(), shell: true, encoding: 'utf-8'});
+  }
+}