heroku 9.0.0-dev.0 → 9.1.0-beta.0

package/lib/lib/releases/releases.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findByPreviousOrId = exports.findByLatestOrId = exports.getRelease = exports.findRelease = void 0;
+const findRelease = async function (heroku, app, search) {
+    const { body: releases } = await heroku.request(`/apps/${app}/releases`, {
+        partial: true,
+        headers: { Range: 'version ..; max=10, order=desc' },
+    });
+    return search(releases);
+};
+exports.findRelease = findRelease;
+const getRelease = async function (heroku, app, release) {
+    let id = release.toLowerCase();
+    id = id.startsWith('v') ? id.slice(1) : id;
+    const { body: releaseResponse } = await heroku.get(`/apps/${app}/releases/${id}`);
+    return releaseResponse;
+};
+exports.getRelease = getRelease;
+const findByLatestOrId = async function (heroku, app, release = 'current') {
+    if (release === 'current') {
+        return (0, exports.findRelease)(heroku, app, releases => releases[0]);
+    }
+    return (0, exports.getRelease)(heroku, app, release);
+};
+exports.findByLatestOrId = findByLatestOrId;
+const findByPreviousOrId = async function (heroku, app, release = 'previous') {
+    if (release === 'previous') {
+        return (0, exports.findRelease)(heroku, app, releases => releases.filter(r => r.status === 'succeeded')[1]);
+    }
+    return (0, exports.getRelease)(heroku, app, release);
+};
+exports.findByPreviousOrId = findByPreviousOrId;

package/lib/lib/releases/status_helper.d.ts

@@ -0,0 +1,5 @@
+export declare const description: (release: {
+    [k: string]: any;
+    status?: string | undefined;
+}) => "" | "release command executing" | "release command failed";
+export declare const color: (s?: string) => "red" | "yellow" | "white";

package/lib/lib/releases/status_helper.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.color = exports.description = void 0;
+const description = function (release) {
+    switch (release.status) {
+        case 'pending':
+            return 'release command executing';
+        case 'failed':
+            return 'release command failed';
+        default:
+            return '';
+    }
+};
+exports.description = description;
+const color = function (s) {
+    switch (s) {
+        case 'pending':
+            return 'yellow';
+        case 'failed':
+            return 'red';
+        default:
+            return 'white';
+    }
+};
+exports.color = color;

package/lib/lib/run/dyno.js

@@ -238,7 +238,7 @@ class Dyno extends stream_1.Duplex {
             // @ts-ignore
             sshProc.stderr.on('data', data => {
                 lastErr = data;
-                // supress host key and permission denied messages
+                // suppress host key and permission denied messages
                 if (this._isDebug() || (data.includes("Warning: Permanently added '[127.0.0.1]") && data.includes('Permission denied (publickey).'))) {
                     process.stderr.write(data);
                 }
@@ -336,7 +336,7 @@ class Dyno extends stream_1.Duplex {
             stdin.pipe(c);
             let sigints = [];
             stdin.on('data', function (c) {
-                if (c === '\u0003') {
+                if (c.toString() === '\u0003') {
                     sigints.push(Date.now());
                 }
                 sigints = sigints.filter(d => d > Date.now() - 1000);

package/lib/lib/run/log-displayer.d.ts

@@ -1,7 +1,7 @@
 import { APIClient } from '@heroku-cli/command';
 interface LogDisplayerOptions {
     app: string;
-    dyno: string;
+    dyno?: string;
     lines?: number;
     tail: boolean;
     source?: string;

package/lib/lib/spaces/format.d.ts

@@ -0,0 +1,4 @@
+export declare function displayCIDR(cidr: string[] | undefined): string;
+export declare function hostStatus(s: string): string;
+export declare function peeringStatus(s: string): string;
+export declare function displayVPNStatus(s: string | undefined): string | undefined;

package/lib/lib/spaces/format.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.displayVPNStatus = exports.peeringStatus = exports.hostStatus = exports.displayCIDR = void 0;
+const color_1 = require("@heroku-cli/color");
+function displayCIDR(cidr) {
+    var _a;
+    return (_a = cidr === null || cidr === void 0 ? void 0 : cidr.join(', ')) !== null && _a !== void 0 ? _a : '';
+}
+exports.displayCIDR = displayCIDR;
+function hostStatus(s) {
+    switch (s) {
+        case 'available':
+            return `${color_1.default.green(s)}`;
+        case 'under-assessment':
+            return `${color_1.default.yellow(s)}`;
+        case 'permanent-failure':
+        case 'released-permanent-failure':
+            return `${color_1.default.red(s)}`;
+        case 'released':
+            return `${color_1.default.gray(s)}`;
+        default:
+            return s;
+    }
+}
+exports.hostStatus = hostStatus;
+function peeringStatus(s) {
+    switch (s) {
+        case 'active':
+            return `${color_1.default.green(s)}`;
+        case 'pending-acceptance':
+        case 'provisioning':
+            return `${color_1.default.yellow(s)}`;
+        case 'expired':
+        case 'failed':
+        case 'deleted':
+        case 'rejected':
+            return `${color_1.default.red(s)}`;
+        default:
+            return s;
+    }
+}
+exports.peeringStatus = peeringStatus;
+function displayVPNStatus(s) {
+    switch (s) {
+        case 'UP':
+        case 'available':
+            return `${color_1.default.green(s)}`;
+        case 'pending':
+        case 'provisioning':
+        case 'deprovisioning':
+            return `${color_1.default.yellow(s)}`;
+        case 'DOWN':
+        case 'deleting':
+        case 'deleted':
+            return `${color_1.default.red(s)}`;
+        default:
+            return s;
+    }
+}
+exports.displayVPNStatus = displayVPNStatus;

package/lib/lib/spaces/hosts.d.ts

@@ -0,0 +1,9 @@
+export declare type Host = {
+    host_id: string;
+    state: string;
+    available_capacity_percentage: number;
+    allocated_at: string;
+    released_at: string;
+};
+export declare function displayHosts(space: string, hosts: Host[]): void;
+export declare function displayHostsAsJSON(hosts: Host[]): void;

package/lib/lib/spaces/hosts.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.displayHostsAsJSON = exports.displayHosts = void 0;
+const core_1 = require("@oclif/core");
+const format_1 = require("./format");
+function displayHosts(space, hosts) {
+    core_1.ux.styledHeader(`${space} Hosts`);
+    core_1.ux.table(hosts, {
+        host_id: {
+            header: 'Host ID',
+        },
+        state: {
+            header: 'State',
+            get: host => (0, format_1.hostStatus)(host.state),
+        },
+        available_capacity_percentage: {
+            header: 'Available Capacity',
+            get: host => `${host.available_capacity_percentage}%`,
+        },
+        allocated_at: {
+            header: 'Allocated At',
+            get: host => host.allocated_at || '',
+        },
+        released_at: {
+            header: 'Released At',
+            get: host => host.released_at || '',
+        },
+    });
+}
+exports.displayHosts = displayHosts;
+function displayHostsAsJSON(hosts) {
+    core_1.ux.log(JSON.stringify(hosts, null, 2));
+}
+exports.displayHostsAsJSON = displayHostsAsJSON;

package/lib/lib/spaces/outbound-rules.d.ts

@@ -0,0 +1,4 @@
+import * as Heroku from '@heroku-cli/schema';
+export declare function parsePorts(protocol: string, port?: string): number[];
+export declare function displayRules(space: string, ruleset: Heroku.OutboundRuleset): void;
+export declare function displayRulesAsJSON(ruleset: Heroku.OutboundRuleset): void;

package/lib/lib/spaces/outbound-rules.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.displayRulesAsJSON = exports.displayRules = exports.parsePorts = void 0;
+const core_1 = require("@oclif/core");
+function parsePorts(protocol, port = '') {
+    if (port === '-1' || port === 'any') {
+        if (protocol === 'icmp') {
+            return [0, 255];
+        }
+        return [0, 65535];
+    }
+    let actual = [];
+    const ports = port.split('-').map(port => Number.parseInt(port));
+    if (ports.length === 2) {
+        actual = ports;
+    }
+    else if (ports.length === 1) {
+        actual = ports.concat(ports);
+    }
+    else {
+        throw new Error('Specified --port range seems incorrect.');
+    }
+    if (actual.length !== 2) {
+        throw new Error('Specified --port range seems incorrect.');
+    }
+    return actual;
+}
+exports.parsePorts = parsePorts;
+function displayRules(space, ruleset) {
+    const rules = ruleset.rules || [];
+    if (rules.length > 0) {
+        core_1.ux.styledHeader('Outbound Rules');
+        display(ruleset.rules);
+    }
+    else {
+        core_1.ux.styledHeader(`${space} has no Outbound Rules. Your Dynos cannot communicate with hosts outside of ${space}.`);
+    }
+}
+exports.displayRules = displayRules;
+function displayRulesAsJSON(ruleset) {
+    core_1.ux.log(JSON.stringify(ruleset, null, 2));
+}
+exports.displayRulesAsJSON = displayRulesAsJSON;
+function display(rules) {
+    core_1.ux.table(lined(rules), {
+        line: {
+            header: 'Rule Number',
+        },
+        target: {
+            header: 'Destination',
+        },
+        from_port: {
+            header: 'From Port',
+            get: rule => rule.from_port.toString(),
+        },
+        to_port: {
+            header: 'To Port',
+            get: rule => rule.to_port.toString(),
+        },
+        protocol: {
+            header: 'Protocol',
+        },
+    });
+}
+function lined(rules) {
+    const lined = [];
+    rules = rules || [];
+    for (let i = 0, len = rules.length; i < len; i++) {
+        lined.push({
+            line: i + 1,
+            target: rules[i].target,
+            from_port: rules[i].from_port,
+            to_port: rules[i].to_port,
+            protocol: rules[i].protocol,
+        });
+    }
+    return lined;
+}

package/lib/lib/spaces/parsers.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Splits strings separated by commas into an array
+ * If the string is empty or null, an empty array is returned.
+ * @param csvString String with comma-separated values
+ * @returns An array of strings or an empty array
+ *
+ */
+export declare function splitCsv(csvString?: string): string[];

package/lib/lib/spaces/parsers.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitCsv = void 0;
+/**
+ * Splits strings separated by commas into an array
+ * If the string is empty or null, an empty array is returned.
+ * @param csvString String with comma-separated values
+ * @returns An array of strings or an empty array
+ *
+ */
+function splitCsv(csvString) {
+    return (csvString || '')
+        .split(',')
+        .map(s => s.trim())
+        .filter(s => s.length > 0);
+}
+exports.splitCsv = splitCsv;

package/lib/lib/spaces/peering.d.ts

@@ -0,0 +1,4 @@
+import { Peering, PeeringInfo } from '@heroku-cli/schema';
+export declare function displayPeeringInfo(space: string, info: PeeringInfo): void;
+export declare function displayPeeringsAsJSON(peerings: Peering[]): void;
+export declare function displayPeerings(space: string, peerings: Peering[]): void;

package/lib/lib/spaces/peering.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.displayPeerings = exports.displayPeeringsAsJSON = exports.displayPeeringInfo = void 0;
+const core_1 = require("@oclif/core");
+const format_1 = require("./format");
+function displayPeeringInfo(space, info) {
+    core_1.ux.styledHeader(`${space} Peering Info`);
+    core_1.ux.styledObject({
+        'AWS Account ID': info.aws_account_id,
+        'AWS Region': info.aws_region,
+        'AWS VPC ID': info.vpc_id,
+        'AWS VPC CIDR': info.vpc_cidr,
+        'Space CIDRs': (0, format_1.displayCIDR)(info.space_cidr_blocks),
+        'Unavailable CIDRs': (0, format_1.displayCIDR)(info.unavailable_cidr_blocks),
+    }, ['AWS Account ID', 'AWS Region', 'AWS VPC ID', 'AWS VPC CIDR', 'Space CIDRs', 'Unavailable CIDRs']);
+}
+exports.displayPeeringInfo = displayPeeringInfo;
+function displayPeeringsAsJSON(peerings) {
+    core_1.ux.log(JSON.stringify(peerings, null, 2));
+}
+exports.displayPeeringsAsJSON = displayPeeringsAsJSON;
+function displayPeerings(space, peerings) {
+    core_1.ux.styledHeader(`${space} Peerings`);
+    core_1.ux.table(peerings, {
+        pcx_id: {
+            header: 'PCX ID',
+        },
+        type: {
+            header: 'Type',
+        },
+        cidr_blocks: {
+            header: 'CIDR Blocks',
+            get: (row) => (0, format_1.displayCIDR)(row.cidr_blocks),
+        },
+        status: {
+            header: 'Status',
+            get: (row) => (0, format_1.peeringStatus)(row.status),
+        },
+        aws_vpc_id: {
+            header: 'VPC ID',
+        },
+        aws_region: {
+            header: 'AWS Region',
+        },
+        aws_account_id: {
+            header: 'AWS Account ID',
+        },
+        expires: {
+            header: 'Expires',
+        },
+    });
+}
+exports.displayPeerings = displayPeerings;

package/lib/lib/spaces/spaces.d.ts

@@ -0,0 +1,4 @@
+import * as Heroku from '@heroku-cli/schema';
+export declare function displayShieldState(space: Heroku.Space): "on" | "off";
+export declare function displayNat(nat?: Required<Heroku.SpaceNetworkAddressTranslation>): string | undefined;
+export declare function renderInfo(space: Heroku.Space, json: boolean): void;

package/lib/lib/spaces/spaces.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderInfo = exports.displayNat = exports.displayShieldState = void 0;
+const core_1 = require("@oclif/core");
+function displayShieldState(space) {
+    return space.shield ? 'on' : 'off';
+}
+exports.displayShieldState = displayShieldState;
+function displayNat(nat) {
+    if (!nat)
+        return;
+    if (nat.state !== 'enabled')
+        return nat.state;
+    return nat.sources.join(', ');
+}
+exports.displayNat = displayNat;
+function renderInfo(space, json) {
+    var _a, _b;
+    if (json) {
+        core_1.ux.log(JSON.stringify(space, null, 2));
+    }
+    else {
+        core_1.ux.styledHeader(space.name || '');
+        core_1.ux.styledObject({
+            ID: space.id,
+            Team: (_a = space.team) === null || _a === void 0 ? void 0 : _a.name,
+            Region: (_b = space.region) === null || _b === void 0 ? void 0 : _b.description,
+            CIDR: space.cidr,
+            'Data CIDR': space.data_cidr,
+            State: space.state,
+            Shield: displayShieldState(space),
+            'Outbound IPs': displayNat(space.outbound_ips),
+            'Created at': space.created_at,
+        }, ['ID', 'Team', 'Region', 'CIDR', 'Data CIDR', 'State', 'Shield', 'Outbound IPs', 'Created at']);
+    }
+}
+exports.renderInfo = renderInfo;

package/lib/lib/spaces/vpn-connections.d.ts

@@ -0,0 +1,2 @@
+import { PrivateSpacesVpn } from '@heroku-cli/schema';
+export declare function displayVPNConfigInfo(space: string, name: string, config: PrivateSpacesVpn): void;

package/lib/lib/spaces/vpn-connections.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.displayVPNConfigInfo = void 0;
+const core_1 = require("@oclif/core");
+function displayVPNConfigInfo(space, name, config) {
+    core_1.ux.styledHeader(`${name} VPN Tunnels`);
+    const configTunnels = config.tunnels || [];
+    configTunnels.forEach((val, i) => {
+        val.tunnel_id = 'Tunnel ' + (i + 1);
+        val.routable_cidr = config.space_cidr_block;
+        val.ike_version = config.ike_version;
+    });
+    core_1.ux.table(configTunnels, {
+        tunnel_id: { header: 'VPN Tunnel' },
+        customer_ip: { header: 'Customer Gateway' },
+        ip: { header: 'VPN Gateway' },
+        pre_shared_key: { header: 'Pre-shared Key' },
+        routable_cidr: { header: 'Routable Subnets' },
+        ike_version: { header: 'IKE Version' },
+    });
+}
+exports.displayVPNConfigInfo = displayVPNConfigInfo;

package/lib/lib/teamUtils.d.ts

@@ -0,0 +1,3 @@
+export declare const isTeamApp: (owner: string | undefined) => boolean;
+export declare const getOwner: (owner: string | undefined) => string | undefined;
+export declare const isValidEmail: (email: string) => boolean;

package/lib/lib/teamUtils.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidEmail = exports.getOwner = exports.isTeamApp = void 0;
+const isTeamApp = function (owner) {
+    return owner ? (/@herokumanager\.com$/.test(owner)) : false;
+};
+exports.isTeamApp = isTeamApp;
+const getOwner = function (owner) {
+    if (owner && (0, exports.isTeamApp)(owner)) {
+        return owner.split('@herokumanager.com')[0];
+    }
+    return owner;
+};
+exports.getOwner = getOwner;
+const isValidEmail = function (email) {
+    return /^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/.test(email);
+};
+exports.isValidEmail = isValidEmail;

package/lib/lib/time.d.ts

@@ -0,0 +1,2 @@
+export declare function ago(since: Date): string;
+export declare function remaining(from: number, to: number): string;

package/lib/lib/time.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.remaining = exports.ago = void 0;
+const strftime = require("strftime");
+function ago(since) {
+    const elapsed = Math.floor((Date.now() - since.getTime()) / 1000);
+    const message = strftime('%Y/%m/%d %H:%M:%S %z', since);
+    if (elapsed < 60)
+        return `${message} (~ ${Math.floor(elapsed)}s ago)`;
+    if (elapsed < 60 * 60)
+        return `${message} (~ ${Math.floor(elapsed / 60)}m ago)`;
+    if (elapsed < 60 * 60 * 25)
+        return `${message} (~ ${Math.floor(elapsed / 60 / 60)}h ago)`;
+    return message;
+}
+exports.ago = ago;
+function remaining(from, to) {
+    const secs = Math.floor((to / 1000) - (from / 1000));
+    const mins = Math.floor(secs / 60);
+    const hours = Math.floor(mins / 60);
+    if (hours > 0)
+        return `${hours}h ${mins % 60}m`;
+    if (mins > 0)
+        return `${mins}m ${secs % 60}s`;
+    if (secs > 0)
+        return `${secs}s`;
+    return '';
+}
+exports.remaining = remaining;

package/lib/lib/types/app_errors.d.ts

@@ -0,0 +1,6 @@
+export declare type AppErrors = {
+    start_time: string;
+    end_time: string;
+    step: string;
+    data: Record<string, number[]>;
+};

package/lib/lib/types/app_errors.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/lib/types/domain.d.ts

@@ -0,0 +1,61 @@
+export interface Domain {
+    /**
+     * status of this record's ACM
+     */
+    acm_status: null | string;
+    /**
+     * reason for the status of this record's ACM
+     */
+    acm_status_reason: null | string;
+    /**
+     * app that owns the domain
+     */
+    app: {
+        /**
+         * unique identifier of app
+         */
+        id: string;
+        /**
+         * unique name of app
+         */
+        name: string;
+    };
+    /**
+     * canonical name record, the address to point a domain at
+     */
+    cname: null | string;
+    /**
+     * when domain was created
+     */
+    created_at: string;
+    /**
+     * full hostname
+     */
+    hostname: string;
+    /**
+     * unique identifier of this domain
+     */
+    id: string;
+    /**
+     * type of domain name
+     */
+    kind: 'heroku' | 'custom';
+    sni_endpoint: null | {
+        /**
+         * unique identifier of this SNI endpoint
+         */
+        id: string;
+        /**
+         * unique name for SNI endpoint
+         */
+        name: string;
+    };
+    /**
+     * status of this record's cname
+     */
+    status: string;
+    /**
+     * when domain was updated
+     */
+    updated_at: string;
+}

package/lib/lib/types/domain.js

@@ -0,0 +1,5 @@
+"use strict";
+// This should've been imported from @heroku-cli/schema (Domain), but the schema definition it's
+// outdated for this interface and doesn't reflects the correct serialization from Platform API.
+// This interface export can be removed when the schema is updated and use imports from schema where required.
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/lib/types/notifications.d.ts

@@ -0,0 +1,20 @@
+declare type FollowUp = {
+    created_at: string;
+    body: string;
+};
+export declare type Notification = {
+    id: string;
+    created_at: string;
+    title: string;
+    read: boolean;
+    body: string;
+    target: {
+        type: string;
+        id: string;
+    };
+    followup: FollowUp[];
+    resource_name: string;
+    type: string;
+};
+export declare type Notifications = Notification[];
+export {};

package/lib/lib/types/notifications.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/lib/utils/keyValueParser.d.ts

@@ -0,0 +1,4 @@
+export default function parseKeyValue(input: string): {
+    key: string;
+    value: string;
+};

package/lib/lib/utils/keyValueParser.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function parseKeyValue(input) {
+    let [key, value] = input.split(/=(.+)/);
+    key = key.trim();
+    value = value ? value.trim() : '';
+    return { key, value };
+}
+exports.default = parseKeyValue;

package/lib/lib/utils/multisort.d.ts

@@ -0,0 +1,32 @@
+export declare type Comparator = Parameters<typeof Array.prototype.sort>[0];
+/**
+ * The multiSortCompareFn function is used to
+ * build a single comparator function for use
+ * in Array.sort when multiple sort criteria
+ * is needed on an object type. The indices of
+ * specified array of SortCriteria indicate the
+ * precedence of each comparator.
+ *
+ * @example
+ * ```ts
+ * type User = {
+ *  firstName: string
+ *  lastName: string
+ * }
+ * const localeCompare = (a: string, b: string) => a.localeCompare(b)
+ * const comparators = [
+ *  (a: User, b: User) => localeCompare(a.firstName, b.firstName),
+ *  (a: User, b: User) => localeCompare(a.lastName, b.lastName)
+ *  ]
+ *
+ * const users: User[] = [
+ *  {fistName: 'Bill', lastName: 'Stevens'},
+ *  {firstName: 'Jill', lastName: 'Ames'},
+ *  {firstName: 'Bill', lastName: 'Bernard'},
+ * ]
+ * users.sort(multiSortCompareFn(comparators)) // Bill Bernard, Bill Stevens, Jill Ames
+ * ```
+ * @param comparators The array of Comparators whose indices indicate sort precedence
+ * @returns Comparator
+ */
+export declare function multiSortCompareFn(comparators: Comparator[]): Comparator;