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

package/lib/lib/git/git.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const command_1 = require("@heroku-cli/command");
 const cp = require("child_process");
 const core_1 = require("@oclif/core");
+const fs = require("fs");
 const util_1 = require("util");
 const execFile = (0, util_1.promisify)(cp.execFile);
 const debug = require('debug')('git');
@@ -71,5 +72,23 @@ class Git {
             message: message,
         });
     }
+    inGitRepo() {
+        try {
+            fs.lstatSync('.git');
+            return true;
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+    }
+    hasGitRemote(remote) {
+        return this.remoteUrl(remote)
+            .then((remote) => Boolean(remote));
+    }
+    createRemote(remote, url) {
+        return this.hasGitRemote(remote)
+            .then(exists => !exists ? this.exec(['remote', 'add', remote, url]) : null);
+    }
 }
 exports.default = Git;

package/lib/lib/git/push.d.ts

@@ -0,0 +1 @@
+export default function push(remote?: string): string;

package/lib/lib/git/push.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function push(remote) {
+    return `git push ${remote || 'heroku'} main`;
+}
+exports.default = push;

package/lib/lib/local/run-foreman.d.ts

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

package/lib/lib/local/run-foreman.js

@@ -1,2 +1,230 @@
 "use strict";
-require('foreman/nf.js');
+// Copyright IBM Corp. 2012,2015. All Rights Reserved.
+// Node module: foreman
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+// This file is copied from the Node Foreman package. It was copied in order to fix
+// a bug related to the use of port 5000 as a default. It is not meant to be a
+// long-term solution, we plan to eventually remove our dependency on Node Foreman.
+// These rules are disabled in order to prevent the need for refactoring
+/* eslint-disable guard-for-in */
+/* eslint-disable new-cap */
+const path = require('path');
+const events = require('events');
+const fs = require('fs');
+const quote = require('shell-quote').quote;
+const program = require('commander');
+const colors = require('foreman/lib/colors');
+const display = require('foreman/lib/console').Console;
+const _proc = require('foreman/lib/proc');
+const _procfile = require('foreman/lib/procfile');
+const _envs = require('foreman/lib/envs');
+const _requirements = require('foreman/lib/requirements');
+const startProxies = require('foreman/lib/proxy').startProxies;
+const startForward = require('foreman/lib/forward').startForward;
+const exporters = require('foreman/lib/exporters');
+const foremanPjson = require('foreman/package.json');
+program.version(foremanPjson.version);
+program.option('-j, --procfile <FILE>', 'load procfile FILE', 'Procfile');
+program.option('-e, --env      <FILE>', 'load environment from FILE, a comma-separated list', '.env');
+program.option('-p, --port     <PORT>', 'start indexing ports at number PORT', 0);
+// Foreman Event Bus/Emitter //
+var emitter = new events.EventEmitter();
+emitter.once('killall', function (signal) {
+    display.Done('Killing all processes with signal ', signal);
+});
+emitter.setMaxListeners(50);
+var start = _proc.start;
+var once = _proc.once;
+var loadProc = _procfile.loadProc;
+var loadEnvs = _envs.loadEnvs;
+var getreqs = _requirements.getreqs;
+var calculatePadding = _requirements.calculatePadding;
+// Kill All Child Processes on SIGINT
+process.once('SIGINT', function () {
+    display.Warn('Interrupted by User');
+    emitter.emit('killall', 'SIGINT');
+});
+program
+    .command('start [procs]')
+    .usage('[Options] [Processes] e.g. web=1,log=2,api')
+    .option('-s, --showenvs', 'show ENV variables on start', false)
+    .option('-x, --proxy     <PORT>', 'start a load balancing proxy on PORT')
+    .option('--ssl-key       <KEY FILE>', 'a key file to use when proxying SSL')
+    .option('--ssl-cert      <CERT FILE>', 'a cert file to use when proxying SSL')
+    .option('-f, --forward   <PORT>', 'start a forward proxy on PORT')
+    .option('-i, --intercept <HOSTNAME>', 'set forward proxy to intercept HOSTNAME', null)
+    .option('-r, --raw', 'raw log output with no app name, timestamp, wrap or trim', false)
+    .option('-t, --trim      <N>', 'trim logs to N characters', 0)
+    .option('-w, --wrap', 'wrap logs (negates trim)')
+    .description('Start the jobs in the Procfile')
+    .action(function (args) {
+    var envs = loadEnvs(program.env);
+    var proc = loadProc(program.procfile);
+    if (!proc) {
+        return;
+    }
+    if (this.showenvs) {
+        for (var key in envs) {
+            display.Alert('env %s=%s', key, envs[key]);
+        }
+    }
+    var reqs = getreqs(args, proc);
+    display.padding = calculatePadding(reqs);
+    display.raw = this.raw;
+    if (this.wrap) {
+        display.wrapline = process.stdout.columns - display.padding - 7;
+        display.trimline = 0;
+        display.Alert('Wrapping display Output to %d Columns', display.wrapline);
+    }
+    else {
+        display.trimline = this.trim;
+        if (display.trimline > 0) {
+            display.Alert('Trimming display Output to %d Columns', display.trimline);
+        }
+    }
+    if (this.forward) {
+        startForward(this.forward, this.intercept, emitter);
+    }
+    // using port 5006 because it is not known to be used by other common software
+    startProxies(reqs, proc, this, emitter, program.port || envs.PORT || process.env.PORT || 5006);
+    start(proc, reqs, envs, program.port || envs.PORT || process.env.PORT || 5006, emitter);
+});
+program
+    .command('run <COMMAND...>')
+    .usage('[Options]')
+    .option('-s, --showenvs', 'show ENV variables on start', false)
+    .description('Run a one off process using the ENV variables')
+    .action(function (args) {
+    var envs = loadEnvs(program.env);
+    var callback = function (code) {
+        process.exit(code);
+    };
+    if (!args || args.length === 0) {
+        return;
+    }
+    var input = quote(args);
+    if (this.showenvs) {
+        for (var key in envs) {
+            display.Alert('env %s=%s', key, envs[key]);
+        }
+    }
+    display.trimline = process.stdout.columns - 5;
+    once(input, envs, callback);
+});
+program
+    .command('export [PROCS]')
+    .option('-a, --app  <NAME>', 'export upstart application as NAME', 'foreman')
+    .option('-u, --user <NAME>', 'export upstart user as NAME', 'root')
+    .option('-o, --out  <DIR>', 'export upstart files to DIR', '.')
+    .option('-c, --cwd  <DIR>', 'change current working directory to DIR')
+    .option('-g, --gid  <GID>', 'set gid of upstart config to GID')
+    .option('-l, --log  <DIR>', 'specify upstart log directory', '/var/log')
+    .option('-t, --type <TYPE>', 'export file to TYPE (default upstart)', 'upstart')
+    .option('-m, --template <DIR>', 'use template folder')
+    .description('Export to an upstart job independent of foreman')
+    .action(function (procArgs) {
+    var envs = loadEnvs(program.env);
+    var procs = loadProc(program.procfile);
+    if (!procs) {
+        return;
+    }
+    var req = getreqs(procArgs, procs);
+    // Variables for Upstart Template
+    var config = {
+        application: this.app,
+        cwd: path.resolve(process.cwd(), this.cwd || ''),
+        user: this.user,
+        logs: this.log,
+        envs: envs,
+        group: this.gid || this.user,
+        template: this.template,
+    };
+    config.envfile = path.resolve(program.env);
+    var writeout;
+    if (exporters[this.type]) {
+        writeout = exporters[this.type];
+    }
+    else {
+        display.Error('Unknown Export Format', this.type);
+        process.exit(1);
+    }
+    // Check for Upstart User
+    // friendly warning - does not stop export
+    var userExists = false;
+    fs.readFileSync('/etc/passwd')
+        .toString().split(/\n/).forEach(function (line) {
+        if (line.match(/^[^:]*/)[0] === config.user) {
+            userExists = true;
+        }
+    });
+    if (!userExists) {
+        display.Warn(display.fmt('User %s Does Not Exist on System', config.user));
+    }
+    // using port 5006 because it is not known to be used by other common software
+    var baseport = Number.parseInt(program.port || envs.PORT || process.env.PORT || 5006);
+    var baseport_i = 0;
+    var baseport_j = 0;
+    var envl = [];
+    config.processes = [];
+    // This is ugly because of shitty support for array copying
+    // Cleanup is definitely required
+    for (var key in req) {
+        var c = {};
+        var cmd = procs[key];
+        if (!cmd) {
+            display.Warn("Required Key '%s' Does Not Exist in Procfile Definition", key);
+            continue;
+        }
+        var n = req[key];
+        config.processes.push({ process: key, n: n });
+        c.process = key;
+        c.command = cmd;
+        for (var _ in config) {
+            c[_] = config[_];
+        }
+        c.numbers = [];
+        for (var i = 1; i <= n; i++) {
+            const port = (baseport + baseport_i + baseport_j) * 100;
+            const envl = [];
+            for (key in envs) {
+                envl.push({
+                    key: key,
+                    value: envs[key],
+                });
+            }
+            envl.push({ key: 'PORT', value: conf.port });
+            // eslint-disable-next-line unicorn/no-array-push-push
+            envl.push({ key: 'FOREMAN_WORKER_NAME', value: conf.process + '.' + conf.number });
+            conf.envs = envl;
+            const conf = Object.assign(Object.assign({}, c), { number: i, port, envs: envl });
+            // Write the APP-PROCESS-N.conf File
+            writeout.foreman_app_n(conf, this.out);
+            baseport_i++;
+            c.numbers.push({ number: i });
+        }
+        envl = [];
+        for (key in envs) {
+            envl.push({
+                key: key,
+                value: envs[key],
+            });
+        }
+        c.envs = envl;
+        // Write the APP-Process.conf File
+        writeout.foreman_app(c, this.out);
+        baseport_i = 0;
+        baseport_j++;
+    }
+    // Write the APP.conf File
+    writeout.foreman(config, this.out);
+});
+program.parse(process.argv);
+if (process.argv.slice(2).length === 0) {
+    console.log(colors.cyan('   _____                           '));
+    console.log(colors.cyan('  |   __|___ ___ ___ _____ ___ ___ '));
+    console.log(colors.yellow('  |   __| . |  _| -_|     |   |   |'));
+    console.log(colors.magenta('  |__|  |___|_| |___|_|_|_|_^_|_|_|'));
+    program.outputHelp();
+    process.exit(1);
+}

package/lib/lib/members/util.d.ts

@@ -0,0 +1,3 @@
+import { APIClient } from '@heroku-cli/command';
+export declare const inviteMemberToTeam: (email: string, role: string, team: string, heroku: APIClient) => Promise<void>;
+export declare const addMemberToTeam: (email: string, role: string, groupName: string, heroku: APIClient, method?: string) => Promise<void>;

package/lib/lib/members/util.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addMemberToTeam = exports.inviteMemberToTeam = void 0;
+const core_1 = require("@oclif/core");
+const color_1 = require("@heroku-cli/color");
+const inviteMemberToTeam = async function (email, role, team, heroku) {
+    core_1.ux.action.start(`Inviting ${color_1.default.cyan(email)} to ${color_1.default.magenta(team)} as ${color_1.default.green(role)}`);
+    await heroku.request(`/teams/${team}/invitations`, {
+        headers: {
+            Accept: 'application/vnd.heroku+json; version=3.team-invitations',
+        }, method: 'PUT',
+        body: { email, role },
+    });
+    core_1.ux.action.stop();
+};
+exports.inviteMemberToTeam = inviteMemberToTeam;
+const addMemberToTeam = async function (email, role, groupName, heroku, method = 'PUT') {
+    core_1.ux.action.start(`Adding ${color_1.default.cyan(email)} to ${color_1.default.magenta(groupName)} as ${color_1.default.green(role)}`);
+    await heroku.request(`/teams/${groupName}/members`, {
+        method: method,
+        body: { email, role },
+    });
+    core_1.ux.action.stop();
+};
+exports.addMemberToTeam = addMemberToTeam;

package/lib/lib/members/utils.d.ts

@@ -0,0 +1,2 @@
+import { APIClient } from '@heroku-cli/command';
+export declare const addMemberToTeam: (email: string, role: string, groupName: string, heroku: APIClient, method?: string) => Promise<void>;

package/lib/lib/members/utils.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addMemberToTeam = void 0;
+const core_1 = require("@oclif/core");
+const color_1 = require("@heroku-cli/color");
+const addMemberToTeam = async function (email, role, groupName, heroku, method = 'PUT') {
+    core_1.ux.action.start(`Adding ${color_1.default.cyan(email)} to ${color_1.default.magenta(groupName)} as ${color_1.default.green(role)}`);
+    await heroku.request(`/teams/${groupName}/members`, {
+        method: method,
+        body: { email, role },
+    });
+    core_1.ux.action.stop();
+};
+exports.addMemberToTeam = addMemberToTeam;

package/lib/lib/notify.d.ts

@@ -0,0 +1 @@
+export default function (subtitle: string, message: string, success?: boolean): void;

package/lib/lib/notify.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("path");
+const notifications_1 = require("@heroku-cli/notifications");
+const core_1 = require("@oclif/core");
+function default_1(subtitle, message, success = true) {
+    const contentImage = path.join(__dirname, `../assets/${success ? 'success' : 'error'}.png`);
+    try {
+        (0, notifications_1.notify)({
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            title: 'heroku cli',
+            subtitle,
+            message,
+            contentImage,
+            sound: true,
+        });
+    }
+    catch (error) {
+        core_1.ux.warn(error);
+    }
+}
+exports.default = default_1;

package/lib/lib/orgs/utils.d.ts

@@ -0,0 +1,5 @@
+import * as Heroku from '@heroku-cli/schema';
+export declare const printGroups: (teams: Heroku.Team[], type: {
+    label: string;
+}) => void;
+export declare const printGroupsJSON: (teams: Heroku.Team[]) => void;

package/lib/lib/orgs/utils.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printGroupsJSON = exports.printGroups = void 0;
+const core_1 = require("@oclif/core");
+const _ = require("lodash");
+const color_1 = require("@heroku-cli/color");
+const printGroups = function (teams, type) {
+    const typeLabel = type.label ? type.label : 'Team';
+    teams = _.sortBy(teams, 'name');
+    core_1.ux.table(teams, {
+        name: {
+            header: typeLabel,
+            get: ({ name }) => color_1.default.green(name),
+        },
+        role: {
+            get: ({ role }) => role,
+        },
+    });
+};
+exports.printGroups = printGroups;
+const printGroupsJSON = function (teams) {
+    core_1.ux.log(JSON.stringify(teams, null, 2));
+};
+exports.printGroupsJSON = printGroupsJSON;

package/lib/lib/pg/backups.d.ts

@@ -0,0 +1,17 @@
+import { APIClient } from '@heroku-cli/command';
+import type { BackupTransfer } from './types';
+declare class Backups {
+    protected app: string;
+    protected heroku: APIClient;
+    protected logsAlreadyShown: Set<string>;
+    constructor(app: string, heroku: APIClient);
+    filesize(size: number, opts?: {}): string;
+    status: (transfer: BackupTransfer) => string;
+    num: (name: string) => Promise<number | undefined>;
+    name: (transfer: BackupTransfer) => string;
+    wait: (action: string, transferID: string, interval: number, verbose: boolean, app: string) => Promise<void>;
+    protected displayLogs(logs: BackupTransfer['logs']): void;
+    protected poll(transferID: string, interval: number, verbose: boolean, appId: string): AsyncGenerator<unknown, void, unknown>;
+}
+declare function factory(app: string, heroku: APIClient): Backups;
+export default factory;

package/lib/lib/pg/backups.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const color_1 = require("@heroku-cli/color");
+const core_1 = require("@oclif/core");
+const tsheredoc_1 = require("tsheredoc");
+const host_1 = require("./host");
+const bytes = require("bytes");
+function prefix(transfer) {
+    if (transfer.from_type === 'pg_dump') {
+        if (transfer.to_type === 'pg_restore') {
+            return 'c';
+        }
+        return transfer.schedule ? 'a' : 'b';
+        // eslint-disable-next-line no-else-return
+    }
+    else {
+        if (transfer.to_type === 'pg_restore') {
+            return 'r';
+        }
+        return 'b';
+    }
+}
+class Backups {
+    constructor(app, heroku) {
+        this.logsAlreadyShown = new Set();
+        this.status = (transfer) => {
+            if (transfer.finished_at && transfer.succeeded) {
+                const warnings = transfer.warnings;
+                if (warnings > 0) {
+                    return `Finished with ${warnings} warnings`;
+                }
+                return `Completed ${transfer.finished_at}`;
+            }
+            if (transfer.finished_at) {
+                return `Failed ${transfer.finished_at}`;
+            }
+            if (transfer.started_at) {
+                return `Running (processed ${this.filesize(transfer.processed_bytes)})`;
+            }
+            return 'Pending';
+        };
+        this.num = async (name) => {
+            let m = name.match(/^[abcr](\d+)$/);
+            if (m)
+                return Number.parseInt(m[1], 10);
+            m = name.match(/^o[ab]\d+$/);
+            if (m) {
+                const { body: transfers } = await this.heroku.get(`/client/v11/apps/${this.app}/transfers`, { hostname: (0, host_1.default)() });
+                const transfer = transfers.find(t => this.name(t) === name);
+                if (transfer)
+                    return transfer.num;
+            }
+        };
+        this.name = (transfer) => {
+            const oldPGBName = transfer.options && transfer.options.pgbackups_name;
+            if (oldPGBName)
+                return `o${oldPGBName}`;
+            return `${prefix(transfer)}${(transfer.num || '').toString().padStart(3, '0')}`;
+        };
+        this.wait = async (action, transferID, interval, verbose, app) => {
+            var e_1, _a;
+            if (verbose) {
+                core_1.ux.log(`${action}...`);
+            }
+            core_1.ux.action.start(action);
+            try {
+                try {
+                    for (var _b = tslib_1.__asyncValues(this.poll(transferID, interval, verbose, app || this.app)), _c; _c = await _b.next(), !_c.done;) {
+                        const backupSucceeded = _c.value;
+                        if (backupSucceeded) {
+                            core_1.ux.action.stop();
+                            break;
+                        }
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (_c && !_c.done && (_a = _b.return)) await _a.call(_b);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+            }
+            catch (error) {
+                core_1.ux.action.stop('!');
+                core_1.ux.error(error);
+            }
+        };
+        this.app = app;
+        this.heroku = heroku;
+    }
+    filesize(size, opts = {}) {
+        Object.assign(opts, {
+            decimalPlaces: 2,
+            fixedDecimals: true,
+        });
+        return bytes(size, opts);
+    }
+    displayLogs(logs) {
+        for (const log of logs) {
+            if (this.logsAlreadyShown.has(log.created_at + log.message)) {
+                continue;
+            }
+            this.logsAlreadyShown.add(log.created_at + log.message);
+            core_1.ux.log(`${log.created_at} ${log.message}`);
+        }
+    }
+    poll(transferID, interval, verbose, appId) {
+        var _a;
+        return tslib_1.__asyncGenerator(this, arguments, function* poll_1() {
+            const tty = process.env.TERM !== 'dumb' && process.stderr.isTTY;
+            let backup = {};
+            let failures = 0;
+            const quietUrl = `/client/v11/apps/${appId !== null && appId !== void 0 ? appId : this.app}/transfers/${transferID}`;
+            const verboseUrl = quietUrl + '?verbose=true';
+            const url = verbose ? verboseUrl : quietUrl;
+            while (failures < 21) {
+                try {
+                    ({ body: backup } = yield tslib_1.__await(this.heroku.get(url, { hostname: (0, host_1.default)() })));
+                }
+                catch (error) {
+                    if (failures++ > 20) {
+                        throw error;
+                    }
+                }
+                if (verbose) {
+                    this.displayLogs(backup.logs);
+                }
+                else if (tty) {
+                    const msg = backup.started_at ? this.filesize(backup.processed_bytes) : 'pending';
+                    const log = (_a = backup.logs) === null || _a === void 0 ? void 0 : _a.pop();
+                    if (log) {
+                        core_1.ux.action.status = `${msg}\n${log.created_at + ' ' + log.message}`;
+                    }
+                    else {
+                        core_1.ux.action.status = msg;
+                    }
+                }
+                if (backup === null || backup === void 0 ? void 0 : backup.finished_at) {
+                    if (backup.succeeded) {
+                        yield yield tslib_1.__await(true);
+                        break;
+                    }
+                    // logs is undefined unless verbose=true is passed
+                    ({ body: backup } = yield tslib_1.__await(this.heroku.get(verboseUrl, { hostname: (0, host_1.default)() })));
+                    throw new Error((0, tsheredoc_1.default)(`
+          An error occurred and the backup did not finish.
+
+          ${backup.logs.slice(-5).map(l => l.message).join('\n')}
+
+          Run ${color_1.default.cmd('heroku pg:backups:info ' + this.name(backup))} for more details.`));
+                }
+                yield yield tslib_1.__await(new Promise(resolve => {
+                    setTimeout(resolve, interval * 1000);
+                }));
+            }
+        });
+    }
+}
+function factory(app, heroku) {
+    return new Backups(app, heroku);
+}
+exports.default = factory;

package/lib/lib/pg/bastion.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { APIClient } from '@heroku-cli/command';
+import * as createTunnel from 'tunnel-ssh';
+import { ConnectionDetails } from './util';
+export declare const getBastion: (config: Record<string, string>, baseName: string) => {
+    bastionHost: string;
+    bastionKey: string;
+} | {
+    bastionHost?: undefined;
+    bastionKey?: undefined;
+};
+export declare const env: (db: ConnectionDetails) => {
+    PGAPPNAME: string;
+    PGSSLMODE: string;
+} & NodeJS.ProcessEnv;
+export declare type TunnelConfig = createTunnel.Config;
+export declare function tunnelConfig(db: ConnectionDetails): TunnelConfig;
+export declare function getConfigs(db: ConnectionDetails): {
+    dbEnv: NodeJS.ProcessEnv;
+    dbTunnelConfig: createTunnel.Config;
+};
+export declare function sshTunnel(db: ConnectionDetails, dbTunnelConfig: TunnelConfig, timeout?: number): Promise<void | import("net").Server | null>;
+export declare function fetchConfig(heroku: APIClient, db: {
+    id: string;
+}): Promise<import("http-call").HTTP<{
+    host: string;
+    private_key: string;
+}>>;