heroku 10.13.2 → 11.0.0-alpha.1

package/lib/oldCommands/autocomplete/create.js

@@ -0,0 +1,254 @@
+export {};
+/*
+import {Command} from '@oclif/core'
+import * as fs from 'fs-extra'
+import * as path from 'path'
+
+import {AutocompleteBase} from '../../lib/autocomplete/base'
+
+const debug = require('debug')('autocomplete:create')
+
+const AC_LIB_PATH = path.resolve(__dirname, '..', '..', '..', 'autocomplete-scripts')
+
+export default class Create extends AutocompleteBase {
+  static hidden = true
+
+  static description = 'create autocomplete setup scripts and completion functions'
+
+  private _commands?: Command.Loadable[]
+
+  async run() {
+    this.errorIfWindows()
+    // 1. ensure needed dirs
+    await this.ensureDirs()
+    // 2. save (generated) autocomplete files
+    await this.createFiles()
+  }
+
+  private async ensureDirs() {
+    // ensure autocomplete cache dir
+    await fs.ensureDir(this.autocompleteCacheDir)
+    // ensure autocomplete completions dir
+    await fs.ensureDir(this.completionsCacheDir)
+  }
+
+  private async createFiles() {
+    await fs.writeFile(this.bashSetupScriptPath, this.bashSetupScript)
+    await fs.writeFile(this.zshSetupScriptPath, this.zshSetupScript)
+    await fs.writeFile(this.bashCommandsListPath, this.bashCommandsList)
+    await fs.writeFile(this.zshCompletionSettersPath, this.zshCompletionSetters)
+  }
+
+  private get bashSetupScriptPath(): string {
+    // <cacheDir>/autocomplete/bash_setup
+    return path.join(this.autocompleteCacheDir, 'bash_setup')
+  }
+
+  private get bashCommandsListPath(): string {
+    // <cacheDir>/autocomplete/commands
+    return path.join(this.autocompleteCacheDir, 'commands')
+  }
+
+  private get zshSetupScriptPath(): string {
+    // <cacheDir>/autocomplete/zsh_setup
+    return path.join(this.autocompleteCacheDir, 'zsh_setup')
+  }
+
+  private get zshCompletionSettersPath(): string {
+    // <cacheDir>/autocomplete/commands_setters
+    return path.join(this.autocompleteCacheDir, 'commands_setters')
+  }
+
+  private get skipEllipsis(): boolean {
+    return process.env.HEROKU_AC_ZSH_SKIP_ELLIPSIS === '1'
+  }
+
+  private get commands(): Command.Loadable[] {
+    if (this._commands) return this._commands
+
+    const plugins = this.config.plugins
+    const commands: Command.Loadable[] = []
+
+    plugins.forEach(p => {
+      p.commands.forEach(c => {
+        if (c.hidden) return
+        try {
+          commands.push(c)
+        } catch (error: any) {
+          debug(`Error creating completions for command ${c.id}`)
+          debug(error.message)
+          this.writeLogFile(error.message)
+        }
+      })
+    })
+
+    this._commands = commands
+    return this._commands
+  }
+
+  private get bashCommandsList(): string {
+    return this.commands.map(c => {
+      try {
+        const publicFlags = this.genCmdPublicFlags(c).trim()
+        return `${c.id} ${publicFlags}`
+      } catch (error: any) {
+        debug(`Error creating bash completion for command ${c.id}, moving on...`)
+        debug(error.message)
+        this.writeLogFile(error.message)
+        return ''
+      }
+    }).join('\n')
+  }
+
+  private get zshCompletionSetters(): string {
+    const cmdsSetter = this.zshCommandsSetter
+    const flagSetters = this.zshCommandsFlagsSetters
+    return `${cmdsSetter}\n${flagSetters}`
+  }
+
+  private get zshCommandsSetter(): string {
+    const cmdsWithDescriptions = this.commands.map(c => {
+      try {
+        return this.genCmdWithDescription(c)
+      } catch (error: any) {
+        debug(`Error creating zsh autocomplete for command ${c.id}, moving on...`)
+        debug(error.message)
+        this.writeLogFile(error.message)
+        return ''
+      }
+    })
+
+    return this.genZshAllCmdsListSetter(cmdsWithDescriptions)
+  }
+
+  private get zshCommandsFlagsSetters(): string {
+    return this.commands.map(c => {
+      try {
+        return this.genZshCmdFlagsSetter(c)
+      } catch (error: any) {
+        debug(`Error creating zsh autocomplete for command ${c.id}, moving on...`)
+        debug(error.message)
+        this.writeLogFile(error.message)
+        return ''
+      }
+    }).join('\n')
+  }
+
+  private genCmdPublicFlags(command: Command.Loadable): string {
+    const Flags = command.flags || {}
+    return Object.keys(Flags)
+      .filter(flag => !Flags[flag].hidden)
+      .map(flag => `--${flag}`)
+      .join(' ')
+  }
+
+  private genCmdWithDescription(command: Command.Loadable): string {
+    let description = ''
+    if (command.description) {
+      const text = command.description.split('\n')[0]
+      description = `:"${text}"`
+    }
+
+    return `"${command.id.replace(/:/g, '\\:')}"${description}`
+  }
+
+  private genZshCmdFlagsSetter(command: Command.Loadable): string {
+    const id = command.id
+    const flagscompletions = Object.keys(command.flags || {})
+      .filter(flag => command.flags && !command.flags[flag].hidden)
+      .map(flag => {
+        const f = (command.flags && command.flags[flag]) || {description: ''}
+        const isBoolean = f.type === 'boolean'
+        const hasCompletion = 'completion' in f || this.findCompletion(id, flag, f.description)
+        const name = isBoolean ? flag : `${flag}=-`
+        let cachecompl = ''
+        if (hasCompletion) {
+          cachecompl = ': :_compadd_flag_options'
+        }
+
+        if (this.wantsLocalFiles(flag)) {
+          cachecompl = ': :_files'
+        }
+
+        const help = isBoolean ? '(switch) ' : (hasCompletion ? '(autocomplete) ' : '')
+        const completion = `--${name}[${help}${f.description}]${cachecompl}`
+        return `"${completion}"`
+      })
+      .join('\n')
+
+    if (flagscompletions) {
+      return `_set_${id.replace(/:/g, '_')}_flags () {
+_flags=(
+${flagscompletions}
+)
+}
+`
+    }
+
+    return `# no flags for ${id}`
+  }
+
+  private genZshAllCmdsListSetter(cmdsWithDesc: Array<string>): string {
+    return `
+_set_all_commands_list () {
+_all_commands_list=(
+${cmdsWithDesc.join('\n')}
+)
+}
+`
+  }
+
+  private get envAnalyticsDir(): string {
+    return `HEROKU_AC_ANALYTICS_DIR=${path.join(
+      this.autocompleteCacheDir,
+      'completion_analytics',
+    )};`
+  }
+
+  private get envCommandsPath(): string {
+    return `HEROKU_AC_COMMANDS_PATH=${path.join(this.autocompleteCacheDir, 'commands')};`
+  }
+
+  private get bashSetupScript(): string {
+    return `${this.envAnalyticsDir}
+${this.envCommandsPath}
+HEROKU_AC_BASH_COMPFUNC_PATH=${path.join(
+    AC_LIB_PATH,
+    'bash',
+    'heroku.bash',
+  )} && test -f $HEROKU_AC_BASH_COMPFUNC_PATH && source $HEROKU_AC_BASH_COMPFUNC_PATH;
+`
+  }
+
+  private get zshSetupScript(): string {
+    return `${this.skipEllipsis ? '' : this.completionDotsFunc}
+${this.envAnalyticsDir}
+${this.envCommandsPath}
+HEROKU_AC_ZSH_SETTERS_PATH=\${HEROKU_AC_COMMANDS_PATH}_setters && test -f $HEROKU_AC_ZSH_SETTERS_PATH && source $HEROKU_AC_ZSH_SETTERS_PATH;
+fpath=(
+${path.join(AC_LIB_PATH, 'zsh')}
+$fpath
+);
+autoload -Uz compinit;
+compinit;
+`
+  }
+
+  private get completionDotsFunc(): string {
+    return `expand-or-complete-with-dots() {
+  echo -n "..."
+  zle expand-or-complete
+  zle redisplay
+}
+zle -N expand-or-complete-with-dots
+bindkey "^I" expand-or-complete-with-dots`
+  }
+
+  private wantsLocalFiles(flag: string): boolean {
+    return [
+      'file',
+      'procfile',
+    ].includes(flag)
+  }
+}
+*/

package/lib/oldCommands/autocomplete/doctor.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/oldCommands/autocomplete/doctor.js

@@ -0,0 +1,110 @@
+export {};
+/*
+import {flags} from '@heroku-cli/command'
+import {Args} from '@oclif/core'
+import {hux} from '@heroku/heroku-cli-util'
+import {FlagInput} from '@oclif/core/lib/interfaces/parser'
+import * as fs from 'fs-extra'
+import * as path from 'path'
+
+import {AutocompleteBase} from '../../lib/autocomplete/base'
+
+export default class Doctor extends AutocompleteBase {
+  static hidden = true
+
+  static description = 'autocomplete diagnostic'
+
+  static args = {
+    shell: Args.string({description: 'shell type', required: false}),
+  }
+
+  static flags: FlagInput = {
+    verbose: flags.boolean({description: 'list completable commands'}),
+  }
+
+  async run() {
+    const {args, flags} = await this.parse(Doctor)
+    const shell = args.shell || this.config.shell
+    const printLine: typeof this.log = (...args) => this.log(...args)
+    this.errorIfNotSupportedShell(shell)
+
+    const data = []
+
+    // cli version
+    data.push({name: 'cli version', value: this.config.version})
+
+    // plugin version
+    const pjson = require(path.resolve(__dirname, '..', '..', '..', 'package.json'))
+    data.push({name: 'plugin version', value: pjson.version})
+
+    // check shell shim source env var
+    // i.e. HEROKU_AC_<shell>_SETUP_PATH
+    const shellProfilePath = path.join(process.env.HOME || '', shell === 'zsh' ? '.zshrc' : '.bashrc')
+    const shellProfile = fs.readFileSync(shellProfilePath)
+    const regex = /AC_\w+_SETUP_PATH/
+    const shimValue = regex.exec(shellProfile.toString()) ? 'present' : 'missing'
+    data.push({name: `~/${shell === 'zsh' ? '.zshrc' : '.bashrc'} shimmed`, value: shimValue})
+
+    // check shell shim
+    const shellCompletion = path.join(this.autocompleteCacheDir, `${shell}_setup`)
+    const shellCompletionValue = fs.existsSync(shellCompletion) ? 'present' : 'missing'
+    data.push({name: `${shell} shim file`, value: shellCompletionValue})
+
+    // check shell command cache
+    const shellCmdCache = path.join(this.autocompleteCacheDir, shell === 'zsh' ? 'commands_setters' : 'commands')
+    const shellCmdCacheValue = fs.existsSync(shellCmdCache) ? 'present' : 'missing'
+    data.push({name: `${shell} commands cache`, value: shellCmdCacheValue})
+
+    // check app completion cache
+    const appsCache = path.join(this.completionsCacheDir, 'app')
+    let appsCacheValue
+    if (fs.existsSync(appsCache)) {
+      const length = fs.readJSONSync(appsCache).length
+      appsCacheValue = length || 'empty'
+    } else {
+      appsCacheValue = 'missing'
+    }
+
+    data.push({name: 'apps completion cache', value: appsCacheValue})
+
+    hux.table(data, {
+      name: {},
+      value: {},
+    }, {'no-header': true, printLine})
+
+    if (flags.verbose) this.printList()
+  }
+
+  private printList() {
+    this.log()
+    const header = 'Completable Commands'
+    this.log(header)
+    this.log('='.repeat(header.length))
+    this.config.plugins.forEach(p => {
+      p.commands.forEach(c => {
+        try {
+          if (c.hidden) {
+            this.log(`${c.id} (hidden)`)
+          } else {
+            const results = Object.keys(c.flags).map((f: string) => {
+              let out = `--${f}`
+              const flag = c.flags[f]
+              if (flag.type === 'option') out += '='
+              const hasCompletion = 'completion' in flag || this.findCompletion(c.id, f, flag.description)
+              if (hasCompletion) {
+                out += '(c)'
+              }
+
+              if (flag.hidden) out += '(h)'
+              return out
+            })
+            if (results.length > 0) this.log(`${c.id} -> ${results}`)
+          }
+        } catch {
+          this.log(`Error creating autocomplete for command ${c.id}`)
+        }
+      })
+    })
+  }
+}
+*/

package/lib/oldCommands/autocomplete/index.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/oldCommands/autocomplete/index.js

@@ -0,0 +1,80 @@
+export {};
+/*
+import {flags} from '@heroku-cli/command'
+import {AppCompletion, PipelineCompletion, SpaceCompletion, TeamCompletion} from '@heroku-cli/command/lib/completions'
+import chalk from 'chalk'
+import {Args, ux} from '@oclif/core'
+import {FlagInput} from '@oclif/core/lib/interfaces/parser'
+
+import * as path from 'path'
+
+import {AutocompleteBase} from '../../lib/autocomplete/base'
+import {updateCache} from '../../lib/autocomplete/cache'
+
+import Create from './create'
+
+export default class Index extends AutocompleteBase {
+  static description = 'display autocomplete installation instructions'
+
+  static args = {
+    shell: Args.string({description: 'shell type', required: false}),
+  }
+
+  static flags: FlagInput = {
+    'refresh-cache': flags.boolean({description: 'refresh cache only (ignores displaying instructions)', char: 'r'}),
+  }
+
+  static examples = [
+    '$ heroku autocomplete',
+    '$ heroku autocomplete bash',
+    '$ heroku autocomplete zsh',
+    '$ heroku autocomplete --refresh-cache',
+  ]
+
+  async run() {
+    const {args, flags} = await this.parse(Index)
+    const shell = args.shell || this.config.shell
+    this.errorIfNotSupportedShell(shell)
+
+    ux.action.start(`${chalk.bold('Building the autocomplete cache')}`)
+    await Create.run([], this.config)
+    await this.updateCache(AppCompletion, 'app')
+    await this.updateCache(PipelineCompletion, 'pipeline')
+    await this.updateCache(SpaceCompletion, 'space')
+    await this.updateCache(TeamCompletion, 'team')
+    ux.action.stop()
+
+    if (!flags['refresh-cache']) {
+      const bin = this.config.bin
+      const bashNote = 'If your terminal starts as a login shell you may need to print the init script into ~/.bash_profile or ~/.profile.'
+      const zshNote = `After sourcing, you can run \`${chalk.cyan('$ compaudit -D')}\` to ensure no permissions conflicts are present`
+      const note = shell === 'zsh' ? zshNote : bashNote
+      const tabStr = shell === 'bash' ? '<TAB><TAB>' : '<TAB>'
+
+      this.log(`
+${chalk.bold(`Setup Instructions for ${bin.toUpperCase()} CLI Autocomplete ---`)}
+
+1) Add the autocomplete env var to your ${shell} profile and source it
+${chalk.cyan(`$ printf "$(${bin} autocomplete:script ${shell})" >> ~/.${shell}rc; source ~/.${shell}rc`)}
+
+NOTE: ${note}
+
+2) Test it out, e.g.:
+${chalk.cyan(`$ ${bin} ${tabStr}`)}                 # Command completion
+${chalk.cyan(`$ ${bin} apps:info --${tabStr}`)}     # Flag completion
+${chalk.cyan(`$ ${bin} apps:info --app=${tabStr}`)} # Flag option completion
+
+Visit the autocomplete Dev Center doc at https://devcenter.heroku.com/articles/heroku-cli-autocomplete
+
+Enjoy!
+`)
+    }
+  }
+
+  private async updateCache(completion: any, cacheKey: string) {
+    const cachePath = path.join(this.completionsCacheDir, cacheKey)
+    const options = await completion.options({config: this.config})
+    await updateCache(cachePath, options)
+  }
+}
+*/

package/lib/oldCommands/autocomplete/options.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/oldCommands/autocomplete/options.js

@@ -0,0 +1,240 @@
+export {};
+/*
+import {flags} from '@heroku-cli/command'
+import {Args, Command} from '@oclif/core'
+import * as path from 'path'
+
+import {AutocompleteBase} from '../../lib/autocomplete/base'
+import {fetchCache} from '../../lib/autocomplete/cache'
+
+export default class Options extends AutocompleteBase {
+  static hidden = true
+
+  static description = 'display arg or flag completion options (used internally by completion functions)'
+
+  static flags = {
+    app: flags.app({required: false, hidden: true}),
+  }
+
+  static args = {
+    completion: Args.string({strict: false}),
+  }
+
+  parsedArgs: { [name: string]: string } = {}
+
+  parsedFlags: { [name: string]: string } = {}
+
+  // helpful dictionary
+  //
+  // *args: refers to a Command's static args
+  // *argv: refers to the current execution's command line positional input
+  // Klass: (class) Command class
+  // completion: (object) object with data/methods to build/retrieve options from cache
+  // curPosition*: the current argv position the shell is trying to complete
+  // options: (string) white-space separated list of values for the shell to use for completion
+
+  async run() {
+    this.errorIfWindows()
+
+    // ex: heroku autocomplete:options 'heroku addons:destroy -a myapp myaddon'
+    try {
+      const commandStateVars = await this.processCommandLine()
+      const completion = this.determineCompletion(commandStateVars)
+      const options = await this.fetchOptions(completion)
+      if (options) this.log(options)
+    } catch (error: any) {
+      // write to ac log
+      this.writeLogFile(error.message)
+    }
+  }
+
+  private async processCommandLine() {
+    // find command id
+    const commandLineToComplete = this.argv[0].split(' ')
+    const id = commandLineToComplete[1]
+    // find Command
+    const C = this.config.findCommand(id)
+    let Klass
+    if (C) {
+      Klass = await C.load()
+      // process Command state from command line data
+      const slicedArgv = commandLineToComplete.slice(2)
+      const [argsIndex, curPositionIsFlag, curPositionIsFlagValue] = this.determineCmdState(slicedArgv, Klass)
+      return {id, Klass, argsIndex, curPositionIsFlag, curPositionIsFlagValue, slicedArgv}
+    }
+
+    this.throwError(`Command ${id} not found`)
+  }
+
+  private determineCompletion(commandStateVars: any) {
+    const {id, Klass, argsIndex, curPositionIsFlag, curPositionIsFlagValue, slicedArgv} = commandStateVars
+    // setup empty cache completion vars to assign
+    let cacheKey: any
+    let cacheCompletion: any
+
+    // completing a flag/value? else completing an arg
+    if (curPositionIsFlag || curPositionIsFlagValue) {
+      const slicedArgvCount = slicedArgv.length
+      const lastArgvArg = slicedArgv[slicedArgvCount - 1]
+      const previousArgvArg = slicedArgv[slicedArgvCount - 2]
+      const argvFlag = curPositionIsFlagValue ? previousArgvArg : lastArgvArg
+      const {name, flag} = this.findFlagFromWildArg(argvFlag, Klass)
+      if (!flag) this.throwError(`${argvFlag} is not a valid flag for ${id}`)
+      cacheKey = name || flag.name
+      cacheCompletion = flag.completion
+    } else {
+      const cmdArgs = Klass.args || []
+      // variable arg (strict: false)
+      if (!Klass.strict) {
+        cacheKey = cmdArgs[0] && cmdArgs[0].name.toLowerCase()
+        cacheCompletion = this.findCompletion(cacheKey, id)
+        if (!cacheCompletion) this.throwError(`Cannot complete variable arg position for ${id}`)
+      } else if (argsIndex > cmdArgs.length - 1) {
+        this.throwError(`Cannot complete arg position ${argsIndex} for ${id}`)
+      } else {
+        const arg = cmdArgs[argsIndex]
+        cacheKey = arg.name.toLowerCase()
+      }
+    }
+
+    // try to auto-populate the completion object
+    if (!cacheCompletion) {
+      cacheCompletion = this.findCompletion(cacheKey, id)
+    }
+
+    return {cacheKey, cacheCompletion}
+  }
+
+  private async fetchOptions(cache: any) {
+    const {cacheCompletion, cacheKey} = cache
+    const flags = await this.parsedFlagsWithEnvVars()
+
+    // build/retrieve & return options cache
+    if (cacheCompletion && cacheCompletion.options) {
+      const ctx = {
+        args: this.parsedArgs,
+        // special case for app & team env vars
+        flags,
+        argv: this.argv,
+        config: this.config,
+      }
+      // use cacheKey function or fallback to arg/flag name
+      const ckey = cacheCompletion.cacheKey ? await cacheCompletion.cacheKey(ctx) : null
+      const key: string = ckey || cacheKey || 'unknown_key_error'
+      const flagCachePath = path.join(this.completionsCacheDir, key)
+
+      // build/retrieve cache
+      const duration = cacheCompletion.cacheDuration || 60 * 60 * 24 // 1 day
+      const opts = {cacheFn: () => cacheCompletion.options(ctx)}
+      const options = await fetchCache(flagCachePath, duration, opts)
+
+      // return options cache
+      return (options || []).join('\n')
+    }
+  }
+
+  private async parsedFlagsWithEnvVars() {
+    const {flags} = await this.parse(Options)
+    return {
+      app: process.env.HEROKU_APP || flags.app,
+      team: process.env.HEROKU_TEAM || process.env.HEROKU_ORG,
+      ...this.parsedFlags,
+    }
+  }
+
+  private throwError(msg: string) {
+    throw new Error(msg)
+  }
+
+  private findFlagFromWildArg(wild: string, Klass: Command.Class): { flag: any; name: any } {
+    let name = wild.replace(/^-+/, '')
+    name = name.replace(/[=](.+)?$/, '')
+
+    const unknown = {flag: undefined, name: undefined}
+    if (!Klass.flags) return unknown
+    const CFlags = Klass.flags
+
+    let flag = CFlags[name]
+    if (flag) return {name, flag}
+
+    name = Object.keys(CFlags).find((k: string) => CFlags[k].char === name) || 'undefinedcommand'
+    flag = CFlags && CFlags[name]
+    if (flag) return {name, flag}
+    return unknown
+  }
+
+  private determineCmdState(argv: string[], Klass: Command.Class): [number, boolean, boolean] {
+    const argNames = Object.keys(Klass.args || {})
+    let needFlagValueSatisfied = false
+    let argIsFlag = false
+    let argIsFlagValue = false
+    let argsIndex = -1
+    let flagName: string
+
+    argv.filter(wild => {
+      if (wild.match(/^-(-)?/)) {
+        // we're a flag
+        argIsFlag = true
+
+        // ignore me
+        const wildSplit = wild.split('=')
+        const key = wildSplit.length === 1 ? wild : wildSplit[0]
+        const {name, flag} = this.findFlagFromWildArg(key, Klass)
+        flagName = name
+        // end ignore me
+
+        if (wildSplit.length === 1) {
+          // we're a flag w/o a '=value'
+          // (find flag & see if flag needs a value)
+          if (flag && flag.type !== 'boolean') {
+            // we're a flag who needs our value to be next
+            argIsFlagValue = false
+            needFlagValueSatisfied = true
+            return false
+          }
+        }
+
+        // --app=my-app is considered a flag & not a flag value
+        // the shell's autocomplete handles partial value matching
+
+        // add parsedFlag
+        if (wildSplit.length === 2 && name) this.parsedFlags[name] = wildSplit[1]
+
+        // we're a flag who is satisfied
+        argIsFlagValue = false
+        needFlagValueSatisfied = false
+        return false
+      }
+
+      // we're not a flag
+      argIsFlag = false
+
+      if (needFlagValueSatisfied) {
+        // we're a flag value
+
+        // add parsedFlag
+        if (flagName) this.parsedFlags[flagName] = wild
+
+        argIsFlagValue = true
+        needFlagValueSatisfied = false
+        return false
+      }
+
+      // we're an arg!
+
+      // add parsedArgs
+      // TO-DO: how to handle variableArgs?
+      argsIndex += 1
+      if (argsIndex < argNames.length) {
+        this.parsedArgs[argNames[argsIndex]] = wild
+      }
+
+      argIsFlagValue = false
+      needFlagValueSatisfied = false
+      return true
+    })
+
+    return [argsIndex, argIsFlag, argIsFlagValue]
+  }
+}
+*/

package/lib/oldCommands/autocomplete/script.d.ts

@@ -0,0 +1 @@
+export {};