heroku 11.0.0-alpha.1 → 11.0.0-alpha.11

package/README.md

@@ -53,10 +53,13 @@ For other issues, [submit a support ticket](https://help.heroku.com/).
 * [`heroku help`](docs/help.md) - Display help for heroku.
 * [`heroku keys`](docs/keys.md) - add/remove account ssh keys
 * [`heroku labs`](docs/labs.md) - add/remove experimental features
+* [`heroku local`](docs/local.md) - run Heroku app locally
 * [`heroku logs`](docs/logs.md) - display recent log output
 * [`heroku maintenance`](docs/maintenance.md) - enable/disable access to app
+* [`heroku members`](docs/members.md) - manage organization members
 * [`heroku notifications`](docs/notifications.md) - display notifications
 * [`heroku orgs`](docs/orgs.md) - manage organizations
+* [`heroku pipelines`](docs/pipelines.md) - manage pipelines
 * [`heroku plugins`](docs/plugins.md) - List installed plugins.
 * [`heroku ps`](docs/ps.md) - Client tools for Heroku Exec
 * [`heroku regions`](docs/regions.md) - list available regions for deployment

package/lib/commands/local/index.d.ts

@@ -0,0 +1,19 @@
+import { Command } from '@oclif/core';
+export default class Index extends Command {
+    static description: string;
+    static aliases: string[];
+    static args: {
+        processname: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static examples: string[];
+    static flags: {
+        procfile: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        env: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        port: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        restart: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        concurrency: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+    runForeman(execArgv: string[]): Promise<void>;
+    loadProcfile(procfilePath: string): Record<string, string>;
+}

package/lib/commands/local/index.js

@@ -0,0 +1,77 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { fork as foreman } from '../../lib/local/fork-foreman.js';
+import { loadProc } from '../../lib/local/load-foreman-procfile.js';
+import { validateEnvFile } from '../../lib/local/env-file-validator.js';
+export default class Index extends Command {
+    // \n splits the description between the title shown in the help
+    // and the DESCRIPTION section shown in the help
+    static description = 'run heroku app locally\nStart the application specified by a Procfile (defaults to ./Procfile)';
+    static aliases = ['local:start'];
+    static args = {
+        processname: Args.string({ required: false, description: 'name of the process' }),
+    };
+    static examples = [
+        `$ heroku local
+$ heroku local web
+$ heroku local web=2
+$ heroku local web=1,worker=2`,
+    ];
+    static flags = {
+        procfile: Flags.string({
+            char: 'f',
+            description: 'use a different Procfile',
+        }),
+        env: Flags.string({
+            char: 'e',
+            description: 'location of env file (defaults to .env)',
+        }),
+        port: Flags.string({
+            char: 'p',
+            description: 'port to listen on',
+        }),
+        restart: Flags.boolean({
+            char: 'r',
+            description: 'restart process if it dies',
+            hidden: true,
+        }),
+        concurrency: Flags.string({
+            char: 'c',
+            description: 'number of processes to start',
+            hidden: true,
+        }),
+    };
+    async run() {
+        const execArgv = ['start'];
+        const { args, flags } = await this.parse(Index);
+        if (flags.restart) {
+            this.error('--restart is no longer available\nUse forego instead: https://github.com/ddollar/forego');
+        }
+        if (flags.concurrency) {
+            this.error('--concurrency is no longer available\nUse forego instead: https://github.com/ddollar/forego');
+        }
+        const envFile = validateEnvFile(flags.env, this.warn.bind(this));
+        if (flags.procfile)
+            execArgv.push('--procfile', flags.procfile);
+        execArgv.push('--env', envFile);
+        if (flags.port)
+            execArgv.push('--port', flags.port);
+        if (args.processname) {
+            execArgv.push(args.processname);
+        }
+        else {
+            const procfile = flags.procfile || 'Procfile';
+            const procHash = this.loadProcfile(procfile);
+            const processes = Object.keys(procHash).filter(x => x !== 'release');
+            execArgv.push(processes.join(','));
+        }
+        await this.runForeman(execArgv);
+    }
+    // Proxy method to make foreman calls testable
+    async runForeman(execArgv) {
+        return foreman(execArgv);
+    }
+    // Proxy method to make procfile loading testable
+    loadProcfile(procfilePath) {
+        return loadProc(procfilePath);
+    }
+}

package/lib/commands/local/run.d.ts

@@ -0,0 +1,11 @@
+import { Command } from '@oclif/core';
+export default class Run extends Command {
+    static description: string;
+    static examples: string[];
+    static strict: boolean;
+    static flags: {
+        env: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        port: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/local/run.js

@@ -0,0 +1,37 @@
+import { Command, Flags } from '@oclif/core';
+import { fork as foreman } from '../../lib/local/fork-foreman.js';
+import { revertSortedArgs } from '../../lib/run/helpers.js';
+import { validateEnvFile } from '../../lib/local/env-file-validator.js';
+export default class Run extends Command {
+    static description = 'run a one-off command';
+    static examples = [
+        '$ heroku local:run bin/migrate',
+    ];
+    static strict = false;
+    static flags = {
+        env: Flags.string({
+            char: 'e',
+            description: 'location of env file (defaults to .env)',
+        }),
+        port: Flags.string({
+            char: 'p',
+            description: 'port to listen on',
+        }),
+    };
+    async run() {
+        const execArgv = ['run'];
+        const { argv, flags } = await this.parse(Run);
+        const commandArgs = revertSortedArgs(process.argv, argv);
+        if (commandArgs.length === 0) {
+            const errorMessage = 'Usage: heroku local:run [COMMAND]\nMust specify command to run';
+            this.error(errorMessage, { exit: -1 });
+        }
+        const envFile = validateEnvFile(flags.env, this.warn.bind(this));
+        execArgv.push('--env', envFile);
+        if (flags.port)
+            execArgv.push('--port', flags.port);
+        execArgv.push('--'); // disable node-foreman flag parsing
+        execArgv.push(...commandArgs); // eslint-disable-line unicorn/no-array-push-push
+        await foreman(execArgv);
+    }
+}

package/lib/commands/local/version.d.ts

@@ -0,0 +1,5 @@
+import { Command } from '@oclif/core';
+export default class Version extends Command {
+    static description: string;
+    run(): Promise<void>;
+}

package/lib/commands/local/version.js

@@ -0,0 +1,10 @@
+import { Command } from '@oclif/core';
+import { fork as foreman } from '../../lib/local/fork-foreman.js';
+export default class Version extends Command {
+    static description = 'display node-foreman version';
+    async run() {
+        await this.parse(Version);
+        const execArgv = ['--version'];
+        await foreman(execArgv);
+    }
+}

package/lib/commands/members/add.d.ts

@@ -0,0 +1,13 @@
+import { Command } from '@heroku-cli/command';
+export default class MembersAdd extends Command {
+    static topic: string;
+    static description: string;
+    static flags: {
+        role: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        team: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static args: {
+        email: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/members/add.js

@@ -0,0 +1,32 @@
+import { Command, flags } from '@heroku-cli/command';
+import { Args } from '@oclif/core';
+import { RoleCompletion } from '@heroku-cli/command/lib/completions.js';
+import { addMemberToTeam, inviteMemberToTeam } from '../../lib/members/util.js';
+import { isTeamInviteFeatureEnabled, ROLE_DESCRIPTION } from '../../lib/members/team-invite-utils.js';
+export default class MembersAdd extends Command {
+    static topic = 'members';
+    static description = 'adds a user to a team';
+    static flags = {
+        role: flags.string({
+            char: 'r',
+            required: true,
+            description: ROLE_DESCRIPTION,
+            completion: RoleCompletion,
+        }),
+        team: flags.team({ required: true }),
+    };
+    static args = {
+        email: Args.string({ required: true, description: 'email address of the team member' }),
+    };
+    async run() {
+        const { flags, args } = await this.parse(MembersAdd);
+        const { team, role } = flags;
+        const { email } = args;
+        if (await isTeamInviteFeatureEnabled(team, this.heroku)) {
+            await inviteMemberToTeam(email, role, team, this.heroku);
+        }
+        else {
+            await addMemberToTeam(email, role, team, this.heroku);
+        }
+    }
+}

package/lib/commands/members/index.d.ts

@@ -0,0 +1,12 @@
+import { Command } from '@heroku-cli/command';
+export default class MembersIndex extends Command {
+    static topic: string;
+    static description: string;
+    static flags: {
+        role: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        pending: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        team: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/members/index.js

@@ -0,0 +1,80 @@
+import { color } from '@heroku-cli/color';
+import { Command, flags } from '@heroku-cli/command';
+import { RoleCompletion } from '@heroku-cli/command/lib/completions.js';
+import { ux } from '@oclif/core';
+import { hux } from '@heroku/heroku-cli-util';
+import { isTeamInviteFeatureEnabled, getTeamInvites } from '../../lib/members/team-invite-utils.js';
+const buildTableColumns = (teamInvites) => {
+    const baseColumns = {
+        email: {
+            get: ({ email }) => color.cyan(email),
+        },
+        role: {
+            get: ({ role }) => color.green(role),
+        },
+    };
+    if (teamInvites.length > 0) {
+        return {
+            ...baseColumns,
+            status: {
+                get: ({ status }) => color.green(status),
+            },
+        };
+    }
+    return baseColumns;
+};
+export default class MembersIndex extends Command {
+    static topic = 'members';
+    static description = 'list members of a team';
+    static flags = {
+        role: flags.string({
+            char: 'r',
+            description: 'filter by role',
+            completion: RoleCompletion,
+        }),
+        pending: flags.boolean({ description: 'filter by pending team invitations' }),
+        json: flags.boolean({ description: 'output in json format' }),
+        team: flags.team({ required: true }),
+    };
+    async run() {
+        const { flags } = await this.parse(MembersIndex);
+        const { role, pending, json, team } = flags;
+        let teamInvites = [];
+        if (await isTeamInviteFeatureEnabled(team, this.heroku)) {
+            const invites = await getTeamInvites(team, this.heroku);
+            teamInvites = invites.map((invite) => ({
+                email: invite.user?.email || '',
+                role: invite.role,
+                status: 'pending',
+                federated: false,
+                user: invite.user,
+                two_factor_authentication: false,
+                created_at: invite.created_at || '',
+                updated_at: invite.updated_at || '',
+            }));
+        }
+        let { body: members } = await this.heroku.get(`/teams/${team}/members`);
+        // Set status '' to all existing members
+        members.forEach((member) => {
+            member.status = '';
+        });
+        members = [...members, ...teamInvites].sort((a, b) => a.email.localeCompare(b.email));
+        if (role)
+            members = members.filter(m => m.role === role);
+        if (pending)
+            members = members.filter(m => m.status === 'pending');
+        if (json) {
+            ux.stdout(JSON.stringify(members, null, 3));
+        }
+        else if (members.length === 0) {
+            let msg = `No members in ${color.magenta(team || '')}`;
+            if (role)
+                msg += ` with role ${color.green(role)}`;
+            ux.stdout(msg);
+        }
+        else {
+            const tableColumns = buildTableColumns(teamInvites);
+            hux.table(members, tableColumns);
+        }
+    }
+}

package/lib/commands/members/remove.d.ts

@@ -0,0 +1,10 @@
+import { Command } from '@heroku-cli/command';
+export default class MembersRemove extends Command {
+    static topic: string;
+    static description: string;
+    static flags: {
+        team: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static strict: boolean;
+    run(): Promise<void>;
+}

package/lib/commands/members/remove.js

@@ -0,0 +1,43 @@
+import { color } from '@heroku-cli/color';
+import { Command, flags } from '@heroku-cli/command';
+import { ux } from '@oclif/core';
+import { isTeamInviteFeatureEnabled, getTeamInvites } from '../../lib/members/team-invite-utils.js';
+const revokeInvite = async (email, team, heroku) => {
+    ux.action.start(`Revoking invite for ${color.cyan(email)} in ${color.magenta(team)}`);
+    await heroku.delete(`/teams/${team}/invitations/${email}`, {
+        headers: {
+            Accept: 'application/vnd.heroku+json; version=3.team-invitations',
+        },
+    });
+    ux.action.stop();
+};
+const removeUserMembership = async (email, team, heroku) => {
+    ux.action.start(`Removing ${color.cyan(email)} from ${color.magenta(team)}`);
+    await heroku.delete(`/teams/${team}/members/${encodeURIComponent(email)}`);
+    ux.action.stop();
+};
+export default class MembersRemove extends Command {
+    static topic = 'members';
+    static description = 'removes a user from a team';
+    static flags = {
+        team: flags.team({ required: true }),
+    };
+    static strict = false;
+    async run() {
+        const { flags, argv } = await this.parse(MembersRemove);
+        const { team } = flags;
+        const email = argv[0];
+        const teamInviteFeatureEnabled = await isTeamInviteFeatureEnabled(team, this.heroku);
+        let isInvitedUser = false;
+        if (teamInviteFeatureEnabled) {
+            const invites = await getTeamInvites(team, this.heroku);
+            isInvitedUser = Boolean(invites.some(m => m.user?.email === email));
+        }
+        if (teamInviteFeatureEnabled && isInvitedUser) {
+            await revokeInvite(email, team, this.heroku);
+        }
+        else {
+            await removeUserMembership(email, team, this.heroku);
+        }
+    }
+}

package/lib/commands/members/set.d.ts

@@ -0,0 +1,11 @@
+import { Command } from '@heroku-cli/command';
+export default class MembersSet extends Command {
+    static topic: string;
+    static description: string;
+    static strict: boolean;
+    static flags: {
+        role: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        team: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/members/set.js

@@ -0,0 +1,24 @@
+import { Command, flags } from '@heroku-cli/command';
+import { RoleCompletion } from '@heroku-cli/command/lib/completions.js';
+import { addMemberToTeam } from '../../lib/members/util.js';
+import { ROLE_DESCRIPTION } from '../../lib/members/team-invite-utils.js';
+export default class MembersSet extends Command {
+    static topic = 'members';
+    static description = 'sets a members role in a team';
+    static strict = false;
+    static flags = {
+        role: flags.string({
+            char: 'r',
+            required: true,
+            description: ROLE_DESCRIPTION,
+            completion: RoleCompletion,
+        }),
+        team: flags.team({ required: true }),
+    };
+    async run() {
+        const { flags, argv } = await this.parse(MembersSet);
+        const { role, team } = flags;
+        const email = argv[0];
+        await addMemberToTeam(email, role, team, this.heroku, 'PATCH');
+    }
+}

package/lib/commands/pipelines/add.d.ts

@@ -0,0 +1,14 @@
+import { Command } from '@heroku-cli/command';
+export default class PipelinesAdd extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        app: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        remote: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        stage: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static args: {
+        pipeline: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/pipelines/add.js

@@ -0,0 +1,58 @@
+import { color } from '@heroku-cli/color';
+import { Command, flags } from '@heroku-cli/command';
+import { StageCompletion } from '@heroku-cli/command/lib/completions.js';
+import { Args, ux } from '@oclif/core';
+import inquirer from 'inquirer';
+import { createCoupling } from '../../lib/api.js';
+import disambiguate from '../../lib/pipelines/disambiguate.js';
+import infer from '../../lib/pipelines/infer.js';
+import { inferrableStageNames as stageNames } from '../../lib/pipelines/stages.js';
+export default class PipelinesAdd extends Command {
+    static description = `add this app to a pipeline
+The app and pipeline names must be specified.
+The stage of the app will be guessed based on its name if not specified.`;
+    static examples = [
+        '$ heroku pipelines:add my-pipeline -a my-app -s production',
+    ];
+    static flags = {
+        app: flags.app({ required: true }),
+        remote: flags.remote(),
+        stage: flags.string({
+            char: 's',
+            description: 'stage of first app in pipeline',
+            completion: StageCompletion,
+        }),
+    };
+    static args = {
+        pipeline: Args.string({
+            description: 'name of pipeline',
+            required: true,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(PipelinesAdd);
+        const { app } = flags;
+        let stage;
+        const guesses = infer(app);
+        const questions = [];
+        const pipeline = await disambiguate(this.heroku, args.pipeline);
+        if (flags.stage) {
+            stage = flags.stage;
+        }
+        else {
+            questions.push({
+                type: 'list',
+                name: 'stage',
+                message: `Stage of ${app}`,
+                choices: stageNames,
+                default: guesses[1],
+            });
+        }
+        const answers = await inquirer.prompt(questions);
+        if (answers.stage)
+            stage = answers.stage;
+        ux.action.start(`Adding ${color.app(app)} to ${color.pipeline(pipeline.name)} pipeline as ${stage}`);
+        await createCoupling(this.heroku, pipeline, app, stage);
+        ux.action.stop();
+    }
+}

package/lib/commands/pipelines/connect.d.ts

@@ -0,0 +1,12 @@
+import { Command } from '@heroku-cli/command';
+export default class Connect extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        repo: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static args: {
+        name: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/pipelines/connect.js

@@ -0,0 +1,49 @@
+import { Command, flags } from '@heroku-cli/command';
+import { Args, ux } from '@oclif/core';
+import { getPipeline } from '../../lib/api.js';
+import GitHubAPI from '../../lib/pipelines/github-api.js';
+import KolkrabbiAPI from '../../lib/pipelines/kolkrabbi-api.js';
+import getGitHubToken from '../../lib/pipelines/setup/get-github-token.js';
+import getNameAndRepo from '../../lib/pipelines/setup/get-name-and-repo.js';
+import getRepo from '../../lib/pipelines/setup/get-repo.js';
+import { nameAndRepo } from '../../lib/pipelines/setup/validate.js';
+export default class Connect extends Command {
+    static description = 'connect a GitHub repo to an existing pipeline';
+    static examples = [
+        '$ heroku pipelines:connect my-pipeline -r githuborg/reponame',
+    ];
+    static flags = {
+        repo: flags.string({
+            name: 'repo',
+            char: 'r',
+            description: 'the GitHub repository to connect to',
+            required: true,
+        }),
+    };
+    static args = {
+        name: Args.string({
+            description: 'name of pipeline',
+            required: true,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Connect);
+        const combinedInputs = {
+            name: args.name,
+            repo: flags.repo,
+        };
+        const errors = nameAndRepo({ repo: flags.repo });
+        if (errors.length > 0) {
+            this.error(errors.join(', '));
+            return;
+        }
+        const kolkrabbi = new KolkrabbiAPI(this.config.userAgent, () => this.heroku.auth);
+        const github = new GitHubAPI(this.config.userAgent, await getGitHubToken(kolkrabbi));
+        const { name: pipelineName, repo: repoName, } = await getNameAndRepo(combinedInputs);
+        const repo = await getRepo(github, repoName);
+        const pipeline = await getPipeline(this.heroku, pipelineName);
+        ux.action.start('Linking to repo');
+        await kolkrabbi.createPipelineRepository(pipeline.body.id, repo.id);
+        ux.action.stop();
+    }
+}

package/lib/commands/pipelines/create.d.ts

@@ -0,0 +1,15 @@
+import { Command } from '@heroku-cli/command';
+export default class Create extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        app: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        remote: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        stage: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        team: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static args: {
+        name: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/pipelines/create.js

@@ -0,0 +1,89 @@
+import { color } from '@heroku-cli/color';
+import { Command, flags } from '@heroku-cli/command';
+import { StageCompletion } from '@heroku-cli/command/lib/completions.js';
+import { Args, ux } from '@oclif/core';
+import inquirer from 'inquirer';
+import { createCoupling, createPipeline, getAccountInfo, getTeam } from '../../lib/api.js';
+import infer from '../../lib/pipelines/infer.js';
+import { inferrableStageNames as stages } from '../../lib/pipelines/stages.js';
+import { getGenerationByAppId } from '../../lib/apps/generation.js';
+export default class Create extends Command {
+    static description = `create a new pipeline
+  An existing app must be specified as the first app in the pipeline.
+  The pipeline name will be inferred from the app name if not specified.
+  The stage of the app will be guessed based on its name if not specified.
+  The pipeline owner will be the user creating the pipeline if not specified with -t for teams or -o for orgs.`;
+    static examples = [
+        '$ heroku pipelines:create -a my-app-staging',
+        '$ heroku pipelines:create my-pipeline -a my-app-staging',
+    ];
+    static flags = {
+        app: flags.app({ required: true }),
+        remote: flags.remote(),
+        stage: flags.string({
+            name: 'stage',
+            char: 's',
+            description: 'stage of first app in pipeline',
+            completion: StageCompletion,
+        }),
+        team: flags.team({
+            description: 'the team which will own the apps',
+        }),
+    };
+    static args = {
+        name: Args.string({
+            description: 'name of pipeline (defaults to basename of the app)',
+            required: false,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Create);
+        const { app, stage: inputStage, team: teamName } = flags;
+        let name;
+        let stage;
+        let owner;
+        const guesses = infer(app);
+        const questions = [];
+        if (args.name) {
+            name = args.name;
+        }
+        else {
+            questions.push({
+                type: 'input',
+                name: 'name',
+                message: 'Pipeline name',
+                default: guesses[0],
+            });
+        }
+        if (inputStage) {
+            stage = inputStage;
+        }
+        else {
+            questions.push({
+                type: 'list',
+                name: 'stage',
+                message: `Stage of ${app}`,
+                choices: stages,
+                default: guesses[1],
+            });
+        }
+        const ownerType = teamName ? 'team' : 'user';
+        // If team or org is not specified, we assign ownership to the user creating
+        const response = teamName ? await getTeam(this.heroku, teamName) : await getAccountInfo(this.heroku);
+        owner = response.body;
+        const ownerID = owner.id;
+        owner = { id: ownerID, type: ownerType };
+        const answers = await inquirer.prompt(questions);
+        if (answers.name)
+            name = answers.name;
+        if (answers.stage)
+            stage = answers.stage;
+        ux.action.start(`Creating ${name} pipeline`);
+        const generation = await getGenerationByAppId(app, this.heroku);
+        const { body: pipeline } = await createPipeline(this.heroku, name, owner, generation);
+        ux.action.stop();
+        ux.action.start(`Adding ${color.app(app)} to ${color.pipeline(pipeline.name)} pipeline as ${stage}`);
+        await createCoupling(this.heroku, pipeline, app, stage);
+        ux.action.stop();
+    }
+}