heroku 8.1.9 → 8.2.0-beta.1

package/lib/commands/autocomplete/options.js

@@ -0,0 +1,210 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const path = require("path");
+const base_1 = require("../../lib/autocomplete/base");
+const cache_1 = require("../../lib/autocomplete/cache");
+class Options extends base_1.AutocompleteBase {
+    constructor() {
+        super(...arguments);
+        this.parsedArgs = {};
+        this.parsedFlags = {};
+    }
+    // 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/retrive options from cache
+    // curPosition*: the current argv position the shell is trying to complete
+    // options: (string) white-space seperated 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) {
+            // write to ac log
+            this.writeLogFile(error.message);
+        }
+    }
+    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`);
+    }
+    determineCompletion(commandStateVars) {
+        const { id, Klass, argsIndex, curPositionIsFlag, curPositionIsFlagValue, slicedArgv } = commandStateVars;
+        // setup empty cache completion vars to assign
+        let cacheKey;
+        let cacheCompletion;
+        // 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 };
+    }
+    async fetchOptions(cache) {
+        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 = 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 (0, cache_1.fetchCache)(flagCachePath, duration, opts);
+            // return options cache
+            return (options || []).join('\n');
+        }
+    }
+    async parsedFlagsWithEnvVars() {
+        const { flags } = await this.parse(Options);
+        return Object.assign({ app: process.env.HEROKU_APP || flags.app, team: process.env.HEROKU_TEAM || process.env.HEROKU_ORG }, this.parsedFlags);
+    }
+    throwError(msg) {
+        throw new Error(msg);
+    }
+    findFlagFromWildArg(wild, Klass) {
+        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) => CFlags[k].char === name) || 'undefinedcommand';
+        flag = CFlags && CFlags[name];
+        if (flag)
+            return { name, flag };
+        return unknown;
+    }
+    determineCmdState(argv, Klass) {
+        const argNames = Object.keys(Klass.args || {});
+        let needFlagValueSatisfied = false;
+        let argIsFlag = false;
+        let argIsFlagValue = false;
+        let argsIndex = -1;
+        let flagName;
+        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 consided 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];
+    }
+}
+exports.default = Options;
+Options.hidden = true;
+Options.description = 'display arg or flag completion options (used internally by completion functions)';
+Options.flags = {
+    app: command_1.flags.app({ required: false, hidden: true }),
+};
+Options.args = {
+    completion: core_1.Args.string({ strict: false }),
+};

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

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

package/lib/commands/autocomplete/script.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const path = require("path");
+const base_1 = require("../../lib/autocomplete/base");
+class Script extends base_1.AutocompleteBase {
+    async run() {
+        const { args } = await this.parse(Script);
+        const shell = args.shell || this.config.shell;
+        this.errorIfNotSupportedShell(shell);
+        const shellUpcase = shell.toUpperCase();
+        this.log(`${this.prefix}HEROKU_AC_${shellUpcase}_SETUP_PATH=${path.join(this.autocompleteCacheDir, `${shell}_setup`)} && test -f $HEROKU_AC_${shellUpcase}_SETUP_PATH && source $HEROKU_AC_${shellUpcase}_SETUP_PATH;`);
+    }
+    get prefix() {
+        return `\n# ${this.config.bin} autocomplete setup\n`;
+    }
+}
+exports.default = Script;
+Script.description = 'display autocomplete setup script for shell';
+Script.hidden = true;
+Script.args = {
+    shell: core_1.Args.string({ description: 'shell type', required: false }),
+};

package/lib/commands/buildpacks/add.d.ts

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

package/lib/commands/buildpacks/add.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const buildpacks_1 = require("../../lib/buildpacks/buildpacks");
+class Add extends command_1.Command {
+    async run() {
+        const { args, flags } = await this.parse(Add);
+        const buildpackCommand = new buildpacks_1.BuildpackCommand(this.heroku);
+        if (flags.index !== undefined) {
+            buildpackCommand.validateIndex(flags.index);
+        }
+        const buildpacks = await buildpackCommand.fetch(flags.app);
+        await buildpackCommand.validateUrlNotSet(buildpacks, args.buildpack);
+        let spliceIndex;
+        if (flags.index === undefined) {
+            spliceIndex = buildpacks.length;
+        }
+        else {
+            // eslint-disable-next-line unicorn/no-array-callback-reference, unicorn/no-array-method-this-argument
+            const foundIndex = buildpackCommand.findIndex(buildpacks, flags.index);
+            spliceIndex = (foundIndex === -1) ? buildpacks.length : foundIndex;
+        }
+        const buildpackUpdates = await buildpackCommand.mutate(flags.app, buildpacks, spliceIndex, args.buildpack, 'add');
+        buildpackCommand.displayUpdate(flags.app, flags.remote || '', buildpackUpdates, 'added');
+    }
+}
+exports.default = Add;
+Add.description = 'add new app buildpack, inserting into list of buildpacks if necessary';
+Add.flags = {
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+    index: command_1.flags.integer({
+        description: 'the 1-based index of the URL in the list of URLs',
+        char: 'i',
+    }),
+};
+Add.args = {
+    buildpack: core_1.Args.string({
+        required: true,
+        description: 'namespace/name of the buildpack',
+    }),
+};

package/lib/commands/buildpacks/clear.d.ts

@@ -0,0 +1,9 @@
+import { Command } from '@heroku-cli/command';
+export default class Clear extends Command {
+    static description: string;
+    static flags: {
+        app: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        remote: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/buildpacks/clear.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const buildpacks_1 = require("../../lib/buildpacks/buildpacks");
+class Clear extends command_1.Command {
+    async run() {
+        const { flags } = await this.parse(Clear);
+        const buildpackCommand = new buildpacks_1.BuildpackCommand(this.heroku);
+        await buildpackCommand.clear(flags.app, 'clear', 'cleared');
+    }
+}
+exports.default = Clear;
+Clear.description = 'clear all buildpacks set on the app';
+Clear.flags = {
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};

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

@@ -0,0 +1,9 @@
+import { Command } from '@heroku-cli/command';
+export default class Index extends Command {
+    static description: string;
+    static flags: {
+        app: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        remote: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/buildpacks/index.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const buildpacks_1 = require("../../lib/buildpacks/buildpacks");
+class Index extends command_1.Command {
+    async run() {
+        const { flags } = await this.parse(Index);
+        const buildpacksCommand = new buildpacks_1.BuildpackCommand(this.heroku);
+        const buildpacks = await buildpacksCommand.fetch(flags.app);
+        if (buildpacks.length === 0) {
+            this.log(`${flags.app} has no Buildpack URL set.`);
+        }
+        else {
+            core_1.ux.styledHeader(`${flags.app} Buildpack URL${buildpacks.length > 1 ? 's' : ''}`);
+            buildpacksCommand.display(buildpacks, '');
+        }
+    }
+}
+exports.default = Index;
+Index.description = 'display the buildpacks for an app';
+Index.flags = {
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};

package/lib/commands/buildpacks/info.d.ts

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

package/lib/commands/buildpacks/info.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const true_myth_1 = require("true-myth");
+const buildpack_registry_1 = require("@heroku/buildpack-registry");
+class Info extends command_1.Command {
+    async run() {
+        const { args } = await this.parse(Info);
+        const registry = new buildpack_registry_1.BuildpackRegistry();
+        true_myth_1.Result.match({
+            Ok: _ => { },
+            Err: err => {
+                this.error(`Could not publish the buildpack.\n${err}`);
+            },
+        }, buildpack_registry_1.BuildpackRegistry.isValidBuildpackSlug(args.buildpack));
+        const result = await registry.info(args.buildpack);
+        true_myth_1.Result.match({
+            Ok: buildpack => {
+                core_1.ux.styledHeader(args.buildpack);
+                core_1.ux.styledObject(buildpack, ['description', 'category', 'license', 'support', 'source', 'readme']);
+            },
+            Err: err => {
+                if (err.status === 404) {
+                    core_1.ux.error(`Could not find the buildpack '${args.buildpack}'`);
+                }
+                else {
+                    core_1.ux.error(`Problems finding buildpack info: ${err.description}`);
+                }
+            },
+        }, result);
+    }
+}
+exports.default = Info;
+Info.description = 'fetch info about a buildpack';
+Info.args = {
+    buildpack: core_1.Args.string({
+        required: true,
+        description: 'namespace/name of the buildpack',
+    }),
+};

package/lib/commands/buildpacks/remove.d.ts

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

package/lib/commands/buildpacks/remove.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const buildpacks_1 = require("../../lib/buildpacks/buildpacks");
+class Remove extends command_1.Command {
+    async run() {
+        const { args, flags } = await this.parse(Remove);
+        const buildpackCommand = new buildpacks_1.BuildpackCommand(this.heroku);
+        if (flags.index && args.buildpack) {
+            core_1.ux.error('Please choose either index or Buildpack, but not both.', { exit: 1 });
+        }
+        if (!flags.index && !args.buildpack) {
+            core_1.ux.error('Usage: heroku buildpacks:remove [BUILDPACK_URL]. Must specify a buildpack to remove, either by index or URL.');
+        }
+        const buildpacks = await buildpackCommand.fetch(flags.app);
+        if (buildpacks.length === 0) {
+            core_1.ux.error(`No buildpacks were found. Next release on ${flags.app} will detect buildpack normally.`, { exit: 1 });
+        }
+        let spliceIndex;
+        if (flags.index) {
+            buildpackCommand.validateIndexInRange(buildpacks, flags.index);
+            // eslint-disable-next-line unicorn/no-array-method-this-argument
+            spliceIndex = await buildpackCommand.findIndex(buildpacks, flags.index);
+        }
+        else {
+            spliceIndex = await buildpackCommand.findUrl(buildpacks, args.buildpack);
+        }
+        if (spliceIndex === -1) {
+            core_1.ux.error('Buildpack not found. Nothing was removed.', { exit: 1 });
+        }
+        if (buildpacks.length === 1) {
+            await buildpackCommand.clear(flags.app, 'remove', 'removed');
+        }
+        else {
+            const buildpackUpdates = await buildpackCommand.mutate(flags.app, buildpacks, spliceIndex, args.buildpack, 'remove');
+            buildpackCommand.displayUpdate(flags.app, flags.remote || '', buildpackUpdates, 'removed');
+        }
+    }
+}
+exports.default = Remove;
+Remove.description = 'remove a buildpack set on the app';
+Remove.flags = {
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+    index: command_1.flags.integer({
+        description: 'the 1-based index of the URL to remove from the list of URLs',
+        char: 'i',
+    }),
+};
+Remove.args = {
+    buildpack: core_1.Args.string({
+        description: 'namespace/name of the buildpack',
+    }),
+};

package/lib/commands/buildpacks/search.d.ts

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

package/lib/commands/buildpacks/search.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const buildpack_registry_1 = require("@heroku/buildpack-registry");
+class Search extends command_1.Command {
+    async run() {
+        const { args, flags } = await this.parse(Search);
+        let searchResults;
+        const registry = new buildpack_registry_1.BuildpackRegistry();
+        if (args.term) {
+            const uniqueBuildpacks = new Map();
+            const array = ((await registry.search(args.term)).unwrapOr([]))
+                .concat((await registry.search(undefined, args.term)).unwrapOr([]))
+                .concat((await registry.search(undefined, undefined, args.term)).unwrapOr([]));
+            array
+                .forEach((element) => {
+                uniqueBuildpacks.set(`${element.namespace}/${element.name}`, element);
+            });
+            searchResults = [...uniqueBuildpacks.values()];
+        }
+        else {
+            searchResults = (await registry.search(flags.namespace, flags.name, flags.description)).unwrapOr([]);
+        }
+        const buildpacks = searchResults.map((buildpack) => {
+            return {
+                buildpack: `${buildpack.namespace}/${buildpack.name}`,
+                category: buildpack.category,
+                description: buildpack.description,
+            };
+        });
+        const displayTable = (buildpacks) => {
+            core_1.ux.table(buildpacks, {
+                buildpack: {
+                    header: 'Buildpack',
+                },
+                category: {
+                    header: 'Category',
+                },
+                description: {
+                    header: 'Description',
+                },
+            });
+        };
+        if (buildpacks.length === 0) {
+            core_1.ux.log('No buildpacks found');
+        }
+        else if (buildpacks.length === 1) {
+            displayTable(buildpacks);
+            core_1.ux.log('\n1 buildpack found');
+        }
+        else {
+            displayTable(buildpacks);
+            core_1.ux.log(`\n${buildpacks.length} buildpacks found`);
+        }
+    }
+}
+exports.default = Search;
+Search.description = 'search for buildpacks';
+Search.flags = {
+    namespace: command_1.flags.string({ description: 'buildpack namespaces to filter on using a comma separated list' }),
+    name: command_1.flags.string({ description: 'buildpack names to filter on using a comma separated list ' }),
+    description: command_1.flags.string({ description: 'buildpack description to filter on' }),
+};
+Search.args = {
+    term: core_1.Args.string({
+        description: 'search term that searches across name, namespace, and description',
+    }),
+};

package/lib/commands/buildpacks/set.d.ts

@@ -0,0 +1,13 @@
+import { Command } from '@heroku-cli/command';
+export default class Set extends Command {
+    static description: 'set new app buildpack, overwriting into list of buildpacks if necessary';
+    static flags: {
+        app: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        remote: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        index: import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    static args: {
+        buildpack: import("@oclif/core/lib/interfaces/parser").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/buildpacks/set.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const buildpacks_1 = require("../../lib/buildpacks/buildpacks");
+class Set extends command_1.Command {
+    async run() {
+        const { args, flags } = await this.parse(Set);
+        if (flags.index && flags.index < 0) {
+            this.error('Invalid index. Must be greater than 0.');
+        }
+        const buildpackCommand = new buildpacks_1.BuildpackCommand(this.heroku);
+        const buildpacks = await buildpackCommand.fetch(flags.app);
+        await buildpackCommand.validateUrlNotSet(buildpacks, args.buildpack);
+        let spliceIndex;
+        if (flags.index === undefined) {
+            spliceIndex = 0;
+        }
+        else {
+            // eslint-disable-next-line unicorn/no-array-callback-reference, unicorn/no-array-method-this-argument
+            const foundIndex = buildpackCommand.findIndex(buildpacks, flags.index);
+            spliceIndex = (foundIndex === -1) ? buildpacks.length : foundIndex;
+        }
+        const buildpackUpdates = await buildpackCommand.mutate(flags.app, buildpacks, spliceIndex, args.buildpack, 'set');
+        buildpackCommand.displayUpdate(flags.app, flags.remote || '', buildpackUpdates, 'set');
+    }
+}
+exports.default = Set;
+Set.flags = {
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+    index: command_1.flags.integer({
+        description: 'the 1-based index of the URL in the list of URLs',
+        char: 'i',
+    }),
+};
+Set.args = {
+    buildpack: core_1.Args.string({
+        required: true,
+        description: 'namespace/name of the buildpack',
+    }),
+};

package/lib/commands/buildpacks/versions.d.ts

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