heroku 11.0.2 → 11.1.0

package/dist/lib/analytics-telemetry/sentry-client.js

@@ -0,0 +1,58 @@
+import * as Sentry from '@sentry/node';
+import { PII_PATTERNS } from '../data-scrubber/patterns.js';
+import { GDPR_FIELDS, HEROKU_FIELDS, PCI_FIELDS } from '../data-scrubber/presets.js';
+import { Scrubber } from '../data-scrubber/scrubber.js';
+import { getVersion, isDev, isTelemetryDisabled, telemetryDebug, } from './telemetry-utils.js';
+// Lazy-loaded state
+let isSentryInitialized = false;
+let sentryClient;
+/**
+ * Ensure Sentry is initialized (lazy initialization)
+ */
+export function ensureSentryInitialized() {
+    if (isSentryInitialized || isTelemetryDisabled) {
+        return;
+    }
+    telemetryDebug('Initializing Sentry...');
+    isSentryInitialized = true;
+    const scrubber = new Scrubber({
+        fields: [...HEROKU_FIELDS, ...GDPR_FIELDS, ...PCI_FIELDS],
+        patterns: [...PII_PATTERNS],
+    });
+    sentryClient = Sentry.init({
+        beforeSend(event) {
+            return scrubber.scrub(event).data;
+        },
+        dsn: 'https://76530569188e7ee2961373f37951d916@o4508609692368896.ingest.us.sentry.io/4508767754846208',
+        environment: isDev ? 'development' : 'production',
+        release: getVersion(),
+        skipOpenTelemetrySetup: true,
+        tracesSampleRate: 1, // needed to ensure we send OTEL data to Honeycomb
+    });
+    telemetryDebug('Sentry initialized (environment: %s, release: %s)', isDev ? 'development' : 'production', getVersion());
+}
+/**
+ * Send error data to Sentry
+ */
+export async function sendToSentry(data) {
+    // Lazy-load Sentry only when we actually need to report an error
+    ensureSentryInitialized();
+    try {
+        telemetryDebug('Sentry payload: %O', {
+            code: data.code,
+            context: data.context,
+            message: data.message,
+            name: data.name,
+            stack: data.stack,
+            statusCode: data.statusCode,
+        });
+        telemetryDebug('Capturing exception in Sentry: %s', data.message);
+        Sentry.captureException(data);
+        // ensures all events are sent to Sentry before exiting.
+        await Sentry.flush();
+        telemetryDebug('Successfully flushed error to Sentry');
+    }
+    catch (error) {
+        telemetryDebug('Error sending to Sentry: %O', error);
+    }
+}

package/dist/lib/analytics-telemetry/telemetry-utils.d.ts

@@ -0,0 +1,68 @@
+import debug from 'debug';
+export declare const telemetryDebug: debug.Debugger;
+export declare const isDev: boolean;
+export declare const isTelemetryDisabled: boolean;
+export interface CLIError extends Error {
+    cliRunDuration?: number | string;
+    code?: string;
+    context?: {
+        isTTY?: boolean;
+    };
+    http?: {
+        statusCode?: number;
+    };
+    oclif?: {
+        exit?: number;
+    };
+    statusCode?: number;
+}
+export interface Telemetry {
+    cliRunDuration: number;
+    command: string;
+    commandRunDuration: number;
+    exitCode: number;
+    exitState: string;
+    isTTY: boolean | undefined;
+    isVersionOrHelp: boolean;
+    lifecycleHookCompletion: {
+        command_not_found: boolean;
+        init: boolean;
+        postrun: boolean;
+        prerun: boolean;
+    };
+    os: string;
+    version: string;
+}
+export type TelemetryData = CLIError | Telemetry;
+export interface TelemetryGlobal {
+    cliTelemetry?: Telemetry;
+}
+/**
+ * Compute duration from a start time to now
+ */
+export declare function computeDuration(cmdStartTime: number): number;
+/**
+ * Get authentication token, cached to avoid recreating Config/APIClient
+ */
+export declare function getToken(): string | undefined;
+/**
+ * Get CLI version
+ */
+export declare function getVersion(): string;
+/**
+ * Check if telemetry is enabled based on environment variables
+ */
+export declare function isTelemetryEnabled(): boolean;
+/**
+ * Serialize data for telemetry worker, handling Error objects specially
+ */
+export declare function serializeTelemetryData(data: TelemetryData): string;
+/**
+ * Set CLI version (called once during setup)
+ */
+export declare function setVersion(v: string): void;
+/**
+ * Spawn telemetry worker process in background
+ * This avoids blocking the main CLI process with telemetry overhead
+ */
+export declare function spawnTelemetryWorker(data: TelemetryData): void;

package/dist/lib/analytics-telemetry/telemetry-utils.js

@@ -0,0 +1,115 @@
+import { APIClient } from '@heroku-cli/command';
+import { Config } from '@oclif/core/config';
+import debug from 'debug';
+import { spawn } from 'node:child_process';
+import path from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const root = path.resolve(__dirname, '../../../package.json');
+// Debug instance for telemetry operations
+export const telemetryDebug = debug('analytics-telemetry');
+// Environment flags
+export const isDev = process.env.IS_DEV_ENVIRONMENT === 'true';
+export const isTelemetryDisabled = process.env.DISABLE_TELEMETRY === 'true';
+// Cached values
+let version;
+let cachedToken;
+/**
+ * Compute duration from a start time to now
+ */
+export function computeDuration(cmdStartTime) {
+    const now = new Date();
+    const cmdFinishTime = now.getTime();
+    return cmdFinishTime - cmdStartTime;
+}
+/**
+ * Get authentication token, cached to avoid recreating Config/APIClient
+ */
+export function getToken() {
+    if (cachedToken !== undefined) {
+        return cachedToken;
+    }
+    try {
+        const config = new Config({ root });
+        const heroku = new APIClient(config);
+        cachedToken = heroku.auth;
+        return cachedToken;
+    }
+    catch {
+        // If config initialization fails, return empty string
+        cachedToken = '';
+        return cachedToken;
+    }
+}
+/**
+ * Get CLI version
+ */
+export function getVersion() {
+    return version || 'unknown';
+}
+/**
+ * Check if telemetry is enabled based on environment variables
+ */
+export function isTelemetryEnabled() {
+    if (process.env.DISABLE_TELEMETRY === 'true')
+        return false;
+    if (process.platform === 'win32' && process.env.ENABLE_WINDOWS_TELEMETRY !== 'true')
+        return false;
+    if (process.env.IS_HEROKU_TEST_ENV === 'true')
+        return false;
+    return true;
+}
+/**
+ * Serialize data for telemetry worker, handling Error objects specially
+ */
+export function serializeTelemetryData(data) {
+    // If it's an Error object, convert to plain object with all properties
+    if (data instanceof Error) {
+        const errorData = data;
+        return JSON.stringify({
+            // Include any other enumerable properties first
+            ...data,
+            // Then override with important properties to ensure they're captured
+            cliRunDuration: errorData.cliRunDuration,
+            code: errorData.code,
+            http: errorData.http,
+            message: errorData.message,
+            name: errorData.name,
+            oclif: errorData.oclif,
+            stack: errorData.stack,
+            statusCode: errorData.statusCode,
+        });
+    }
+    return JSON.stringify(data);
+}
+/**
+ * Set CLI version (called once during setup)
+ */
+export function setVersion(v) {
+    version = v;
+}
+/**
+ * Spawn telemetry worker process in background
+ * This avoids blocking the main CLI process with telemetry overhead
+ */
+export function spawnTelemetryWorker(data) {
+    try {
+        const workerPath = path.join(__dirname, '..', '..', '..', 'dist', 'lib', 'analytics-telemetry', 'telemetry-worker.js');
+        const child = spawn(process.execPath, [workerPath], {
+            detached: true,
+            // Keep stderr attached to see DEBUG output, but ignore stdout
+            stdio: ['pipe', 'ignore', 'inherit'],
+            // On Windows, prevent console window from appearing
+            windowsHide: true,
+        });
+        // Send data via stdin
+        child.stdin.write(serializeTelemetryData(data));
+        child.stdin.end();
+        // Detach from parent so it can exit immediately
+        child.unref();
+    }
+    catch {
+        // Silently fail - don't let telemetry errors affect user experience
+    }
+}

package/dist/lib/analytics-telemetry/telemetry-worker.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Telemetry worker process - runs in background to send telemetry data
+ * This runs as a separate process to avoid blocking the main CLI
+ */
+export {};

package/dist/lib/analytics-telemetry/telemetry-worker.js

@@ -0,0 +1,37 @@
+/* eslint-disable n/no-process-exit */
+/**
+ * Telemetry worker process - runs in background to send telemetry data
+ * This runs as a separate process to avoid blocking the main CLI
+ */
+import { sendTelemetry } from './global-telemetry.js';
+// Read telemetry data from stdin
+let inputData = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => {
+    inputData += chunk;
+});
+process.stdin.on('end', async () => {
+    try {
+        const parsed = JSON.parse(inputData);
+        // If the data looks like an error, reconstruct it as an Error instance
+        let telemetryData = parsed;
+        if (parsed.message && parsed.stack && (parsed.name === 'Error' || parsed.name)) {
+            const error = new Error(parsed.message);
+            error.name = parsed.name;
+            error.stack = parsed.stack;
+            // Copy over additional properties
+            Object.assign(error, parsed);
+            telemetryData = error;
+        }
+        // Send telemetry (this will initialize OpenTelemetry and Sentry if needed)
+        await sendTelemetry(telemetryData);
+        process.exit(0);
+    }
+    catch {
+        // Silently fail - don't let telemetry errors affect user experience
+        process.exit(1);
+    }
+});
+// Handle errors silently
+process.on('uncaughtException', () => process.exit(1));
+process.on('unhandledRejection', () => process.exit(1));

package/dist/lib/analytics-telemetry/worker-client.d.ts

@@ -0,0 +1,15 @@
+import { TelemetryGlobal } from './telemetry-utils.js';
+declare global {
+    var cliTelemetry: TelemetryGlobal['cliTelemetry'];
+}
+interface SetupTelemetryOptions {
+    cliStartTime: number;
+    computeDuration: (startTime: number) => number;
+    enableTelemetry: boolean;
+}
+/**
+ * Setup telemetry handlers for beforeExit and signal handlers
+ * This centralizes all telemetry worker spawning logic
+ */
+export declare function setupTelemetryHandlers(options: SetupTelemetryOptions): void;
+export {};

package/dist/lib/analytics-telemetry/worker-client.js

@@ -0,0 +1,44 @@
+/* eslint-disable n/no-process-exit */
+import { spawnTelemetryWorker } from './telemetry-utils.js';
+/**
+ * Setup telemetry handlers for beforeExit and signal handlers
+ * This centralizes all telemetry worker spawning logic
+ */
+export function setupTelemetryHandlers(options) {
+    const { cliStartTime, computeDuration, enableTelemetry } = options;
+    if (!enableTelemetry)
+        return;
+    process.once('beforeExit', code => {
+        // capture as successful exit
+        if (global.cliTelemetry) {
+            if (global.cliTelemetry.isVersionOrHelp) {
+                const cmdStartTime = global.cliTelemetry.commandRunDuration;
+                global.cliTelemetry.commandRunDuration = computeDuration(cmdStartTime);
+            }
+            global.cliTelemetry.exitCode = code;
+            global.cliTelemetry.cliRunDuration = computeDuration(cliStartTime);
+            const telemetryData = global.cliTelemetry;
+            // Spawn background process to send telemetry without blocking exit
+            spawnTelemetryWorker(telemetryData);
+        }
+    });
+    process.on('SIGINT', () => {
+        // Spawn background process to send telemetry
+        const error = Object.assign(new Error('Received SIGINT'), {
+            cliRunDuration: computeDuration(cliStartTime),
+            context: {
+                isTTY: process.stdin.isTTY,
+            },
+        });
+        spawnTelemetryWorker(error);
+        process.exit(1);
+    });
+    process.on('SIGTERM', () => {
+        // Spawn background process to send telemetry
+        const error = Object.assign(new Error('Received SIGTERM'), {
+            cliRunDuration: computeDuration(cliStartTime),
+        });
+        spawnTelemetryWorker(error);
+        process.exit(1);
+    });
+}

package/dist/lib/api.d.ts

@@ -5,7 +5,7 @@ export declare const V3_HEADER = "application/vnd.heroku+json; version=3";
 export declare const SDK_HEADER = "application/vnd.heroku+json; version=3.sdk";
 export declare const FILTERS_HEADER: string;
 export declare const PIPELINES_HEADER: string;
-export declare type Owner = Pick<Heroku.Account, 'id' | 'type'> | Pick<Heroku.Team, 'id' | 'type'>;
+export type Owner = Pick<Heroku.Account, 'id' | 'type'> | Pick<Heroku.Team, 'id' | 'type'>;
 export declare function createAppSetup(heroku: APIClient, body: {
     body: any;
 }): Promise<import("@heroku/http-call").HTTP<Heroku.AppSetup>>;

package/dist/lib/apps/app-transfer.d.ts

@@ -1,5 +1,5 @@
 import { APIClient } from '@heroku-cli/command';
-declare type Options = {
+type Options = {
     appName: string;
     bulk: boolean;
     heroku: APIClient;

package/dist/lib/apps/error_info.d.ts

@@ -1,4 +1,4 @@
-export declare type ErrorInfo = {
+export type ErrorInfo = {
     name: string;
     title: string;
     level: string;

package/dist/lib/apps/generation.d.ts

@@ -1,9 +1,9 @@
 import { APIClient } from '@heroku-cli/command';
 import { App, Space, DynoSize, TeamApp, Pipeline, Generation, AppGeneration, DynoSizeGeneration, PipelineGeneration } from '../types/fir.js';
 import Dyno from '../run/dyno.js';
-export declare type GenerationKind = 'fir' | 'cedar';
-export declare type GenerationLike = Generation | AppGeneration | DynoSizeGeneration | PipelineGeneration | Dyno;
-export declare type GenerationCapable = App | Space | DynoSize | TeamApp | Pipeline;
+export type GenerationKind = 'fir' | 'cedar';
+export type GenerationLike = Generation | AppGeneration | DynoSizeGeneration | PipelineGeneration | Dyno;
+export type GenerationCapable = App | Space | DynoSize | TeamApp | Pipeline;
 /**
  * Get the generation of an object
  *

package/dist/lib/buildpacks/buildpacks.d.ts

@@ -1,6 +1,6 @@
 import { APIClient } from '@heroku-cli/command';
 import { BuildpackRegistry } from '@heroku/buildpack-registry';
-export declare type BuildpackResponse = {
+export type BuildpackResponse = {
     buildpack: {
         name: string;
         url: string;

package/dist/lib/container/docker_helper.d.ts

@@ -1,18 +1,18 @@
-export declare type CmdOptions = {
+export type CmdOptions = {
     input?: string;
     output?: boolean;
 };
-export declare type DockerJob = {
+export type DockerJob = {
     depth: number;
     dockerfile: string;
     name: string;
     postfix: number;
     resource: string;
 };
-export declare type GroupedDockerJobs = {
+export type GroupedDockerJobs = {
     [processType: string]: DockerJob[];
 };
-declare type BuildImageParams = {
+type BuildImageParams = {
     arch?: string;
     buildArgs: string[];
     dockerfile: string;

package/dist/lib/data/types.d.ts

@@ -1,15 +1,15 @@
-export declare type DeepRequired<T> = T extends object ? {
+export type DeepRequired<T> = T extends object ? {
     [K in keyof T]-?: DeepRequired<T[K]>;
 } : T;
-declare type ResourceReference = {
+type ResourceReference = {
     id: string;
     name: string;
 };
-declare type AppReference = ResourceReference;
-declare type AddonReference = ResourceReference;
-declare type CommonRuntimeRegion = 'eu' | 'us';
-declare type PrivateSpaceRegion = 'california' | 'dublin' | 'frankfurt' | 'london' | 'montreal' | 'mumbai' | 'ohio' | 'oregon' | 'paris' | 'singapore' | 'sydney' | 'tokyo' | 'virginia';
-export declare type InfoResponse = {
+type AppReference = ResourceReference;
+type AddonReference = ResourceReference;
+type CommonRuntimeRegion = 'eu' | 'us';
+type PrivateSpaceRegion = 'california' | 'dublin' | 'frankfurt' | 'london' | 'montreal' | 'mumbai' | 'ohio' | 'oregon' | 'paris' | 'singapore' | 'sydney' | 'tokyo' | 'virginia';
+export type InfoResponse = {
     addon: AddonReference;
     app: AppReference;
     created_at: string;
@@ -45,10 +45,10 @@ export declare type InfoResponse = {
     tier: 'advanced';
     version: string;
 };
-export declare type Quotas = {
+export type Quotas = {
     items: Array<Quota>;
 };
-export declare type Quota = {
+export type Quota = {
     critical_gb: null | number;
     current_gb: null | number;
     enforcement_action: 'none' | 'notify' | 'restrict';
@@ -56,47 +56,47 @@ export declare type Quota = {
     type: string;
     warning_gb: null | number;
 };
-declare type TableLimit = {
+type TableLimit = {
     current: number;
     limit: number;
     name: 'table-limit';
 };
-declare type ConnectionLimit = {
+type ConnectionLimit = {
     current: number;
     limit: number;
     name: 'connection-limit';
 };
-declare type StorageLimitInGb = {
+type StorageLimitInGb = {
     current: number;
     limit: number;
     name: 'storage-limit-in-gb';
 };
-export declare type PlanLimit = ConnectionLimit | StorageLimitInGb | TableLimit;
-export declare type PostgresLevelInfo = {
+export type PlanLimit = ConnectionLimit | StorageLimitInGb | TableLimit;
+export type PostgresLevelInfo = {
     connection_limit: number;
     memory_in_gb: number;
     name: string;
     vcpu: number;
 };
-export declare type PostgresLevelsResponse = {
+export type PostgresLevelsResponse = {
     items: Array<PostgresLevelInfo>;
 };
-declare type BaseChange = {
+type BaseChange = {
     current: boolean | null | number | string;
     name: string;
     previous: boolean | null | number | string;
 };
-declare type PoolChange = {
+type PoolChange = {
     pool: string;
 } & BaseChange;
-export declare type ScaleResponse = {
+export type ScaleResponse = {
     changes: Array<PoolChange>;
 };
-declare type SettingsChange = BaseChange;
-export declare type SettingsChangeResponse = {
+type SettingsChange = BaseChange;
+export type SettingsChangeResponse = {
     changes: Array<SettingsChange>;
 };
-export declare type SettingsResponse = {
+export type SettingsResponse = {
     items: Array<{
         current: boolean | null | number | string;
         default: boolean | null | number | string;
@@ -104,12 +104,12 @@ export declare type SettingsResponse = {
         reboot_required: boolean;
     }>;
 };
-export declare type CreatePoolParameters = {
+export type CreatePoolParameters = {
     count: number;
     level: string;
     name?: string;
 };
-export declare type ComputeInstance = {
+export type ComputeInstance = {
     id: string;
     level: string;
     name: string;
@@ -117,12 +117,12 @@ export declare type ComputeInstance = {
     status: string;
     updated_at: string;
 };
-export declare type ConnectionEndpoint = {
+export type ConnectionEndpoint = {
     host: string;
     port: number;
     status: 'available' | 'degraded' | 'deprovisioning' | 'modifying';
 };
-export declare type PoolInfoResponse = {
+export type PoolInfoResponse = {
     compute_instances: Array<ComputeInstance>;
     connections_used: null | number;
     endpoints: Array<ConnectionEndpoint>;
@@ -142,10 +142,10 @@ export declare type PoolInfoResponse = {
         waiting: boolean;
     };
 };
-export declare type CredentialsInfo = {
+export type CredentialsInfo = {
     items: Array<AdvancedCredentialInfo>;
 };
-export declare type CredentialInfo = AdvancedCredentialInfo | NonAdvancedCredentialInfo;
+export type CredentialInfo = AdvancedCredentialInfo | NonAdvancedCredentialInfo;
 export interface AdvancedCredentialInfo extends Record<string, unknown> {
     database: string;
     host: string;
@@ -161,23 +161,23 @@ export interface AdvancedCredentialInfo extends Record<string, unknown> {
     type: 'additional' | 'owner';
 }
 export declare function isAdvancedCredentialInfo(credential: CredentialInfo): credential is AdvancedCredentialInfo;
-export declare type PricingInfo = {
+export type PricingInfo = {
     billing_period: 'month';
     billing_unit: 'compute' | 'gigabyte';
     included_units?: number;
     product_description: string;
     rate: number;
 };
-export declare type TierPricingInfo = Record<string, PricingInfo>;
-export declare type PricingInfoResponse = Record<string, TierPricingInfo>;
-declare type NonAdvancedCredentialState = 'active' | 'archived' | 'enabling' | 'revoked' | 'revoking';
-declare type NonAdvancedCredential = {
+export type TierPricingInfo = Record<string, PricingInfo>;
+export type PricingInfoResponse = Record<string, TierPricingInfo>;
+type NonAdvancedCredentialState = 'active' | 'archived' | 'enabling' | 'revoked' | 'revoking';
+type NonAdvancedCredential = {
     connections?: null | number;
     password: string;
     state: NonAdvancedCredentialState;
     user: string;
 };
-declare type NonAdvancedCredentialStoreState = 'active' | 'archived' | 'provisioning' | 'revoking' | 'rotating' | 'rotation_completed' | 'wait_for_provisioning';
+type NonAdvancedCredentialStoreState = 'active' | 'archived' | 'provisioning' | 'revoking' | 'rotating' | 'rotation_completed' | 'wait_for_provisioning';
 export interface NonAdvancedCredentialInfo extends Record<string, unknown> {
     credentials: Array<NonAdvancedCredential>;
     database: string;
@@ -187,10 +187,10 @@ export interface NonAdvancedCredentialInfo extends Record<string, unknown> {
     state: NonAdvancedCredentialStoreState;
     uuid: string;
 }
-export declare type ExtendedPostgresLevelInfo = {
+export type ExtendedPostgresLevelInfo = {
     pricing: PricingInfo | undefined;
 } & PostgresLevelInfo;
-export declare type Maintenance = {
+export type Maintenance = {
     'addon': {
         'attachments': string[];
         'kind': string;
@@ -215,7 +215,7 @@ export declare type Maintenance = {
     'status': MaintenanceStatus;
     'window': null | string;
 };
-export declare type Window = {
+export type Window = {
     previous_window: null | string;
     previously_scheduled_at: null | string;
     scheduled_at: null | string;
@@ -229,7 +229,7 @@ export declare enum MaintenanceStatus {
     ready = "ready",
     running = "running"
 }
-export declare type WaitStatus = {
+export type WaitStatus = {
     message: null | string;
     waiting: boolean;
 };

package/dist/lib/domains/domains.js

@@ -1,6 +1,6 @@
 import { color, hux } from '@heroku/heroku-cli-util';
 import { ux } from '@oclif/core/ux';
-import { parse } from 'psl';
+import { parse } from 'tldts';
 const wait = function (ms) {
     return new Promise(resolve => {
         setTimeout(resolve, ms);
@@ -87,13 +87,20 @@ export async function waitForDomains(heroku, app) {
     }
     return apiDomains;
 }
-function isParseError(parsed) {
-    return parsed.error !== undefined;
-}
 function type(domain) {
-    const parsed = parse(domain.hostname);
-    if (isParseError(parsed)) {
-        throw new Error(parsed.error.message);
+    // Wildcard domains (*.example.com) are always treated as subdomains (CNAME)
+    // This must be checked before parsing since wildcards aren't valid hostnames
+    if (domain.hostname.includes('*')) {
+        return 'CNAME';
+    }
+    // Parse the domain with private domains enabled (for .herokuapp.com, etc.)
+    const result = parse(domain.hostname, { allowPrivateDomains: true });
+    // Reject invalid or unparsable hostnames (e.g., "notadomain", "localhost", IPs, empty strings)
+    // All of these result in domain === null
+    if (result.domain === null) {
+        throw new Error(`Invalid hostname: ${domain.hostname}`);
     }
-    return parsed.subdomain === null ? 'ALIAS/ANAME' : 'CNAME';
+    // Empty string subdomain means root domain → ALIAS/ANAME
+    // Non-empty subdomain means has subdomain → CNAME
+    return result.subdomain ? 'CNAME' : 'ALIAS/ANAME';
 }

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

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

package/dist/lib/pg/push_pull.d.ts

@@ -3,7 +3,7 @@
 import type { pg } from '@heroku/heroku-cli-util';
 import { ChildProcess } from 'node:child_process';
 export declare const parseExclusions: (rawExcludeList: string | undefined) => Array<string>;
-declare type ExecFn = typeof exec;
+type ExecFn = typeof exec;
 export declare const prepare: (target: pg.ConnectionDetails, execFn?: ExecFn) => Promise<void>;
 export declare const maybeTunnel: (herokuDb: pg.ConnectionDetails) => Promise<pg.ConnectionDetails>;
 export declare const connArgs: (uri: pg.ConnectionDetails, skipDFlag?: boolean) => string[];