@hyperfixation/cli 0.1.4 → 0.1.6

package/dist/database.js

@@ -61,8 +61,8 @@ export async function openDatabase(runner, options) {
         throw new DatabaseTransportError("tunnel", `could not reach Postgres on ${TUNNEL_LOOPBACK}:${String(remotePort)} on the box, and no ` +
             "container was named to discover an address on the docker network", { cause: loopback.failure });
     }
-    const found = await containerAddress(runner, candidates);
-    const direct = await tryTunnel(runner, options.admin, remotePort, found.address);
+    const found = await findPostgresContainer(runner, candidates);
+    const direct = await tryTunnel(runner, options.admin, remotePort, found.address, found.container);
     if ("database" in direct)
         return direct.database;
     if (options.dockerExec !== true) {
@@ -74,16 +74,13 @@ export async function openDatabase(runner, options) {
 }
 /** The cluster at a URL this process can already dial — a test's Postgres, or a live tunnel. */
 export function openDatabaseUrl(adminUrl) {
-    return tunnelDatabase(adminUrl, undefined, undefined);
+    return tunnelDatabase(adminUrl, undefined, undefined, undefined);
 }
-async function tryTunnel(runner, admin, remotePort, remoteHost) {
+async function tryTunnel(runner, admin, remotePort, remoteHost, container) {
     let tunnel;
     try {
         tunnel = await runner.tunnel(remotePort, remoteHost);
-        const database = tunnelDatabase(adminUrlOf(admin, tunnel.localPort), tunnel, {
-            host: remoteHost,
-            port: remotePort,
-        });
+        const database = tunnelDatabase(adminUrlOf(admin, tunnel.localPort), tunnel, { host: remoteHost, port: remotePort }, container);
         await database.query("SELECT 1");
         return { database };
     }
@@ -100,7 +97,7 @@ async function tryTunnel(runner, admin, remotePort, remoteHost) {
  * network something else. Every candidate that failed is reported, because which name a database
  * got is a fact about how it was created and the operator is the one who knows it.
  */
-async function containerAddress(runner, containers) {
+export async function findPostgresContainer(runner, containers) {
     const problems = [];
     for (const container of containers) {
         const command = ["docker", "inspect", "-f", DOCKER_NETWORKS_FORMAT, container];
@@ -135,7 +132,7 @@ function coolifyAddress(stdout) {
         .filter((entry) => isIPv4(entry.address));
     return (networks.find((entry) => entry.network === COOLIFY_NETWORK) ?? networks[0])?.address;
 }
-function tunnelDatabase(adminUrl, tunnel, boxAddress) {
+function tunnelDatabase(adminUrl, tunnel, boxAddress, container) {
     const clients = new Map();
     const clientFor = async (databaseName) => {
         const url = withDatabase(adminUrl, databaseName);
@@ -150,6 +147,7 @@ function tunnelDatabase(adminUrl, tunnel, boxAddress) {
     return {
         kind: "tunnel",
         boxAddress,
+        container,
         adminUrl: (databaseName) => withDatabase(adminUrl, databaseName),
         query: async (sql, queryOptions) => {
             const client = await clientFor(queryOptions?.database);
@@ -175,6 +173,7 @@ function tunnelDatabase(adminUrl, tunnel, boxAddress) {
 function dockerExecDatabase(runner, container, admin) {
     return {
         kind: "docker-exec",
+        container,
         adminUrl: () => undefined,
         query: async (sql, queryOptions) => {
             // `-f -`: the statement goes down stdin, so it never appears in the box's process list

package/dist/deploy-app.d.ts

@@ -0,0 +1,32 @@
+import { type StepExec, type StepOut } from "./cloud-steps/index.js";
+import { type OperatorConfig } from "./config.js";
+import type { FetchLike } from "./providers/http.js";
+export interface DeployAppOptions {
+    /** The app as `hf new` named it, which is also its state file's name. */
+    app: string;
+    /** The commit to deploy. Defaults to `main`'s on the app's own repository. */
+    sha?: string;
+    io: StepOut;
+    config?: OperatorConfig;
+    /** Where the per-app state files are. Defaults to `stateDir()`. */
+    stateDir?: string;
+    env?: NodeJS.ProcessEnv;
+    fetch?: FetchLike;
+    exec?: StepExec;
+    now?: () => number;
+    sleep?: (ms: number) => Promise<void>;
+}
+export interface DeployAppResult {
+    app: string;
+    /** The commit the app answered `/api/status` with before this returned. */
+    sha: string;
+    url: string;
+}
+/**
+ * `hf deploy <name>` — point the app at a commit and wait until it says it is serving it.
+ *
+ * The same path as `hf new`'s tenth step, and the reason there is a command at all: auto-deploy
+ * is off, so a merge to main changes nothing on the box until this runs. Everything it needs is
+ * in the state cache the provisioning run wrote; nothing here is interactive.
+ */
+export declare function deployApp(options: DeployAppOptions): Promise<DeployAppResult>;

package/dist/deploy-app.js

@@ -0,0 +1,81 @@
+import { deployCommit } from "./cloud-steps/deploy.js";
+import { spawnStepExec, StepFailed } from "./cloud-steps/index.js";
+import { gitAuthEnv } from "./cloud-steps/repo.js";
+import { loadOperatorConfig, requireOperatorConfig } from "./config.js";
+import { deriveNames } from "./names.js";
+import { CoolifyClient } from "./providers/coolify.js";
+import { openAppState } from "./state.js";
+/** What a commit looks like once `git` has resolved it; `/api/status` reports the same form. */
+const FULL_SHA = /^[0-9a-f]{40}$/;
+/**
+ * `hf deploy <name>` — point the app at a commit and wait until it says it is serving it.
+ *
+ * The same path as `hf new`'s tenth step, and the reason there is a command at all: auto-deploy
+ * is off, so a merge to main changes nothing on the box until this runs. Everything it needs is
+ * in the state cache the provisioning run wrote; nothing here is interactive.
+ */
+export async function deployApp(options) {
+    const env = options.env ?? process.env;
+    const config = options.config ?? (await loadOperatorConfig({ env }));
+    const names = deriveNames(options.app);
+    const required = requireOperatorConfig(config, ["HF_COOLIFY_URL", "HF_COOLIFY_TOKEN", "HF_BASE_DOMAIN", "HF_GITHUB_TOKEN"], { env });
+    const store = await openAppState(names.given, { dir: options.stateDir, env });
+    const { coolify, statusTokens, repo } = store.state;
+    const appUuid = coolify?.appUuid;
+    const readToken = statusTokens?.read;
+    if (appUuid === undefined || readToken === undefined) {
+        const missing = appUuid === undefined ? "Coolify application uuid" : "read status token";
+        throw new StepFailed(`${store.file} has no ${missing}: hf new has not finished provisioning ${names.given}`);
+    }
+    const sha = options.sha === undefined
+        ? await mainSha(options, repo, required.HF_GITHUB_TOKEN)
+        : options.sha;
+    if (!FULL_SHA.test(sha)) {
+        throw new StepFailed(`${sha} is not a commit sha: --sha takes the full forty hex characters, because that is ` +
+            "what /api/status reports back");
+    }
+    const fqdn = `${names.given}.${required.HF_BASE_DOMAIN}`;
+    await deployCommit({
+        name: names.given,
+        appUuid,
+        fqdn,
+        sha,
+        readToken,
+        coolify: new CoolifyClient({
+            url: required.HF_COOLIFY_URL,
+            token: required.HF_COOLIFY_TOKEN,
+            fetch: options.fetch,
+        }),
+        io: options.io,
+        now: options.now ?? (() => Date.now()),
+        sleep: options.sleep ?? (async (ms) => await new Promise((resolve) => setTimeout(resolve, ms))),
+        fetch: options.fetch,
+    });
+    await store.patch({ lastDeployedSha: sha });
+    return { app: names.given, sha, url: `https://${fqdn}` };
+}
+/**
+ * `main`'s sha on the app's repository, read with `git ls-remote` and no checkout.
+ *
+ * The remote rather than a local clone: the operator running this has just merged a pull request,
+ * and whatever is in a directory on the laptop is not what the box would build.
+ */
+async function mainSha(options, repo, token) {
+    if (repo === undefined) {
+        throw new StepFailed(`no owner/name repository in ${options.app}'s state cache: nothing can be asked what main ` +
+            "is. Pass --sha <sha>.");
+    }
+    const url = `https://github.com/${repo}.git`;
+    const exec = options.exec ?? spawnStepExec;
+    const outcome = await exec("git", ["ls-remote", url, "refs/heads/main"], {
+        cwd: process.cwd(),
+        capture: true,
+        env: gitAuthEnv(token),
+    });
+    const sha = /^([0-9a-f]{40})\s/.exec(outcome.stdout.trim())?.[1];
+    if (outcome.code !== 0 || sha === undefined) {
+        throw new StepFailed(`git ls-remote ${url} refs/heads/main named no commit: the repository may be gone, the ` +
+            "branch unborn, or HF_GITHUB_TOKEN unable to read it. Pass --sha <sha>.");
+    }
+    return sha;
+}

package/dist/doctor.js

@@ -142,7 +142,7 @@ async function doctorApp(context, name) {
         }
     }
     const report = await statusFindings(context, name, state, add);
-    versionFinding(report?.applicationVersion, mainSha, mainShaProblem, add);
+    versionFinding(name, report?.applicationVersion, mainSha, mainShaProblem, add);
     if (report?.budget !== undefined) {
         budgetFinding(report.budget.current, "current", add);
         budgetFinding(report.budget.previous, "previous", add);
@@ -232,7 +232,14 @@ function amount(value) {
     const parsed = Number(value);
     return Number.isFinite(parsed) ? parsed : undefined;
 }
-function versionFinding(deployed, mainSha, mainShaProblem, add) {
+/**
+ * What the app answers against what its repository's main holds.
+ *
+ * The mismatch names `hf deploy` because nothing else closes it: Coolify's push auto-deploy is
+ * disabled on every application `hf new` creates, so a merged pull request sits unpublished until
+ * an operator says so.
+ */
+function versionFinding(name, deployed, mainSha, mainShaProblem, add) {
     if (mainShaProblem !== undefined) {
         add("version", "fail", mainShaProblem);
         return;
@@ -245,7 +252,7 @@ function versionFinding(deployed, mainSha, mainShaProblem, add) {
     }
     add("version", deployed === mainSha ? "ok" : "warn", deployed === mainSha
         ? `applicationVersion ${short(mainSha)} is main`
-        : `applicationVersion ${short(deployed)} is not main ${short(mainSha)}`);
+        : `applicationVersion ${short(deployed)} is not main ${short(mainSha)} — run hf deploy ${name}`);
 }
 function budgetFinding(period, which, add) {
     if (period === null) {

package/dist/index.d.ts

@@ -15,7 +15,7 @@ export { generate, GENERATOR_BIN, GENERATOR_CONFIG, NoGenerators, type GenerateO
 export { dev, devBuildSha, DEV_COMPOSE_FILE, type DevOptions, type DevResult } from "./dev.js";
 export { run, CommandFailed, type RunOptions } from "./spawn.js";
 export { createLocalRunner, createSshRunner, shellQuote, sshExecArgv, sshTunnelArgv, RunnerError, DEFAULT_TUNNEL_READY_TIMEOUT_MS, type ExecOptions, type ExecResult, type LocalRunner, type LocalRunnerOptions, type Runner, type SshRunnerOptions, type Tunnel, } from "./runner.js";
-export { openDatabase, openDatabaseUrl, redactPasswords, DatabaseTransportError, DEFAULT_POSTGRES_PORT, type AdminCredentials, type Database, type DatabaseTransport, type OpenDatabaseOptions, type QueryOptions, type QueryResult, } from "./database.js";
+export { findPostgresContainer, openDatabase, openDatabaseUrl, redactPasswords, DatabaseTransportError, DEFAULT_POSTGRES_PORT, type AdminCredentials, type Database, type DatabaseTransport, type OpenDatabaseOptions, type QueryOptions, type QueryResult, } from "./database.js";
 export { createLocalDirectoryBackupSource, createS3BackupSource, BackupSourceError, COOLIFY_BACKUP_DIR, type BackupDump, type BackupSource, type BackupSourceKind, type LocalDirectoryBackupSourceOptions, } from "./backup-source.js";
-export { formatRestoreCheck, pgRestoreArgv, restoreCheck, restoreCheckApp, RestoreCheckError, SCRATCH_SUFFIX, STALE_DUMP_HOURS, type RestoreCheckAppOptions, type RestoreCheckOptions, type RestoreCheckResult, type RestoreCheckRow, type RestoreVerdict, } from "./restore-check.js";
+export { formatRestoreCheck, pgRestoreArgv, pgRestoreInContainerArgv, restoreCheck, restoreCheckApp, RestoreCheckError, SCRATCH_SUFFIX, STALE_DUMP_HOURS, type RestoreCheckAppOptions, type RestoreCheckOptions, type RestoreCheckResult, type RestoreCheckRow, type RestoreVerdict, } from "./restore-check.js";
 export { provisionDatabase, ProvisionDatabaseError, REQUIRED_EXTENSIONS, type ProvisionDatabaseOptions, type ProvisionDatabaseResult, } from "./provision-database.js";

package/dist/index.js

@@ -15,7 +15,7 @@ export { generate, GENERATOR_BIN, GENERATOR_CONFIG, NoGenerators, } from "./gen.
 export { dev, devBuildSha, DEV_COMPOSE_FILE } from "./dev.js";
 export { run, CommandFailed } from "./spawn.js";
 export { createLocalRunner, createSshRunner, shellQuote, sshExecArgv, sshTunnelArgv, RunnerError, DEFAULT_TUNNEL_READY_TIMEOUT_MS, } from "./runner.js";
-export { openDatabase, openDatabaseUrl, redactPasswords, DatabaseTransportError, DEFAULT_POSTGRES_PORT, } from "./database.js";
+export { findPostgresContainer, openDatabase, openDatabaseUrl, redactPasswords, DatabaseTransportError, DEFAULT_POSTGRES_PORT, } from "./database.js";
 export { createLocalDirectoryBackupSource, createS3BackupSource, BackupSourceError, COOLIFY_BACKUP_DIR, } from "./backup-source.js";
-export { formatRestoreCheck, pgRestoreArgv, restoreCheck, restoreCheckApp, RestoreCheckError, SCRATCH_SUFFIX, STALE_DUMP_HOURS, } from "./restore-check.js";
+export { formatRestoreCheck, pgRestoreArgv, pgRestoreInContainerArgv, restoreCheck, restoreCheckApp, RestoreCheckError, SCRATCH_SUFFIX, STALE_DUMP_HOURS, } from "./restore-check.js";
 export { provisionDatabase, ProvisionDatabaseError, REQUIRED_EXTENSIONS, } from "./provision-database.js";

package/dist/new-cloud.d.ts

@@ -77,9 +77,10 @@ export declare function invalidateStaleSecretSteps(state: AppStateStore): Promis
 export declare function runSteps<Context extends CloudContext>(steps: readonly Step<Context>[], context: Context): Promise<RunStepsResult>;
 /**
  * The keys a cloud `hf new` runs without: three have a default derived from another key, the two
- * provider keys are what the checklist warns about when they are unset, and the three Langfuse
- * keys are three ways of configuring one step — an org key, a project key pair, or neither, which
- * the step degrades to a warning and a checklist line.
+ * provider keys are what the checklist warns about when they are unset, the three Langfuse keys
+ * are three ways of configuring one step — an org key, a project key pair, or neither, which the
+ * step degrades to a warning and a checklist line — and the S3 storage is one the backup step
+ * discovers when the box has exactly one, and warns about when it cannot.
  */
 export declare const OPTIONAL_CLOUD_CONFIG: readonly ConfigKey[];
 /**

package/dist/new-cloud.js

@@ -108,11 +108,13 @@ export async function runSteps(steps, context) {
 }
 /**
  * The keys a cloud `hf new` runs without: three have a default derived from another key, the two
- * provider keys are what the checklist warns about when they are unset, and the three Langfuse
- * keys are three ways of configuring one step — an org key, a project key pair, or neither, which
- * the step degrades to a warning and a checklist line.
+ * provider keys are what the checklist warns about when they are unset, the three Langfuse keys
+ * are three ways of configuring one step — an org key, a project key pair, or neither, which the
+ * step degrades to a warning and a checklist line — and the S3 storage is one the backup step
+ * discovers when the box has exactly one, and warns about when it cannot.
  */
 export const OPTIONAL_CLOUD_CONFIG = [
+    "HF_COOLIFY_S3_STORAGE_UUID",
     "HF_DB_HOST_INTERNAL",
     "HF_DB_CONTAINER",
     "HF_PG_ADMIN_USER",

package/dist/providers/coolify.d.ts

@@ -80,6 +80,23 @@ export interface CoolifyEnvironmentVariable {
     is_literal?: boolean;
     is_multiline?: boolean;
     is_shown_once?: boolean;
+    /**
+     * Whether the builder interpolates the variable, and whether the containers get it.
+     *
+     * Both default true in Coolify's UI and neither is in the document's *request* schemas —
+     * only in its `EnvironmentVariable` model — but the box accepts and stores them (verified
+     * against 4.3.21). `SOURCE_COMMIT` needs both: it is the compose image tag and build arg as
+     * well as the `HF_BUILD_SHA` three services read.
+     */
+    is_buildtime?: boolean;
+    is_runtime?: boolean;
+}
+/** One entry of `GET /applications/{uuid}/envs`, narrowed to what an upsert has to match on. */
+export interface CoolifyEnvEntry {
+    uuid: string;
+    key: string;
+    value?: string;
+    is_preview?: boolean;
 }
 export interface CoolifyDeploymentRequest {
     deployments: {
@@ -108,10 +125,33 @@ export interface CoolifyBackupRequest {
     database_backup_retention_amount_locally?: number;
     database_backup_retention_days_locally?: number;
 }
+/**
+ * What `PATCH /databases/{uuid}/backups/{scheduled_backup_uuid}` accepts of the fields E3 sets.
+ *
+ * Every field is optional upstream and only the ones a rerun reconciles are here: the schedule it
+ * finds was registered by an earlier `hf new`, and rewriting fields nobody set would undo whatever
+ * the operator changed in Coolify's own UI.
+ */
+export interface CoolifyBackupUpdate {
+    frequency?: string;
+    enabled?: boolean;
+    save_s3?: boolean;
+    s3_storage_uuid?: string;
+    databases_to_backup?: string;
+    dump_all?: boolean;
+}
 export interface CoolifyBackup {
     uuid: string;
     message?: string;
 }
+/** An S3 storage as `GET /s3-storages` lists it; `is_usable` is Coolify's own validation verdict. */
+export interface CoolifyS3Storage {
+    uuid: string;
+    name: string;
+    bucket?: string;
+    region?: string;
+    is_usable?: boolean;
+}
 export interface CoolifyClientOptions {
     /** `HF_COOLIFY_URL` — the instance's origin, without `/api/v1`. */
     url: string;
@@ -148,11 +188,27 @@ export declare class CoolifyClient {
         tag?: string;
     }): Promise<CoolifyApplicationSummary[]>;
     updateEnvsBulk(appUuid: string, data: readonly CoolifyEnvironmentVariable[]): Promise<unknown>;
+    /** Every environment variable on the application, preview and non-preview alike. */
+    listEnvs(appUuid: string): Promise<CoolifyEnvEntry[]>;
+    createEnv(appUuid: string, variable: CoolifyEnvironmentVariable): Promise<{
+        uuid: string;
+    }>;
+    /** Keyed by `key` — and by `is_preview`, which is why an upsert sends the entry's own flag. */
+    updateEnv(appUuid: string, variable: CoolifyEnvironmentVariable): Promise<unknown>;
     deploy(uuid: string, options?: {
         force?: boolean;
     }): Promise<CoolifyDeploymentRequest>;
     getDeployment(deploymentUuid: string): Promise<CoolifyDeployment>;
     createDatabaseBackup(databaseUuid: string, body: CoolifyBackupRequest): Promise<CoolifyBackup>;
+    updateDatabaseBackup(databaseUuid: string, backupUuid: string, body: CoolifyBackupUpdate): Promise<unknown>;
+    /**
+     * Every S3 storage the token's team has configured.
+     *
+     * A backup registered with `save_s3` and no `s3_storage_uuid` is accepted, then runs with
+     * `S3 storage configuration is missing` in its log and keeps the dump on the box alone — so the
+     * uuid has to come from somewhere, and this is the only place the API offers one.
+     */
+    listS3Storages(): Promise<CoolifyS3Storage[]>;
     /**
      * The database's scheduled backups.
      *

package/dist/providers/coolify.js

@@ -55,6 +55,27 @@ export class CoolifyClient {
             secrets: data.map((variable) => variable.value),
         });
     }
+    /** Every environment variable on the application, preview and non-preview alike. */
+    async listEnvs(appUuid) {
+        return await this.request({ method: "GET", path: `/applications/${segment(appUuid)}/envs` });
+    }
+    async createEnv(appUuid, variable) {
+        return await this.request({
+            method: "POST",
+            path: `/applications/${segment(appUuid)}/envs`,
+            body: variable,
+            secrets: [variable.value],
+        });
+    }
+    /** Keyed by `key` — and by `is_preview`, which is why an upsert sends the entry's own flag. */
+    async updateEnv(appUuid, variable) {
+        return await this.request({
+            method: "PATCH",
+            path: `/applications/${segment(appUuid)}/envs`,
+            body: variable,
+            secrets: [variable.value],
+        });
+    }
     async deploy(uuid, options = {}) {
         return await this.request({
             method: "POST",
@@ -75,6 +96,23 @@ export class CoolifyClient {
             body,
         });
     }
+    async updateDatabaseBackup(databaseUuid, backupUuid, body) {
+        return await this.request({
+            method: "PATCH",
+            path: `/databases/${segment(databaseUuid)}/backups/${segment(backupUuid)}`,
+            body,
+        });
+    }
+    /**
+     * Every S3 storage the token's team has configured.
+     *
+     * A backup registered with `save_s3` and no `s3_storage_uuid` is accepted, then runs with
+     * `S3 storage configuration is missing` in its log and keeps the dump on the box alone — so the
+     * uuid has to come from somewhere, and this is the only place the API offers one.
+     */
+    async listS3Storages() {
+        return await this.request({ method: "GET", path: "/s3-storages" });
+    }
     /**
      * The database's scheduled backups.
      *

package/dist/restore-check.d.ts

@@ -36,20 +36,26 @@ export interface RestoreCheckOptions {
     app: string;
     state: AppStateStore;
     source: BackupSource;
-    /** Where `pg_restore` runs: the box, or this machine in a test. */
+    /** Where the dump file is and where `docker` is run: the box, or this machine in a test. */
     runner: Runner;
     /** How the scratch database is created and both sides are counted. */
     database: Database | string;
     /**
-     * The cluster's admin URL **as the runner sees it**, for `pg_restore`.
+     * The Postgres container `pg_restore` runs inside.
      *
-     * Not the same address as `database`: the laptop reaches the cluster through an `ssh -L`
-     * forward onto a local port, and a `pg_restore` running on the far side of that forward has to
-     * dial the box's own loopback. Defaults to `database`'s URL, which is what a test wants when
-     * both sides are the same machine.
+     * The box host has no Postgres client tools — Postgres runs only in Coolify's container — so a
+     * `pg_restore` on the host exits 127. The dump is the host's and is not mounted into the
+     * container, so it goes down `docker exec -i`'s stdin.
+     */
+    container: string;
+    /** The superuser inside the container; `HF_PG_ADMIN_USER`, default `postgres`. */
+    adminUser?: string;
+    /**
+     * @deprecated Unused: `pg_restore` no longer dials an address, it runs beside the server inside
+     * `container`. Removed in 0.2.0.
      */
     restoreAdminUrl?: string;
-    /** The `pg_restore` binary on the runner. */
+    /** The `pg_restore` binary inside the container. */
     pgRestorePath?: string;
     now?: Date;
 }
@@ -64,13 +70,32 @@ export interface RestoreCheckOptions {
  * mismatch — has to leave the warning standing until a check actually passes.
  */
 export declare function restoreCheck(options: RestoreCheckOptions): Promise<RestoreCheckResult>;
-/** The argv `restoreCheck` runs — the array the test asserts against. */
+/**
+ * The argv `restoreCheck` runs — the array the test asserts against.
+ *
+ * @deprecated The box host has no `pg_restore`; the restore runs inside the Postgres container.
+ * Use `pgRestoreInContainerArgv`. Removed in 0.2.0.
+ */
 export declare function pgRestoreArgv(options: {
     url: string;
     role: string;
     file: string;
     pgRestorePath?: string;
 }): string[];
+/**
+ * The argv `restoreCheck` runs — the array the test asserts against.
+ *
+ * No `--dbname` URL: inside the container the server is on the local socket, so the admin user
+ * and the database name are all it takes and no password crosses an argv. The dump arrives on
+ * stdin, which is why there is no file argument either.
+ */
+export declare function pgRestoreInContainerArgv(options: {
+    container: string;
+    adminUser: string;
+    database: string;
+    role: string;
+    pgRestorePath?: string;
+}): string[];
 /** The table `hf restore-check` prints, and the two lines around it. */
 export declare function formatRestoreCheck(result: RestoreCheckResult): string[];
 export interface RestoreCheckAppOptions {