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

package/lib/commands/status.js

@@ -1,8 +1,7 @@
-import { color } from '@heroku-cli/color';
+import { color, hux } from '@heroku/heroku-cli-util';
+import { HTTP } from '@heroku/http-call';
 import { Command, Flags, ux } from '@oclif/core';
-import { hux } from '@heroku/heroku-cli-util';
 import { formatDistanceToNow } from 'date-fns';
-import { HTTP } from '@heroku/http-call';
 import { getMaxUpdateTypeLength } from '../lib/status/util.js';
 const capitalize = (str) => str.charAt(0).toUpperCase() + str.slice(1);
 const errorMessage = 'Heroku platform status is unavailable at this time. Refer to https://status.salesforce.com/products/Heroku or try again later.';
@@ -67,27 +66,27 @@ const formatTrustResponse = (instances, activeIncidents, maintenances, localizat
     const dataIncidents = herokuActiveIncidents.filter(incident => incident.serviceKeys.includes('HerokuData') || incident.serviceKeys.includes('Data'));
     if (appsIncidents.length > 0) {
         const severity = determineIncidentSeverity(appsIncidents);
-        systemStatus.push({ system: 'Apps', status: severity });
+        systemStatus.push({ status: severity, system: 'Apps' });
         incidents.push(...appsIncidents);
     }
     else {
-        systemStatus.push({ system: 'Apps', status: 'green' });
+        systemStatus.push({ status: 'green', system: 'Apps' });
     }
     if (dataIncidents.length > 0) {
         const severity = determineIncidentSeverity(dataIncidents);
-        systemStatus.push({ system: 'Data', status: severity });
+        systemStatus.push({ status: severity, system: 'Data' });
         incidents.push(...dataIncidents);
     }
     else {
-        systemStatus.push({ system: 'Data', status: 'green' });
+        systemStatus.push({ status: 'green', system: 'Data' });
     }
     if (toolsIncidents.length > 0) {
         const severity = determineIncidentSeverity(toolsIncidents);
-        systemStatus.push({ system: 'Tools', status: severity });
+        systemStatus.push({ status: severity, system: 'Tools' });
         incidents.push(...toolsIncidents);
     }
     else {
-        systemStatus.push({ system: 'Tools', status: 'green' });
+        systemStatus.push({ status: 'green', system: 'Tools' });
     }
     if (maintenances.length > 0)
         scheduled.push(...maintenances);
@@ -98,11 +97,13 @@ const formatTrustResponse = (instances, activeIncidents, maintenances, localizat
             });
         });
     }
+    /* eslint-disable perfectionist/sort-objects */
     return {
         status: systemStatus,
         incidents,
         scheduled,
     };
+    /* eslint-enable perfectionist/sort-objects */
 };
 export default class Status extends Command {
     static description = 'display current status of the Heroku platform';
@@ -148,10 +149,10 @@ export default class Status extends Command {
         if (herokuStatus) {
             for (const incident of herokuStatus.incidents) {
                 ux.stdout();
-                hux.styledHeader(`${incident.title} ${color.yellow(incident.created_at)} ${color.cyan(incident.full_url)}`);
+                hux.styledHeader(`${incident.title} ${color.warning(incident.created_at)} ${color.info(incident.full_url)}`);
                 const padding = getMaxUpdateTypeLength(incident.updates.map(update => update.update_type));
                 for (const u of incident.updates) {
-                    ux.stdout(`${color.yellow(u.update_type.padEnd(padding))} ${new Date(u.updated_at).toISOString()} (${formatDistanceToNow(new Date(u.updated_at))} ago)`);
+                    ux.stdout(`${color.warning(u.update_type.padEnd(padding))} ${new Date(u.updated_at).toISOString()} (${formatDistanceToNow(new Date(u.updated_at))} ago)`);
                     ux.stdout(`${u.contents}\n`);
                 }
             }
@@ -159,11 +160,11 @@ export default class Status extends Command {
         else if (formattedTrustStatus) {
             for (const incident of formattedTrustStatus.incidents) {
                 ux.stdout();
-                hux.styledHeader(`${incident.id} ${color.yellow(incident.createdAt)} ${color.cyan(`https://status.salesforce.com/incidents/${incident.id}`)}`);
+                hux.styledHeader(`${incident.id} ${color.warning(incident.createdAt)} ${color.info(`https://status.salesforce.com/incidents/${incident.id}`)}`);
                 const padding = getMaxUpdateTypeLength(incident.IncidentEvents.map(event => event.localizedType ?? event.type));
                 for (const event of incident.IncidentEvents) {
                     const eventType = event.localizedType ?? event.type;
-                    ux.stdout(`${color.yellow(eventType.padEnd(padding))} ${new Date(event.createdAt).toISOString()} (${formatDistanceToNow(new Date(event.createdAt))} ago)`);
+                    ux.stdout(`${color.warning(eventType.padEnd(padding))} ${new Date(event.createdAt).toISOString()} (${formatDistanceToNow(new Date(event.createdAt))} ago)`);
                     ux.stdout(`${event.message}\n`);
                 }
             }

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

@@ -1,9 +1,9 @@
 import { Command } from '@heroku-cli/command';
 export default class Index extends Command {
-    static topic: string;
     static description: string;
     static flags: {
         json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
+    static topic: string;
     run(): Promise<void>;
 }

package/lib/commands/teams/index.js

@@ -1,12 +1,11 @@
-import { color } from '@heroku-cli/color';
+import { color, hux } from '@heroku/heroku-cli-util';
 import { Command, flags } from '@heroku-cli/command';
-import { hux } from '@heroku/heroku-cli-util';
 export default class Index extends Command {
-    static topic = 'teams';
-    static description = `list the teams that you are a member of\n\nUse ${color.cmd('heroku members:*')} to manage team members.`;
+    static description = `list the teams that you are a member of\n\nUse ${color.code('heroku members:*')} to manage team members.`;
     static flags = {
         json: flags.boolean({ description: 'output in json format' }),
     };
+    static topic = 'teams';
     async run() {
         const { flags } = await this.parse(Index);
         const { body: teams } = await this.heroku.get('/teams');
@@ -19,7 +18,7 @@ export default class Index extends Command {
                 return (aName > bName) ? 1 : ((bName > aName) ? -1 : 0);
             }), {
                 name: { header: 'Team' },
-                role: { header: 'Role', get: ({ role }) => color.green(role || '') },
+                role: { get: ({ role }) => color.info(role || ''), header: 'Role' },
             });
         }
     }

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

@@ -1,16 +1,17 @@
 import { Command } from '@heroku-cli/command';
 export default class Add extends Command {
+    static args: {
+        endpoint: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
     static description: string;
+    static example: string;
     static flags: {
         app: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         headers: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
-        space: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         signals: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        space: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         transport: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
     };
-    static args: {
-        endpoint: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
-    };
-    static example: string;
     run(): Promise<void>;
+    private getExporterType;
 }

package/lib/commands/telemetry/add.js

@@ -1,28 +1,40 @@
+import { color } from '@heroku/heroku-cli-util';
 import { Command, flags as Flags } from '@heroku-cli/command';
 import { Args, ux } from '@oclif/core';
 import tsheredoc from 'tsheredoc';
 import { validateAndFormatSignals } from '../../lib/telemetry/util.js';
 const heredoc = tsheredoc.default;
 export default class Add extends Command {
+    static args = {
+        endpoint: Args.string({ description: 'drain url', required: true }),
+    };
     static description = 'Add and configure a new telemetry drain. Defaults to collecting all telemetry unless otherwise specified.';
+    /* eslint-disable quotes */
+    static example = heredoc `
+    Add a telemetry drain to an app to collect logs and traces:
+    
+    ${color.command(`heroku telemetry:add https://my-endpoint.com --app myapp --signals logs,traces --headers '{"x-drain-example-team": "API_KEY", "x-drain-example-dataset": "METRICS_DATASET"}'`)}
+  `;
     static flags = {
-        app: Flags.string({ char: 'a', exactlyOne: ['app', 'space'], description: 'app to add a drain to' }),
+        app: Flags.string({ char: 'a', description: 'app to add a drain to', exactlyOne: ['app', 'space'] }),
         headers: Flags.string({ description: 'custom headers to configure the drain in json format' }),
-        space: Flags.string({ char: 's', description: 'space to add a drain to' }),
         signals: Flags.string({ default: 'all', description: 'comma-delimited list of signals to collect (traces, metrics, logs). Use "all" to collect all signals.' }),
-        transport: Flags.string({ default: 'http', options: ['http', 'grpc'], description: 'transport protocol for the drain' }),
-    };
-    static args = {
-        endpoint: Args.string({ required: true, description: 'drain url' }),
+        space: Flags.string({ char: 's', description: 'space to add a drain to' }),
+        // If splunk transport is accepted as a feature, this should have options: ['http', 'grpc', 'splunk']
+        transport: Flags.string({ default: 'http', description: 'transport protocol for the drain' }),
     };
-    static example = heredoc(`
-    Add a telemetry drain to an app to collect logs and traces:
-    $ heroku telemetry:add https://my-endpoint.com --app myapp --signals logs,traces --headers '{"x-drain-example-team": "API_KEY", "x-drain-example-dataset": "METRICS_DATASET"}'
-  `);
+    /* eslint-enable quotes */
     async run() {
-        const { flags, args } = await this.parse(Add);
-        const { app, headers, space, signals, transport } = flags;
+        const { args, flags } = await this.parse(Add);
+        const { app, headers, signals, space, transport } = flags;
         const { endpoint } = args;
+        // Allow splunk, but do not show splunk in error message until splunk transport is accepted as a feature
+        // When splunk transport is accepted as a feature, and options are added for the transport flag, this section should be removed
+        const publicTransports = ['http', 'grpc'];
+        const validTransports = [...publicTransports, 'splunk'];
+        if (!validTransports.includes(transport)) {
+            throw new Error(`Expected --transport=${transport} to be one of: ${publicTransports.join(', ')}`);
+        }
         let id;
         if (app) {
             const { body: herokuApp } = await this.heroku.get(`/apps/${app}`, {
@@ -36,16 +48,16 @@ export default class Add extends Command {
         }
         const exporterHeaders = headers || '{}';
         const drainConfig = {
-            owner: {
-                type: app ? 'app' : 'space',
-                id,
-            },
-            signals: validateAndFormatSignals(signals),
             exporter: {
                 endpoint,
-                type: (transport === 'grpc') ? 'otlp' : 'otlphttp',
                 headers: JSON.parse(exporterHeaders),
+                type: this.getExporterType(transport),
+            },
+            owner: {
+                id,
+                type: app ? 'app' : 'space',
             },
+            signals: validateAndFormatSignals(signals),
         };
         const { body: drain } = await this.heroku.post('/telemetry-drains', {
             body: drainConfig,
@@ -55,4 +67,17 @@ export default class Add extends Command {
         });
         ux.stdout(`successfully added drain ${drain.exporter.endpoint}`);
     }
+    getExporterType(transport) {
+        switch (transport) {
+            case 'grpc': {
+                return 'otlp';
+            }
+            case 'splunk': {
+                return 'splunk';
+            }
+            default: {
+                return 'otlphttp';
+            }
+        }
+    }
 }

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

@@ -1,13 +1,13 @@
 import { Command } from '@heroku-cli/command';
 import { TelemetryDrains } from '../../lib/types/telemetry.js';
 export default class Index extends Command {
-    static topic: string;
     static description: string;
+    static example: string;
     static flags: {
-        space: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         app: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        space: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
-    static example: string;
-    run(): Promise<void>;
+    static topic: string;
     protected display(telemetryDrains: TelemetryDrains, owner: string | undefined): void;
+    run(): Promise<void>;
 }

package/lib/commands/telemetry/index.js

@@ -1,14 +1,29 @@
+import { color, hux } from '@heroku/heroku-cli-util';
 import { Command, flags as Flags } from '@heroku-cli/command';
 import { ux } from '@oclif/core';
-import { hux } from '@heroku/heroku-cli-util';
 export default class Index extends Command {
-    static topic = 'telemetry';
     static description = 'list telemetry drains';
+    static example = `${color.command('heroku telemetry')}`;
     static flags = {
-        space: Flags.string({ char: 's', description: 'filter by space name', exactlyOne: ['app', 'space'] }),
         app: Flags.string({ char: 'a', description: 'filter by app name' }),
+        space: Flags.string({ char: 's', description: 'filter by space name', exactlyOne: ['app', 'space'] }),
     };
-    static example = '$ heroku telemetry';
+    static topic = 'telemetry';
+    display(telemetryDrains, owner) {
+        if (telemetryDrains.length === 0) {
+            ux.stdout(`There are no telemetry drains in ${owner}`);
+        }
+        else {
+            hux.styledHeader(`${owner} Telemetry Drains`);
+            /* eslint-disable perfectionist/sort-objects */
+            hux.table(telemetryDrains, {
+                ID: { get: telemetryDrain => telemetryDrain.id },
+                Signals: { get: telemetryDrain => telemetryDrain.signals },
+                Endpoint: { get: telemetryDrain => telemetryDrain.exporter.endpoint },
+            });
+            /* eslint-enable perfectionist/sort-objects */
+        }
+    }
     async run() {
         const { flags } = await this.parse(Index);
         const { app, space } = flags;
@@ -31,17 +46,4 @@ export default class Index extends Command {
         }
         this.display(drains, app || space);
     }
-    display(telemetryDrains, owner) {
-        if (telemetryDrains.length === 0) {
-            ux.stdout(`There are no telemetry drains in ${owner}`);
-        }
-        else {
-            hux.styledHeader(`${owner} Telemetry Drains`);
-            hux.table(telemetryDrains, {
-                ID: { get: telemetryDrain => telemetryDrain.id },
-                Signals: { get: telemetryDrain => telemetryDrain.signals },
-                Endpoint: { get: telemetryDrain => telemetryDrain.exporter.endpoint },
-            });
-        }
-    }
 }

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

@@ -1,10 +1,10 @@
 import { Command } from '@heroku-cli/command';
 export default class Info extends Command {
-    static topic: string;
-    static description: string;
     static args: {
         telemetry_drain_id: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
     };
+    static description: string;
     static example: string;
+    static topic: string;
     run(): Promise<void>;
 }

package/lib/commands/telemetry/info.js

@@ -1,13 +1,14 @@
+import { color } from '@heroku/heroku-cli-util';
 import { Command } from '@heroku-cli/command';
 import { Args } from '@oclif/core';
 import { displayTelemetryDrain } from '../../lib/telemetry/util.js';
 export default class Info extends Command {
-    static topic = 'telemetry';
-    static description = 'show a telemetry drain\'s info';
     static args = {
-        telemetry_drain_id: Args.string({ required: true, description: 'ID of the drain to show info for' }),
+        telemetry_drain_id: Args.string({ description: 'ID of the drain to show info for', required: true }),
     };
-    static example = '$ heroku telemetry:info 022e2e2e-2e2e-2e2e-2e2e-2e2e2e2e2e2e';
+    static description = 'show a telemetry drain\'s info';
+    static example = `${color.command('heroku telemetry:info 022e2e2e-2e2e-2e2e-2e2e-2e2e2e2e2e2e')}`;
+    static topic = 'telemetry';
     async run() {
         const { args } = await this.parse(Info);
         const { telemetry_drain_id } = args;

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

@@ -1,16 +1,16 @@
 import { Command } from '@heroku-cli/command';
 export default class Update extends Command {
-    static topic: string;
-    static description: string;
     static args: {
         telemetry_drain_id: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
     };
+    static description: string;
+    static example: string;
     static flags: {
         endpoint: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         headers: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         signals: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         transport: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
-    static example: string;
+    static topic: string;
     run(): Promise<void>;
 }

package/lib/commands/telemetry/update.js

@@ -1,23 +1,22 @@
-import { flags as Flags, Command } from '@heroku-cli/command';
+import { color } from '@heroku/heroku-cli-util';
+import { Command, flags as Flags } from '@heroku-cli/command';
 import { Args, ux } from '@oclif/core';
 import tsheredoc from 'tsheredoc';
 import { displayTelemetryDrain, validateAndFormatSignals } from '../../lib/telemetry/util.js';
 const heredoc = tsheredoc.default;
 export default class Update extends Command {
-    static topic = 'telemetry';
-    static description = 'updates a telemetry drain with provided attributes (attributes not provided remain unchanged)';
     static args = {
-        telemetry_drain_id: Args.string({ required: true, description: 'ID of the drain to update' }),
+        telemetry_drain_id: Args.string({ description: 'ID of the drain to update', required: true }),
     };
+    static description = 'updates a telemetry drain with provided attributes (attributes not provided remain unchanged)';
+    static example = `${color.command('heroku telemetry:update acde070d-8c4c-4f0d-9d8a-162843c10333 --signals logs,metrics --endpoint https://my-new-endpoint.com')}`;
     static flags = {
         endpoint: Flags.string({ description: 'drain url' }),
         headers: Flags.string({ description: 'custom headers to configure the drain in json format' }),
         signals: Flags.string({ description: 'comma-delimited list of signals to collect (traces, metrics, logs). Use "all" to collect all signals.' }),
-        transport: Flags.string({ options: ['http', 'grpc'], description: 'transport protocol for the drain' }),
+        transport: Flags.string({ description: 'transport protocol for the drain', options: ['http', 'grpc'] }),
     };
-    static example = heredoc(`
-    $ heroku telemetry:update acde070d-8c4c-4f0d-9d8a-162843c10333 --signals logs,metrics --endpoint https://my-new-endpoint.com
-  `);
+    static topic = 'telemetry';
     async run() {
         const { args, flags } = await this.parse(Update);
         const { telemetry_drain_id } = args;
@@ -47,10 +46,10 @@ export default class Update extends Command {
         }
         ux.action.start(`Updating telemetry drain ${telemetry_drain_id}`);
         const { body: telemetryDrain } = await this.heroku.patch(`/telemetry-drains/${telemetry_drain_id}`, {
+            body: drainConfig,
             headers: {
                 Accept: 'application/vnd.heroku+json; version=3.sdk',
             },
-            body: drainConfig,
         });
         ux.action.stop();
         await displayTelemetryDrain(telemetryDrain, this.heroku);

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

@@ -1,14 +1,14 @@
 import { Command } from '@heroku-cli/command';
 export default class UsageAddons extends Command {
-    static topic: string;
     static description: string;
     static flags: {
         app: 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 topic: string;
+    run(): Promise<void>;
     private displayAppUsage;
     private fetchAndDisplayAppUsageData;
     private fetchAndDisplayTeamUsageData;
     private getAppInfoFromTeamAddons;
-    run(): Promise<void>;
 }

package/lib/commands/usage/addons.js

@@ -1,14 +1,26 @@
+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';
-import { color } from '@heroku-cli/color';
 export default class UsageAddons extends Command {
-    static topic = 'usage';
     static description = 'list usage for metered add-ons attached to an app or apps within a team';
     static flags = {
         app: flags.string({ char: 'a', description: 'app to list metered add-ons usage for' }),
         team: flags.team({ description: 'team to list metered add-ons usage for' }),
     };
+    static topic = 'usage';
+    async run() {
+        const { flags } = await this.parse(UsageAddons);
+        const { app, team } = flags;
+        if (!app && !team) {
+            ux.error('Specify an app with --app or a team with --team');
+        }
+        if (app) {
+            await this.fetchAndDisplayAppUsageData(app, team);
+        }
+        else if (team) {
+            await this.fetchAndDisplayTeamUsageData(team);
+        }
+    }
     displayAppUsage(app, usageAddons, appAddons) {
         const metersArray = usageAddons.flatMap(addon => Object.entries(addon.meters).map(([label, data]) => ({
             label,
@@ -65,7 +77,7 @@ export default class UsageAddons extends Command {
         this.displayAppUsage(app, usageAddons, appAddons);
     }
     async fetchAndDisplayTeamUsageData(team) {
-        ux.action.start(`Gathering usage data for ${color.magenta(team)}`);
+        ux.action.start(`Gathering usage data for ${color.team(team)}`);
         const [{ body: usageData }, { body: teamAddons }] = await Promise.all([
             this.heroku.get(`/teams/${team}/usage`, {
                 headers: {
@@ -77,7 +89,7 @@ export default class UsageAddons extends Command {
         ux.action.stop();
         ux.stdout();
         if (!usageData.apps || usageData.apps.length === 0) {
-            ux.stdout(`No usage found for team ${color.magenta(team)}`);
+            ux.stdout(`No usage found for team ${color.team(team)}`);
             return;
         }
         const appInfoArray = this.getAppInfoFromTeamAddons(teamAddons);
@@ -100,17 +112,4 @@ export default class UsageAddons extends Command {
             name,
         }));
     }
-    async run() {
-        const { flags } = await this.parse(UsageAddons);
-        const { app, team } = flags;
-        if (!app && !team) {
-            ux.error('Specify an app with --app or a team with --team');
-        }
-        if (app) {
-            await this.fetchAndDisplayAppUsageData(app, team);
-        }
-        else if (team) {
-            await this.fetchAndDisplayTeamUsageData(team);
-        }
-    }
 }

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,
+            });
+        }
+    }
+}