heroku 8.1.8 → 8.2.0-beta.0

package/lib/commands/authorizations/rotate.d.ts

@@ -0,0 +1,8 @@
+import { Command } from '@heroku-cli/command';
+export default class AuthorizationsRotate extends Command {
+    static description: string;
+    static args: {
+        id: import("@oclif/core/lib/interfaces/parser").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/authorizations/rotate.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const authorizations_1 = require("../../lib/authorizations/authorizations");
+class AuthorizationsRotate extends command_1.Command {
+    async run() {
+        const { args } = await this.parse(AuthorizationsRotate);
+        core_1.ux.action.start('Rotating OAuth Authorization');
+        const { body: authorization } = await this.heroku.post(`/oauth/authorizations/${encodeURIComponent(args.id)}/actions/regenerate-tokens`);
+        core_1.ux.action.stop();
+        (0, authorizations_1.display)(authorization);
+    }
+}
+exports.default = AuthorizationsRotate;
+AuthorizationsRotate.description = 'updates an OAuth authorization token';
+AuthorizationsRotate.args = {
+    id: core_1.Args.string({ required: true }),
+};

package/lib/commands/authorizations/update.d.ts

@@ -0,0 +1,13 @@
+import { Command } from '@heroku-cli/command';
+export default class AuthorizationsUpdate extends Command {
+    static description: string;
+    static flags: {
+        description: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        'client-id': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        'client-secret': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    static args: {
+        id: import("@oclif/core/lib/interfaces/parser").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/authorizations/update.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const authorizations_1 = require("../../lib/authorizations/authorizations");
+class AuthorizationsUpdate extends command_1.Command {
+    async run() {
+        const { args, flags } = await this.parse(AuthorizationsUpdate);
+        core_1.ux.action.start('Updating OAuth Authorization');
+        let client;
+        if (flags['client-id']) {
+            client = {
+                id: flags['client-id'],
+                secret: flags['client-secret'],
+            };
+        }
+        const { body: authentication } = await this.heroku.patch(`/oauth/authorizations/${args.id}`, {
+            body: {
+                description: flags.description,
+                client,
+            },
+        });
+        core_1.ux.action.stop();
+        (0, authorizations_1.display)(authentication);
+    }
+}
+exports.default = AuthorizationsUpdate;
+AuthorizationsUpdate.description = 'updates an OAuth authorization';
+AuthorizationsUpdate.flags = {
+    description: command_1.flags.string({ char: 'd', description: 'set a custom authorization description' }),
+    'client-id': command_1.flags.string({ description: 'identifier of OAuth client to set', dependsOn: ['client-secret'] }),
+    'client-secret': command_1.flags.string({ description: 'secret of OAuth client to set', dependsOn: ['client-id'] }),
+};
+AuthorizationsUpdate.args = {
+    id: core_1.Args.string({ required: true }),
+};

package/lib/commands/autocomplete/create.d.ts

@@ -0,0 +1,29 @@
+import { AutocompleteBase } from '../../lib/autocomplete/base';
+export default class Create extends AutocompleteBase {
+    static hidden: boolean;
+    static description: string;
+    private _commands?;
+    run(): Promise<void>;
+    private ensureDirs;
+    private createFiles;
+    private get bashSetupScriptPath();
+    private get bashCommandsListPath();
+    private get zshSetupScriptPath();
+    private get zshCompletionSettersPath();
+    private get skipEllipsis();
+    private get commands();
+    private get bashCommandsList();
+    private get zshCompletionSetters();
+    private get zshCommandsSetter();
+    private get zshCommandsFlagsSetters();
+    private genCmdPublicFlags;
+    private genCmdWithDescription;
+    private genZshCmdFlagsSetter;
+    private genZshAllCmdsListSetter;
+    private get envAnalyticsDir();
+    private get envCommandsPath();
+    private get bashSetupScript();
+    private get zshSetupScript();
+    private get completionDotsFunc();
+    private wantsLocalFiles;
+}

package/lib/commands/autocomplete/create.js

@@ -0,0 +1,213 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = require("fs-extra");
+const path = require("path");
+const base_1 = require("../../lib/autocomplete/base");
+const debug = require('debug')('autocomplete:create');
+const AC_LIB_PATH = path.resolve(__dirname, '..', '..', '..', 'autocomplete-scripts');
+class Create extends base_1.AutocompleteBase {
+    async run() {
+        this.errorIfWindows();
+        // 1. ensure needed dirs
+        await this.ensureDirs();
+        // 2. save (generated) autocomplete files
+        await this.createFiles();
+    }
+    async ensureDirs() {
+        // ensure autocomplete cache dir
+        await fs.ensureDir(this.autocompleteCacheDir);
+        // ensure autocomplete completions dir
+        await fs.ensureDir(this.completionsCacheDir);
+    }
+    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);
+    }
+    get bashSetupScriptPath() {
+        // <cacheDir>/autocomplete/bash_setup
+        return path.join(this.autocompleteCacheDir, 'bash_setup');
+    }
+    get bashCommandsListPath() {
+        // <cacheDir>/autocomplete/commands
+        return path.join(this.autocompleteCacheDir, 'commands');
+    }
+    get zshSetupScriptPath() {
+        // <cacheDir>/autocomplete/zsh_setup
+        return path.join(this.autocompleteCacheDir, 'zsh_setup');
+    }
+    get zshCompletionSettersPath() {
+        // <cacheDir>/autocomplete/commands_setters
+        return path.join(this.autocompleteCacheDir, 'commands_setters');
+    }
+    get skipEllipsis() {
+        return process.env.HEROKU_AC_ZSH_SKIP_ELLIPSIS === '1';
+    }
+    get commands() {
+        if (this._commands)
+            return this._commands;
+        const plugins = this.config.plugins;
+        const commands = [];
+        plugins.forEach(p => {
+            p.commands.forEach(c => {
+                if (c.hidden)
+                    return;
+                try {
+                    commands.push(c);
+                }
+                catch (error) {
+                    debug(`Error creating completions for command ${c.id}`);
+                    debug(error.message);
+                    this.writeLogFile(error.message);
+                }
+            });
+        });
+        this._commands = commands;
+        return this._commands;
+    }
+    get bashCommandsList() {
+        return this.commands.map(c => {
+            try {
+                const publicFlags = this.genCmdPublicFlags(c).trim();
+                return `${c.id} ${publicFlags}`;
+            }
+            catch (error) {
+                debug(`Error creating bash completion for command ${c.id}, moving on...`);
+                debug(error.message);
+                this.writeLogFile(error.message);
+                return '';
+            }
+        }).join('\n');
+    }
+    get zshCompletionSetters() {
+        const cmdsSetter = this.zshCommandsSetter;
+        const flagSetters = this.zshCommandsFlagsSetters;
+        return `${cmdsSetter}\n${flagSetters}`;
+    }
+    get zshCommandsSetter() {
+        const cmdsWithDescriptions = this.commands.map(c => {
+            try {
+                return this.genCmdWithDescription(c);
+            }
+            catch (error) {
+                debug(`Error creating zsh autocomplete for command ${c.id}, moving on...`);
+                debug(error.message);
+                this.writeLogFile(error.message);
+                return '';
+            }
+        });
+        return this.genZshAllCmdsListSetter(cmdsWithDescriptions);
+    }
+    get zshCommandsFlagsSetters() {
+        return this.commands.map(c => {
+            try {
+                return this.genZshCmdFlagsSetter(c);
+            }
+            catch (error) {
+                debug(`Error creating zsh autocomplete for command ${c.id}, moving on...`);
+                debug(error.message);
+                this.writeLogFile(error.message);
+                return '';
+            }
+        }).join('\n');
+    }
+    genCmdPublicFlags(command) {
+        const Flags = command.flags || {};
+        return Object.keys(Flags)
+            .filter(flag => !Flags[flag].hidden)
+            .map(flag => `--${flag}`)
+            .join(' ');
+    }
+    genCmdWithDescription(command) {
+        let description = '';
+        if (command.description) {
+            const text = command.description.split('\n')[0];
+            description = `:"${text}"`;
+        }
+        return `"${command.id.replace(/:/g, '\\:')}"${description}`;
+    }
+    genZshCmdFlagsSetter(command) {
+        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}`;
+    }
+    genZshAllCmdsListSetter(cmdsWithDesc) {
+        return `
+_set_all_commands_list () {
+_all_commands_list=(
+${cmdsWithDesc.join('\n')}
+)
+}
+`;
+    }
+    get envAnalyticsDir() {
+        return `HEROKU_AC_ANALYTICS_DIR=${path.join(this.autocompleteCacheDir, 'completion_analytics')};`;
+    }
+    get envCommandsPath() {
+        return `HEROKU_AC_COMMANDS_PATH=${path.join(this.autocompleteCacheDir, 'commands')};`;
+    }
+    get bashSetupScript() {
+        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;
+`;
+    }
+    get zshSetupScript() {
+        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;
+`;
+    }
+    get completionDotsFunc() {
+        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`;
+    }
+    wantsLocalFiles(flag) {
+        return [
+            'file',
+            'procfile',
+        ].includes(flag);
+    }
+}
+exports.default = Create;
+Create.hidden = true;
+Create.description = 'create autocomplete setup scripts and completion functions';

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

@@ -0,0 +1,12 @@
+import { FlagInput } from '@oclif/core/lib/interfaces/parser';
+import { AutocompleteBase } from '../../lib/autocomplete/base';
+export default class Doctor extends AutocompleteBase {
+    static hidden: boolean;
+    static description: string;
+    static args: {
+        shell: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: FlagInput;
+    run(): Promise<void>;
+    private printList;
+}

package/lib/commands/autocomplete/doctor.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const fs = require("fs-extra");
+const path = require("path");
+const base_1 = require("../../lib/autocomplete/base");
+class Doctor extends base_1.AutocompleteBase {
+    async run() {
+        const { args, flags } = await this.parse(Doctor);
+        const shell = args.shell || this.config.shell;
+        const printLine = (...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 shimVlaue = regex.exec(shellProfile.toString()) ? 'present' : 'missing';
+        data.push({ name: `~/${shell === 'zsh' ? '.zshrc' : '.bashrc'} shimmed`, value: shimVlaue });
+        // 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 });
+        core_1.ux.table(data, {
+            name: {},
+            value: {},
+        }, { 'no-header': true, printLine });
+        if (flags.verbose)
+            this.printList();
+    }
+    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) => {
+                            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 (_a) {
+                    this.log(`Error creating autocomplete for command ${c.id}`);
+                }
+            });
+        });
+    }
+}
+exports.default = Doctor;
+Doctor.hidden = true;
+Doctor.description = 'autocomplete diagnostic';
+Doctor.args = {
+    shell: core_1.Args.string({ description: 'shell type', required: false }),
+};
+Doctor.flags = {
+    verbose: command_1.flags.boolean({ description: 'list completable commands' }),
+};

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

@@ -0,0 +1,12 @@
+import { FlagInput } from '@oclif/core/lib/interfaces/parser';
+import { AutocompleteBase } from '../../lib/autocomplete/base';
+export default class Index extends AutocompleteBase {
+    static description: string;
+    static args: {
+        shell: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: FlagInput;
+    static examples: string[];
+    run(): Promise<void>;
+    private updateCache;
+}

package/lib/commands/autocomplete/index.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const completions_1 = require("@heroku-cli/command/lib/completions");
+const chalk_1 = require("chalk");
+const core_1 = require("@oclif/core");
+const path = require("path");
+const base_1 = require("../../lib/autocomplete/base");
+const cache_1 = require("../../lib/autocomplete/cache");
+const create_1 = require("./create");
+class Index extends base_1.AutocompleteBase {
+    async run() {
+        const { args, flags } = await this.parse(Index);
+        const shell = args.shell || this.config.shell;
+        this.errorIfNotSupportedShell(shell);
+        core_1.ux.action.start(`${chalk_1.default.bold('Building the autocomplete cache')}`);
+        await create_1.default.run([], this.config);
+        await this.updateCache(completions_1.AppCompletion, 'app');
+        await this.updateCache(completions_1.PipelineCompletion, 'pipeline');
+        await this.updateCache(completions_1.SpaceCompletion, 'space');
+        await this.updateCache(completions_1.TeamCompletion, 'team');
+        core_1.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_1.default.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_1.default.bold(`Setup Instructions for ${bin.toUpperCase()} CLI Autocomplete ---`)}
+
+1) Add the autocomplete env var to your ${shell} profile and source it
+${chalk_1.default.cyan(`$ printf "$(${bin} autocomplete:script ${shell})" >> ~/.${shell}rc; source ~/.${shell}rc`)}
+
+NOTE: ${note}
+
+2) Test it out, e.g.:
+${chalk_1.default.cyan(`$ ${bin} ${tabStr}`)}                 # Command completion
+${chalk_1.default.cyan(`$ ${bin} apps:info --${tabStr}`)}     # Flag completion
+${chalk_1.default.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!
+`);
+        }
+    }
+    async updateCache(completion, cacheKey) {
+        const cachePath = path.join(this.completionsCacheDir, cacheKey);
+        const options = await completion.options({ config: this.config });
+        await (0, cache_1.updateCache)(cachePath, options);
+    }
+}
+exports.default = Index;
+Index.description = 'display autocomplete installation instructions';
+Index.args = {
+    shell: core_1.Args.string({ description: 'shell type', required: false }),
+};
+Index.flags = {
+    'refresh-cache': command_1.flags.boolean({ description: 'refresh cache only (ignores displaying instructions)', char: 'r' }),
+};
+Index.examples = [
+    '$ heroku autocomplete',
+    '$ heroku autocomplete bash',
+    '$ heroku autocomplete zsh',
+    '$ heroku autocomplete --refresh-cache',
+];

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

@@ -0,0 +1,25 @@
+import { AutocompleteBase } from '../../lib/autocomplete/base';
+export default class Options extends AutocompleteBase {
+    static hidden: boolean;
+    static description: string;
+    static flags: {
+        app: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    static args: {
+        completion: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+    };
+    parsedArgs: {
+        [name: string]: string;
+    };
+    parsedFlags: {
+        [name: string]: string;
+    };
+    run(): Promise<void>;
+    private processCommandLine;
+    private determineCompletion;
+    private fetchOptions;
+    private parsedFlagsWithEnvVars;
+    private throwError;
+    private findFlagFromWildArg;
+    private determineCmdState;
+}