heroku 9.0.0-alpha.1 → 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/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/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/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[]>;

package/lib/lib/certs/domains.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitForDomains = void 0;
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+function customDomainCreationComplete(app, heroku) {
+    return tslib_1.__asyncGenerator(this, arguments, function* customDomainCreationComplete_1() {
+        let retries = 30;
+        while (retries--) {
+            const { body: apiDomains } = yield tslib_1.__await(heroku.get(`/apps/${app}/domains`));
+            const someNull = apiDomains.some((domain) => domain.kind === 'custom' && !domain.cname);
+            if (!someNull) {
+                yield yield tslib_1.__await(apiDomains);
+                break;
+            }
+            yield tslib_1.__await(new Promise(resolve => {
+                setTimeout(resolve, 1000);
+            }));
+            yield yield tslib_1.__await(null);
+        }
+    });
+}
+async function waitForDomains(app, heroku) {
+    var e_1, _a;
+    core_1.ux.action.start('Waiting for stable domains to be created');
+    try {
+        for (var _b = tslib_1.__asyncValues(customDomainCreationComplete(app, heroku)), _c; _c = await _b.next(), !_c.done;) {
+            const apiDomains = _c.value;
+            if (apiDomains) {
+                core_1.ux.action.stop();
+                return apiDomains;
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) await _a.call(_b);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    core_1.ux.action.stop('!');
+    throw new Error('Timed out while waiting for stable domains to be created');
+}
+exports.waitForDomains = waitForDomains;

package/lib/lib/certs/flags.d.ts

@@ -0,0 +1,7 @@
+import { SniEndpoint } from '../types/sni_endpoint';
+import { APIClient } from '@heroku-cli/command';
+export default function (flags: {
+    endpoint: string | undefined;
+    name: string | undefined;
+    app: string;
+}, heroku: APIClient): Promise<SniEndpoint>;

package/lib/lib/certs/flags.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+async function default_1(flags, heroku) {
+    if (flags.endpoint && flags.name) {
+        throw new Error('Specified both --name and --endpoint, please use just one');
+    }
+    let { body: sniEndpoints } = await heroku.get(`/apps/${flags.app}/sni-endpoints`);
+    if (sniEndpoints.length === 0) {
+        throw new Error(`${flags.app} has no SSL certificates`);
+    }
+    if (flags.endpoint) {
+        const promises = [];
+        sniEndpoints.forEach(endpoint => {
+            endpoint.domains.forEach(domain => promises.push(heroku.get(`/apps/${flags.app}/domains/${domain}`)));
+        });
+        const domains = (await Promise.all(promises)).map(({ body: domain }) => domain);
+        sniEndpoints = sniEndpoints.filter(endpoint => {
+            // This was modified from `endpoint.cname === flags.endpoint` because `cname` doesn't exist anymore in the SniEndpoint serialization.
+            // We're making the assumption that the `--endpoint` flag was being used to search by hostname (internationalized domain name).
+            return domains.some(domain => { var _a; return domain.hostname === flags.endpoint && ((_a = domain.sni_endpoint) === null || _a === void 0 ? void 0 : _a.name) === endpoint.name; });
+        });
+        if (sniEndpoints.length > 1) {
+            throw new Error('Must pass --name when more than one endpoint matches --endpoint');
+        }
+    }
+    if (flags.name) {
+        sniEndpoints = sniEndpoints.filter(endpoint => {
+            return endpoint.name === flags.name;
+        });
+        if (sniEndpoints.length > 1) {
+            throw new Error(`More than one endpoint matches ${flags.name}, please file a support ticket`);
+        }
+    }
+    if (sniEndpoints.length > 1) {
+        throw new Error('Must pass --name when more than one endpoint');
+    }
+    if (sniEndpoints.length === 0) {
+        throw new Error('Record not found.');
+    }
+    return sniEndpoints[0];
+}
+exports.default = default_1;

package/lib/lib/certs/format_date.d.ts

@@ -0,0 +1 @@
+export default function (date: string): string;

package/lib/lib/certs/format_date.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const date_fns_1 = require("date-fns");
+function getUTCDate(dateString = Date.now()) {
+    const date = new Date(dateString);
+    return new Date(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate(), date.getUTCHours(), date.getUTCMinutes(), date.getUTCSeconds());
+}
+function default_1(date) {
+    return `${(0, date_fns_1.format)(getUTCDate(date), 'yyyy-MM-dd HH:mm')} UTC`;
+}
+exports.default = default_1;

package/lib/lib/certs/get_cert_and_key.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+import type { PathLike } from 'node:fs';
+export declare function getCertAndKey(args: {
+    CRT: PathLike;
+    KEY: PathLike;
+}): Promise<{
+    crt: string;
+    key: string;
+}>;

package/lib/lib/certs/get_cert_and_key.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCertAndKey = void 0;
+const fs = require("node:fs/promises");
+async function getCertAndKey(args) {
+    return {
+        crt: await fs.readFile(args.CRT, { encoding: 'utf-8' }),
+        key: await fs.readFile(args.KEY, { encoding: 'utf-8' }),
+    };
+}
+exports.getCertAndKey = getCertAndKey;

package/lib/lib/ci/interfaces/kolkrabbi.d.ts

@@ -186,7 +186,7 @@ export interface HerokuPlatformApiOrganization {
     [k: string]: any;
 }
 /**
- * Pipeline repositories link a pipeline to a Github repository.
+ * Pipeline repositories link a pipeline to a GitHub repository.
  */
 export interface KolkrabbiApiPipelineRepositories {
     /**

package/lib/lib/ci/source.js

@@ -4,11 +4,11 @@ exports.createSourceBlob = void 0;
 const fs = require("async-file");
 const core_1 = require("@oclif/core");
 const git = require("./git");
-const got = require('got');
+const got_1 = require("got");
 async function uploadArchive(url, filePath) {
-    const request = got.stream.put(url, {
+    const request = got_1.default.stream.put(url, {
         headers: {
-            'content-length': (await fs.stat(filePath)).size,
+            'content-length': (await fs.stat(filePath)).size.toString(),
         },
     });
     fs.createReadStream(filePath).pipe(request);

package/lib/lib/ci/test-run.js

@@ -4,9 +4,9 @@ exports.displayTestRunInfo = exports.displayAndExit = exports.waitForStates = ex
 const color_1 = require("@heroku-cli/color");
 const core_1 = require("@oclif/core");
 const https_1 = require("https");
+const node_crypto_1 = require("node:crypto");
 const phoenix_1 = require("phoenix");
 const util_1 = require("util");
-const uuid_1 = require("uuid");
 const WebSocket = require("ws");
 const debug = require('debug')('ci');
 const ansiEscapes = require('ansi-escapes');
@@ -132,7 +132,7 @@ async function renderList(command, testRuns, pipeline, watchOption, jsonOption)
         transport: WebSocket,
         params: {
             token: command.heroku.auth,
-            tab_id: `heroku-cli-${(0, uuid_1.v4)()}`,
+            tab_id: `heroku-cli-${(0, node_crypto_1.randomUUID)()}`,
         },
         logger: (kind, msg, data) => debug(`${kind}: ${msg}\n${(0, util_1.inspect)(data)}`),
     });

package/lib/lib/config/quote.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parse = exports.quote = void 0;
 const shell = require('shell-quote');
-// slightly modifed form of shell-quote to default to using single-quotes over backslashes
+// slightly modified form of shell-quote to default to using single-quotes over backslashes
 function quote(s) {
     // eslint-disable-next-line no-useless-escape
     if (/["\s#!$&'()*,:;<=>?@\[\\\]^`{|}]/.test(s)) {

package/lib/lib/confirmCommand.d.ts

@@ -0,0 +1 @@
+export default function confirmCommand(app: string, confirm?: string, message?: string): Promise<void>;

package/lib/lib/{apps/confirm-app.js → confirmCommand.js}

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const color_1 = require("@heroku-cli/color");
 const core_1 = require("@oclif/core");
-async function confirmApp(app, confirm, message) {
+async function confirmCommand(app, confirm, message) {
     if (confirm) {
         if (confirm === app)
             return;
@@ -20,4 +20,4 @@ This command will affect the app ${color_1.default.bold.red(app)}`;
     }
     throw new Error(`Confirmation did not match ${color_1.default.bold.red(app)}. Aborted.`);
 }
-exports.default = confirmApp;
+exports.default = confirmCommand;