heroku 11.0.0-alpha.12 → 11.0.0-alpha.13

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

@@ -1,6 +1,6 @@
 import { Command } from '@heroku-cli/command';
 import * as Heroku from '@heroku-cli/schema';
-export declare function renderAttachment(attachment: Heroku.AddOnAttachment, app: string, isFirst?: boolean): string;
+export declare function renderAttachment(attachment: Heroku.AddOnAttachment, app: string, isLast?: boolean): string;
 export default class Addons extends Command {
     static description: string;
     static examples: string[];

package/lib/commands/addons/index.js

@@ -136,8 +136,8 @@ function formatAttachment(attachment, showApp = true) {
     }
     return output.join(' ');
 }
-export function renderAttachment(attachment, app, isFirst = false) {
-    const line = isFirst ? '\u2514\u2500' : '\u251C\u2500';
+export function renderAttachment(attachment, app, isLast = false) {
+    const line = isLast ? '\u2514\u2500' : '\u251C\u2500';
     const attName = formatAttachment(attachment, attachment.app?.name !== app);
     return printf(' %s %s', color.dim(line), attName);
 }
@@ -157,8 +157,8 @@ function displayForApp(app, addons) {
         const atts = _.sortBy(addon.attachments, isForeignApp, 'app.name', 'name');
         // render each attachment under the add-on
         const attLines = atts.map((attachment, idx) => {
-            const isFirst = (idx === addon.attachments.length - 1);
-            return renderAttachment(attachment, app, isFirst);
+            const isLast = (idx === addon.attachments.length - 1);
+            return renderAttachment(attachment, app, isLast);
         });
         return [addonLine].concat(attLines)
             .join('\n') + '\n'; // Separate each add-on row by a blank line

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

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

package/lib/commands/pg/copy.js

@@ -1,6 +1,6 @@
+import { color, utils } from '@heroku/heroku-cli-util';
 import { Command, flags } from '@heroku-cli/command';
 import { Args, ux } from '@oclif/core';
-import { color, utils } from '@heroku/heroku-cli-util';
 import ConfirmCommand from '../../lib/confirmCommand.js';
 import backupsFactory from '../../lib/pg/backups.js';
 const getAttachmentInfo = async function (heroku, db, app) {
@@ -9,9 +9,9 @@ const getAttachmentInfo = async function (heroku, db, app) {
         const conn = utils.pg.DatabaseResolver.parsePostgresConnectionString(db);
         const host = `${conn.host}:${conn.port}`;
         return {
+            confirm: conn.database || conn.host,
             name: conn.database ? `database ${conn.database} on ${host}` : `database on ${host}`,
             url: db,
-            confirm: conn.database || conn.host,
         };
     }
     const attachment = await dbResolver.getAttachment(app, db);
@@ -21,34 +21,34 @@ const getAttachmentInfo = async function (heroku, db, app) {
     const { body: config } = await heroku.get(`/apps/${attachment.app.name}/config-vars`);
     const formattedConfig = Object.fromEntries(Object.entries(config).map(([k, v]) => [k.toUpperCase(), v]));
     return {
-        name: attachment.name.replace(/^HEROKU_POSTGRESQL_/, '')
-            .replace(/_URL$/, ''),
-        url: formattedConfig[attachment.name.toUpperCase() + '_URL'],
         attachment: {
             ...attachment,
             addon,
         },
         confirm: app,
+        name: attachment.name.replace(/^HEROKU_POSTGRESQL_/, '')
+            .replace(/_URL$/, ''),
+        url: formattedConfig[attachment.name.toUpperCase() + '_URL'],
     };
 };
 export default class Copy extends Command {
-    static description = 'copy all data from source db to target';
-    static help = 'at least one of the databases must be a Heroku PostgreSQL DB';
-    static topic = 'pg';
     static args = {
-        source: Args.string({ required: true, description: 'config var exposed to the owning app containing the source database URL' }),
-        target: Args.string({ required: true, description: 'config var exposed to the owning app containing the target database URL' }),
+        source: Args.string({ description: 'config var exposed to the owning app containing the source database URL', required: true }),
+        target: Args.string({ description: 'config var exposed to the owning app containing the target database URL', required: true }),
     };
+    static description = 'copy all data from source db to target';
     static flags = {
-        'wait-interval': flags.string(),
-        verbose: flags.boolean(),
-        confirm: flags.string(),
         app: flags.app({ required: true }),
+        confirm: flags.string(),
         remote: flags.remote(),
+        verbose: flags.boolean(),
+        'wait-interval': flags.string(),
     };
+    static help = 'at least one of the databases must be a Heroku PostgreSQL DB';
+    static topic = 'pg';
     async run() {
-        const { flags, args } = await this.parse(Copy);
-        const { 'wait-interval': waitInterval, verbose, confirm, app } = flags;
+        const { args, flags } = await this.parse(Copy);
+        const { app, confirm, verbose, 'wait-interval': waitInterval } = flags;
         const pgbackups = backupsFactory(app, this.heroku);
         const interval = Math.max(3, Number.parseInt(waitInterval || '0', 10)) || 3;
         const [source, target] = await Promise.all([getAttachmentInfo(this.heroku, args.source, app), getAttachmentInfo(this.heroku, args.target, app)]);
@@ -69,10 +69,10 @@ export default class Copy extends Command {
         ux.action.stop();
         if (source.attachment) {
             const { body: credentials } = await this.heroku.get(`/postgres/v0/databases/${source.attachment.addon.name}/credentials`, {
-                hostname: utils.pg.host(),
                 headers: {
                     Authorization: `Basic ${Buffer.from(`:${this.heroku.auth}`).toString('base64')}`,
                 },
+                hostname: utils.pg.host(),
             });
             if (credentials.length > 1) {
                 ux.warn('pg:copy will only copy your default credential and the data it has access to. Any additional credentials and data that only they can access will not be copied.');

package/lib/commands/pg/credentials/url.js

@@ -39,11 +39,9 @@ export default class Url extends Command {
         if (!activeCreds) {
             ux.error(`Could not find any active credentials for ${name}`, { exit: 1 });
         }
-        const creds = Object.assign({}, db, {
-            database: credInfo.database, host: credInfo.host, port: credInfo.port,
-        }, {
-            user: activeCreds?.user, password: activeCreds?.password,
-        });
+        const creds = {
+            ...db, database: credInfo.database, host: credInfo.host, password: activeCreds?.password, port: credInfo.port, user: activeCreds?.user,
+        };
         const connUrl = new URL(`postgres://${creds.host}/${creds.database}`);
         connUrl.port = creds.port.toString();
         if (creds.user && creds.password) {

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

@@ -1,16 +1,16 @@
 import { Command } from '@heroku-cli/command';
-import type { CredentialInfo, CredentialsInfo } from '../../lib/pg/types.js';
+import type { NonAdvancedCredentialInfo } from '../../lib/data/types.js';
 export default class Credentials extends Command {
-    static topic: string;
+    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>;
     };
-    static args: {
-        database: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
-    };
+    static topic: string;
+    protected isDefaultCredential(cred: NonAdvancedCredentialInfo): boolean;
     run(): Promise<void>;
-    protected sortByDefaultAndName(credentials: CredentialsInfo): CredentialsInfo;
-    protected isDefaultCredential(cred: CredentialInfo): boolean;
+    protected sortByDefaultAndName(credentials: NonAdvancedCredentialInfo[]): NonAdvancedCredentialInfo[];
 }

package/lib/commands/pg/credentials.js

@@ -1,29 +1,32 @@
+import { hux, utils } from '@heroku/heroku-cli-util';
 import { Command, flags } from '@heroku-cli/command';
 import { Args } from '@oclif/core';
-import { hux, utils } from '@heroku/heroku-cli-util';
 import { presentCredentialAttachments } from '../../lib/pg/util.js';
 import { nls } from '../../nls.js';
 export default class Credentials extends Command {
-    static topic = 'pg';
+    static args = {
+        database: Args.string({ description: `${nls('pg:database:arg:description')} ${nls('pg:database:arg:description:default:suffix')}` }),
+    };
     static description = 'show information on credentials in the database';
     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')}` }),
-    };
+    static topic = 'pg';
+    isDefaultCredential(cred) {
+        return cred.name === 'default';
+    }
     async run() {
-        const { flags, args } = await this.parse(Credentials);
+        const { args, flags } = await this.parse(Credentials);
         const { app } = flags;
         const { database } = args;
         const dbResolver = new utils.pg.DatabaseResolver(this.heroku);
         const { addon } = await dbResolver.getAttachment(app, database);
         const { body: credentials } = await this.heroku.get(`/postgres/v0/databases/${addon.id}/credentials`, {
-            hostname: utils.pg.host(),
             headers: {
                 Authorization: `Basic ${Buffer.from(`:${this.heroku.auth}`).toString('base64')}`,
             },
+            hostname: utils.pg.host(),
         });
         const sortedCredentials = this.sortByDefaultAndName(credentials);
         const { body: attachments } = await this.heroku.get(`/addons/${addon.id}/addon-attachments`);
@@ -55,7 +58,4 @@ export default class Credentials extends Command {
             return isDefaultB < isDefaultA ? -1 : (isDefaultA < isDefaultB ? 1 : a.name.localeCompare(b.name));
         });
     }
-    isDefaultCredential(cred) {
-        return cred.name === 'default';
-    }
 }

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

@@ -0,0 +1,16 @@
+import BaseCommand from '../../lib/webhooks/base.js';
+export default class WebhooksAdd extends BaseCommand {
+    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>;
+        pipeline: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        include: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        level: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        secret: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        authorization: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        url: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/webhooks/add.js

@@ -0,0 +1,43 @@
+import { flags } from '@heroku-cli/command';
+import { hux } from '@heroku/heroku-cli-util';
+import { ux } from '@oclif/core';
+import BaseCommand from '../../lib/webhooks/base.js';
+export default class WebhooksAdd extends BaseCommand {
+    static description = 'add a webhook to an app';
+    static examples = [
+        '$ heroku webhooks:add -i api:dyno -l notify -u https://example.com/hooks',
+    ];
+    static flags = {
+        app: flags.app(),
+        remote: flags.remote(),
+        pipeline: flags.pipeline({ char: 'p', description: 'pipeline on which to list', hidden: true }),
+        include: flags.string({ char: 'i', description: 'comma delimited event types your server will receive ', required: true }),
+        level: flags.string({ char: 'l', description: 'notify does not retry, sync will retry until successful or timeout', required: true }),
+        secret: flags.string({ char: 's', description: 'value to sign delivery with in Heroku-Webhook-Hmac-SHA256 header' }),
+        authorization: flags.string({ char: 't', description: 'authorization header to send with webhooks' }),
+        url: flags.string({ char: 'u', description: 'URL for receiver', required: true }),
+    };
+    async run() {
+        const { flags } = await this.parse(WebhooksAdd);
+        const { path, display } = this.webhookType(flags);
+        ux.action.start(`Adding webhook to ${display}`);
+        const response = await this.webhooksClient.post(`${path}/webhooks`, {
+            body: {
+                include: flags.include.split(',').map((s) => s.trim()),
+                level: flags.level,
+                secret: flags.secret,
+                url: flags.url,
+                authorization: flags.authorization,
+            },
+        });
+        ux.action.stop();
+        const secret = response.headers && response.headers['heroku-webhook-secret'];
+        if (secret) {
+            hux.styledHeader('Webhooks Signing Secret');
+            ux.stdout(secret);
+        }
+        else {
+            ux.warn('no secret found');
+        }
+    }
+}

package/lib/commands/webhooks/deliveries/index.d.ts

@@ -0,0 +1,12 @@
+import BaseCommand from '../../../lib/webhooks/base.js';
+export default class Deliveries extends BaseCommand {
+    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>;
+        status: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        pipeline: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/webhooks/deliveries/index.js

@@ -0,0 +1,75 @@
+import { flags } from '@heroku-cli/command';
+import { hux } from '@heroku/heroku-cli-util';
+import BaseCommand from '../../../lib/webhooks/base.js';
+export default class Deliveries extends BaseCommand {
+    static description = 'list webhook deliveries on an app';
+    static examples = [
+        '$ heroku webhooks:deliveries',
+    ];
+    static flags = {
+        app: flags.app(),
+        remote: flags.remote(),
+        status: flags.string({ char: 's', description: 'filter deliveries by status' }),
+        pipeline: flags.pipeline({ char: 'p', description: 'pipeline on which to list', hidden: true }),
+    };
+    async run() {
+        const { flags } = await this.parse(Deliveries);
+        const webhookType = this.webhookType(flags);
+        let { path } = webhookType;
+        const { display } = webhookType;
+        const max = 1000;
+        path = `${path}/webhook-deliveries`;
+        if (flags.status) {
+            path += `?eq[status]=${encodeURIComponent(flags.status)}`;
+        }
+        const { body: deliveries } = await this.webhooksClient.get(path, {
+            headers: {
+                Range: `seq ..; order=desc,max=${max}`,
+            },
+            partial: true,
+        });
+        if (deliveries.length === 0) {
+            this.log(`${display} has no deliveries`);
+        }
+        else {
+            const code = (w) => (w.last_attempt && w.last_attempt.code && String(w.last_attempt.code)) || '';
+            deliveries.reverse();
+            if (deliveries.length === max) {
+                this.warn(`Only showing the ${max} most recent deliveries`);
+                this.warn('It is possible to filter deliveries by using the --status flag');
+            }
+            const printLine = (...args) => this.log(...args);
+            hux.table(deliveries, {
+                id: {
+                    header: 'Delivery ID',
+                },
+                created_at: {
+                    header: 'Created', get: (w) => w.created_at,
+                },
+                status: {
+                    header: 'Status', get: (w) => w.status,
+                },
+                include: {
+                    header: 'Include', get: (w) => w.event.include,
+                },
+                level: {
+                    header: 'Level', get: (w) => w.webhook.level,
+                },
+                num_attempts: {
+                    header: 'Attempts', get: (w) => String(w.num_attempts),
+                },
+                last_code: {
+                    header: 'Code', get: code,
+                },
+                last_error: {
+                    header: 'Error', get: (w) => (w.last_attempt && w.last_attempt.error_class) || '',
+                },
+                next_attempt_at: {
+                    header: 'Next Attempt', get: (w) => w.next_attempt_at || '',
+                },
+            }, {
+                printLine,
+            });
+        }
+    }
+}

package/lib/commands/webhooks/deliveries/info.d.ts

@@ -0,0 +1,14 @@
+import BaseCommand from '../../../lib/webhooks/base.js';
+export default class DeliveriesInfo extends BaseCommand {
+    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>;
+        pipeline: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static args: {
+        id: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/webhooks/deliveries/info.js

@@ -0,0 +1,40 @@
+import { flags } from '@heroku-cli/command';
+import { Args } from '@oclif/core';
+import { hux } from '@heroku/heroku-cli-util';
+import BaseCommand from '../../../lib/webhooks/base.js';
+export default class DeliveriesInfo extends BaseCommand {
+    static description = 'info for a webhook event on an app';
+    static examples = [
+        '$ heroku webhooks:deliveries:info 99999999-9999-9999-9999-999999999999',
+    ];
+    static flags = {
+        app: flags.app(),
+        remote: flags.remote(),
+        pipeline: flags.pipeline({ char: 'p', description: 'pipeline on which to list', hidden: true }),
+    };
+    static args = {
+        id: Args.string({ required: true, description: 'ID of the webhook event' }),
+    };
+    async run() {
+        const { flags, args } = await this.parse(DeliveriesInfo);
+        const { path } = this.webhookType(flags);
+        const { body: delivery } = await this.webhooksClient.get(`${path}/webhook-deliveries/${args.id}`);
+        const { body: event } = await this.webhooksClient.get(`${path}/webhook-events/${delivery.event.id}`);
+        const obj = {
+            Created: delivery.created_at,
+            Event: delivery.event.id,
+            Webhook: delivery.webhook.id,
+            Status: delivery.status,
+            Include: delivery.event.include,
+            Level: delivery.webhook.level,
+            Attempts: delivery.num_attempts,
+            Code: delivery.last_attempt && delivery.last_attempt.code,
+            Error: delivery.last_attempt && delivery.last_attempt.error_class,
+            'Next Attempt': delivery.next_attempt_at,
+        };
+        hux.styledHeader(delivery.id);
+        hux.styledObject(obj);
+        hux.styledHeader('Event Payload');
+        hux.styledJSON(event.payload);
+    }
+}

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

@@ -0,0 +1,11 @@
+import BaseCommand from '../../lib/webhooks/base.js';
+export default class Webhooks extends BaseCommand {
+    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>;
+        pipeline: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/webhooks/index.js

@@ -0,0 +1,42 @@
+import { color, hux } from '@heroku/heroku-cli-util';
+import { flags } from '@heroku-cli/command';
+import { ux } from '@oclif/core';
+import BaseCommand from '../../lib/webhooks/base.js';
+export default class Webhooks extends BaseCommand {
+    static description = 'list webhooks on an app';
+    static examples = ['$ heroku webhooks'];
+    static flags = {
+        app: flags.app(),
+        remote: flags.remote(),
+        pipeline: flags.pipeline({
+            char: 'p',
+            description: 'pipeline on which to list',
+            hidden: true,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Webhooks);
+        const { path, display } = this.webhookType(flags);
+        const { body: webhooks } = await this.webhooksClient.get(`${path}/webhooks`);
+        if (webhooks.length === 0) {
+            ux.stdout(`${display} has no webhooks\nUse ${color.command('heroku webhooks:add')} to add one.`);
+            return;
+        }
+        webhooks.sort((a, b) => Date.parse(a.created_at) - Date.parse(b.created_at));
+        hux.table(webhooks, {
+            id: {
+                header: 'Webhook ID',
+            },
+            url: {
+                header: 'URL',
+            },
+            include: {
+                header: 'Include',
+                get: (row) => row.include.join(','),
+            },
+            level: {
+                header: 'Level',
+            },
+        });
+    }
+}

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

@@ -0,0 +1,14 @@
+import BaseCommand from '../../lib/webhooks/base.js';
+export default class WebhooksInfo extends BaseCommand {
+    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>;
+        pipeline: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static args: {
+        id: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/webhooks/info.js

@@ -0,0 +1,29 @@
+import { flags } from '@heroku-cli/command';
+import { Args } from '@oclif/core';
+import { hux } from '@heroku/heroku-cli-util';
+import BaseCommand from '../../lib/webhooks/base.js';
+export default class WebhooksInfo extends BaseCommand {
+    static description = 'info for a webhook on an app';
+    static examples = ['$ heroku webhooks:info 99999999-9999-9999-9999-999999999999'];
+    static flags = {
+        app: flags.app(),
+        remote: flags.remote(),
+        pipeline: flags.pipeline({ char: 'p', description: 'pipeline on which to list', hidden: true }),
+    };
+    static args = {
+        id: Args.string({ required: true, description: 'ID of the webhook' }),
+    };
+    async run() {
+        const { flags, args } = await this.parse(WebhooksInfo);
+        const { path } = this.webhookType(flags);
+        const { body: webhook } = await this.webhooksClient.get(`${path}/webhooks/${args.id}`);
+        const obj = {
+            'Webhook ID': webhook.id,
+            URL: webhook.url,
+            Include: webhook.include.join(','),
+            Level: webhook.level,
+        };
+        hux.styledHeader(webhook.id);
+        hux.styledObject(obj);
+    }
+}

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

@@ -0,0 +1,14 @@
+import BaseCommand from '../../lib/webhooks/base.js';
+export default class WebhooksRemove extends BaseCommand {
+    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>;
+        pipeline: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static args: {
+        id: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/webhooks/remove.js

@@ -0,0 +1,24 @@
+import { flags } from '@heroku-cli/command';
+import { Args, ux } from '@oclif/core';
+import BaseCommand from '../../lib/webhooks/base.js';
+export default class WebhooksRemove extends BaseCommand {
+    static description = 'removes a webhook from an app';
+    static examples = [
+        '$ heroku webhooks:remove 99999999-9999-9999-9999-999999999999',
+    ];
+    static flags = {
+        app: flags.app(),
+        remote: flags.remote(),
+        pipeline: flags.pipeline({ char: 'p', description: 'pipeline on which to list', hidden: true }),
+    };
+    static args = {
+        id: Args.string({ description: 'id of webhook to remove', required: true }),
+    };
+    async run() {
+        const { flags, args } = await this.parse(WebhooksRemove);
+        const { path, display } = this.webhookType(flags);
+        ux.action.start(`Removing webhook ${args.id} from ${display}`);
+        await this.webhooksClient.delete(`${path}/webhooks/${args.id}`);
+        ux.action.stop();
+    }
+}

package/lib/commands/webhooks/update.d.ts

@@ -0,0 +1,19 @@
+import BaseCommand from '../../lib/webhooks/base.js';
+export default class WebhooksUpdate extends BaseCommand {
+    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>;
+        pipeline: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        include: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        level: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        secret: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        authorization: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        url: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static args: {
+        id: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/webhooks/update.js

@@ -0,0 +1,36 @@
+import { flags } from '@heroku-cli/command';
+import { Args, ux } from '@oclif/core';
+import BaseCommand from '../../lib/webhooks/base.js';
+export default class WebhooksUpdate extends BaseCommand {
+    static description = 'updates a webhook in an app';
+    static examples = [
+        '$ heroku webhooks:update 99999999-9999-9999-9999-999999999999 -i dyno -l notify -s 09928c40bf1b191b645174a19f7053d16a180da37332e719ef0998f4c0a2 -u https://example.com/hooks',
+    ];
+    static flags = {
+        app: flags.app(),
+        remote: flags.remote(),
+        pipeline: flags.pipeline({ char: 'p', description: 'pipeline on which to list', hidden: true }),
+        include: flags.string({ char: 'i', description: 'comma delimited event types your server will receive ', required: true }),
+        level: flags.string({ char: 'l', description: 'notify does not retry, sync will retry until successful or timeout', required: true }),
+        secret: flags.string({ char: 's', description: 'value to sign delivery with in Heroku-Webhook-Hmac-SHA256 header' }),
+        authorization: flags.string({ char: 't', description: 'authorization header to send with webhooks' }),
+        url: flags.string({ char: 'u', description: 'URL for receiver', required: true }),
+    };
+    static args = {
+        id: Args.string({ required: true, description: 'ID of the webhook' }),
+    };
+    async run() {
+        const { flags, args } = await this.parse(WebhooksUpdate);
+        const { path, display } = this.webhookType(flags);
+        ux.action.start(`Updating webhook ${args.id} for ${display}`);
+        await this.webhooksClient.patch(`${path}/webhooks/${args.id}`, {
+            body: {
+                include: flags.include && flags.include.split(',').map((s) => s.trim()),
+                level: flags.level,
+                secret: flags.secret,
+                url: flags.url,
+            },
+        });
+        ux.action.stop();
+    }
+}