heroku 9.0.0-alpha.1 → 9.0.0-alpha.2

package/lib/lib/container/debug.d.ts

@@ -0,0 +1,2 @@
+import * as logger from 'debug';
+export declare const debug: logger.Debugger;

package/lib/lib/container/debug.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.debug = void 0;
+const logger = require("debug");
+exports.debug = logger('heroku-container-registry');

package/lib/lib/container/docker_helper.d.ts

@@ -0,0 +1,24 @@
+export declare type cmdOptions = {
+    output?: boolean;
+    input?: string;
+};
+export declare const cmd: (cmd: string, args: string[], options?: cmdOptions) => Promise<string>;
+export declare const version: () => Promise<number[]>;
+export declare const pullImage: (resource: string) => Promise<string>;
+export declare const getDockerfiles: (rootdir: string, recursive: boolean) => string[];
+export declare type dockerJob = {
+    name: string;
+    resource: string;
+    dockerfile: string;
+    postfix: number;
+    depth: number;
+};
+export declare type groupedDockerJobs = {
+    [processType: string]: dockerJob[];
+};
+export declare const getJobs: (resourceRoot: string, dockerfiles: string[]) => groupedDockerJobs;
+export declare const filterByProcessType: (jobs: groupedDockerJobs, processTypes: string[]) => groupedDockerJobs;
+export declare const chooseJobs: (jobs: groupedDockerJobs) => Promise<dockerJob[]>;
+export declare const buildImage: (dockerfile: string, resource: string, buildArgs: string[], path?: string) => Promise<string>;
+export declare const pushImage: (resource: string) => Promise<string>;
+export declare const runImage: (resource: string, command: string, port: number) => Promise<string>;

package/lib/lib/container/docker_helper.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runImage = exports.pushImage = exports.buildImage = exports.chooseJobs = exports.filterByProcessType = exports.getJobs = exports.getDockerfiles = exports.pullImage = exports.version = exports.cmd = void 0;
+const Child = require("child_process");
+const debug_1 = require("./debug");
+const glob = require("glob");
+const Path = require("path");
+const inquirer = require("inquirer");
+const os = require("os");
+const DOCKERFILE_REGEX = /\bDockerfile(.\w*)?$/;
+const cmd = async function (cmd, args, options = {}) {
+    (0, debug_1.debug)(cmd, args);
+    const stdio = [
+        options.input ? 'pipe' : process.stdin,
+        options.output ? 'pipe' : process.stdout,
+        process.stderr,
+    ];
+    return new Promise((resolve, reject) => {
+        const child = Child.spawn(cmd, args, { stdio: stdio });
+        if (child.stdin) {
+            child.stdin.end(options.input);
+        }
+        let stdout;
+        if (child.stdout) {
+            stdout = '';
+            child.stdout.on('data', data => {
+                stdout += data.toString();
+            });
+        }
+        child.on('error', (err) => {
+            if (err.code === 'ENOENT' && err.path === 'docker') {
+                reject(new Error(`Cannot find docker, please ensure docker is installed.
+        If you need help installing docker, visit https://docs.docker.com/install/#supported-platforms`));
+            }
+            else {
+                reject(err);
+            }
+        });
+        child.on('exit', (code, signal) => {
+            if (signal || code) {
+                reject(new Error(signal || (code === null || code === void 0 ? void 0 : code.toString())));
+            }
+            else {
+                resolve(stdout);
+            }
+        });
+    });
+};
+exports.cmd = cmd;
+const version = async function () {
+    const version = await (0, exports.cmd)('docker', ['version', '-f', '{{.Client.Version}}'], { output: true });
+    const [major, minor] = version.split(/\./);
+    return [Number.parseInt(major, 10) || 0, Number.parseInt(minor, 10) || 0]; // ensure exactly 2 components
+};
+exports.version = version;
+const pullImage = function (resource) {
+    const args = ['pull', resource];
+    return (0, exports.cmd)('docker', args);
+};
+exports.pullImage = pullImage;
+const getDockerfiles = function (rootdir, recursive) {
+    const match = recursive ? './**/Dockerfile?(.)*' : 'Dockerfile*';
+    let dockerfiles = glob.sync(match, {
+        cwd: rootdir,
+        nodir: true,
+    });
+    if (recursive) {
+        dockerfiles = dockerfiles.filter(df => df.match(/Dockerfile\.[\w]+$/));
+    }
+    else {
+        dockerfiles = dockerfiles.filter(df => df.match(/Dockerfile$/));
+    }
+    return dockerfiles.map(file => Path.join(rootdir, file));
+};
+exports.getDockerfiles = getDockerfiles;
+const getJobs = function (resourceRoot, dockerfiles) {
+    const jobs = [];
+    dockerfiles.forEach(dockerfile => {
+        const match = dockerfile.match(DOCKERFILE_REGEX);
+        if (match) {
+            const proc = (match[1] || '.standard').slice(1);
+            jobs.push({
+                name: proc,
+                resource: `${resourceRoot}/${proc}`,
+                dockerfile: dockerfile,
+                postfix: Path.basename(dockerfile) === 'Dockerfile' ? 0 : 1,
+                depth: Path.normalize(dockerfile).split(Path.sep).length,
+            });
+        }
+    });
+    // prefer closer Dockerfiles, then prefer Dockerfile over Dockerfile.web
+    jobs.sort((a, b) => {
+        return a.depth - b.depth || a.postfix - b.postfix;
+    });
+    // group all Dockerfiles for the same process type together
+    const groupedJobs = {};
+    jobs.forEach(job => {
+        groupedJobs[job.name] = groupedJobs[job.name] || [];
+        groupedJobs[job.name].push(job);
+    });
+    return groupedJobs;
+};
+exports.getJobs = getJobs;
+const filterByProcessType = function (jobs, processTypes) {
+    const filteredJobs = {};
+    processTypes.forEach(processType => {
+        filteredJobs[processType] = jobs[processType];
+    });
+    return filteredJobs;
+};
+exports.filterByProcessType = filterByProcessType;
+const chooseJobs = async function (jobs) {
+    const chosenJobs = [];
+    for (const processType in jobs) {
+        if (Object.prototype.hasOwnProperty.call(jobs, processType)) {
+            const group = jobs[processType];
+            if (group.length > 1) {
+                const prompt = [{
+                        type: 'list',
+                        name: processType,
+                        choices: group.map(j => j.dockerfile),
+                        message: `Found multiple Dockerfiles with process type ${processType}. Please choose one to build and push `,
+                    }];
+                const answer = await inquirer.prompt(prompt);
+                const found = group.find(o => o.dockerfile === answer[processType]);
+                if (found) {
+                    chosenJobs.push(found);
+                }
+            }
+            else {
+                chosenJobs.push(group[0]);
+            }
+        }
+    }
+    return chosenJobs;
+};
+exports.chooseJobs = chooseJobs;
+const buildImage = async function (dockerfile, resource, buildArgs, path) {
+    const cwd = path || Path.dirname(dockerfile);
+    const args = ['build', '-f', dockerfile, '-t', resource, '--platform', 'linux/amd64'];
+    for (const element of buildArgs) {
+        if (element.length > 0) {
+            args.push('--build-arg', element);
+        }
+    }
+    args.push(cwd);
+    return (0, exports.cmd)('docker', args);
+};
+exports.buildImage = buildImage;
+const pushImage = async function (resource) {
+    const args = ['push', resource];
+    return (0, exports.cmd)('docker', args);
+};
+exports.pushImage = pushImage;
+const runImage = function (resource, command, port) {
+    const args = [
+        'run',
+        '--user',
+        os.userInfo().uid.toString(),
+        '-e',
+        `PORT=${port}`,
+        '-it',
+        resource,
+        command,
+    ];
+    return (0, exports.cmd)('docker', args);
+};
+exports.runImage = runImage;

package/lib/lib/container/streamer.d.ts

@@ -0,0 +1 @@
+export declare const streamer: (url: string, out: NodeJS.WriteStream) => Promise<unknown>;

package/lib/lib/container/streamer.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.streamer = void 0;
+async function call(url, out, retries) {
+    const http = require('http-call').HTTP;
+    const maxRetries = 30;
+    try {
+        const { response } = await http.stream(url);
+        response.on('data', function (d) {
+            out.write(d);
+        });
+        return await new Promise(function (resolve, reject) {
+            response.on('error', reject);
+            response.on('end', resolve);
+        });
+    }
+    catch (error) {
+        if (error.statusCode === 404 && retries <= maxRetries) {
+            return new Promise(function (resolve, reject) {
+                setTimeout(function () {
+                    call(url, out, retries + 1).then(resolve, reject);
+                }, 1000);
+            });
+        }
+        throw error;
+    }
+}
+const streamer = function (url, out) {
+    return call(url, out, 0);
+};
+exports.streamer = streamer;

package/lib/lib/domains/domains.d.ts

@@ -0,0 +1,6 @@
+import { APIClient } from '@heroku-cli/command';
+import * as Heroku from '@heroku-cli/schema';
+export declare function getDomains(heroku: APIClient, app: string): Promise<Required<Heroku.Domain>[]>;
+export declare function waitForDomains(heroku: APIClient, app: string): Promise<Required<Heroku.Domain>[]>;
+export declare function printDomains(domains: Required<Heroku.Domain>[], message: string): void;
+export declare function waitForCertIssuedOnDomains(heroku: APIClient, app: string): Promise<void>;

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/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;