heroku 9.0.0-dev.0 → 9.1.0-beta.0

package/lib/commands/container/login.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const DockerHelper = require("../../lib/container/docker_helper");
+const debug_1 = require("../../lib/container/debug");
+async function dockerLogin(registry, password) {
+    const [major, minor] = await DockerHelper.version();
+    if (major > 17 || (major === 17 && minor >= 7)) {
+        return dockerLoginStdin(registry, password);
+    }
+    return dockerLoginArgv(registry, password);
+}
+function dockerLoginStdin(registry, password) {
+    const args = [
+        'login',
+        '--username=_',
+        '--password-stdin',
+        registry,
+    ];
+    return DockerHelper.cmd('docker', args, { input: password });
+}
+function dockerLoginArgv(registry, password) {
+    const args = [
+        'login',
+        '--username=_',
+        `--password=${password}`,
+        registry,
+    ];
+    return DockerHelper.cmd('docker', args);
+}
+class Login extends command_1.Command {
+    async run() {
+        const { flags } = await this.parse(Login);
+        const { verbose } = flags;
+        const herokuHost = process.env.HEROKU_HOST || 'heroku.com';
+        const registry = `registry.${herokuHost}`;
+        const password = this.heroku.auth;
+        if (verbose) {
+            debug_1.debug.enabled = true;
+        }
+        if (!password)
+            throw new Error('not logged in');
+        try {
+            await dockerLogin(registry, password);
+        }
+        catch (error) {
+            core_1.ux.error(`Login failed${error.message ? ` with: ${error.message}` : ''}.`, { exit: 1 });
+        }
+    }
+}
+exports.default = Login;
+Login.topic = 'container';
+Login.description = 'log in to Heroku Container Registry';
+Login.flags = {
+    verbose: command_1.flags.boolean({ char: 'v' }),
+};

package/lib/commands/container/logout.d.ts

@@ -0,0 +1,9 @@
+import { Command } from '@heroku-cli/command';
+export default class Logout extends Command {
+    static topic: string;
+    static description: string;
+    static flags: {
+        verbose: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/container/logout.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const DockerHelper = require("../../lib/container/docker_helper");
+const debug_1 = require("../../lib/container/debug");
+function dockerLogout(registry) {
+    const args = [
+        'logout',
+        registry,
+    ];
+    return DockerHelper.cmd('docker', args);
+}
+class Logout extends command_1.Command {
+    async run() {
+        const { flags } = await this.parse(Logout);
+        const { verbose } = flags;
+        const herokuHost = process.env.HEROKU_HOST || 'heroku.com';
+        const registry = `registry.${herokuHost}`;
+        if (verbose) {
+            debug_1.debug.enabled = true;
+        }
+        try {
+            await dockerLogout(registry);
+        }
+        catch (error) {
+            const { message } = error;
+            core_1.ux.error(`Error: docker logout exited${message ? ` with: ${message}` : ''}.`);
+        }
+    }
+}
+exports.default = Logout;
+Logout.topic = 'container';
+Logout.description = 'log out from Heroku Container Registry';
+Logout.flags = {
+    verbose: command_1.flags.boolean({ char: 'v' }),
+};

package/lib/commands/container/pull.d.ts

@@ -0,0 +1,14 @@
+import { Command } from '@heroku-cli/command';
+export default class Pull extends Command {
+    static topic: string;
+    static description: string;
+    static usage: string;
+    static example: string;
+    static strict: boolean;
+    static flags: {
+        app: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        remote: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        verbose: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/container/pull.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const DockerHelper = require("../../lib/container/docker_helper");
+const helpers_1 = require("../../lib/container/helpers");
+const debug_1 = require("../../lib/container/debug");
+const color_1 = require("@heroku-cli/color");
+class Pull extends command_1.Command {
+    async run() {
+        const { argv, flags } = await this.parse(Pull);
+        const { verbose, app } = flags;
+        if (argv.length === 0) {
+            this.error(`Error: Requires one or more process types\n${Pull.example}`);
+        }
+        const { body: appBody } = await this.heroku.get(`/apps/${app}`);
+        (0, helpers_1.ensureContainerStack)(appBody, 'pull');
+        const herokuHost = process.env.HEROKU_HOST || 'heroku.com';
+        const registry = `registry.${herokuHost}`;
+        if (verbose) {
+            debug_1.debug.enabled = true;
+        }
+        for (const process of argv) {
+            const tag = `${registry}/${app}/${process}`;
+            core_1.ux.styledHeader(`Pulling ${process} as ${tag}`);
+            await DockerHelper.pullImage(tag);
+        }
+    }
+}
+exports.default = Pull;
+Pull.topic = 'container';
+Pull.description = 'pulls an image from an app\'s process type';
+Pull.usage = 'container:pull -a APP [-v] PROCESS_TYPE...';
+Pull.example = `
+  ${color_1.default.cmd('$ heroku container:pull web')}        # Pulls the web image from the app
+  ${color_1.default.cmd('$ heroku container:pull web worker')} # Pulls both the web and worker images from the app
+  ${color_1.default.cmd('$ heroku container:pull web:latest')} # Pulls the latest tag from the web image`;
+Pull.strict = false;
+Pull.flags = {
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+    verbose: command_1.flags.boolean({ char: 'v' }),
+};

package/lib/commands/container/push.d.ts

@@ -0,0 +1,16 @@
+import { Command } from '@heroku-cli/command';
+export default class Push extends Command {
+    static topic: string;
+    static description: string;
+    static strict: boolean;
+    static flags: {
+        app: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        verbose: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        recursive: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        arg: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        'context-path': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        remote: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    static examples: string[];
+    run(): Promise<void>;
+}

package/lib/commands/container/push.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const DockerHelper = require("../../lib/container/docker_helper");
+const helpers_1 = require("../../lib/container/helpers");
+const debug_1 = require("../../lib/container/debug");
+async function selectJobs(jobs, processTypes, recursive) {
+    let filteredJobs = {};
+    let selectedJobs = [];
+    if (Object.keys(jobs).length === 0) {
+        return selectedJobs;
+    }
+    if (recursive) {
+        if (processTypes.length > 0) {
+            filteredJobs = DockerHelper.filterByProcessType(jobs, processTypes);
+        }
+        selectedJobs = await DockerHelper.chooseJobs(filteredJobs);
+    }
+    else if (jobs.standard) {
+        jobs.standard.forEach(pj => {
+            pj.resource = pj.resource.replace(/standard$/, processTypes[0]);
+        });
+        selectedJobs = jobs.standard || [];
+    }
+    return selectedJobs;
+}
+class Push extends command_1.Command {
+    async run() {
+        const { argv: processTypes, flags } = await this.parse(Push);
+        const { verbose, app, recursive, arg, 'context-path': contextPath } = flags;
+        if (verbose) {
+            debug_1.debug.enabled = true;
+        }
+        if (processTypes.length === 0 && !recursive) {
+            core_1.ux.error('Requires either --recursive or one or more process types', { exit: 1 });
+        }
+        if (processTypes.length > 1 && !recursive) {
+            core_1.ux.error('Requires exactly one target process type, or --recursive option', { exit: 1 });
+        }
+        const { body: appBody } = await this.heroku.get(`/apps/${app}`);
+        (0, helpers_1.ensureContainerStack)(appBody, 'push');
+        const herokuHost = process.env.HEROKU_HOST || 'heroku.com';
+        const registry = `registry.${herokuHost}`;
+        const dockerfiles = DockerHelper.getDockerfiles(process.cwd(), recursive);
+        const possibleJobs = DockerHelper.getJobs(`${registry}/${app}`, dockerfiles);
+        const jobs = await selectJobs(possibleJobs, processTypes, recursive);
+        if (jobs.length === 0) {
+            core_1.ux.error('No images to push', { exit: 1 });
+        }
+        const buildArgs = (arg === undefined) ? [] : arg.split(',');
+        try {
+            for (const job of jobs) {
+                if (job.name === 'standard') {
+                    core_1.ux.styledHeader(`Building ${processTypes} (${job.dockerfile})`);
+                }
+                else {
+                    core_1.ux.styledHeader(`Building ${job.name} (${job.dockerfile})`);
+                }
+                await DockerHelper.buildImage(job.dockerfile, job.resource, buildArgs, contextPath);
+            }
+        }
+        catch (error) {
+            core_1.ux.error(`docker build exited with ${error}`, { exit: 1 });
+        }
+        try {
+            for (const job of jobs) {
+                if (job.name === 'standard') {
+                    core_1.ux.styledHeader(`Pushing ${processTypes} (${job.dockerfile})`);
+                }
+                else {
+                    core_1.ux.styledHeader(`Pushing ${job.name} (${job.dockerfile})`);
+                }
+                await DockerHelper.pushImage(job.resource);
+            }
+            const plural = jobs.length !== 1;
+            core_1.ux.log(`Your image${plural ? 's have' : ' has'} been successfully pushed. You can now release ${plural ? 'them' : 'it'} with the 'container:release' command.`);
+        }
+        catch (error) {
+            core_1.ux.error(`docker push exited with ${error}`, { exit: 1 });
+        }
+    }
+}
+exports.default = Push;
+Push.topic = 'container';
+Push.description = 'builds, then pushes Docker images to deploy your Heroku app';
+Push.strict = false;
+Push.flags = {
+    app: command_1.flags.app({ required: true }),
+    verbose: command_1.flags.boolean({ char: 'v' }),
+    recursive: command_1.flags.boolean({ char: 'R', description: 'pushes Dockerfile.<process> found in current and subdirectories' }),
+    arg: command_1.flags.string({ description: 'set build-time variables' }),
+    'context-path': command_1.flags.string({ description: 'path to use as build context (defaults to Dockerfile dir)' }),
+    remote: command_1.flags.remote({ char: 'r' }),
+};
+Push.examples = [
+    '$ heroku container:push web                          # Pushes Dockerfile to web process type',
+    '$ heroku container:push worker                       # Pushes Dockerfile to worker process type',
+    '$ heroku container:push web worker --recursive       # Pushes Dockerfile.web and Dockerfile.worker',
+    '$ heroku container:push --recursive                  # Pushes Dockerfile.*',
+    '$ heroku container:push web --arg ENV=live,HTTPS=on  # Build-time variables',
+    '$ heroku container:push --recursive --context-path . # Pushes Dockerfile.* using current dir as build context',
+];

package/lib/commands/container/release.d.ts

@@ -0,0 +1,14 @@
+import { Command } from '@heroku-cli/command';
+export default class ContainerRelease extends Command {
+    static topic: string;
+    static description: string;
+    static usage: string;
+    static example: string;
+    static strict: boolean;
+    static flags: {
+        app: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        remote: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        verbose: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/container/release.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const color_1 = require("@heroku-cli/color");
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const debug_1 = require("../../lib/container/debug");
+const streamer_1 = require("../../lib/container/streamer");
+const helpers_1 = require("../../lib/container/helpers");
+class ContainerRelease extends command_1.Command {
+    async run() {
+        const { flags, argv } = await this.parse(ContainerRelease);
+        const { app, verbose } = flags;
+        if (argv.length === 0) {
+            this.error(`Error: Requires one or more process types\n ${ContainerRelease.example}`);
+        }
+        if (verbose) {
+            debug_1.debug.enabled = true;
+        }
+        const { body: appBody } = await this.heroku.get(`/apps/${app}`);
+        (0, helpers_1.ensureContainerStack)(appBody, 'release');
+        const herokuHost = process.env.HEROKU_HOST || 'heroku.com';
+        const updateData = [];
+        for (const process of argv) {
+            const image = `${app}/${process}`;
+            const tag = 'latest';
+            const { body: imageResp } = await this.heroku.get(`/v2/${image}/manifests/${tag}`, {
+                hostname: `registry.${herokuHost}`,
+                headers: {
+                    Accept: 'application/vnd.docker.distribution.manifest.v2+json',
+                    Authorization: `Basic ${Buffer.from(`:${this.heroku.auth}`).toString('base64')}`,
+                }
+            });
+            let imageID;
+            let v1Comp;
+            switch (imageResp.schemaVersion) {
+                case 1:
+                    v1Comp = JSON.parse(imageResp.history[0].v1Compatibility);
+                    imageID = v1Comp.id;
+                    break;
+                case 2:
+                    imageID = imageResp.config.digest;
+                    break;
+            }
+            updateData.push({
+                type: process, docker_image: imageID,
+            });
+        }
+        core_1.ux.action.start(`Releasing images ${argv.join(',')} to ${app}`);
+        await this.heroku.patch(`/apps/${app}/formation`, {
+            body: { updates: updateData }, headers: {
+                Accept: 'application/vnd.heroku+json; version=3.docker-releases',
+            },
+        });
+        core_1.ux.action.stop();
+        const { body: oldReleases } = await this.heroku.get(`/apps/${app}/releases`, {
+            partial: true, headers: { Range: 'version ..; max=2, order=desc' },
+        });
+        const oldRelease = oldReleases[0];
+        const { body: updatedReleases } = await this.heroku.get(`/apps/${app}/releases`, {
+            partial: true, headers: { Range: 'version ..; max=1, order=desc' },
+        });
+        const release = updatedReleases[0];
+        if ((!oldRelease && !release) || (oldRelease && (oldRelease.id === release.id))) {
+            return;
+        }
+        if (release.status === 'failed') {
+            core_1.ux.error('Error: release command failed', { exit: 1 });
+        }
+        else if ((release.status === 'pending') && release.output_stream_url) {
+            core_1.ux.log('Running release command...');
+            await (0, streamer_1.streamer)(release.output_stream_url, process.stdout);
+            const { body: finishedRelease } = await this.heroku.request(`/apps/${app}/releases/${release.id}`);
+            if (finishedRelease.status === 'failed') {
+                core_1.ux.error('Error: release command failed', { exit: 1 });
+            }
+        }
+    }
+}
+exports.default = ContainerRelease;
+ContainerRelease.topic = 'container';
+ContainerRelease.description = 'Releases previously pushed Docker images to your Heroku app';
+ContainerRelease.usage = 'container:release';
+ContainerRelease.example = `
+  ${color_1.default.cmd('heroku container:release web')}        # Releases the previously pushed web process type
+  ${color_1.default.cmd('heroku container:release web worker')} # Releases the previously pushed web and worker process types`;
+ContainerRelease.strict = false;
+ContainerRelease.flags = {
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+    verbose: command_1.flags.boolean({ char: 'v' }),
+};

package/lib/commands/container/rm.d.ts

@@ -0,0 +1,13 @@
+import { Command } from '@heroku-cli/command';
+export default class Rm extends Command {
+    static topic: string;
+    static description: string;
+    static usage: string;
+    static example: string;
+    static strict: boolean;
+    static flags: {
+        app: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        remote: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/container/rm.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const color_1 = require("@heroku-cli/color");
+const helpers_1 = require("../../lib/container/helpers");
+class Rm extends command_1.Command {
+    async run() {
+        const { argv, flags } = await this.parse(Rm);
+        const { app } = flags;
+        if (argv.length === 0) {
+            this.error(`Error: Requires one or more process types\n${Rm.example}`);
+        }
+        const { body: appBody } = await this.heroku.get(`/apps/${app}`);
+        (0, helpers_1.ensureContainerStack)(appBody, 'rm');
+        for (const process of argv) {
+            core_1.ux.action.start(`Removing container ${process} for ${color_1.default.app(app)}`);
+            await this.heroku.patch(`/apps/${app}/formation/${process}`, {
+                headers: {
+                    Accept: 'application/vnd.heroku+json; version=3.docker-releases',
+                },
+                body: { docker_image: null },
+            });
+            core_1.ux.action.stop();
+        }
+    }
+}
+exports.default = Rm;
+Rm.topic = 'container';
+Rm.description = 'remove the process type from your app';
+Rm.usage = 'container:rm -a APP [-v] PROCESS_TYPE...';
+Rm.example = `
+  ${color_1.default.cmd('heroku container:rm web')}        # Destroys the web container
+  ${color_1.default.cmd('heroku container:rm web worker')} # Destroys the web and worker containers`;
+Rm.strict = false;
+Rm.flags = {
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};

package/lib/commands/container/run.d.ts

@@ -0,0 +1,15 @@
+import { Command } from '@heroku-cli/command';
+export default class Run extends Command {
+    static topic: string;
+    static description: string;
+    static usage: string;
+    static example: string;
+    static strict: boolean;
+    static flags: {
+        app: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        remote: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        port: import("@oclif/core/lib/interfaces").OptionFlag<number, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        verbose: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/container/run.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const DockerHelper = require("../../lib/container/docker_helper");
+const helpers_1 = require("../../lib/container/helpers");
+const debug_1 = require("../../lib/container/debug");
+const color_1 = require("@heroku-cli/color");
+class Run extends command_1.Command {
+    async run() {
+        const { argv, flags } = await this.parse(Run);
+        const { verbose, app, port } = flags;
+        if (argv.length === 0) {
+            this.error(`Error: Requires one process type\n${Run.example}`);
+        }
+        if (verbose) {
+            debug_1.debug.enabled = true;
+        }
+        const { body: appBody } = await this.heroku.get(`/apps/${app}`);
+        (0, helpers_1.ensureContainerStack)(appBody, 'run');
+        const processType = argv.shift();
+        const command = argv.join(' ');
+        const herokuHost = process.env.HEROKU_HOST || 'heroku.com';
+        const registry = `registry.${herokuHost}`;
+        const dockerfiles = DockerHelper.getDockerfiles(process.cwd(), false);
+        const possibleJobs = DockerHelper.getJobs(`${registry}/${app}`, dockerfiles);
+        let jobs = [];
+        if (possibleJobs.standard) {
+            possibleJobs.standard.forEach((pj) => {
+                pj.resource = pj.resource.replace(/standard$/, processType);
+            });
+            jobs = possibleJobs.standard || [];
+        }
+        if (jobs.length === 0) {
+            core_1.ux.error('No images to run');
+        }
+        const job = jobs[0];
+        if (command.length === 0) {
+            core_1.ux.styledHeader(`Running ${job.resource}`);
+        }
+        else {
+            core_1.ux.styledHeader(`Running '${command}' on ${job.resource}`);
+        }
+        try {
+            await DockerHelper.runImage(job.resource, command, port);
+        }
+        catch (error) {
+            core_1.ux.error(`docker run exited with ${error}`);
+        }
+    }
+}
+exports.default = Run;
+Run.topic = 'container';
+Run.description = 'builds, then runs the docker image locally';
+Run.usage = 'container:run -a APP [-v] PROCESS_TYPE...';
+Run.example = `
+  ${color_1.default.cmd('$ heroku container:pull web')}        # Pulls the web image from the app
+  ${color_1.default.cmd('$ heroku container:pull web worker')} # Pulls both the web and worker images from the app
+  ${color_1.default.cmd('$ heroku container:pull web:latest')} # Pulls the latest tag from the web image`;
+Run.strict = false;
+Run.flags = {
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+    port: command_1.flags.integer({ char: 'p', description: 'port the app will run on', default: 5000 }),
+    verbose: command_1.flags.boolean({ char: 'v' }),
+};

package/lib/commands/dashboard.d.ts

@@ -0,0 +1,7 @@
+import { Command } from '@heroku-cli/command';
+export default class Dashboard extends Command {
+    static topic: string;
+    static description: string;
+    static hidden: boolean;
+    run(): Promise<void>;
+}