heroku 8.1.9 → 8.2.0-beta.0

package/lib/commands/domains/info.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+class DomainsInfo extends command_1.Command {
+    async run() {
+        const { args, flags } = await this.parse(DomainsInfo);
+        const { body: res } = await this.heroku.get(`/apps/${flags.app}/domains/${args.hostname}`);
+        const domain = Object.assign(Object.assign({}, res), { app: res.app && res.app.name });
+        core_1.ux.styledObject(domain);
+    }
+}
+exports.default = DomainsInfo;
+DomainsInfo.description = 'show detailed information for a domain on an app';
+DomainsInfo.examples = [
+    '$ heroku domains:info www.example.com',
+];
+DomainsInfo.flags = {
+    help: command_1.flags.help({ char: 'h' }),
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};
+DomainsInfo.args = {
+    hostname: core_1.Args.string({ required: true }),
+};

package/lib/commands/domains/remove.d.ts

@@ -0,0 +1,14 @@
+import { Command } from '@heroku-cli/command';
+export default class DomainsRemove extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        help: import("@oclif/core/lib/interfaces").BooleanFlag<void>;
+        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>;
+    };
+    static args: {
+        hostname: import("@oclif/core/lib/interfaces/parser").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/domains/remove.js

@@ -0,0 +1,26 @@
+"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 spinner_1 = require("@oclif/core/lib/cli-ux/action/spinner");
+class DomainsRemove extends command_1.Command {
+    async run() {
+        const { args, flags } = await this.parse(DomainsRemove);
+        const action = new spinner_1.default();
+        action.start(`Removing ${color_1.color.green(args.hostname)} from ${color_1.color.app(flags.app)}`);
+        await this.heroku.delete(`/apps/${flags.app}/domains/${args.hostname}`);
+        action.stop();
+    }
+}
+exports.default = DomainsRemove;
+DomainsRemove.description = 'remove a domain from an app';
+DomainsRemove.examples = ['heroku domains:remove www.example.com'];
+DomainsRemove.flags = {
+    help: command_1.flags.help({ char: 'h' }),
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};
+DomainsRemove.args = {
+    hostname: core_1.Args.string({ required: true }),
+};

package/lib/commands/domains/update.d.ts

@@ -0,0 +1,15 @@
+import { Command } from '@heroku-cli/command';
+export default class DomainsUpdate extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        help: import("@oclif/core/lib/interfaces").BooleanFlag<void>;
+        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>;
+        cert: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    static args: {
+        hostname: import("@oclif/core/lib/interfaces/parser").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/domains/update.js

@@ -0,0 +1,40 @@
+"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 spinner_1 = require("@oclif/core/lib/cli-ux/action/spinner");
+class DomainsUpdate extends command_1.Command {
+    async run() {
+        const { args, flags } = await this.parse(DomainsUpdate);
+        const { hostname } = args;
+        const action = new spinner_1.default();
+        try {
+            action.start(`Updating ${color_1.color.cyan(hostname)} to use ${color_1.color.cyan(flags.cert)} certificate`);
+            await this.heroku.patch(`/apps/${flags.app}/domains/${hostname}`, {
+                body: { sni_endpoint: flags.cert },
+            });
+        }
+        catch (error) {
+            core_1.ux.error(error);
+        }
+        finally {
+            action.stop();
+        }
+    }
+}
+exports.default = DomainsUpdate;
+DomainsUpdate.description = 'update a domain to use a different SSL certificate on an app';
+DomainsUpdate.examples = ['heroku domains:update www.example.com --cert mycert'];
+DomainsUpdate.flags = {
+    help: command_1.flags.help({ char: 'h' }),
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+    cert: command_1.flags.string({
+        required: true,
+        description: 'the name or id of the certificate you want to use for this domain',
+    }),
+};
+DomainsUpdate.args = {
+    hostname: core_1.Args.string({ required: true }),
+};

package/lib/commands/domains/wait.d.ts

@@ -0,0 +1,13 @@
+import { Command } from '@heroku-cli/command';
+export default class DomainsWait extends Command {
+    static description: string;
+    static flags: {
+        help: import("@oclif/core/lib/interfaces").BooleanFlag<void>;
+        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>;
+    };
+    static args: {
+        hostname: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/domains/wait.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const wait_for_domain_1 = require("../../lib/domains/wait-for-domain");
+class DomainsWait extends command_1.Command {
+    async run() {
+        const { args, flags } = await this.parse(DomainsWait);
+        let domains;
+        if (args.hostname) {
+            const { body: domain } = await this.heroku.get(`/apps/${flags.app}/domains/${args.hostname}`);
+            domains = [domain];
+        }
+        else {
+            const { body: apiDomains } = await this.heroku.get(`/apps/${flags.app}/domains`);
+            domains = apiDomains.filter(domain => domain.status === 'pending');
+        }
+        for (const domain of domains) {
+            await (0, wait_for_domain_1.default)(flags.app, this.heroku, domain);
+        }
+    }
+}
+exports.default = DomainsWait;
+DomainsWait.description = 'wait for domain to be active for an app';
+DomainsWait.flags = {
+    help: command_1.flags.help({ char: 'h' }),
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};
+DomainsWait.args = {
+    hostname: core_1.Args.string(),
+};

package/lib/commands/git/clone.d.ts

@@ -0,0 +1,13 @@
+import { Command } from '@heroku-cli/command';
+export declare class GitClone extends Command {
+    static description: string;
+    static example: string;
+    static args: {
+        DIRECTORY: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+    };
+    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/git/clone.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitClone = void 0;
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const git_1 = require("../../lib/git/git");
+class GitClone extends command_1.Command {
+    async run() {
+        const git = new git_1.default();
+        const { flags, args } = await this.parse(GitClone);
+        const { body: app } = await this.heroku.get(`/apps/${flags.app}`);
+        const directory = args.DIRECTORY || app.name;
+        const remote = flags.remote || 'heroku';
+        await git.spawn(['clone', '-o', remote, git.url(app.name), directory]);
+    }
+}
+exports.GitClone = GitClone;
+GitClone.description = 'clones a heroku app to your local machine at DIRECTORY (defaults to app name)';
+GitClone.example = `$ heroku git:clone -a example
+Cloning into 'example'...
+remote: Counting objects: 42, done.
+...`;
+GitClone.args = {
+    DIRECTORY: core_1.Args.string({ optional: true, description: 'where to clone the app' }),
+};
+GitClone.flags = {
+    app: command_1.flags.string({ char: 'a', env: 'HEROKU_APP', required: true, description: 'the Heroku app to use' }),
+    remote: command_1.flags.string({ char: 'r', description: 'the git remote to create, default "heroku"' }),
+};

package/lib/commands/git/credentials.d.ts

@@ -0,0 +1,9 @@
+import { Command } from '@heroku-cli/command';
+export declare class GitCredentials extends Command {
+    static hidden: boolean;
+    static description: string;
+    static args: {
+        command: import("@oclif/core/lib/interfaces/parser").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/git/credentials.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitCredentials = void 0;
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+class GitCredentials extends command_1.Command {
+    async run() {
+        const { args } = await this.parse(GitCredentials);
+        switch (args.command) {
+            case 'get':
+                if (!this.heroku.auth)
+                    throw new Error('not logged in');
+                this.log(`protocol=https
+host=git.heroku.com
+username=heroku
+password=${this.heroku.auth}`);
+                break;
+            case 'erase':
+            case 'store':
+                // ignore
+                break;
+            default:
+                throw new Error(`unknown command: ${args.command}`);
+        }
+    }
+}
+exports.GitCredentials = GitCredentials;
+GitCredentials.hidden = true;
+GitCredentials.description = 'internal command for git-credentials';
+GitCredentials.args = {
+    command: core_1.Args.string({ required: true }),
+};

package/lib/commands/git/remote.d.ts

@@ -0,0 +1,11 @@
+import { Command } from '@heroku-cli/command';
+export declare class GitRemote extends Command {
+    static description: string;
+    static example: string;
+    static flags: {
+        app: 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 strict: boolean;
+    run(): Promise<void>;
+}

package/lib/commands/git/remote.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitRemote = void 0;
+const color_1 = require("@heroku-cli/color");
+const command_1 = require("@heroku-cli/command");
+const git_1 = require("../../lib/git/git");
+class GitRemote extends command_1.Command {
+    async run() {
+        const parsed = await this.parse(GitRemote);
+        const { flags } = parsed;
+        const argv = parsed.argv;
+        const git = new git_1.default();
+        const appName = flags.app || argv.shift() || process.env.HEROKU_APP;
+        if (!appName) {
+            this.error('Specify an app with --app');
+        }
+        const { body: app } = await this.heroku.get(`/apps/${appName}`);
+        const remote = flags.remote || (await git.remoteFromGitConfig()) || 'heroku';
+        const remotes = await git.exec(['remote']);
+        const url = git.url(app.name);
+        if (remotes.split('\n').includes(remote)) {
+            await git.exec(['remote', 'set-url', remote, url].concat(argv));
+        }
+        else {
+            await git.exec(['remote', 'add', remote, url].concat(argv));
+        }
+        const newRemote = await git.remoteUrl(remote);
+        this.log(`set git remote ${color_1.default.cyan(remote)} to ${color_1.default.cyan(newRemote)}`);
+    }
+}
+exports.GitRemote = GitRemote;
+GitRemote.description = `adds a git remote to an app repo
+extra arguments will be passed to git remote add
+`;
+GitRemote.example = `# set git remote heroku to https://git.heroku.com/example.git
+    $ heroku git:remote -a example
+
+    # set git remote heroku-staging to https://git.heroku.com/example.git
+    $ heroku git:remote --remote heroku-staging -a example`;
+GitRemote.flags = {
+    app: command_1.flags.string({ char: 'a', description: 'the Heroku app to use' }),
+    remote: command_1.flags.string({ char: 'r', description: 'the git remote to create' }),
+};
+GitRemote.strict = false;

package/lib/commands/labs/disable.d.ts

@@ -0,0 +1,11 @@
+import { Command } from '@heroku-cli/command';
+import { FlagInput } from '@oclif/core/lib/interfaces/parser';
+export default class LabsDisable extends Command {
+    static description: string;
+    static args: {
+        feature: import("@oclif/core/lib/interfaces/parser").Arg<string, Record<string, unknown>>;
+    };
+    static flags: FlagInput;
+    run(): Promise<void>;
+    disableFeature(feature: string, app?: string): Promise<any>;
+}

package/lib/commands/labs/disable.js

@@ -0,0 +1,65 @@
+"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 SecurityExceptionFeatures = {
+    'spaces-strict-tls': {
+        async prompt(app) {
+            core_1.ux.warn('Insecure Action');
+            const name = await core_1.ux.prompt(`You are enabling an older security protocol, TLS 1.0, which some organizations may not deem secure.
+To proceed, type ${app} or re-run this command with --confirm ${app}`);
+            return name;
+        },
+    },
+};
+class LabsDisable extends command_1.Command {
+    async run() {
+        const { args, flags } = await this.parse(LabsDisable);
+        const feature = args.feature;
+        let request;
+        let target;
+        if (SecurityExceptionFeatures[feature]) {
+            if (flags.confirm !== flags.app) {
+                const prompt = SecurityExceptionFeatures[feature].prompt;
+                const confirm = await prompt(flags.app);
+                if (confirm !== flags.app) {
+                    this.error('Confirmation name did not match app name. Try again.');
+                }
+            }
+        }
+        try {
+            await this.heroku.get(`/account/features/${feature}`);
+            request = this.disableFeature(feature);
+            target = (await this.heroku.get('/account')).body.email;
+        }
+        catch (error) {
+            if (error.http.statusCode !== 404)
+                throw error;
+            // might be an app feature
+            if (!flags.app)
+                throw error;
+            await this.heroku.get(`/apps/${flags.app}/features/${feature}`);
+            request = this.disableFeature(feature, flags.app);
+            target = flags.app;
+        }
+        core_1.ux.action.start(`Disabling ${color_1.default.green(feature)} for ${color_1.default.cyan(target)}`);
+        await request;
+        core_1.ux.action.stop();
+    }
+    disableFeature(feature, app) {
+        return this.heroku.patch(app ? `/apps/${app}/features/${feature}` : `/account/features/${feature}`, {
+            body: { enabled: false },
+        });
+    }
+}
+exports.default = LabsDisable;
+LabsDisable.description = 'disables an experimental feature';
+LabsDisable.args = {
+    feature: core_1.Args.string({ required: true }),
+};
+LabsDisable.flags = {
+    app: command_1.flags.app(),
+    remote: command_1.flags.remote(),
+    confirm: command_1.flags.string({ required: false }),
+};

package/lib/commands/local/index.d.ts

@@ -0,0 +1,17 @@
+import { Command } from '@oclif/core';
+export default class Index extends Command {
+    static description: string;
+    static aliases: string[];
+    static args: {
+        processname: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static examples: string[];
+    static flags: {
+        procfile: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        env: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        port: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        restart: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        concurrency: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/local/index.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const completions_1 = require("@heroku-cli/command/lib/completions");
+const core_1 = require("@oclif/core");
+const fork_foreman_1 = require("../../lib/local/fork-foreman");
+// eslint-disable-next-line node/no-missing-require
+const Procfile = require('../../lib/local/load-foreman-procfile');
+class Index extends core_1.Command {
+    async run() {
+        const execArgv = ['start'];
+        const { args, flags } = await this.parse(Index);
+        if (flags.restart) {
+            this.error('--restart is no longer available\nUse forego instead: https://github.com/ddollar/forego');
+        }
+        if (flags.concurrency) {
+            this.error('--concurrency is no longer available\nUse forego instead: https://github.com/ddollar/forego');
+        }
+        if (flags.procfile)
+            execArgv.push('--procfile', flags.procfile);
+        if (flags.env)
+            execArgv.push('--env', flags.env);
+        if (flags.port)
+            execArgv.push('--port', flags.port);
+        if (args.processname) {
+            execArgv.push(args.processname);
+        }
+        else {
+            const procfile = flags.procfile || 'Procfile';
+            const procHash = Procfile.loadProc(procfile);
+            const processes = Object.keys(procHash).filter(x => x !== 'release');
+            execArgv.push(processes.join(','));
+        }
+        await (0, fork_foreman_1.fork)(execArgv);
+    }
+}
+exports.default = Index;
+// \n splits the description between the title shown in the help
+// and the DESCRIPTION section shown in the help
+Index.description = 'run heroku app locally\nStart the application specified by a Procfile (defaults to ./Procfile)';
+Index.aliases = ['local:start'];
+Index.args = {
+    processname: core_1.Args.string({ required: false }),
+};
+Index.examples = [
+    `$ heroku local
+$ heroku local web
+$ heroku local web=2
+$ heroku local web=1,worker=2`,
+];
+Index.flags = {
+    procfile: core_1.Flags.string({
+        char: 'f',
+        description: 'use a different Procfile',
+        completion: completions_1.FileCompletion,
+    }),
+    env: core_1.Flags.string({
+        char: 'e',
+        description: 'location of env file (defaults to .env)',
+        completion: completions_1.FileCompletion,
+    }),
+    port: core_1.Flags.string({
+        char: 'p',
+        description: 'port to listen on',
+    }),
+    restart: core_1.Flags.boolean({
+        char: 'r',
+        description: 'restart process if it dies',
+        hidden: true,
+    }),
+    concurrency: core_1.Flags.string({
+        char: 'c',
+        description: 'number of processes to start',
+        hidden: true,
+    }),
+};

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

@@ -0,0 +1,11 @@
+import { Command } from '@oclif/core';
+export default class Run extends Command {
+    static description: string;
+    static examples: string[];
+    static strict: boolean;
+    static flags: {
+        env: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        port: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/local/run.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const completions_1 = require("@heroku-cli/command/lib/completions");
+const core_1 = require("@oclif/core");
+const fork_foreman_1 = require("../../lib/local/fork-foreman");
+class Run extends core_1.Command {
+    async run() {
+        const execArgv = ['run'];
+        const { argv, flags } = await this.parse(Run);
+        if (argv.length === 0) {
+            const errorMessage = 'Usage: heroku local:run [COMMAND]\nMust specify command to run';
+            this.error(errorMessage, { exit: -1 });
+        }
+        if (flags.env)
+            execArgv.push('--env', flags.env);
+        if (flags.port)
+            execArgv.push('--port', flags.port);
+        execArgv.push('--'); // disable node-foreman flag parsing
+        execArgv.push(...argv); // eslint-disable-line unicorn/no-array-push-push
+        await (0, fork_foreman_1.fork)(execArgv);
+    }
+}
+exports.default = Run;
+Run.description = 'run a one-off command';
+Run.examples = [
+    '$ heroku local:run bin/migrate',
+];
+Run.strict = false;
+Run.flags = {
+    env: core_1.Flags.string({
+        char: 'e',
+        completion: completions_1.FileCompletion,
+    }),
+    port: core_1.Flags.string({
+        char: 'p',
+        default: '5001',
+    }),
+};

package/lib/commands/local/version.d.ts

@@ -0,0 +1,5 @@
+import { Command } from '@oclif/core';
+export default class Version extends Command {
+    static description: string;
+    run(): Promise<void>;
+}

package/lib/commands/local/version.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const fork_foreman_1 = require("../../lib/local/fork-foreman");
+class Version extends core_1.Command {
+    async run() {
+        await this.parse(Version);
+        const execArgv = ['--version'];
+        await (0, fork_foreman_1.fork)(execArgv);
+    }
+}
+exports.default = Version;
+Version.description = 'display node-foreman version';

package/lib/commands/logs.d.ts

@@ -0,0 +1,16 @@
+import { Command } from '@heroku-cli/command';
+export default class Logs extends Command {
+    static description: string;
+    static examples: string[];
+    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>;
+        num: import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        ps: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        dyno: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        source: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        tail: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'force-colors': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/logs.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+// tslint:disable:file-name-casing
+const color_1 = require("@heroku-cli/color");
+const command_1 = require("@heroku-cli/command");
+const completions_1 = require("@heroku-cli/command/lib/completions");
+const log_displayer_1 = require("../lib/run/log-displayer");
+class Logs extends command_1.Command {
+    async run() {
+        const { flags } = await this.parse(Logs);
+        color_1.default.enabled = flags['force-colors'] || color_1.default.enabled;
+        await (0, log_displayer_1.default)(this.heroku, {
+            app: flags.app,
+            // @ts-ignore
+            dyno: flags.dyno || flags.ps,
+            lines: flags.num || 100,
+            tail: flags.tail,
+            source: flags.source,
+        });
+    }
+}
+exports.default = Logs;
+Logs.description = `display recent log output
+disable colors with --no-color, HEROKU_LOGS_COLOR=0, or HEROKU_COLOR=0`;
+Logs.examples = [
+    '$ heroku logs --app=my-app',
+    '$ heroku logs --num=50',
+    '$ heroku logs --dyno=web --app=my-app',
+    '$ heroku logs --app=my-app --tail',
+];
+Logs.flags = {
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+    num: command_1.flags.integer({ char: 'n', description: 'number of lines to display' }),
+    ps: command_1.flags.string({ char: 'p', description: 'hidden alias for dyno', hidden: true }),
+    dyno: command_1.flags.string({
+        char: 'd',
+        description: 'only show output from this dyno type (such as "web" or "worker")',
+        completion: completions_1.ProcessTypeCompletion,
+    }),
+    source: command_1.flags.string({ char: 's', description: 'only show output from this source (such as "app" or "heroku")' }),
+    tail: command_1.flags.boolean({ char: 't', description: 'continually stream logs' }),
+    'force-colors': command_1.flags.boolean({ description: 'force use of colors (even on non-tty output)' }),
+};

package/lib/commands/pipelines/add.d.ts

@@ -0,0 +1,14 @@
+import { Command } from '@heroku-cli/command';
+export default class PipelinesAdd extends Command {
+    static description: string;
+    static examples: string[];
+    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>;
+        stage: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    static args: {
+        pipeline: import("@oclif/core/lib/interfaces/parser").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}