heroku 9.0.0-dev.0 → 9.0.0

package/lib/lib/domains/domains.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitForCertIssuedOnDomains = exports.printDomains = exports.waitForDomains = exports.getDomains = void 0;
+const psl_1 = require("psl");
+const core_1 = require("@oclif/core");
+const color_1 = require("@heroku-cli/color");
+const wait = function (ms) {
+    return new Promise(function (resolve) {
+        setTimeout(resolve, ms);
+    });
+};
+function isParseError(parsed) {
+    return parsed.error !== undefined;
+}
+async function getDomains(heroku, app) {
+    const { body: domains } = await heroku.get(`/apps/${app}/domains`);
+    return domains;
+}
+exports.getDomains = getDomains;
+function type(domain) {
+    const parsed = (0, psl_1.parse)(domain.hostname);
+    if (isParseError(parsed)) {
+        throw new Error(parsed.error.message);
+    }
+    return parsed.subdomain === null ? 'ALIAS/ANAME' : 'CNAME';
+}
+async function waitForDomains(heroku, app) {
+    function someNull(domains) {
+        return domains.some(domain => domain.kind === 'custom' && !domain.cname);
+    }
+    let apiDomains = await getDomains(heroku, app);
+    if (someNull(apiDomains)) {
+        core_1.ux.action.start('Waiting for stable domains to be created');
+        let index = 0;
+        do {
+            // trying 30 times was easier for me to test that setTimeout
+            if (index >= 30) {
+                throw new Error('Timed out while waiting for stable domains to be created');
+            }
+            await wait(1000);
+            apiDomains = await getDomains(heroku, app);
+            index++;
+        } while (someNull(apiDomains));
+    }
+    return apiDomains;
+}
+exports.waitForDomains = waitForDomains;
+function printDomains(domains, message) {
+    domains = domains.filter(domain => domain.kind === 'custom');
+    const domains_with_type = domains.map(domain => Object.assign({}, domain, { type: type(domain) }));
+    if (domains_with_type.length === 0) {
+        core_1.ux.styledHeader(`${message}  Add a custom domain to your app by running ${color_1.default.cmd('heroku domains:add <yourdomain.com>')}`);
+    }
+    else {
+        core_1.ux.styledHeader(`${message}  Update your application's DNS settings as follows`);
+        core_1.ux.table(domains_with_type, {
+            domain: {
+                get: ({ hostname }) => hostname,
+            },
+            recordType: {
+                header: 'Record Type',
+                get: ({ type }) => type,
+            },
+            dnsTarget: {
+                header: 'DNS Target',
+                get: ({ cname }) => cname,
+            },
+        });
+    }
+}
+exports.printDomains = printDomains;
+async function waitForCertIssuedOnDomains(heroku, app) {
+    function certIssuedOrFailedForAllCustomDomains(domains) {
+        domains = domains.filter(domain => domain.kind === 'custom');
+        return domains.every(domain => domain.acm_status === 'cert issued' || domain.acm_status === 'failed');
+    }
+    function someFailed(domains) {
+        domains = domains.filter(domain => domain.kind === 'custom');
+        return domains.some(domain => domain.acm_status === 'failed');
+    }
+    function backoff(attempts) {
+        const wait = 15 * 1000;
+        // Don't wait more than 60 seconds
+        const multiplier = attempts < 60 ? Math.floor(attempts / 20) : 3;
+        const extraWait = wait * multiplier;
+        return wait + extraWait;
+    }
+    let domains = await getDomains(heroku, app);
+    if (!certIssuedOrFailedForAllCustomDomains(domains)) {
+        core_1.ux.action.start('Waiting until the certificate is issued to all domains');
+        let retries = 0;
+        while (!certIssuedOrFailedForAllCustomDomains(domains)) {
+            await wait(backoff(retries));
+            domains = await getDomains(heroku, app);
+            retries++;
+        }
+        if (someFailed(domains)) {
+            core_1.ux.action.stop(color_1.default.red('!'));
+            throw new Error('ACM not enabled for some domains');
+        }
+        core_1.ux.action.stop();
+    }
+}
+exports.waitForCertIssuedOnDomains = waitForCertIssuedOnDomains;

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

@@ -13,4 +13,7 @@ export default class Git {
         ref: string;
         message: string;
     }>;
+    inGitRepo(): true | undefined;
+    hasGitRemote(remote: string): Promise<boolean>;
+    createRemote(remote: string, url: string): Promise<string | null>;
 }

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');
@@ -43,11 +44,11 @@ class Git {
         return `https://${command_1.vars.httpGitHost}/${app}.git`;
     }
     async remoteUrl(name) {
+        var _a, _b, _c;
         const remotes = await this.exec(['remote', '-v']);
-        return remotes.split('\n')
+        return (_c = (_b = (_a = remotes.split('\n')
             .map(r => r.split('\t'))
-            .find(r => r[0] === name)[1]
-            .split(' ')[0];
+            .find(r => r[0] === name)) === null || _a === void 0 ? void 0 : _a[1]) === null || _b === void 0 ? void 0 : _b.split(' ')[0]) !== null && _c !== void 0 ? _c : '';
     }
     url(app) {
         return this.httpGitUrl(app);
@@ -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/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;