heroku 11.0.0-alpha.10 → 11.0.0-alpha.12

package/lib/commands/members/index.js

@@ -1,47 +1,51 @@
-import { color } from '@heroku-cli/color';
+import { color, hux } from '@heroku/heroku-cli-util';
 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';
+import { getTeamInvites, isTeamInviteFeatureEnabled } from '../../lib/members/team-invite-utils.js';
 const buildTableColumns = (teamInvites) => {
     const baseColumns = {
         email: {
-            get: ({ email }) => color.cyan(email),
+            get: ({ email }) => color.user(email),
         },
         role: {
-            get: ({ role }) => color.green(role),
+            get: ({ role }) => color.info(role),
         },
     };
     if (teamInvites.length > 0) {
         return {
             ...baseColumns,
             status: {
-                get: ({ status }) => color.green(status),
+                get({ status }) {
+                    if (status === 'pending')
+                        return color.warning(status);
+                    return color.success(status);
+                },
             },
         };
     }
     return baseColumns;
 };
 export default class MembersIndex extends Command {
-    static topic = 'members';
     static description = 'list members of a team';
     static flags = {
+        json: flags.boolean({ description: 'output in json format' }),
+        pending: flags.boolean({ description: 'filter by pending team invitations' }),
         role: flags.string({
             char: 'r',
-            description: 'filter by role',
             completion: RoleCompletion,
+            description: 'filter by role',
         }),
-        pending: flags.boolean({ description: 'filter by pending team invitations' }),
-        json: flags.boolean({ description: 'output in json format' }),
         team: flags.team({ required: true }),
     };
+    static topic = 'members';
     async run() {
         const { flags } = await this.parse(MembersIndex);
-        const { role, pending, json, team } = flags;
+        const { json, pending, role, team } = flags;
         let teamInvites = [];
         if (await isTeamInviteFeatureEnabled(team, this.heroku)) {
             const invites = await getTeamInvites(team, this.heroku);
+            /* eslint-disable perfectionist/sort-objects */
             teamInvites = invites.map((invite) => ({
                 email: invite.user?.email || '',
                 role: invite.role,
@@ -52,6 +56,7 @@ export default class MembersIndex extends Command {
                 created_at: invite.created_at || '',
                 updated_at: invite.updated_at || '',
             }));
+            /* eslint-enable perfectionist/sort-objects */
         }
         let { body: members } = await this.heroku.get(`/teams/${team}/members`);
         // Set status '' to all existing members
@@ -67,9 +72,9 @@ export default class MembersIndex extends Command {
             ux.stdout(JSON.stringify(members, null, 3));
         }
         else if (members.length === 0) {
-            let msg = `No members in ${color.magenta(team || '')}`;
+            let msg = `No members in ${color.team(team || '')}`;
             if (role)
-                msg += ` with role ${color.green(role)}`;
+                msg += ` with role ${color.info(role)}`;
             ux.stdout(msg);
         }
         else {

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

@@ -1,10 +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;
+    static topic: string;
     run(): Promise<void>;
 }

package/lib/commands/members/remove.js

@@ -1,9 +1,9 @@
-import { color } from '@heroku-cli/color';
+import { color } from '@heroku/heroku-cli-util';
 import { Command, flags } from '@heroku-cli/command';
 import { ux } from '@oclif/core';
-import { isTeamInviteFeatureEnabled, getTeamInvites } from '../../lib/members/team-invite-utils.js';
+import { getTeamInvites, isTeamInviteFeatureEnabled } 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)}`);
+    ux.action.start(`Revoking invite for ${color.user(email)} in ${color.team(team)}`);
     await heroku.delete(`/teams/${team}/invitations/${email}`, {
         headers: {
             Accept: 'application/vnd.heroku+json; version=3.team-invitations',
@@ -12,19 +12,19 @@ const revokeInvite = async (email, team, heroku) => {
     ux.action.stop();
 };
 const removeUserMembership = async (email, team, heroku) => {
-    ux.action.start(`Removing ${color.cyan(email)} from ${color.magenta(team)}`);
+    ux.action.start(`Removing ${color.user(email)} from ${color.team(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;
+    static topic = 'members';
     async run() {
-        const { flags, argv } = await this.parse(MembersRemove);
+        const { argv, flags } = await this.parse(MembersRemove);
         const { team } = flags;
         const email = argv[0];
         const teamInviteFeatureEnabled = await isTeamInviteFeatureEnabled(team, this.heroku);

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

@@ -1,13 +1,13 @@
 import { Command } from '@heroku-cli/command';
 export default class NotificationsIndex extends Command {
     static description: string;
-    static topic: string;
     static flags: {
-        app: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
-        remote: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         all: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        app: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         read: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        remote: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
+    static topic: string;
     run(): Promise<void>;
 }

package/lib/commands/notifications/index.js

@@ -1,14 +1,13 @@
+import { color, hux } from '@heroku/heroku-cli-util';
 import { Command, flags } from '@heroku-cli/command';
-import { color } from '@heroku-cli/color';
 import { ux } from '@oclif/core';
-import { hux } from '@heroku/heroku-cli-util';
-import * as time from '../../lib/time.js';
 import wrap from 'word-wrap';
+import * as time from '../../lib/time.js';
 function displayNotifications(notifications, app, readNotification) {
     const read = readNotification ? 'Read' : 'Unread';
     hux.styledHeader(app ? `${read} Notifications for ${color.app(app.name)}` : `${read} Notifications`);
     for (const n of notifications) {
-        ux.stdout(color.yellow(`\n${n.title}\n`));
+        ux.stdout(color.info(`\n${n.title}\n`));
         ux.stdout(wrap(`\n${color.dim(time.ago(new Date(n.created_at)))}\n${n.body}`, { width: 80 }));
         for (const followup of n.followup) {
             ux.stdout();
@@ -18,14 +17,14 @@ function displayNotifications(notifications, app, readNotification) {
 }
 export default class NotificationsIndex extends Command {
     static description = 'display notifications';
-    static topic = 'notifications';
     static flags = {
-        app: flags.app({ required: false }),
-        remote: flags.remote(),
         all: flags.boolean({ description: 'view all notifications (not just the ones for the current app)' }),
+        app: flags.app({ required: false }),
         json: flags.boolean({ description: 'output in json format' }),
         read: flags.boolean({ description: 'show notifications already read' }),
+        remote: flags.remote(),
     };
+    static topic = 'notifications';
     async run() {
         const { flags } = await this.parse(NotificationsIndex);
         const appResponse = flags.app && !flags.all ? await this.heroku.get(`/apps/${flags.app}`) : null;
@@ -45,14 +44,14 @@ export default class NotificationsIndex extends Command {
         if (notifications.length === 0) {
             if (flags.read) {
                 if (app)
-                    ux.stdout(`You have no notifications on ${color.green(app.name)}.\nRun heroku notifications --all to view notifications for all apps.`);
+                    ux.stdout(`You have no notifications on ${color.app(app.name)}.\nRun heroku notifications --all to view notifications for all apps.`);
                 else
                     ux.stdout('You have no notifications.');
             }
             else if (app)
-                ux.stdout(`No unread notifications on ${color.green(app.name)}.\nRun ${color.cmd('heroku notifications --all')} to view notifications for all apps.`);
+                ux.stdout(`No unread notifications on ${color.app(app.name)}.\nRun ${color.code('heroku notifications --all')} to view notifications for all apps.`);
             else
-                ux.stdout(`No unread notifications.\nRun ${color.cmd('heroku notifications --read')} to view read notifications.`);
+                ux.stdout(`No unread notifications.\nRun ${color.code('heroku notifications --read')} to view read notifications.`);
         }
         else
             displayNotifications(notifications, app, flags.read);

package/lib/commands/orgs/open.js

@@ -1,7 +1,7 @@
+import { color } from '@heroku/heroku-cli-util';
 import { Command, flags } from '@heroku-cli/command';
 import open from 'open';
 import { ux } from '@oclif/core';
-import { color } from '@heroku-cli/color';
 export default class OrgsOpen extends Command {
     static topic = 'orgs';
     static description = 'open the team interface in a browser window';
@@ -9,7 +9,7 @@ export default class OrgsOpen extends Command {
         team: flags.team({ required: true }),
     };
     static async openUrl(url) {
-        ux.stdout(`Opening ${color.cyan(url)}...`);
+        ux.stdout(`Opening ${color.info(url)}...`);
         await open(url);
     }
     async run() {

package/lib/commands/pg/backups/cancel.d.ts

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

package/lib/commands/pg/backups/cancel.js

@@ -0,0 +1,43 @@
+import { Command, flags } from '@heroku-cli/command';
+import { Args, ux } from '@oclif/core';
+import { utils } from '@heroku/heroku-cli-util';
+import backupsFactory from '../../../lib/pg/backups.js';
+export default class Cancel extends Command {
+    static topic = 'pg';
+    static description = 'cancel an in-progress backup or restore (default newest)';
+    static flags = {
+        app: flags.app({ required: true }),
+        remote: flags.remote(),
+    };
+    static args = {
+        backup_id: Args.string({ description: 'ID of the backup. If omitted, we use the last unfinished backup ID.' }),
+    };
+    async run() {
+        const { flags, args } = await this.parse(Cancel);
+        const { app } = flags;
+        const { backup_id } = args;
+        const pgbackups = backupsFactory(app, this.heroku);
+        let transfer;
+        if (backup_id) {
+            const num = await pgbackups.num(backup_id);
+            if (!num) {
+                ux.error(`Invalid Backup: ${backup_id}`);
+            }
+            ({ body: transfer } = await this.heroku.get(`/client/v11/apps/${app}/transfers/${num}`, { hostname: utils.pg.host() }));
+        }
+        else {
+            const { body: transfers } = await this.heroku.get(`/client/v11/apps/${app}/transfers`, { hostname: utils.pg.host() });
+            transfer = transfers
+                .sort((a, b) => b.created_at.localeCompare(a.created_at))
+                .find(t => !t.finished_at);
+        }
+        if (transfer) {
+            ux.action.start(`Cancelling ${pgbackups.name(transfer)}`);
+            await this.heroku.post(`/client/v11/apps/${app}/transfers/${transfer.uuid}/actions/cancel`, { hostname: utils.pg.host() });
+            ux.action.stop();
+        }
+        else {
+            ux.error('No active backups/transfers');
+        }
+    }
+}

package/lib/commands/pg/backups/capture.d.ts

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

package/lib/commands/pg/backups/capture.js

@@ -0,0 +1,62 @@
+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 backupsApi from '../../../lib/pg/backups.js';
+import { nls } from '../../../nls.js';
+const heredoc = tsheredoc.default;
+export default class Capture extends Command {
+    static args = {
+        database: Args.string({ description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}` }),
+    };
+    static description = 'capture a new backup';
+    static flags = {
+        app: flags.app({ required: true }),
+        remote: flags.remote(),
+        verbose: flags.boolean({ char: 'v' }),
+        'wait-interval': flags.string(),
+    };
+    static topic = 'pg';
+    async run() {
+        const { args, flags } = await this.parse(Capture);
+        const { app, verbose, 'wait-interval': waitInterval } = flags;
+        const { database } = args;
+        const interval = Math.max(3, Number.parseInt(waitInterval || '3', 10));
+        const dbResolver = new utils.pg.DatabaseResolver(this.heroku);
+        const { addon: db } = await dbResolver.getAttachment(app, database);
+        const pgBackupsApi = backupsApi(app, this.heroku);
+        try {
+            const { body: dbInfo } = await this.heroku.get(`/client/v11/databases/${db.id}`, { hostname: utils.pg.host() });
+            const dbProtected = /On/.test(dbInfo.info.find(attribute => attribute.name === 'Continuous Protection')?.values[0] || '');
+            if (dbProtected) {
+                ux.warn('Continuous protection is already enabled for this database. Logical backups of large databases are likely to fail.');
+                ux.warn('See https://devcenter.heroku.com/articles/heroku-postgres-data-safety-and-continuous-protection#physical-backups-on-heroku-postgres.');
+            }
+        }
+        catch (error) {
+            const httpError = error;
+            if (httpError.statusCode !== 404)
+                throw httpError;
+            ux.error(heredoc `
+          ${color.datastore(db.name)} is not yet provisioned.
+          Run ${color.code('heroku addons:wait')} to wait until the db is provisioned.
+        `, { exit: 1 });
+        }
+        ux.action.start(`Starting backup of ${color.datastore(db.name)}`);
+        const { body: backup } = await this.heroku.post(`/client/v11/databases/${db.id}/backups`, { hostname: utils.pg.host() });
+        ux.action.stop();
+        ux.stdout(heredoc `
+
+      Use Ctrl-C at any time to stop monitoring progress; the backup will continue running.
+      Use ${color.code('heroku pg:backups:info')} to check progress.
+      Stop a running backup with ${color.code('heroku pg:backups:cancel')}.
+    `);
+        if (app !== db.app.name) {
+            ux.stdout(heredoc `
+        HINT: You are running this command with a non-billing application.
+        Use ${color.code('heroku pg:backups -a ' + db.app.name)} to check the list of backups.
+      `);
+        }
+        await pgBackupsApi.wait(`Backing up ${color.datastore(backup.from_name)} to ${color.cyan(pgBackupsApi.name(backup))}`, backup.uuid, interval, verbose, db.app.name || app);
+    }
+}

package/lib/commands/pg/backups/delete.d.ts

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

package/lib/commands/pg/backups/delete.js

@@ -0,0 +1,34 @@
+import { color, utils } from '@heroku/heroku-cli-util';
+import { Command, flags } from '@heroku-cli/command';
+import { Args, ux } from '@oclif/core';
+import ConfirmCommand from '../../../lib/confirmCommand.js';
+import backupsFactory from '../../../lib/pg/backups.js';
+export default class Delete extends Command {
+    static args = {
+        backup_id: Args.string({ description: 'ID of the backup', required: true }),
+    };
+    static description = 'delete a backup';
+    static examples = [
+        color.command('heroku pg:backup:delete --app APP_ID BACKUP_ID'),
+    ];
+    static flags = {
+        app: flags.app({ required: true }),
+        confirm: flags.string({ char: 'c', hidden: true }),
+        remote: flags.remote(),
+    };
+    static topic = 'pg';
+    async run() {
+        const { args, flags } = await this.parse(Delete);
+        const { app, confirm } = flags;
+        const { backup_id } = args;
+        const pgbackups = backupsFactory(app, this.heroku);
+        await new ConfirmCommand().confirm(app, confirm);
+        ux.action.start(`Deleting backup ${color.cyan(backup_id)} on ${color.app(app)}`);
+        const num = await pgbackups.num(backup_id);
+        if (!num) {
+            throw new Error(`Invalid Backup: ${backup_id}`);
+        }
+        await this.heroku.delete(`/client/v11/apps/${app}/transfers/${num}`, { hostname: utils.pg.host() });
+        ux.action.stop();
+    }
+}

package/lib/commands/pg/backups/download.d.ts

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

package/lib/commands/pg/backups/download.js

@@ -0,0 +1,54 @@
+import { color, utils } from '@heroku/heroku-cli-util';
+import { Command, flags } from '@heroku-cli/command';
+import { Args, ux } from '@oclif/core';
+import fs from 'fs-extra';
+import pgBackupsApi from '../../../lib/pg/backups.js';
+import download from '../../../lib/pg/download.js';
+function defaultFilename() {
+    let f = 'latest.dump';
+    if (!fs.existsSync(f))
+        return f;
+    let i = 1;
+    do
+        f = `latest.dump.${i++}`;
+    while (fs.existsSync(f));
+    return f;
+}
+export default class Download extends Command {
+    static args = {
+        backup_id: Args.string({ description: 'ID of the backup. If omitted, we use the last backup ID.' }),
+    };
+    static description = 'downloads database backup';
+    static flags = {
+        app: flags.app({ required: true }),
+        output: flags.string({ char: 'o', description: 'location to download to. Defaults to latest.dump' }),
+        remote: flags.remote(),
+    };
+    static topic = 'pg';
+    async run() {
+        const { args, flags } = await this.parse(Download);
+        const { backup_id } = args;
+        const { app } = flags;
+        const output = flags.output || defaultFilename();
+        let num;
+        ux.action.start(`Getting backup from ${color.app(app)}`);
+        if (backup_id) {
+            num = await pgBackupsApi(app, this.heroku).num(backup_id);
+            if (!num)
+                throw new Error(`Invalid Backup: ${backup_id}`);
+        }
+        else {
+            const { body: transfers } = await this.heroku.get(`/client/v11/apps/${app}/transfers`, { hostname: utils.pg.host() });
+            const lastBackup = transfers
+                .filter(t => t.succeeded && t.to_type === 'gof3r')
+                .sort((a, b) => b.created_at.localeCompare(a.created_at))[0];
+            if (!lastBackup)
+                throw new Error(`No backups on ${color.app(app)}. Capture one with ${color.cyan.bold('heroku pg:backups:capture')}`);
+            num = lastBackup.num;
+        }
+        ux.action.status = `fetching url of #${num}`;
+        const { body: info } = await this.heroku.post(`/client/v11/apps/${app}/transfers/${num}/actions/public-url`, { hostname: utils.pg.host() });
+        ux.action.stop(`done, #${num}`);
+        await download(info.url, output, { progress: true });
+    }
+}

package/lib/commands/pg/backups/index.d.ts

@@ -0,0 +1,20 @@
+import { Command } from '@heroku-cli/command';
+export default class Index extends Command {
+    static description: string;
+    static flags: {
+        app: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        at: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        confirm: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        output: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        remote: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        verbose: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'wait-interval': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static strict: boolean;
+    static topic: string;
+    run(): Promise<void>;
+    private displayBackups;
+    private displayCopies;
+    private displayRestores;
+}

package/lib/commands/pg/backups/index.js

@@ -0,0 +1,121 @@
+import { color, hux, utils } from '@heroku/heroku-cli-util';
+import { Command, flags } from '@heroku-cli/command';
+import { ux } from '@oclif/core';
+import backupsFactory from '../../../lib/pg/backups.js';
+export default class Index extends Command {
+    static description = 'list database backups';
+    static flags = {
+        app: flags.app({ required: true }),
+        at: flags.string({ hidden: true }),
+        confirm: flags.string({ char: 'c', hidden: true }),
+        output: flags.string({ char: 'o', hidden: true }),
+        quiet: flags.boolean({ char: 'q', hidden: true }),
+        remote: flags.remote(),
+        verbose: flags.boolean({ char: 'v', hidden: true }),
+        'wait-interval': flags.string({ hidden: true }),
+    };
+    static strict = false;
+    static topic = 'pg';
+    async run() {
+        const { flags: { app } } = await this.parse(Index);
+        const { body: transfers } = await this.heroku.get(`/client/v11/apps/${app}/transfers`, { hostname: utils.pg.host() });
+        // NOTE that the sort order is descending
+        transfers.sort((transferA, transferB) => transferB.created_at.localeCompare(transferA.created_at));
+        this.displayBackups(transfers, app);
+        this.displayRestores(transfers, app);
+        this.displayCopies(transfers, app);
+    }
+    displayBackups(transfers, app) {
+        const backups = transfers.filter(backupTransfer => backupTransfer.from_type === 'pg_dump' && backupTransfer.to_type === 'gof3r');
+        const pgbackups = backupsFactory(app, this.heroku);
+        hux.styledHeader('Backups');
+        if (backups.length === 0) {
+            ux.stdout(`No backups. Capture one with ${color.code('heroku pg:backups:capture')}`);
+        }
+        else {
+            /* eslint-disable perfectionist/sort-objects */
+            hux.table(backups, {
+                ID: {
+                    get: (transfer) => color.name(pgbackups.name(transfer)),
+                },
+                'Created at': {
+                    get: (transfer) => transfer.created_at,
+                },
+                Status: {
+                    get: (transfer) => pgbackups.status(transfer),
+                },
+                Size: {
+                    get: (transfer) => pgbackups.filesize(transfer.processed_bytes),
+                },
+                Database: {
+                    get: (transfer) => color.datastore(transfer.from_name) || 'UNKNOWN',
+                },
+            });
+            /* eslint-enable perfectionist/sort-objects */
+        }
+        ux.stdout();
+    }
+    displayCopies(transfers, app) {
+        const pgbackups = backupsFactory(app, this.heroku);
+        const copies = transfers.filter(t => t.from_type === 'pg_dump' && t.to_type === 'pg_restore').slice(0, 10);
+        hux.styledHeader('Copies');
+        if (copies.length === 0) {
+            ux.stdout(`No copies found. Use ${color.code('heroku pg:copy')} to copy a database to another`);
+        }
+        else {
+            /* eslint-disable perfectionist/sort-objects */
+            hux.table(copies, {
+                ID: {
+                    get: (transfer) => color.name(pgbackups.name(transfer)),
+                },
+                'Started at': {
+                    get: (transfer) => transfer.created_at,
+                },
+                Status: {
+                    get: (transfer) => pgbackups.status(transfer),
+                },
+                Size: {
+                    get: (transfer) => pgbackups.filesize(transfer.processed_bytes),
+                },
+                From: {
+                    get: (transfer) => color.datastore(transfer.from_name) || color.inactive('UNKNOWN'),
+                },
+                To: {
+                    get: (transfer) => color.datastore(transfer.to_name) || color.inactive('UNKNOWN'),
+                },
+            });
+        }
+        /* eslint-enable perfectionist/sort-objects */
+        ux.stdout();
+    }
+    displayRestores(transfers, app) {
+        const restores = transfers
+            .filter(t => t.from_type !== 'pg_dump' && t.to_type === 'pg_restore')
+            .slice(0, 10); // first 10 only
+        const pgbackups = backupsFactory(app, this.heroku);
+        hux.styledHeader('Restores');
+        if (restores.length === 0) {
+            ux.stdout(`No restores found. Use ${color.code('heroku pg:backups:restore')} to restore a backup`);
+        }
+        else {
+            hux.table(restores, {
+                ID: {
+                    get: (transfer) => color.name(pgbackups.name(transfer)),
+                },
+                'Started at': {
+                    get: (transfer) => transfer.created_at,
+                },
+                Status: {
+                    get: (transfer) => pgbackups.status(transfer),
+                },
+                Size: {
+                    get: (transfer) => pgbackups.filesize(transfer.processed_bytes),
+                },
+                Database: {
+                    get: (transfer) => color.datastore(transfer.to_name) || 'UNKNOWN',
+                },
+            });
+        }
+        ux.stdout();
+    }
+}

package/lib/commands/pg/backups/info.d.ts

@@ -0,0 +1,17 @@
+import { Command } from '@heroku-cli/command';
+import type { BackupTransfer } from '../../../lib/pg/types.js';
+export default class Info extends Command {
+    static args: {
+        backup_id: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    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 topic: string;
+    displayBackup: (backup: BackupTransfer, app: string) => void;
+    displayLogs: (backup: BackupTransfer) => void;
+    getBackup: (id: string | undefined, app: string) => Promise<BackupTransfer>;
+    run(): Promise<void>;
+}