heroku 11.0.0-alpha.11 → 11.0.0-alpha.13

package/lib/lib/run/helpers.js

@@ -1,5 +1,6 @@
-/* eslint-disable @typescript-eslint/ban-ts-comment */
 import { ux } from '@oclif/core';
+import * as https from 'https';
+import { URL } from 'url';
 // this function exists because oclif sorts argv
 // and to capture all non-flag command inputs
 export function revertSortedArgs(processArgs, argv) {
@@ -15,8 +16,8 @@ export function revertSortedArgs(processArgs, argv) {
         if (processArg === '--') {
             isSeparatorPresent = true;
         }
-        if ((argv.includes(processArg) && (!isSeparatorPresent && !argIsFlag)) ||
-            (argv.includes(processArg) && (isSeparatorPresent))) {
+        if ((argv.includes(processArg) && (!isSeparatorPresent && !argIsFlag))
+            || (argv.includes(processArg) && (isSeparatorPresent))) {
             originalInputOrder.push(processArg);
         }
     }
@@ -50,3 +51,118 @@ export function buildEnvFromFlag(flag) {
     }
     return env;
 }
+/**
+ * Determines whether to prepend `launcher` to the command for a given app.
+ * Behavior: Only prepend on CNB stack apps and when not explicitly disabled.
+ */
+export async function shouldPrependLauncher(heroku, appName, disableLauncher) {
+    if (disableLauncher)
+        return false;
+    const { body: app } = await heroku.get(`/apps/${appName}`, {
+        headers: { Accept: 'application/vnd.heroku+json; version=3.sdk' },
+    });
+    return (app.stack && app.stack.name) === 'cnb';
+}
+/**
+ * Builds the command string, automatically deciding whether to prepend `launcher`.
+ */
+export async function buildCommandWithLauncher(heroku, appName, args, disableLauncher) {
+    const prependLauncher = await shouldPrependLauncher(heroku, appName, disableLauncher);
+    return buildCommand(args, prependLauncher);
+}
+/**
+ * Fetches the response body from an HTTP request when the response body isn't available
+ * from the error object (e.g., EventSource doesn't expose response bodies).
+ *
+ * Uses native fetch API with a custom https.Agent to handle staging SSL certificates
+ * (rejectUnauthorized: false).
+ *
+ * Note: Node.js native fetch doesn't support custom agents directly, so we use
+ * https.request when rejectUnauthorized is needed, but structure the code with
+ *
+ * @param url - The URL to fetch the response body from
+ * @param expectedStatusCode - Only return body if status code matches (default: 403)
+ * @returns The response body as a string, or empty string if unavailable or status doesn't match
+ */
+export async function fetchHttpResponseBody(url, expectedStatusCode = 403) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 5000); // 5 second timeout
+    try {
+        const parsedUrl = new URL(url);
+        const userAgent = process.env.HEROKU_DEBUG_USER_AGENT || 'heroku-run';
+        // Note: Native fetch in Node.js doesn't support custom https.Agent for SSL certificate handling.
+        // We use https.request when rejectUnauthorized: false is needed (staging environments).
+        // This maintains compatibility while using modern async/await and AbortController patterns.
+        if (parsedUrl.protocol !== 'https:') {
+            // For non-HTTPS URLs, use native fetch
+            const response = await fetch(url, {
+                headers: {
+                    Accept: 'text/plain',
+                    'User-Agent': userAgent,
+                },
+                method: 'GET',
+                signal: controller.signal,
+            });
+            clearTimeout(timeoutId);
+            if (response.status === expectedStatusCode) {
+                return await response.text();
+            }
+            return '';
+        }
+        // For HTTPS with rejectUnauthorized: false (staging), use https.request
+        // This is the same pattern as dyno.ts - necessary for staging SSL certs
+        return await new Promise(resolve => {
+            const cleanup = () => {
+                clearTimeout(timeoutId);
+                controller.abort();
+            };
+            const options = {
+                headers: {
+                    Accept: 'text/plain',
+                    'User-Agent': userAgent,
+                },
+                hostname: parsedUrl.hostname,
+                method: 'GET',
+                path: parsedUrl.pathname + parsedUrl.search,
+                port: parsedUrl.port || 443,
+                rejectUnauthorized: false, // Allow staging self-signed certificates
+            };
+            const req = https.request(options, res => {
+                let body = '';
+                res.setEncoding('utf8');
+                res.on('data', chunk => {
+                    body += chunk;
+                });
+                res.on('end', () => {
+                    cleanup();
+                    if (res.statusCode === expectedStatusCode) {
+                        resolve(body);
+                    }
+                    else {
+                        resolve('');
+                    }
+                });
+            });
+            req.on('error', () => {
+                cleanup();
+                resolve('');
+            });
+            // Abort on timeout
+            controller.signal.addEventListener('abort', () => {
+                req.destroy();
+                resolve('');
+            }, { once: true });
+            req.end();
+        });
+    }
+    catch (error) {
+        clearTimeout(timeoutId);
+        // AbortError is expected on timeout - return empty string
+        if (error instanceof Error && error.name === 'AbortError') {
+            return '';
+        }
+        // For other errors, return empty string for graceful degradation
+        // This matches the previous behavior where errors returned empty string
+        return '';
+    }
+}

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

@@ -11,13 +11,13 @@ interface LogDisplayerOptions {
 export declare class LogDisplayer {
     private heroku;
     constructor(heroku: APIClient);
+    createEventSourceInstance(url: string, options?: any): EventSource;
     display(options: LogDisplayerOptions): Promise<void>;
-    private setupProcessHandlers;
-    private getGenerationByAppId;
     private buildRequestBodyParameters;
     private createLogSession;
-    createEventSourceInstance(url: string, options?: any): EventSource;
+    private getGenerationByAppId;
     private readLogs;
+    private setupProcessHandlers;
 }
 export default function logDisplayer(heroku: APIClient, options: LogDisplayerOptions): Promise<void>;
 export {};

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

@@ -1,14 +1,17 @@
+import { color } from '@heroku/heroku-cli-util';
 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';
+import { getGenerationByAppId } from '../apps/generation.js';
+import colorize from './colorize.js';
 export class LogDisplayer {
     heroku;
     constructor(heroku) {
         this.heroku = heroku;
     }
+    createEventSourceInstance(url, options) {
+        return new EventSource(url, options);
+    }
     async display(options) {
         this.setupProcessHandlers();
         const firApp = (await this.getGenerationByAppId(options)) === 'fir';
@@ -29,27 +32,12 @@ export class LogDisplayer {
             }
         } 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 });
-            }
-        });
-    }
-    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'));
+            process.stderr.write(color.info('Fetching logs...\n\n'));
             Object.assign(requestBodyParameters, {
                 dyno: options.dyno,
                 type: options.type,
@@ -71,8 +59,9 @@ export class LogDisplayer {
         });
         return logSession;
     }
-    createEventSourceInstance(url, options) {
-        return new EventSource(url, options);
+    async getGenerationByAppId(options) {
+        const generation = await getGenerationByAppId(options.app, this.heroku);
+        return generation || '';
     }
     readLogs(logplexURL, isTail, recreateSessionTimeout) {
         return new Promise((resolve, reject) => {
@@ -125,6 +114,17 @@ export class LogDisplayer {
             }
         });
     }
+    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 });
+            }
+        });
+    }
 }
 // Default export for backward compatibility
 export default async function logDisplayer(heroku, options) {

package/lib/lib/spaces/format.js

@@ -1,52 +1,65 @@
-import { color } from '@heroku-cli/color';
+import { color } from '@heroku/heroku-cli-util';
 export function displayCIDR(cidr) {
     return cidr?.join(', ') ?? '';
 }
 export function hostStatus(s) {
     switch (s) {
-        case 'available':
-            return `${color.green(s)}`;
-        case 'under-assessment':
-            return `${color.yellow(s)}`;
+        case 'available': {
+            return `${color.success(s)}`;
+        }
+        case 'under-assessment': {
+            return `${color.info(s)}`;
+        }
         case 'permanent-failure':
-        case 'released-permanent-failure':
-            return `${color.red(s)}`;
-        case 'released':
+        case 'released-permanent-failure': {
+            return `${color.failure(s)}`;
+        }
+        case 'released': {
             return `${color.gray(s)}`;
-        default:
+        }
+        default: {
             return s;
+        }
     }
 }
 export function peeringStatus(s) {
     switch (s) {
-        case 'active':
-            return `${color.green(s)}`;
+        case 'active': {
+            return `${color.success(s)}`;
+        }
         case 'pending-acceptance':
-        case 'provisioning':
-            return `${color.yellow(s)}`;
+        case 'provisioning': {
+            return `${color.info(s)}`;
+        }
         case 'expired':
         case 'failed':
         case 'deleted':
-        case 'rejected':
-            return `${color.red(s)}`;
-        default:
+        case 'rejected': {
+            return `${color.failure(s)}`;
+        }
+        default: {
             return s;
+        }
     }
 }
 export function displayVPNStatus(s) {
     switch (s) {
         case 'UP':
-        case 'available':
-            return `${color.green(s)}`;
+        case 'available': {
+            return `${color.success(s)}`;
+        }
         case 'pending':
         case 'provisioning':
-        case 'deprovisioning':
-            return `${color.yellow(s)}`;
+        case 'deprovisioning': {
+            return `${color.info(s)}`;
+        }
         case 'DOWN':
         case 'deleting':
-        case 'deleted':
-            return `${color.red(s)}`;
-        default:
+        case 'deleted': {
+            return `${color.failure(s)}`;
+        }
+        default: {
             return s;
+        }
     }
 }

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

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

@@ -1,43 +1,30 @@
-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,
+import { ux } from '@oclif/core';
+import { hux } from '@heroku/heroku-cli-util';
+import { hostStatus } from './format.js';
+export function displayHosts(space, hosts) {
+    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 || '',
+        },
+    });
 }
-
-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 || '',
-    },
-  })
+export function displayHostsAsJSON(hosts) {
+    ux.stdout(JSON.stringify(hosts, null, 2));
 }
-
-export function displayHostsAsJSON(hosts: Host[]) {
-  ux.log(JSON.stringify(hosts, null, 2))
-}
-*/

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

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

@@ -1,55 +1,48 @@
-export {};
-/*
-import {ux} from '@oclif/core'
-import {hux} from '@heroku/heroku-cli-util'
-import {displayCIDR, peeringStatus} from './format'
-import {Peering, PeeringInfo} from '@heroku-cli/schema'
-
-export function displayPeeringInfo(space: string, info: PeeringInfo) {
-  hux.styledHeader(`${space} Peering Info`)
-  hux.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': displayCIDR(info.space_cidr_blocks),
-    'Unavailable CIDRs': displayCIDR(info.unavailable_cidr_blocks),
-  }, ['AWS Account ID', 'AWS Region', 'AWS VPC ID', 'AWS VPC CIDR', 'Space CIDRs', 'Unavailable CIDRs'])
+import { ux } from '@oclif/core';
+import { hux } from '@heroku/heroku-cli-util';
+import { displayCIDR, peeringStatus } from './format.js';
+export function displayPeeringInfo(space, info) {
+    hux.styledHeader(`${space} Peering Info`);
+    hux.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': displayCIDR(info.space_cidr_blocks),
+        'Unavailable CIDRs': displayCIDR(info.unavailable_cidr_blocks),
+    }, ['AWS Account ID', 'AWS Region', 'AWS VPC ID', 'AWS VPC CIDR', 'Space CIDRs', 'Unavailable CIDRs']);
 }
-
-export function displayPeeringsAsJSON(peerings: Peering[]) {
-  ux.log(JSON.stringify(peerings, null, 2))
+export function displayPeeringsAsJSON(peerings) {
+    ux.stdout(JSON.stringify(peerings, null, 2));
 }
-
-export function displayPeerings(space: string, peerings: Peering[]) {
-  hux.styledHeader(`${space} Peerings`)
-  hux.table<Peering>(peerings, {
-    pcx_id: {
-      header: 'PCX ID',
-    },
-    type: {
-      header: 'Type',
-    },
-    cidr_blocks: {
-      header: 'CIDR Blocks',
-      get: (row: Peering) => displayCIDR(row.cidr_blocks),
-    },
-    status: {
-      header: 'Status',
-      get: (row: Required<Peering>) => peeringStatus(row.status),
-    },
-    aws_vpc_id: {
-      header: 'VPC ID',
-    },
-    aws_region: {
-      header: 'AWS Region',
-    },
-    aws_account_id: {
-      header: 'AWS Account ID',
-    },
-    expires: {
-      header: 'Expires',
-    },
-  })
+export function displayPeerings(space, peerings) {
+    hux.styledHeader(`${space} Peerings`);
+    hux.table(peerings, {
+        pcx_id: {
+            header: 'PCX ID',
+        },
+        type: {
+            header: 'Type',
+        },
+        cidr_blocks: {
+            header: 'CIDR Blocks',
+            get: (row) => displayCIDR(row.cidr_blocks),
+        },
+        status: {
+            header: 'Status',
+            get: (row) => peeringStatus(row.status),
+        },
+        aws_vpc_id: {
+            header: 'VPC ID',
+        },
+        aws_region: {
+            header: 'AWS Region',
+        },
+        aws_account_id: {
+            header: 'AWS Account ID',
+        },
+        expires: {
+            header: 'Expires',
+        },
+    });
 }
-*/

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

@@ -1 +1,6 @@
-export {};
+import * as Heroku from '@heroku-cli/schema';
+import { SpaceNat } from '../types/fir.js';
+import { SpaceWithOutboundIps } from '../types/spaces.js';
+export declare function displayShieldState(space: Heroku.Space): "on" | "off";
+export declare function displayNat(nat?: Required<SpaceNat>): string | undefined;
+export declare function renderInfo(space: SpaceWithOutboundIps, json: boolean): void;

package/lib/lib/spaces/spaces.js

@@ -1,42 +1,33 @@
-export {};
-/*
-import * as Heroku from '@heroku-cli/schema'
-import {ux} from '@oclif/core'
-import {hux} from '@heroku/heroku-cli-util'
-import {SpaceNat} from '../types/fir'
-import {SpaceWithOutboundIps} from '../types/spaces'
-import {getGeneration} from '../apps/generation'
-
-export function displayShieldState(space: Heroku.Space) {
-  return space.shield ? 'on' : 'off'
+import { color, hux } from '@heroku/heroku-cli-util';
+import { ux } from '@oclif/core';
+import { getGeneration } from '../apps/generation.js';
+export function displayShieldState(space) {
+    return space.shield ? 'on' : 'off';
 }
-
-export function displayNat(nat?: Required<SpaceNat>) {
-  if (!nat) return
-  if (nat.state !== 'enabled') return nat.state
-  return nat.sources.join(', ')
+export function displayNat(nat) {
+    if (!nat)
+        return;
+    if (nat.state !== 'enabled')
+        return nat.state;
+    return nat.sources.join(', ');
 }
-
-export function renderInfo(space: SpaceWithOutboundIps, json: boolean) {
-  if (json) {
-    ux.log(JSON.stringify(space, null, 2))
-  } else {
-    hux.styledHeader(space.name || '')
-    hux.styledObject(
-      {
-        ID: space.id,
-        Team: space.team?.name,
-        Region: space.region?.description,
-        CIDR: space.cidr,
-        'Data CIDR': space.data_cidr,
-        State: space.state,
-        Shield: displayShieldState(space),
-        'Outbound IPs': displayNat(space.outbound_ips),
-        Generation: getGeneration(space),
-        'Created at': space.created_at,
-      },
-      ['ID', 'Team', 'Region', 'CIDR', 'Data CIDR', 'State', 'Shield', 'Outbound IPs', 'Generation', 'Created at'],
-    )
-  }
+export function renderInfo(space, json) {
+    if (json) {
+        ux.stdout(JSON.stringify(space, null, 2));
+    }
+    else {
+        hux.styledHeader(color.space(space.name || ''));
+        hux.styledObject({
+            ID: space.id,
+            Team: space.team?.name,
+            Region: space.region?.description,
+            CIDR: space.cidr,
+            'Data CIDR': space.data_cidr,
+            State: space.state,
+            Shield: displayShieldState(space),
+            'Outbound IPs': displayNat(space.outbound_ips),
+            Generation: getGeneration(space),
+            'Created at': space.created_at,
+        }, ['ID', 'Team', 'Region', 'CIDR', 'Data CIDR', 'State', 'Shield', 'Outbound IPs', 'Generation', 'Created at']);
+    }
 }
-*/

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

@@ -1,18 +1,18 @@
-// import {hux} from '@heroku/heroku-cli-util'
+import { hux } from '@heroku/heroku-cli-util';
 export function displayVPNConfigInfo(space, name, config) {
-    // hux.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
-    // })
-    // hux.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'},
-    // })
+    hux.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;
+    });
+    hux.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' },
+    });
 }

package/lib/lib/telemetry/util.d.ts

@@ -1,4 +1,4 @@
-import { TelemetryDrain } from '../types/telemetry.js';
 import { APIClient } from '@heroku-cli/command';
+import { TelemetryDrain } from '../types/telemetry.js';
 export declare function validateAndFormatSignals(signalInput: string | undefined): string[];
 export declare function displayTelemetryDrain(telemetryDrain: TelemetryDrain, heroku: APIClient): Promise<void>;