heroku 9.0.0-dev.0 → 9.0.0

package/lib/commands/addons/docs.d.ts

@@ -0,0 +1,14 @@
+import { Command } from '@heroku-cli/command';
+export default class Docs extends Command {
+    static topic: string;
+    static description: string;
+    static flags: {
+        'show-url': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        app: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        remote: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    static args: {
+        addon: import("@oclif/core/lib/interfaces/parser").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/addons/docs.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const color_1 = require("@heroku-cli/color");
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const resolve_1 = require("../../lib/addons/resolve");
+const open = require("open");
+class Docs extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(Docs);
+        const { app } = flags;
+        const id = args.addon.split(':')[0];
+        const addonResponse = await this.heroku.get(`/addon-services/${encodeURIComponent(id)}`)
+            .catch(() => null);
+        const addon = (addonResponse === null || addonResponse === void 0 ? void 0 : addonResponse.body) ? addonResponse.body : (await (0, resolve_1.resolveAddon)(this.heroku, app, id)).addon_service;
+        const url = `https://devcenter.heroku.com/articles/${addon.name}`;
+        if (flags['show-url']) {
+            core_1.ux.log(url);
+        }
+        else {
+            core_1.ux.log(`Opening ${color_1.default.cyan(url)}...`);
+            await open(url);
+        }
+    }
+}
+exports.default = Docs;
+Docs.topic = 'addons';
+Docs.description = "open an add-on's Dev Center documentation in your browser";
+Docs.flags = {
+    'show-url': command_1.flags.boolean({ description: 'show URL, do not open browser' }),
+    app: command_1.flags.app(),
+    remote: command_1.flags.remote(),
+};
+Docs.args = {
+    addon: core_1.Args.string({ required: true }),
+};

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

@@ -0,0 +1,16 @@
+import { Command } from '@heroku-cli/command';
+import * as Heroku from '@heroku-cli/schema';
+export declare function renderAttachment(attachment: Heroku.AddOnAttachment, app: string, isFirst?: boolean): string;
+export default class Addons extends Command {
+    static topic: string;
+    static usage: string;
+    static description: string;
+    static flags: {
+        all: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        app: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        remote: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    static examples: string[];
+    run(): Promise<void>;
+}

package/lib/commands/addons/index.js

@@ -0,0 +1,246 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderAttachment = void 0;
+const color_1 = require("@heroku-cli/color");
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const util_1 = require("../../lib/addons/util");
+const lodash_1 = require("lodash");
+const printf = require('printf');
+const topic = 'addons';
+async function addonGetter(api, app) {
+    let attachmentsResponse = null;
+    let addonsResponse;
+    if (app) { // don't display attachments globally
+        addonsResponse = api.get(`/apps/${app}/addons`, {
+            headers: {
+                'Accept-Expansion': 'addon_service,plan',
+            },
+        });
+        const sudoHeaders = JSON.parse(process.env.HEROKU_HEADERS || '{}');
+        if (sudoHeaders['X-Heroku-Sudo'] && !sudoHeaders['X-Heroku-Sudo-User']) {
+            // because the root /addon-attachments endpoint won't include relevant
+            // attachments when sudo-ing for another app, we will use the more
+            // specific API call and sacrifice listing foreign attachments.
+            attachmentsResponse = api.get(`/apps/${app}/addon-attachments`);
+        }
+        else {
+            // In order to display all foreign attachments, we'll get out entire
+            // attachment list
+            attachmentsResponse = api.get('/addon-attachments');
+        }
+    }
+    else {
+        addonsResponse = api.get('/addons', {
+            headers: {
+                'Accept-Expansion': 'addon_service,plan',
+            },
+        });
+    }
+    // Get addons and attachments in parallel
+    const [{ body: addonsRaw }, potentialAttachments] = await Promise.all([addonsResponse, attachmentsResponse]);
+    function isRelevantToApp(addon) {
+        var _a;
+        return !app || ((_a = addon.app) === null || _a === void 0 ? void 0 : _a.name) === app || (0, lodash_1.some)(addon.attachments, att => att.app.name === app);
+    }
+    const groupedAttachments = (0, lodash_1.groupBy)(potentialAttachments === null || potentialAttachments === void 0 ? void 0 : potentialAttachments.body, 'addon.id');
+    const addons = [];
+    addonsRaw.forEach(function (addon) {
+        addon.attachments = groupedAttachments[addon.id] || [];
+        delete groupedAttachments[addon.id];
+        if (isRelevantToApp(addon)) {
+            addons.push(addon);
+        }
+        if (addon.plan) {
+            addon.plan.price = (0, util_1.grandfatheredPrice)(addon);
+        }
+    });
+    // Any attachments left didn't have a corresponding add-on record in API.
+    // This is probably normal (because we are asking API for all attachments)
+    // but it could also be due to certain types of permissions issues, so check
+    // if the attachment looks relevant to the app, and then render whatever
+    (0, lodash_1.values)(groupedAttachments)
+        .forEach(function (atts) {
+        const inaccessibleAddon = {
+            app: atts[0].addon.app, name: atts[0].addon.name, addon_service: {}, plan: {}, attachments: atts,
+        };
+        if (isRelevantToApp(inaccessibleAddon)) {
+            addons.push(inaccessibleAddon);
+        }
+    });
+    return addons;
+}
+function displayAll(addons) {
+    addons = (0, lodash_1.sortBy)(addons, 'app.name', 'plan.name', 'addon.name');
+    if (addons.length === 0) {
+        core_1.ux.log('No add-ons.');
+        return;
+    }
+    core_1.ux.table(addons, {
+        'Owning App': {
+            get: ({ app }) => color_1.default.cyan((app === null || app === void 0 ? void 0 : app.name) || ''),
+        },
+        'Add-on': {
+            get: ({ name }) => color_1.default.magenta(name || ''),
+        },
+        Plan: {
+            get: function ({ plan }) {
+                if (typeof plan === 'undefined')
+                    return color_1.default.dim('?');
+                return plan.name;
+            },
+        },
+        Price: {
+            get: function ({ plan }) {
+                if (typeof (plan === null || plan === void 0 ? void 0 : plan.price) === 'undefined')
+                    return color_1.default.dim('?');
+                return (0, util_1.formatPrice)({ price: plan === null || plan === void 0 ? void 0 : plan.price, hourly: true });
+            },
+        },
+        'Max Price': {
+            get: function ({ plan }) {
+                if (typeof (plan === null || plan === void 0 ? void 0 : plan.price) === 'undefined')
+                    return color_1.default.dim('?');
+                return (0, util_1.formatPrice)({ price: plan === null || plan === void 0 ? void 0 : plan.price, hourly: false });
+            },
+        },
+        State: {
+            get: function ({ state }) {
+                let result = state || '';
+                switch (state) {
+                    case 'provisioned':
+                        result = 'created';
+                        break;
+                    case 'provisioning':
+                        result = 'creating';
+                        break;
+                    case 'deprovisioned':
+                        result = 'errored';
+                }
+                return result;
+            },
+        },
+    });
+}
+function formatAttachment(attachment, showApp = true) {
+    var _a;
+    const attName = color_1.default.green(attachment.name || '');
+    const output = [color_1.default.dim('as'), attName];
+    if (showApp) {
+        const appInfo = `on ${color_1.default.cyan(((_a = attachment.app) === null || _a === void 0 ? void 0 : _a.name) || '')} app`;
+        output.push(color_1.default.dim(appInfo));
+    }
+    return output.join(' ');
+}
+function renderAttachment(attachment, app, isFirst = false) {
+    var _a;
+    const line = isFirst ? '\u2514\u2500' : '\u251C\u2500';
+    const attName = formatAttachment(attachment, ((_a = attachment.app) === null || _a === void 0 ? void 0 : _a.name) !== app);
+    return printf(' %s %s', color_1.default.dim(line), attName);
+}
+exports.renderAttachment = renderAttachment;
+function displayForApp(app, addons) {
+    if (addons.length === 0) {
+        core_1.ux.log(`No add-ons for app ${app}.`);
+        return;
+    }
+    const isForeignApp = (attOrAddon) => { var _a; return ((_a = attOrAddon.app) === null || _a === void 0 ? void 0 : _a.name) !== app; };
+    function presentAddon(addon) {
+        var _a;
+        const name = color_1.default.magenta(addon.name || '');
+        let service = (_a = addon.addon_service) === null || _a === void 0 ? void 0 : _a.name;
+        if (service === undefined) {
+            service = color_1.default.dim('?');
+        }
+        const addonLine = `${service} (${name})`;
+        const atts = (0, lodash_1.sortBy)(addon.attachments, isForeignApp, 'app.name', 'name');
+        // render each attachment under the add-on
+        const attLines = atts.map(function (attachment, idx) {
+            const isFirst = (idx === addon.attachments.length - 1);
+            return renderAttachment(attachment, app, isFirst);
+        });
+        return [addonLine].concat(attLines)
+            .join('\n') + '\n'; // Separate each add-on row by a blank line
+    }
+    addons = (0, lodash_1.sortBy)(addons, isForeignApp, 'plan.name', 'name');
+    core_1.ux.log();
+    core_1.ux.table(addons, {
+        'Add-on': { get: presentAddon },
+        Plan: {
+            get: ({ plan }) => plan && plan.name !== undefined ?
+                plan.name.replace(/^[^:]+:/, '') :
+                color_1.default.dim('?'),
+        },
+        Price: {
+            get: function (addon) {
+                var _a, _b, _c;
+                if (((_a = addon.app) === null || _a === void 0 ? void 0 : _a.name) === app) {
+                    return (0, util_1.formatPrice)({ price: (_b = addon.plan) === null || _b === void 0 ? void 0 : _b.price, hourly: true });
+                }
+                return color_1.default.dim(printf('(billed to %s app)', color_1.default.cyan(((_c = addon.app) === null || _c === void 0 ? void 0 : _c.name) || '')));
+            },
+        },
+        'Max Price': {
+            get: function (addon) {
+                var _a, _b, _c;
+                if (((_a = addon.app) === null || _a === void 0 ? void 0 : _a.name) === app) {
+                    return (0, util_1.formatPrice)({ price: (_b = addon.plan) === null || _b === void 0 ? void 0 : _b.price, hourly: false });
+                }
+                return color_1.default.dim(printf('(billed to %s app)', color_1.default.cyan(((_c = addon.app) === null || _c === void 0 ? void 0 : _c.name) || '')));
+            },
+        },
+        State: {
+            get: ({ state }) => (0, util_1.formatState)(state || ''),
+        },
+    }, {
+    // Separate each add-on row by a blank line
+    // printLine: (s: string) => {
+    //   ux.log(s)
+    //   ux.log('\n')
+    // },
+    });
+    core_1.ux.log(`The table above shows ${color_1.default.magenta('add-ons')} and the ${color_1.default.green('attachments')} to the current app (${app}) or other ${color_1.default.cyan('apps')}.\n  `);
+}
+function displayJSON(addons) {
+    core_1.ux.log(JSON.stringify(addons, null, 2));
+}
+class Addons extends command_1.Command {
+    async run() {
+        const { flags } = await this.parse(Addons);
+        const { app, all, json } = flags;
+        if (!all && app) {
+            const addons = await addonGetter(this.heroku, app);
+            if (json)
+                displayJSON(addons);
+            else
+                displayForApp(app, addons);
+        }
+        else {
+            const addons = await addonGetter(this.heroku);
+            if (json)
+                displayJSON(addons);
+            else
+                displayAll(addons);
+        }
+    }
+}
+exports.default = Addons;
+Addons.topic = topic;
+Addons.usage = 'addons [--all|--app APP]';
+Addons.description = `Lists your add-ons and attachments.
+
+  The default filter applied depends on whether you are in a Heroku app
+  directory. If so, the --app flag is implied. If not, the default of --all
+  is implied. Explicitly providing either flag overrides the default
+  behavior.
+  `;
+Addons.flags = {
+    all: command_1.flags.boolean({ char: 'A', description: 'show add-ons and attachments for all accessible apps' }),
+    json: command_1.flags.boolean({ description: 'return add-ons in json format' }),
+    app: command_1.flags.app(),
+    remote: command_1.flags.remote(),
+};
+Addons.examples = [
+    `$ heroku ${topic} --all`,
+    `$ heroku ${topic} --app acme-inc-www`,
+];

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

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

package/lib/commands/addons/info.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const color_1 = require("@heroku-cli/color");
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const util_1 = require("../../lib/addons/util");
+const resolve_1 = require("../../lib/addons/resolve");
+const topic = 'addons';
+class Info extends command_1.Command {
+    async run() {
+        var _a, _b, _c, _d;
+        const { flags, args } = await this.parse(Info);
+        const { app } = flags;
+        const addon = await (0, resolve_1.resolveAddon)(this.heroku, app, args.addon);
+        const { body: attachments } = await this.heroku.get(`/addons/${addon.id}/addon-attachments`);
+        addon.plan.price = (0, util_1.grandfatheredPrice)(addon);
+        addon.attachments = attachments;
+        core_1.ux.styledHeader(color_1.default.magenta((_a = addon.name) !== null && _a !== void 0 ? _a : ''));
+        core_1.ux.styledObject({
+            Plan: addon.plan.name,
+            Price: (0, util_1.formatPrice)({ price: addon.plan.price, hourly: true }),
+            'Max Price': (0, util_1.formatPrice)({ price: addon.plan.price, hourly: false }),
+            Attachments: addon.attachments.map(function (att) {
+                var _a;
+                return [
+                    color_1.default.cyan(((_a = att.app) === null || _a === void 0 ? void 0 : _a.name) || ''), color_1.default.green(att.name || ''),
+                ].join('::');
+            })
+                .sort(), 'Owning app': color_1.default.cyan((_c = (_b = addon.app) === null || _b === void 0 ? void 0 : _b.name) !== null && _c !== void 0 ? _c : ''), 'Installed at': (new Date((_d = addon.created_at) !== null && _d !== void 0 ? _d : ''))
+                .toString(), State: (0, util_1.formatState)(addon.state),
+        });
+    }
+}
+exports.default = Info;
+Info.topic = topic;
+Info.description = 'show detailed add-on resource and attachment information';
+Info.flags = {
+    app: command_1.flags.app(),
+    remote: command_1.flags.remote(),
+};
+Info.usage = `${topic}:info ADDON`;
+Info.args = {
+    addon: core_1.Args.string({ required: true }),
+};

package/lib/commands/addons/open.d.ts

@@ -0,0 +1,75 @@
+import { Command } from '@heroku-cli/command';
+export interface SsoParams {
+    /**
+     * user email address
+     */
+    email: string;
+    /**
+     * user ID
+     */
+    user_id: string;
+    /**
+     * billing app name
+     */
+    app: string;
+    /**
+     * context app name
+     */
+    context_app: string;
+    /**
+     * SSO request timestamp
+     */
+    timestamp: string;
+    /**
+     * Navigation metadata (deprecated)
+     */
+    'nav-data': string;
+    /**
+     * Provider ID (deprecated)
+     */
+    id: string;
+    /**
+     * SSO v1 token (deprecated)
+     */
+    token: string;
+    /**
+     * Add-on resource ID
+     */
+    resource_id: string;
+    /**
+     * SSO v3 token
+     */
+    resource_token: string;
+}
+export interface AddonSso {
+    /**
+     * SSO request method
+     */
+    method: 'get' | 'post';
+    /**
+     * URL of the SSO request
+     */
+    action: string;
+    /**
+     * SSO params for POST request
+     */
+    params?: SsoParams;
+}
+export default class Open extends Command {
+    static urlOpener: (url: string) => Promise<unknown>;
+    static topic: string;
+    static description: string;
+    static flags: {
+        'show-url': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        app: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        remote: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    static args: {
+        addon: import("@oclif/core/lib/interfaces/parser").Arg<string, Record<string, unknown>>;
+    };
+    static openUrl(url: string): Promise<void>;
+    private parsed;
+    run(): Promise<void>;
+    private sudo;
+    private writeSudoTemplate;
+}

package/lib/commands/addons/open.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const color_1 = require("@heroku-cli/color");
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const resolve_1 = require("../../lib/addons/resolve");
+const fs = require("node:fs/promises");
+const os = require("node:os");
+const path = require("node:path");
+const http_call_1 = require("http-call");
+const open = require("open");
+class Open extends command_1.Command {
+    constructor() {
+        super(...arguments);
+        this.parsed = this.parse(Open);
+    }
+    static async openUrl(url) {
+        core_1.ux.log(`Opening ${color_1.default.cyan(url)}...`);
+        await Open.urlOpener(url);
+    }
+    async run() {
+        const ctx = await this.parsed;
+        const { flags: { app }, args: { addon } } = ctx;
+        if (process.env.HEROKU_SUDO) {
+            return this.sudo(ctx);
+        }
+        let attachment = null;
+        try {
+            attachment = await (0, resolve_1.attachmentResolver)(this.heroku, app, addon);
+        }
+        catch (error) {
+            if (error instanceof http_call_1.HTTPError && error.statusCode !== 404) {
+                throw error;
+            }
+        }
+        let webUrl;
+        if (attachment) {
+            webUrl = attachment.web_url;
+        }
+        else {
+            const resolvedAddon = await (0, resolve_1.resolveAddon)(this.heroku, app, addon);
+            webUrl = resolvedAddon.web_url;
+        }
+        if (ctx.flags['show-url']) {
+            core_1.ux.log(webUrl);
+        }
+        else {
+            await Open.openUrl(webUrl);
+        }
+    }
+    async sudo(ctx) {
+        const { flags: { app }, args } = ctx;
+        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',
+            },
+        });
+        const { method, action } = sso.body;
+        if (method === 'get') {
+            await Open.openUrl(action);
+        }
+        else {
+            const ssoPath = await this.writeSudoTemplate(ctx, sso.body);
+            await Open.openUrl(`file://${ssoPath}`);
+        }
+    }
+    async writeSudoTemplate(ctx, sso) {
+        const ssoPath = path.join(os.tmpdir(), 'heroku-sso.html');
+        const { flags: { app }, args } = ctx;
+        const html = `<!DOCTYPE HTML>\n<html lang="en">\n  <head>\n    <meta charset="utf-8">\n    <title>Heroku Add-ons SSO</title>\n    <script src="https://ajax.googleapis.com/ajax/libs/jquery/2.0.0/jquery.min.js"></script>\n  </head>\n\n  <body>\n    <h3>Opening ${args.addon}${app ? ` on ${app}` : ''}...</h3>\n    <form method="POST" action="${sso.action}">\n    </form>\n\n    <script>\n      var params = ${JSON.stringify(sso.params)}\n      var form = document.forms[0]\n      $(document).ready(function() {\n        $.each(params, function(key, value) {\n          $('<input>').attr({ type: 'hidden', name: key, value: value })\n            .appendTo(form)\n        })\n        form.submit()\n      })\n    </script>\n  </body>\n</html>`;
+        await fs.writeFile(ssoPath, html);
+        return ssoPath;
+    }
+}
+exports.default = Open;
+Open.urlOpener = open;
+Open.topic = 'addons';
+Open.description = 'open an add-on\'s dashboard in your browser';
+Open.flags = {
+    'show-url': command_1.flags.boolean({ description: 'show URL, do not open browser' }),
+    app: command_1.flags.app(),
+    remote: command_1.flags.remote(),
+};
+Open.args = {
+    addon: core_1.Args.string({ required: true }),
+};

package/lib/commands/addons/plans.d.ts

@@ -0,0 +1,12 @@
+import { Command } from '@heroku-cli/command';
+export default class Plans extends Command {
+    static topic: string;
+    static description: string;
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    static args: {
+        service: import("@oclif/core/lib/interfaces/parser").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/addons/plans.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const util_1 = require("../../lib/addons/util");
+const _ = require("lodash");
+class Plans extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(Plans);
+        let { body: plans } = await this.heroku.get(`/addon-services/${args.service}/plans`);
+        plans = _.sortBy(plans, ['price.contract', 'price.cents']);
+        if (flags.json) {
+            core_1.ux.styledJSON(plans);
+        }
+        else {
+            core_1.ux.table(plans, {
+                default: {
+                    header: '',
+                    get: (plan) => plan.default ? 'default' : '',
+                },
+                name: {
+                    header: 'Slug',
+                },
+                human_name: {
+                    header: 'Name',
+                },
+                price: {
+                    header: 'Price',
+                    get: (plan) => (0, util_1.formatPrice)({ price: plan.price, hourly: true }),
+                },
+                max_price: {
+                    header: 'Max price',
+                    get: (plan) => (0, util_1.formatPrice)({ price: plan.price, hourly: false }),
+                },
+            });
+        }
+    }
+}
+exports.default = Plans;
+Plans.topic = 'addons';
+Plans.description = 'list all available plans for an add-on service';
+Plans.flags = {
+    json: command_1.flags.boolean({ description: 'output in json format' }),
+};
+Plans.args = {
+    service: core_1.Args.string({ required: true }),
+};

package/lib/commands/addons/rename.d.ts

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

package/lib/commands/addons/rename.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+class Rename extends command_1.Command {
+    async run() {
+        var _a;
+        const { args } = await this.parse(Rename);
+        const { body: addon } = await this.heroku.get(`/addons/${encodeURIComponent(args.addon_name)}`);
+        await this.heroku.patch(`/apps/${(_a = addon.app) === null || _a === void 0 ? void 0 : _a.id}/addons/${addon.id}`, { body: { name: args.new_name } });
+        core_1.ux.log(`${args.addon_name} successfully renamed to ${args.new_name}.`);
+    }
+}
+exports.default = Rename;
+Rename.topic = 'addons';
+Rename.description = 'rename an add-on';
+Rename.args = {
+    addon_name: core_1.Args.string({ required: true }),
+    new_name: core_1.Args.string({ required: true }),
+};

package/lib/commands/addons/services.d.ts

@@ -0,0 +1,9 @@
+import { Command } from '@heroku-cli/command';
+export default class Services extends Command {
+    static topic: string;
+    static description: string;
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}