heroku 10.13.2 → 11.0.0-alpha.10

package/lib/lib/run/log-displayer.js

@@ -1,91 +1,133 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const core_1 = require("@oclif/core");
-const color_1 = require("@heroku-cli/color");
-const colorize_1 = require("./colorize");
-const generation_1 = require("../apps/generation");
-const EventSource = require('@heroku/eventsource');
-function readLogs(logplexURL, isTail, recreateSessionTimeout) {
-    return new Promise(function (resolve, reject) {
-        const userAgent = process.env.HEROKU_DEBUG_USER_AGENT || 'heroku-run';
-        const proxy = process.env.https_proxy || process.env.HTTPS_PROXY;
-        const es = new EventSource(logplexURL, {
-            proxy,
-            headers: {
-                'User-Agent': userAgent,
-            },
-        });
-        es.addEventListener('error', function (err) {
-            if (err && (err.status || err.message)) {
-                const msg = (isTail && (err.status === 404 || err.status === 403)) ?
-                    'Log stream timed out. Please try again.' :
-                    `Logs eventsource failed with: ${err.status}${err.message ? ` ${err.message}` : ''}`;
-                reject(new Error(msg));
-                es.close();
+import { ux } from '@oclif/core';
+import { color } from '@heroku-cli/color';
+import colorize from './colorize.js';
+import { getGenerationByAppId } from '../apps/generation.js';
+import { EventSource } from 'eventsource';
+import { HttpsProxyAgent } from 'https-proxy-agent';
+export class LogDisplayer {
+    heroku;
+    constructor(heroku) {
+        this.heroku = heroku;
+    }
+    async display(options) {
+        this.setupProcessHandlers();
+        const firApp = (await this.getGenerationByAppId(options)) === 'fir';
+        const isTail = firApp || options.tail;
+        const requestBodyParameters = this.buildRequestBodyParameters(firApp, options);
+        let recreateLogSession = false;
+        do {
+            const logSession = await this.createLogSession(requestBodyParameters, options.app);
+            try {
+                await this.readLogs(logSession.logplex_url, isTail, firApp ? Number(process.env.HEROKU_LOG_STREAM_TIMEOUT || '15') * 60 * 1000 : undefined);
             }
-            if (!isTail) {
-                resolve();
-                es.close();
+            catch (error) {
+                const { message } = error;
+                if (message === 'Fir log stream timeout')
+                    recreateLogSession = true;
+                else
+                    ux.error(message, { exit: 1 });
+            }
+        } while (recreateLogSession);
+    }
+    setupProcessHandlers() {
+        process.stdout.on('error', err => {
+            if (err.code === 'EPIPE') {
+                // eslint-disable-next-line n/no-process-exit
+                process.exit(0);
+            }
+            else {
+                ux.error(err.stack, { exit: 1 });
             }
-            // should only land here if --tail and no error status or message
         });
-        es.addEventListener('message', function (e) {
-            e.data.trim().split(/\n+/).forEach(line => {
-                core_1.ux.log((0, colorize_1.default)(line));
+    }
+    async getGenerationByAppId(options) {
+        const generation = await getGenerationByAppId(options.app, this.heroku);
+        return generation || '';
+    }
+    buildRequestBodyParameters(firApp, options) {
+        const requestBodyParameters = {
+            source: options.source,
+        };
+        if (firApp) {
+            process.stderr.write(color.cyan.bold('Fetching logs...\n\n'));
+            Object.assign(requestBodyParameters, {
+                dyno: options.dyno,
+                type: options.type,
             });
-        });
-        if (isTail && recreateSessionTimeout) {
-            setTimeout(() => {
-                reject(new Error('Fir log stream timeout'));
-                es.close();
-            }, recreateSessionTimeout);
-        }
-    });
-}
-async function logDisplayer(heroku, options) {
-    process.stdout.on('error', err => {
-        if (err.code === 'EPIPE') {
-            process.exit(0);
         }
         else {
-            core_1.ux.error(err.stack, { exit: 1 });
+            Object.assign(requestBodyParameters, {
+                dyno: options.dyno || options.type,
+                lines: options.lines,
+                tail: options.tail,
+            });
         }
-    });
-    const firApp = (await (0, generation_1.getGenerationByAppId)(options.app, heroku)) === 'fir';
-    const isTail = firApp || options.tail;
-    const requestBodyParameters = {
-        source: options.source,
-    };
-    if (firApp) {
-        process.stderr.write(color_1.default.cyan.bold('Fetching logs...\n\n'));
-        Object.assign(requestBodyParameters, {
-            dyno: options.dyno,
-            type: options.type,
-        });
+        return requestBodyParameters;
     }
-    else {
-        Object.assign(requestBodyParameters, {
-            dyno: options.dyno || options.type,
-            lines: options.lines,
-            tail: options.tail,
-        });
-    }
-    let recreateLogSession = false;
-    do {
-        const { body: logSession } = await heroku.post(`/apps/${options.app}/log-sessions`, {
+    async createLogSession(requestBodyParameters, app) {
+        const { body: logSession } = await this.heroku.post(`/apps/${app}/log-sessions`, {
             body: requestBodyParameters,
             headers: { Accept: 'application/vnd.heroku+json; version=3.sdk' },
         });
-        try {
-            await readLogs(logSession.logplex_url, isTail, firApp ? Number(process.env.HEROKU_LOG_STREAM_TIMEOUT || '15') * 60 * 1000 : undefined);
-        }
-        catch (error) {
-            const { message } = error;
-            if (message === 'Fir log stream timeout')
-                recreateLogSession = true;
-            else
-                core_1.ux.error(message, { exit: 1 });
-        }
-    } while (recreateLogSession);
+        return logSession;
+    }
+    createEventSourceInstance(url, options) {
+        return new EventSource(url, options);
+    }
+    readLogs(logplexURL, isTail, recreateSessionTimeout) {
+        return new Promise((resolve, reject) => {
+            const userAgent = process.env.HEROKU_DEBUG_USER_AGENT || 'heroku-run';
+            const proxy = process.env.https_proxy || process.env.HTTPS_PROXY;
+            // Custom fetch function to handle headers and proxy
+            const customFetch = async (input, init) => {
+                const headers = new Headers(init?.headers);
+                headers.set('User-Agent', userAgent);
+                const fetchOptions = {
+                    ...init,
+                    headers,
+                };
+                // If proxy is set, use https-proxy-agent
+                if (proxy) {
+                    const proxyAgent = new HttpsProxyAgent(proxy);
+                    fetchOptions.agent = proxyAgent;
+                }
+                return fetch(input, fetchOptions);
+            };
+            const es = this.createEventSourceInstance(logplexURL, {
+                fetch: customFetch,
+            });
+            es.addEventListener('error', (err) => {
+                // The new eventsource package provides message and code properties on errors
+                const errorEvent = err;
+                if (errorEvent && (errorEvent.code || errorEvent.message)) {
+                    const msg = (isTail && (errorEvent.code === 404 || errorEvent.code === 403))
+                        ? 'Log stream timed out. Please try again.'
+                        : `Logs eventsource failed with: ${errorEvent.code}${errorEvent.message ? ` ${errorEvent.message}` : ''}`;
+                    reject(new Error(msg));
+                    es.close();
+                }
+                if (!isTail) {
+                    resolve();
+                    es.close();
+                }
+                // should only land here if --tail and no error status or message
+            });
+            es.addEventListener('message', (e) => {
+                e.data.trim().split(/\n+/).forEach((line) => {
+                    ux.stdout(colorize(line));
+                });
+            });
+            if (isTail && recreateSessionTimeout) {
+                setTimeout(() => {
+                    reject(new Error('Fir log stream timeout'));
+                    es.close();
+                }, recreateSessionTimeout);
+            }
+        });
+    }
+}
+// Default export for backward compatibility
+export default async function logDisplayer(heroku, options) {
+    const displayer = new LogDisplayer(heroku);
+    await displayer.display(options);
 }
-exports.default = logDisplayer;

package/lib/lib/sessions/sessions.js

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

package/lib/lib/spaces/format.js

@@ -1,60 +1,52 @@
-"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 : '';
+import { color } from '@heroku-cli/color';
+export function displayCIDR(cidr) {
+    return cidr?.join(', ') ?? '';
 }
-exports.displayCIDR = displayCIDR;
-function hostStatus(s) {
+export function hostStatus(s) {
     switch (s) {
         case 'available':
-            return `${color_1.default.green(s)}`;
+            return `${color.green(s)}`;
         case 'under-assessment':
-            return `${color_1.default.yellow(s)}`;
+            return `${color.yellow(s)}`;
         case 'permanent-failure':
         case 'released-permanent-failure':
-            return `${color_1.default.red(s)}`;
+            return `${color.red(s)}`;
         case 'released':
-            return `${color_1.default.gray(s)}`;
+            return `${color.gray(s)}`;
         default:
             return s;
     }
 }
-exports.hostStatus = hostStatus;
-function peeringStatus(s) {
+export function peeringStatus(s) {
     switch (s) {
         case 'active':
-            return `${color_1.default.green(s)}`;
+            return `${color.green(s)}`;
         case 'pending-acceptance':
         case 'provisioning':
-            return `${color_1.default.yellow(s)}`;
+            return `${color.yellow(s)}`;
         case 'expired':
         case 'failed':
         case 'deleted':
         case 'rejected':
-            return `${color_1.default.red(s)}`;
+            return `${color.red(s)}`;
         default:
             return s;
     }
 }
-exports.peeringStatus = peeringStatus;
-function displayVPNStatus(s) {
+export function displayVPNStatus(s) {
     switch (s) {
         case 'UP':
         case 'available':
-            return `${color_1.default.green(s)}`;
+            return `${color.green(s)}`;
         case 'pending':
         case 'provisioning':
         case 'deprovisioning':
-            return `${color_1.default.yellow(s)}`;
+            return `${color.yellow(s)}`;
         case 'DOWN':
         case 'deleting':
         case 'deleted':
-            return `${color_1.default.red(s)}`;
+            return `${color.red(s)}`;
         default:
             return s;
     }
 }
-exports.displayVPNStatus = displayVPNStatus;

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

@@ -1,9 +1 @@
-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;
+export {};

package/lib/lib/spaces/hosts.js

@@ -1,35 +1,43 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.displayHostsAsJSON = exports.displayHosts = void 0;
-const core_1 = require("@oclif/core");
-const heroku_cli_util_1 = require("@heroku/heroku-cli-util");
-const format_1 = require("./format");
-function displayHosts(space, hosts) {
-    heroku_cli_util_1.hux.styledHeader(`${space} Hosts`);
-    heroku_cli_util_1.hux.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 || '',
-        },
-    });
+export {};
+/*
+import {ux} from '@oclif/core'
+import {hux} from '@heroku/heroku-cli-util'
+import {hostStatus} from './format'
+
+export type Host = {
+  host_id: string,
+  state: string,
+  available_capacity_percentage: number,
+  allocated_at: string,
+  released_at: string,
 }
-exports.displayHosts = displayHosts;
-function displayHostsAsJSON(hosts) {
-    core_1.ux.log(JSON.stringify(hosts, null, 2));
+
+export function displayHosts(space: string, hosts: Host[]) {
+  hux.styledHeader(`${space} Hosts`)
+  hux.table(hosts, {
+    host_id: {
+      header: 'Host ID',
+    },
+    state: {
+      header: 'State',
+      get: host => 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.displayHostsAsJSON = displayHostsAsJSON;
+
+export function displayHostsAsJSON(hosts: Host[]) {
+  ux.log(JSON.stringify(hosts, null, 2))
+}
+*/

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

@@ -1,4 +1 @@
-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;
+export {};

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

@@ -1,79 +1,85 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.displayRulesAsJSON = exports.displayRules = exports.parsePorts = void 0;
-const core_1 = require("@oclif/core");
-const heroku_cli_util_1 = require("@heroku/heroku-cli-util");
-function parsePorts(protocol, port = '') {
-    if (port === '-1' || port === 'any') {
-        if (protocol === 'icmp') {
-            return [0, 255];
-        }
-        return [0, 65535];
+export {};
+/*
+import {ux} from '@oclif/core'
+import {hux} from '@heroku/heroku-cli-util'
+
+import * as Heroku from '@heroku-cli/schema'
+
+export function parsePorts(protocol: string, port: string = '') {
+  if (port === '-1' || port === 'any') {
+    if (protocol === 'icmp') {
+      return [0, 255]
     }
-    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;
+
+    return [0, 65535]
+  }
+
+  let actual: number[] = []
+  const ports: number[] = 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) {
-        heroku_cli_util_1.hux.styledHeader('Outbound Rules');
-        display(ruleset.rules);
-    }
-    else {
-        heroku_cli_util_1.hux.styledHeader(`${space} has no Outbound Rules. Your Dynos cannot communicate with hosts outside of ${space}.`);
-    }
+
+export function displayRules(space: string, ruleset: Heroku.OutboundRuleset) {
+  const rules = ruleset.rules || []
+  if (rules.length > 0) {
+    hux.styledHeader('Outbound Rules')
+    display(ruleset.rules)
+  } else {
+    hux.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));
+
+export function displayRulesAsJSON(ruleset: Heroku.OutboundRuleset) {
+  ux.log(JSON.stringify(ruleset, null, 2))
 }
-exports.displayRulesAsJSON = displayRulesAsJSON;
-function display(rules) {
-    heroku_cli_util_1.hux.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 display(rules: Heroku.OutboundRuleset['rules']) {
+  hux.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;
+
+function lined(rules: Heroku.OutboundRuleset['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.js

@@ -1,6 +1,3 @@
-"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.
@@ -8,10 +5,9 @@ exports.splitCsv = void 0;
  * @returns An array of strings or an empty array
  *
  */
-function splitCsv(csvString) {
+export 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

@@ -1,4 +1 @@
-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;
+export {};