heroku 9.0.0-dev.0 → 9.0.0

package/lib/lib/pg/backups.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const color_1 = require("@heroku-cli/color");
+const core_1 = require("@oclif/core");
+const tsheredoc_1 = require("tsheredoc");
+const host_1 = require("./host");
+const bytes = require("bytes");
+function prefix(transfer) {
+    if (transfer.from_type === 'pg_dump') {
+        if (transfer.to_type === 'pg_restore') {
+            return 'c';
+        }
+        return transfer.schedule ? 'a' : 'b';
+        // eslint-disable-next-line no-else-return
+    }
+    else {
+        if (transfer.to_type === 'pg_restore') {
+            return 'r';
+        }
+        return 'b';
+    }
+}
+class Backups {
+    constructor(app, heroku) {
+        this.logsAlreadyShown = new Set();
+        this.status = (transfer) => {
+            if (transfer.finished_at && transfer.succeeded) {
+                const warnings = transfer.warnings;
+                if (warnings > 0) {
+                    return `Finished with ${warnings} warnings`;
+                }
+                return `Completed ${transfer.finished_at}`;
+            }
+            if (transfer.finished_at) {
+                return `Failed ${transfer.finished_at}`;
+            }
+            if (transfer.started_at) {
+                return `Running (processed ${this.filesize(transfer.processed_bytes)})`;
+            }
+            return 'Pending';
+        };
+        this.num = async (name) => {
+            let m = name.match(/^[abcr](\d+)$/);
+            if (m)
+                return Number.parseInt(m[1], 10);
+            m = name.match(/^o[ab]\d+$/);
+            if (m) {
+                const { body: transfers } = await this.heroku.get(`/client/v11/apps/${this.app}/transfers`, { hostname: (0, host_1.default)() });
+                const transfer = transfers.find(t => this.name(t) === name);
+                if (transfer)
+                    return transfer.num;
+            }
+        };
+        this.name = (transfer) => {
+            const oldPGBName = transfer.options && transfer.options.pgbackups_name;
+            if (oldPGBName)
+                return `o${oldPGBName}`;
+            return `${prefix(transfer)}${(transfer.num || '').toString().padStart(3, '0')}`;
+        };
+        this.wait = async (action, transferID, interval, verbose, app) => {
+            var e_1, _a;
+            if (verbose) {
+                core_1.ux.log(`${action}...`);
+            }
+            core_1.ux.action.start(action);
+            try {
+                try {
+                    for (var _b = tslib_1.__asyncValues(this.poll(transferID, interval, verbose, app || this.app)), _c; _c = await _b.next(), !_c.done;) {
+                        const backupSucceeded = _c.value;
+                        if (backupSucceeded) {
+                            core_1.ux.action.stop();
+                            break;
+                        }
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (_c && !_c.done && (_a = _b.return)) await _a.call(_b);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+            }
+            catch (error) {
+                core_1.ux.action.stop('!');
+                core_1.ux.error(error);
+            }
+        };
+        this.app = app;
+        this.heroku = heroku;
+    }
+    filesize(size, opts = {}) {
+        Object.assign(opts, {
+            decimalPlaces: 2,
+            fixedDecimals: true,
+        });
+        return bytes(size, opts);
+    }
+    displayLogs(logs) {
+        for (const log of logs) {
+            if (this.logsAlreadyShown.has(log.created_at + log.message)) {
+                continue;
+            }
+            this.logsAlreadyShown.add(log.created_at + log.message);
+            core_1.ux.log(`${log.created_at} ${log.message}`);
+        }
+    }
+    poll(transferID, interval, verbose, appId) {
+        var _a;
+        return tslib_1.__asyncGenerator(this, arguments, function* poll_1() {
+            const tty = process.env.TERM !== 'dumb' && process.stderr.isTTY;
+            let backup = {};
+            let failures = 0;
+            const quietUrl = `/client/v11/apps/${appId !== null && appId !== void 0 ? appId : this.app}/transfers/${transferID}`;
+            const verboseUrl = quietUrl + '?verbose=true';
+            const url = verbose ? verboseUrl : quietUrl;
+            while (failures < 21) {
+                try {
+                    ({ body: backup } = yield tslib_1.__await(this.heroku.get(url, { hostname: (0, host_1.default)() })));
+                }
+                catch (error) {
+                    if (failures++ > 20) {
+                        throw error;
+                    }
+                }
+                if (verbose) {
+                    this.displayLogs(backup.logs);
+                }
+                else if (tty) {
+                    const msg = backup.started_at ? this.filesize(backup.processed_bytes) : 'pending';
+                    const log = (_a = backup.logs) === null || _a === void 0 ? void 0 : _a.pop();
+                    if (log) {
+                        core_1.ux.action.status = `${msg}\n${log.created_at + ' ' + log.message}`;
+                    }
+                    else {
+                        core_1.ux.action.status = msg;
+                    }
+                }
+                if (backup === null || backup === void 0 ? void 0 : backup.finished_at) {
+                    if (backup.succeeded) {
+                        yield yield tslib_1.__await(true);
+                        break;
+                    }
+                    // logs is undefined unless verbose=true is passed
+                    ({ body: backup } = yield tslib_1.__await(this.heroku.get(verboseUrl, { hostname: (0, host_1.default)() })));
+                    throw new Error((0, tsheredoc_1.default)(`
+          An error occurred and the backup did not finish.
+
+          ${backup.logs.slice(-5).map(l => l.message).join('\n')}
+
+          Run ${color_1.default.cmd('heroku pg:backups:info ' + this.name(backup))} for more details.`));
+                }
+                yield yield tslib_1.__await(new Promise(resolve => {
+                    setTimeout(resolve, interval * 1000);
+                }));
+            }
+        });
+    }
+}
+function factory(app, heroku) {
+    return new Backups(app, heroku);
+}
+exports.default = factory;

package/lib/lib/pg/bastion.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { APIClient } from '@heroku-cli/command';
+import * as createTunnel from 'tunnel-ssh';
+import { ConnectionDetails } from './util';
+export declare const getBastion: (config: Record<string, string>, baseName: string) => {
+    bastionHost: string;
+    bastionKey: string;
+} | {
+    bastionHost?: undefined;
+    bastionKey?: undefined;
+};
+export declare const env: (db: ConnectionDetails) => {
+    PGAPPNAME: string;
+    PGSSLMODE: string;
+} & NodeJS.ProcessEnv;
+export declare type TunnelConfig = createTunnel.Config;
+export declare function tunnelConfig(db: ConnectionDetails): TunnelConfig;
+export declare function getConfigs(db: ConnectionDetails): {
+    dbEnv: NodeJS.ProcessEnv;
+    dbTunnelConfig: createTunnel.Config;
+};
+export declare function sshTunnel(db: ConnectionDetails, dbTunnelConfig: TunnelConfig, timeout?: number): Promise<void | import("net").Server | null>;
+export declare function fetchConfig(heroku: APIClient, db: {
+    id: string;
+}): Promise<import("http-call").HTTP<{
+    host: string;
+    private_key: string;
+}>>;

package/lib/lib/pg/bastion.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchConfig = exports.sshTunnel = exports.getConfigs = exports.tunnelConfig = exports.env = exports.getBastion = void 0;
+const debug = require('debug')('pg');
+const EventEmitter = require("node:events");
+const createTunnel = require("tunnel-ssh");
+const util_1 = require("util");
+const host_1 = require("./host");
+const core_1 = require("@oclif/core");
+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;
+const env = (db) => {
+    const baseEnv = Object.assign({
+        PGAPPNAME: 'psql non-interactive',
+        PGSSLMODE: (!db.host || db.host === 'localhost') ? 'prefer' : 'require',
+    }, process.env);
+    const mapping = {
+        PGUSER: 'user',
+        PGPASSWORD: 'password',
+        PGDATABASE: 'database',
+        PGPORT: 'port',
+        PGHOST: 'host',
+    };
+    Object.keys(mapping).forEach(envVar => {
+        const val = db[mapping[envVar]];
+        if (val) {
+            baseEnv[envVar] = val;
+        }
+    });
+    return baseEnv;
+};
+exports.env = env;
+function tunnelConfig(db) {
+    const localHost = '127.0.0.1';
+    const localPort = Math.floor((Math.random() * (65535 - 49152)) + 49152);
+    return {
+        username: 'bastion',
+        host: db.bastionHost,
+        privateKey: db.bastionKey,
+        dstHost: db.host || undefined,
+        dstPort: (db.port && Number.parseInt(db.port, 10)) || undefined,
+        localHost,
+        localPort,
+    };
+}
+exports.tunnelConfig = tunnelConfig;
+function getConfigs(db) {
+    const dbEnv = (0, exports.env)(db);
+    const dbTunnelConfig = tunnelConfig(db);
+    if (db.bastionKey) {
+        Object.assign(dbEnv, {
+            PGPORT: dbTunnelConfig.localPort,
+            PGHOST: dbTunnelConfig.localHost,
+        });
+    }
+    return {
+        dbEnv,
+        dbTunnelConfig,
+    };
+}
+exports.getConfigs = getConfigs;
+class Timeout {
+    constructor(timeout, message) {
+        this.events = new EventEmitter();
+        this.timeout = timeout;
+        this.message = message;
+    }
+    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);
+        }
+    }
+    cancel() {
+        this.events.emit('cancelled');
+    }
+}
+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, util_1.promisify)(createTunnel);
+    try {
+        return await Promise.race([
+            timeoutInstance.promise(),
+            createSSHTunnel(dbTunnelConfig),
+        ]);
+    }
+    catch (error) {
+        debug(error);
+        core_1.ux.error('Unable to establish a secure tunnel to your database.');
+    }
+    finally {
+        timeoutInstance.cancel();
+    }
+}
+exports.sshTunnel = sshTunnel;
+async function fetchConfig(heroku, db) {
+    return heroku.get(`/client/v11/databases/${encodeURIComponent(db.id)}/bastion`, {
+        hostname: (0, host_1.default)(),
+    });
+}
+exports.fetchConfig = fetchConfig;

package/lib/lib/pg/config.d.ts

@@ -0,0 +1,2 @@
+import type { APIClient } from '@heroku-cli/command';
+export declare function getConfig(heroku: APIClient, app: string): Promise<Record<string, string> | undefined>;

package/lib/lib/pg/config.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConfig = void 0;
+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;
+}
+exports.getConfig = getConfig;

package/lib/lib/pg/download.d.ts

@@ -0,0 +1,5 @@
+declare type downloadOptions = {
+    progress: boolean;
+};
+export default function download(url: string, path: string, opts: downloadOptions): Promise<unknown>;
+export {};

package/lib/lib/pg/download.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = require("fs-extra");
+const Path = require("path");
+const https = require('https');
+const bytes = require('bytes');
+const progress = require('smooth-progress');
+function download(url, path, opts) {
+    const tty = process.stderr.isTTY && process.env.TERM !== 'dumb';
+    function showProgress(rsp) {
+        const bar = progress({
+            tmpl: `Downloading ${path}... :bar :percent :eta :data`,
+            width: 25,
+            total: Number.parseInt(rsp.headers['content-length'], 10),
+        });
+        let total = 0;
+        rsp.on('data', function (chunk) {
+            total += chunk.length;
+            bar.tick(chunk.length, { data: bytes(total, { decimalPlaces: 2, fixedDecimals: 2 }) });
+        });
+    }
+    return new Promise(function (resolve, reject) {
+        fs.mkdirSync(Path.dirname(path), { recursive: true });
+        const file = fs.createWriteStream(path);
+        https.get(url, function (rsp) {
+            if (tty && opts.progress)
+                showProgress(rsp);
+            rsp.pipe(file)
+                .on('error', reject)
+                .on('close', resolve);
+        });
+    });
+}
+exports.default = download;

package/lib/lib/pg/fetcher.d.ts

@@ -0,0 +1,39 @@
+import { APIClient } from '@heroku-cli/command';
+import type { AddOnAttachment } from '@heroku-cli/schema';
+import * as Heroku from '@heroku-cli/schema';
+import type { AddOnAttachmentWithConfigVarsAndPlan, AddOnWithRelatedData } from './types';
+export declare function arbitraryAppDB(heroku: APIClient, app: string): Promise<Heroku.AddOn>;
+export declare function all(heroku: APIClient, app_id: string): Promise<AddOnWithRelatedData[]>;
+export declare function getAttachment(heroku: APIClient, app: string, db?: string, namespace?: string): Promise<Required<AddOnAttachment & {
+    addon: AddOnAttachmentWithConfigVarsAndPlan;
+}>>;
+export declare function getAddon(heroku: APIClient, app: string, db?: string): Promise<{
+    id: string;
+    name: string;
+    app: {
+        [k: string]: any;
+        id?: string | undefined;
+        name?: string | undefined;
+    };
+} & Required<AddOnAttachment> & {
+    config_vars: string[] | undefined;
+    addon: Required<{
+        id: string;
+        name: string;
+        app: {
+            [k: string]: any;
+            id?: string | undefined;
+            name?: string | undefined;
+        };
+    }> & {
+        attachment_names?: string[] | undefined;
+        links?: import("./types").Link[] | undefined;
+        plan: Required<{
+            [k: string]: any;
+            id?: string | undefined;
+            name?: string | undefined;
+        } | undefined>;
+    };
+}>;
+export declare function database(heroku: APIClient, app: string, db?: string, namespace?: string): Promise<import("./util").ConnectionDetailsWithAttachment>;
+export declare function getRelease(heroku: APIClient, appName: string, id: string): Promise<Heroku.Release>;

package/lib/lib/pg/fetcher.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRelease = exports.database = exports.getAddon = exports.getAttachment = exports.all = exports.arbitraryAppDB = void 0;
+const api_client_1 = require("@heroku-cli/command/lib/api-client");
+const debug_1 = require("debug");
+const resolve_1 = require("../addons/resolve");
+const bastion_1 = require("./bastion");
+const config_1 = require("./config");
+const color_1 = require("@heroku-cli/color");
+const util_1 = require("./util");
+const pgDebug = (0, debug_1.default)('pg');
+async function arbitraryAppDB(heroku, app) {
+    // Since Postgres backups are tied to the app and not the add-on, but
+    // we require *an* add-on to interact with, make sure that add-on is
+    // attached to the right app.
+    pgDebug(`fetching arbitrary app db on ${app}`);
+    const { body: addons } = await heroku.get(`/apps/${app}/addons`);
+    const addon = addons.find(a => { var _a, _b, _c; return ((_a = a === null || a === void 0 ? void 0 : a.app) === null || _a === void 0 ? void 0 : _a.name) === app && ((_c = (_b = a === null || a === void 0 ? void 0 : a.plan) === null || _b === void 0 ? void 0 : _b.name) === null || _c === void 0 ? void 0 : _c.startsWith('heroku-postgresql')); });
+    if (!addon)
+        throw new Error(`No heroku-postgresql databases on ${app}`);
+    return addon;
+}
+exports.arbitraryAppDB = arbitraryAppDB;
+function getAttachmentNamesByAddon(attachments) {
+    return attachments.reduce((results, a) => {
+        results[a.addon.id] = (results[a.addon.id] || []).concat(a.name);
+        return results;
+    }, {});
+}
+async function all(heroku, app_id) {
+    const { uniqBy } = require('lodash');
+    pgDebug(`fetching all DBs on ${app_id}`);
+    const attachments = await allAttachments(heroku, app_id);
+    let addons = attachments.map(a => a.addon);
+    // Get the list of attachment names per addon here and add to each addon obj
+    const attachmentNamesByAddon = getAttachmentNamesByAddon(attachments);
+    addons = uniqBy(addons, 'id');
+    addons.forEach(addon => {
+        addon.attachment_names = attachmentNamesByAddon[addon.id];
+    });
+    return addons;
+}
+exports.all = all;
+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 resolve_1.AmbiguousError && ((_a = error.body) === null || _a === void 0 ? void 0 : _a.id) === 'multiple_matches' && error.matches) {
+            return { matches: error.matches, error };
+        }
+        if (error instanceof api_client_1.HerokuAPIError && error.http.statusCode === 404 && error.body && error.body.id === 'not_found') {
+            return { matches: null, error };
+        }
+        throw error;
+    }
+}
+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_1.getConfig)(heroku, app),
+            allAttachments(heroku, app),
+        ]);
+        if (attachments.length === 0) {
+            throw new Error(`${color_1.default.app(app)} has no databases`);
+        }
+        console.log('hi', JSON.stringify(attachments));
+        matches = attachments.filter(attachment => config[db] && config[db] === config[(0, util_1.getConfigVarName)(attachment.config_vars)]);
+        if (matches.length === 0) {
+            const validOptions = attachments.map(attachment => (0, util_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_1.getConfig)(heroku, first.app.name)) !== null && _a !== void 0 ? _a : {};
+        if (matches.every(match => config[(0, util_1.getConfigVarName)(first.config_vars)] === config[(0, util_1.getConfigVarName)(match.config_vars)])) {
+            return first;
+        }
+    }
+    throw error;
+}
+exports.getAttachment = getAttachment;
+async function allAttachments(heroku, app_id) {
+    const { body: attachments } = await heroku.get(`/apps/${app_id}/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 getAddon(heroku, app, db = 'DATABASE_URL') {
+    return (await getAttachment(heroku, app, db)).addon;
+}
+exports.getAddon = getAddon;
+async function database(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_1.getConfig)(heroku, attached.app.name);
+    const database = (0, util_1.getConnectionDetails)(attached, config);
+    if ((0, util_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;
+}
+exports.database = database;
+async function getRelease(heroku, appName, id) {
+    const { body: release } = await heroku.get(`/apps/${appName}/releases/${id}`);
+    return release;
+}
+exports.getRelease = getRelease;

package/lib/lib/pg/host.d.ts

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

package/lib/lib/pg/host.js

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

package/lib/lib/pg/psql.d.ts

@@ -0,0 +1,48 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { SpawnOptions, type SpawnOptionsWithStdioTuple } from 'child_process';
+import type { ChildProcess } from 'node:child_process';
+import { EventEmitter } from 'node:events';
+import type { Server } from 'node:net';
+import { Stream } from 'node:stream';
+import { getConfigs, TunnelConfig } from './bastion';
+import { ConnectionDetails, getConnectionDetails } from './util';
+export declare function psqlQueryOptions(query: string, dbEnv: NodeJS.ProcessEnv, cmdArgs?: string[]): {
+    dbEnv: NodeJS.ProcessEnv;
+    psqlArgs: string[];
+    childProcessOptions: SpawnOptionsWithStdioTuple<"ignore", "pipe", "inherit">;
+};
+export declare function psqlFileOptions(file: string, dbEnv: NodeJS.ProcessEnv): {
+    dbEnv: NodeJS.ProcessEnv;
+    psqlArgs: string[];
+    childProcessOptions: SpawnOptions;
+};
+export declare function psqlInteractiveOptions(prompt: string, dbEnv: NodeJS.ProcessEnv): {
+    dbEnv: NodeJS.ProcessEnv;
+    psqlArgs: string[];
+    childProcessOptions: SpawnOptions;
+};
+export declare function execPSQL({ dbEnv, psqlArgs, childProcessOptions }: {
+    dbEnv: NodeJS.ProcessEnv;
+    psqlArgs: string[];
+    childProcessOptions: SpawnOptions;
+}): ChildProcess;
+export declare function waitForPSQLExit(psql: EventEmitter): Promise<void>;
+export declare const trapAndForwardSignalsToChildProcess: (childProcess: ChildProcess) => () => void;
+export declare function consumeStream(inputStream: Stream): Promise<unknown>;
+export declare function runWithTunnel(db: ConnectionDetails, tunnelConfig: TunnelConfig, options: Parameters<typeof execPSQL>[0]): Promise<string>;
+export declare class Tunnel {
+    private readonly bastionTunnel;
+    private readonly events;
+    constructor(bastionTunnel: Server);
+    waitForClose(): Promise<void>;
+    close(): void;
+    static connect(db: ConnectionDetails, tunnelConfig: TunnelConfig): Promise<Tunnel>;
+}
+export declare function fetchVersion(db: Parameters<typeof exec>[0]): Promise<string | undefined>;
+export declare function exec(db: ConnectionDetails, query: string, cmdArgs?: string[]): Promise<string>;
+export declare function execFile(db: Parameters<typeof getConfigs>[0], file: string): Promise<string>;
+export declare function interactive(db: ReturnType<typeof getConnectionDetails>): Promise<string>;