heroku 9.0.0-alpha.0 → 9.0.0-alpha.2

package/lib/commands/ps/restart.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const color_1 = require("@heroku-cli/color");
+const core_1 = require("@oclif/core");
+class Restart extends command_1.Command {
+    async run() {
+        const { args, flags } = await this.parse(Restart);
+        const app = flags.app;
+        const dyno = args.dyno;
+        let msg = 'Restarting';
+        if (dyno)
+            msg += ` ${color_1.default.cyan(dyno)}`;
+        msg += (dyno && dyno.includes('.')) ? ' dyno' : ' dynos';
+        msg += ` on ${color_1.default.app(app)}`;
+        core_1.ux.action.start(msg);
+        await this.heroku.delete(dyno ? `/apps/${app}/dynos/${encodeURIComponent(dyno)}` : `/apps/${app}/dynos`);
+        core_1.ux.action.stop();
+    }
+}
+exports.default = Restart;
+Restart.description = 'restart app dynos';
+Restart.topic = 'ps';
+Restart.aliases = ['dyno:restart'];
+Restart.hiddenAliases = ['restart'];
+Restart.examples = [
+    '$ heroku ps:restart web.1',
+    '$ heroku ps:restart web',
+    '$ heroku ps:restart',
+];
+Restart.help = 'if DYNO is not specified, restarts all dynos on app';
+Restart.args = {
+    dyno: core_1.Args.string({ required: false }),
+};
+Restart.flags = {
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};

package/lib/commands/ps/scale.d.ts

@@ -0,0 +1,13 @@
+import { Command } from '@heroku-cli/command';
+export default class Scale extends Command {
+    static strict: boolean;
+    static description: string;
+    static examples: string[];
+    static aliases: string[];
+    static hiddenAliases: 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/ps/scale.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const color_1 = require("@heroku-cli/color");
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const lodash_1 = require("lodash");
+const tsheredoc_1 = require("tsheredoc");
+const emptyFormationErr = (app) => {
+    return new Error(`No process types on ${color_1.default.magenta(app)}.\nUpload a Procfile to add process types.\nhttps://devcenter.heroku.com/articles/procfile`);
+};
+class Scale extends command_1.Command {
+    async run() {
+        const _a = await this.parse(Scale), { flags } = _a, restParse = tslib_1.__rest(_a, ["flags"]);
+        const argv = restParse.argv;
+        const { app } = flags;
+        // will remove this flag once we have
+        // successfully launched larger dyno sizes
+        let isLargerDyno = false;
+        const { body: largerDynoFeatureFlag } = await this.heroku.get('/account/features/frontend-larger-dynos')
+            .catch((error) => {
+            if (error.statusCode === 404) {
+                return { body: { enabled: false } };
+            }
+            throw error;
+        });
+        function parse(args) {
+            return (0, lodash_1.compact)(args.map(arg => {
+                const change = arg.match(/^([\w-]+)([=+-]\d+)(?::([\w-]+))?$/);
+                if (!change)
+                    return;
+                const quantity = change[2][0] === '=' ? change[2].slice(1) : change[2];
+                if (change[3])
+                    change[3] = change[3].replace('Shield-', 'Private-');
+                return { type: change[1], quantity, size: change[3] };
+            }));
+        }
+        const changes = parse(argv);
+        // checks for larger dyno sizes
+        // if the feature is not enabled
+        if (!largerDynoFeatureFlag.enabled) {
+            changes.forEach(({ size }) => {
+                const largerDynoNames = /^(?!standard-[12]x$)(performance|private|shield)-(l-ram|xl|2xl)$/i;
+                isLargerDyno = largerDynoNames.test(size);
+                if (isLargerDyno) {
+                    const availableDynoSizes = 'eco, basic, standard-1x, standard-2x, performance-m, performance-l, private-s, private-m, private-l, shield-s, shield-m, shield-l';
+                    core_1.ux.error(`No such size as ${size}. Use ${availableDynoSizes}.`, { exit: 1 });
+                }
+            });
+        }
+        if (changes.length === 0) {
+            const { body: formation } = await this.heroku.get(`/apps/${app}/formation`);
+            const { body: appProps } = await this.heroku.get(`/apps/${app}`);
+            const shielded = appProps.space && appProps.space.shield;
+            if (shielded) {
+                formation.forEach(d => {
+                    if (d.size !== undefined) {
+                        d.size = d.size.replace('Private-', 'Shield-');
+                    }
+                });
+            }
+            if (formation.length === 0) {
+                throw emptyFormationErr(app);
+            }
+            core_1.ux.log(formation.map(d => `${d.type}=${d.quantity}:${d.size}`)
+                .sort()
+                .join(' '));
+        }
+        else {
+            core_1.ux.action.start('Scaling dynos');
+            const { body: appProps } = await this.heroku.get(`/apps/${app}`);
+            const { body: formation } = await this.heroku.patch(`/apps/${app}/formation`, { body: { updates: changes } });
+            const shielded = appProps.space && appProps.space.shield;
+            if (shielded) {
+                formation.forEach(d => {
+                    if (d.size !== undefined) {
+                        d.size = d.size.replace('Private-', 'Shield-');
+                    }
+                });
+            }
+            const output = formation.filter(f => changes.find(c => c.type === f.type))
+                .map(d => `${color_1.default.green(d.type || '')} at ${d.quantity}:${d.size}`);
+            core_1.ux.action.stop(`done, now running ${output.join(', ')}`);
+        }
+    }
+}
+exports.default = Scale;
+Scale.strict = false;
+Scale.description = (0, tsheredoc_1.default) `
+    scale dyno quantity up or down
+    Appending a size (eg. web=2:Standard-2X) allows simultaneous scaling and resizing.
+
+    Omitting any arguments will display the app's current dyno formation, in a
+    format suitable for passing back into ps:scale.
+  `;
+Scale.examples = [(0, tsheredoc_1.default) `
+    $ heroku ps:scale web=3:Standard-2X worker+1 --app APP
+    Scaling dynos... done, now running web at 3:Standard-2X, worker at 1:Standard-1X.
+  `, (0, tsheredoc_1.default) `
+    $ heroku ps:scale --app APP
+    web=3:Standard-2X worker=1:Standard-1X
+  `];
+Scale.aliases = ['dyno:scale'];
+Scale.hiddenAliases = ['scale'];
+Scale.flags = {
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};

package/lib/commands/ps/stop.d.ts

@@ -0,0 +1,17 @@
+import { Command } from '@heroku-cli/command';
+export default class Stop extends Command {
+    static description: string;
+    static topic: string;
+    static aliases: string[];
+    static hiddenAliases: string[];
+    static examples: string[];
+    static help: string;
+    static args: {
+        dyno: import("@oclif/core/lib/interfaces/parser").Arg<string, Record<string, unknown>>;
+    };
+    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/ps/stop.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const color_1 = require("@heroku-cli/color");
+const core_1 = require("@oclif/core");
+class Stop extends command_1.Command {
+    async run() {
+        const { args, flags } = await this.parse(Stop);
+        const app = flags.app;
+        const dyno = args.dyno;
+        const type = dyno.includes('.') ? 'ps' : 'type';
+        core_1.ux.action.start(`Stopping ${color_1.default.cyan(dyno)} ${type === 'ps' ? 'dyno' : 'dynos'} on ${color_1.default.app(app)}`);
+        await this.heroku.post(`/apps/${app}/dynos/${dyno}/actions/stop`);
+        core_1.ux.action.stop();
+    }
+}
+exports.default = Stop;
+Stop.description = 'stop app dyno';
+Stop.topic = 'ps';
+Stop.aliases = ['dyno:stop', 'ps:kill', 'dyno:kill'];
+Stop.hiddenAliases = ['stop', 'kill'];
+Stop.examples = [
+    '$ heroku ps:stop run.1828',
+    '$ heroku ps:stop run',
+];
+Stop.help = 'stop app dyno or dyno type';
+Stop.args = {
+    dyno: core_1.Args.string({ required: true }),
+};
+Stop.flags = {
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};

package/lib/commands/ps/type.d.ts

@@ -0,0 +1,12 @@
+import { Command } from '@heroku-cli/command';
+export default class Type extends Command {
+    static strict: boolean;
+    static description: string;
+    static aliases: string[];
+    static hiddenAliases: 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/ps/type.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const color_1 = require("@heroku-cli/color");
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const lodash_1 = require("lodash");
+const tsheredoc_1 = require("tsheredoc");
+const COST_MONTHLY = {
+    Free: 0,
+    Eco: 0,
+    Hobby: 7,
+    Basic: 7,
+    'Standard-1X': 25,
+    'Standard-2X': 50,
+    'Performance-M': 250,
+    Performance: 500,
+    'Performance-L': 500,
+    '1X': 36,
+    '2X': 72,
+    PX: 576,
+    'Performance-L-RAM': 500,
+    'Performance-XL': 750,
+    'Performance-2XL': 1500,
+};
+const calculateHourly = (size) => COST_MONTHLY[size] / 720;
+const emptyFormationErr = (app) => {
+    return new Error(`No process types on ${app}.\nUpload a Procfile to add process types.\nhttps://devcenter.heroku.com/articles/procfile`);
+};
+const displayFormation = async (heroku, app) => {
+    const { body: formation } = await heroku.get(`/apps/${app}/formation`);
+    const { body: appProps } = await heroku.get(`/apps/${app}`);
+    const shielded = appProps.space && appProps.space.shield;
+    const dynoTotals = {};
+    let isShowingEcoCostMessage = false;
+    const formationTableData = (0, lodash_1.sortBy)(formation, 'type')
+        // this filter shouldn't be necessary, but it makes TS happy
+        .filter((f) => typeof f.size === 'string' && typeof f.quantity === 'number')
+        .map((d => {
+        if (d.size === 'Eco') {
+            isShowingEcoCostMessage = true;
+        }
+        if (shielded) {
+            d.size = d.size.replace('Private-', 'Shield-');
+        }
+        if (d.size in dynoTotals) {
+            dynoTotals[d.size] += d.quantity;
+        }
+        else {
+            dynoTotals[d.size] = d.quantity;
+        }
+        return {
+            // this rule does not realize `size` isn't used on an array
+            /* eslint-disable unicorn/explicit-length-check */
+            type: color_1.default.green(d.type || ''),
+            size: color_1.default.cyan(d.size),
+            qty: color_1.default.yellow(`${d.quantity}`),
+            'cost/hour': calculateHourly(d.size) ?
+                '~$' + (calculateHourly(d.size) * (d.quantity || 1)).toFixed(3)
+                    .toString() :
+                '',
+            'max cost/month': COST_MONTHLY[d.size] ?
+                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                // @ts-ignore
+                '$' + (COST_MONTHLY[d.size] * d.quantity).toString() :
+                '',
+        };
+    }));
+    const dynoTotalsTableData = Object.keys(dynoTotals)
+        .map(k => ({
+        type: color_1.default.green(k), total: color_1.default.yellow((dynoTotals[k]).toString()),
+    }));
+    if (formation.length === 0) {
+        throw emptyFormationErr(app);
+    }
+    core_1.ux.styledHeader('Dyno Types');
+    core_1.ux.table(formationTableData, {
+        type: {},
+        size: {},
+        qty: {},
+        'cost/hour': {},
+        'max cost/month': {},
+    });
+    core_1.ux.styledHeader('Dyno Totals');
+    core_1.ux.table(dynoTotalsTableData, {
+        type: {},
+        total: {},
+    });
+    if (isShowingEcoCostMessage) {
+        core_1.ux.log('\n$5 (flat monthly fee, shared across all Eco dynos)');
+    }
+};
+class Type extends command_1.Command {
+    async run() {
+        const _a = await this.parse(Type), { flags } = _a, restParse = tslib_1.__rest(_a, ["flags"]);
+        const argv = restParse.argv;
+        const { app } = flags;
+        // will remove this flag once we have
+        // successfully launched larger dyno sizes
+        let isLargerDyno = false;
+        const { body: largerDynoFeatureFlag } = await this.heroku.get('/account/features/frontend-larger-dynos')
+            .catch((error) => {
+            if (error.statusCode === 404) {
+                return { body: { enabled: false } };
+            }
+            throw error;
+        });
+        const parse = async () => {
+            if (!argv || argv.length === 0)
+                return [];
+            const { body: formation } = await this.heroku.get(`/apps/${app}/formation`);
+            if (argv.find(a => a.match(/=/))) {
+                return (0, lodash_1.compact)(argv.map(arg => {
+                    const match = arg.match(/^([a-zA-Z0-9_]+)=([\w-]+)$/);
+                    const type = match && match[1];
+                    const size = match && match[2];
+                    if (!type || !size || !formation.find(p => p.type === type)) {
+                        throw new Error(`Type ${color_1.default.red(type || '')} not found in process formation.\nTypes: ${color_1.default.yellow(formation.map(f => f.type)
+                            .join(', '))}`);
+                    }
+                    return { type, size };
+                }));
+            }
+            return formation.map(p => ({ type: p.type, size: argv[0] }));
+        };
+        const changes = await parse();
+        // checks for larger dyno sizes
+        // if the feature is not enabled
+        if (!largerDynoFeatureFlag.enabled) {
+            changes.forEach(({ size }) => {
+                const largerDynoNames = /^(?!standard-[12]x$)(performance|private|shield)-(l-ram|xl|2xl)$/i;
+                isLargerDyno = largerDynoNames.test(size);
+                if (isLargerDyno) {
+                    const availableDynoSizes = 'eco, basic, standard-1x, standard-2x, performance-m, performance-l, private-s, private-m, private-l, shield-s, shield-m, shield-l';
+                    core_1.ux.error(`No such size as ${size}. Use ${availableDynoSizes}.`, { exit: 1 });
+                }
+            });
+        }
+        if (changes.length > 0) {
+            core_1.ux.action.start(`Scaling dynos on ${color_1.default.magenta(app)}`);
+            await this.heroku.patch(`/apps/${app}/formation`, { body: { updates: changes } });
+            core_1.ux.action.stop();
+        }
+        await displayFormation(this.heroku, app);
+    }
+}
+exports.default = Type;
+Type.strict = false;
+Type.description = (0, tsheredoc_1.default) `
+    manage dyno sizes
+    Called with no arguments shows the current dyno size.
+
+    Called with one argument sets the size.
+    Where SIZE is one of eco|basic|standard-1x|standard-2x|performance
+
+    Called with 1..n TYPE=SIZE arguments sets the quantity per type.
+  `;
+Type.aliases = ['ps:resize', 'dyno:resize'];
+Type.hiddenAliases = ['resize', 'dyno:type'];
+Type.flags = {
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};

package/lib/commands/redis/cli.d.ts

@@ -0,0 +1,15 @@
+import { Command } from '@heroku-cli/command';
+export default class Cli extends Command {
+    static topic: string;
+    static description: string;
+    static flags: {
+        confirm: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        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>;
+    };
+    static args: {
+        database: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static examples: string[];
+    run(): Promise<void>;
+}

package/lib/commands/redis/cli.js

@@ -0,0 +1,204 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const readline = require("readline");
+const ssh2_1 = require("ssh2");
+const Parser = require("redis-parser");
+const portfinder = require("portfinder");
+const confirmCommand_1 = require("../../lib/confirmCommand");
+const tls = require("tls");
+const node_util_1 = require("node:util");
+const net = require("net");
+const api_1 = require("../../lib/redis/api");
+const REPLY_OK = 'OK';
+async function redisCLI(uri, client) {
+    const io = readline.createInterface(process.stdin, process.stdout);
+    const reply = new Parser({
+        returnReply(reply) {
+            switch (state) {
+                case 'monitoring':
+                    if (reply !== REPLY_OK) {
+                        console.log(reply);
+                    }
+                    break;
+                case 'subscriber':
+                    if (Array.isArray(reply)) {
+                        reply.forEach(function (value, i) {
+                            console.log(`${i + 1}) ${value}`);
+                        });
+                    }
+                    else {
+                        console.log(reply);
+                    }
+                    break;
+                case 'connect':
+                    if (reply !== REPLY_OK) {
+                        console.log(reply);
+                    }
+                    state = 'normal';
+                    io.prompt();
+                    break;
+                case 'closing':
+                    if (reply !== REPLY_OK) {
+                        console.log(reply);
+                    }
+                    break;
+                default:
+                    if (Array.isArray(reply)) {
+                        reply.forEach(function (value, i) {
+                            console.log(`${i + 1}) ${value}`);
+                        });
+                    }
+                    else {
+                        console.log(reply);
+                    }
+                    io.prompt();
+                    break;
+            }
+        }, returnError(err) {
+            console.log(err.message);
+            io.prompt();
+        }, returnFatalError(err) {
+            client.emit('error', err);
+            console.dir(err);
+        },
+    });
+    let state = 'connect';
+    client.write(`AUTH ${uri.password}\n`);
+    io.setPrompt(uri.host + '> ');
+    io.on('line', function (line) {
+        switch (line.split(' ')[0]) {
+            case 'MONITOR':
+                state = 'monitoring';
+                break;
+            case 'PSUBSCRIBE':
+            case 'SUBSCRIBE':
+                state = 'subscriber';
+                break;
+        }
+        client.write(`${line}\n`);
+    });
+    io.on('close', function () {
+        state = 'closing';
+        client.write('QUIT\n');
+    });
+    client.on('data', function (data) {
+        reply.execute(data);
+    });
+    return new Promise((resolve, reject) => {
+        client.on('error', reject);
+        client.on('end', function () {
+            console.log('\nDisconnected from instance.');
+            io.close();
+            resolve();
+        });
+    });
+}
+async function bastionConnect(uri, bastions, config, preferNativeTls) {
+    const tunnel = await new Promise(resolve => {
+        var _a;
+        const ssh2 = new ssh2_1.Client();
+        resolve(ssh2);
+        ssh2.once('ready', () => resolve(ssh2));
+        ssh2.connect({
+            host: bastions.split(',')[0],
+            username: 'bastion',
+            privateKey: (_a = match(config, /_BASTION_KEY/)) !== null && _a !== void 0 ? _a : '',
+        });
+    });
+    const localPort = await portfinder.getPortPromise({ startPort: 49152, stopPort: 65535 });
+    const stream = await (0, node_util_1.promisify)(tunnel.forwardOut)('localhost', localPort, uri.hostname, Number.parseInt(uri.port, 10));
+    let client = stream;
+    if (preferNativeTls) {
+        client = tls.connect({
+            socket: stream,
+            port: Number.parseInt(uri.port, 10),
+            host: uri.hostname,
+            rejectUnauthorized: false,
+        });
+    }
+    stream.on('close', () => tunnel.end());
+    stream.on('end', () => client.end());
+    return redisCLI(uri, client);
+}
+function match(config, lookup) {
+    for (const key in config) {
+        if (lookup.test(key)) {
+            return config[key];
+        }
+    }
+    return null;
+}
+async function maybeTunnel(redis, config) {
+    var _a;
+    const bastions = match(config, /_BASTIONS/);
+    const hobby = redis.plan.indexOf('hobby') === 0;
+    const preferNativeTls = redis.prefer_native_tls;
+    const uri = preferNativeTls && hobby ? new URL((_a = match(config, /_TLS_URL/)) !== null && _a !== void 0 ? _a : '') : new URL(redis.resource_url);
+    if (bastions !== null) {
+        return bastionConnect(uri, bastions, config, preferNativeTls);
+    }
+    let client;
+    if (preferNativeTls) {
+        client = tls.connect({
+            port: Number.parseInt(uri.port, 10), host: uri.hostname, rejectUnauthorized: false,
+        });
+    }
+    else if (hobby) {
+        client = net.connect({ port: Number.parseInt(uri.port, 10), host: uri.hostname });
+    }
+    else {
+        client = tls.connect({
+            port: Number.parseInt(uri.port, 10) + 1, host: uri.hostname, rejectUnauthorized: false,
+        });
+    }
+    return redisCLI(uri, client);
+}
+class Cli extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(Cli);
+        const api = (0, api_1.default)(flags.app, args.database, false, this.heroku);
+        const addon = await api.getRedisAddon();
+        const configVars = await getRedisConfigVars(addon, this.heroku);
+        const { body: redis } = await api.request(`/redis/v0/databases/${addon.id}`);
+        if (redis.plan.startsWith('shield-')) {
+            core_1.ux.error('\n      Using redis:cli on Heroku Redis shield plans is not supported.\n      Please see Heroku DevCenter for more details: https://devcenter.heroku.com/articles/shield-private-space#shield-features\n      ', { exit: 1 });
+        }
+        const hobby = redis.plan.indexOf('hobby') === 0;
+        const prefer_native_tls = redis.prefer_native_tls;
+        if (!prefer_native_tls && hobby) {
+            await (0, confirmCommand_1.default)(flags.app, flags.confirm, 'WARNING: Insecure action.\nAll data, including the Redis password, will not be encrypted.');
+        }
+        const nonBastionVars = Object.keys(configVars)
+            .filter(function (configVar) {
+            return !(/(?:BASTIONS|BASTION_KEY|BASTION_REKEYS_AFTER)$/.test(configVar));
+        })
+            .join(', ');
+        core_1.ux.log(`Connecting to ${addon.name} (${nonBastionVars}):`);
+        return maybeTunnel(redis, configVars);
+    }
+}
+exports.default = Cli;
+Cli.topic = 'redis';
+Cli.description = 'opens a redis prompt';
+Cli.flags = {
+    confirm: command_1.flags.string({ char: 'c' }),
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};
+Cli.args = {
+    database: core_1.Args.string(),
+};
+Cli.examples = [
+    '$ heroku redis:cli --app=my-app my-database',
+    '$ heroku redis:cli --app=my-app --confirm my-database',
+];
+async function getRedisConfigVars(addon, heroku) {
+    const { body: config } = await heroku.get(`/apps/${addon.billing_entity.name}/config-vars`);
+    const redisConfigVars = {};
+    addon.config_vars.forEach(configVar => {
+        redisConfigVars[configVar] = config[configVar];
+    });
+    return redisConfigVars;
+}

package/lib/commands/redis/credentials.d.ts

@@ -0,0 +1,14 @@
+import { Command } from '@heroku-cli/command';
+export default class Credentials extends Command {
+    static topic: string;
+    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>;
+        reset: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    static args: {
+        database: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/redis/credentials.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const api_1 = require("../../lib/redis/api");
+class Credentials extends command_1.Command {
+    async run() {
+        const { args, flags } = await this.parse(Credentials);
+        const { app, reset } = flags;
+        const { database } = args;
+        const addon = await (0, api_1.default)(app, database, false, this.heroku).getRedisAddon();
+        if (reset) {
+            core_1.ux.log(`Resetting credentials for ${addon.name}`);
+            await (0, api_1.default)(app, database, false, this.heroku).request(`/redis/v0/databases/${addon.name}/credentials_rotation`, 'POST');
+        }
+        else {
+            const { body: redis } = await (0, api_1.default)(app, database, false, this.heroku).request(`/redis/v0/databases/${addon.name}`);
+            core_1.ux.log(redis.resource_url);
+        }
+    }
+}
+exports.default = Credentials;
+Credentials.topic = 'redis';
+Credentials.description = 'display credentials information';
+Credentials.flags = {
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+    reset: command_1.flags.boolean({ description: 'reset credentials' }),
+};
+Credentials.args = {
+    database: core_1.Args.string({ required: false }),
+};

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

@@ -0,0 +1,15 @@
+import { Command } from '@heroku-cli/command';
+export default class Info extends Command {
+    static topic: string;
+    static description: string;
+    static aliases: 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>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    static args: {
+        database: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}