heroku 8.1.9 → 8.2.0-beta.1

package/lib/commands/run/inside.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// tslint:disable:file-name-casing
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const debug_1 = require("debug");
+const dyno_1 = require("../../lib/run/dyno");
+const helpers_1 = require("../../lib/run/helpers");
+const debug = (0, debug_1.default)('heroku:run:inside');
+class RunInside extends command_1.Command {
+    async run() {
+        const parsed = await this.parse(RunInside);
+        const { flags } = parsed;
+        const argv = parsed.argv;
+        if (argv.length < 2) {
+            throw new Error('Usage: heroku run:inside DYNO COMMAND\n\nExample: heroku run:inside web.1 bash');
+        }
+        const opts = {
+            'exit-code': flags['exit-code'],
+            app: flags.app,
+            command: (0, helpers_1.buildCommand)(argv.slice(1)),
+            dyno: argv[0],
+            env: flags.env,
+            heroku: this.heroku,
+            listen: flags.listen,
+        };
+        const dyno = new dyno_1.default(opts);
+        try {
+            await dyno.start();
+        }
+        catch (error) {
+            debug(error);
+            if (error.exitCode) {
+                core_1.ux.exit(error.exitCode);
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+}
+exports.default = RunInside;
+RunInside.description = 'run a one-off process inside an existing heroku dyno';
+RunInside.hidden = true;
+RunInside.examples = [
+    '$ heroku run:inside web.1 bash',
+];
+RunInside.flags = {
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+    'exit-code': command_1.flags.boolean({ char: 'x', description: 'passthrough the exit code of the remote command' }),
+    env: command_1.flags.string({ char: 'e', description: "environment variables to set (use ';' to split multiple vars)" }),
+    listen: command_1.flags.boolean({ description: 'listen on a local port', hidden: true }),
+};
+RunInside.strict = false;

package/lib/commands/sessions/destroy.d.ts

@@ -0,0 +1,8 @@
+import { Command } from '@heroku-cli/command';
+export default class SessionsDestroy extends Command {
+    static description: string;
+    static args: {
+        id: import("@oclif/core/lib/interfaces/parser").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/sessions/destroy.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const color_1 = require("@heroku-cli/color");
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+class SessionsDestroy extends command_1.Command {
+    async run() {
+        const { args: { id } } = await this.parse(SessionsDestroy);
+        core_1.ux.action.start(`Destroying ${color_1.default.cyan(id)}`);
+        await this.heroku.delete(`/oauth/sessions/${encodeURIComponent(id)}`);
+        core_1.ux.action.stop();
+    }
+}
+exports.default = SessionsDestroy;
+SessionsDestroy.description = 'delete (logout) OAuth session by ID';
+SessionsDestroy.args = {
+    id: core_1.Args.string({ required: true }),
+};

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

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

package/lib/commands/sessions/index.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const color_1 = require("@heroku-cli/color");
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const { sortBy } = require('lodash');
+class SessionsIndex extends command_1.Command {
+    async run() {
+        const { flags } = await this.parse(SessionsIndex);
+        let { body: sessions } = await this.heroku.get('/oauth/sessions');
+        sessions = sortBy(sessions, 'description');
+        if (flags.json) {
+            core_1.ux.styledJSON(sessions);
+        }
+        else if (sessions.length === 0) {
+            core_1.ux.log('No OAuth sessions.');
+        }
+        else {
+            const printLine = (...args) => this.log(...args);
+            core_1.ux.table(sessions, {
+                description: { get: (v) => color_1.default.green(v.description) },
+                id: {},
+            }, { 'no-header': true, printLine });
+        }
+    }
+}
+exports.default = SessionsIndex;
+SessionsIndex.description = 'list your OAuth sessions';
+SessionsIndex.flags = {
+    json: command_1.flags.boolean({ char: 'j', description: 'output in json format' }),
+};

package/lib/commands/status.d.ts

@@ -0,0 +1,8 @@
+import { Command } from '@oclif/core';
+export default class Status extends Command {
+    static description: string;
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/status.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const color_1 = require("@heroku-cli/color");
+const core_1 = require("@oclif/core");
+const distanceInWordsToNow = require("date-fns/distance_in_words_to_now");
+const http_call_1 = require("http-call");
+const util_1 = require("../lib/status/util");
+const capitalize = (str) => str.slice(0, 1).toUpperCase() + str.slice(1);
+const printStatus = (status) => {
+    const colorize = color_1.default[status];
+    let message = capitalize(status);
+    if (status === 'green') {
+        message = 'No known issues at this time.';
+    }
+    return colorize(message);
+};
+class Status extends core_1.Command {
+    async run() {
+        const { flags } = await this.parse(Status);
+        const apiPath = '/api/v4/current-status';
+        const host = process.env.HEROKU_STATUS_HOST || 'https://status.heroku.com';
+        const { body } = await http_call_1.default.get(host + apiPath);
+        if (flags.json) {
+            core_1.ux.styledJSON(body);
+            return;
+        }
+        for (const item of body.status) {
+            const message = printStatus(item.status);
+            this.log(`${(item.system + ':').padEnd(11)}${message}`);
+        }
+        for (const incident of body.incidents) {
+            core_1.ux.log();
+            core_1.ux.styledHeader(`${incident.title} ${color_1.default.yellow(incident.created_at)} ${color_1.default.cyan(incident.full_url)}`);
+            const padding = (0, util_1.maxBy)(incident.updates, (i) => i.update_type.length).update_type.length + 0;
+            for (const u of incident.updates) {
+                core_1.ux.log(`${color_1.default.yellow(u.update_type.padEnd(padding))} ${new Date(u.updated_at).toISOString()} (${distanceInWordsToNow(new Date(u.updated_at))} ago)`);
+                core_1.ux.log(`${u.contents}\n`);
+            }
+        }
+    }
+}
+exports.default = Status;
+Status.description = 'display current status of the Heroku platform';
+Status.flags = {
+    json: core_1.Flags.boolean({ description: 'output in json format' }),
+};

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

@@ -0,0 +1,16 @@
+import BaseCommand from '../../lib/webhooks/base';
+export default class WebhooksAdd extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        app: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        remote: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        pipeline: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        include: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        level: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        secret: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        authorization: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        url: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/webhooks/add.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const spinner_1 = require("@oclif/core/lib/cli-ux/action/spinner");
+const base_1 = require("../../lib/webhooks/base");
+class WebhooksAdd extends base_1.default {
+    async run() {
+        const { flags } = await this.parse(WebhooksAdd);
+        const { path, display } = this.webhookType(flags);
+        const action = new spinner_1.default();
+        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,
+            },
+        });
+        const secret = response.headers && response.headers['heroku-webhook-secret'];
+        if (secret) {
+            core_1.ux.styledHeader('Webhooks Signing Secret');
+            this.log(secret);
+        }
+        else {
+            core_1.ux.warn('no secret found');
+        }
+        action.stop();
+    }
+}
+exports.default = WebhooksAdd;
+WebhooksAdd.description = 'add a webhook to an app';
+WebhooksAdd.examples = [
+    '$ heroku webhooks:add -i api:dyno -l notify -u https://example.com/hooks',
+];
+WebhooksAdd.flags = {
+    app: command_1.flags.app(),
+    remote: command_1.flags.remote(),
+    pipeline: command_1.flags.pipeline({ char: 'p', description: 'pipeline on which to list', hidden: true }),
+    include: command_1.flags.string({ char: 'i', description: 'comma delimited event types your server will receive ', required: true }),
+    level: command_1.flags.string({ char: 'l', description: 'notify does not retry, sync will retry until successful or timeout', required: true }),
+    secret: command_1.flags.string({ char: 's', description: 'value to sign delivery with in Heroku-Webhook-Hmac-SHA256 header' }),
+    authorization: command_1.flags.string({ char: 't', description: 'authoriation header to send with webhooks' }),
+    url: command_1.flags.string({ char: 'u', description: 'URL for receiver', required: true }),
+};

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

@@ -0,0 +1,12 @@
+import BaseCommand from '../../../lib/webhooks/base';
+export default class Deliveries extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        app: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        remote: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        status: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        pipeline: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

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

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const base_1 = require("../../../lib/webhooks/base");
+class Deliveries extends base_1.default {
+    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) => {
+                return (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);
+            core_1.ux.table(deliveries, {
+                id: {
+                    header: 'Delivery ID',
+                },
+                created_at: {
+                    header: 'Created', get: (w) => w.created_at,
+                },
+                status: {
+                    get: (w) => w.status,
+                },
+                include: {
+                    get: (w) => w.event.include,
+                },
+                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 || '',
+                },
+            }, {
+                'no-header': false, printLine,
+            });
+        }
+    }
+}
+exports.default = Deliveries;
+Deliveries.description = 'list webhook deliveries on an app';
+Deliveries.examples = [
+    '$ heroku webhooks:deliveries',
+];
+Deliveries.flags = {
+    app: command_1.flags.app(),
+    remote: command_1.flags.remote(),
+    status: command_1.flags.string({ char: 's', description: 'filter deliveries by status' }),
+    pipeline: command_1.flags.pipeline({ char: 'p', description: 'pipeline on which to list', hidden: true }),
+};

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

@@ -0,0 +1,14 @@
+import BaseCommand from '../../../lib/webhooks/base';
+export default class DeliveriesInfo extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        app: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        remote: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        pipeline: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    static args: {
+        id: import("@oclif/core/lib/interfaces/parser").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

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

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const base_1 = require("../../../lib/webhooks/base");
+class DeliveriesInfo extends base_1.default {
+    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,
+        };
+        core_1.ux.styledHeader(delivery.id);
+        core_1.ux.styledObject(obj);
+        core_1.ux.styledHeader('Event Payload');
+        core_1.ux.styledJSON(event.payload);
+    }
+}
+exports.default = DeliveriesInfo;
+DeliveriesInfo.description = 'info for a webhook event on an app';
+DeliveriesInfo.examples = [
+    '$ heroku webhooks:deliveries:info 99999999-9999-9999-9999-999999999999',
+];
+DeliveriesInfo.flags = {
+    app: command_1.flags.app(),
+    remote: command_1.flags.remote(),
+    pipeline: command_1.flags.pipeline({ char: 'p', description: 'pipeline on which to list', hidden: true }),
+};
+DeliveriesInfo.args = {
+    id: core_1.Args.string({ required: true }),
+};

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

@@ -0,0 +1,11 @@
+import BaseCommand from '../../../lib/webhooks/base';
+export default class EventsIndex extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        app: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        remote: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        pipeline: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

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

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const base_1 = require("../../../lib/webhooks/base");
+class EventsIndex extends base_1.default {
+    async run() {
+        const { flags } = await this.parse(EventsIndex);
+        const { path, display } = this.webhookType(flags);
+        core_1.ux.warn('heroku webhooks:event is deprecated, please use heroku webhooks:deliveries');
+        const { body: events } = await this.webhooksClient.get(`${path}/webhook-events`);
+        if (events.length === 0) {
+            this.log(`${display} has no events`);
+        }
+        else {
+            events.sort((a, b) => Date.parse(a.created_at) - Date.parse(b.created_at));
+            const printLine = (...args) => this.log(...args);
+            core_1.ux.table(events, {
+                id: {
+                    header: 'Event ID',
+                },
+                resource: {
+                    get: (w) => w.payload.resource,
+                },
+                action: {
+                    get: (w) => w.payload.action,
+                },
+                published_at: {
+                    header: 'Published At', get: (w) => w.payload.published_at,
+                },
+            }, {
+                'no-header': false, printLine,
+            });
+        }
+    }
+}
+exports.default = EventsIndex;
+EventsIndex.description = 'list webhook events on an app';
+EventsIndex.examples = [
+    '$ heroku webhooks:events',
+];
+EventsIndex.flags = {
+    app: command_1.flags.app(),
+    remote: command_1.flags.remote(),
+    pipeline: command_1.flags.pipeline({ char: 'p', description: 'pipeline on which to list', hidden: true }),
+};

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

@@ -0,0 +1,14 @@
+import BaseCommand from '../../../lib/webhooks/base';
+export default class Info extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        app: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        remote: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        pipeline: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    static args: {
+        id: import("@oclif/core/lib/interfaces/parser").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const base_1 = require("../../../lib/webhooks/base");
+class Info extends base_1.default {
+    async run() {
+        const { flags, args } = await this.parse(Info);
+        const { path } = this.webhookType(flags);
+        core_1.ux.warn('heroku webhooks:event:info is deprecated, please use heroku webhooks:deliveries:info');
+        const { body: webhookEvent } = await this.webhooksClient.get(`${path}/webhook-events/${args.id}`);
+        const obj = {
+            payload: JSON.stringify(webhookEvent.payload, null, 2),
+        };
+        core_1.ux.styledHeader(webhookEvent.id);
+        core_1.ux.styledObject(obj);
+    }
+}
+exports.default = Info;
+Info.description = 'info for a webhook event on an app';
+Info.examples = [
+    '$ heroku webhooks:events:info 99999999-9999-9999-9999-999999999999',
+];
+Info.flags = {
+    app: command_1.flags.app(),
+    remote: command_1.flags.remote(),
+    pipeline: command_1.flags.pipeline({ char: 'p', description: 'pipeline on which to list', hidden: true }),
+};
+Info.args = {
+    id: core_1.Args.string({ required: true }),
+};

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

@@ -0,0 +1,11 @@
+import BaseCommand from '../../lib/webhooks/base';
+export default class Webhooks extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        app: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        remote: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        pipeline: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/webhooks/index.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const color_1 = require("@heroku-cli/color");
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const base_1 = require("../../lib/webhooks/base");
+class Webhooks extends base_1.default {
+    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) {
+            this.log(`${display} has no webhooks\nUse ${color_1.default.cmd('heroku webhooks:add')} to add one.`);
+            return;
+        }
+        webhooks.sort((a, b) => Date.parse(a.created_at) - Date.parse(b.created_at));
+        const printLine = (...args) => this.log(...args);
+        core_1.ux.table(webhooks, {
+            id: {
+                header: 'Webhook ID',
+            },
+            url: {
+                header: 'URL',
+            },
+            include: {
+                get: (row) => row.include.join(','),
+            },
+            level: {},
+        }, {
+            'no-header': false, printLine,
+        });
+    }
+}
+exports.default = Webhooks;
+Webhooks.description = 'list webhooks on an app';
+Webhooks.examples = ['$ heroku webhooks'];
+Webhooks.flags = {
+    app: command_1.flags.app(),
+    remote: command_1.flags.remote(),
+    pipeline: command_1.flags.pipeline({
+        char: 'p',
+        description: 'pipeline on which to list',
+        hidden: true,
+    }),
+};

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

@@ -0,0 +1,14 @@
+import BaseCommand from '../../lib/webhooks/base';
+export default class WebhooksInfo extends BaseCommand {
+    static description: string;
+    static example: string[];
+    static flags: {
+        app: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        remote: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        pipeline: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    static args: {
+        id: import("@oclif/core/lib/interfaces/parser").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/webhooks/info.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const base_1 = require("../../lib/webhooks/base");
+class WebhooksInfo extends base_1.default {
+    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,
+        };
+        core_1.ux.styledHeader(webhook.id);
+        core_1.ux.styledObject(obj);
+    }
+}
+exports.default = WebhooksInfo;
+WebhooksInfo.description = 'info for a webhook on an app';
+WebhooksInfo.example = ['$ heroku webhooks:info 99999999-9999-9999-9999-999999999999'];
+WebhooksInfo.flags = {
+    app: command_1.flags.app(),
+    remote: command_1.flags.remote(),
+    pipeline: command_1.flags.pipeline({ char: 'p', description: 'pipeline on which to list', hidden: true }),
+};
+WebhooksInfo.args = {
+    id: core_1.Args.string({ required: true }),
+};

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

@@ -0,0 +1,14 @@
+import BaseCommand from '../../lib/webhooks/base';
+export default class WebhooksRemove extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        app: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        remote: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        pipeline: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    static args: {
+        id: import("@oclif/core/lib/interfaces/parser").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}