heroku 10.12.0-beta.0 → 10.13.0-beta.0

package/lib/commands/container/push.js

@@ -81,7 +81,7 @@ class Push extends command_1.Command {
                 else {
                     heroku_cli_util_1.hux.styledHeader(`Pushing ${job.name} (${job.dockerfile})`);
                 }
-                await DockerHelper.pushImage(job.resource);
+                await DockerHelper.pushImage(job.resource, this.config.arch);
             }
             const plural = jobs.length !== 1;
             core_1.ux.log(`Your image${plural ? 's have' : ' has'} been successfully pushed. You can now release ${plural ? 'them' : 'it'} with the 'container:release' command.`);

package/lib/commands/status.js

@@ -7,6 +7,7 @@ const util_1 = require("@oclif/core/lib/util");
 const date_fns_1 = require("date-fns");
 const http_call_1 = require("@heroku/http-call");
 const util_2 = require("../lib/status/util");
+const errorMessage = 'Heroku platform status is unavailable at this time. Refer to https://status.salesforce.com/products/Heroku or try again later.';
 const printStatus = (status) => {
     const colorize = color_1.default[status];
     let message = (0, util_1.capitalize)(status);
@@ -15,27 +16,162 @@ const printStatus = (status) => {
     }
     return colorize(message);
 };
+const getTrustStatus = async () => {
+    const trustHost = process.env.SF_TRUST_STAGING ? 'https://status-api-stg.test.edgekey.net/v1' : 'https://api.status.salesforce.com/v1';
+    const currentDateTime = new Date(Date.now()).toISOString();
+    let instances = [];
+    let activeIncidents = [];
+    let maintenances = [];
+    let localizations = [];
+    try {
+        const [instanceResponse, activeIncidentsResponse, maintenancesResponse, localizationsResponse] = await Promise.all([
+            http_call_1.default.get(`${trustHost}/instances?products=Heroku`),
+            http_call_1.default.get(`${trustHost}/incidents/active`),
+            http_call_1.default.get(`${trustHost}/maintenances?startTime=${currentDateTime}&limit=10&offset=0&product=Heroku&locale=en`),
+            http_call_1.default.get(`${trustHost}/localizations?locale=en`),
+        ]);
+        instances = instanceResponse.body;
+        activeIncidents = activeIncidentsResponse.body;
+        maintenances = maintenancesResponse.body;
+        localizations = localizationsResponse.body;
+    }
+    catch (_a) {
+        core_1.ux.error(errorMessage, { exit: 1 });
+    }
+    return formatTrustResponse(instances, activeIncidents, maintenances, localizations);
+};
+const determineIncidentSeverity = (incidents) => {
+    const severityArray = [];
+    incidents.forEach(incident => {
+        incident.IncidentImpacts.forEach(impact => {
+            if (!impact.endTime && impact.severity) {
+                severityArray.push(impact.severity);
+            }
+        });
+    });
+    if (severityArray.includes('major'))
+        return 'red';
+    if (severityArray.includes('minor'))
+        return 'yellow';
+    return 'green';
+};
+const formatTrustResponse = (instances, activeIncidents, maintenances, localizations) => {
+    const systemStatus = [];
+    const incidents = [];
+    const scheduled = [];
+    const instanceKeyArray = new Set(instances.map(instance => instance.key));
+    const herokuActiveIncidents = activeIncidents.filter(incident => {
+        return incident.instanceKeys.some(key => instanceKeyArray.has(key));
+    });
+    const toolsIncidents = herokuActiveIncidents.filter(incident => {
+        const tools = ['TOOLS', 'Tools', 'CLI', 'Dashboard', 'Platform API'];
+        return tools.some(tool => incident.serviceKeys.includes(tool));
+    });
+    const appsIncidents = herokuActiveIncidents.filter(incident => {
+        return incident.serviceKeys.includes('HerokuApps') || incident.serviceKeys.includes('Apps');
+    });
+    const dataIncidents = herokuActiveIncidents.filter(incident => {
+        return incident.serviceKeys.includes('HerokuData') || incident.serviceKeys.includes('Data');
+    });
+    if (appsIncidents.length > 0) {
+        const severity = determineIncidentSeverity(appsIncidents);
+        systemStatus.push({ system: 'Apps', status: severity });
+        incidents.push(...appsIncidents);
+    }
+    else {
+        systemStatus.push({ system: 'Apps', status: 'green' });
+    }
+    if (dataIncidents.length > 0) {
+        const severity = determineIncidentSeverity(dataIncidents);
+        systemStatus.push({ system: 'Data', status: severity });
+        incidents.push(...dataIncidents);
+    }
+    else {
+        systemStatus.push({ system: 'Data', status: 'green' });
+    }
+    if (toolsIncidents.length > 0) {
+        const severity = determineIncidentSeverity(toolsIncidents);
+        systemStatus.push({ system: 'Tools', status: severity });
+        incidents.push(...toolsIncidents);
+    }
+    else {
+        systemStatus.push({ system: 'Tools', status: 'green' });
+    }
+    if (maintenances.length > 0)
+        scheduled.push(...maintenances);
+    if (incidents.length > 0) {
+        incidents.forEach(incident => {
+            incident.IncidentEvents.forEach(event => {
+                var _a;
+                event.localizedType = (_a = localizations.find((l) => l.modelKey === event.type)) === null || _a === void 0 ? void 0 : _a.text;
+            });
+        });
+    }
+    return {
+        status: systemStatus,
+        incidents,
+        scheduled,
+    };
+};
 class Status extends core_1.Command {
     async run() {
+        var _a;
         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);
+        const herokuApiPath = '/api/v4/current-status';
+        let herokuStatus;
+        let formattedTrustStatus;
+        if (process.env.TRUST_ONLY) {
+            formattedTrustStatus = await getTrustStatus();
+        }
+        else {
+            try {
+                // Try calling the Heroku status API first
+                const herokuHost = process.env.HEROKU_STATUS_HOST || 'https://status.heroku.com';
+                const herokuStatusResponse = await http_call_1.default.get(herokuHost + herokuApiPath);
+                herokuStatus = herokuStatusResponse.body;
+            }
+            catch (_b) {
+                // If the Heroku status API call fails, call the SF Trust API
+                formattedTrustStatus = await getTrustStatus();
+            }
+        }
+        if (!herokuStatus && !formattedTrustStatus)
+            core_1.ux.error(errorMessage, { exit: 1 });
         if (flags.json) {
-            heroku_cli_util_1.hux.styledJSON(body);
+            heroku_cli_util_1.hux.styledJSON(herokuStatus !== null && herokuStatus !== void 0 ? herokuStatus : formattedTrustStatus);
             return;
         }
-        for (const item of body.status) {
-            const message = printStatus(item.status);
-            this.log(`${(item.system + ':').padEnd(11)}${message}`);
+        const systemStatus = herokuStatus ? herokuStatus.status : formattedTrustStatus === null || formattedTrustStatus === void 0 ? void 0 : formattedTrustStatus.status;
+        if (systemStatus) {
+            for (const item of systemStatus) {
+                const message = printStatus(item.status);
+                this.log(`${(item.system + ':').padEnd(11)}${message}`);
+            }
+        }
+        else {
+            core_1.ux.error(errorMessage, { exit: 1 });
+        }
+        if (herokuStatus) {
+            for (const incident of herokuStatus.incidents) {
+                core_1.ux.log();
+                heroku_cli_util_1.hux.styledHeader(`${incident.title} ${color_1.default.yellow(incident.created_at)} ${color_1.default.cyan(incident.full_url)}`);
+                const padding = (0, util_2.getMaxUpdateTypeLength)(incident.updates.map(update => update.update_type));
+                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()} (${(0, date_fns_1.formatDistanceToNow)(new Date(u.updated_at))} ago)`);
+                    core_1.ux.log(`${u.contents}\n`);
+                }
+            }
         }
-        for (const incident of body.incidents) {
-            core_1.ux.log();
-            heroku_cli_util_1.hux.styledHeader(`${incident.title} ${color_1.default.yellow(incident.created_at)} ${color_1.default.cyan(incident.full_url)}`);
-            const padding = (0, util_2.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()} (${(0, date_fns_1.formatDistanceToNow)(new Date(u.updated_at))} ago)`);
-                core_1.ux.log(`${u.contents}\n`);
+        else if (formattedTrustStatus) {
+            for (const incident of formattedTrustStatus.incidents) {
+                core_1.ux.log();
+                heroku_cli_util_1.hux.styledHeader(`${incident.id} ${color_1.default.yellow(incident.createdAt)} ${color_1.default.cyan(`https://status.salesforce.com/incidents/${incident.id}`)}`);
+                const padding = (0, util_2.getMaxUpdateTypeLength)(incident.IncidentEvents.map(event => { var _a; return (_a = event.localizedType) !== null && _a !== void 0 ? _a : event.type; }));
+                for (const event of incident.IncidentEvents) {
+                    const eventType = (_a = event.localizedType) !== null && _a !== void 0 ? _a : event.type;
+                    core_1.ux.log(`${color_1.default.yellow(eventType.padEnd(padding))} ${new Date(event.createdAt).toISOString()} (${(0, date_fns_1.formatDistanceToNow)(new Date(event.createdAt))} ago)`);
+                    core_1.ux.log(`${event.message}\n`);
+                }
             }
         }
     }

package/lib/lib/container/docker_helper.d.ts

@@ -27,6 +27,6 @@ declare type BuildImageParams = {
     arch?: string;
 };
 export declare const buildImage: ({ dockerfile, resource, buildArgs, path, arch }: BuildImageParams) => Promise<string>;
-export declare const pushImage: (resource: string) => Promise<string>;
+export declare const pushImage: (resource: string, arch: string) => Promise<string>;
 export declare const runImage: (resource: string, command: string, port: number) => Promise<string>;
 export {};

package/lib/lib/container/docker_helper.js

@@ -145,8 +145,14 @@ const buildImage = async function ({ dockerfile, resource, buildArgs, path, arch
     const args = ['build', '-f', dockerfile, '-t', resource];
     // Older Docker versions don't allow for this flag, but we are
     // adding it here when necessary to allow for pushing a docker build from m1/m2 Macs.
-    if (arch === 'arm64')
+    if (arch === 'arm64' || arch === 'aarch64')
         args.push('--platform', 'linux/amd64');
+    // newer docker versions support attestations and software bill of materials, so we want to disable them to save time/space
+    // Heroku's container registry doesn't support pushing them right now
+    if (await (0, exports.version)() >= [24, 0, 0]) {
+        args.push('--provenance', 'false');
+        args.push('--sbom', 'false');
+    }
     for (const element of buildArgs) {
         if (element.length > 0) {
             args.push('--build-arg', element);
@@ -156,8 +162,13 @@ const buildImage = async function ({ dockerfile, resource, buildArgs, path, arch
     return (0, exports.cmd)('docker', args);
 };
 exports.buildImage = buildImage;
-const pushImage = async function (resource) {
+const pushImage = async function (resource, arch) {
     const args = ['push', resource];
+    // Older Docker versions don't allow for this flag, but we are
+    // adding it here when necessary to allow for pushing a docker build from m1/m2 Macs.
+    // Heroku's container registry doesn't support pushing multi-arch images so we need to push the expected arch
+    if (arch === 'arm64' || arch === 'aarch64')
+        args.push('--platform', 'linux/amd64');
     return (0, exports.cmd)('docker', args);
 };
 exports.pushImage = pushImage;

package/lib/lib/status/util.d.ts

@@ -1 +1 @@
-export declare function maxBy<T>(arr: T[], fn: (i: T) => number): T | undefined;
+export declare function getMaxUpdateTypeLength(updateTypes: string[]): number;

package/lib/lib/status/util.js

@@ -1,14 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.maxBy = void 0;
-function maxBy(arr, fn) {
-    let max;
-    for (const cur of arr) {
-        const i = fn(cur);
-        if (!max || i > max.i) {
-            max = { i, element: cur };
+exports.getMaxUpdateTypeLength = void 0;
+function getMaxUpdateTypeLength(updateTypes) {
+    let max = 0;
+    for (const update of updateTypes) {
+        if (!max || update.length > max) {
+            max = update.length;
         }
     }
-    return max && max.element;
+    return max;
 }
-exports.maxBy = maxBy;
+exports.getMaxUpdateTypeLength = getMaxUpdateTypeLength;