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

package/lib/lib/run/dyno.d.ts

@@ -2,76 +2,68 @@
 /// <reference types="node" resolution-mode="require"/>
 /// <reference types="node" resolution-mode="require"/>
 /// <reference types="node" resolution-mode="require"/>
-import { APIClient } from '@heroku-cli/command';
-import { Dyno as APIDyno } from '@heroku-cli/schema';
 import { HTTP } from '@heroku/http-call';
+import { APIClient, type IOptions } from '@heroku-cli/command';
+import { Dyno as APIDyno } from '@heroku-cli/schema';
 import * as net from 'net';
 import { Duplex } from 'stream';
 import * as tls from 'tls';
 import { URL } from 'url';
 interface HerokuApiClientRun extends APIClient {
-    options: IOptions & {
+    options: {
         rejectUnauthorized?: boolean;
-    };
+    } & IOptions;
 }
-interface DynoOpts {
-    'exit-code'?: boolean;
-    'no-tty'?: boolean;
+export interface DynoOpts {
     app: string;
     attach?: boolean;
     command: string;
     dyno?: string;
     env?: string;
+    'exit-code'?: boolean;
     heroku: APIClient;
     listen?: boolean;
+    'no-tty'?: boolean;
+    notificationSubtitle?: string;
     notify?: boolean;
     showStatus?: boolean;
     size?: string;
     type?: string;
 }
-interface IOptions {
-    debug?: boolean;
-    debugHeaders?: boolean;
-    preauth?: boolean;
-    required?: boolean;
-}
 export default class Dyno extends Duplex {
     opts: DynoOpts;
-    get _useSSH(): boolean | undefined;
     dyno?: APIDyno;
     heroku: HerokuApiClientRun;
     input: any;
-    p: any;
-    reject?: (reason?: any) => void;
-    resolve?: (value?: unknown) => void;
-    uri?: URL;
     legacyUri?: {
         [key: string]: any;
     };
+    p: any;
+    reject?: (reason?: any) => void;
+    resolve?: (value?: unknown) => void;
     unpipeStdin: any;
+    uri?: URL;
     useSSH: any;
     private _notified?;
     private _startedAt?;
     constructor(opts: DynoOpts);
-    /**
-     * Starts the dyno
-     */
-    start(): Promise<void>;
-    _doStart(retries?: number): Promise<HTTP<unknown> | undefined>;
     attach(): any;
-    _rendezvous(): Promise<unknown>;
-    _ssh(retries?: number): Promise<unknown>;
+    start(): Promise<void>;
     _connect(): Promise<unknown>;
-    _handle(localServer: net.Server): void;
-    _isDebug(): boolean | "" | undefined;
+    _doStart(retries?: number): Promise<HTTP<unknown> | undefined>;
     _env(): {
         [key: string]: any;
     };
-    _status(status: string | undefined): string;
+    _handle(localServer: net.Server): void;
+    _isDebug(): boolean | "" | undefined;
+    _notify(): void;
+    _read(): void;
     _readData(c?: tls.TLSSocket): (data: string) => void;
     _readStdin(c: tls.TLSSocket): void;
-    _read(): void;
+    _rendezvous(): Promise<unknown>;
+    _ssh(retries?: number): Promise<unknown>;
+    _status(status: string | undefined): string;
+    get _useSSH(): boolean | undefined;
     _write(chunk: any, encoding: any, callback: any): void;
-    _notify(): void;
 }
 export {};

package/lib/lib/run/dyno.js

@@ -1,36 +1,32 @@
 /* eslint-disable @typescript-eslint/ban-ts-comment */
-import { color } from '@heroku-cli/color';
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { color } from '@heroku/heroku-cli-util';
 import { notify } from '@heroku-cli/notifications';
-import { spawn } from 'child_process';
 import { ux } from '@oclif/core';
 import debugFactory from 'debug';
 import * as https from 'https';
 import * as net from 'net';
+import { spawn } from 'node:child_process';
 import { Duplex, Transform } from 'stream';
 import * as tls from 'tls';
 import * as tty from 'tty';
-import { URL, parse } from 'url';
+import { URL } from 'url';
 import { buildEnvFromFlag } from './helpers.js';
 const debug = debugFactory('heroku:run');
-const wait = (ms) => new Promise(resolve => setTimeout(() => resolve(), ms));
+const wait = (ms) => new Promise(resolve => {
+    setTimeout(() => resolve(), ms);
+});
 export default class Dyno extends Duplex {
     opts;
-    get _useSSH() {
-        if (this.uri) {
-            /* tslint:disable:no-http-string */
-            return this.uri.protocol === 'http:' || this.uri.protocol === 'https:';
-            /* tslint:enable:no-http-string */
-        }
-    }
     dyno;
     heroku;
     input;
+    legacyUri;
     p;
     reject;
     resolve;
-    uri;
-    legacyUri;
     unpipeStdin;
+    uri;
     useSSH;
     _notified;
     _startedAt;
@@ -44,68 +40,12 @@ export default class Dyno extends Duplex {
             this.opts.showStatus = true;
         }
     }
-    /**
-     * Starts the dyno
-     */
-    async start() {
-        this._startedAt = Date.now();
-        if (this.opts.showStatus) {
-            ux.action.start(`Running ${color.cyan.bold(this.opts.command)} on ${color.app(this.opts.app)}`);
-        }
-        await this._doStart();
-    }
-    async _doStart(retries = 2) {
-        const command = this.opts['exit-code'] ? `${this.opts.command}; echo "\uFFFF heroku-command-exit-status: $?"` : this.opts.command;
-        try {
-            const dyno = await this.heroku.post(this.opts.dyno ? `/apps/${this.opts.app}/dynos/${this.opts.dyno}` : `/apps/${this.opts.app}/dynos`, {
-                headers: {
-                    Accept: this.opts.dyno ? 'application/vnd.heroku+json; version=3.run-inside' : 'application/vnd.heroku+json; version=3',
-                },
-                body: {
-                    command,
-                    attach: this.opts.attach,
-                    size: this.opts.size,
-                    type: this.opts.type,
-                    env: this._env(),
-                    force_no_tty: this.opts['no-tty'],
-                },
-            });
-            // @ts-ignore
-            this.dyno = dyno.body;
-            if (this.opts.attach || this.opts.dyno) {
-                // @ts-ignore
-                if (this.dyno.name && this.opts.dyno === undefined) {
-                    // @ts-ignore
-                    this.opts.dyno = this.dyno.name;
-                }
-                await this.attach();
-            }
-            else if (this.opts.showStatus) {
-                ux.action.stop(this._status('done'));
-            }
-        }
-        catch (error) {
-            // Currently the runtime API sends back a 409 in the event the
-            // release isn't found yet. API just forwards this response back to
-            // the client, so we'll need to retry these. This usually
-            // happens when you create an app and immediately try to run a
-            // one-off dyno. No pause between attempts since this is
-            // typically a very short-lived condition.
-            if (error.statusCode === 409 && retries > 0) {
-                return this._doStart(retries - 1);
-            }
-            throw error;
-        }
-        finally {
-            ux.action.stop();
-        }
-    }
     // Attaches stdin/stdout to dyno
     attach() {
         this.pipe(process.stdout);
         if (this.dyno && this.dyno.attach_url) {
             this.uri = new URL(this.dyno.attach_url);
-            this.legacyUri = parse(this.dyno.attach_url);
+            this.legacyUri = new URL(this.dyno.attach_url);
         }
         if (this._useSSH) {
             this.p = this._ssh();
@@ -117,70 +57,13 @@ export default class Dyno extends Duplex {
             this.end();
         });
     }
-    _rendezvous() {
-        return new Promise((resolve, reject) => {
-            this.resolve = resolve;
-            this.reject = reject;
-            if (this.opts.showStatus) {
-                ux.action.status = this._status('starting');
-            }
-            // @ts-ignore
-            const c = tls.connect(Number.parseInt(this.uri.port, 10), this.uri.hostname, {
-                rejectUnauthorized: this.heroku.options.rejectUnauthorized,
-            });
-            c.setTimeout(1000 * 60 * 60);
-            c.setEncoding('utf8');
-            c.on('connect', () => {
-                debug('connect');
-                // @ts-ignore eslint-disable-next-line no-unsafe-optional-chaining
-                const pathnameWithSearchParams = this.uri.pathname + this.uri.search;
-                c.write(pathnameWithSearchParams.slice(1) + '\r\n', () => {
-                    if (this.opts.showStatus) {
-                        ux.action.status = this._status('connecting');
-                    }
-                });
-            });
-            c.on('data', this._readData(c));
-            c.on('close', () => {
-                debug('close');
-                // @ts-ignore
-                this.opts['exit-code'] ? this.reject('No exit code returned') : this.resolve();
-                if (this.unpipeStdin) {
-                    this.unpipeStdin();
-                }
-            });
-            c.on('error', this.reject);
-            c.on('timeout', () => {
-                debug('timeout');
-                c.end();
-                // @ts-ignore
-                this.reject(new Error('timed out'));
-            });
-            process.once('SIGINT', () => c.end());
-        });
-    }
-    async _ssh(retries = 20) {
-        const interval = 1000;
-        try {
-            const { body: dyno } = await this.heroku.get(`/apps/${this.opts.app}/dynos/${this.opts.dyno}`);
-            // @ts-ignore
-            this.dyno = dyno;
-            // @ts-ignore
-            ux.action.stop(this._status(this.dyno.state));
-            // @ts-ignore
-            if (this.dyno.state === 'starting' || this.dyno.state === 'up') {
-                return this._connect();
-            }
-            await wait(interval);
-            return this._ssh();
-        }
-        catch (error) {
-            // the API sometimes responds with a 404 when the dyno is not yet ready
-            if (error.http.statusCode === 404 && retries > 0) {
-                return this._ssh(retries - 1);
-            }
-            throw error;
+    // Starts the dyno
+    async start() {
+        this._startedAt = Date.now();
+        if (this.opts.showStatus) {
+            ux.action.start(`Running ${color.code(this.opts.command)} on ${color.app(this.opts.app)}`);
         }
+        await this._doStart();
     }
     _connect() {
         return new Promise((resolve, reject) => {
@@ -193,6 +76,13 @@ export default class Dyno extends Duplex {
             const r = https.request(options);
             r.end();
             r.on('error', this.reject);
+            r.on('response', response => {
+                const { statusCode } = response;
+                if (statusCode === 403) {
+                    r.destroy();
+                    this.reject?.(new Error("You can't access this space from your IP address. Contact your team admin."));
+                }
+            });
             r.on('upgrade', (_, remote) => {
                 const s = net.createServer(client => {
                     client.on('end', () => {
@@ -216,6 +106,61 @@ export default class Dyno extends Duplex {
             });
         });
     }
+    async _doStart(retries = 2) {
+        const command = this.opts['exit-code'] ? `${this.opts.command}; echo "\uFFFF heroku-command-exit-status: $?"` : this.opts.command;
+        try {
+            const dyno = await this.heroku.post(this.opts.dyno ? `/apps/${this.opts.app}/dynos/${this.opts.dyno}` : `/apps/${this.opts.app}/dynos`, {
+                body: {
+                    attach: this.opts.attach,
+                    command,
+                    env: this._env(),
+                    force_no_tty: this.opts['no-tty'],
+                    size: this.opts.size,
+                    type: this.opts.type,
+                },
+                headers: {
+                    Accept: this.opts.dyno ? 'application/vnd.heroku+json; version=3.run-inside' : 'application/vnd.heroku+json; version=3',
+                },
+            });
+            // @ts-ignore
+            this.dyno = dyno.body;
+            if (this.opts.attach || this.opts.dyno) {
+                // @ts-ignore
+                if (this.dyno.name && this.opts.dyno === undefined) {
+                    // @ts-ignore
+                    this.opts.dyno = this.dyno.name;
+                }
+                await this.attach();
+            }
+            else if (this.opts.showStatus) {
+                ux.action.stop(this._status('done'));
+            }
+        }
+        catch (error) {
+            // Currently the runtime API sends back a 409 in the event the
+            // release isn't found yet. API just forwards this response back to
+            // the client, so we'll need to retry these. This usually
+            // happens when you create an app and immediately try to run a
+            // one-off dyno. No pause between attempts since this is
+            // typically a very short-lived condition.
+            if (error.statusCode === 409 && retries > 0) {
+                return this._doStart(retries - 1);
+            }
+            throw error;
+        }
+        finally {
+            ux.action.stop();
+        }
+    }
+    _env() {
+        const c = this.opts.env ? buildEnvFromFlag(this.opts.env) : {};
+        c.TERM = process.env.TERM;
+        if (tty.isatty(1)) {
+            c.COLUMNS = process.stdout.columns;
+            c.LINES = process.stdout.rows;
+        }
+        return c;
+    }
     _handle(localServer) {
         const addr = localServer.address();
         const host = addr.address;
@@ -224,7 +169,7 @@ export default class Dyno extends Duplex {
         // does not actually uncork but allows error to be displayed when attempting to read
         this.uncork();
         if (this.opts.listen) {
-            ux.stderr(`listening on port ${host}:${port} for ssh client`);
+            ux.stdout(`listening on port ${host}:${port} for ssh client`);
         }
         else {
             const params = [host, '-p', port.toString(), '-oStrictHostKeyChecking=no', '-oUserKnownHostsFile=/dev/null', '-oServerAliveInterval=20'];
@@ -275,7 +220,7 @@ export default class Dyno extends Duplex {
                     }
                     msgs.push('Check that your ssh key has been uploaded to heroku with `heroku keys:add`.');
                     // eslint-disable-next-line unicorn/no-array-push-push
-                    msgs.push(`See ${color.cyan('https://devcenter.heroku.com/articles/one-off-dynos#shield-private-spaces')}`);
+                    msgs.push(`See ${color.info('https://devcenter.heroku.com/articles/one-off-dynos#shield-private-spaces')}`);
                     ux.error(msgs.join('\n'));
                 }
                 // cleanup local server
@@ -291,20 +236,33 @@ export default class Dyno extends Duplex {
         const debug = process.env.HEROKU_DEBUG;
         return debug && (debug === '1' || debug.toUpperCase() === 'TRUE');
     }
-    _env() {
-        const c = this.opts.env ? buildEnvFromFlag(this.opts.env) : {};
-        c.TERM = process.env.TERM;
-        if (tty.isatty(1)) {
-            c.COLUMNS = process.stdout.columns;
-            c.LINES = process.stdout.rows;
+    _notify() {
+        try {
+            if (this._notified)
+                return;
+            this._notified = true;
+            if (!this.opts.notify)
+                return;
+            // only show notifications if dyno took longer than 20 seconds to start
+            // @ts-ignore
+            if (Date.now() - this._startedAt < 1000 * 20)
+                return;
+            const notification = {
+                message: 'dyno is up',
+                subtitle: this.opts.notificationSubtitle || `heroku run ${this.opts.command}`,
+                title: this.opts.app,
+            };
+            notify(notification);
+        }
+        catch (error) {
+            ux.warn(error);
         }
-        return c;
     }
-    _status(status) {
-        // @ts-ignore
-        const size = this.dyno.size > 0 ? ` (${this.dyno.size})` : '';
-        // @ts-ignore
-        return `${status}, ${this.dyno.name || this.opts.dyno}${size}`;
+    _read() {
+        if (this.useSSH) {
+            throw new Error('Cannot read stream from ssh dyno');
+        }
+        // do not need to do anything to handle Readable interface
     }
     _readData(c) {
         let firstLine = true;
@@ -321,8 +279,7 @@ export default class Dyno extends Duplex {
             this._notify();
             // carriage returns break json parsing of output
             if (!process.stdout.isTTY) {
-                // eslint-disable-next-line no-control-regex, prefer-regex-literals
-                data = data.replace(new RegExp('\r\n', 'g'), '\n');
+                data = data.replaceAll('\r\n', '\n');
             }
             const exitCode = data.match(/\uFFFF heroku-command-exit-status: (\d+)/m);
             if (exitCode) {
@@ -334,7 +291,7 @@ export default class Dyno extends Duplex {
                     this.resolve();
                 }
                 else {
-                    const err = new Error(`Process exited with code ${color.red(code.toString())}`);
+                    const err = new Error(`Process exited with code ${color.failure(code.toString())}`);
                     err.exitCode = code;
                     // @ts-ignore
                     this.reject(err);
@@ -370,19 +327,90 @@ export default class Dyno extends Duplex {
         }
         else {
             stdin.pipe(new Transform({
+                flush: done => c.write('\u0004', done),
                 objectMode: true,
                 transform: (chunk, _, next) => c.write(chunk, next),
-                // eslint-disable-next-line unicorn/no-hex-escape
-                flush: done => c.write('\x04', done),
             }));
         }
         this.uncork();
     }
-    _read() {
-        if (this.useSSH) {
-            throw new Error('Cannot read stream from ssh dyno');
+    _rendezvous() {
+        return new Promise((resolve, reject) => {
+            this.resolve = resolve;
+            this.reject = reject;
+            if (this.opts.showStatus) {
+                ux.action.status = this._status('starting');
+            }
+            // @ts-ignore
+            const c = tls.connect(Number.parseInt(this.uri.port, 10), this.uri.hostname, {
+                rejectUnauthorized: this.heroku.options.rejectUnauthorized,
+            });
+            c.setTimeout(1000 * 60 * 60);
+            c.setEncoding('utf8');
+            c.on('connect', () => {
+                debug('dyno connect');
+                // @ts-ignore eslint-disable-next-line no-unsafe-optional-chaining
+                const pathnameWithSearchParams = this.uri.pathname + this.uri.search;
+                c.write(pathnameWithSearchParams.slice(1) + '\r\n', () => {
+                    if (this.opts.showStatus) {
+                        ux.action.status = this._status('connecting');
+                    }
+                });
+            });
+            c.on('data', this._readData(c));
+            c.on('close', () => {
+                debug('dyno connection close');
+                // @ts-ignore
+                this.opts['exit-code'] ? this.reject('No exit code returned') : this.resolve();
+                if (this.unpipeStdin) {
+                    this.unpipeStdin();
+                }
+            });
+            c.on('error', this.reject);
+            c.on('timeout', () => {
+                debug('dyno timeout');
+                c.end();
+                // @ts-ignore
+                this.reject(new Error('timed out'));
+            });
+            process.once('SIGINT', () => c.end());
+        });
+    }
+    async _ssh(retries = 20) {
+        const interval = 1000;
+        try {
+            const { body: dyno } = await this.heroku.get(`/apps/${this.opts.app}/dynos/${this.opts.dyno}`);
+            // @ts-ignore
+            this.dyno = dyno;
+            // @ts-ignore
+            ux.action.stop(this._status(this.dyno.state));
+            // @ts-ignore
+            if (this.dyno.state === 'starting' || this.dyno.state === 'up') {
+                return this._connect();
+            }
+            await wait(interval);
+            return this._ssh();
+        }
+        catch (error) {
+            // the API sometimes responds with a 404 when the dyno is not yet ready
+            if (error.http.statusCode === 404 && retries > 0) {
+                return this._ssh(retries - 1);
+            }
+            throw error;
+        }
+    }
+    _status(status) {
+        // @ts-ignore
+        const size = this.dyno.size > 0 ? ` (${this.dyno.size})` : '';
+        // @ts-ignore
+        return `${status}, ${this.dyno.name || this.opts.dyno}${size}`;
+    }
+    get _useSSH() {
+        if (this.uri) {
+            /* tslint:disable:no-http-string */
+            return this.uri.protocol === 'http:' || this.uri.protocol === 'https:';
+            /* tslint:enable:no-http-string */
         }
-        // do not need to do anything to handle Readable interface
     }
     _write(chunk, encoding, callback) {
         if (this.useSSH) {
@@ -392,28 +420,4 @@ export default class Dyno extends Duplex {
             throw new Error('no input');
         this.input.write(chunk, encoding, callback);
     }
-    _notify() {
-        try {
-            if (this._notified)
-                return;
-            this._notified = true;
-            if (!this.opts.notify)
-                return;
-            // only show notifications if dyno took longer than 20 seconds to start
-            // @ts-ignore
-            if (Date.now() - this._startedAt < 1000 * 20)
-                return;
-            const notification = {
-                // @ts-ignore
-                title: this.opts.app,
-                subtitle: `heroku run ${this.opts.command}`,
-                message: 'dyno is up',
-                // sound: true
-            };
-            notify(notification);
-        }
-        catch (error) {
-            ux.warn(error);
-        }
-    }
 }

package/lib/lib/run/helpers.d.ts

@@ -1,3 +1,28 @@
+import type { APIClient } from '@heroku-cli/command';
 export declare function revertSortedArgs(processArgs: Array<string>, argv: Array<string>): string[];
 export declare function buildCommand(args: Array<string>, prependLauncher?: boolean): string;
 export declare function buildEnvFromFlag(flag: string): {};
+/**
+ * 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 declare function shouldPrependLauncher(heroku: APIClient, appName: string, disableLauncher: boolean): Promise<boolean>;
+/**
+ * Builds the command string, automatically deciding whether to prepend `launcher`.
+ */
+export declare function buildCommandWithLauncher(heroku: APIClient, appName: string, args: string[], disableLauncher: boolean): Promise<string>;
+/**
+ * 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 declare function fetchHttpResponseBody(url: string, expectedStatusCode?: number): Promise<string>;