heroku 10.0.2 → 10.0.3-alpha.1

package/bin/heroku-prompts.js

@@ -0,0 +1,235 @@
+const fs = require('node:fs')
+const inquirer = require('inquirer')
+
+function choicesPrompt(description, choices, required, defaultValue) {
+  return inquirer.prompt([{
+    type: 'list',
+    name: 'choices',
+    message: description,
+    choices,
+    default: defaultValue,
+    validate(input) {
+      if (!required || input) {
+        return true
+      }
+
+      return `${description} is required`
+    },
+  }])
+}
+
+function prompt(description, required) {
+  return inquirer.prompt([{
+    type: 'input',
+    name: 'input',
+    message: description,
+    validate(input) {
+      if (!required || input.trim()) {
+        return true
+      }
+
+      return `${description} is required`
+    },
+  }])
+}
+
+function filePrompt(description, defaultPath) {
+  return inquirer.prompt([{
+    type: 'input',
+    name: 'path',
+    message: description,
+    default: defaultPath,
+    validate(input) {
+      if (fs.existsSync(input)) {
+        return true
+      }
+
+      return 'File does not exist. Please enter a valid file path.'
+    },
+  }])
+}
+
+const showBooleanPrompt = async (commandFlag, userInputMap, defaultOption) => {
+  const {description, default: defaultValue, name: flagOrArgName} = commandFlag
+  const choice = await choicesPrompt(description, [
+    {name: 'yes', value: true},
+    {name: 'no', value: false},
+  ], defaultOption)
+
+  // user cancelled
+  if (choice === undefined || choice === 'Cancel') {
+    return true
+  }
+
+  if (choice === 'Yes') {
+    userInputMap.set(flagOrArgName, defaultValue)
+  }
+
+  return false
+}
+
+const showOtherDialog = async (commandFlagOrArg, userInputMap) => {
+  const {description, default: defaultValue, options, required, name: flagOrArgName} = commandFlagOrArg
+
+  let input
+  const isFileInput = description?.includes('absolute path')
+  if (isFileInput) {
+    input = await filePrompt(description, '')
+  } else if (options) {
+    const choices = options.map(option => ({name: option, value: option}))
+    input = await choicesPrompt(`Select the ${description}`, choices, required, defaultValue)
+  } else {
+    input = await prompt(`${description.slice(0, 1).toUpperCase()}${description.slice(1)} (${required ? 'required' : 'optional - press "Enter" to bypass'})`, required)
+  }
+
+  if (input === undefined) {
+    return true
+  }
+
+  if (input !== '') {
+    userInputMap.set(flagOrArgName, input)
+  }
+
+  return false
+}
+
+function collectInputsFromManifest(flagsOrArgsManifest, omitOptional) {
+  const requiredInputs = []
+  const optionalInputs = []
+
+  // Prioritize options over booleans to
+  // prevent the user from yo-yo back and
+  // forth between the different input dialogs
+  const keysByType = Object.keys(flagsOrArgsManifest).sort((a, b) => {
+    const {type: aType} = flagsOrArgsManifest[a]
+    const {type: bType} = flagsOrArgsManifest[b]
+    if (aType === bType) {
+      return 0
+    }
+
+    if (aType === 'option') {
+      return -1
+    }
+
+    if (bType === 'option') {
+      return 1
+    }
+
+    return 0
+  })
+
+  keysByType.forEach(key => {
+    const isRequired = Reflect.get(flagsOrArgsManifest[key], 'required');
+    (isRequired ? requiredInputs : optionalInputs).push(key)
+  })
+  // Prioritize required inputs
+  // over optional inputs when
+  // prompting the user.
+  // required inputs are sorted
+  // alphabetically. optional
+  // inputs are sorted alphabetically
+  // and then pushed to the end of
+  // the list.
+  requiredInputs.sort((a, b) => {
+    if (a < b) {
+      return -1
+    }
+
+    if (a > b) {
+      return 1
+    }
+
+    return 0
+  })
+  // Include optional only when not explicitly omitted
+  return omitOptional ? requiredInputs : [...requiredInputs, ...optionalInputs]
+}
+
+async function getInput(flagsOrArgsManifest, userInputMap, omitOptional) {
+  const flagsOrArgs = collectInputsFromManifest(flagsOrArgsManifest, omitOptional)
+
+  for (const flagOrArg of flagsOrArgs) {
+    const {name, description, type, hidden} = flagsOrArgsManifest[flagOrArg]
+    if (userInputMap.has(name)) {
+      continue
+    }
+
+    // hidden args and flags may be exposed later
+    // based on the user type. For now, skip them.
+    if (!description || hidden) {
+      continue
+    }
+
+    const cancelled = await (type === 'boolean' ? showBooleanPrompt : showOtherDialog)(flagsOrArgsManifest[flagOrArg], userInputMap)
+    if (cancelled) {
+      return true
+    }
+  }
+
+  return false
+}
+
+async function promptForInputs(commandName, commandManifest, userArgs, userFlags) {
+  const {args, flags} = commandManifest
+
+  const userInputByArg = new Map()
+  Object.keys(args).forEach((argKey, index) => {
+    if (userArgs[index]) {
+      userInputByArg.set(argKey, userArgs[index])
+    }
+  })
+
+  let cancelled = await getInput(args, userInputByArg)
+  if (cancelled) {
+    return {userInputByArg}
+  }
+
+  const userInputByFlag = new Map()
+  Object.keys(flags).forEach(flagKey => {
+    const {name, char} = flags[flagKey]
+    if (userFlags[name] || userFlags[char]) {
+      userInputByFlag.set(flagKey, userFlags[flagKey])
+    }
+  })
+  cancelled = await getInput(flags, userInputByFlag)
+  if (cancelled) {
+    return
+  }
+
+  return {userInputByArg, userInputByFlag}
+}
+
+module.exports.promptUser =  async (config, commandName, args, flags) => {
+  const commandMeta = config.findCommand(commandName)
+  if (!commandMeta) {
+    process.stderr.write(`"${commandName}" not a valid command\n$ `)
+    return
+  }
+
+  const {userInputByArg, userInputByFlag} = await promptForInputs(commandName, commandMeta, args, flags)
+
+  try {
+    for (const [, {input: argValue}] of userInputByArg) {
+      if (argValue) {
+        args.push(argValue)
+      }
+    }
+
+    for (const [flagName, {input: flagValue}] of userInputByFlag) {
+      if (!flagValue) {
+        continue
+      }
+
+      if (flagValue === true) {
+        args.push(`--${flagName}`)
+        continue
+      }
+
+      args.push(`--${flagName}`, flagValue)
+    }
+
+    return args
+  } catch (error) {
+    process.stderr.write(error.message)
+  }
+}

package/bin/heroku-repl.js

@@ -0,0 +1,48 @@
+const {Config} = require('@oclif/core')
+const root = require.resolve('../package.json')
+const config = new Config({root})
+const flagsByName = new Map()
+async function * commandGenerator() {
+  while (true) {
+    const argv = await new Promise(resolve => {
+      process.stdin.once('data', resolve)
+    })
+    yield argv.toString().trim().split(' ')
+  }
+}
+
+module.exports.herokuRepl = async function (config) {
+  process.stderr.write('Welcome to the Heroku Terminal!\n$ ')
+
+  for await (const input of commandGenerator()) {
+    const [command, ...argv] = input
+    if (command === '.exit') {
+      process.exit(0)
+    }
+
+    if (command.startsWith('set')) {
+      flagsByName.set(argv[0], argv[1])
+      process.stderr.write(`setting --app to "${argv[1]}"\n$ `)
+      continue
+    }
+
+    const commandMeta = config.findCommand(command)
+    if (!commandMeta) {
+      process.stderr.write(`"${command}" not a valid command\n$ `)
+      continue
+    }
+
+    try {
+      const {flags} = commandMeta
+      if (flags.app && flagsByName.has('app') && !argv?.includes('--app')) {
+        argv.push('--app', flagsByName.get('app'))
+      }
+
+      await config.runCommand(command, argv)
+    } catch (error) {
+      process.stderr.write(error.message)
+    }
+
+    process.stderr.write('\n$ ')
+  }
+}

package/bin/run

@@ -1,10 +1,15 @@
 #!/usr/bin/env node
 
+const {Config} = require('@oclif/core')
+const root = require.resolve('../package.json')
+const config = new Config({root})
+
 process.env.HEROKU_UPDATE_INSTRUCTIONS = process.env.HEROKU_UPDATE_INSTRUCTIONS || 'update with: "npm update -g heroku"'
 
 const now = new Date()
 const cliStartTime = now.getTime()
 const globalTelemetry = require('../lib/global_telemetry')
+const yargs = require('yargs-parser')(process.argv.slice(2))
 
 process.once('beforeExit', async code => {
   // capture as successful exit
@@ -38,13 +43,32 @@ process.on('SIGTERM', async () => {
 globalTelemetry.initializeInstrumentation()
 
 const oclif = require('@oclif/core')
+const oclifFlush = require('@oclif/core/flush')
+const oclifError = require('@oclif/core/handle')
+const { promptUser } = require('./heroku-prompts')
+const { herokuRepl } = require('./heroku-repl')
 
-oclif.run().then(require('@oclif/core/flush')).catch(async error => {
-  // capture any errors raised by oclif
-  const cliError = error
-  cliError.cliRunDuration = globalTelemetry.computeDuration(cliStartTime)
-  await globalTelemetry.sendTelemetry(cliError)
+const main = async () => {
+  try {
+    await config.load()
+    const {_: [commandName, ...args], ...flags} = yargs
+    if (!commandName && !args.length && !Object.keys(flags).length) {
+      return await herokuRepl(config)
+    }
+    if (flags.prompt) {
+      delete flags.prompt
+      await promptUser(config, commandName, args, flags)
+    }
+    await oclif.run(undefined, config)
+    await oclifFlush()
+  } catch (error) {
+    // capture any errors raised by oclif
+    const cliError = error
+    cliError.cliRunDuration = globalTelemetry.computeDuration(cliStartTime)
+    await globalTelemetry.sendTelemetry(cliError)
 
-  return require('@oclif/core/handle')(error)
-})
+    oclifError(error)
+  }
+};
 
+void main();

package/lib/analytics.d.ts

@@ -25,6 +25,7 @@ export default class AnalyticsCommand {
     config: Interfaces.Config;
     userConfig: typeof deps.UserConfig.prototype;
     http: typeof deps.HTTP;
+    initialize: Promise<void>;
     constructor(config: Interfaces.Config);
     record(opts: RecordOpts): Promise<any>;
     get url(): string;

package/lib/analytics.js

@@ -11,9 +11,10 @@ class AnalyticsCommand {
         this.http = deps_1.default.HTTP.create({
             headers: { 'user-agent': config.userAgent },
         });
+        this.initialize = this.init();
     }
     async record(opts) {
-        await this.init();
+        await this.initialize;
         const plugin = opts.Command.plugin;
         if (!plugin) {
             debug('no plugin found for analytics');

package/lib/commands/addons/open.js

@@ -53,7 +53,7 @@ class Open extends command_1.Command {
         const sso = await this.heroku.request(`/apps/${app}/addons/${args.addon}/sso`, {
             method: 'GET',
             headers: {
-                Accept: 'application/vnd.heroku+json; version=3.add-ons-sso',
+                Accept: 'application/vnd.heroku+json; version=3.sdk',
             },
         });
         const { method, action } = sso.body;

package/lib/commands/spaces/destroy.js

@@ -1,13 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const core_1 = require("@oclif/core");
-const color_1 = require("@heroku-cli/color");
 const command_1 = require("@heroku-cli/command");
 const tsheredoc_1 = require("tsheredoc");
 const confirmCommand_1 = require("../../lib/confirmCommand");
 const spaces_1 = require("../../lib/spaces/spaces");
+const color_1 = require("@heroku-cli/color");
 class Destroy extends command_1.Command {
     async run() {
+        var _a, _b;
         const { flags, args } = await this.parse(Destroy);
         const { confirm } = flags;
         const spaceName = flags.space || args.space;
@@ -22,7 +23,20 @@ class Destroy extends command_1.Command {
         if (space.state === 'allocated') {
             ({ body: space.outbound_ips } = await this.heroku.get(`/spaces/${spaceName}/nat`));
             if (space.outbound_ips && space.outbound_ips.state === 'enabled') {
-                natWarning = `The Outbound IPs for this space will be reused!\nEnsure that external services no longer allow these Outbound IPs: ${(0, spaces_1.displayNat)(space.outbound_ips)}\n`;
+                const ipv6 = ((_a = space.generation) === null || _a === void 0 ? void 0 : _a.name) === 'fir' ? ' and IPv6' : '';
+                natWarning = (0, tsheredoc_1.default) `
+        ${color_1.default.dim('===')} ${color_1.default.bold('WARNING: Outbound IPs Will Be Reused')}
+        ${color_1.default.yellow(`⚠️ Deleting this space frees up the following outbound IPv4${ipv6} IPs for reuse:`)}
+        ${color_1.default.bold((_b = (0, spaces_1.displayNat)(space.outbound_ips)) !== null && _b !== void 0 ? _b : '')}
+
+        ${color_1.default.dim('Update the following configurations:')}
+        ${color_1.default.dim('=')} IP allowlists
+        ${color_1.default.dim('=')} Firewall rules
+        ${color_1.default.dim('=')} Security group configurations
+        ${color_1.default.dim('=')} Network ACLs
+
+        ${color_1.default.yellow(`Ensure that you remove the listed IPv4${ipv6} addresses from your security configurations.`)}
+      `;
             }
         }
         await (0, confirmCommand_1.default)(spaceName, confirm, `Destructive Action\nThis command will destroy the space ${color_1.default.bold.red(spaceName)}\n${natWarning}\n`);

package/lib/commands/telemetry/add.js

@@ -29,7 +29,7 @@ class Add extends command_1.Command {
             signals: (0, util_1.validateAndFormatSignals)(signals),
             exporter: {
                 endpoint,
-                type: `otlp${transport}`,
+                type: (transport === 'grpc') ? 'otlp' : 'otlphttp',
                 headers: JSON.parse(exporterHeaders),
             },
         };

package/lib/commands/telemetry/index.js

@@ -44,6 +44,6 @@ Index.topic = 'telemetry';
 Index.description = 'list telemetry drains';
 Index.flags = {
     space: command_1.flags.string({ char: 's', description: 'filter by space name', exactlyOne: ['app', 'space'] }),
-    app: command_1.flags.app({ description: 'filter by app name' }),
+    app: command_1.flags.string({ description: 'filter by app name' }),
 };
 Index.example = '$ heroku telemetry';

package/lib/hooks/postrun/performance_analytics.js

@@ -8,5 +8,6 @@ const performance_analytics = async function () {
     const cmdStartTime = global.cliTelemetry.commandRunDuration;
     global.cliTelemetry.commandRunDuration = telemetry.computeDuration(cmdStartTime);
     global.cliTelemetry.lifecycleHookCompletion.postrun = true;
+    await Reflect.get(globalThis, 'recordPromise');
 };
 exports.default = performance_analytics;

package/lib/hooks/prerun/analytics.js

@@ -8,6 +8,6 @@ const analytics = async function (options) {
     }
     global.cliTelemetry = telemetry.setupTelemetry(this.config, options);
     const analytics = new analytics_1.default(this.config);
-    await analytics.record(options);
+    Reflect.set(globalThis, 'recordPromise', analytics.record(options));
 };
 exports.default = analytics;