heroku 8.1.9 → 8.2.0-beta.0

package/lib/lib/ci/interfaces/kolkrabbi.d.ts

@@ -0,0 +1,311 @@
+/**
+ * This file was automatically generated by json-schema-to-typescript.
+ * DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file,
+ * and run json-schema-to-typescript to regenerate this file.
+ */
+/**
+ * Kolkrabbi API.
+ */
+export interface KolkrabbiApi {
+    'account-link'?: KolkrabbiApiAccountLink;
+    'app-json-schema'?: AppJsonSchema;
+    'app-json'?: KolkrabbiApiAppJson;
+    apps?: KolkrabbiApiApps;
+    organization?: HerokuPlatformApiOrganization;
+    'pipeline-repository'?: KolkrabbiApiPipelineRepositories;
+    pipeline?: HerokuPlatformApiPipeline;
+    'pull-requests'?: KolkrabbiApiPullRequests;
+    repository?: KolkrabbiApiRepositories;
+    [k: string]: any;
+}
+/**
+ * An account link represents the relationship between a Heroku user and a GitHub user.
+ */
+export interface KolkrabbiApiAccountLink {
+    /**
+     * unique identifier of an account link
+     */
+    id?: string;
+    /**
+     * Heroku details for the account link
+     */
+    heroku?: {
+        /**
+         * unique identifier of the Heroku user
+         */
+        user_id?: string;
+        [k: string]: any;
+    };
+    /**
+     * GitHub details for the account link
+     */
+    github?: {
+        /**
+         * unique identifier of the GitHub user
+         */
+        user_id?: number;
+        [k: string]: any;
+    };
+    [k: string]: any;
+}
+export interface AppJsonSchema {
+    /**
+     * A clean and simple name to identify the template (30 characters max).
+     */
+    name?: string;
+    /**
+     * A brief summary of the app: what it does, who it's for, why it exists, etc.
+     */
+    description?: string;
+    /**
+     * An array of strings describing the app.
+     */
+    keywords?: any[];
+    /**
+     * The project's website.
+     */
+    website?: string;
+    /**
+     * The location of the application's source code, such as a Git URL, GitHub URL, Subversion URL, or Mercurial URL.
+     */
+    repository?: string;
+    /**
+     * The URL of the application's logo image. Dimensions should be square. Format can be SVG, PNG, or JPG.
+     */
+    logo?: string;
+    /**
+     * A URL specifying where to redirect the user once their new app is deployed. If value is a fully-qualified URL, the user should be redirected to that URL. If value begins with a slash `/`, the user should be redirected to that path in their newly deployed app.
+     */
+    success_url?: string;
+    /**
+     * A key-value object specifying scripts or shell commands to execute at different stages in the build/release process. Currently, `postdeploy` is the only supported script.
+     */
+    scripts?: {
+        [k: string]: any;
+    };
+    /**
+     * A key-value object for environment variables, or [config vars](https://devcenter.heroku.com/articles/config-vars) in Heroku parlance. Keys are the names of the environment variables. Values can be strings or objects. If the value is a string, it will be used. If the value is an object, it defines specific requirements for that variable:
+     *
+     * - `description`: a human-friendly blurb about what the value is for and how to determine what it should be
+     * - `value`: a default value to use. This should always be a string.
+     * - `required`: A boolean indicating whether the given value is required for the app to function (default: `true`).
+     * - `generator`: a string representing a function to call to generate the value. Currently the only supported generator is `secret`, which generates a pseudo-random string of characters.
+     */
+    env?: {
+        [k: string]: any;
+    };
+    /**
+     * An array of strings specifying Heroku addons to provision on the app before deploying. Each addon should be in the format `addon:plan` or `addon`. If plan is omitted, that addon's default plan will be provisioned.
+     */
+    addons?: any[];
+    /**
+     * An ordered array of objects specifying the buildpacks to be applied to this app
+     */
+    buildpacks?: any[];
+    /**
+     * Dynos to scale on the app before deploying.
+     */
+    formation?: {
+        [k: string]: any;
+    };
+}
+export interface KolkrabbiApiAppJson {
+    app_json?: AppJsonSchema;
+    /**
+     * name of branch to commit to
+     */
+    branch?: string | null;
+    [k: string]: any;
+}
+/**
+ * FIXME
+ */
+export interface KolkrabbiApiApps {
+    /**
+     * unique identifier of app
+     */
+    app_id?: string;
+    /**
+     * when app was created
+     */
+    created_at?: string;
+    /**
+     * unique identifier of app
+     */
+    id?: string;
+    /**
+     * when app was updated
+     */
+    updated_at?: string | null;
+    [k: string]: any;
+}
+/**
+ * Deprecated: Organizations allow you to manage access to a shared group of applications across your development team.
+ */
+export interface HerokuPlatformApiOrganization {
+    /**
+     * unique identifier of organization
+     */
+    id?: string;
+    /**
+     * when the organization was created
+     */
+    created_at?: string;
+    /**
+     * whether charges incurred by the org are paid by credit card.
+     */
+    credit_card_collections?: boolean;
+    /**
+     * whether to use this organization when none is specified
+     */
+    default?: boolean;
+    /**
+     * upper limit of members allowed in an organization.
+     */
+    membership_limit?: number | null;
+    /**
+     * unique name of organization
+     */
+    name?: string;
+    /**
+     * whether the org is provisioned licenses by salesforce.
+     */
+    provisioned_licenses?: boolean;
+    /**
+     * role in the organization
+     */
+    role?: 'admin' | 'collaborator' | 'member' | 'owner' | null;
+    /**
+     * type of organization.
+     */
+    type?: 'enterprise' | 'team';
+    /**
+     * when the organization was updated
+     */
+    updated_at?: string;
+    [k: string]: any;
+}
+/**
+ * Pipeline repositories link a pipeline to a Github repository.
+ */
+export interface KolkrabbiApiPipelineRepositories {
+    /**
+     * whether automatic review apps is enabled
+     */
+    automatic_review_apps?: boolean;
+    /**
+     * whether CI is enabled
+     */
+    ci?: boolean;
+    /**
+     * unique identifier of a pipeline repository
+     */
+    id?: string;
+    creator?: KolkrabbiApiAccountLink;
+    /**
+     * when the pipeline repository was created
+     */
+    created_at?: string;
+    /**
+     * organization tied to this pipeline repository
+     */
+    organization?: {
+        [k: string]: any;
+    } | null;
+    owner?: KolkrabbiApiAccountLink;
+    pipeline?: HerokuPlatformApiPipeline;
+    repository?: KolkrabbiApiRepositories;
+    /**
+     * whether review apps is enabled
+     */
+    review_apps?: boolean;
+    /**
+     * a collection of statuses
+     */
+    statuses?: any[];
+    /**
+     * when pipeline repository was updated
+     */
+    updated_at?: string | null;
+    [k: string]: any;
+}
+/**
+ * A pipeline allows grouping of apps into different stages.
+ */
+export interface HerokuPlatformApiPipeline {
+    /**
+     * unique identifier of pipeline
+     */
+    id?: string;
+    [k: string]: any;
+}
+/**
+ * A Repository is a reference to a remote DVCs codebase
+ */
+export interface KolkrabbiApiRepositories {
+    /**
+     * The id that the remote DVCS uses for the repository
+     */
+    id?: number;
+    /**
+     * The name for the remote DVCS uses for the repository
+     */
+    name?: string;
+    /**
+     * The type of DVCS
+     */
+    type?: string;
+    /**
+     * when the repository reference was created
+     */
+    created_at?: string;
+    /**
+     * when repository was updated
+     */
+    updated_at?: string | null;
+    [k: string]: any;
+}
+/**
+ * FIXME
+ */
+export interface KolkrabbiApiPullRequests {
+    app_setup?: {
+        /**
+         * unique identifier of app setup
+         */
+        id?: string;
+        /**
+         * the overall status of app setup
+         */
+        status?: 'failed' | 'pending' | 'succeeded';
+        [k: string]: any;
+    };
+    /**
+     * when app was created
+     */
+    created_at?: string;
+    pull_request?: {
+        /**
+         * unique identifier of pull request
+         */
+        id?: number;
+        /**
+         * pull request number
+         */
+        number?: number;
+        /**
+         * unique name of app
+         */
+        ref?: string;
+        /**
+         * pull request title
+         */
+        title?: string;
+        [k: string]: any;
+    };
+    /**
+     * when app was updated
+     */
+    updated_at?: string | null;
+    [k: string]: any;
+}

package/lib/lib/ci/interfaces/kolkrabbi.js

@@ -0,0 +1,7 @@
+"use strict";
+/**
+ * This file was automatically generated by json-schema-to-typescript.
+ * DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file,
+ * and run json-schema-to-typescript to regenerate this file.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/lib/ci/pipelines.d.ts

@@ -0,0 +1,3 @@
+import { Command } from '@heroku-cli/command';
+export declare function disambiguatePipeline(pipelineIDOrName: any, command: Command): Promise<any>;
+export declare function getPipeline(flags: any, command: Command): Promise<any>;

package/lib/lib/ci/pipelines.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPipeline = exports.disambiguatePipeline = void 0;
+const inquirer_1 = require("inquirer");
+const validator_1 = require("validator");
+async function disambiguatePipeline(pipelineIDOrName, command) {
+    const headers = { Accept: 'application/vnd.heroku+json; version=3.pipelines' };
+    if ((0, validator_1.isUUID)(pipelineIDOrName)) {
+        const { body: pipeline } = await command.heroku.get(`/pipelines/${pipelineIDOrName}`, { headers });
+        return pipeline;
+    }
+    const { body: pipelines } = await command.heroku.get(`/pipelines?eq[name]=${pipelineIDOrName}`, { headers });
+    let choices;
+    let questions;
+    switch (pipelines.length) {
+        case 0:
+            command.error('Pipeline not found');
+            break;
+        case 1:
+            return pipelines[0];
+        default:
+            choices = pipelines.map(function (x) {
+                return { name: new Date(x.created_at), value: x };
+            });
+            questions = [{
+                    type: 'list',
+                    name: 'pipeline',
+                    message: `Which ${pipelineIDOrName} pipeline?`,
+                    choices,
+                }];
+            return (0, inquirer_1.prompt)(questions);
+    }
+}
+exports.disambiguatePipeline = disambiguatePipeline;
+async function getPipeline(flags, command) {
+    let pipeline;
+    if ((!flags.pipeline) && (!flags.app)) {
+        command.error('Required flag:  --pipeline PIPELINE or --app APP');
+    }
+    if (flags && flags.pipeline) {
+        pipeline = await disambiguatePipeline(flags.pipeline, command);
+        if (pipeline.pipeline) {
+            pipeline = pipeline.pipeline;
+        } // in case prompt returns an object like { pipeline: { ... } }
+    }
+    else {
+        const { body: coupling } = await command.heroku.get(`/apps/${flags.app}/pipeline-couplings`);
+        if ((coupling) && (coupling.pipeline)) {
+            pipeline = coupling.pipeline;
+        }
+        else {
+            command.error(`No pipeline found with application ${flags.app}`);
+        }
+    }
+    return pipeline;
+}
+exports.getPipeline = getPipeline;

package/lib/lib/ci/source.d.ts

@@ -0,0 +1,2 @@
+import { Command } from '@heroku-cli/command';
+export declare function createSourceBlob(ref: any, command: Command): Promise<any>;

package/lib/lib/ci/source.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSourceBlob = void 0;
+const fs = require("async-file");
+const core_1 = require("@oclif/core");
+const git = require("./git");
+const got = require('got');
+async function uploadArchive(url, filePath) {
+    const request = got.stream.put(url, {
+        headers: {
+            'content-length': (await fs.stat(filePath)).size,
+        },
+    });
+    fs.createReadStream(filePath).pipe(request);
+    return new Promise((resolve, reject) => {
+        request.on('error', reject);
+        request.on('response', resolve);
+    });
+}
+async function prepareSource(ref, command) {
+    const filePath = await git.createArchive(ref);
+    const { body: source } = await command.heroku.post('/sources');
+    await uploadArchive(source.source_blob.put_url, filePath);
+    return Promise.resolve(source);
+}
+async function createSourceBlob(ref, command) {
+    try {
+        const githubRepository = await git.githubRepository();
+        const { user, repo } = githubRepository;
+        const { body: archiveLink } = await command.heroku.get(`https://kolkrabbi.heroku.com/github/repos/${user}/${repo}/tarball/${ref}`);
+        if (await command.heroku.request(archiveLink.archive_link, { method: 'HEAD' })) {
+            return archiveLink.archive_link;
+        }
+    }
+    catch (error) {
+        // the commit isn't in the repo, we will package the local git commit instead
+        core_1.ux.debug(`Commit not found in pipeline repository: ${error}`);
+    }
+    const sourceBlob = await prepareSource(ref, command);
+    return sourceBlob.source_blob.get_url;
+}
+exports.createSourceBlob = createSourceBlob;

package/lib/lib/ci/test-run.d.ts

@@ -0,0 +1,5 @@
+import { Command } from '@heroku-cli/command';
+import * as Heroku from '@heroku-cli/schema';
+export declare function renderList(command: Command, testRuns: Heroku.TestRun[], pipeline: Heroku.Pipeline, watchOption: boolean, jsonOption: boolean): Promise<void>;
+export declare function displayAndExit(pipeline: Heroku.Pipeline, number: number, command: Command): Promise<void>;
+export declare function displayTestRunInfo(command: Command, testRun: Heroku.TestRun, testNodes: Heroku.TestNode[], nodeArg: string | undefined): Promise<void>;

package/lib/lib/ci/test-run.js

@@ -0,0 +1,232 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.displayTestRunInfo = exports.displayAndExit = exports.renderList = void 0;
+const color_1 = require("@heroku-cli/color");
+const core_1 = require("@oclif/core");
+const https_1 = require("https");
+const phoenix_1 = require("phoenix");
+const util_1 = require("util");
+const uuid_1 = require("uuid");
+const WebSocket = require("ws");
+const debug = require('debug')('ci');
+const ansiEscapes = require('ansi-escapes');
+const HEROKU_CI_WEBSOCKET_URL = process.env.HEROKU_CI_WEBSOCKET_URL || 'wss://particleboard.heroku.com/socket';
+function logStream(url, fn) {
+    return (0, https_1.get)(url, fn);
+}
+function stream(url) {
+    return new Promise((resolve, reject) => {
+        const request = logStream(url, output => {
+            output.on('data', data => {
+                if (data.toString() === Buffer.from('').toString()) {
+                    request.abort();
+                    resolve();
+                }
+            });
+            output.on('end', () => resolve());
+            output.on('error', e => reject(e));
+            output.pipe(process.stdout);
+        });
+    });
+}
+function statusIcon({ status }) {
+    if (!status) {
+        return color_1.default.yellow('-');
+    }
+    switch (status) {
+        case 'pending':
+        case 'creating':
+        case 'building':
+        case 'running':
+        case 'debugging':
+            return color_1.default.yellow('-');
+        case 'errored':
+            return color_1.default.red('!');
+        case 'failed':
+            return color_1.default.red('✗');
+        case 'succeeded':
+            return color_1.default.green('✓');
+        case 'cancelled':
+            return color_1.default.yellow('!');
+        default:
+            return color_1.default.yellow('?');
+    }
+}
+const BUILDING = 'building';
+const RUNNING = 'running';
+const ERRORED = 'errored';
+const FAILED = 'failed';
+const SUCCEEDED = 'succeeded';
+const CANCELLED = 'cancelled';
+const TERMINAL_STATES = [SUCCEEDED, FAILED, ERRORED, CANCELLED];
+const RUNNING_STATES = [RUNNING].concat(TERMINAL_STATES);
+const BUILDING_STATES = [BUILDING, RUNNING].concat(TERMINAL_STATES);
+function printLine(testRun) {
+    return `${statusIcon(testRun)} #${testRun.number} ${testRun.commit_branch}:${testRun.commit_sha.slice(0, 7)} ${testRun.status}`;
+}
+function printLineTestNode(testNode) {
+    return `${statusIcon(testNode)} #${testNode.index} ${testNode.status}`;
+}
+function processExitCode(command, testNode) {
+    if (testNode.exit_code && testNode.exit_code !== 0) {
+        command.exit(testNode.exit_code);
+    }
+}
+function handleTestRunEvent(newTestRun, testRuns) {
+    const previousTestRun = testRuns.find(({ id }) => id === newTestRun.id);
+    if (previousTestRun) {
+        const previousTestRunIndex = testRuns.indexOf(previousTestRun);
+        testRuns.splice(previousTestRunIndex, 1);
+    }
+    testRuns.push(newTestRun);
+    return testRuns;
+}
+function sort(testRuns) {
+    return testRuns.sort((a, b) => a.number < b.number ? 1 : -1);
+}
+function draw(testRuns, watchOption = false, jsonOption = false, count = 15) {
+    const latestTestRuns = sort(testRuns).slice(0, count);
+    if (jsonOption) {
+        core_1.ux.styledJSON(latestTestRuns);
+        return;
+    }
+    if (watchOption) {
+        process.stdout.write(ansiEscapes.eraseDown);
+    }
+    const data = [];
+    latestTestRuns.forEach(testRun => {
+        data.push({
+            iconStatus: `${statusIcon(testRun)}`,
+            number: testRun.number,
+            branch: testRun.commit_branch,
+            sha: testRun.commit_sha.slice(0, 7),
+            status: testRun.status,
+        });
+    });
+    core_1.ux.table(data, {
+        iconStatus: {
+            minWidth: 1, header: '', // header '' is to make sure that width is 1 character
+        },
+        number: {
+            header: '', // header '' is to make sure that width is 1 character
+        },
+        branch: {},
+        sha: {},
+        status: {},
+    }, { printHeader: undefined });
+    if (watchOption) {
+        process.stdout.write(ansiEscapes.cursorUp(latestTestRuns.length));
+    }
+}
+async function renderList(command, testRuns, pipeline, watchOption, jsonOption) {
+    const watchable = (Boolean(watchOption && !jsonOption));
+    if (!jsonOption) {
+        const header = `${watchOption ? 'Watching' : 'Showing'} latest test runs for the ${pipeline.name} pipeline`;
+        core_1.ux.styledHeader(header);
+    }
+    draw(testRuns, watchOption, jsonOption);
+    if (!watchable) {
+        return;
+    }
+    const socket = new phoenix_1.Socket(HEROKU_CI_WEBSOCKET_URL, {
+        transport: WebSocket,
+        params: {
+            token: command.heroku.auth,
+            tab_id: `heroku-cli-${(0, uuid_1.v4)()}`,
+        },
+        logger: (kind, msg, data) => debug(`${kind}: ${msg}\n${(0, util_1.inspect)(data)}`),
+    });
+    socket.connect();
+    const channel = socket.channel(`events:pipelines/${pipeline.id}/test-runs`, {});
+    channel.on('create', ({ data }) => {
+        testRuns = handleTestRunEvent(data, testRuns);
+        draw(testRuns, watchOption);
+    });
+    channel.on('update', ({ data }) => {
+        testRuns = handleTestRunEvent(data, testRuns);
+        draw(testRuns, watchOption);
+    });
+    // eslint-disable-next-line unicorn/require-array-join-separator
+    channel.join();
+}
+exports.renderList = renderList;
+async function renderNodeOutput(command, testRun, testNode) {
+    if (!testNode) {
+        command.error(`Test run ${testRun.number} was ${testRun.status}. No Heroku CI runs found for this pipeline.`);
+    }
+    await stream(testNode.setup_stream_url);
+    await stream(testNode.output_stream_url);
+    command.log();
+    command.log(printLine(testRun));
+}
+async function waitForStates(states, testRun, command) {
+    let newTestRun = testRun;
+    while (!states.includes(newTestRun.status.toString())) {
+        const { body: bodyTestRun } = await command.heroku.get(`/pipelines/${testRun.pipeline.id}/test-runs/${testRun.number}`);
+        newTestRun = bodyTestRun;
+    }
+    return newTestRun;
+}
+async function display(pipeline, number, command) {
+    let { body: testRun } = await command.heroku.get(`/pipelines/${pipeline.id}/test-runs/${number}`);
+    if (testRun) {
+        core_1.ux.action.start('Waiting for build to start');
+        testRun = await waitForStates(BUILDING_STATES, testRun, command);
+        core_1.ux.action.stop();
+        const { body: testNodes } = await command.heroku.get(`/test-runs/${testRun.id}/test-nodes`);
+        let firstTestNode = testNodes[0];
+        if (firstTestNode) {
+            await stream(firstTestNode.setup_stream_url);
+        }
+        if (testRun) {
+            testRun = await waitForStates(RUNNING_STATES, testRun, command);
+        }
+        if (firstTestNode) {
+            await stream(firstTestNode.output_stream_url);
+        }
+        if (testRun) {
+            testRun = await waitForStates(TERMINAL_STATES, testRun, command);
+        }
+        // At this point, we know that testRun has a finished status,
+        // and we can check for exit_code from firstTestNode
+        if (testRun) {
+            const { body: newTestNodes } = await command.heroku.get(`/test-runs/${testRun.id}/test-nodes`);
+            firstTestNode = newTestNodes[0];
+            command.log();
+            command.log(printLine(testRun));
+        }
+        return firstTestNode;
+    }
+}
+async function displayAndExit(pipeline, number, command) {
+    const testNode = await display(pipeline, number, command);
+    testNode ? processExitCode(command, testNode) : command.exit(1);
+}
+exports.displayAndExit = displayAndExit;
+async function displayTestRunInfo(command, testRun, testNodes, nodeArg) {
+    let testNode;
+    if (nodeArg) {
+        const nodeIndex = Number.parseInt(nodeArg, 2);
+        testNode = testNodes.length > 1 ? testNodes[nodeIndex] : testNodes[0];
+        await renderNodeOutput(command, testRun, testNode);
+        if (testNodes.length === 1) {
+            command.log();
+            command.warn('This pipeline doesn\'t have parallel test runs, but you specified a node');
+            command.warn('See https://devcenter.heroku.com/articles/heroku-ci-parallel-test-runs for more info');
+        }
+        processExitCode(command, testNode);
+    }
+    else if (testNodes.length > 1) {
+        command.log(printLine(testRun));
+        command.log();
+        testNodes.forEach(testNode => {
+            command.log(printLineTestNode(testNode));
+        });
+    }
+    else {
+        testNode = testNodes[0];
+        await renderNodeOutput(command, testRun, testNode);
+        processExitCode(command, testNode);
+    }
+}
+exports.displayTestRunInfo = displayTestRunInfo;

package/lib/lib/clients/clients.d.ts

@@ -0,0 +1 @@
+export declare function validateURL(uri: string): string;

package/lib/lib/clients/clients.js

@@ -0,0 +1,25 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateURL = void 0;
+const url_1 = require("url");
+function insecureURL(uri) {
+    if (uri.protocol === 'https:')
+        return false;
+    // allow non-https localhost, 10.*, 127.*, and 192.* clients for testing
+    if (/^localhost(?:[:]\d+)?$/.test(uri.host))
+        return false;
+    if (/\.local(?:[:]\d+)?$/.test(uri.host))
+        return false;
+    if (uri.host.match(/^(10|127|192)\.\d{1,3}\.\d{1,3}\.\d{1,3}(?:[:]\d+)?$/))
+        return false;
+    return true;
+}
+function validateURL(uri) {
+    const u = new url_1.URL(uri);
+    if (!u.protocol)
+        throw new Error('Invalid URL');
+    if (insecureURL(u))
+        throw new Error('Unsupported callback URL. Clients have to use HTTPS for non-local addresses.');
+    return uri;
+}
+exports.validateURL = validateURL;