@automattic/vip 2.10.0 → 2.12.0

package/package/dist/bin/vip-wp.js

@@ -0,0 +1,555 @@
+#!/usr/bin/env node
+
+/**
+ * External dependencies
+ */
+"use strict";
+
+var _chalk = _interopRequireDefault(require("chalk"));
+
+var _graphqlTag = _interopRequireDefault(require("graphql-tag"));
+
+var _socket = _interopRequireDefault(require("socket.io-client"));
+
+var _socket2 = _interopRequireDefault(require("socket.io-stream"));
+
+var _readline = _interopRequireDefault(require("readline"));
+
+var _stream = require("stream");
+
+var _debug = _interopRequireDefault(require("debug"));
+
+var _api = _interopRequireWildcard(require("../lib/api"));
+
+var _command = _interopRequireWildcard(require("../lib/cli/command"));
+
+var exit = _interopRequireWildcard(require("../lib/cli/exit"));
+
+var _format = require("../lib/cli/format");
+
+var _prompt = require("../lib/cli/prompt");
+
+var _tracker = require("../lib/tracker");
+
+var _token = _interopRequireDefault(require("../lib/token"));
+
+var _rollbar = require("../lib/rollbar");
+
+var _socksProxyAgent = _interopRequireDefault(require("../lib/http/socks-proxy-agent"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * Internal dependencies
+ */
+const debug = (0, _debug.default)('@automattic/vip:wp');
+const appQuery = `id, name,
+	organization {
+		id
+		name
+	}
+	environments {
+	id
+	appId
+	type
+	name
+	primaryDomain {
+		name
+	}
+}`;
+const NON_TTY_COLUMNS = 100;
+const NON_TTY_ROWS = 15;
+const cancelCommandChar = '\x03';
+let currentJob = null;
+let currentOffset = 0;
+let commandRunning = false;
+
+const pipeStreamsToProcess = ({
+  stdin,
+  stdout: outStream
+}) => {
+  process.stdin.pipe(stdin);
+  outStream.pipe(process.stdout);
+};
+
+const unpipeStreamsFromProcess = ({
+  stdin,
+  stdout: outStream
+}) => {
+  process.stdin.unpipe(stdin);
+  outStream.unpipe(process.stdout);
+};
+
+const bindStreamEvents = ({
+  subShellRl,
+  commonTrackingParams,
+  isSubShell,
+  stdoutStream
+}) => {
+  stdoutStream.on('error', err => {
+    commandRunning = false; // TODO handle this better
+
+    console.error('Error: ' + err.message);
+  });
+  stdoutStream.on('end', async () => {
+    subShellRl.clearLine();
+    commandRunning = false;
+    await (0, _tracker.trackEvent)('wpcli_command_end', commonTrackingParams); // Tell socket.io to stop trying to connect
+
+    currentJob.socket.close();
+    unpipeStreamsFromProcess({
+      stdin: currentJob.stdinStream,
+      stdout: currentJob.stdoutStream
+    }); // Reset offset
+
+    currentOffset = 0;
+
+    if (!isSubShell) {
+      subShellRl.close();
+      process.exit();
+      return;
+    }
+
+    subShellRl.resume();
+    subShellRl.prompt();
+  });
+};
+
+const getTokenForCommand = async (appId, envId, command) => {
+  const api = await (0, _api.default)();
+  return api.mutate({
+    // $FlowFixMe: gql template is not supported by flow
+    mutation: (0, _graphqlTag.default)`
+				mutation TriggerWPCLICommandMutation($input: AppEnvironmentTriggerWPCLICommandInput ){
+					triggerWPCLICommandOnAppEnvironment( input: $input ) {
+						inputToken
+						command {
+							guid
+						}
+					}
+				}
+			`,
+    variables: {
+      input: {
+        id: appId,
+        environmentId: envId,
+        command
+      }
+    }
+  });
+}; // eslint-disable-next-line no-unused-vars
+
+
+const cancelCommand = async guid => {
+  const api = await (0, _api.default)();
+  return api.mutate({
+    // $FlowFixMe: gql template is not supported by flow
+    mutation: (0, _graphqlTag.default)`
+			mutation cancelWPCLICommand($input: CancelWPCLICommandInput ){
+				cancelWPCLICommand( input: $input ) {
+					command {
+						id
+					}
+				}
+			}
+		`,
+    variables: {
+      input: {
+        guid: guid
+      }
+    }
+  });
+};
+
+const launchCommandAndGetStreams = async ({
+  socket,
+  guid,
+  inputToken,
+  offset = 0
+}) => {
+  const stdoutStream = _socket2.default.createStream();
+
+  const stdinStream = _socket2.default.createStream();
+
+  stdoutStream.on('data', data => {
+    currentOffset = data.length + currentOffset;
+  }); // TODO handle all arguments
+  // TODO handle disconnect - does IOStream correctly buffer stdin?
+  // TODO stderr - currently server doesn't support it, so errors don't terminate process
+
+  const data = {
+    guid,
+    inputToken,
+    columns: process.stdout.columns || NON_TTY_COLUMNS,
+    rows: process.stdout.rows || NON_TTY_ROWS,
+    offset
+  };
+  (0, _socket2.default)(socket).emit('cmd', data, stdinStream, stdoutStream);
+  socket.on('unauthorized', err => {
+    console.log('There was an error with the authentication:', err.message);
+  });
+  socket.on('cancel', message => {
+    socket.close();
+    exit.withError(`Cancel received from server: ${message}`);
+  });
+  (0, _socket2.default)(socket).on('error', err => {
+    // This returns the error so it can be catched by the socket.on('error')
+    _rollbar.rollbar.error(err);
+
+    return err;
+  });
+  socket.on('error', err => {
+    if (err === 'Rate limit exceeded') {
+      console.log(_chalk.default.red('\nError:'), 'Rate limit exceeded: Please wait a moment and try again.');
+      return;
+    }
+
+    _rollbar.rollbar.error(err);
+
+    console.log(err);
+  });
+  return {
+    stdinStream,
+    stdoutStream,
+    socket
+  };
+};
+
+const bindReconnectEvents = ({
+  cliCommand,
+  inputToken,
+  subShellRl,
+  commonTrackingParams,
+  isSubShell
+}) => {
+  currentJob.socket.io.removeAllListeners('reconnect');
+  currentJob.socket.io.removeAllListeners('reconnect_attempt');
+  currentJob.socket.removeAllListeners('retry');
+  currentJob.socket.io.on('reconnect', async () => {
+    debug('socket.io: reconnect');
+
+    _rollbar.rollbar.info('WP-CLI socket.io.on( \'reconnect\' )', {
+      custom: {
+        code: 'wp-cli-on-reconnect',
+        commandGuid: cliCommand.guid
+      }
+    }); // Close old streams
+
+
+    unpipeStreamsFromProcess({
+      stdin: currentJob.stdinStream,
+      stdout: currentJob.stdoutStream
+    });
+    (0, _tracker.trackEvent)('wpcli_command_reconnect', commonTrackingParams);
+    currentJob = await launchCommandAndGetStreams({
+      socket: currentJob.socket,
+      guid: cliCommand.guid,
+      inputToken: inputToken,
+      offset: currentOffset
+    }); // Rebind new streams
+
+    pipeStreamsToProcess({
+      stdin: currentJob.stdinStream,
+      stdout: currentJob.stdoutStream
+    });
+    bindStreamEvents({
+      subShellRl,
+      isSubShell,
+      commonTrackingParams,
+      stdoutStream: currentJob.stdoutStream
+    });
+    bindReconnectEvents({
+      cliCommand,
+      inputToken,
+      subShellRl,
+      commonTrackingParams,
+      isSubShell
+    }); // Resume readline interface
+
+    subShellRl.resume();
+  });
+  currentJob.socket.on('retry', async () => {
+    debug('socket: retry');
+
+    _rollbar.rollbar.info('WP-CLI socket.io.on( \'retry\' )', {
+      custom: {
+        code: 'wp-cli-on-retry',
+        commandGuid: cliCommand.guid
+      }
+    });
+
+    setTimeout(() => {
+      currentJob.socket.io.engine.close();
+    }, 5000);
+  });
+  currentJob.socket.on('exit', async ({
+    exitCode,
+    message
+  }) => {
+    debug('socket: exit. Code: %d. Message: %s', exitCode, message);
+
+    if (message) {
+      console.log(message);
+    }
+
+    currentJob.stdinStream.destroy();
+    currentJob.stdoutStream.destroy();
+    currentJob.socket.close();
+    process.exit(exitCode);
+  });
+  currentJob.socket.io.on('reconnect_attempt', attempt => {
+    console.error('There was an error connecting to the server. Retrying...');
+
+    if (attempt > 1) {
+      return;
+    } // create a new input stream so that we can still catch things like SIGINT while reconnecting
+
+
+    if (currentJob.stdinStream) {
+      process.stdin.unpipe(currentJob.stdinStream);
+    }
+
+    process.stdin.pipe(_socket2.default.createStream());
+    currentJob.stdoutStream = _socket2.default.createStream();
+    bindStreamEvents({
+      subShellRl,
+      isSubShell,
+      commonTrackingParams,
+      stdoutStream: currentJob.stdoutStream
+    });
+  });
+};
+
+(0, _command.default)({
+  wildcardCommand: true,
+  appContext: true,
+  envContext: true,
+  appQuery
+}).option('yes', 'Run the command in production without a confirmation prompt').argv(process.argv, async (args, opts) => {
+  const isSubShell = 0 === args.length; // Have to re-quote anything that needs it before we pass it on
+
+  const quotedArgs = (0, _format.requoteArgs)(args);
+  const cmd = quotedArgs.join(' '); // Store only the first 2 parts of command to avoid recording secrets. Can be tweaked
+
+  const commandForAnalytics = quotedArgs.slice(0, 2).join(' ');
+  const {
+    id: appId,
+    name: appName,
+    organization: {
+      id: orgId
+    }
+  } = opts.app;
+  const {
+    id: envId,
+    type: envName
+  } = opts.env;
+  /* eslint-disable camelcase */
+
+  const commonTrackingParams = {
+    command: commandForAnalytics,
+    app_id: appId,
+    env_id: envId,
+    org_id: orgId,
+    method: isSubShell ? 'subshell' : 'shell'
+  };
+  /* eslint-enable camelcase */
+
+  (0, _tracker.trackEvent)('wpcli_command_execute', commonTrackingParams);
+
+  if (isSubShell) {
+    // Reset the cursor (can get messed up with enquirer)
+    process.stdout.write('\u001b[?25h');
+    console.log(`Welcome to the WP CLI shell for the ${(0, _format.formatEnvironment)(envName)} environment of ${_chalk.default.green(appName)} (${opts.env.primaryDomain.name})!`);
+  } else if (envName === 'production') {
+    const yes = opts.yes || (await (0, _prompt.confirm)([{
+      key: 'command',
+      value: `wp ${cmd}`
+    }], `Are you sure you want to run this command on ${(0, _format.formatEnvironment)(envName)} for site ${appName}?`));
+
+    if (!yes) {
+      (0, _tracker.trackEvent)('wpcli_confirm_cancel', commonTrackingParams);
+      console.log('Command cancelled');
+      process.exit();
+    }
+  } // We'll handle our own errors, thank you
+
+
+  (0, _api.disableGlobalGraphQLErrorHandling)();
+  const promptIdentifier = `${appName}.${(0, _command.getEnvIdentifier)(opts.env)}`;
+  let countSIGINT = 0;
+  const mutableStdout = new _stream.Writable({
+    write: function (chunk, encoding, callback) {
+      if (!this.muted) {
+        process.stdout.write(chunk, encoding);
+      }
+
+      callback();
+    }
+  });
+  mutableStdout.muted = false;
+  const subShellSettings = {
+    input: process.stdin,
+    output: mutableStdout,
+    terminal: true,
+    prompt: '',
+    historySize: 0
+  };
+
+  if (isSubShell) {
+    subShellSettings.prompt = (0, _chalk.default)`{bold.yellowBright ${promptIdentifier}:}{blue ~}$ `;
+    subShellSettings.historySize = 200;
+  }
+
+  const subShellRl = _readline.default.createInterface(subShellSettings);
+
+  subShellRl.on('line', async line => {
+    if (commandRunning) {
+      return;
+    } // Handle plain return / newline
+
+
+    if (!line) {
+      subShellRl.prompt();
+      return;
+    } // Check for exit, like SSH (handles both `exit` and `exit;`)
+
+
+    if (line.startsWith('exit')) {
+      subShellRl.close();
+      process.exit();
+    }
+
+    const startsWithWp = line.startsWith('wp ');
+    const empty = 0 === line.length;
+    const userCmdCancelled = line === cancelCommandChar;
+
+    if ((empty || !startsWithWp) && !userCmdCancelled) {
+      console.log(_chalk.default.red('Error:'), 'invalid command, please pass a valid WP CLI command.');
+      subShellRl.prompt();
+      return;
+    }
+
+    subShellRl.pause();
+    let result;
+
+    try {
+      result = await getTokenForCommand(appId, envId, line.replace('wp ', ''));
+    } catch (error) {
+      // If this was a GraphQL error, print that to the message to the line
+      if (error.graphQLErrors) {
+        error.graphQLErrors.forEach(err => {
+          console.log(_chalk.default.red('Error:'), err.message);
+        });
+      } else {
+        // Else, other type of error, just dump it
+        _rollbar.rollbar.error(error);
+
+        console.log(error);
+      }
+
+      if (!isSubShell) {
+        subShellRl.close();
+        process.exit(1);
+      }
+
+      subShellRl.prompt();
+      return;
+    }
+
+    const {
+      data: {
+        triggerWPCLICommandOnAppEnvironment: {
+          command: cliCommand,
+          inputToken
+        }
+      }
+    } = result;
+
+    if (line.includes("'")) {
+      _rollbar.rollbar.info('WP-CLI Command containing single quotes', {
+        custom: {
+          code: 'wp-cli-single-quotes',
+          commandGuid: cliCommand.guid
+        }
+      });
+    }
+
+    const token = await _token.default.get();
+    const socket = (0, _socket.default)(`${_api.API_HOST}/wp-cli`, {
+      transportOptions: {
+        polling: {
+          extraHeaders: {
+            Authorization: `Bearer ${token.raw}`
+          }
+        }
+      },
+      agent: (0, _socksProxyAgent.default)()
+    });
+    currentJob = await launchCommandAndGetStreams({
+      socket,
+      guid: cliCommand.guid,
+      inputToken: inputToken
+    });
+    pipeStreamsToProcess({
+      stdin: currentJob.stdinStream,
+      stdout: currentJob.stdoutStream
+    });
+    commandRunning = true;
+    bindStreamEvents({
+      subShellRl,
+      commonTrackingParams,
+      isSubShell,
+      stdoutStream: currentJob.stdoutStream
+    });
+    bindReconnectEvents({
+      cliCommand,
+      inputToken,
+      subShellRl,
+      commonTrackingParams,
+      isSubShell
+    });
+  }); // Fix to re-add the \n character that readline strips when terminal == true
+
+  process.stdin.on('data', data => {
+    // only run this in interactive mode for prompts from WP commands
+    if (commandRunning && 0 === Buffer.compare(data, Buffer.from('\r'))) {
+      if (currentJob && currentJob.stdinStream) {
+        currentJob.stdinStream.write('\n');
+      }
+    }
+  });
+  subShellRl.on('SIGINT', async () => {
+    // if we have a 2nd SIGINT, exit immediately
+    if (countSIGINT >= 1) {
+      process.exit();
+    }
+
+    countSIGINT += 1; // write out CTRL-C/SIGINT
+
+    process.stdin.write(cancelCommandChar);
+
+    if (currentJob && currentJob.stdoutStream) {
+      currentJob.stdoutStream.end();
+    }
+
+    await (0, _tracker.trackEvent)('wpcli_cancel_command', commonTrackingParams);
+    console.log('Command cancelled by user'); // if no command running (.e.g. interactive shell, exit only after doing cleanup)
+
+    if (commandRunning === false) {
+      process.exit();
+    }
+  });
+
+  if (!isSubShell) {
+    mutableStdout.muted = true;
+    subShellRl.write(`wp ${cmd}\n`);
+    mutableStdout.muted = false;
+    return;
+  }
+
+  subShellRl.prompt();
+});

package/package/dist/bin/vip.js

@@ -0,0 +1,149 @@
+#!/usr/bin/env node
+
+/**
+ * External dependencies
+ */
+"use strict";
+
+var _opn = _interopRequireDefault(require("opn"));
+
+var _enquirer = require("enquirer");
+
+var _chalk = _interopRequireDefault(require("chalk"));
+
+var _debug = _interopRequireDefault(require("debug"));
+
+var _config = _interopRequireDefault(require("../../config/config.json"));
+
+var _command = _interopRequireWildcard(require("../lib/cli/command"));
+
+var _token = _interopRequireDefault(require("../lib/token"));
+
+var _tracker = require("../lib/tracker");
+
+var _rollbar = require("../lib/rollbar");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * Internal dependencies
+ */
+const debug = (0, _debug.default)('@automattic/vip:bin:vip');
+
+if (_config.default && _config.default.environment !== 'production') {
+  debug(`${_chalk.default.bgYellow('WARNING:')} RUNNING DEV VERSION OF @automattic/vip`);
+  debug('You should `npm link` your locally checked out copy of this repo as part of your development setup.');
+} // Config
+
+
+const tokenURL = 'https://dashboard.wpvip.com/me/cli/token';
+
+const runCmd = async function () {
+  const cmd = (0, _command.default)();
+  cmd.command('logout', 'Logout from your current session', async () => {
+    await _token.default.purge();
+    await (0, _tracker.trackEvent)('logout_command_execute');
+    console.log('You are successfully logged out.');
+  }).command('app', 'List and modify your VIP applications').command('config', 'Set configuration for your VIP applications').command('dev-env', 'Use local dev-environment').command('import', 'Import media or SQL files into your VIP applications').command('logs', 'Get logs from your VIP applications').command('search-replace', 'Perform search and replace tasks on files').command('sync', 'Sync production to a development environment').command('whoami', 'Display details about the currently logged-in user').command('wp', 'Run WP CLI commands against an environment');
+  cmd.argv(process.argv);
+};
+
+const rootCmd = async function () {
+  let token = await _token.default.get();
+  const isHelpCommand = process.argv.some(arg => arg === 'help' || arg === '-h' || arg === '--help');
+  const isLogoutCommand = process.argv.some(arg => arg === 'logout');
+  const isDevEnvCommandWithoutEnv = process.argv.some(arg => arg === 'dev-env') && !(0, _command.containsAppEnvArgument)(process.argv);
+  debug('Argv:', process.argv);
+
+  if (isLogoutCommand || isHelpCommand || isDevEnvCommandWithoutEnv || token && token.valid()) {
+    runCmd();
+  } else {
+    console.log();
+    console.log('  Welcome to');
+    console.log('   _    __ ________         ________    ____');
+    console.log('  | |  / //  _/ __ \       / ____/ /   /  _/');
+    console.log('  | | / / / // /_/ /______/ /   / /    / /  ');
+    console.log('  | |/ /_/ // ____//_____/ /___/ /____/ /   ');
+    console.log('  |___//___/_/           \____/_____/___/   ');
+    console.log();
+    console.log('  VIP CLI is your tool for interacting with and managing your VIP applications.');
+    console.log();
+    console.log(`  To get started, we need an access token for your VIP account. We'll open ${tokenURL} in your web browser; follow the instructions there to continue.`);
+    console.log();
+    await (0, _tracker.trackEvent)('login_command_execute');
+    const answer = await (0, _enquirer.prompt)({
+      type: 'confirm',
+      name: 'continue',
+      message: 'Ready?'
+    });
+
+    if (!answer.continue) {
+      await (0, _tracker.trackEvent)('login_command_browser_cancelled');
+      return;
+    }
+
+    (0, _opn.default)(tokenURL, {
+      wait: false
+    });
+    await (0, _tracker.trackEvent)('login_command_browser_opened');
+    const {
+      token: tokenInput
+    } = await (0, _enquirer.prompt)({
+      type: 'password',
+      name: 'token',
+      message: 'Access Token:'
+    });
+
+    try {
+      token = new _token.default(tokenInput);
+    } catch (err) {
+      console.log('The token provided is malformed. Please check the token and try again.');
+
+      _rollbar.rollbar.error(err);
+
+      await (0, _tracker.trackEvent)('login_command_token_submit_error', {
+        error: err.message
+      });
+      return;
+    }
+
+    if (token.expired()) {
+      console.log('The token provided is expired. Please log in again to refresh the token.');
+      await (0, _tracker.trackEvent)('login_command_token_submit_error', {
+        error: 'expired'
+      });
+      return;
+    }
+
+    if (!token.valid()) {
+      console.log('The provided token is not valid. Please log in again to refresh the token.');
+      await (0, _tracker.trackEvent)('login_command_token_submit_error', {
+        error: 'invalid'
+      });
+      return;
+    }
+
+    try {
+      _token.default.set(token.raw);
+    } catch (err) {
+      await (0, _tracker.trackEvent)('login_command_token_submit_error', {
+        error: err.message
+      });
+
+      _rollbar.rollbar.error(err);
+
+      throw err;
+    } // De-anonymize user for tracking
+
+
+    await (0, _tracker.aliasUser)(token.id);
+    await (0, _tracker.trackEvent)('login_command_token_submit_success');
+    runCmd();
+  }
+};
+
+rootCmd();

package/package/dist/lib/analytics/clients/client.js

@@ -0,0 +1 @@
+"use strict";