heroku 11.0.0-alpha.11 → 11.0.0-alpha.12

package/lib/commands/pg/upgrade/run.js

@@ -0,0 +1,95 @@
+import { color, utils } from '@heroku/heroku-cli-util';
+import { Command, flags } from '@heroku-cli/command';
+import { Args, ux } from '@oclif/core';
+import tsheredoc from 'tsheredoc';
+import ConfirmCommand from '../../../lib/confirmCommand.js';
+import { databaseNameFromUrl, formatResponseWithCommands } from '../../../lib/pg/util.js';
+import { nls } from '../../../nls.js';
+const heredoc = tsheredoc.default;
+export default class Upgrade extends Command {
+    static args = {
+        database: Args.string({ description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}` }),
+    };
+    static description = heredoc(`
+    starts a Postgres version upgrade
+
+    On Essential-tier databases, this command upgrades the database's Postgres version.
+
+    On Standard-tier and higher leader databases, this command runs a previously scheduled Postgres version upgrade. You must run ${color.code('pg:upgrade:prepare')} before this command to schedule a version upgrade.
+
+    On follower databases, this command unfollows the leader database before upgrading the follower's Postgres version.
+    `);
+    static examples = [
+        heredoc `
+      # Upgrade an Essential-tier database to a specific version
+      ${color.command('heroku pg:upgrade:run postgresql-curved-12345 --version 14 --app myapp')}
+    `,
+        heredoc `
+      # Upgrade a Standard-tier follower database to the latest supported version
+      ${color.command('heroku pg:upgrade:run HEROKU_POSTGRESQL_BLUE_URL --app myapp')}
+    `,
+        heredoc `
+      # Run a previously scheduled upgrade on a Standard-tier leader database
+      ${color.command('heroku pg:upgrade:run DATABASE_URL --app myapp')}
+    `,
+    ];
+    static flags = {
+        app: flags.app({ required: true }),
+        confirm: flags.string({ char: 'c' }),
+        remote: flags.remote({ char: 'r' }),
+        version: flags.string({ char: 'v', description: 'Postgres version to upgrade to' }),
+    };
+    static topic = 'pg';
+    async run() {
+        const { args, flags } = await this.parse(Upgrade);
+        const { app, confirm, version } = flags;
+        const { database } = args;
+        const dbResolver = new utils.pg.DatabaseResolver(this.heroku);
+        const { addon: db } = await dbResolver.getAttachment(app, database);
+        if (utils.pg.isLegacyEssentialDatabase(db))
+            ux.error(`You can only use ${color.code('pg:upgrade:*')} commands on Essential-* and higher plans.`);
+        const versionPhrase = version ? heredoc(`Postgres version ${version}`) : heredoc('the latest supported Postgres version');
+        const { body: replica } = await this.heroku.get(`/client/v11/databases/${db.id}`, { hostname: utils.pg.host() });
+        if (utils.pg.isEssentialDatabase(db)) {
+            await new ConfirmCommand().confirm(app, confirm, heredoc(`
+        Destructive action
+        You're upgrading ${color.addon(db.name)} to ${versionPhrase}.
+
+        You can't undo this action.
+      `));
+        }
+        else if (replica.following) {
+            const { body: configVars } = await this.heroku.get(`/apps/${app}/config-vars`);
+            const origin = databaseNameFromUrl(replica.following, configVars);
+            await new ConfirmCommand().confirm(app, confirm, heredoc(`
+        Destructive action
+        You're upgrading ${color.addon(db.name)} to ${versionPhrase}. The database will stop following ${origin} and become writable.
+
+        You can't undo this action.
+      `));
+        }
+        else {
+            await new ConfirmCommand().confirm(app, confirm, heredoc(`
+        Destructive action
+        You're upgrading the Postgres version on ${color.datastore(db.name)}. This action also upgrades any followers on the database.
+
+        You can't undo this action.
+      `));
+        }
+        try {
+            const data = { version };
+            ux.action.start(`Starting upgrade on ${color.datastore(db.name)}`);
+            const response = await this.heroku.post(`/client/v11/databases/${db.id}/upgrade/run`, { hostname: utils.pg.host(), body: data });
+            ux.action.stop(heredoc(`done\n${formatResponseWithCommands(response.body.message)}`));
+        }
+        catch (error) {
+            if (error instanceof Error && 'body' in error) {
+                const response = error;
+                ux.error(heredoc(`${formatResponseWithCommands(response.body.message)}\n\nError ID: ${response.body.id}`));
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+}

package/lib/commands/pg/upgrade/wait.d.ts

@@ -0,0 +1,16 @@
+import { Command } from '@heroku-cli/command';
+export default class Wait extends Command {
+    static args: {
+        database: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        app: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        'no-notify': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        remote: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'wait-interval': import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static topic: string;
+    run(): Promise<void>;
+}

package/lib/commands/pg/upgrade/wait.js

@@ -0,0 +1,105 @@
+import { color, utils } from '@heroku/heroku-cli-util';
+import { HTTPError } from '@heroku/http-call';
+import { Command, flags } from '@heroku-cli/command';
+import { Args, ux } from '@oclif/core';
+import debug from 'debug';
+import tsheredoc from 'tsheredoc';
+import notify from '../../../lib/notify.js';
+import { formatResponseWithCommands } from '../../../lib/pg/util.js';
+import { nls } from '../../../nls.js';
+const heredoc = tsheredoc.default;
+const wait = (ms) => new Promise(resolve => {
+    setTimeout(resolve, ms);
+});
+export default class Wait extends Command {
+    static args = {
+        database: Args.string({ description: `${nls('pg:database:arg:description')}` }),
+    };
+    static description = 'provides the status of an upgrade and blocks it until the operation is complete';
+    static examples = [
+        heredoc(`
+      # Wait for upgrade to complete with default settings
+      ${color.command('heroku pg:upgrade:wait postgresql-curved-12345 --app myapp')}
+    `),
+        heredoc(`
+      # Wait with custom polling interval
+      ${color.command('heroku pg:upgrade:wait postgresql-curved-12345 --app myapp --wait-interval 10')}
+    `),
+        heredoc(`
+      # Wait without showing OS notifications
+      ${color.command('heroku pg:upgrade:wait postgresql-curved-12345 --app myapp --no-notify')}
+    `),
+    ];
+    static flags = {
+        app: flags.app({ required: true }),
+        'no-notify': flags.boolean({ description: 'do not show OS notification' }),
+        remote: flags.remote(),
+        'wait-interval': flags.integer({ description: 'how frequently to poll in seconds (to avoid rate limiting)' }),
+    };
+    static topic = 'pg';
+    async run() {
+        const { args, flags } = await this.parse(Wait);
+        const { app, 'wait-interval': waitInterval } = flags;
+        const dbName = args.database;
+        const pgDebug = debug('pg');
+        const waitFor = async (db) => {
+            const interval = (!waitInterval || waitInterval < 0) ? 5 : waitInterval;
+            let status;
+            let waiting = false;
+            let retries = 20;
+            const notFoundMessage = 'Waiting to provision...';
+            while (true) {
+                try {
+                    ({ body: status } = await this.heroku.get(`/client/v11/databases/${db.id}/upgrade/wait_status`, { hostname: utils.pg.host() }));
+                }
+                catch (error) {
+                    if (error instanceof HTTPError && (!retries || error.statusCode !== 404)) {
+                        const httpError = error;
+                        pgDebug(httpError);
+                        throw httpError;
+                    }
+                    retries--;
+                    status = { message: notFoundMessage, 'waiting?': true };
+                }
+                let message = formatResponseWithCommands(status.message);
+                if (status.step)
+                    message = heredoc(`(${status.step}) ${message}`);
+                if (status['error?']) {
+                    notify('error', `${db.name} ${message}`, false);
+                    ux.error(message || '', { exit: 1 });
+                }
+                if (!status['waiting?']) {
+                    if (waiting) {
+                        ux.action.stop(message);
+                    }
+                    else {
+                        ux.stdout(heredoc(`Waiting for database ${color.yellow(db.name)}... ${message}`));
+                    }
+                    return;
+                }
+                if (!waiting) {
+                    waiting = true;
+                    ux.action.start(`Waiting for database ${color.yellow(db.name)}`, message);
+                }
+                ux.action.status = message;
+                await wait(interval * 1000);
+            }
+        };
+        // This is actually incorrect, if we're only using one db we should make the database arg required and
+        // just use the resolver to get the add-on to be waited on.
+        // This looks similar to other implementations where you also can wait on all databases from the same app.
+        // Maybe it was initially thought to implement this in the future, but it was never implemented.
+        let dbs = [];
+        if (dbName) {
+            const dbResolver = new utils.pg.DatabaseResolver(this.heroku);
+            const { addon } = await dbResolver.getAttachment(app, dbName);
+            dbs = [addon];
+        }
+        else {
+            ux.error(heredoc('You must provide a database. Run `--help` for more information on the command.'));
+        }
+        for (const db of dbs) {
+            await waitFor(db);
+        }
+    }
+}

package/lib/commands/pg/vacuum-stats.d.ts

@@ -0,0 +1,13 @@
+import { Command } from '@heroku-cli/command';
+export default class VacuumStats extends Command {
+    static topic: string;
+    static description: 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>;
+    };
+    static args: {
+        database: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/lib/{oldCommands → commands}/pg/vacuum-stats.js

@@ -1,28 +1,25 @@
-export {};
-/*
-import {Command, flags} from '@heroku-cli/command'
-import {Args, ux} from '@oclif/core'
-import {database} from '../../lib/pg/fetcher'
-import {exec} from '../../lib/pg/psql'
-import heredoc from 'tsheredoc'
-import {nls} from '../../nls'
-
+import { Command, flags } from '@heroku-cli/command';
+import { Args, ux } from '@oclif/core';
+import { utils } from '@heroku/heroku-cli-util';
+import tsheredoc from 'tsheredoc';
+import { nls } from '../../nls.js';
+const heredoc = tsheredoc.default;
 export default class VacuumStats extends Command {
-  static topic = 'pg';
-  static description = 'show dead rows and whether an automatic vacuum is expected to be triggered';
-  static flags = {
-    app: flags.app({required: true}),
-    remote: flags.remote(),
-  }
-
-  static args = {
-    database: Args.string({description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}`}),
-  }
-
-  public async run(): Promise<void> {
-    const {flags, args} = await this.parse(VacuumStats)
-    const db = await database(this.heroku, flags.app, args.database)
-    const query = heredoc(`
+    static topic = 'pg';
+    static description = 'show dead rows and whether an automatic vacuum is expected to be triggered';
+    static flags = {
+        app: flags.app({ required: true }),
+        remote: flags.remote(),
+    };
+    static args = {
+        database: Args.string({ description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}` }),
+    };
+    async run() {
+        const { flags, args } = await this.parse(VacuumStats);
+        const dbResolver = new utils.pg.DatabaseResolver(this.heroku);
+        const db = await dbResolver.getDatabase(flags.app, args.database);
+        const psqlService = new utils.pg.PsqlService(db);
+        const query = heredoc(`
       WITH table_opts AS (
         SELECT
           pg_class.oid, relname, nspname, array_to_string(reloptions, '') AS relopts
@@ -61,9 +58,8 @@ export default class VacuumStats extends Command {
         pg_stat_user_tables psut INNER JOIN pg_class ON psut.relid = pg_class.oid
           INNER JOIN vacuum_settings ON pg_class.oid = vacuum_settings.oid
       ORDER BY 1
-    `)
-    const output = await exec(db, query)
-    ux.log(output)
-  }
+    `);
+        const output = await psqlService.execQuery(query);
+        ux.stdout(output);
+    }
 }
-*/

package/lib/commands/pg/wait.d.ts

@@ -0,0 +1,15 @@
+import { Command } from '@heroku-cli/command';
+export default class Wait extends Command {
+    static topic: string;
+    static description: string;
+    static flags: {
+        'wait-interval': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'no-notify': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        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>;
+    };
+    static args: {
+        database: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/pg/wait.js

@@ -0,0 +1,79 @@
+import { Command, flags } from '@heroku-cli/command';
+import { Args, ux } from '@oclif/core';
+import debug from 'debug';
+import { utils, color } from '@heroku/heroku-cli-util';
+import notify from '../../lib/notify.js';
+import { nls } from '../../nls.js';
+const wait = (ms) => new Promise(resolve => {
+    setTimeout(resolve, ms);
+});
+export default class Wait extends Command {
+    static topic = 'pg';
+    static description = 'blocks until database is available';
+    static flags = {
+        'wait-interval': flags.string({ description: 'how frequently to poll in seconds (to avoid rate limiting)' }),
+        'no-notify': flags.boolean({ description: 'do not show OS notification' }),
+        app: flags.app({ required: true }),
+        remote: flags.remote(),
+    };
+    static args = {
+        database: Args.string({ description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:all-dbs:suffix')}` }),
+    };
+    async run() {
+        const { flags, args } = await this.parse(Wait);
+        const { app, 'wait-interval': waitInterval } = flags;
+        const dbName = args.database;
+        const pgDebug = debug('pg');
+        const waitFor = async (db) => {
+            let interval = waitInterval && Number.parseInt(waitInterval, 10);
+            if (!interval || interval < 0)
+                interval = 5;
+            let status;
+            let waiting = false;
+            let retries = 20;
+            const notFoundMessage = 'Waiting to provision...';
+            while (true) {
+                try {
+                    ({ body: status } = await this.heroku.get(`/client/v11/databases/${db.id}/wait_status`, { hostname: utils.pg.host() }));
+                }
+                catch (error) {
+                    const httpError = error;
+                    pgDebug(httpError);
+                    if (!retries || httpError.statusCode !== 404)
+                        throw httpError;
+                    retries--;
+                    status = { 'waiting?': true, message: notFoundMessage };
+                }
+                if (status['error?']) {
+                    notify('error', `${db.name} ${status.message}`, false);
+                    ux.error(status.message || '', { exit: 1 });
+                }
+                if (!status['waiting?']) {
+                    if (waiting) {
+                        ux.action.stop(status.message);
+                    }
+                    return;
+                }
+                if (!waiting) {
+                    waiting = true;
+                    ux.action.start(`Waiting for database ${color.yellow(db.name)}`, status.message);
+                }
+                ux.action.status = status.message;
+                await wait(interval * 1000);
+            }
+        };
+        let dbs;
+        if (dbName) {
+            const dbResolver = new utils.pg.DatabaseResolver(this.heroku);
+            const { addon } = await dbResolver.getAttachment(app, dbName);
+            dbs = [addon];
+        }
+        else {
+            const dbResolver = new utils.pg.DatabaseResolver(this.heroku);
+            dbs = await dbResolver.getAllLegacyDatabases(app);
+        }
+        for (const db of dbs) {
+            await waitFor(db);
+        }
+    }
+}

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

@@ -1,5 +1,8 @@
 import { Command } from '@heroku-cli/command';
 export default class PipelinesAdd extends Command {
+    static args: {
+        pipeline: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
     static description: string;
     static examples: string[];
     static flags: {
@@ -7,8 +10,5 @@ export default class PipelinesAdd extends Command {
         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

@@ -1,4 +1,4 @@
-import { color } from '@heroku-cli/color';
+import { color } from '@heroku/heroku-cli-util';
 import { Command, flags } from '@heroku-cli/command';
 import { StageCompletion } from '@heroku-cli/command/lib/completions.js';
 import { Args, ux } from '@oclif/core';
@@ -8,25 +8,25 @@ 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 args = {
+        pipeline: Args.string({
+            description: 'name of pipeline',
+            required: true,
+        }),
+    };
     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',
+        color.command('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,
+            description: 'stage of first app in pipeline',
         }),
     };
     async run() {
@@ -41,17 +41,17 @@ The stage of the app will be guessed based on its name if not specified.`;
         }
         else {
             questions.push({
-                type: 'list',
-                name: 'stage',
-                message: `Stage of ${app}`,
                 choices: stageNames,
                 default: guesses[1],
+                message: `Stage of ${app}`,
+                name: 'stage',
+                type: 'list',
             });
         }
         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}`);
+        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.js

@@ -1,4 +1,5 @@
 import { Command, flags } from '@heroku-cli/command';
+import { color } from '@heroku/heroku-cli-util';
 import { Args, ux } from '@oclif/core';
 import { getPipeline } from '../../lib/api.js';
 import GitHubAPI from '../../lib/pipelines/github-api.js';
@@ -10,7 +11,7 @@ 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',
+        color.command('heroku pipelines:connect my-pipeline -r githuborg/reponame'),
     ];
     static flags = {
         repo: flags.string({

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

@@ -1,5 +1,8 @@
 import { Command } from '@heroku-cli/command';
 export default class Create extends Command {
+    static args: {
+        name: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
     static description: string;
     static examples: string[];
     static flags: {
@@ -8,8 +11,5 @@ export default class Create extends Command {
         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

@@ -1,41 +1,41 @@
-import { color } from '@heroku-cli/color';
+import { color } from '@heroku/heroku-cli-util';
 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 { createCoupling, createPipeline, getAccountInfo, getTeam, } from '../../lib/api.js';
+import { getGenerationByAppId } from '../../lib/apps/generation.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 args = {
+        name: Args.string({
+            description: 'name of pipeline (defaults to basename of the app)',
+            required: false,
+        }),
+    };
     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',
+        color.command('heroku pipelines:create -a my-app-staging'),
+        color.command('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,
+            description: 'stage of first app in pipeline',
+            name: 'stage',
         }),
         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;
@@ -49,10 +49,10 @@ export default class Create extends Command {
         }
         else {
             questions.push({
-                type: 'input',
-                name: 'name',
-                message: 'Pipeline name',
                 default: guesses[0],
+                message: 'Pipeline name',
+                name: 'name',
+                type: 'input',
             });
         }
         if (inputStage) {
@@ -60,11 +60,11 @@ export default class Create extends Command {
         }
         else {
             questions.push({
-                type: 'list',
-                name: 'stage',
-                message: `Stage of ${app}`,
                 choices: stages,
                 default: guesses[1],
+                message: `Stage of ${app}`,
+                name: 'stage',
+                type: 'list',
             });
         }
         const ownerType = teamName ? 'team' : 'user';
@@ -82,7 +82,7 @@ export default class Create extends Command {
         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}`);
+        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/destroy.d.ts

@@ -1,9 +1,9 @@
 import { Command } from '@heroku-cli/command';
 export default class PipelinesDestroy extends Command {
-    static description: string;
-    static examples: string[];
     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/destroy.js

@@ -1,19 +1,19 @@
-import { color } from '@heroku-cli/color';
+import { color } from '@heroku/heroku-cli-util';
 import { Command } from '@heroku-cli/command';
 import { Args, ux } from '@oclif/core';
 import { destroyPipeline } from '../../lib/api.js';
 import disambiguate from '../../lib/pipelines/disambiguate.js';
 export default class PipelinesDestroy extends Command {
-    static description = 'destroy a pipeline';
-    static examples = [
-        '$ heroku pipelines:destroy my-pipeline',
-    ];
     static args = {
         pipeline: Args.string({
             description: 'name of pipeline',
             required: true,
         }),
     };
+    static description = 'destroy a pipeline';
+    static examples = [
+        color.command('heroku pipelines:destroy my-pipeline'),
+    ];
     async run() {
         const { args } = await this.parse(PipelinesDestroy);
         const pipeline = await disambiguate(this.heroku, args.pipeline);

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

@@ -1,10 +1,10 @@
 import { Command } from '@heroku-cli/command';
-import KolkrabbiAPI from '../../lib/pipelines/kolkrabbi-api.js';
 import { GenerationKind } from '../../lib/apps/generation.js';
+import KolkrabbiAPI from '../../lib/pipelines/kolkrabbi-api.js';
 interface AppInfo {
+    hash?: string;
     name: string;
     repo?: string;
-    hash?: string;
 }
 export default class PipelinesDiff extends Command {
     static description: string;
@@ -13,8 +13,8 @@ export default class PipelinesDiff extends Command {
         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>;
     };
-    kolkrabbi: KolkrabbiAPI;
     getAppInfo: (appName: string, appId: string, generation: GenerationKind) => Promise<AppInfo>;
+    kolkrabbi: KolkrabbiAPI;
     run(): Promise<undefined>;
 }
 export {};