heroku 11.0.0-alpha.11 → 11.0.0-alpha.13

package/lib/commands/pipelines/diff.js

@@ -1,11 +1,10 @@
-import { color } from '@heroku-cli/color';
+import { color, hux } from '@heroku/heroku-cli-util';
+import { HTTP } from '@heroku/http-call';
 import { Command, flags } from '@heroku-cli/command';
 import { ux } from '@oclif/core';
-import { hux } from '@heroku/heroku-cli-util';
-import { HTTP } from '@heroku/http-call';
-import { getCoupling, getPipeline, getReleases, listPipelineApps, SDK_HEADER } from '../../lib/api.js';
-import KolkrabbiAPI from '../../lib/pipelines/kolkrabbi-api.js';
+import { SDK_HEADER, getCoupling, getPipeline, getReleases, listPipelineApps, } from '../../lib/api.js';
 import { getGeneration } from '../../lib/apps/generation.js';
+import KolkrabbiAPI from '../../lib/pipelines/kolkrabbi-api.js';
 const PROMOTION_ORDER = ['development', 'staging', 'production'];
 async function diff(targetApp, downstreamApp, githubToken, herokuUserAgent) {
     if (!downstreamApp.repo) {
@@ -24,9 +23,9 @@ async function diff(targetApp, downstreamApp, githubToken, herokuUserAgent) {
     try {
         const path = `${targetApp.repo}/compare/${downstreamApp.hash}...${targetApp.hash}`;
         const headers = {
-            authorization: 'token ' + githubToken,
             'Content-Type': 'application/vnd.github+json',
             'X-GitHub-Api-Version': '2022-11-28',
+            authorization: 'token ' + githubToken,
         };
         if (herokuUserAgent) {
             Reflect.set(headers, 'user-agent', herokuUserAgent);
@@ -48,7 +47,7 @@ async function diff(targetApp, downstreamApp, githubToken, herokuUserAgent) {
             author: {},
             message: {},
         });
-        ux.stdout(`\nhttps://github.com/${path}`);
+        ux.stdout(`\n${color.info(`https://github.com/${path}`)}`);
     }
     catch {
         ux.stdout(`\n${color.app(targetApp.name)} was not compared to ${color.app(downstreamApp.name)} because we were unable to perform a diff`);
@@ -58,17 +57,16 @@ async function diff(targetApp, downstreamApp, githubToken, herokuUserAgent) {
 export default class PipelinesDiff extends Command {
     static description = 'compares the latest release of this app to its downstream app(s)';
     static examples = [
-        '$ heroku pipelines:diff -a my-app-staging',
+        color.command('heroku pipelines:diff -a my-app-staging'),
     ];
     static flags = {
         app: flags.app({ required: true }),
         remote: flags.remote(),
     };
-    kolkrabbi = new KolkrabbiAPI(this.config.userAgent, () => this.heroku.auth);
     getAppInfo = async (appName, appId, generation) => {
         // Find GitHub connection for the app
         const githubApp = await this.kolkrabbi.getAppLink(appId)
-            .catch(() => ({ name: appName, repo: null, hash: null }));
+            .catch(() => ({ hash: null, name: appName, repo: null }));
         // Find the commit hash of the latest release for this app
         let slug;
         let ociImages;
@@ -93,10 +91,11 @@ export default class PipelinesDiff extends Command {
             }
         }
         catch {
-            return { name: appName, repo: githubApp.repo, hash: undefined };
+            return { hash: undefined, name: appName, repo: githubApp.repo };
         }
-        return { name: appName, repo: githubApp.repo, hash: commit };
+        return { hash: commit, name: appName, repo: githubApp.repo };
     };
+    kolkrabbi = new KolkrabbiAPI(this.config.userAgent, () => this.heroku.auth);
     async run() {
         const { flags } = await this.parse(PipelinesDiff);
         const targetAppName = flags.app;
@@ -140,7 +139,7 @@ export default class PipelinesDiff extends Command {
         const targetAppInfo = appInfo[0];
         if (!targetAppInfo.repo) {
             const command = `heroku pipelines:open ${coupling.pipeline.name}`;
-            return ux.error(`${targetAppName} does not seem to be connected to GitHub!\nRun ${color.cyan(command)} and "Connect to GitHub".`);
+            return ux.error(`${targetAppName} does not seem to be connected to GitHub!\nRun ${color.code(command)} and "Connect to GitHub".`);
         }
         if (!targetAppInfo.hash) {
             return ux.error(`No release was found for ${targetAppName}, unable to diff`);

package/lib/commands/pipelines/index.js

@@ -1,10 +1,10 @@
+import { color, hux } from '@heroku/heroku-cli-util';
 import { Command, flags } from '@heroku-cli/command';
 import { ux } from '@oclif/core';
-import { hux } from '@heroku/heroku-cli-util';
 export default class Pipelines extends Command {
     static description = 'list pipelines you have access to';
     static examples = [
-        '$ heroku pipelines',
+        color.command('heroku pipelines'),
     ];
     static flags = {
         json: flags.boolean({ description: 'output in json format' }),
@@ -18,7 +18,7 @@ export default class Pipelines extends Command {
         else {
             hux.styledHeader('My Pipelines');
             for (const pipeline of pipelines) {
-                ux.stdout(pipeline.name);
+                ux.stdout(color.pipeline(pipeline.name || ''));
             }
         }
     }

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

@@ -1,13 +1,13 @@
 import { Command } from '@heroku-cli/command';
 export default class PipelinesInfo extends Command {
+    static args: {
+        pipeline: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
     static description: string;
     static examples: string[];
     static flags: {
         json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         'with-owners': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
-    static args: {
-        pipeline: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
-    };
     run(): Promise<void>;
 }

package/lib/commands/pipelines/info.js

@@ -1,13 +1,19 @@
+import { color, hux } from '@heroku/heroku-cli-util';
 import { Command, flags } from '@heroku-cli/command';
 import { Args } from '@oclif/core';
-import { hux } from '@heroku/heroku-cli-util';
 import { listPipelineApps } from '../../lib/api.js';
 import disambiguate from '../../lib/pipelines/disambiguate.js';
 import renderPipeline from '../../lib/pipelines/render-pipeline.js';
 export default class PipelinesInfo extends Command {
+    static args = {
+        pipeline: Args.string({
+            description: 'pipeline to show list of apps for',
+            required: true,
+        }),
+    };
     static description = 'show list of apps in a pipeline';
     static examples = [
-        '$ heroku pipelines:info my-pipeline',
+        color.command('heroku pipelines:info my-pipeline'),
     ];
     static flags = {
         json: flags.boolean({
@@ -18,23 +24,18 @@ export default class PipelinesInfo extends Command {
             hidden: true,
         }),
     };
-    static args = {
-        pipeline: Args.string({
-            description: 'pipeline to show list of apps for',
-            required: true,
-        }),
-    };
     async run() {
         const { args, flags } = await this.parse(PipelinesInfo);
         const pipeline = await disambiguate(this.heroku, args.pipeline);
         const pipelineApps = await listPipelineApps(this.heroku, pipeline.id);
         if (flags.json) {
+            // eslint-disable-next-line perfectionist/sort-objects
             hux.styledJSON({ pipeline, apps: pipelineApps });
         }
         else {
             await renderPipeline(this.heroku, pipeline, pipelineApps, {
-                withOwners: flags['with-owners'],
                 showOwnerWarning: true,
+                withOwners: flags['with-owners'],
             });
         }
     }

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

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

package/lib/commands/pipelines/open.js

@@ -0,0 +1,19 @@
+import { color } from '@heroku/heroku-cli-util';
+import { Command } from '@heroku-cli/command';
+import { Args, ux } from '@oclif/core';
+import open from 'open';
+import disambiguate from '../../lib/pipelines/disambiguate.js';
+export default class Open extends Command {
+    static args = {
+        pipeline: Args.string({ description: 'name of pipeline', required: true }),
+    };
+    static description = 'open a pipeline in dashboard';
+    static examples = [color.command('heroku pipelines:open my-pipeline')];
+    async run() {
+        const { args } = await this.parse(Open);
+        const pipeline = await disambiguate(this.heroku, args.pipeline);
+        const url = `https://dashboard.heroku.com/pipelines/${pipeline.id}`;
+        ux.stdout(`Opening ${color.info(url)}...`);
+        await open(url);
+    }
+}

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

@@ -0,0 +1,12 @@
+import { Command } from '@heroku-cli/command';
+export default class Promote 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>;
+        to: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static sleep(time: number): Promise<void>;
+    run(): Promise<void>;
+}

package/lib/commands/pipelines/promote.js

@@ -0,0 +1,209 @@
+import { color, hux } from '@heroku/heroku-cli-util';
+import { Command, flags } from '@heroku-cli/command';
+import { ux } from '@oclif/core';
+import assert from 'assert';
+import fetch from 'node-fetch';
+import * as Stream from 'stream';
+import * as util from 'util';
+import { listPipelineApps } from '../../lib/api.js';
+import keyBy from '../../lib/pipelines/key-by.js';
+function assertNotPromotingToSelf(source, target) {
+    assert.notStrictEqual(source, target, `Cannot promote from an app to itself: ${target}. Specify a different target app.`);
+}
+function findAppInPipeline(apps, target) {
+    const found = apps.find(app => (app.name === target) || (app.id === target));
+    assert(found, `Cannot find app ${color.app(target)}`);
+    return found;
+}
+const PROMOTION_ORDER = ['development', 'staging', 'production'];
+const wait = (ms = 100) => new Promise(resolve => setTimeout(resolve, ms));
+function isComplete(promotionTarget) {
+    return promotionTarget.status !== 'pending';
+}
+function isSucceeded(promotionTarget) {
+    return promotionTarget.status === 'succeeded';
+}
+function isFailed(promotionTarget) {
+    return promotionTarget.status === 'failed';
+}
+function pollPromotionStatus(heroku, id, needsReleaseCommand) {
+    return heroku.get(`/pipeline-promotions/${id}/promotion-targets`).then(({ body: targets }) => {
+        if (targets.every(isComplete)) {
+            return targets;
+        }
+        //
+        // With only one target, we can return as soon as the release is created.
+        // The command will then read the release phase output
+        //
+        // `needsReleaseCommand` allows us to keep polling, as it can take a few
+        // seconds to get the release to succeeded after the release command
+        // finished.
+        //
+        if (needsReleaseCommand && targets.length === 1 && targets[0].release !== null) {
+            return targets;
+        }
+        return wait(1000).then(pollPromotionStatus.bind(null, heroku, id, needsReleaseCommand));
+    });
+}
+async function getCoupling(heroku, app) {
+    ux.stdout('Fetching app info...');
+    const { body: coupling } = await heroku.get(`/apps/${app}/pipeline-couplings`);
+    return coupling;
+}
+async function promote(heroku, label, id, sourceAppId, targetApps, secondFactor) {
+    const options = {
+        body: {
+            pipeline: { id },
+            source: { app: { id: sourceAppId } },
+            targets: targetApps.map(app => ({ app: { id: app.id } })),
+        },
+        headers: {},
+    };
+    if (secondFactor) {
+        options.headers = { 'Heroku-Two-Factor-Code': secondFactor };
+    }
+    try {
+        ux.stdout(`${label}...`);
+        const { body: promotions } = await heroku.post('/pipeline-promotions', options);
+        return promotions;
+    }
+    catch (error) {
+        if (!error.body || error.body.id !== 'two_factor') {
+            throw error;
+        }
+        const secondFactor = await heroku.twoFactorPrompt();
+        return promote(heroku, label, id, sourceAppId, targetApps, secondFactor);
+    }
+}
+function assertValidPromotion(app, source, target) {
+    if (!target || PROMOTION_ORDER.indexOf(source) < 0) { // eslint-disable-line unicorn/prefer-includes
+        throw new Error(`Cannot promote ${app} from '${source}' stage`);
+    }
+}
+function assertApps(app, targetApps, targetStage) {
+    if (targetApps.length === 0) {
+        throw new Error(`Cannot promote from ${color.app(app)} as there are no downstream apps in ${targetStage} stage`);
+    }
+}
+async function getRelease(heroku, app, releaseId) {
+    ux.stdout('Fetching release info...');
+    const { body: release } = await heroku.get(`/apps/${app}/releases/${releaseId}`);
+    return release;
+}
+async function streamReleaseCommand(heroku, targets, promotion) {
+    if (targets.length !== 1 || targets.every(isComplete)) {
+        return pollPromotionStatus(heroku, promotion.id, false);
+    }
+    const target = targets[0];
+    const release = await getRelease(heroku, target.app.id, target.release.id);
+    if (!release.output_stream_url) {
+        return pollPromotionStatus(heroku, promotion.id, false);
+    }
+    ux.stdout('Running release command...');
+    async function streamReleaseOutput(releaseStreamUrl) {
+        const finished = util.promisify(Stream.finished);
+        const fetchResponse = await fetch(releaseStreamUrl);
+        if (fetchResponse.status >= 400) {
+            throw new Error('stream release output not available');
+        }
+        fetchResponse.body.pipe(process.stdout);
+        await finished(fetchResponse.body);
+    }
+    async function retry(maxAttempts, fn) {
+        let currentAttempt = 0;
+        while (true) {
+            try {
+                await fn();
+                return;
+            }
+            catch (error) {
+                if (++currentAttempt === maxAttempts) {
+                    throw error;
+                }
+                await Promote.sleep(1000);
+            }
+        }
+    }
+    await retry(100, () => streamReleaseOutput(release.output_stream_url));
+    return pollPromotionStatus(heroku, promotion.id, false);
+}
+export default class Promote extends Command {
+    static description = 'promote the latest release of this app to its downstream app(s)';
+    static examples = [
+        color.command('heroku pipelines:promote -a my-app-staging'),
+    ];
+    static flags = {
+        app: flags.app({
+            required: true,
+        }),
+        remote: flags.remote(),
+        to: flags.string({
+            char: 't',
+            description: 'comma separated list of apps to promote to',
+        }),
+    };
+    static sleep(time) {
+        return new Promise(resolve => setTimeout(resolve, time));
+    }
+    async run() {
+        const { flags } = await this.parse(Promote);
+        const appNameOrId = flags.app;
+        const coupling = await getCoupling(this.heroku, appNameOrId);
+        ux.stdout(`Fetching apps from ${color.pipeline(coupling.pipeline.name)}...`);
+        const allApps = await listPipelineApps(this.heroku, coupling.pipeline.id);
+        const sourceStage = coupling.stage;
+        let promotionActionName = '';
+        let targetApps = [];
+        if (flags.to) {
+            // The user specified a specific set of apps they want to target
+            // We don't have to infer the apps or the stage they want to promote to
+            // Strip out any empty app names due to something like a trailing comma
+            const targetAppNames = flags.to.split(',').filter((appName) => appName.length > 0);
+            // Now let's make sure that we can find every target app they specified
+            // The only requirement is that the app be in this pipeline. They can be at any stage.
+            targetApps = targetAppNames.reduce((acc, targetAppNameOrId) => {
+                assertNotPromotingToSelf(appNameOrId, targetAppNameOrId);
+                const app = findAppInPipeline(allApps, targetAppNameOrId);
+                if (app) {
+                    acc.push(app);
+                }
+                return acc;
+            }, []);
+            promotionActionName = `Starting promotion to apps: ${targetAppNames.toString()}`;
+        }
+        else {
+            const targetStage = PROMOTION_ORDER[PROMOTION_ORDER.indexOf(sourceStage) + 1];
+            assertValidPromotion(appNameOrId, sourceStage, targetStage);
+            targetApps = allApps.filter(app => app.pipelineCoupling.stage === targetStage);
+            assertApps(appNameOrId, targetApps, targetStage);
+            promotionActionName = `Starting promotion to ${targetStage}`;
+        }
+        const promotion = await promote(this.heroku, promotionActionName, coupling.pipeline.id, coupling.app.id, targetApps);
+        const pollLoop = pollPromotionStatus(this.heroku, promotion.id, true);
+        ux.stdout('Waiting for promotion to complete...');
+        let promotionTargets = await pollLoop;
+        try {
+            promotionTargets = await streamReleaseCommand(this.heroku, promotionTargets, promotion);
+        }
+        catch (error) {
+            ux.error(error);
+        }
+        const appsByID = keyBy(allApps, 'id');
+        const styledTargets = promotionTargets.reduce((memo, target) => {
+            const app = appsByID[target.app.id];
+            const details = [target.status];
+            if (isFailed(target)) {
+                details.push(target.error_message);
+            }
+            memo[app.name] = details;
+            return memo;
+        }, {});
+        if (promotionTargets.every(isSucceeded)) {
+            ux.stdout('\nPromotion successful');
+        }
+        else {
+            ux.warn('\nPromotion to some apps failed');
+        }
+        hux.styledObject(styledTargets);
+    }
+}

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

@@ -0,0 +1,10 @@
+import { Command } from '@heroku-cli/command';
+export default class PipelinesRemove 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>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/pipelines/remove.js

@@ -0,0 +1,20 @@
+import { color } from '@heroku/heroku-cli-util';
+import { Command, flags } from '@heroku-cli/command';
+import { ux } from '@oclif/core';
+import { removeCoupling } from '../../lib/api.js';
+export default class PipelinesRemove extends Command {
+    static description = 'remove this app from its pipeline';
+    static examples = [
+        color.command('heroku pipelines:remove -a my-app'),
+    ];
+    static flags = {
+        app: flags.app({ required: true }),
+        remote: flags.remote(),
+    };
+    async run() {
+        const { flags: { app } } = await this.parse(PipelinesRemove);
+        ux.action.start(`Removing ${color.app(app)}`);
+        await removeCoupling(this.heroku, app);
+        ux.action.stop();
+    }
+}

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

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

package/lib/commands/pipelines/rename.js

@@ -0,0 +1,34 @@
+import { color } from '@heroku/heroku-cli-util';
+import { Command } from '@heroku-cli/command';
+import { Args, ux } from '@oclif/core';
+import { updatePipeline } from '../../lib/api.js';
+import disambiguate from '../../lib/pipelines/disambiguate.js';
+export default class PipelinesRename extends Command {
+    /* eslint-disable perfectionist/sort-objects */
+    // the order of args is important for the command to work
+    // TODO: change pipeline to be a flag, which would be consistent with apps:rename
+    static args = {
+        pipeline: Args.string({
+            description: 'name of pipeline to rename',
+            required: true,
+        }),
+        name: Args.string({
+            description: 'new name of pipeline',
+            required: true,
+        }),
+    };
+    /* eslint-enable perfectionist/sort-objects */
+    static description = 'rename a pipeline';
+    static examples = [
+        color.command('heroku pipelines:rename my-pipeline new-pipeline-name'),
+    ];
+    async run() {
+        const { args } = await this.parse(PipelinesRename);
+        const pipeline = await disambiguate(this.heroku, args.pipeline);
+        ux.action.start(`Renaming ${color.pipeline(pipeline.name)} pipeline to ${color.info(args.name)}`);
+        await updatePipeline(this.heroku, pipeline.id, {
+            name: args.name,
+        });
+        ux.action.stop();
+    }
+}

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

@@ -0,0 +1,16 @@
+import { Command } from '@heroku-cli/command';
+import openBrowser from 'open';
+export default class Setup extends Command {
+    static args: {
+        name: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+        repo: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        team: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    static open: typeof openBrowser;
+    run(): Promise<void>;
+}

package/lib/commands/pipelines/setup.js

@@ -0,0 +1,88 @@
+import { color } from '@heroku/heroku-cli-util';
+import { Command, flags } from '@heroku-cli/command';
+import { Args, ux } from '@oclif/core';
+import debug from 'debug';
+import openBrowser from 'open';
+import { createPipeline, getAccountInfo, getTeam } from '../../lib/api.js';
+import GitHubAPI from '../../lib/pipelines/github-api.js';
+import KolkrabbiAPI from '../../lib/pipelines/kolkrabbi-api.js';
+import createApps from '../../lib/pipelines/setup/create-apps.js';
+import getCISettings from '../../lib/pipelines/setup/get-ci-settings.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 getSettings from '../../lib/pipelines/setup/get-settings.js';
+import pollAppSetups from '../../lib/pipelines/setup/poll-app-setups.js';
+import setupPipeline from '../../lib/pipelines/setup/setup-pipeline.js';
+import { STAGING_APP_INDICATOR, nameAndRepo } from '../../lib/pipelines/setup/validate.js';
+const pipelineDebug = debug('pipelines:setup');
+export default class Setup extends Command {
+    static args = {
+        name: Args.string({
+            description: 'name of pipeline',
+            required: false,
+        }),
+        repo: Args.string({
+            description: 'a GitHub repository to connect the pipeline to',
+            required: false,
+        }),
+    };
+    static description = 'bootstrap a new pipeline with common settings and create a production and staging app (requires a fully formed app.json in the repo)';
+    static examples = [color.command('heroku pipelines:setup my-pipeline githuborg/reponame -t my-team')];
+    static flags = {
+        team: flags.team({
+            description: 'the team to assign pipeline ownership to (defaults to current user)',
+        }),
+        yes: flags.boolean({
+            char: 'y',
+            description: 'accept all default settings without prompting',
+        }),
+    };
+    static open = openBrowser;
+    async run() {
+        const { args, flags } = await this.parse(Setup);
+        const errors = nameAndRepo(args);
+        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 { team, yes } = flags;
+        const { name: pipelineName, repo: repoName } = await getNameAndRepo(args);
+        const stagingAppName = pipelineName + STAGING_APP_INDICATOR;
+        const repo = await getRepo(github, repoName);
+        const settings = await getSettings(yes, repo.default_branch);
+        const ciSettings = await getCISettings(yes, team);
+        const ownerType = team ? 'team' : 'user';
+        // If team or org is not specified, we assign ownership to the user creating
+        const { body: { id: ownerID }, } = team ? await getTeam(this.heroku, team) : await getAccountInfo(this.heroku);
+        const owner = { id: ownerID, type: ownerType };
+        ux.action.start('Creating pipeline');
+        const { body: pipeline } = await createPipeline(this.heroku, pipelineName, owner);
+        ux.action.stop();
+        ux.action.start('Linking to repo');
+        await kolkrabbi.createPipelineRepository(pipeline.id, repo.id);
+        ux.action.stop();
+        const archiveURL = await kolkrabbi.getArchiveURL(repoName, repo.default_branch);
+        const appSetupsResult = await createApps(this.heroku, archiveURL, pipeline, pipelineName, stagingAppName, team);
+        const appSetups = appSetupsResult.map((result) => result.body);
+        ux.action.start(`Creating production and staging apps (${color.app(pipelineName)} and ${color.app(stagingAppName)})`);
+        await pollAppSetups(this.heroku, appSetups);
+        ux.action.stop();
+        const stagingApp = appSetups.find((appSetup) => appSetup.app.name === stagingAppName).app;
+        const setup = setupPipeline(kolkrabbi, stagingApp.id, settings, pipeline.id, ciSettings);
+        ux.action.start('Configuring pipeline');
+        try {
+            await setup;
+            await Setup.open(`https://dashboard.heroku.com/pipelines/${pipeline.id}`);
+        }
+        catch (error) {
+            pipelineDebug(error);
+            ux.error(error);
+        }
+        finally {
+            ux.action.stop();
+        }
+    }
+}

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

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