heroku 8.1.9 → 8.2.0-beta.0

package/lib/lib/config/quote.d.ts

@@ -0,0 +1,2 @@
+export declare function quote(s: string): string;
+export declare function parse(a: string): string;

package/lib/lib/config/quote.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse = exports.quote = void 0;
+const shell = require('shell-quote');
+// slightly modifed form of shell-quote to default to using single-quotes over backslashes
+function quote(s) {
+    // eslint-disable-next-line no-useless-escape
+    if (/["\s#!$&'()*,:;<=>?@\[\\\]^`{|}]/.test(s)) {
+        if (/['\n]/.test(s))
+            return '"' +
+                s
+                    .replace(/(["\\$`!])/g, '\\$1')
+                    .replace(/\n/g, '\\n') +
+                '"';
+        return "'" + s.replace(/(['\\])/g, '\\$1') + "'";
+    }
+    return s;
+}
+exports.quote = quote;
+function parse(a) {
+    if (a.startsWith('"')) {
+        a = a.replace(/\\n/g, '\n');
+    }
+    else if (a.startsWith("'")) {
+        a = a.replace(/\\\\/g, '\\');
+    }
+    const parsed = shell.parse(a);
+    if (parsed.length > 1)
+        throw new Error(`Invalid token: ${a}`);
+    return parsed[0];
+    // return parsed[0].replace(/\\\\n/g, '\n')
+}
+exports.parse = parse;

package/lib/lib/config/util.d.ts

@@ -0,0 +1,3 @@
+export declare class Editor {
+    edit(input: string, options?: {}): any;
+}

package/lib/lib/config/util.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Editor = void 0;
+const edit = require('edit-string');
+// This indirection exists to give tests
+// a way to stub calls to `edit(...)`
+class Editor {
+    edit(input, options = {}) {
+        return edit(input, options);
+    }
+}
+exports.Editor = Editor;

package/lib/lib/domains/wait-for-domain.d.ts

@@ -0,0 +1,3 @@
+import { APIClient } from '@heroku-cli/command';
+import * as Heroku from '@heroku-cli/schema';
+export default function waitForDomain(app: string, heroku: APIClient, domain: Heroku.Domain): Promise<void>;

package/lib/lib/domains/wait-for-domain.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const color_1 = require("@heroku-cli/color");
+const core_1 = require("@oclif/core");
+const spinner_1 = require("@oclif/core/lib/cli-ux/action/spinner");
+async function waitForDomain(app, heroku, domain) {
+    const action = new spinner_1.default();
+    action.start(`Waiting for ${color_1.color.green(domain.hostname || 'domain')}`);
+    while (domain.status === 'pending') {
+        await core_1.ux.wait(5000);
+        const { body: updatedDomain } = await heroku.get(`/apps/${app}/domains/${domain.id}`);
+        domain = updatedDomain;
+    }
+    action.stop();
+    if (domain.status === 'succeeded' || domain.status === 'none')
+        return;
+    throw new Error(`The domain creation finished with status ${domain.status}`);
+}
+exports.default = waitForDomain;

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

@@ -0,0 +1,8 @@
+export default class Git {
+    exec(args: string[]): Promise<string>;
+    spawn(args: string[]): Promise<unknown>;
+    remoteFromGitConfig(): Promise<string | void>;
+    httpGitUrl(app: string): string;
+    remoteUrl(name: string): Promise<string>;
+    url(app: string): string;
+}

package/lib/lib/git/git.js

@@ -0,0 +1,56 @@
+"use strict";
+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 util_1 = require("util");
+const execFile = (0, util_1.promisify)(cp.execFile);
+const debug = require('debug')('git');
+class Git {
+    async exec(args) {
+        debug('exec: git %o', args);
+        try {
+            const { stdout, stderr } = await execFile('git', args);
+            if (stderr)
+                process.stderr.write(stderr);
+            return stdout.trim();
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                core_1.ux.error('Git must be installed to use the Heroku CLI.  See instructions here: https://git-scm.com');
+            }
+            throw error;
+        }
+    }
+    spawn(args) {
+        return new Promise((resolve, reject) => {
+            debug('spawn: git %o', args);
+            const s = cp.spawn('git', args, { stdio: [0, 1, 2] });
+            s.on('error', (err) => {
+                if (err.code === 'ENOENT') {
+                    core_1.ux.error('Git must be installed to use the Heroku CLI.  See instructions here: https://git-scm.com');
+                }
+                else
+                    reject(err);
+            });
+            s.on('close', resolve);
+        });
+    }
+    remoteFromGitConfig() {
+        return this.exec(['config', 'heroku.remote']).catch(() => { });
+    }
+    httpGitUrl(app) {
+        return `https://${command_1.vars.httpGitHost}/${app}.git`;
+    }
+    async remoteUrl(name) {
+        const remotes = await this.exec(['remote', '-v']);
+        return remotes.split('\n')
+            .map(r => r.split('\t'))
+            .find(r => r[0] === name)[1]
+            .split(' ')[0];
+    }
+    url(app) {
+        return this.httpGitUrl(app);
+    }
+}
+exports.default = Git;

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

@@ -0,0 +1 @@
+export declare function fork(argv: string[]): Promise<void>;

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fork = void 0;
+const child_process_1 = require("child_process");
+const fs = require("fs");
+const path = require("path");
+// depending if this is being ran before or after compilation
+// we need to check for `.ts` and `.js` extensions and use
+// the appropriate one.
+function getForemanScriptPath() {
+    const file = 'run-foreman';
+    const withJsExtension = path.join(__dirname, file + '.js');
+    const withTsExtension = path.join(__dirname, file + '.ts');
+    if (fs.existsSync(withJsExtension)) {
+        return withJsExtension;
+    }
+    if (fs.existsSync(withTsExtension)) {
+        return withTsExtension;
+    }
+    throw new Error(`Path to ${file} not found`);
+}
+function fork(argv) {
+    const script = getForemanScriptPath();
+    const nf = (0, child_process_1.fork)(script, argv, { stdio: 'inherit' });
+    return new Promise(resolve => {
+        nf.on('exit', function (code) {
+            if (code !== 0)
+                process.exit(code);
+            resolve();
+        });
+    });
+}
+exports.fork = fork;

package/lib/lib/local/load-foreman-procfile.js

@@ -0,0 +1,2 @@
+"use strict";
+module.exports = require('foreman/lib/procfile');

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

@@ -0,0 +1,2 @@
+"use strict";
+require('foreman/nf.js');

package/lib/lib/pipelines/api.d.ts

@@ -0,0 +1,25 @@
+import { APIClient } from '@heroku-cli/command';
+import * as Heroku from '@heroku-cli/schema';
+export declare const V3_HEADER = "application/vnd.heroku+json; version=3";
+export declare const FILTERS_HEADER: string;
+export declare const PIPELINES_HEADER: string;
+export declare function createAppSetup(heroku: APIClient, body: {
+    body: any;
+}): Promise<import("http-call").HTTP<unknown>>;
+export declare function postCoupling(heroku: APIClient, pipeline: any, app: any, stage: string): Promise<import("http-call").HTTP<unknown>>;
+export declare function createCoupling(heroku: APIClient, pipeline: any, app: string, stage: string): Promise<import("http-call").HTTP<unknown>>;
+export declare function createPipeline(heroku: APIClient, name: any, owner: any): Promise<import("http-call").HTTP<unknown>>;
+export declare function createPipelineTransfer(heroku: APIClient, pipeline: Heroku.Pipeline): Promise<import("http-call").HTTP<unknown>>;
+export declare function destroyPipeline(heroku: APIClient, name: any, pipelineId: any): Promise<import("http-call").HTTP<unknown>>;
+export declare function findPipelineByName(heroku: APIClient, idOrName: string): Promise<import("http-call").HTTP<Heroku.Pipeline[]>>;
+export declare function getCoupling(heroku: APIClient, app: string): Promise<import("http-call").HTTP<Heroku.PipelineCoupling>>;
+export declare function getPipeline(heroku: APIClient, id: string): Promise<import("http-call").HTTP<Heroku.Pipeline>>;
+export declare function updatePipeline(heroku: APIClient, id: string, body: Heroku.Pipeline): Promise<import("http-call").HTTP<Heroku.Pipeline>>;
+export declare function getTeam(heroku: APIClient, teamId: any): Promise<import("http-call").HTTP<Heroku.Team>>;
+export declare function getAccountInfo(heroku: APIClient, id?: string): Promise<import("http-call").HTTP<Heroku.Account>>;
+export declare function getAppSetup(heroku: APIClient, buildId: any): Promise<import("http-call").HTTP<unknown>>;
+export declare function listPipelineApps(heroku: APIClient, pipelineId: string): Promise<Array<Heroku.App>>;
+export declare function patchCoupling(heroku: APIClient, id: string, stage: string): Promise<import("http-call").HTTP<unknown>>;
+export declare function removeCoupling(heroku: APIClient, app: string): Promise<import("http-call").HTTP<unknown>>;
+export declare function updateCoupling(heroku: APIClient, app: string, stage: string): Promise<import("http-call").HTTP<unknown>>;
+export declare function getReleases(heroku: APIClient, appId: string): Promise<import("http-call").HTTP<Heroku.Release[]>>;

package/lib/lib/pipelines/api.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getReleases = exports.updateCoupling = exports.removeCoupling = exports.patchCoupling = exports.listPipelineApps = exports.getAppSetup = exports.getAccountInfo = exports.getTeam = exports.updatePipeline = exports.getPipeline = exports.getCoupling = exports.findPipelineByName = exports.destroyPipeline = exports.createPipelineTransfer = exports.createPipeline = exports.createCoupling = exports.postCoupling = exports.createAppSetup = exports.PIPELINES_HEADER = exports.FILTERS_HEADER = exports.V3_HEADER = void 0;
+const lodash_1 = require("lodash");
+exports.V3_HEADER = 'application/vnd.heroku+json; version=3';
+exports.FILTERS_HEADER = `${exports.V3_HEADER}.filters`;
+exports.PIPELINES_HEADER = `${exports.V3_HEADER}.pipelines`;
+function createAppSetup(heroku, body) {
+    return heroku.post('/app-setups', { body });
+}
+exports.createAppSetup = createAppSetup;
+function postCoupling(heroku, pipeline, app, stage) {
+    return heroku.post('/pipeline-couplings', {
+        body: { app, pipeline, stage },
+    });
+}
+exports.postCoupling = postCoupling;
+function createCoupling(heroku, pipeline, app, stage) {
+    return postCoupling(heroku, pipeline.id, app, stage);
+}
+exports.createCoupling = createCoupling;
+function createPipeline(heroku, name, owner) {
+    return heroku.request('/pipelines', {
+        method: 'POST',
+        headers: { Accept: exports.PIPELINES_HEADER },
+        body: { name, owner },
+    });
+}
+exports.createPipeline = createPipeline;
+function createPipelineTransfer(heroku, pipeline) {
+    return heroku.post('/pipeline-transfers', {
+        body: pipeline,
+    });
+}
+exports.createPipelineTransfer = createPipelineTransfer;
+function deleteCoupling(heroku, id) {
+    return heroku.delete(`/pipeline-couplings/${id}`);
+}
+function destroyPipeline(heroku, name, pipelineId) {
+    return heroku.request(`/pipelines/${pipelineId}`, {
+        method: 'DELETE',
+        headers: { Accept: exports.PIPELINES_HEADER },
+        body: { name },
+    });
+}
+exports.destroyPipeline = destroyPipeline;
+function findPipelineByName(heroku, idOrName) {
+    return heroku.request(`/pipelines?eq[name]=${idOrName}`, {
+        method: 'GET',
+        headers: { Accept: exports.PIPELINES_HEADER },
+    });
+}
+exports.findPipelineByName = findPipelineByName;
+function getCoupling(heroku, app) {
+    return heroku.get(`/apps/${app}/pipeline-couplings`);
+}
+exports.getCoupling = getCoupling;
+function getPipeline(heroku, id) {
+    return heroku.request(`/pipelines/${id}`, {
+        method: 'GET',
+        headers: { Accept: exports.PIPELINES_HEADER },
+    });
+}
+exports.getPipeline = getPipeline;
+function updatePipeline(heroku, id, body) {
+    return heroku.patch(`/pipelines/${id}`, {
+        body,
+    });
+}
+exports.updatePipeline = updatePipeline;
+// function getApp(heroku: APIClient, app) {
+//   return heroku.get(`/apps/${app}`)
+// }
+function getTeam(heroku, teamId) {
+    return heroku.get(`/teams/${teamId}`);
+}
+exports.getTeam = getTeam;
+function getAppFilter(heroku, appIds) {
+    return heroku.request('/filters/apps', {
+        method: 'POST',
+        headers: { Accept: exports.FILTERS_HEADER, Range: 'id ..; max=1000;' },
+        body: { in: { id: appIds } },
+    });
+}
+function getAccountInfo(heroku, id = '~') {
+    return heroku.get(`/users/${id}`);
+}
+exports.getAccountInfo = getAccountInfo;
+function getAppSetup(heroku, buildId) {
+    return heroku.get(`/app-setups/${buildId}`);
+}
+exports.getAppSetup = getAppSetup;
+function listCouplings(heroku, pipelineId) {
+    return heroku.get(`/pipelines/${pipelineId}/pipeline-couplings`);
+}
+function listPipelineApps(heroku, pipelineId) {
+    return listCouplings(heroku, pipelineId).then(({ body: couplings }) => {
+        const appIds = couplings.map(coupling => (coupling.app && coupling.app.id) || '');
+        return getAppFilter(heroku, appIds).then(({ body: apps }) => {
+            const couplingsByAppId = (0, lodash_1.keyBy)(couplings, coupling => coupling.app && coupling.app.id);
+            return apps.map(app => {
+                return Object.assign(Object.assign({}, app), { coupling: couplingsByAppId[app.id] });
+            });
+        });
+    });
+}
+exports.listPipelineApps = listPipelineApps;
+function patchCoupling(heroku, id, stage) {
+    return heroku.patch(`/pipeline-couplings/${id}`, { body: { stage } });
+}
+exports.patchCoupling = patchCoupling;
+function removeCoupling(heroku, app) {
+    return getCoupling(heroku, app)
+        .then(({ body }) => {
+        return deleteCoupling(heroku, body.id);
+    });
+}
+exports.removeCoupling = removeCoupling;
+function updateCoupling(heroku, app, stage) {
+    return getCoupling(heroku, app)
+        .then(({ body: coupling }) => patchCoupling(heroku, coupling.id, stage));
+}
+exports.updateCoupling = updateCoupling;
+function getReleases(heroku, appId) {
+    return heroku.get(`/apps/${appId}/releases`, {
+        headers: { Accept: exports.V3_HEADER, Range: 'version ..; order=desc' },
+        partial: true,
+    });
+}
+exports.getReleases = getReleases;

package/lib/lib/pipelines/disambiguate.d.ts

@@ -0,0 +1,3 @@
+import { APIClient } from '@heroku-cli/command';
+import * as Heroku from '@heroku-cli/schema';
+export default function disambiguate(heroku: APIClient, pipelineIDOrName: string): Promise<Heroku.Pipeline>;

package/lib/lib/pipelines/disambiguate.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const inquirer_1 = require("inquirer");
+const validator_1 = require("validator");
+const api_1 = require("./api");
+async function disambiguate(heroku, pipelineIDOrName) {
+    let pipeline;
+    if ((0, validator_1.isUUID)(pipelineIDOrName)) {
+        const result = (await (0, api_1.getPipeline)(heroku, pipelineIDOrName));
+        pipeline = result.body;
+    }
+    else {
+        const { body: pipelines } = await (0, api_1.findPipelineByName)(heroku, pipelineIDOrName);
+        if (pipelines.length === 0) {
+            throw new Error('Pipeline not found');
+        }
+        else if (pipelines.length === 1) {
+            pipeline = pipelines[0];
+        }
+        else {
+            // Disambiguate
+            const choices = pipelines.map(x => {
+                return {
+                    name: new Date(x.created_at).toString(),
+                    value: x,
+                };
+            });
+            const questions = [{
+                    type: 'list',
+                    name: 'pipeline',
+                    message: `Which ${pipelineIDOrName} pipeline?`,
+                    choices,
+                }];
+            // eslint-disable-next-line no-async-promise-executor
+            pipeline = await new Promise(async function (resolve, reject) {
+                const answers = await (0, inquirer_1.prompt)(questions);
+                if (answers.pipeline) {
+                    resolve(answers.pipeline);
+                }
+                else {
+                    // eslint-disable-next-line prefer-promise-reject-errors
+                    reject('Must pick a pipeline');
+                }
+            });
+        }
+    }
+    return pipeline;
+}
+exports.default = disambiguate;

package/lib/lib/pipelines/github-api.d.ts

@@ -0,0 +1,8 @@
+import HTTP from 'http-call';
+export default class GitHubAPI {
+    version: any;
+    token: any;
+    constructor(version: any, token: any);
+    request(url: any, options?: any): Promise<HTTP<unknown>>;
+    getRepo(name: any): Promise<any>;
+}

package/lib/lib/pipelines/github-api.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const http_call_1 = require("http-call");
+const GITHUB_API = 'https://api.github.com';
+class GitHubAPI {
+    constructor(version, token) {
+        this.version = version;
+        this.token = token;
+    }
+    request(url, options = {}) {
+        options.headers = Object.assign({ Authorization: `Token ${this.token}`, 'User-Agent': this.version }, options.headers);
+        return http_call_1.default.get(`${GITHUB_API}${url}`, options);
+    }
+    getRepo(name) {
+        return this.request(`/repos/${name}`).then((res) => res.body);
+    }
+}
+exports.default = GitHubAPI;

package/lib/lib/pipelines/infer.d.ts

@@ -0,0 +1 @@
+export default function infer(app: string): string[];

package/lib/lib/pipelines/infer.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const stages_1 = require("./stages");
+function infer(app) {
+    const inferredStage = stages_1.inferrableStages.find(stage => stage.inferRegex.test(app));
+    if (inferredStage) {
+        return [app.replace(inferredStage.inferRegex, ''), inferredStage.name];
+    }
+    return [app, 'production'];
+}
+exports.default = infer;

package/lib/lib/pipelines/key-by.d.ts

@@ -0,0 +1 @@
+export default function keyBy(list: any, propertyOrCb: any): any;

package/lib/lib/pipelines/key-by.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function keyBy(list, propertyOrCb) {
+    const isCallback = typeof propertyOrCb === 'function';
+    return list.reduce((memo, item) => {
+        const key = isCallback ? propertyOrCb(item) : item[propertyOrCb];
+        memo[key] = item;
+        return memo;
+    }, {});
+}
+exports.default = keyBy;

package/lib/lib/pipelines/kolkrabbi-api.d.ts

@@ -0,0 +1,14 @@
+export default class {
+    version: any;
+    getToken: () => any;
+    constructor(version: any, getToken: () => any);
+    request(url: string, options?: any): Promise<any>;
+    getAccount(): Promise<any>;
+    createPipelineRepository(pipeline: any, repository: any): Promise<any>;
+    updatePipelineRepository(pipeline: any, body: any): Promise<any>;
+    updateAppLink(app: any, body: any): Promise<any>;
+    getAppLink(app: any): Promise<any>;
+    getPipelineRepository(pipeline: any): Promise<any>;
+    getPipelineGithub(pipeline: any): Promise<any>;
+    getArchiveURL(repo: any, ref: any): Promise<any>;
+}

package/lib/lib/pipelines/kolkrabbi-api.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const http_call_1 = require("http-call");
+const KOLKRABBI_BASE_URL = 'https://kolkrabbi.heroku.com';
+class default_1 {
+    constructor(version, getToken) {
+        this.version = version;
+        this.getToken = getToken;
+    }
+    request(url, options = {}) {
+        options.headers = {
+            Authorization: `Bearer ${this.getToken()}`,
+            'User-Agent': this.version,
+        };
+        if (['POST', 'PATCH', 'DELETE'].includes(options.method)) {
+            options.headers['Content-type'] = 'application/json';
+        }
+        return http_call_1.HTTP.request(KOLKRABBI_BASE_URL + url, options).then((res) => res.body);
+    }
+    getAccount() {
+        return this.request('/account/github/token');
+    }
+    createPipelineRepository(pipeline, repository) {
+        return this.request(`/pipelines/${pipeline}/repository`, {
+            method: 'POST',
+            body: { repository },
+        });
+    }
+    updatePipelineRepository(pipeline, body) {
+        return this.request(`/pipelines/${pipeline}/repository`, {
+            method: 'PATCH',
+            body,
+        });
+    }
+    updateAppLink(app, body) {
+        return this.request(`/apps/${app}/github`, {
+            method: 'PATCH',
+            body,
+        });
+    }
+    getAppLink(app) {
+        return this.request(`/apps/${app}/github`, {
+            method: 'GET',
+        });
+    }
+    getPipelineRepository(pipeline) {
+        return this.request(`/pipelines/${pipeline}/repository`, {
+            method: 'GET',
+        });
+    }
+    getPipelineGithub(pipeline) {
+        return this.request(`/pipelines/${pipeline}/github`, {
+            method: 'GET',
+        });
+    }
+    getArchiveURL(repo, ref) {
+        return this.request(`/github/repos/${repo}/tarball/${ref}`, {
+            followRedirect: false,
+        }).then(res => res.archive_link);
+    }
+}
+exports.default = default_1;

package/lib/lib/pipelines/ownership.d.ts

@@ -0,0 +1,4 @@
+import { APIClient } from '@heroku-cli/command';
+import * as Heroku from '@heroku-cli/schema';
+export declare function warnMixedOwnership(pipelineApps: Array<Heroku.App>, pipeline: Heroku.Pipeline, owner: string): void;
+export declare function getOwner(heroku: APIClient, apps: Array<Heroku.App>, pipeline: Heroku.Pipeline): Promise<any>;

package/lib/lib/pipelines/ownership.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOwner = exports.warnMixedOwnership = void 0;
+const color_1 = require("@heroku-cli/color");
+const core_1 = require("@oclif/core");
+const api_1 = require("./api");
+function warnMixedOwnership(pipelineApps, pipeline, owner) {
+    const hasMixedOwnership = pipelineApps.some(app => {
+        return (app.owner && app.owner.id) !== pipeline.owner.id;
+    });
+    if (hasMixedOwnership) {
+        core_1.ux.log();
+        let message = `Some apps in this pipeline do not belong to ${color_1.default.cmd(owner)}.`;
+        message += '\n\nAll apps in a pipeline must have the same owner as the pipeline owner.';
+        message += '\nTransfer these apps or change the pipeline owner in pipeline settings.';
+        message += `\nSee ${color_1.default.cyan('https://devcenter.heroku.com/articles/pipeline-ownership-transition')} for more info.`;
+        core_1.ux.warn(message);
+    }
+}
+exports.warnMixedOwnership = warnMixedOwnership;
+function getOwner(heroku, apps, pipeline) {
+    let owner;
+    let ownerPromise;
+    if (pipeline.owner.type === 'team') {
+        ownerPromise = (0, api_1.getTeam)(heroku, pipeline.owner.id).then(response => response.body);
+    }
+    else {
+        const app = apps.find(app => {
+            return app.owner ? app.owner.id === pipeline.owner.id : false;
+        });
+        // If pipeline owner doesn't own any application and type is user (unlikely)
+        // We return the uuid as default
+        owner = app ? app.owner && app.owner.email : pipeline.owner.id;
+        ownerPromise = Promise.resolve(owner);
+    }
+    return ownerPromise.then(owner => {
+        return owner.name ? `${owner.name} (team)` : owner;
+    });
+}
+exports.getOwner = getOwner;

package/lib/lib/pipelines/render-pipeline.d.ts

@@ -0,0 +1,6 @@
+import { APIClient } from '@heroku-cli/command';
+import * as Heroku from '@heroku-cli/schema';
+export default function renderPipeline(heroku: APIClient, pipeline: Heroku.Pipeline, pipelineApps: Array<Heroku.App>, { withOwners, showOwnerWarning }?: {
+    withOwners: boolean;
+    showOwnerWarning: boolean;
+}): Promise<void>;

package/lib/lib/pipelines/render-pipeline.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const color_1 = require("@heroku-cli/color");
+const core_1 = require("@oclif/core");
+const lodash_1 = require("lodash");
+const ownership_1 = require("./ownership");
+async function renderPipeline(heroku, pipeline, pipelineApps, 
+// eslint-disable-next-line unicorn/no-object-as-default-parameter
+{ withOwners, showOwnerWarning } = { withOwners: false, showOwnerWarning: false }) {
+    core_1.ux.styledHeader(pipeline.name);
+    let owner;
+    if (pipeline.owner) {
+        owner = await (0, ownership_1.getOwner)(heroku, pipelineApps, pipeline);
+        core_1.ux.log(`owner: ${owner}`);
+    }
+    core_1.ux.log('');
+    const columns = {
+        name: {
+            header: 'app name',
+            get(row) {
+                return color_1.default.app(row.name || '');
+            },
+        },
+        'coupling.stage': {
+            header: 'stage',
+            get(row) {
+                return row.coupling.stage;
+            },
+        },
+    };
+    if (withOwners) {
+        columns['owner.email'] = {
+            header: 'owner',
+            get(row) {
+                const email = row.owner && row.owner.email;
+                if (email) {
+                    return email.endsWith('@herokumanager.com') ? `${row.split('@')[0]} (team)` : email;
+                }
+            },
+        };
+    }
+    const developmentApps = (0, lodash_1.sortBy)(pipelineApps.filter(app => app.coupling.stage === 'development'), ['name']);
+    const reviewApps = (0, lodash_1.sortBy)(pipelineApps.filter(app => app.coupling.stage === 'review'), ['name']);
+    const stagingApps = (0, lodash_1.sortBy)(pipelineApps.filter(app => app.coupling.stage === 'staging'), ['name']);
+    const productionApps = (0, lodash_1.sortBy)(pipelineApps.filter(app => app.coupling.stage === 'production'), ['name']);
+    const apps = developmentApps.concat(reviewApps).concat(stagingApps).concat(productionApps);
+    core_1.ux.table(apps, columns);
+    if (showOwnerWarning && pipeline.owner) {
+        (0, ownership_1.warnMixedOwnership)(pipelineApps, pipeline, owner);
+    }
+}
+exports.default = renderPipeline;