heroku 9.0.0-alpha.0 → 9.0.0-alpha.2

package/lib/lib/addons/resolve.js

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AmbiguousError = exports.NotFound = exports.resolveAddon = exports.attachmentResolver = exports.appAttachment = exports.addonResolver = exports.appAddon = void 0;
+const http_call_1 = require("http-call");
+const api_client_1 = require("@heroku-cli/command/lib/api-client");
+const addonHeaders = {
+    Accept: 'application/vnd.heroku+json; version=3.actions',
+    'Accept-Expansion': 'addon_service,plan',
+};
+const appAddon = async function (heroku, app, id, options = {}) {
+    const response = await heroku.post('/actions/addons/resolve', {
+        headers: addonHeaders,
+        body: { app: app, addon: id, addon_service: options.addon_service },
+    });
+    return singularize('addon', options.namespace)(response === null || response === void 0 ? void 0 : response.body);
+};
+exports.appAddon = appAddon;
+const handleNotFound = function (err, resource) {
+    if (err.statusCode === 404 && err.body && err.body.resource === resource) {
+        return true;
+    }
+    throw err;
+};
+const addonResolver = async (heroku, app, id, options) => {
+    const getAddon = async (addonId) => {
+        const response = await heroku.post('/actions/addons/resolve', {
+            headers: addonHeaders,
+            body: { app: null, addon: addonId, addon_service: options === null || options === void 0 ? void 0 : options.addon_service },
+        });
+        return singularize('addon', (options === null || options === void 0 ? void 0 : options.namespace) || '')(response === null || response === void 0 ? void 0 : response.body);
+    };
+    if (!app || id.includes('::')) {
+        return getAddon(id);
+    }
+    try {
+        return await (0, exports.appAddon)(heroku, app, id, options);
+    }
+    catch (error) {
+        if (error instanceof http_call_1.HTTPError && handleNotFound(error, 'add_on')) {
+            return getAddon(id);
+        }
+        throw error;
+    }
+};
+exports.addonResolver = addonResolver;
+// -----------------------------------------------------
+// Attachment resolver functions
+// originating from `packages/addons-v5/lib/resolve.js`
+// -----------------------------------------------------
+const filter = function (app, addonService) {
+    return (attachments) => {
+        return attachments.filter(attachment => {
+            var _a, _b;
+            if (((_a = attachment === null || attachment === void 0 ? void 0 : attachment.app) === null || _a === void 0 ? void 0 : _a.name) !== app) {
+                return false;
+            }
+            return !(addonService && ((_b = attachment === null || attachment === void 0 ? void 0 : attachment.addon_service) === null || _b === void 0 ? void 0 : _b.name) !== addonService);
+        });
+    };
+};
+const attachmentHeaders = {
+    Accept: 'application/vnd.heroku+json; version=3.actions',
+    'Accept-Inclusion': 'addon:plan,config_vars',
+};
+const appAttachment = async (heroku, app, id, options = {}) => {
+    const result = await heroku.post('/actions/addon-attachments/resolve', {
+        headers: attachmentHeaders, body: { app, addon_attachment: id, addon_service: options.addon_service },
+    });
+    return singularize('addon_attachment', options.namespace)(result.body);
+};
+exports.appAttachment = appAttachment;
+const attachmentResolver = async (heroku, app, id, options = {}) => {
+    async function getAttachment(id) {
+        try {
+            const result = await heroku.post('/actions/addon-attachments/resolve', {
+                headers: attachmentHeaders, body: { app: null, addon_attachment: id, addon_service: options.addon_service },
+            });
+            return singularize('addon_attachment', options.namespace || '')(result.body);
+        }
+        catch (error) {
+            if (error instanceof api_client_1.HerokuAPIError) {
+                handleNotFound(error.http, 'add_on attachment');
+            }
+        }
+    }
+    async function getAppAddonAttachment(addon, app) {
+        var _a;
+        try {
+            const result = await heroku.get(`/addons/${encodeURIComponent((_a = addon.id) !== null && _a !== void 0 ? _a : '')}/addon-attachments`, { headers: attachmentHeaders });
+            const matches = filter(app, options.addon_service)(result.body);
+            return singularize('addon_attachment', options.namespace)(matches);
+        }
+        catch (error) {
+            const err = error instanceof api_client_1.HerokuAPIError ? error.http : error;
+            handleNotFound(err, 'add_on attachment');
+        }
+    }
+    // first check to see if there is an attachment matching this app/id combo
+    try {
+        const attachment = await (!app || id.includes('::') ? getAttachment(id) : (0, exports.appAttachment)(heroku, app, id, options));
+        if (attachment) {
+            return attachment;
+        }
+    }
+    catch (_a) { }
+    // if no attachment, look up an add-on that matches the id
+    // If we were passed an add-on slug, there still could be an attachment
+    // to the context app. Try to find and use it so `context_app` is set
+    // correctly in the SSO payload.
+    if (app) {
+        try {
+            const addon = await resolveAddon(heroku, app, id, options);
+            return await getAppAddonAttachment(addon, app);
+        }
+        catch (error) {
+            const err = error instanceof api_client_1.HerokuAPIError ? error.http : error;
+            handleNotFound(err, 'add_on attachment');
+        }
+    }
+};
+exports.attachmentResolver = attachmentResolver;
+// -----------------------------------------------------
+// END
+// -----------------------------------------------------
+const addonResolverMap = new Map();
+async function resolveAddon(...args) {
+    var _a;
+    const [, app, id, options] = args;
+    const key = `${app}|${id}|${(_a = options === null || options === void 0 ? void 0 : options.addon_service) !== null && _a !== void 0 ? _a : ''}`;
+    const promise = addonResolverMap.get(key) || (0, exports.addonResolver)(...args);
+    try {
+        await promise;
+        addonResolverMap.has(key) || addonResolverMap.set(key, promise);
+    }
+    catch (_b) {
+        addonResolverMap.delete(key);
+    }
+    return promise;
+}
+exports.resolveAddon = resolveAddon;
+resolveAddon.cache = addonResolverMap;
+class NotFound extends Error {
+    constructor() {
+        super(...arguments);
+        this.statusCode = 404;
+        this.message = 'Couldn\'t find that addon.';
+    }
+}
+exports.NotFound = NotFound;
+class AmbiguousError extends Error {
+    constructor(matches, type) {
+        super();
+        this.matches = matches;
+        this.type = type;
+        this.statusCode = 422;
+        this.body = { id: 'multiple_matches', message: this.message };
+        this.message = `Ambiguous identifier; multiple matching add-ons found: ${matches.map(match => match.name).join(', ')}.`;
+    }
+}
+exports.AmbiguousError = AmbiguousError;
+function singularize(type, namespace) {
+    return (matches) => {
+        if (namespace) {
+            matches = matches.filter(m => m.namespace === namespace);
+        }
+        else if (matches.length > 1) {
+            // In cases that aren't specific enough, filter by namespace
+            matches = matches.filter(m => !Reflect.has(m, 'namespace') || m.namespace === null);
+        }
+        switch (matches.length) {
+            case 0:
+                throw new NotFound();
+            case 1:
+                return matches[0];
+            default:
+                throw new AmbiguousError(matches, type !== null && type !== void 0 ? type : '');
+        }
+    };
+}

package/lib/lib/addons/util.d.ts

@@ -0,0 +1,9 @@
+import * as Heroku from '@heroku-cli/schema';
+export declare const trapConfirmationRequired: <T>(app: string, confirm: string | undefined, fn: (confirmed?: string) => Promise<T>) => Promise<T>;
+export declare const formatPrice: ({ price, hourly }: {
+    price: Heroku.AddOn['price'] | number;
+    hourly?: boolean | undefined;
+}) => any;
+export declare const formatPriceText: (price: Heroku.AddOn['price']) => string;
+export declare const grandfatheredPrice: (addon: Heroku.AddOn) => any;
+export declare const formatState: (state: string) => string;

package/lib/lib/addons/util.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatState = exports.grandfatheredPrice = exports.formatPriceText = exports.formatPrice = exports.trapConfirmationRequired = void 0;
+const confirmCommand_1 = require("../confirmCommand");
+const color_1 = require("@heroku-cli/color");
+const printf = require('printf');
+const trapConfirmationRequired = async function (app, confirm, fn) {
+    return await fn(confirm)
+        .catch((error) => {
+        if (!error.body || error.body.id !== 'confirmation_required')
+            throw error;
+        return (0, confirmCommand_1.default)(app, confirm, error.body.message)
+            .then(() => fn(app));
+    });
+};
+exports.trapConfirmationRequired = trapConfirmationRequired;
+// This function assumes that price.cents will reflect price per month.
+// If the API returns any unit other than month
+// this function will need to be updated.
+const formatPrice = function ({ price, hourly }) {
+    if (!price)
+        return;
+    if (price.contract)
+        return 'contract';
+    if (price.cents === 0)
+        return 'free';
+    // we are using a standardized 720 hours/month
+    if (hourly)
+        return `~$${((price.cents / 100) / 720).toFixed(3)}/hour`;
+    const fmt = price.cents % 100 === 0 ? '$%.0f/%s' : '$%.02f/%s';
+    return printf(fmt, price.cents / 100, price.unit);
+};
+exports.formatPrice = formatPrice;
+const formatPriceText = function (price) {
+    const priceHourly = (0, exports.formatPrice)({ price, hourly: true });
+    const priceMonthly = (0, exports.formatPrice)({ price, hourly: false });
+    if (!priceHourly)
+        return '';
+    if (priceHourly === 'free' || priceHourly === 'contract')
+        return `${color_1.default.green(priceHourly)}`;
+    return `${color_1.default.green(priceHourly)} (max ${priceMonthly})`;
+};
+exports.formatPriceText = formatPriceText;
+const grandfatheredPrice = function (addon) {
+    var _a, _b, _c;
+    const price = (_a = addon.plan) === null || _a === void 0 ? void 0 : _a.price;
+    return Object.assign({}, price, {
+        cents: (_b = addon.billed_price) === null || _b === void 0 ? void 0 : _b.cents,
+        contract: (_c = addon.billed_price) === null || _c === void 0 ? void 0 : _c.contract,
+    });
+};
+exports.grandfatheredPrice = grandfatheredPrice;
+const formatState = function (state) {
+    switch (state) {
+        case 'provisioned':
+            state = 'created';
+            break;
+        case 'provisioning':
+            state = 'creating';
+            break;
+        case 'deprovisioning':
+            state = 'destroying';
+            break;
+        case 'deprovisioned':
+            state = 'errored';
+            break;
+        default:
+            state = '';
+    }
+    return state;
+};
+exports.formatState = formatState;

package/lib/lib/api.d.ts

@@ -24,7 +24,7 @@ export declare function removeCoupling(heroku: APIClient, app: string): Promise<
 export declare function updateCoupling(heroku: APIClient, app: string, stage: string): Promise<import("http-call").HTTP<Heroku.PipelineCoupling>>;
 export declare function getReleases(heroku: APIClient, appId: string): Promise<import("http-call").HTTP<Heroku.Release[]>>;
 export declare function getPipelineConfigVars(heroku: APIClient, pipelineID: string): Promise<import("http-call").HTTP<Heroku.ConfigVars>>;
-export declare function setPipelineConfigVars(heroku: APIClient, pipelineID: string, body: Heroku.ConfigVars): Promise<import("http-call").HTTP<Heroku.ConfigVars>>;
+export declare function setPipelineConfigVars(heroku: APIClient, pipelineID: string, body: Heroku.ConfigVars | Record<string, null>): Promise<import("http-call").HTTP<Heroku.ConfigVars>>;
 export declare function createTestRun(heroku: APIClient, body: Heroku.TestRun): Promise<import("http-call").HTTP<Heroku.TestRun>>;
 export declare function getTestNodes(heroku: APIClient, testRunIdD: string): Promise<import("http-call").HTTP<Heroku.TestRun>>;
 export declare function updateTestRun(heroku: APIClient, id: string, body: Heroku.TestRun): Promise<import("http-call").HTTP<Heroku.TestRun>>;

package/lib/lib/apps/app-transfer.d.ts

@@ -0,0 +1,10 @@
+import { APIClient } from '@heroku-cli/command';
+declare type Options = {
+    heroku: APIClient;
+    appName: string;
+    recipient: string;
+    personalToPersonal: boolean;
+    bulk: boolean;
+};
+export declare const appTransfer: (options: Options) => Promise<void>;
+export {};

package/lib/lib/apps/app-transfer.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.appTransfer = void 0;
+const color_1 = require("@heroku-cli/color");
+const core_1 = require("@oclif/core");
+const getRequestOpts = (options) => {
+    const { appName, bulk, recipient, personalToPersonal } = options;
+    const isPersonalToPersonal = personalToPersonal || personalToPersonal === undefined;
+    const requestOpts = isPersonalToPersonal ?
+        {
+            body: { app: appName, recipient },
+            transferMsg: `Initiating transfer of ${color_1.color.app(appName)}`,
+            path: '/account/app-transfers',
+            method: 'POST',
+        } : {
+        body: { owner: recipient },
+        transferMsg: `Transferring ${color_1.color.app(appName)}`,
+        path: `/teams/apps/${appName}`,
+        method: 'PATCH',
+    };
+    if (!bulk)
+        requestOpts.transferMsg += ` to ${color_1.color.magenta(recipient)}`;
+    return requestOpts;
+};
+const appTransfer = async (options) => {
+    const { body, transferMsg, path, method } = getRequestOpts(options);
+    core_1.ux.action.start(transferMsg);
+    const { body: request } = await options.heroku.request(path, {
+        method,
+        body,
+    });
+    const message = request.state === 'pending' ? 'email sent' : undefined;
+    core_1.ux.action.stop(message);
+};
+exports.appTransfer = appTransfer;

package/lib/lib/apps/error_info.d.ts

@@ -0,0 +1,7 @@
+export declare type ErrorInfo = {
+    name: string;
+    title: string;
+    level: string;
+};
+declare const ERROR_INFO: ErrorInfo[];
+export default ERROR_INFO;

package/lib/lib/apps/error_info.js

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ERROR_INFO = [
+    {
+        name: 'H10',
+        title: 'App Crashed',
+        level: 'critical',
+    },
+    {
+        name: 'H11',
+        title: 'Backlog too deep',
+        level: 'critical',
+    },
+    {
+        name: 'H12',
+        title: 'Request Timeout',
+        level: 'critical',
+    },
+    {
+        name: 'H13',
+        title: 'Connection closed without response',
+        level: 'critical',
+    },
+    {
+        name: 'H14',
+        title: 'No web dynos running',
+        level: 'critical',
+    },
+    {
+        name: 'H15',
+        title: 'Idle connection',
+        level: 'warning',
+    },
+    {
+        name: 'H16',
+        title: 'Redirect to herokuapp.com',
+        level: 'warning',
+    },
+    {
+        name: 'H17',
+        title: 'Poorly formatted HTTP response',
+        level: 'warning',
+    },
+    {
+        name: 'H18',
+        title: 'Server Request Interrupted',
+        level: 'critical',
+    },
+    {
+        name: 'H19',
+        title: 'Backend connection timeout',
+        level: 'critical',
+    },
+    {
+        name: 'H20',
+        title: 'App boot timeout',
+        level: 'critical',
+    },
+    {
+        name: 'H21',
+        title: 'Backend connection refused',
+        level: 'critical',
+    },
+    {
+        name: 'H22',
+        title: 'Connection limit reached',
+        level: 'critical',
+    },
+    {
+        name: 'H23',
+        title: 'Endpoint misconfigured',
+        level: 'critical',
+    },
+    {
+        name: 'H24',
+        title: 'Forced close',
+        level: 'critical',
+    },
+    {
+        name: 'H25',
+        title: 'HTTP Restriction',
+        level: 'critical',
+    },
+    {
+        name: 'H26',
+        title: 'Request Error',
+        level: 'critical',
+    },
+    {
+        name: 'H27',
+        title: 'Client Request Interrupted',
+        level: 'info',
+    },
+    {
+        name: 'H28',
+        title: 'Client Connection Idle',
+        level: 'warning',
+    },
+    {
+        name: 'H31',
+        title: 'Misdirected Request',
+        level: 'critical',
+    },
+    {
+        name: 'H80',
+        title: 'Maintenance Mode',
+        level: 'warning',
+    },
+    {
+        name: 'H81',
+        title: 'Blank app',
+        level: 'info',
+    },
+    {
+        name: 'H82',
+        title: "You've used up your dyno hour pool",
+        level: 'info',
+    },
+    {
+        name: 'H99',
+        title: 'Platform error',
+        level: 'critical',
+    },
+    {
+        name: 'R10',
+        title: 'Boot timeout',
+        level: 'critical',
+    },
+    {
+        name: 'R12',
+        title: 'Exit timeout',
+        level: 'warning',
+    },
+    {
+        name: 'R13',
+        title: 'Attach error',
+        level: 'warning',
+    },
+    {
+        name: 'R14',
+        title: 'Memory quota exceeded',
+        level: 'critical',
+    },
+    {
+        name: 'R15',
+        title: 'Memory quota vastly exceeded',
+        level: 'critical',
+    },
+    {
+        name: 'R151',
+        title: 'Memory quota vastly exceeded',
+        level: 'warning',
+    },
+    {
+        name: 'R16',
+        title: 'Detached',
+        level: 'warning',
+    },
+    {
+        name: 'R99',
+        title: 'Platform error',
+        level: 'warning',
+    },
+    {
+        name: 'L10',
+        title: 'Drain buffer overflow',
+        level: 'warning',
+    },
+    {
+        name: 'L11',
+        title: 'Tail buffer overflow',
+        level: 'warning',
+    },
+    {
+        name: 'L12',
+        title: 'Local buffer overflow',
+        level: 'warning',
+    },
+    {
+        name: 'L13',
+        title: 'Local delivery error',
+        level: 'critical',
+    },
+];
+exports.default = ERROR_INFO;

package/lib/lib/autocomplete/completions.d.ts

@@ -9,6 +9,10 @@ export declare const DynoSizeCompletion: Completion;
 export declare const FileCompletion: Completion;
 export declare const PipelineCompletion: Completion;
 export declare const ProcessTypeCompletion: Completion;
+export declare const ProtocolCompletion: {
+    cacheDuration: number;
+    options: () => Promise<string[]>;
+};
 export declare const RegionCompletion: Completion;
 export declare const RemoteCompletion: Completion;
 export declare const RoleCompletion: Completion;

package/lib/lib/autocomplete/completions.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CompletionLookup = exports.CompletionMapping = exports.TeamCompletion = exports.StageCompletion = exports.StackCompletion = exports.SpaceCompletion = exports.ScopeCompletion = exports.RoleCompletion = exports.RemoteCompletion = exports.RegionCompletion = exports.ProcessTypeCompletion = exports.PipelineCompletion = exports.FileCompletion = exports.DynoSizeCompletion = exports.BuildpackCompletion = exports.AppDynoCompletion = exports.AppAddonCompletion = exports.AppCompletion = exports.herokuGet = exports.oneDay = void 0;
+exports.CompletionLookup = exports.CompletionMapping = exports.TeamCompletion = exports.StageCompletion = exports.StackCompletion = exports.SpaceCompletion = exports.ScopeCompletion = exports.RoleCompletion = exports.RemoteCompletion = exports.RegionCompletion = exports.ProtocolCompletion = exports.ProcessTypeCompletion = exports.PipelineCompletion = exports.FileCompletion = exports.DynoSizeCompletion = exports.BuildpackCompletion = exports.AppDynoCompletion = exports.AppAddonCompletion = exports.AppCompletion = exports.herokuGet = exports.oneDay = void 0;
 const command_1 = require("@heroku-cli/command");
 const deps_1 = require("@heroku-cli/command/lib/deps");
 const git_1 = require("@heroku-cli/command/lib/git");
@@ -138,6 +138,11 @@ exports.ProcessTypeCompletion = {
         return types;
     },
 };
+exports.ProtocolCompletion = {
+    cacheDuration: 60 * 60 * 24 * 365, options: async () => {
+        return ['tcp', 'udp', 'icmp', '0-255', 'any'];
+    },
+};
 exports.RegionCompletion = {
     cacheDuration: exports.oneDay * 7,
     options: async (ctx) => {

package/lib/lib/buildpacks/buildpacks.js

@@ -6,8 +6,7 @@ const buildpack_registry_1 = require("@heroku/buildpack-registry");
 const core_1 = require("@oclif/core");
 const lodash_1 = require("lodash");
 const true_myth_1 = require("true-myth");
-// eslint-disable-next-line node/no-missing-require
-const push = require('./push');
+const push_1 = require("../git/push");
 const validUrl = require('valid-url');
 class BuildpackCommand {
     constructor(heroku) {
@@ -103,12 +102,12 @@ class BuildpackCommand {
     displayUpdate(app, remote, buildpacks, action) {
         if (buildpacks.length === 1) {
             core_1.ux.log(`Buildpack ${action}. Next release on ${app} will use ${this.registryUrlToName(buildpacks[0].buildpack.url)}.`);
-            core_1.ux.log(`Run ${color_1.default.magenta(push(remote))} to create a new release using this buildpack.`);
+            core_1.ux.log(`Run ${color_1.default.magenta((0, push_1.default)(remote))} to create a new release using this buildpack.`);
         }
         else {
             core_1.ux.log(`Buildpack ${action}. Next release on ${app} will use:`);
             this.display(buildpacks, '  ');
-            core_1.ux.log(`Run ${color_1.default.magenta(push(remote))} to create a new release using these buildpacks.`);
+            core_1.ux.log(`Run ${color_1.default.magenta((0, push_1.default)(remote))} to create a new release using these buildpacks.`);
         }
     }
     registryUrlToName(buildpack, registryOnly = false) {

package/lib/lib/certs/certificate_details.d.ts

@@ -0,0 +1,2 @@
+import { SniEndpoint } from '../types/sni_endpoint';
+export declare const displayCertificateDetails: (sniEndpoint: SniEndpoint, message?: string) => void;

package/lib/lib/certs/certificate_details.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.displayCertificateDetails = void 0;
+const format_date_1 = require("./format_date");
+const core_1 = require("@oclif/core");
+const color_1 = require("@heroku-cli/color");
+const displayCertificateDetails = function (sniEndpoint, message = 'Certificate details:') {
+    const now = new Date();
+    const autoRenewsAt = new Date(sniEndpoint.ssl_cert.expires_at);
+    autoRenewsAt.setMonth(autoRenewsAt.getMonth() - 1);
+    if (sniEndpoint.app && sniEndpoint.ssl_cert.acm && autoRenewsAt > now) {
+        core_1.ux.log(`Renewal scheduled for ${color_1.color.green((0, format_date_1.default)(autoRenewsAt.toString()))}.\n`);
+    }
+    core_1.ux.log(message);
+    const tableObject = {
+        'Common Name(s)': sniEndpoint.ssl_cert.cert_domains,
+        'Expires At': (0, format_date_1.default)(sniEndpoint.ssl_cert.expires_at),
+        Issuer: sniEndpoint.ssl_cert.issuer,
+        'Starts At': (0, format_date_1.default)(sniEndpoint.ssl_cert.starts_at),
+        Subject: sniEndpoint.ssl_cert.subject,
+    };
+    // Only displays domains when the list of ids was replaced by the list of hostnames
+    if (sniEndpoint.domains.length > 0 && !sniEndpoint.domains.some(domain => domain.match('^[a-f0-9]{8}(-[a-f0-9]{4}){3}-[a-f0-9]{12}'))) {
+        tableObject['Domain(s)'] = sniEndpoint.domains;
+    }
+    core_1.ux.styledObject(tableObject);
+    if (sniEndpoint.ssl_cert['ca_signed?']) {
+        core_1.ux.log('SSL certificate is verified by a root authority.');
+    }
+    else if (sniEndpoint.ssl_cert.issuer === sniEndpoint.ssl_cert.subject) {
+        core_1.ux.log('SSL certificate is self signed.');
+    }
+    else {
+        core_1.ux.log('SSL certificate is not trusted.');
+    }
+};
+exports.displayCertificateDetails = displayCertificateDetails;

package/lib/lib/certs/display_table.d.ts

@@ -0,0 +1,2 @@
+import { SniEndpoint } from '../types/sni_endpoint';
+export default function (endpoints: SniEndpoint[]): void;

package/lib/lib/certs/display_table.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const format_date_1 = require("./format_date");
+function type(endpoint) {
+    if (endpoint.ssl_cert && endpoint.ssl_cert.acm) {
+        return 'ACM';
+    }
+    return 'SNI';
+}
+function default_1(endpoints) {
+    const mapped = endpoints
+        .filter(endpoint => endpoint.ssl_cert)
+        .map(endpoint => {
+        const tableContents = {
+            name: endpoint.name,
+            expires_at: endpoint.ssl_cert.expires_at,
+            ca_signed: endpoint.ssl_cert['ca_signed?'],
+            type: type(endpoint),
+            common_names: endpoint.ssl_cert.cert_domains.join(', '),
+            display_name: endpoint.display_name,
+        };
+        // If they're using ACM it's not really worth showing the number of associated domains since
+        // it'll always be 1 and is entirely outside the user's control
+        if (!endpoint.ssl_cert.acm) {
+            tableContents.associated_domains = endpoint.domains.length > 0 ? endpoint.domains.length : '0';
+        }
+        return tableContents;
+    });
+    const columns = {
+        name: { header: 'Name' },
+    };
+    if (endpoints.some(endpoint => endpoint.display_name)) {
+        columns.display_name = { header: 'Display Name' };
+    }
+    columns.common_names = { header: 'Common Name(s)' };
+    columns.expires_at = {
+        header: 'Expires',
+        get: ({ expires_at }) => expires_at === undefined ? '' : (0, format_date_1.default)(expires_at),
+    };
+    columns.ca_signed = {
+        header: 'Trusted',
+        get: ({ ca_signed }) => ca_signed ? 'True' : 'False',
+    };
+    columns.type = { header: 'Type' };
+    if (endpoints.some(endpoint => !endpoint.ssl_cert.acm)) {
+        columns.associated_domains = { header: 'Domains' };
+    }
+    core_1.ux.table(mapped, columns);
+}
+exports.default = default_1;

package/lib/lib/certs/domains.d.ts

@@ -0,0 +1,3 @@
+import { APIClient } from '@heroku-cli/command';
+import { Domain } from '../types/domain';
+export declare function waitForDomains(app: string, heroku: APIClient): Promise<Domain[]>;