@heroku/heroku-cli-util 8.0.15 → 9.0.0-beta.0

package/dist/utils/pg/bastion.js

@@ -0,0 +1,122 @@
+"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);
+    const mapping = {
+        PGDATABASE: 'database',
+        PGHOST: 'host',
+        PGPASSWORD: 'password',
+        PGPORT: 'port',
+        PGUSER: 'user',
+    };
+    for (const envVar of Object.keys(mapping)) {
+        const val = db[mapping[envVar]];
+        if (val) {
+            baseEnv[envVar] = val;
+        }
+    }
+    return baseEnv;
+};
+exports.env = env;
+async function fetchConfig(heroku, db) {
+    return heroku.get(`/client/v11/databases/${encodeURIComponent(db.id)}/bastion`, {
+        hostname: (0, host_1.default)(),
+    });
+}
+const getBastion = function (config, baseName) {
+    // If there are bastions, extract a host and a key
+    // otherwise, return an empty Object
+    // If there are bastions:
+    // * there should be one *_BASTION_KEY
+    // * pick one host from the comma-separated list in *_BASTIONS
+    // We assert that _BASTIONS and _BASTION_KEY always exist together
+    // If either is falsy, pretend neither exist
+    const bastionKey = config[`${baseName}_BASTION_KEY`];
+    const bastions = (config[`${baseName}_BASTIONS`] || '').split(',');
+    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);
+    const dbTunnelConfig = tunnelConfig(db);
+    if (db.bastionKey) {
+        Object.assign(dbEnv, {
+            PGHOST: dbTunnelConfig.localHost,
+            PGPORT: dbTunnelConfig.localPort,
+        });
+    }
+    return {
+        dbEnv,
+        dbTunnelConfig,
+    };
+}
+async function sshTunnel(db, dbTunnelConfig, timeout = 10000) {
+    if (!db.bastionKey) {
+        return null;
+    }
+    const timeoutInstance = new Timeout(timeout, 'Establishing a secure tunnel timed out');
+    const createSSHTunnel = (0, node_util_1.promisify)(createTunnel);
+    try {
+        return await Promise.race([
+            timeoutInstance.promise(),
+            createSSHTunnel(dbTunnelConfig),
+        ]);
+    }
+    catch (error) {
+        pgDebug(error);
+        core_1.ux.error('Unable to establish a secure tunnel to your database.');
+    }
+    finally {
+        timeoutInstance.cancel();
+    }
+}
+function tunnelConfig(db) {
+    const localHost = '127.0.0.1';
+    const localPort = Math.floor((Math.random() * (65535 - 49152)) + 49152);
+    return {
+        dstHost: db.host || undefined,
+        dstPort: (db.port && Number.parseInt(db.port, 10)) || undefined,
+        host: db.bastionHost,
+        localHost,
+        localPort,
+        privateKey: db.bastionKey,
+        username: 'bastion',
+    };
+}
+class Timeout {
+    constructor(timeout, message) {
+        // eslint-disable-next-line unicorn/prefer-event-target
+        this.events = new EventEmitter();
+        this.timeout = timeout;
+        this.message = message;
+    }
+    cancel() {
+        this.events.emit('cancelled');
+    }
+    async promise() {
+        this.timer = setTimeout(() => {
+            this.events.emit('error', new Error(this.message));
+        }, this.timeout);
+        try {
+            await EventEmitter.once(this.events, 'cancelled');
+        }
+        finally {
+            clearTimeout(this.timer);
+        }
+    }
+}

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

@@ -0,0 +1,8 @@
+import type { APIClient } from '@heroku-cli/command';
+import type { AddOnAttachment } from '@heroku-cli/schema';
+import type { AddOnAttachmentWithConfigVarsAndPlan } from '../../types/pg/data-api';
+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<{
+    addon: AddOnAttachmentWithConfigVarsAndPlan;
+} & AddOnAttachment>, config?: Record<string, string>): string;

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

@@ -0,0 +1,34 @@
+"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");
+const responseByAppId = new Map();
+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;
+}
+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 : [];
+    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.`);
+    }
+    const configVarName = `${attachment.name}_URL`;
+    if (configVars.includes(configVarName) && configVarName in config) {
+        return configVarName;
+    }
+    return getConfigVarName(configVars);
+}

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

@@ -0,0 +1,12 @@
+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';
+export declare function getAttachment(heroku: APIClient, app: string, db?: string, namespace?: string): Promise<Required<{
+    addon: AddOnAttachmentWithConfigVarsAndPlan;
+} & AddOnAttachment>>;
+export declare const getConnectionDetails: (attachment: Required<{
+    addon: AddOnAttachmentWithConfigVarsAndPlan;
+} & AddOnAttachment>, configVars?: Record<string, string>) => ConnectionDetailsWithAttachment;
+export declare function getDatabase(heroku: APIClient, app: string, db?: string, namespace?: string): Promise<ConnectionDetailsWithAttachment>;
+export declare const parsePostgresConnectionString: (db: string) => ConnectionDetails;

package/dist/utils/pg/databases.js

@@ -0,0 +1,137 @@
+"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');
+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'); });
+}
+async function getAttachment(heroku, app, db = 'DATABASE_URL', namespace = '') {
+    var _a;
+    const matchesOrError = await matchesHelper(heroku, app, db, namespace);
+    let { matches } = matchesOrError;
+    const { error } = matchesOrError;
+    // happy path where the resolver matches just one
+    if (matches && matches.length === 1) {
+        return matches[0];
+    }
+    // case for 404 where there are implicit attachments
+    if (!matches) {
+        const appConfigMatch = /^(.+?)::(.+)/.exec(db);
+        if (appConfigMatch) {
+            app = appConfigMatch[1];
+            db = appConfigMatch[2];
+        }
+        if (!db.endsWith('_URL')) {
+            db += '_URL';
+        }
+        const [config = {}, attachments] = await Promise.all([
+            (0, config_vars_1.getConfig)(heroku, app),
+            allAttachments(heroku, app),
+        ]);
+        if (attachments.length === 0) {
+            throw new Error(`${color_1.default.app(app)} has no databases`);
+        }
+        matches = attachments.filter(attachment => config[db] && config[db] === config[(0, config_vars_1.getConfigVarName)(attachment.config_vars)]);
+        if (matches.length === 0) {
+            const validOptions = attachments.map(attachment => (0, config_vars_1.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)])) {
+            return first;
+        }
+    }
+    throw error;
+}
+const getConnectionDetails = (attachment, configVars = {}) => {
+    const connStringVar = (0, config_vars_1.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 payload = {
+        attachment,
+        database: conn.database,
+        host: conn.host,
+        password: conn.password,
+        pathname: conn.pathname,
+        port: conn.port,
+        url: conn.url,
+        user: conn.user,
+    };
+    // If bastion creds exist, graft it into the payload
+    const bastion = (0, bastion_1.getBastion)(configVars, baseName);
+    if (bastion) {
+        Object.assign(payload, bastion);
+    }
+    return payload;
+};
+exports.getConnectionDetails = getConnectionDetails;
+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 bastionHost = bastionConfig.host;
+        const bastionKey = bastionConfig.private_key;
+        Object.assign(database, { bastionHost, bastionKey });
+    }
+    return database;
+}
+async function matchesHelper(heroku, app, db, namespace) {
+    var _a;
+    (0, debug_1.default)(`fetching ${db} on ${app}`);
+    const addonService = process.env.HEROKU_POSTGRESQL_ADDON_NAME || 'heroku-postgresql';
+    (0, debug_1.default)(`addon service: ${addonService}`);
+    try {
+        const attached = await (0, resolve_1.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) {
+            return { error, matches: error.matches };
+        }
+        if (error instanceof api_client_1.HerokuAPIError && error.http.statusCode === 404 && error.body && error.body.id === 'not_found') {
+            return { error, matches: null };
+        }
+        throw error;
+    }
+}
+const parsePostgresConnectionString = (db) => {
+    const dbPath = /:\/\//.test(db) ? db : `postgres:///${db}`;
+    const url = new URL(dbPath);
+    const { hostname, password, pathname, port, username } = url;
+    return {
+        database: pathname.charAt(0) === '/' ? pathname.slice(1) : pathname,
+        host: hostname,
+        password,
+        pathname,
+        port: port || node_process_1.env.PGPORT || (hostname && '5432'),
+        url: dbPath,
+        user: username,
+    };
+};
+exports.parsePostgresConnectionString = parsePostgresConnectionString;

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

@@ -0,0 +1 @@
+export default function (): string;

package/dist/utils/pg/host.js

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

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

@@ -0,0 +1,28 @@
+import { type ChildProcess, type SpawnOptions, type SpawnOptionsWithStdioTuple } from 'node:child_process';
+import { EventEmitter } from 'node:events';
+import { Server } from 'node:net';
+import { Stream } from 'node:stream';
+import { ConnectionDetails, TunnelConfig } from '../../types/pg/tunnel';
+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[]): {
+    childProcessOptions: SpawnOptionsWithStdioTuple<"ignore", "pipe", "inherit">;
+    dbEnv: NodeJS.ProcessEnv;
+    psqlArgs: string[];
+};
+export declare function execPSQL({ childProcessOptions, dbEnv, psqlArgs }: {
+    childProcessOptions: SpawnOptions;
+    dbEnv: NodeJS.ProcessEnv;
+    psqlArgs: string[];
+}): ChildProcess;
+export declare function runWithTunnel(db: ConnectionDetails, tunnelConfig: TunnelConfig, options: Parameters<typeof execPSQL>[0]): Promise<string>;
+export declare const trapAndForwardSignalsToChildProcess: (childProcess: ChildProcess) => () => void;
+export declare function waitForPSQLExit(psql: EventEmitter): Promise<void>;
+export declare class Tunnel {
+    private readonly bastionTunnel;
+    private readonly events;
+    constructor(bastionTunnel: Server);
+    static connect(db: ConnectionDetails, tunnelConfig: TunnelConfig): Promise<Tunnel>;
+    close(): void;
+    waitForClose(): Promise<void>;
+}

package/dist/utils/pg/psql.js

@@ -0,0 +1,188 @@
+"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) {
+    let result = '';
+    const throughStream = new node_stream_1.Stream.PassThrough();
+    // eslint-disable-next-line no-async-promise-executor
+    const promise = new Promise(async (resolve, reject) => {
+        try {
+            await (0, promises_1.finished)(throughStream);
+            resolve(result);
+        }
+        catch (error) {
+            reject(error);
+        }
+    });
+    // eslint-disable-next-line no-return-assign
+    throughStream.on('data', chunk => result += chunk.toString());
+    inputStream.pipe(throughStream);
+    return promise;
+}
+async function exec(db, query, cmdArgs = []) {
+    const configs = (0, bastion_1.getConfigs)(db);
+    const options = psqlQueryOptions(query, configs.dbEnv, cmdArgs);
+    return runWithTunnel(db, configs.dbTunnelConfig, options);
+}
+function psqlQueryOptions(query, dbEnv, cmdArgs = []) {
+    pgDebug('Running query: %s', query.trim());
+    const psqlArgs = ['-c', query, '--set', 'sslmode=require', ...cmdArgs];
+    const childProcessOptions = {
+        stdio: ['ignore', 'pipe', 'inherit'],
+    };
+    return {
+        childProcessOptions,
+        dbEnv,
+        psqlArgs,
+    };
+}
+function execPSQL({ childProcessOptions, dbEnv, psqlArgs }) {
+    const options = Object.assign({ env: dbEnv }, childProcessOptions);
+    pgDebug('opening psql process');
+    const psql = (0, node_child_process_1.spawn)('psql', psqlArgs, options);
+    psql.once('spawn', () => pgDebug('psql process spawned'));
+    return psql;
+}
+// According to node.js docs, sending a kill to a process won't cause an error
+// but could have unintended consequences if the PID gets reassigned:
+// https://nodejs.org/docs/latest-v14.x/api/child_process.html#child_process_subprocess_kill_signal
+// To be on the safe side, check if the process was already killed before sending the signal
+function kill(childProcess, signal) {
+    if (!childProcess.killed) {
+        pgDebug('killing psql child process');
+        childProcess.kill(signal);
+    }
+}
+async function runWithTunnel(db, tunnelConfig, options) {
+    const tunnel = await Tunnel.connect(db, tunnelConfig);
+    pgDebug('after create tunnel');
+    const psql = execPSQL(options);
+    // interactive opens with stdio: 'inherit'
+    // which gives the child process the same stdin,stdout,stderr of the node process (global `process`)
+    // https://nodejs.org/api/child_process.html#child_process_options_stdio
+    // psql.stdout will be null in this case
+    // 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);
+    try {
+        pgDebug('waiting for psql or tunnel to exit');
+        // wait for either psql or tunnel to exit;
+        // the important bit is that we ensure both processes are
+        // always cleaned up in the `finally` block below
+        await Promise.race([
+            waitForPSQLExit(psql),
+            tunnel.waitForClose(),
+        ]);
+    }
+    catch (error) {
+        pgDebug('wait for psql or tunnel error', error);
+        throw error;
+    }
+    finally {
+        pgDebug('begin tunnel cleanup');
+        cleanupSignalTraps();
+        tunnel.close();
+        kill(psql, 'SIGKILL');
+        pgDebug('end tunnel cleanup');
+    }
+    return stdoutPromise;
+}
+// trap SIGINT so that ctrl+c can be used by psql without killing the
+// parent node process.
+// you can use ctrl+c in psql to kill running queries
+// while keeping the psql process open.
+// 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) => {
+    const signalsToTrap = ['SIGINT'];
+    const signalTraps = signalsToTrap.map(signal => {
+        process.removeAllListeners(signal);
+        const listener = () => kill(childProcess, signal);
+        process.on(signal, listener);
+        return [signal, listener];
+    });
+    // restores the built-in node ctrl+c and other handlers
+    return () => {
+        for (const [signal, listener] of signalTraps) {
+            process.removeListener(signal, listener);
+        }
+    };
+};
+exports.trapAndForwardSignalsToChildProcess = trapAndForwardSignalsToChildProcess;
+async function waitForPSQLExit(psql) {
+    let errorToThrow = null;
+    try {
+        const [exitCode] = await (0, node_events_1.once)(psql, 'close');
+        pgDebug(`psql exited with code ${exitCode}`);
+        if (exitCode > 0) {
+            errorToThrow = new Error(`psql exited with code ${exitCode}`);
+        }
+    }
+    catch (error) {
+        pgDebug('psql process error', error);
+        const { code } = error;
+        if (code === 'ENOENT') {
+            errorToThrow = new Error('The local psql command could not be located. For help installing psql, see https://devcenter.heroku.com/articles/heroku-postgresql#local-setup');
+        }
+    }
+    if (errorToThrow) {
+        throw errorToThrow;
+    }
+}
+// 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 {
+    constructor(bastionTunnel) {
+        this.bastionTunnel = bastionTunnel;
+        // eslint-disable-next-line unicorn/prefer-event-target
+        this.events = new node_events_1.EventEmitter();
+    }
+    static async connect(db, tunnelConfig) {
+        const tunnel = await (0, bastion_1.sshTunnel)(db, tunnelConfig);
+        return new Tunnel(tunnel);
+    }
+    close() {
+        if (this.bastionTunnel) {
+            pgDebug('close tunnel');
+            this.bastionTunnel.close();
+        }
+        else {
+            pgDebug('no tunnel necessary; sending fake close event');
+            this.events.emit('close', 0);
+        }
+    }
+    async waitForClose() {
+        if (this.bastionTunnel) {
+            try {
+                pgDebug('wait for tunnel close');
+                await (0, node_events_1.once)(this.bastionTunnel, 'close');
+                pgDebug('tunnel closed');
+            }
+            catch (error) {
+                pgDebug('tunnel close error', error);
+                throw new Error('Secure tunnel to your database failed');
+            }
+        }
+        else {
+            pgDebug('no bastion required; waiting for fake close event');
+            await (0, node_events_1.once)(this.events, 'close');
+        }
+    }
+}
+exports.Tunnel = Tunnel;

package/dist/ux/confirm.d.ts

@@ -0,0 +1 @@
+export declare function confirm(message: string): Promise<boolean>;

package/dist/ux/confirm.js

@@ -0,0 +1,7 @@
+"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);
+}

package/dist/ux/prompt.d.ts

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

package/dist/ux/prompt.js

@@ -0,0 +1,7 @@
+"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);
+}

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

@@ -0,0 +1 @@
+export declare function styledHeader(header: string): void;

package/dist/ux/styled-header.js

@@ -0,0 +1,7 @@
+"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);
+}

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

@@ -0,0 +1 @@
+export declare function styledJson(obj: unknown): void;

package/dist/ux/styled-json.js

@@ -0,0 +1,7 @@
+"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);
+}

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

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

package/dist/ux/styled-object.js

@@ -0,0 +1,7 @@
+"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);
+}

package/dist/ux/table.d.ts

@@ -0,0 +1,2 @@
+import { ux } from '@oclif/core';
+export declare function table<T extends Record<string, unknown>>(data: T[], columns: Parameters<typeof ux.table>[1], options?: Parameters<typeof ux.table>[2]): void;

package/dist/ux/table.js

@@ -0,0 +1,7 @@
+"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);
+}

package/dist/ux/wait.d.ts

@@ -0,0 +1 @@
+export declare function wait(ms?: number): Promise<void>;

package/dist/ux/wait.js

@@ -0,0 +1,7 @@
+"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);
+}