heroku 9.0.0-alpha.0 → 9.0.0-alpha.2

package/lib/commands/pg/settings/log-statement.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const tsheredoc_1 = require("tsheredoc");
+const setter_1 = require("../../../lib/pg/setter");
+class LogStatement extends setter_1.PGSettingsCommand {
+    constructor() {
+        super(...arguments);
+        this.settingKey = 'log_statement';
+    }
+    convertValue(val) {
+        return val;
+    }
+    explain(setting) {
+        return setting.values[setting.value];
+    }
+}
+exports.default = LogStatement;
+LogStatement.description = (0, tsheredoc_1.default)(`
+    log_statement controls which SQL statements are logged.
+    Valid values for VALUE:
+    none - No statements are logged
+    ddl  - All data definition statements, such as CREATE, ALTER and DROP will be logged
+    mod  - Includes all statements from ddl as well as data-modifying statements such as INSERT, UPDATE, DELETE, TRUNCATE, COPY
+    all  - All statements are logged
+  `);
+LogStatement.args = {
+    database: core_1.Args.string(),
+    value: core_1.Args.string({ options: ['none', 'ddl', 'mod', 'all'] }),
+};

package/lib/commands/pg/settings/track-functions.d.ts

@@ -0,0 +1,12 @@
+import { PGSettingsCommand } from '../../../lib/pg/setter';
+import type { Setting, SettingKey } from '../../../lib/pg/types';
+export default class TrackFunctions extends PGSettingsCommand {
+    static description: string;
+    static args: {
+        database: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+        value: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+    };
+    protected settingKey: SettingKey;
+    protected convertValue(val: unknown): unknown;
+    protected explain(setting: Setting<keyof Setting<unknown>['value']>): string;
+}

package/lib/commands/pg/settings/track-functions.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const tsheredoc_1 = require("tsheredoc");
+const setter_1 = require("../../../lib/pg/setter");
+// ref: https://www.postgresql.org/docs/current/runtime-config-statistics.html#GUC-TRACK-FUNCTIONS
+class TrackFunctions extends setter_1.PGSettingsCommand {
+    constructor() {
+        super(...arguments);
+        this.settingKey = 'track_functions';
+    }
+    convertValue(val) {
+        return val;
+    }
+    explain(setting) {
+        return setting.values[setting.value];
+    }
+}
+exports.default = TrackFunctions;
+TrackFunctions.description = (0, tsheredoc_1.default)(`
+    track_functions controls tracking of function call counts and time used. Default is none.
+    Valid values for VALUE:
+    none - No functions are tracked (default)
+    pl   - Only procedural language functions are tracked
+    all  - All functions, including SQL and C language functions, are tracked. Simple SQL-language that are inlined are not tracked`);
+TrackFunctions.args = {
+    database: core_1.Args.string(),
+    value: core_1.Args.string({ options: ['none', 'pl', 'all'] }),
+};

package/lib/commands/pg/unfollow.d.ts

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

package/lib/commands/pg/unfollow.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 fetcher_1 = require("../../lib/pg/fetcher");
+const host_1 = require("../../lib/pg/host");
+const util_1 = require("../../lib/pg/util");
+const confirmCommand_1 = require("../../lib/confirmCommand");
+const tsheredoc_1 = require("tsheredoc");
+class Unfollow extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(Unfollow);
+        const { app, confirm } = flags;
+        const db = await (0, fetcher_1.getAddon)(this.heroku, app, args.database);
+        const { body: replica } = await this.heroku.get(`/client/v11/databases/${db.id}`, { hostname: (0, host_1.default)() });
+        if (!replica.following)
+            core_1.ux.error(`${color_1.default.addon(db.name)} is not a follower`);
+        const { body: configVars } = await this.heroku.get(`/apps/${app}/config-vars`);
+        const origin = (0, util_1.databaseNameFromUrl)(replica.following, configVars);
+        await (0, confirmCommand_1.default)(app, confirm, (0, tsheredoc_1.default)(`
+      Destructive action
+      ${color_1.default.addon(db.name)} will become writeable and no longer follow ${origin}. This cannot be undone.
+    `));
+        core_1.ux.action.start(`${color_1.default.addon(db.name)} unfollowing`);
+        await this.heroku.put(`/client/v11/databases/${db.id}/unfollow`, { hostname: (0, host_1.default)() });
+        core_1.ux.action.stop();
+    }
+}
+exports.default = Unfollow;
+Unfollow.topic = 'pg';
+Unfollow.description = 'stop a replica from following and make it a writeable database';
+Unfollow.flags = {
+    confirm: command_1.flags.string({ char: 'c' }),
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};
+Unfollow.args = {
+    database: core_1.Args.string({ required: true }),
+};

package/lib/commands/pg/upgrade.d.ts

@@ -0,0 +1,15 @@
+import { Command } from '@heroku-cli/command';
+export default class Upgrade extends Command {
+    static topic: string;
+    static description: string;
+    static flags: {
+        confirm: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        version: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        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: {
+        database: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/pg/upgrade.js

@@ -0,0 +1,58 @@
+"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 tsheredoc_1 = require("tsheredoc");
+const fetcher_1 = require("../../lib/pg/fetcher");
+const host_1 = require("../../lib/pg/host");
+const util_1 = require("../../lib/pg/util");
+const confirmCommand_1 = require("../../lib/confirmCommand");
+class Upgrade extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(Upgrade);
+        const { app, version, confirm } = flags;
+        const { database } = args;
+        const db = await (0, fetcher_1.getAddon)(this.heroku, app, database);
+        if ((0, util_1.legacyEssentialPlan)(db))
+            core_1.ux.error('pg:upgrade is only available for Essential-* databases and follower databases on Standard-tier and higher plans.');
+        const { body: replica } = await this.heroku.get(`/client/v11/databases/${db.id}`, { hostname: (0, host_1.default)() });
+        if (replica.following) {
+            const { body: configVars } = await this.heroku.get(`/apps/${app}/config-vars`);
+            const origin = (0, util_1.databaseNameFromUrl)(replica.following, configVars);
+            await (0, confirmCommand_1.default)(app, confirm, (0, tsheredoc_1.default)(`
+        Destructive action
+        ${color_1.default.addon(db.name)} will be upgraded to a newer PostgreSQL version, stop following ${origin}, and become writable.
+
+        This cannot be undone.
+      `));
+        }
+        else {
+            await (0, confirmCommand_1.default)(app, confirm, (0, tsheredoc_1.default)(`
+        Destructive action
+        ${color_1.default.addon(db.name)} will be upgraded to a newer PostgreSQL version.
+
+        This cannot be undone.
+      `));
+        }
+        const data = { version };
+        core_1.ux.action.start(`Starting upgrade of ${color_1.default.addon(db.name)}`);
+        await this.heroku.post(`/client/v11/databases/${db.id}/upgrade`, { hostname: (0, host_1.default)(), body: data });
+        core_1.ux.action.stop(`Use ${color_1.default.cmd('heroku pg:wait')} to track status`);
+    }
+}
+exports.default = Upgrade;
+Upgrade.topic = 'pg';
+Upgrade.description = (0, tsheredoc_1.default)(`
+    For an Essential-* plan, this command upgrades the database's PostgreSQL version. For a Standard-tier and higher plan, this command unfollows the leader database before upgrading the PostgreSQL version.
+    To upgrade to another PostgreSQL version, use pg:copy instead
+  `);
+Upgrade.flags = {
+    confirm: command_1.flags.string({ char: 'c' }),
+    version: command_1.flags.string({ char: 'v', description: 'PostgreSQL version to upgrade to' }),
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};
+Upgrade.args = {
+    database: core_1.Args.string(),
+};

package/lib/commands/pg/vacuum-stats.d.ts

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

package/lib/commands/pg/vacuum-stats.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const fetcher_1 = require("../../lib/pg/fetcher");
+const psql_1 = require("../../lib/pg/psql");
+const tsheredoc_1 = require("tsheredoc");
+class VacuumStats extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(VacuumStats);
+        const db = await (0, fetcher_1.database)(this.heroku, flags.app, args.database);
+        const query = (0, tsheredoc_1.default)(`
+      WITH table_opts AS (
+        SELECT
+          pg_class.oid, relname, nspname, array_to_string(reloptions, '') AS relopts
+        FROM
+          pg_class INNER JOIN pg_namespace ns ON relnamespace = ns.oid
+      ), vacuum_settings AS (
+        SELECT
+          oid, relname, nspname,
+          CASE
+            WHEN relopts LIKE '%autovacuum_vacuum_threshold%'
+              THEN substring(relopts, '.*autovacuum_vacuum_threshold=([0-9.]+).*')::integer
+              ELSE current_setting('autovacuum_vacuum_threshold')::integer
+            END AS autovacuum_vacuum_threshold,
+          CASE
+            WHEN relopts LIKE '%autovacuum_vacuum_scale_factor%'
+              THEN substring(relopts, '.*autovacuum_vacuum_scale_factor=([0-9.]+).*')::real
+              ELSE current_setting('autovacuum_vacuum_scale_factor')::real
+            END AS autovacuum_vacuum_scale_factor
+        FROM
+          table_opts
+      )
+      SELECT
+        vacuum_settings.nspname AS schema,
+        vacuum_settings.relname AS table,
+        to_char(psut.last_vacuum, 'YYYY-MM-DD HH24:MI') AS last_vacuum,
+        to_char(psut.last_autovacuum, 'YYYY-MM-DD HH24:MI') AS last_autovacuum,
+        to_char(pg_class.reltuples, '9G999G999G999') AS rowcount,
+        to_char(psut.n_dead_tup, '9G999G999G999') AS dead_rowcount,
+        to_char(autovacuum_vacuum_threshold
+              + (autovacuum_vacuum_scale_factor::numeric * pg_class.reltuples), '9G999G999G999') AS autovacuum_threshold,
+        CASE
+          WHEN autovacuum_vacuum_threshold + (autovacuum_vacuum_scale_factor::numeric * pg_class.reltuples) < psut.n_dead_tup
+          THEN 'yes'
+        END AS expect_autovacuum
+      FROM
+        pg_stat_user_tables psut INNER JOIN pg_class ON psut.relid = pg_class.oid
+          INNER JOIN vacuum_settings ON pg_class.oid = vacuum_settings.oid
+      ORDER BY 1
+    `);
+        const output = await (0, psql_1.exec)(db, query);
+        core_1.ux.log(output);
+    }
+}
+exports.default = VacuumStats;
+VacuumStats.topic = 'pg';
+VacuumStats.description = 'show dead rows and whether an automatic vacuum is expected to be triggered';
+VacuumStats.flags = {
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};
+VacuumStats.args = {
+    database: core_1.Args.string(),
+};

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

@@ -0,0 +1,15 @@
+import { Command } from '@heroku-cli/command';
+export default class Wait extends Command {
+    static topic: string;
+    static description: string;
+    static flags: {
+        'wait-interval': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        'no-notify': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        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: {
+        database: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/pg/wait.js

@@ -0,0 +1,79 @@
+"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("debug");
+const fetcher_1 = require("../../lib/pg/fetcher");
+const host_1 = require("../../lib/pg/host");
+const notify_1 = require("../../lib/notify");
+const wait = (ms) => new Promise(resolve => {
+    setTimeout(resolve, ms);
+});
+class Wait extends command_1.Command {
+    async run() {
+        const { flags, args } = await this.parse(Wait);
+        const { app, 'wait-interval': waitInterval } = flags;
+        const dbName = args.database;
+        const pgDebug = (0, debug_1.default)('pg');
+        const waitFor = async (db) => {
+            let interval = waitInterval && Number.parseInt(waitInterval, 10);
+            if (!interval || interval < 0)
+                interval = 5;
+            let status;
+            let waiting = false;
+            let retries = 20;
+            while (true) {
+                try {
+                    ({ body: status } = await this.heroku.get(`/client/v11/databases/${db.id}/wait_status`, { hostname: (0, host_1.default)() }));
+                }
+                catch (error) {
+                    const httpError = error;
+                    pgDebug(httpError);
+                    if (!retries || httpError.statusCode !== 404)
+                        throw httpError;
+                    retries--;
+                    status = { 'waiting?': true };
+                }
+                if (status['error?']) {
+                    (0, notify_1.default)('error', `${db.name} ${status.message}`, false);
+                    core_1.ux.error(status.message || '', { exit: 1 });
+                }
+                if (!status['waiting?']) {
+                    if (waiting) {
+                        core_1.ux.action.stop(status.message);
+                    }
+                    return;
+                }
+                if (!waiting) {
+                    waiting = true;
+                    core_1.ux.action.start(`Waiting for database ${color_1.default.yellow(db.name)}`, status.message);
+                }
+                core_1.ux.action.status = status.message;
+                await wait(interval * 1000);
+            }
+        };
+        let dbs = [];
+        if (dbName) {
+            dbs = [await (0, fetcher_1.getAddon)(this.heroku, app, dbName)];
+        }
+        else {
+            dbs = await (0, fetcher_1.all)(this.heroku, app);
+        }
+        for (const db of dbs) {
+            await waitFor(db);
+        }
+    }
+}
+exports.default = Wait;
+Wait.topic = 'pg';
+Wait.description = 'blocks until database is available';
+Wait.flags = {
+    'wait-interval': command_1.flags.string({ description: 'how frequently to poll in seconds (to avoid rate limiting)' }),
+    'no-notify': command_1.flags.boolean({ description: 'do not show OS notification' }),
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+};
+Wait.args = {
+    database: core_1.Args.string(),
+};

package/lib/commands/pipelines/connect.js

@@ -32,7 +32,7 @@ class Connect extends command_1.Command {
     }
 }
 exports.default = Connect;
-Connect.description = 'connect a github repo to an existing pipeline';
+Connect.description = 'connect a GitHub repo to an existing pipeline';
 Connect.examples = [
     '$ heroku pipelines:connect my-pipeline -r githuborg/reponame',
 ];

package/lib/commands/pipelines/diff.js

@@ -20,7 +20,7 @@ async function diff(targetApp, downstreamApp, githubToken, herokuUserAgent) {
     if (downstreamApp.hash === targetApp.hash) {
         return core_1.ux.log(`\n${color_1.default.app(targetApp.name)} is up to date with ${color_1.default.app(downstreamApp.name)}`);
     }
-    // Do the actual Github diff
+    // Do the actual GitHub diff
     try {
         const path = `${targetApp.repo}/compare/${downstreamApp.hash}...${targetApp.hash}`;
         const headers = { authorization: 'token ' + githubToken };

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

@@ -0,0 +1,15 @@
+import { Command } from '@heroku-cli/command';
+export default class Index extends Command {
+    static topic: string;
+    static description: string;
+    static strict: boolean;
+    static usage: 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>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        extended: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/ps/index.js

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const color_1 = require("@heroku-cli/color");
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const time_1 = require("../../lib/time");
+const tsheredoc_1 = require("tsheredoc");
+function getProcessNumber(s) {
+    return Number.parseInt(s.split('.', 2)[1], 10);
+}
+function uniqueValues(value, index, self) {
+    return self.indexOf(value) === index;
+}
+function byProcessNumber(a, b) {
+    return getProcessNumber(a.name) - getProcessNumber(b.name);
+}
+function byProcessName(a, b) {
+    if (a.name > b.name) {
+        return 1;
+    }
+    if (b.name > a.name) {
+        return -1;
+    }
+    return 0;
+}
+function byProcessTypeAndNumber(a, b) {
+    if (a.type > b.type) {
+        return 1;
+    }
+    if (b.type > a.type) {
+        return -1;
+    }
+    return getProcessNumber(a.name) - getProcessNumber(b.name);
+}
+function truncate(s) {
+    return s.length > 35 ? `${s.slice(0, 34)}…` : s;
+}
+function printExtended(dynos) {
+    const sortedDynos = dynos.sort(byProcessTypeAndNumber);
+    core_1.ux.table(sortedDynos, {
+        ID: { get: (dyno) => dyno.id },
+        Process: { get: (dyno) => dyno.name },
+        State: { get: (dyno) => `${dyno.state} ${(0, time_1.ago)(new Date(dyno.updated_at))}` },
+        Region: { get: (dyno) => dyno.extended ? dyno.extended.region : '' },
+        'Execution Plane': { get: (dyno) => dyno.extended ? dyno.extended.execution_plane : '' },
+        Fleet: { get: (dyno) => dyno.extended ? dyno.extended.fleet : '' },
+        Instance: { get: (dyno) => dyno.extended ? dyno.extended.instance : '' },
+        IP: { get: (dyno) => dyno.extended ? dyno.extended.ip : '' },
+        Port: { get: (dyno) => dyno.extended ? dyno.extended.port.toString() : '' },
+        AZ: { get: (dyno) => dyno.extended ? dyno.extended.az : '' },
+        Release: { get: (dyno) => dyno.release.version },
+        Command: { get: (dyno) => truncate(dyno.command) },
+        Route: { get: (dyno) => dyno.extended ? dyno.extended.route : '' },
+        Size: { get: (dyno) => dyno.size },
+    }, {
+        'no-truncate': true,
+    });
+}
+async function printAccountQuota(heroku, app, account) {
+    if (app.process_tier !== 'free' && app.process_tier !== 'eco') {
+        return;
+    }
+    if (app.owner.id !== account.id) {
+        return;
+    }
+    const { body: quota } = await heroku.request(`/accounts/${account.id}/actions/get-quota`, { headers: { Accept: 'application/vnd.heroku+json; version=3.account-quotas' } }).catch(() => {
+        return { body: null };
+    });
+    if (!quota || (quota.id && quota.id === 'not_found')) {
+        return;
+    }
+    const remaining = (quota.account_quota === 0) ? 0 : quota.account_quota - quota.quota_used;
+    const percentage = (quota.account_quota === 0) ? 0 : Math.floor(remaining / quota.account_quota * 100);
+    const remainingMinutes = remaining / 60;
+    const hours = Math.floor(remainingMinutes / 60);
+    const minutes = Math.floor(remainingMinutes % 60);
+    const appQuota = quota.apps.find(appQuota => {
+        return appQuota.app_uuid === app.id;
+    });
+    const appQuotaUsed = appQuota ? appQuota.quota_used / 60 : 0;
+    const appPercentage = appQuota ? Math.floor(appQuota.quota_used * 100 / quota.account_quota) : 0;
+    const appHours = Math.floor(appQuotaUsed / 60);
+    const appMinutes = Math.floor(appQuotaUsed % 60);
+    if (app.process_tier === 'eco') {
+        core_1.ux.log(`Eco dyno hours quota remaining this month: ${hours}h ${minutes}m (${percentage}%)`);
+        core_1.ux.log(`Eco dyno usage for this app: ${appHours}h ${appMinutes}m (${appPercentage}%)`);
+        core_1.ux.log('For more information on Eco dyno hours, see:');
+        core_1.ux.log('https://devcenter.heroku.com/articles/eco-dyno-hours');
+        core_1.ux.log();
+    }
+    if (app.process_tier === 'free') {
+        core_1.ux.log(`Free dyno hours quota remaining this month: ${hours}h ${minutes}m (${percentage}%)`);
+        core_1.ux.log(`Free dyno usage for this app: ${appHours}h ${appMinutes}m (${appPercentage}%)`);
+        core_1.ux.log('For more information on dyno sleeping and how to upgrade, see:');
+        core_1.ux.log('https://devcenter.heroku.com/articles/dyno-sleeping');
+        core_1.ux.log();
+    }
+}
+function decorateOneOffDyno(dyno) {
+    const since = (0, time_1.ago)(new Date(dyno.updated_at));
+    // eslint-disable-next-line unicorn/explicit-length-check
+    const size = dyno.size || '1X';
+    const state = dyno.state === 'up' ? color_1.default.green(dyno.state) : color_1.default.yellow(dyno.state);
+    return `${dyno.name} (${color_1.default.cyan(size)}): ${state} ${color_1.default.dim(since)}: ${dyno.command}`;
+}
+function decorateCommandDyno(dyno) {
+    const since = (0, time_1.ago)(new Date(dyno.updated_at));
+    const state = dyno.state === 'up' ? color_1.default.green(dyno.state) : color_1.default.yellow(dyno.state);
+    return `${dyno.name}: ${state} ${color_1.default.dim(since)}`;
+}
+function printDynos(dynos) {
+    const oneOffs = dynos.filter(d => d.type === 'run').sort(byProcessNumber);
+    const commands = dynos.filter(d => d.type !== 'run').map(d => d.command).filter(uniqueValues);
+    // Print one-off dynos
+    if (oneOffs.length > 0) {
+        core_1.ux.styledHeader(`${color_1.default.green('run')}: one-off processes (${color_1.default.yellow(oneOffs.length.toString())})`);
+        oneOffs.forEach(dyno => core_1.ux.log(decorateOneOffDyno(dyno)));
+        core_1.ux.log();
+    }
+    // Print dynos grouped by command
+    commands.forEach(function (command) {
+        const commandDynos = dynos.filter(d => d.command === command).sort(byProcessNumber);
+        const type = commandDynos[0].type;
+        // eslint-disable-next-line unicorn/explicit-length-check
+        const size = commandDynos[0].size || '1X';
+        core_1.ux.styledHeader(`${color_1.default.green(type)} (${color_1.default.cyan(size)}): ${command} (${color_1.default.yellow(commandDynos.length.toString())})`);
+        for (const dyno of commandDynos)
+            core_1.ux.log(decorateCommandDyno(dyno));
+        core_1.ux.log();
+    });
+}
+class Index extends command_1.Command {
+    async run() {
+        const _a = await this.parse(Index), { flags } = _a, restParse = tslib_1.__rest(_a, ["flags"]);
+        const { app, json, extended } = flags;
+        const types = restParse.argv;
+        const suffix = extended ? '?extended=true' : ''; // read previous comment, including this on the request doesn't make any difference.
+        const promises = {
+            dynos: this.heroku.request(`/apps/${app}/dynos${suffix}`),
+            appInfo: this.heroku.request(`/apps/${app}`, { headers: { Accept: 'application/vnd.heroku+json; version=3.process-tier' } }),
+            accountInfo: this.heroku.request('/account'),
+        };
+        const [{ body: dynos }, { body: appInfo }, { body: accountInfo }] = await Promise.all([promises.dynos, promises.appInfo, promises.accountInfo]);
+        const shielded = appInfo.space && appInfo.space.shield;
+        if (shielded) {
+            dynos.forEach(d => {
+                d.size = d.size.replace('Private-', 'Shield-');
+            });
+        }
+        let selectedDynos = dynos;
+        if (types.length > 0) {
+            selectedDynos = selectedDynos.filter(dyno => types.find((t) => dyno.type === t));
+            types.forEach(t => {
+                if (!selectedDynos.some(d => d.type === t)) {
+                    throw new Error(`No ${color_1.default.cyan(t)} dynos on ${color_1.default.magenta(app)}`);
+                }
+            });
+        }
+        selectedDynos = selectedDynos.sort(byProcessName);
+        if (json)
+            core_1.ux.styledJSON(selectedDynos);
+        else if (extended)
+            printExtended(selectedDynos);
+        else {
+            await printAccountQuota(this.heroku, appInfo, accountInfo);
+            if (selectedDynos.length === 0)
+                core_1.ux.log(`No dynos on ${color_1.default.magenta(app)}`);
+            else
+                printDynos(selectedDynos);
+        }
+    }
+}
+exports.default = Index;
+Index.topic = 'ps';
+Index.description = 'list dynos for an app';
+Index.strict = false;
+Index.usage = 'ps [TYPE [TYPE ...]]';
+Index.examples = [(0, tsheredoc_1.default) `
+    $ heroku ps
+    === run: one-off dyno
+    run.1: up for 5m: bash
+    === web: bundle exec thin start -p $PORT
+    web.1: created for 30s
+  `, (0, tsheredoc_1.default) `
+    $ heroku ps run # specifying types
+    === run: one-off dyno
+    run.1: up for 5m: bash
+  `];
+Index.flags = {
+    app: command_1.flags.app({ required: true }),
+    remote: command_1.flags.remote(),
+    json: command_1.flags.boolean({ description: 'display as json' }),
+    extended: command_1.flags.boolean({ char: 'x', hidden: true }), // should be removed? Platform API doesn't serialize extended attributes even if the query param `extended=true` is sent.
+};

package/lib/commands/ps/restart.d.ts

@@ -0,0 +1,17 @@
+import { Command } from '@heroku-cli/command';
+export default class Restart extends Command {
+    static description: string;
+    static topic: string;
+    static aliases: string[];
+    static hiddenAliases: string[];
+    static examples: string[];
+    static help: string;
+    static args: {
+        dyno: 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>;
+}