heroku 8.1.9 → 8.2.0-beta.0

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

@@ -0,0 +1,72 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { APIClient } from '@heroku-cli/command';
+import { IOptions } from '@heroku-cli/command/lib/api-client';
+import { Dyno as APIDyno } from '@heroku-cli/schema';
+import { HTTP } from 'http-call';
+import * as net from 'net';
+import { Duplex } from 'stream';
+import * as tls from 'tls';
+import { URL } from 'url';
+interface HerokuApiClientRun extends APIClient {
+    options: IOptions & {
+        rejectUnauthorized?: boolean;
+    };
+}
+interface DynoOpts {
+    'exit-code'?: boolean;
+    'no-tty'?: boolean;
+    app: string;
+    attach?: boolean;
+    command: string;
+    dyno?: string;
+    env?: string;
+    heroku: APIClient;
+    listen?: boolean;
+    notify?: boolean;
+    showStatus?: boolean;
+    size?: string;
+    type?: string;
+}
+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;
+    };
+    unpipeStdin: any;
+    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>;
+    _connect(): Promise<unknown>;
+    _handle(localServer: net.Server): void;
+    _isDebug(): boolean | "" | undefined;
+    _env(): {
+        [key: string]: any;
+    };
+    _status(status: string | undefined): string;
+    _readData(c?: tls.TLSSocket): (data: string) => void;
+    _readStdin(c: tls.TLSSocket): void;
+    _read(): void;
+    _write(chunk: any, encoding: any, callback: any): void;
+    _notify(): void;
+}
+export {};

package/lib/lib/run/dyno.js

@@ -0,0 +1,397 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+const color_1 = require("@heroku-cli/color");
+const notifications_1 = require("@heroku-cli/notifications");
+const child_process_1 = require("child_process");
+const core_1 = require("@oclif/core");
+const debug_1 = require("debug");
+const https = require("https");
+const net = require("net");
+const stream_1 = require("stream");
+const tls = require("tls");
+const tty = require("tty");
+const url_1 = require("url");
+const helpers_1 = require("./helpers");
+const debug = (0, debug_1.default)('heroku:run');
+const wait = (ms) => new Promise(resolve => setTimeout(() => resolve(), ms));
+class Dyno extends stream_1.Duplex {
+    constructor(opts) {
+        super();
+        this.opts = opts;
+        this.cork();
+        this.opts = opts;
+        this.heroku = opts.heroku;
+        if (this.opts.showStatus === undefined) {
+            this.opts.showStatus = true;
+        }
+    }
+    get _useSSH() {
+        if (this.uri) {
+            /* tslint:disable:no-http-string */
+            return this.uri.protocol === 'http:' || this.uri.protocol === 'https:';
+            /* tslint:enable:no-http-string */
+        }
+    }
+    /**
+     * Starts the dyno
+     */
+    async start() {
+        this._startedAt = Date.now();
+        if (this.opts.showStatus) {
+            core_1.ux.action.start(`Running ${color_1.default.cyan.bold(this.opts.command)} on ${color_1.default.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) {
+                core_1.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 {
+            core_1.ux.action.stop();
+        }
+    }
+    // Attaches stdin/stdout to dyno
+    attach() {
+        this.pipe(process.stdout);
+        if (this.dyno && this.dyno.attach_url) {
+            this.uri = new url_1.URL(this.dyno.attach_url);
+            this.legacyUri = (0, url_1.parse)(this.dyno.attach_url);
+        }
+        if (this._useSSH) {
+            this.p = this._ssh();
+        }
+        else {
+            this.p = this._rendezvous();
+        }
+        return this.p.then(() => {
+            this.end();
+        });
+    }
+    _rendezvous() {
+        return new Promise((resolve, reject) => {
+            this.resolve = resolve;
+            this.reject = reject;
+            if (this.opts.showStatus) {
+                core_1.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) {
+                        core_1.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
+            core_1.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;
+        }
+    }
+    _connect() {
+        return new Promise((resolve, reject) => {
+            this.resolve = resolve;
+            this.reject = reject;
+            // @ts-ignore
+            const options = this.legacyUri;
+            options.headers = { Connection: 'Upgrade', Upgrade: 'tcp' };
+            options.rejectUnauthorized = false;
+            const r = https.request(options);
+            r.end();
+            r.on('error', this.reject);
+            r.on('upgrade', (_, remote) => {
+                const s = net.createServer(client => {
+                    client.on('end', () => {
+                        s.close();
+                        // @ts-ignore
+                        this.resolve();
+                    });
+                    client.on('connect', () => s.close());
+                    client.on('error', () => this.reject);
+                    remote.on('error', () => this.reject);
+                    client.setNoDelay(true);
+                    remote.setNoDelay(true);
+                    remote.on('data', (data) => client.write(data));
+                    client.on('data', data => remote.write(data));
+                });
+                s.listen(0, 'localhost', () => this._handle(s));
+                // abort the request when the local pipe server is closed
+                s.on('close', () => {
+                    r.abort();
+                });
+            });
+        });
+    }
+    _handle(localServer) {
+        const addr = localServer.address();
+        const host = addr.address;
+        const port = addr.port;
+        let lastErr = '';
+        // does not actually uncork but allows error to be displayed when attempting to read
+        this.uncork();
+        if (this.opts.listen) {
+            core_1.ux.log(`listening on port ${host}:${port} for ssh client`);
+        }
+        else {
+            const params = [host, '-p', port.toString(), '-oStrictHostKeyChecking=no', '-oUserKnownHostsFile=/dev/null', '-oServerAliveInterval=20'];
+            // Debug SSH
+            if (this._isDebug()) {
+                params.push('-vvv');
+            }
+            const stdio = [0, 1, 'pipe'];
+            if (this.opts['exit-code']) {
+                stdio[1] = 'pipe';
+                if (process.stdout.isTTY) {
+                    // force tty
+                    params.push('-t');
+                }
+            }
+            const sshProc = (0, child_process_1.spawn)('ssh', params, { stdio });
+            // only receives stdout with --exit-code
+            if (sshProc.stdout) {
+                sshProc.stdout.setEncoding('utf8');
+                sshProc.stdout.on('data', this._readData());
+            }
+            // @ts-ignore
+            sshProc.stderr.on('data', data => {
+                lastErr = data;
+                // supress 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);
+                }
+            });
+            sshProc.on('close', () => {
+                // there was a problem connecting with the ssh key
+                if (lastErr.length > 0 && lastErr.includes('Permission denied')) {
+                    const msgs = ['There was a problem connecting to the dyno.'];
+                    if (process.env.SSH_AUTH_SOCK) {
+                        msgs.push('Confirm that your ssh key is added to your agent by running `ssh-add`.');
+                    }
+                    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_1.default.cyan('https://devcenter.heroku.com/articles/one-off-dynos#shield-private-spaces')}`);
+                    core_1.ux.error(msgs.join('\n'));
+                }
+                // cleanup local server
+                localServer.close();
+            });
+            this.p
+                .then(() => sshProc.kill())
+                .catch(() => sshProc.kill());
+        }
+        this._notify();
+    }
+    _isDebug() {
+        const debug = process.env.HEROKU_DEBUG;
+        return debug && (debug === '1' || debug.toUpperCase() === 'TRUE');
+    }
+    _env() {
+        const c = this.opts.env ? (0, helpers_1.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;
+    }
+    _status(status) {
+        // @ts-ignore
+        const size = this.dyno.size > 0 ? ` (${this.dyno.size})` : '';
+        // @ts-ignore
+        return `${status}, ${this.dyno.name || this.opts.dyno}${size}`;
+    }
+    _readData(c) {
+        let firstLine = true;
+        return (data) => {
+            debug('input: %o', data);
+            // discard first line
+            if (c && firstLine) {
+                if (this.opts.showStatus)
+                    core_1.ux.action.stop(this._status('up'));
+                firstLine = false;
+                this._readStdin(c);
+                return;
+            }
+            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');
+            }
+            const exitCode = data.match(/\uFFFF heroku-command-exit-status: (\d+)/m);
+            if (exitCode) {
+                debug('got exit code: %d', exitCode[1]);
+                this.push(data.replace(/^\uFFFF heroku-command-exit-status: \d+$\n?/m, ''));
+                const code = Number.parseInt(exitCode[1], 10);
+                if (code === 0) {
+                    // @ts-ignore
+                    this.resolve();
+                }
+                else {
+                    const err = new Error(`Process exited with code ${color_1.default.red(code.toString())}`);
+                    err.exitCode = code;
+                    // @ts-ignore
+                    this.reject(err);
+                }
+                return;
+            }
+            this.push(data);
+        };
+    }
+    _readStdin(c) {
+        this.input = c;
+        const stdin = process.stdin;
+        stdin.setEncoding('utf8');
+        // without this the CLI will hang on rake db:migrate
+        // until a character is pressed
+        if (stdin.unref) {
+            stdin.unref();
+        }
+        if (!this.opts['no-tty'] && tty.isatty(0)) {
+            // @ts-ignore
+            stdin.setRawMode(true);
+            stdin.pipe(c);
+            let sigints = [];
+            stdin.on('data', function (c) {
+                if (c === '\u0003') {
+                    sigints.push(Date.now());
+                }
+                sigints = sigints.filter(d => d > Date.now() - 1000);
+                if (sigints.length >= 4) {
+                    core_1.ux.error('forcing dyno disconnect', { exit: 1 });
+                }
+            });
+        }
+        else {
+            stdin.pipe(new stream_1.Transform({
+                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');
+        }
+        // do not need to do anything to handle Readable interface
+    }
+    _write(chunk, encoding, callback) {
+        if (this.useSSH) {
+            throw new Error('Cannot write stream to ssh dyno');
+        }
+        if (!this.input)
+            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
+            };
+            (0, notifications_1.notify)(notification);
+        }
+        catch (error) {
+            core_1.ux.warn(error);
+        }
+    }
+}
+exports.default = Dyno;

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

@@ -0,0 +1,2 @@
+export declare function buildCommand(args: Array<string>): string;
+export declare function buildEnvFromFlag(flag: string): {};

package/lib/lib/run/helpers.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildEnvFromFlag = exports.buildCommand = void 0;
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+const core_1 = require("@oclif/core");
+function buildCommand(args) {
+    if (args.length === 1) {
+        // do not add quotes around arguments if there is only one argument
+        // `heroku run "rake test"` should work like `heroku run rake test`
+        return args[0];
+    }
+    let cmd = '';
+    for (let arg of args) {
+        if (arg.includes(' ') || arg.includes('"')) {
+            arg = '"' + arg.replace(/"/g, '\\"') + '"';
+        }
+        cmd = cmd + ' ' + arg;
+    }
+    return cmd.trim();
+}
+exports.buildCommand = buildCommand;
+function buildEnvFromFlag(flag) {
+    const env = {};
+    for (const v of flag.split(';')) {
+        const m = v.match(/^\s*([\w.-]+)\s*=\s*(.*)?\s*$/);
+        // @ts-ignore
+        if (m)
+            env[m[1]] = m[2];
+        else
+            core_1.ux.warn(`env flag ${v} appears invalid. Avoid using ';' in values.`);
+    }
+    return env;
+}
+exports.buildEnvFromFlag = buildEnvFromFlag;

package/lib/lib/run/line-transform.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="node" />
+import * as stream from 'stream';
+declare const transform: stream.Transform;
+export default transform;

package/lib/lib/run/line-transform.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+const stream = require("stream");
+// this splits a stream into lines
+const transform = new stream.Transform({ decodeStrings: false });
+transform._transform = function (chunk, _encoding, next) {
+    let data = chunk;
+    // @ts-ignore
+    if (this._lastLineData)
+        data = this._lastLineData + data;
+    const lines = data.split('\n');
+    // @ts-ignore
+    this._lastLineData = lines.splice(-1, 1)[0];
+    lines.forEach(this.push.bind(this));
+    next();
+};
+transform._flush = function (done) {
+    // @ts-ignore
+    if (this._lastLineData)
+        this.push(this._lastLineData);
+    // @ts-ignore
+    this._lastLineData = null;
+    done();
+};
+exports.default = transform;

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

@@ -0,0 +1,10 @@
+import { APIClient } from '@heroku-cli/command';
+interface LogDisplayerOptions {
+    app: string;
+    dyno: string;
+    lines?: number;
+    tail: boolean;
+    source?: string;
+}
+declare function logDisplayer(heroku: APIClient, options: LogDisplayerOptions): Promise<unknown>;
+export default logDisplayer;

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

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const http_call_1 = require("http-call");
+const url_1 = require("url");
+const colorize_1 = require("./colorize");
+const line_transform_1 = require("./line-transform");
+const EventSource = require('@heroku/eventsource');
+async function readLogsV1(logplexURL) {
+    const { response } = await http_call_1.default.stream(logplexURL);
+    return new Promise(function (resolve, reject) {
+        response.setEncoding('utf8');
+        line_transform_1.default.setEncoding('utf8');
+        response.pipe(line_transform_1.default);
+        line_transform_1.default.on('data', line => core_1.ux.log((0, colorize_1.default)(line)));
+        response.on('end', resolve);
+        response.on('error', reject);
+    });
+}
+function readLogsV2(logplexURL) {
+    return new Promise(function (resolve, reject) {
+        const u = new url_1.URL(logplexURL);
+        const isTail = u.searchParams.get('tail') === 'true';
+        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}`;
+                reject(msg);
+                es.close();
+            }
+            if (!isTail) {
+                resolve();
+                es.close();
+            }
+            // 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));
+            });
+        });
+    });
+}
+function readLogs(logplexURL) {
+    const u = new url_1.URL(logplexURL);
+    if (u.searchParams.has('srv')) {
+        return readLogsV1(logplexURL);
+    }
+    return readLogsV2(logplexURL);
+}
+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 });
+        }
+    });
+    const response = await heroku.post(`/apps/${options.app}/log-sessions`, {
+        body: {
+            tail: options.tail,
+            dyno: options.dyno,
+            source: options.source,
+            lines: options.lines,
+        },
+    });
+    return readLogs(response.body.logplex_url);
+}
+exports.default = logDisplayer;

package/lib/lib/sessions/sessions.d.ts

@@ -0,0 +1,7 @@
+export interface OAuthSession {
+    created_at?: string;
+    description?: null | string;
+    expires_in?: null | number;
+    id?: string;
+    updated_at?: string;
+}

package/lib/lib/sessions/sessions.js

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

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

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

package/lib/lib/status/util.js

@@ -0,0 +1,14 @@
+"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 };
+        }
+    }
+    return max && max.element;
+}
+exports.maxBy = maxBy;

package/lib/lib/webhooks/base.d.ts

@@ -0,0 +1,13 @@
+import { APIClient, Command } from '@heroku-cli/command';
+import { Config } from '@oclif/core';
+export default abstract class extends Command {
+    webhooksClient: APIClient;
+    protected constructor(argv: string[], config: Config);
+    webhookType(context: {
+        pipeline?: string;
+        app?: string;
+    }): {
+        path: string;
+        display: string;
+    };
+}