@heroku/heroku-cli-util 9.0.2 → 10.0.0-beta.0

package/dist/index.d.ts

@@ -1,17 +1,16 @@
-import { AmbiguousError } from './types/errors/ambiguous';
-import { NotFound } from './types/errors/not-found';
-import { AddOnAttachmentWithConfigVarsAndPlan, AddOnWithRelatedData, Link } from './types/pg/data-api';
-import { ConnectionDetails, ConnectionDetailsWithAttachment, TunnelConfig } from './types/pg/tunnel';
-import { getDatabase } from './utils/pg/databases';
-import getHost from './utils/pg/host';
-import { exec } from './utils/pg/psql';
-import { confirm } from './ux/confirm';
-import { prompt } from './ux/prompt';
-import { styledHeader } from './ux/styled-header';
-import { styledJSON } from './ux/styled-json';
-import { styledObject } from './ux/styled-object';
-import { table } from './ux/table';
-import { wait } from './ux/wait';
+import { AmbiguousError } from './types/errors/ambiguous.js';
+import { NotFound } from './types/errors/not-found.js';
+import { AddOnAttachmentWithConfigVarsAndPlan, AddOnWithRelatedData, Link } from './types/pg/data-api.js';
+import { ConnectionDetails, ConnectionDetailsWithAttachment, TunnelConfig } from './types/pg/tunnel.js';
+import { getDatabase } from './utils/pg/databases.js';
+import getHost from './utils/pg/host.js';
+import { exec } from './utils/pg/psql.js';
+import { prompt } from './ux/prompt.js';
+import { styledHeader } from './ux/styled-header.js';
+import { styledJSON } from './ux/styled-json.js';
+import { styledObject } from './ux/styled-object.js';
+import { table } from './ux/table.js';
+import { wait } from './ux/wait.js';
 export declare const types: {
     errors: {
         AmbiguousError: typeof AmbiguousError;
@@ -36,7 +35,7 @@ export declare const utils: {
     };
 };
 export declare const hux: {
-    confirm: typeof confirm;
+    confirm: (message: string, { defaultAnswer, ms, }?: import("./ux/confirm.js").PromptInputs<boolean>) => Promise<boolean>;
     prompt: typeof prompt;
     styledHeader: typeof styledHeader;
     styledJSON: typeof styledJSON;

package/dist/index.js

@@ -1,22 +1,19 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.hux = exports.utils = exports.types = void 0;
-const ambiguous_1 = require("./types/errors/ambiguous");
-const not_found_1 = require("./types/errors/not-found");
-const databases_1 = require("./utils/pg/databases");
-const host_1 = require("./utils/pg/host");
-const psql_1 = require("./utils/pg/psql");
-const confirm_1 = require("./ux/confirm");
-const prompt_1 = require("./ux/prompt");
-const styled_header_1 = require("./ux/styled-header");
-const styled_json_1 = require("./ux/styled-json");
-const styled_object_1 = require("./ux/styled-object");
-const table_1 = require("./ux/table");
-const wait_1 = require("./ux/wait");
-exports.types = {
+import { AmbiguousError } from './types/errors/ambiguous.js';
+import { NotFound } from './types/errors/not-found.js';
+import { getDatabase } from './utils/pg/databases.js';
+import getHost from './utils/pg/host.js';
+import { exec } from './utils/pg/psql.js';
+import { confirm } from './ux/confirm.js';
+import { prompt } from './ux/prompt.js';
+import { styledHeader } from './ux/styled-header.js';
+import { styledJSON } from './ux/styled-json.js';
+import { styledObject } from './ux/styled-object.js';
+import { table } from './ux/table.js';
+import { wait } from './ux/wait.js';
+export const types = {
     errors: {
-        AmbiguousError: ambiguous_1.AmbiguousError,
-        NotFound: not_found_1.NotFound,
+        AmbiguousError,
+        NotFound,
     },
     pg: {
         AddOnAttachmentWithConfigVarsAndPlan: {},
@@ -27,21 +24,21 @@ exports.types = {
         TunnelConfig: {},
     },
 };
-exports.utils = {
+export const utils = {
     pg: {
-        databases: databases_1.getDatabase,
-        host: host_1.default,
+        databases: getDatabase,
+        host: getHost,
         psql: {
-            exec: psql_1.exec,
+            exec,
         },
     },
 };
-exports.hux = {
-    confirm: confirm_1.confirm,
-    prompt: prompt_1.prompt,
-    styledHeader: styled_header_1.styledHeader,
-    styledJSON: styled_json_1.styledJSON,
-    styledObject: styled_object_1.styledObject,
-    table: table_1.table,
-    wait: wait_1.wait,
+export const hux = {
+    confirm,
+    prompt,
+    styledHeader,
+    styledJSON,
+    styledObject,
+    table,
+    wait,
 };

package/dist/types/errors/ambiguous.js

@@ -1,14 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AmbiguousError = void 0;
-class AmbiguousError extends Error {
+export class AmbiguousError extends Error {
+    matches;
+    type;
+    body;
+    message;
+    statusCode = 422;
     constructor(matches, type) {
         super();
         this.matches = matches;
         this.type = type;
-        this.body = { id: 'multiple_matches', message: this.message };
-        this.statusCode = 422;
         this.message = `Ambiguous identifier; multiple matching add-ons found: ${matches.map(match => match.name).join(', ')}.`;
+        this.body = { id: 'multiple_matches', message: this.message };
     }
 }
-exports.AmbiguousError = AmbiguousError;

package/dist/types/errors/not-found.js

@@ -1,12 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NotFound = void 0;
-class NotFound extends Error {
-    constructor() {
-        super(...arguments);
-        this.id = 'not_found';
-        this.message = 'Couldn\'t find that addon.';
-        this.statusCode = 404;
-    }
+export class NotFound extends Error {
+    id = 'not_found';
+    message = 'Couldn\'t find that addon.';
+    statusCode = 404;
 }
-exports.NotFound = NotFound;

package/dist/types/pg/data-api.js

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

package/dist/types/pg/tunnel.d.ts

@@ -1,7 +1,7 @@
 import type { AddOnAttachment } from '@heroku-cli/schema';
 import { Server } from 'node:net';
 import * as createTunnel from 'tunnel-ssh';
-import type { AddOnAttachmentWithConfigVarsAndPlan } from './data-api';
+import type { AddOnAttachmentWithConfigVarsAndPlan } from './data-api.js';
 export type ConnectionDetails = {
     _tunnel?: Server;
     bastionHost?: string;

package/dist/types/pg/tunnel.js

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

package/dist/utils/addons/resolve.d.ts

@@ -1,6 +1,6 @@
 import type { APIClient } from '@heroku-cli/command';
 import type { AddOnAttachment } from '@heroku-cli/schema';
-import type { AddOnAttachmentWithConfigVarsAndPlan } from '../../types/pg/data-api';
+import type { AddOnAttachmentWithConfigVarsAndPlan } from '../../types/pg/data-api.js';
 export declare const appAttachment: (heroku: APIClient, app: string | undefined, id: string, options?: {
     addon_service?: string;
     namespace?: string;

package/dist/utils/addons/resolve.js

@@ -1,16 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.appAttachment = void 0;
-const ambiguous_1 = require("../../types/errors/ambiguous");
-const not_found_1 = require("../../types/errors/not-found");
-const appAttachment = async (heroku, app, id, options = {}) => {
+import { AmbiguousError } from '../../types/errors/ambiguous.js';
+import { NotFound } from '../../types/errors/not-found.js';
+export const appAttachment = async (heroku, app, id, options = {}) => {
     const result = await heroku.post('/actions/addon-attachments/resolve', {
         // eslint-disable-next-line camelcase
         body: { addon_attachment: id, addon_service: options.addon_service, app }, headers: attachmentHeaders,
     });
     return singularize('addon_attachment', options.namespace)(result.body);
 };
-exports.appAttachment = appAttachment;
 const attachmentHeaders = {
     Accept: 'application/vnd.heroku+json; version=3.sdk',
     'Accept-Inclusion': 'addon:plan,config_vars',
@@ -26,13 +22,13 @@ function singularize(type, namespace) {
         }
         switch (matches.length) {
             case 0: {
-                throw new not_found_1.NotFound();
+                throw new NotFound();
             }
             case 1: {
                 return matches[0];
             }
             default: {
-                throw new ambiguous_1.AmbiguousError(matches, type !== null && type !== void 0 ? type : '');
+                throw new AmbiguousError(matches, type ?? '');
             }
         }
     };

package/dist/utils/pg/bastion.d.ts

@@ -1,8 +1,8 @@
 import type { APIClient } from '@heroku-cli/command';
 import * as createTunnel from 'tunnel-ssh';
-import { AddOnAttachmentWithConfigVarsAndPlan } from '../../types/pg/data-api';
-import { ConnectionDetails } from '../../types/pg/tunnel';
-import { TunnelConfig } from '../../types/pg/tunnel';
+import { AddOnAttachmentWithConfigVarsAndPlan } from '../../types/pg/data-api.js';
+import { ConnectionDetails } from '../../types/pg/tunnel.js';
+import { TunnelConfig } from '../../types/pg/tunnel.js';
 export declare const bastionKeyPlan: (a: AddOnAttachmentWithConfigVarsAndPlan) => boolean;
 export declare const env: (db: ConnectionDetails) => {
     TZ?: string;

package/dist/utils/pg/bastion.js

@@ -1,21 +1,17 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getBastion = exports.env = exports.bastionKeyPlan = void 0;
-exports.fetchConfig = fetchConfig;
-exports.getConfigs = getConfigs;
-exports.sshTunnel = sshTunnel;
-exports.tunnelConfig = tunnelConfig;
-const core_1 = require("@oclif/core");
-const debug_1 = require("debug");
-const EventEmitter = require("node:events");
-const node_util_1 = require("node:util");
-const createTunnel = require("tunnel-ssh");
-const host_1 = require("./host");
-const pgDebug = (0, debug_1.default)('pg');
-const bastionKeyPlan = (a) => Boolean(/private/.test(a.addon.plan.name));
-exports.bastionKeyPlan = bastionKeyPlan;
-const env = (db) => {
-    const baseEnv = Object.assign({ PGAPPNAME: 'psql non-interactive', PGSSLMODE: (!db.host || db.host === 'localhost') ? 'prefer' : 'require' }, process.env);
+import { ux } from '@oclif/core';
+import debug from 'debug';
+import * as EventEmitter from 'node:events';
+import { promisify } from 'node:util';
+import * as createTunnel from 'tunnel-ssh';
+import host from './host.js';
+const pgDebug = debug('pg');
+export const bastionKeyPlan = (a) => Boolean(/private/.test(a.addon.plan.name));
+export const env = (db) => {
+    const baseEnv = {
+        PGAPPNAME: 'psql non-interactive',
+        PGSSLMODE: (!db.host || db.host === 'localhost') ? 'prefer' : 'require',
+        ...process.env,
+    };
     const mapping = {
         PGDATABASE: 'database',
         PGHOST: 'host',
@@ -31,13 +27,12 @@ const env = (db) => {
     }
     return baseEnv;
 };
-exports.env = env;
-async function fetchConfig(heroku, db) {
+export async function fetchConfig(heroku, db) {
     return heroku.get(`/client/v11/databases/${encodeURIComponent(db.id)}/bastion`, {
-        hostname: (0, host_1.default)(),
+        hostname: host(),
     });
 }
-const getBastion = function (config, baseName) {
+export const getBastion = function (config, baseName) {
     // If there are bastions, extract a host and a key
     // otherwise, return an empty Object
     // If there are bastions:
@@ -50,9 +45,8 @@ const getBastion = function (config, baseName) {
     const bastionHost = bastions[Math.floor(Math.random() * bastions.length)];
     return (bastionKey && bastionHost) ? { bastionHost, bastionKey } : {};
 };
-exports.getBastion = getBastion;
-function getConfigs(db) {
-    const dbEnv = (0, exports.env)(db);
+export function getConfigs(db) {
+    const dbEnv = env(db);
     const dbTunnelConfig = tunnelConfig(db);
     if (db.bastionKey) {
         Object.assign(dbEnv, {
@@ -65,12 +59,12 @@ function getConfigs(db) {
         dbTunnelConfig,
     };
 }
-async function sshTunnel(db, dbTunnelConfig, timeout = 10000) {
+export async function sshTunnel(db, dbTunnelConfig, timeout = 10_000) {
     if (!db.bastionKey) {
         return null;
     }
     const timeoutInstance = new Timeout(timeout, 'Establishing a secure tunnel timed out');
-    const createSSHTunnel = (0, node_util_1.promisify)(createTunnel);
+    const createSSHTunnel = promisify(createTunnel.default);
     try {
         return await Promise.race([
             timeoutInstance.promise(),
@@ -79,15 +73,15 @@ async function sshTunnel(db, dbTunnelConfig, timeout = 10000) {
     }
     catch (error) {
         pgDebug(error);
-        core_1.ux.error('Unable to establish a secure tunnel to your database.');
+        ux.error('Unable to establish a secure tunnel to your database.');
     }
     finally {
         timeoutInstance.cancel();
     }
 }
-function tunnelConfig(db) {
+export function tunnelConfig(db) {
     const localHost = '127.0.0.1';
-    const localPort = Math.floor((Math.random() * (65535 - 49152)) + 49152);
+    const localPort = Math.floor((Math.random() * (65_535 - 49_152)) + 49_152);
     return {
         dstHost: db.host || undefined,
         dstPort: (db.port && Number.parseInt(db.port, 10)) || undefined,
@@ -99,9 +93,11 @@ function tunnelConfig(db) {
     };
 }
 class Timeout {
+    events = new EventEmitter.EventEmitter();
+    message;
+    timeout;
+    timer;
     constructor(timeout, message) {
-        // eslint-disable-next-line unicorn/prefer-event-target
-        this.events = new EventEmitter();
         this.timeout = timeout;
         this.message = message;
     }
@@ -113,7 +109,9 @@ class Timeout {
             this.events.emit('error', new Error(this.message));
         }, this.timeout);
         try {
-            await EventEmitter.once(this.events, 'cancelled');
+            await new Promise(resolve => {
+                this.events.once('cancelled', () => resolve());
+            });
         }
         finally {
             clearTimeout(this.timer);

package/dist/utils/pg/config-vars.d.ts

@@ -1,6 +1,6 @@
 import type { APIClient } from '@heroku-cli/command';
 import type { AddOnAttachment } from '@heroku-cli/schema';
-import type { AddOnAttachmentWithConfigVarsAndPlan } from '../../types/pg/data-api';
+import type { AddOnAttachmentWithConfigVarsAndPlan } from '../../types/pg/data-api.js';
 export declare function getConfig(heroku: APIClient, app: string): Promise<Record<string, string> | undefined>;
 export declare function getConfigVarName(configVars: string[]): string;
 export declare function getConfigVarNameFromAttachment(attachment: Required<{

package/dist/utils/pg/config-vars.js

@@ -1,30 +1,24 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getConfig = getConfig;
-exports.getConfigVarName = getConfigVarName;
-exports.getConfigVarNameFromAttachment = getConfigVarNameFromAttachment;
-const color_1 = require("@heroku-cli/color");
-const core_1 = require("@oclif/core");
+import { color } from '@heroku-cli/color';
+import { ux } from '@oclif/core';
 const responseByAppId = new Map();
-async function getConfig(heroku, app) {
+export async function getConfig(heroku, app) {
     if (!responseByAppId.has(app)) {
         const promise = heroku.get(`/apps/${app}/config-vars`);
         responseByAppId.set(app, promise);
     }
     const result = await responseByAppId.get(app);
-    return result === null || result === void 0 ? void 0 : result.body;
+    return result?.body;
 }
-function getConfigVarName(configVars) {
+export function getConfigVarName(configVars) {
     const connStringVars = configVars.filter(cv => (cv.endsWith('_URL')));
     if (connStringVars.length === 0)
         throw new Error('Database URL not found for this addon');
     return connStringVars[0];
 }
-function getConfigVarNameFromAttachment(attachment, config = {}) {
-    var _a, _b;
-    const configVars = (_b = (_a = attachment.addon.config_vars) === null || _a === void 0 ? void 0 : _a.filter((cv) => { var _a; return (_a = config[cv]) === null || _a === void 0 ? void 0 : _a.startsWith('postgres://'); })) !== null && _b !== void 0 ? _b : [];
+export function getConfigVarNameFromAttachment(attachment, config = {}) {
+    const configVars = attachment.addon.config_vars?.filter((cv) => config[cv]?.startsWith('postgres://')) ?? [];
     if (configVars.length === 0) {
-        core_1.ux.error(`No config vars found for ${attachment.name}; perhaps they were removed as a side effect of ${color_1.default.cmd('heroku rollback')}? Use ${color_1.default.cmd('heroku addons:attach')} to create a new attachment and then ${color_1.default.cmd('heroku addons:detach')} to remove the current attachment.`);
+        ux.error(`No config vars found for ${attachment.name}; perhaps they were removed as a side effect of ${color.cmd('heroku rollback')}? Use ${color.cmd('heroku addons:attach')} to create a new attachment and then ${color.cmd('heroku addons:detach')} to remove the current attachment.`);
     }
     const configVarName = `${attachment.name}_URL`;
     if (configVars.includes(configVarName) && configVarName in config) {

package/dist/utils/pg/databases.d.ts

@@ -1,7 +1,7 @@
 import type { AddOnAttachment } from '@heroku-cli/schema';
 import { APIClient } from '@heroku-cli/command';
-import type { AddOnAttachmentWithConfigVarsAndPlan } from '../../types/pg/data-api';
-import type { ConnectionDetails, ConnectionDetailsWithAttachment } from '../../types/pg/tunnel';
+import type { AddOnAttachmentWithConfigVarsAndPlan } from '../../types/pg/data-api.js';
+import type { ConnectionDetails, ConnectionDetailsWithAttachment } from '../../types/pg/tunnel.js';
 export declare function getAttachment(heroku: APIClient, app: string, db?: string, namespace?: string): Promise<Required<{
     addon: AddOnAttachmentWithConfigVarsAndPlan;
 } & AddOnAttachment>>;

package/dist/utils/pg/databases.js

@@ -1,25 +1,19 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parsePostgresConnectionString = exports.getConnectionDetails = void 0;
-exports.getAttachment = getAttachment;
-exports.getDatabase = getDatabase;
-const color_1 = require("@heroku-cli/color");
-const api_client_1 = require("@heroku-cli/command/lib/api-client");
-const debug_1 = require("debug");
-const node_process_1 = require("node:process");
-const ambiguous_1 = require("../../types/errors/ambiguous");
-const resolve_1 = require("../addons/resolve");
-const bastion_1 = require("./bastion");
-const config_vars_1 = require("./config-vars");
-const pgDebug = (0, debug_1.default)('pg');
+import { color } from '@heroku-cli/color';
+import { HerokuAPIError } from '@heroku-cli/command/lib/api-client.js';
+import debug from 'debug';
+import { env } from 'node:process';
+import { AmbiguousError } from '../../types/errors/ambiguous.js';
+import { appAttachment } from '../addons/resolve.js';
+import { bastionKeyPlan, fetchConfig, getBastion } from './bastion.js';
+import { getConfig, getConfigVarName, getConfigVarNameFromAttachment } from './config-vars.js';
+const pgDebug = debug('pg');
 async function allAttachments(heroku, appId) {
     const { body: attachments } = await heroku.get(`/apps/${appId}/addon-attachments`, {
         headers: { 'Accept-Inclusion': 'addon:plan,config_vars' },
     });
-    return attachments.filter((a) => { var _a, _b; return (_b = (_a = a.addon.plan) === null || _a === void 0 ? void 0 : _a.name) === null || _b === void 0 ? void 0 : _b.startsWith('heroku-postgresql'); });
+    return attachments.filter((a) => a.addon.plan?.name?.startsWith('heroku-postgresql'));
 }
-async function getAttachment(heroku, app, db = 'DATABASE_URL', namespace = '') {
-    var _a;
+export async function getAttachment(heroku, app, db = 'DATABASE_URL', namespace = '') {
     const matchesOrError = await matchesHelper(heroku, app, db, namespace);
     let { matches } = matchesOrError;
     const { error } = matchesOrError;
@@ -38,36 +32,36 @@ async function getAttachment(heroku, app, db = 'DATABASE_URL', namespace = '') {
             db += '_URL';
         }
         const [config = {}, attachments] = await Promise.all([
-            (0, config_vars_1.getConfig)(heroku, app),
+            getConfig(heroku, app),
             allAttachments(heroku, app),
         ]);
         if (attachments.length === 0) {
-            throw new Error(`${color_1.default.app(app)} has no databases`);
+            throw new Error(`${color.app(app)} has no databases`);
         }
-        matches = attachments.filter(attachment => config[db] && config[db] === config[(0, config_vars_1.getConfigVarName)(attachment.config_vars)]);
+        matches = attachments.filter(attachment => config[db] && config[db] === config[getConfigVarName(attachment.config_vars)]);
         if (matches.length === 0) {
-            const validOptions = attachments.map(attachment => (0, config_vars_1.getConfigVarName)(attachment.config_vars));
+            const validOptions = attachments.map(attachment => getConfigVarName(attachment.config_vars));
             throw new Error(`Unknown database: ${db}. Valid options are: ${validOptions.join(', ')}`);
         }
     }
     // case for multiple attachments with passedDb
     const first = matches[0];
     // case for 422 where there are ambiguous attachments that are equivalent
-    if (matches.every(match => { var _a, _b, _c, _d; return ((_a = first.addon) === null || _a === void 0 ? void 0 : _a.id) === ((_b = match.addon) === null || _b === void 0 ? void 0 : _b.id) && ((_c = first.app) === null || _c === void 0 ? void 0 : _c.id) === ((_d = match.app) === null || _d === void 0 ? void 0 : _d.id); })) {
-        const config = (_a = await (0, config_vars_1.getConfig)(heroku, first.app.name)) !== null && _a !== void 0 ? _a : {};
-        if (matches.every(match => config[(0, config_vars_1.getConfigVarName)(first.addon.config_vars)] === config[(0, config_vars_1.getConfigVarName)(match.config_vars)])) {
+    if (matches.every(match => first.addon?.id === match.addon?.id && first.app?.id === match.app?.id)) {
+        const config = await getConfig(heroku, first.app.name) ?? {};
+        if (matches.every(match => config[getConfigVarName(first.addon.config_vars)] === config[getConfigVarName(match.config_vars)])) {
             return first;
         }
     }
     throw error;
 }
-const getConnectionDetails = (attachment, configVars = {}) => {
-    const connStringVar = (0, config_vars_1.getConfigVarNameFromAttachment)(attachment, configVars);
+export const getConnectionDetails = (attachment, configVars = {}) => {
+    const connStringVar = getConfigVarNameFromAttachment(attachment, configVars);
     // remove _URL from the end of the config var name
     const baseName = connStringVar.slice(0, -4);
     // build the default payload for non-bastion dbs
     pgDebug(`Using "${connStringVar}" to connect to your database…`);
-    const conn = (0, exports.parsePostgresConnectionString)(configVars[connStringVar]);
+    const conn = parsePostgresConnectionString(configVars[connStringVar]);
     const payload = {
         attachment,
         database: conn.database,
@@ -79,22 +73,21 @@ const getConnectionDetails = (attachment, configVars = {}) => {
         user: conn.user,
     };
     // If bastion creds exist, graft it into the payload
-    const bastion = (0, bastion_1.getBastion)(configVars, baseName);
+    const bastion = getBastion(configVars, baseName);
     if (bastion) {
         Object.assign(payload, bastion);
     }
     return payload;
 };
-exports.getConnectionDetails = getConnectionDetails;
-async function getDatabase(heroku, app, db, namespace) {
+export async function getDatabase(heroku, app, db, namespace) {
     const attached = await getAttachment(heroku, app, db, namespace);
     // would inline this as well but in some cases attachment pulls down config
     // as well, and we would request twice at the same time but I did not want
     // to push this down into attachment because we do not always need config
-    const config = await (0, config_vars_1.getConfig)(heroku, attached.app.name);
-    const database = (0, exports.getConnectionDetails)(attached, config);
-    if ((0, bastion_1.bastionKeyPlan)(attached.addon) && !database.bastionKey) {
-        const { body: bastionConfig } = await (0, bastion_1.fetchConfig)(heroku, attached.addon);
+    const config = await getConfig(heroku, attached.app.name);
+    const database = getConnectionDetails(attached, config);
+    if (bastionKeyPlan(attached.addon) && !database.bastionKey) {
+        const { body: bastionConfig } = await fetchConfig(heroku, attached.addon);
         const bastionHost = bastionConfig.host;
         const bastionKey = bastionConfig.private_key;
         Object.assign(database, { bastionHost, bastionKey });
@@ -102,25 +95,24 @@ async function getDatabase(heroku, app, db, namespace) {
     return database;
 }
 async function matchesHelper(heroku, app, db, namespace) {
-    var _a;
-    (0, debug_1.default)(`fetching ${db} on ${app}`);
+    debug(`fetching ${db} on ${app}`);
     const addonService = process.env.HEROKU_POSTGRESQL_ADDON_NAME || 'heroku-postgresql';
-    (0, debug_1.default)(`addon service: ${addonService}`);
+    debug(`addon service: ${addonService}`);
     try {
-        const attached = await (0, resolve_1.appAttachment)(heroku, app, db, { addon_service: addonService, namespace });
+        const attached = await appAttachment(heroku, app, db, { addon_service: addonService, namespace });
         return ({ matches: [attached] });
     }
     catch (error) {
-        if (error instanceof ambiguous_1.AmbiguousError && ((_a = error.body) === null || _a === void 0 ? void 0 : _a.id) === 'multiple_matches' && error.matches) {
+        if (error instanceof AmbiguousError && error.body?.id === 'multiple_matches' && error.matches) {
             return { error, matches: error.matches };
         }
-        if (error instanceof api_client_1.HerokuAPIError && error.http.statusCode === 404 && error.body && error.body.id === 'not_found') {
+        if (error instanceof HerokuAPIError && error.http.statusCode === 404 && error.body && error.body.id === 'not_found') {
             return { error, matches: null };
         }
         throw error;
     }
 }
-const parsePostgresConnectionString = (db) => {
+export const parsePostgresConnectionString = (db) => {
     const dbPath = /:\/\//.test(db) ? db : `postgres:///${db}`;
     const url = new URL(dbPath);
     const { hostname, password, pathname, port, username } = url;
@@ -129,9 +121,8 @@ const parsePostgresConnectionString = (db) => {
         host: hostname,
         password,
         pathname,
-        port: port || node_process_1.env.PGPORT || (hostname && '5432'),
+        port: port || env.PGPORT || (hostname && '5432'),
         url: dbPath,
         user: username,
     };
 };
-exports.parsePostgresConnectionString = parsePostgresConnectionString;

package/dist/utils/pg/host.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = default_1;
-function default_1() {
+export default function () {
     const host = process.env.HEROKU_DATA_HOST || process.env.HEROKU_POSTGRESQL_HOST;
-    return host !== null && host !== void 0 ? host : 'api.data.heroku.com';
+    return host ?? 'api.data.heroku.com';
 }

package/dist/utils/pg/psql.d.ts

@@ -2,7 +2,7 @@ import { type ChildProcess, type SpawnOptions, type SpawnOptionsWithStdioTuple }
 import { EventEmitter } from 'node:events';
 import { Server } from 'node:net';
 import { Stream } from 'node:stream';
-import { ConnectionDetails, TunnelConfig } from '../../types/pg/tunnel';
+import { ConnectionDetails, TunnelConfig } from '../../types/pg/tunnel.js';
 export declare function consumeStream(inputStream: Stream): Promise<unknown>;
 export declare function exec(db: ConnectionDetails, query: string, cmdArgs?: string[]): Promise<string>;
 export declare function psqlQueryOptions(query: string, dbEnv: NodeJS.ProcessEnv, cmdArgs?: string[]): {

package/dist/utils/pg/psql.js

@@ -1,26 +1,17 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Tunnel = exports.trapAndForwardSignalsToChildProcess = void 0;
-exports.consumeStream = consumeStream;
-exports.exec = exec;
-exports.psqlQueryOptions = psqlQueryOptions;
-exports.execPSQL = execPSQL;
-exports.runWithTunnel = runWithTunnel;
-exports.waitForPSQLExit = waitForPSQLExit;
-const debug_1 = require("debug");
-const node_child_process_1 = require("node:child_process");
-const node_events_1 = require("node:events");
-const node_stream_1 = require("node:stream");
-const promises_1 = require("node:stream/promises");
-const bastion_1 = require("./bastion");
-const pgDebug = (0, debug_1.default)('pg');
-function consumeStream(inputStream) {
+import debug from 'debug';
+import { spawn, } from 'node:child_process';
+import { EventEmitter, once } from 'node:events';
+import { Stream } from 'node:stream';
+import { finished } from 'node:stream/promises';
+import { getConfigs, sshTunnel } from './bastion.js';
+const pgDebug = debug('pg');
+export function consumeStream(inputStream) {
     let result = '';
-    const throughStream = new node_stream_1.Stream.PassThrough();
+    const throughStream = new Stream.PassThrough();
     // eslint-disable-next-line no-async-promise-executor
     const promise = new Promise(async (resolve, reject) => {
         try {
-            await (0, promises_1.finished)(throughStream);
+            await finished(throughStream);
             resolve(result);
         }
         catch (error) {
@@ -32,12 +23,12 @@ function consumeStream(inputStream) {
     inputStream.pipe(throughStream);
     return promise;
 }
-async function exec(db, query, cmdArgs = []) {
-    const configs = (0, bastion_1.getConfigs)(db);
+export async function exec(db, query, cmdArgs = []) {
+    const configs = getConfigs(db);
     const options = psqlQueryOptions(query, configs.dbEnv, cmdArgs);
     return runWithTunnel(db, configs.dbTunnelConfig, options);
 }
-function psqlQueryOptions(query, dbEnv, cmdArgs = []) {
+export function psqlQueryOptions(query, dbEnv, cmdArgs = []) {
     pgDebug('Running query: %s', query.trim());
     const psqlArgs = ['-c', query, '--set', 'sslmode=require', ...cmdArgs];
     const childProcessOptions = {
@@ -49,10 +40,13 @@ function psqlQueryOptions(query, dbEnv, cmdArgs = []) {
         psqlArgs,
     };
 }
-function execPSQL({ childProcessOptions, dbEnv, psqlArgs }) {
-    const options = Object.assign({ env: dbEnv }, childProcessOptions);
+export function execPSQL({ childProcessOptions, dbEnv, psqlArgs }) {
+    const options = {
+        env: dbEnv,
+        ...childProcessOptions,
+    };
     pgDebug('opening psql process');
-    const psql = (0, node_child_process_1.spawn)('psql', psqlArgs, options);
+    const psql = spawn('psql', psqlArgs, options);
     psql.once('spawn', () => pgDebug('psql process spawned'));
     return psql;
 }
@@ -66,7 +60,7 @@ function kill(childProcess, signal) {
         childProcess.kill(signal);
     }
 }
-async function runWithTunnel(db, tunnelConfig, options) {
+export async function runWithTunnel(db, tunnelConfig, options) {
     const tunnel = await Tunnel.connect(db, tunnelConfig);
     pgDebug('after create tunnel');
     const psql = execPSQL(options);
@@ -77,7 +71,7 @@ async function runWithTunnel(db, tunnelConfig, options) {
     // return a string for consistency but ideally we should return the child process from this function
     // and let the caller decide what to do with stdin/stdout/stderr
     const stdoutPromise = psql.stdout ? consumeStream(psql.stdout) : Promise.resolve('');
-    const cleanupSignalTraps = (0, exports.trapAndForwardSignalsToChildProcess)(psql);
+    const cleanupSignalTraps = trapAndForwardSignalsToChildProcess(psql);
     try {
         pgDebug('waiting for psql or tunnel to exit');
         // wait for either psql or tunnel to exit;
@@ -108,7 +102,7 @@ async function runWithTunnel(db, tunnelConfig, options) {
 // This code is to stop the parent node process (heroku CLI)
 // from exiting. If the parent Heroku CLI node process exits, then psql will exit as it
 // is a child process of the Heroku CLI node process.
-const trapAndForwardSignalsToChildProcess = (childProcess) => {
+export const trapAndForwardSignalsToChildProcess = (childProcess) => {
     const signalsToTrap = ['SIGINT'];
     const signalTraps = signalsToTrap.map(signal => {
         process.removeAllListeners(signal);
@@ -123,11 +117,10 @@ const trapAndForwardSignalsToChildProcess = (childProcess) => {
         }
     };
 };
-exports.trapAndForwardSignalsToChildProcess = trapAndForwardSignalsToChildProcess;
-async function waitForPSQLExit(psql) {
+export async function waitForPSQLExit(psql) {
     let errorToThrow = null;
     try {
-        const [exitCode] = await (0, node_events_1.once)(psql, 'close');
+        const [exitCode] = await once(psql, 'close');
         pgDebug(`psql exited with code ${exitCode}`);
         if (exitCode > 0) {
             errorToThrow = new Error(`psql exited with code ${exitCode}`);
@@ -147,14 +140,16 @@ async function waitForPSQLExit(psql) {
 // a small wrapper around tunnel-ssh
 // so that other code doesn't have to worry about
 // whether there is or is not a tunnel
-class Tunnel {
+export class Tunnel {
+    bastionTunnel;
+    events;
     constructor(bastionTunnel) {
         this.bastionTunnel = bastionTunnel;
         // eslint-disable-next-line unicorn/prefer-event-target
-        this.events = new node_events_1.EventEmitter();
+        this.events = new EventEmitter();
     }
     static async connect(db, tunnelConfig) {
-        const tunnel = await (0, bastion_1.sshTunnel)(db, tunnelConfig);
+        const tunnel = await sshTunnel(db, tunnelConfig);
         return new Tunnel(tunnel);
     }
     close() {
@@ -171,7 +166,7 @@ class Tunnel {
         if (this.bastionTunnel) {
             try {
                 pgDebug('wait for tunnel close');
-                await (0, node_events_1.once)(this.bastionTunnel, 'close');
+                await once(this.bastionTunnel, 'close');
                 pgDebug('tunnel closed');
             }
             catch (error) {
@@ -181,8 +176,7 @@ class Tunnel {
         }
         else {
             pgDebug('no bastion required; waiting for fake close event');
-            await (0, node_events_1.once)(this.events, 'close');
+            await once(this.events, 'close');
         }
     }
 }
-exports.Tunnel = Tunnel;

package/dist/ux/confirm.d.ts

@@ -1 +1,9 @@
-export declare function confirm(message: string): Promise<boolean>;
+export type PromptInputs<T> = {
+    /**
+     * default value to offer to the user.  Will be used if the user does not respond within the timeout period.
+     */
+    defaultAnswer?: T;
+    /** after this many ms, the prompt will time out.  If a default value is provided, the default will be used.  Otherwise the prompt will throw an error */
+    ms?: number;
+};
+export declare const confirm: (message: string, { defaultAnswer, ms, }?: PromptInputs<boolean>) => Promise<boolean>;

package/dist/ux/confirm.js

@@ -1,7 +1,37 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.confirm = confirm;
-const core_1 = require("@oclif/core");
-async function confirm(message) {
-    return core_1.ux.confirm(message);
-}
+import { ux } from '@oclif/core';
+import { createPromptModule } from 'inquirer';
+const prompt = createPromptModule();
+export const confirm = async (message, { defaultAnswer = false, ms = 10_000, } = {}) => {
+    let timeoutId;
+    const promptPromise = prompt([{
+            default: defaultAnswer,
+            message,
+            name: 'answer',
+            type: 'confirm',
+        }]).then(({ answer }) => {
+        if (timeoutId)
+            clearTimeout(timeoutId);
+        return answer;
+    });
+    const timeoutPromise = new Promise((resolve, reject) => {
+        timeoutId = setTimeout(() => {
+            if (defaultAnswer === undefined) {
+                reject(ux.error('Prompt timed out'));
+            }
+            else {
+                // Force the process to continue with the default answer
+                process.stdin.push(null);
+                // Clean up stdin
+                process.stdin.pause();
+                resolve(defaultAnswer);
+            }
+        }, ms);
+    });
+    try {
+        return await Promise.race([promptPromise, timeoutPromise]);
+    }
+    finally {
+        if (timeoutId)
+            clearTimeout(timeoutId);
+    }
+};

package/dist/ux/prompt.d.ts

@@ -1,2 +1,7 @@
-import { ux } from '@oclif/core';
-export declare function prompt(name: string, options?: ux.IPromptOptions): Promise<string>;
+type PromptOptions = {
+    default?: string;
+    required?: boolean;
+    type?: string;
+};
+export declare function prompt(name: string, options?: PromptOptions): Promise<string>;
+export {};

package/dist/ux/prompt.js

@@ -1,7 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.prompt = prompt;
-const core_1 = require("@oclif/core");
-async function prompt(name, options) {
-    return core_1.ux.prompt(name, options);
+import inquirer from 'inquirer';
+export async function prompt(name, options) {
+    const { answer } = await inquirer.prompt([{
+            default: options?.default,
+            message: name,
+            name: 'answer',
+            type: options?.type ?? 'input',
+            validate: options?.required ? (input) => input.length > 0 || 'This field is required' : undefined,
+        }]);
+    return answer;
 }

package/dist/ux/styled-header.js

@@ -1,7 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.styledHeader = styledHeader;
-const core_1 = require("@oclif/core");
-function styledHeader(header) {
-    return core_1.ux.styledHeader(header);
+import { color } from '@heroku-cli/color';
+import { ux } from '@oclif/core';
+export function styledHeader(header) {
+    return ux.stdout(color.dim('=== ') + color.bold(header) + '\n');
 }

package/dist/ux/styled-json.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.styledJSON = styledJSON;
-const core_1 = require("@oclif/core");
-function styledJSON(obj) {
-    return core_1.ux.styledJSON(obj);
+import { ux } from '@oclif/core';
+export function styledJSON(obj) {
+    ux.stdout(ux.colorizeJson(obj));
 }

package/dist/ux/styled-object.d.ts

@@ -1 +1 @@
-export declare function styledObject(obj: unknown, keys?: string[]): void;
+export declare function styledObject(obj: unknown, keys?: string[]): string | undefined;

package/dist/ux/styled-object.js

@@ -1,7 +1,49 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.styledObject = styledObject;
-const core_1 = require("@oclif/core");
-function styledObject(obj, keys) {
-    return core_1.ux.styledObject(obj, keys);
+import { color } from '@heroku-cli/color';
+import { ux } from '@oclif/core';
+import { inspect } from 'node:util';
+function prettyPrint(obj) {
+    if (!obj)
+        return inspect(obj);
+    if (typeof obj === 'string')
+        return obj;
+    if (typeof obj === 'number')
+        return obj.toString();
+    if (typeof obj === 'boolean')
+        return obj.toString();
+    if (typeof obj === 'object') {
+        return Object.entries(obj)
+            .map(([key, value]) => `${key}: ${inspect(value)}`)
+            .join(', ');
+    }
+    return inspect(obj);
+}
+export function styledObject(obj, keys) {
+    if (!obj)
+        return inspect(obj);
+    if (typeof obj === 'string')
+        return obj;
+    if (typeof obj === 'number')
+        return obj.toString();
+    if (typeof obj === 'boolean')
+        return obj.toString();
+    const output = [];
+    const keyLengths = Object.keys(obj).map(key => key.toString().length);
+    const maxKeyLength = Math.max(...keyLengths) + 2;
+    const logKeyValue = (key, value) => `${color.cyan(key)}:` + ' '.repeat(maxKeyLength - key.length - 1) + prettyPrint(value);
+    for (const [key, value] of Object.entries(obj)) {
+        if (keys && !keys.includes(key))
+            continue;
+        if (Array.isArray(value)) {
+            if (value.length > 0) {
+                output.push(logKeyValue(key, value[0]));
+                for (const e of value.slice(1)) {
+                    output.push(' '.repeat(maxKeyLength) + prettyPrint(e));
+                }
+            }
+        }
+        else if (value !== null && value !== undefined) {
+            output.push(logKeyValue(key, value));
+        }
+    }
+    ux.stdout(output.join('\n'));
 }

package/dist/ux/table.d.ts

@@ -1,2 +1,22 @@
-import { ux } from '@oclif/core';
-export declare function table<T extends Record<string, unknown>>(data: T[], columns: ux.Table.table.Columns<T>, options?: ux.Table.table.Options): void;
+type Column<T extends Record<string, unknown>> = {
+    extended: boolean;
+    get(row: T): unknown;
+    header: string;
+    minWidth: number;
+};
+type Columns<T extends Record<string, unknown>> = {
+    [key: string]: Partial<Column<T>>;
+};
+type Options = {
+    columns?: string;
+    extended?: boolean;
+    filter?: string;
+    'no-header'?: boolean;
+    'no-truncate'?: boolean;
+    printLine?(s: unknown): void;
+    rowStart?: string;
+    sort?: string;
+    title?: string;
+};
+export declare function table<T extends Record<string, unknown>>(data: T[], columns: Columns<T>, options?: Options): void;
+export {};

package/dist/ux/table.js

@@ -1,7 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.table = table;
-const core_1 = require("@oclif/core");
-function table(data, columns, options) {
-    return core_1.ux.table(data, columns, options);
+import { printTable } from '@oclif/table';
+export function table(data, columns, options) {
+    const cols = Object.entries(columns).map(([key, opts]) => {
+        if (opts.header)
+            return { key, name: opts.header };
+        return key;
+    });
+    const d = data.map(row => Object.fromEntries(Object.entries(columns).map(([key, { get }]) => [key, get ? get(row) : row[key]])));
+    printTable({
+        borderStyle: 'headers-only-with-underline',
+        columns: cols,
+        data: d,
+        title: options?.title,
+    });
 }

package/dist/ux/wait.js

@@ -1,7 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.wait = wait;
-const core_1 = require("@oclif/core");
-function wait(ms) {
-    return core_1.ux.wait(ms);
+export function wait(ms) {
+    return new Promise(resolve => {
+        setTimeout(resolve, ms);
+    });
 }

package/package.json

@@ -1,7 +1,7 @@
 {
-  "type": "commonjs",
+  "type": "module",
   "name": "@heroku/heroku-cli-util",
-  "version": "9.0.2",
+  "version": "10.0.0-beta.0",
   "description": "Set of helpful CLI utilities",
   "author": "Heroku",
   "license": "ISC",
@@ -16,6 +16,7 @@
     "@types/chai": "^4.3.13",
     "@types/chai-as-promised": "^8.0.2",
     "@types/debug": "^4.1.12",
+    "@types/inquirer": "^9.0.8",
     "@types/mocha": "^10.0.10",
     "@types/node": "^22.15.3",
     "@types/sinon": "^17.0.4",
@@ -28,10 +29,10 @@
     "eslint-plugin-import": "^2.31.0",
     "eslint-plugin-mocha": "^10.4.3",
     "mocha": "^10.8.2",
+    "mock-stdin": "^1.0.0",
     "nock": "^13.2.9",
     "nyc": "^17.1.0",
     "sinon": "^18.0.1",
-    "stdout-stderr": "^0.1.13",
     "strip-ansi": "^6",
     "ts-node": "^10.9.2",
     "tsconfig-paths": "^4.2.0",
@@ -40,32 +41,24 @@
   },
   "dependencies": {
     "@heroku-cli/color": "^2.0.4",
-    "@heroku-cli/command": "^11.5.0",
+    "@heroku-cli/command": "^12.0.0",
     "@heroku/http-call": "^5.4.0",
-    "@oclif/core": "^2.16.0",
+    "@oclif/core": "^4.3.0",
+    "@oclif/table": "0.4.8",
     "debug": "^4.4.0",
+    "inquirer": "^12.6.1",
     "tunnel-ssh": "4.1.6"
   },
   "engines": {
     "node": ">=20"
   },
-  "mocha": {
-    "require": [
-      "ts-node/register",
-      "source-map-support/register",
-      "test/hooks.ts"
-    ],
-    "watch-extensions": "ts",
-    "recursive": true,
-    "reporter": "spec",
-    "timeout": 360000
-  },
   "scripts": {
     "build": "npm run clean && tsc",
     "clean": "rm -rf dist",
-    "lint": "eslint . --ext .ts --config .eslintrc.js",
+    "example": "sh examples/run.sh",
+    "lint": "eslint . --ext .ts --config .eslintrc.cjs",
     "prepare": "npm run build",
-    "test": "nyc mocha  --forbid-only \"test/**/*.test.ts\"",
-    "test:local": "mocha \"test/**/*.test.ts\""
+    "test": "nyc mocha --forbid-only \"test/**/*.test.ts\"",
+    "test:local": "nyc mocha \"${npm_config_file:-test/**/*.test.+(ts|tsx)}\""
   }
 }