@datatruck/cli 0.27.0 → 0.28.0

package/utils/fs.js

@@ -3,12 +3,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.tryRm = exports.safeRename = exports.fetchData = exports.countFileLines = exports.createWriteStreamPool = exports.createFileScanner = exports.createProgress = exports.cpy = exports.isNotFoundError = exports.updateFileStats = exports.copyFileWithStreams = exports.waitForClose = exports.writeGitIgnoreList = exports.fastglobToGitIgnore = exports.forEachFile = exports.readDir = exports.readPartialFile = exports.mkTmpDir = exports.fastFolderSizeAsync = exports.tmpDir = exports.rmTmpDir = exports.isTmpDir = exports.sessionTmpDir = exports.parentTmpDir = exports.findFile = exports.parsePackageFile = exports.parseFile = exports.parseFileExtensions = exports.writeJSONFile = exports.existsFile = exports.existsDir = exports.safeStat = exports.ensureEmptyDir = exports.mkdirIfNotExists = exports.isLocalDir = exports.isEmptyDir = exports.isWSLSystem = void 0;
-const globalData_1 = __importDefault(require("../globalData"));
+exports.groupFiles = exports.ensureFreeDiskSpace = exports.checkFreeDiskSpace = exports.fetchDiskStats = exports.initEmptyDir = exports.tryRm = exports.safeRename = exports.fetchData = exports.countFileLines = exports.createWriteStreamPool = exports.createFileScanner = exports.createProgress = exports.cpy = exports.isNotFoundError = exports.updateFileStats = exports.copyFileWithStreams = exports.waitForClose = exports.writeGitIgnoreList = exports.fastglobToGitIgnore = exports.forEachFile = exports.readDir = exports.readPartialFile = exports.fastFolderSizeAsync = exports.findFile = exports.parsePackageFile = exports.parseFile = exports.parseFileExtensions = exports.writeJSONFile = exports.existsFile = exports.existsDir = exports.safeStat = exports.ensureExistsDir = exports.ensureSingleFile = exports.ensureEmptyDir = exports.mkdirIfNotExists = exports.isLocalDir = exports.isEmptyDir = exports.isWSLSystem = void 0;
 const math_1 = require("./math");
 const path_1 = require("./path");
+const string_1 = require("./string");
 const async_1 = require("async");
-const crypto_1 = require("crypto");
+const bytes_1 = __importDefault(require("bytes"));
 const fast_folder_size_1 = __importDefault(require("fast-folder-size"));
 const fast_glob_1 = __importDefault(require("fast-glob"));
 const fs_1 = require("fs");
@@ -53,6 +53,19 @@ async function ensureEmptyDir(path) {
         throw new Error(`Dir is not empty: ${path}`);
 }
 exports.ensureEmptyDir = ensureEmptyDir;
+async function ensureSingleFile(path) {
+    const files = await readDir(path);
+    if (files.length !== 1)
+        throw new Error(`Dir has not one file: ${files.length}`);
+    const [file] = files;
+    return (0, path_2.join)(path, file);
+}
+exports.ensureSingleFile = ensureSingleFile;
+async function ensureExistsDir(path) {
+    if (!(await existsDir(path)))
+        throw new Error(`Dir is not crated: ${path}`);
+}
+exports.ensureExistsDir = ensureExistsDir;
 async function safeStat(path) {
     try {
         return await (0, promises_1.stat)(path);
@@ -116,48 +129,10 @@ async function findFile(sourcePath, baseName, extensions, errorMessage = "Path n
     return path;
 }
 exports.findFile = findFile;
-function parentTmpDir() {
-    return (0, path_2.join)(globalData_1.default.tempDir, "datatruck-temp");
-}
-exports.parentTmpDir = parentTmpDir;
-function sessionTmpDir() {
-    return (0, path_2.join)(parentTmpDir(), process.pid.toString());
-}
-exports.sessionTmpDir = sessionTmpDir;
-function isTmpDir(path) {
-    return path.startsWith(sessionTmpDir()) && path.includes("datatruck-temp");
-}
-exports.isTmpDir = isTmpDir;
-async function rmTmpDir(input) {
-    if (typeof input === "string") {
-        if (!isTmpDir(input))
-            throw new Error(`Path is not a temp dir: ${input}`);
-        await (0, promises_1.rm)(input, {
-            recursive: true,
-        });
-    }
-    else {
-        for (const path of input)
-            await rmTmpDir(path);
-    }
-}
-exports.rmTmpDir = rmTmpDir;
-function tmpDir(prefix, id) {
-    if (!id)
-        id = (0, crypto_1.randomUUID)().slice(0, 8);
-    return (0, path_2.join)(sessionTmpDir(), `${prefix}-${id}`);
-}
-exports.tmpDir = tmpDir;
 async function fastFolderSizeAsync(path) {
     return (await (0, util_1.promisify)(fast_folder_size_1.default)(path)) || 0;
 }
 exports.fastFolderSizeAsync = fastFolderSizeAsync;
-async function mkTmpDir(prefix, id) {
-    const path = tmpDir(prefix, id);
-    await (0, promises_1.mkdir)(path, { recursive: true });
-    return path;
-}
-exports.mkTmpDir = mkTmpDir;
 async function readPartialFile(path, positions) {
     let result = "";
     const statResult = await (0, promises_1.stat)(path);
@@ -316,7 +291,7 @@ async function cpy(options) {
         const isDir = rawEntryPath.endsWith("/");
         const entryPath = (0, path_2.normalize)(rawEntryPath);
         const entrySourcePath = (0, path_2.resolve)((0, path_2.join)(basePath, rawEntryPath));
-        const entryTargetPath = (0, path_2.resolve)((0, path_2.join)(options.targetPath, rawEntryPath));
+        const entryTargetPath = (0, path_2.resolve)((0, path_2.join)(options.outPath, rawEntryPath));
         const onPathResult = await options?.onPath?.({
             isDir,
             entryPath,
@@ -414,7 +389,7 @@ function createProgress(options) {
                 return;
             if (path && increment)
                 progress.current++;
-            await options.onProgress({
+            options.onProgress({
                 relative: {
                     description,
                     payload: path,
@@ -434,14 +409,14 @@ async function createFileScanner(options) {
     const progress = createProgress(options);
     Object.assign(progress, {
         progress: progress.update,
-        end: async () => {
+        end: () => {
             if (!progress.disposed)
-                await progress.update("Finished");
+                progress.update("Finished");
             progress.disposed = true;
         },
         start: async (cb) => {
             let lastTime = performance.now();
-            await progress.update("Scanning files");
+            progress.update("Scanning files");
             for await (const entry of pathIterator(stream)) {
                 if (cb) {
                     if (await cb(entry))
@@ -451,9 +426,9 @@ async function createFileScanner(options) {
                     progress.total++;
                 }
                 if (lastTime - performance.now() > 500)
-                    await progress.update("Scanning files");
+                    progress.update("Scanning files");
             }
-            await progress.update("Scanned files");
+            progress.update("Scanned files");
         },
     });
     const stream = fast_glob_1.default.stream(options.glob.include, {
@@ -575,3 +550,61 @@ async function tryRm(path) {
     catch (_) { }
 }
 exports.tryRm = tryRm;
+async function initEmptyDir(path) {
+    if (!path)
+        throw new Error(`Path is not defined`);
+    await mkdirIfNotExists(path);
+    await ensureEmptyDir(path);
+    return path;
+}
+exports.initEmptyDir = initEmptyDir;
+async function fetchDiskStats(path) {
+    const fs = await (0, promises_1.statfs)(path);
+    const total = fs.bsize * fs.blocks;
+    const free = fs.bsize * fs.bavail;
+    return { total, free };
+}
+exports.fetchDiskStats = fetchDiskStats;
+async function checkFreeDiskSpace(stat, inSize) {
+    const humanSize = typeof inSize === "number" ? (0, bytes_1.default)(inSize) : inSize;
+    const size = bytes_1.default.parse(inSize);
+    if (stat.free < size)
+        throw new Error(`Free disk space is less than ${humanSize}: ${(0, bytes_1.default)(stat.free)}/${(0, bytes_1.default)(stat.total)}`);
+}
+exports.checkFreeDiskSpace = checkFreeDiskSpace;
+async function ensureFreeDiskSpace(input, inSize) {
+    if (Array.isArray(input)) {
+        for (const path of input) {
+            const stat = await fetchDiskStats(path);
+            await checkFreeDiskSpace(stat, inSize);
+        }
+    }
+    else {
+        await checkFreeDiskSpace(input, inSize);
+    }
+}
+exports.ensureFreeDiskSpace = ensureFreeDiskSpace;
+function groupFiles(inFiles, suffixes, gzSuffix = ".tar.gz") {
+    const compressed = {};
+    if (suffixes) {
+        const validGzSuffixes = suffixes.map((f) => `${f}${gzSuffix}`);
+        inFiles = inFiles.filter((f) => (0, string_1.endsWith)(f, suffixes) || (0, string_1.endsWith)(f, validGzSuffixes));
+    }
+    const grouped = inFiles.reduce((items, name) => {
+        const key = name.endsWith(gzSuffix)
+            ? name.slice(0, -gzSuffix.length)
+            : name;
+        if (!items[key])
+            items[key] = [];
+        items[key].push(name);
+        return items;
+    }, {});
+    for (const key in grouped) {
+        const suffixFile = grouped[key].find((v) => v.endsWith(gzSuffix));
+        if (suffixFile) {
+            compressed[key] = suffixFile;
+        }
+    }
+    return [Object.keys(grouped), compressed];
+}
+exports.groupFiles = groupFiles;

package/utils/list.d.ts

@@ -0,0 +1,64 @@
+import { Timer } from "./date";
+import { ProgressManager } from "./progress";
+import { Streams } from "./stream";
+import { Listr, ListrGetRendererClassFromValue, ListrLogger, ListrTask, ListrTaskWrapper } from "listr2";
+export declare class List3Logger<Levels extends string = string> extends ListrLogger<Levels> {
+    constructor(options?: {
+        streams?: Partial<Streams>;
+    });
+}
+export type Listr3Context = Record<string, Record<string, any>>;
+type KeyIndex = number | string | (string | number)[];
+type Listr3Task<T extends Listr3Context, K extends keyof T> = {
+    key: K;
+    keyIndex?: KeyIndex;
+    data: T[K];
+    title: string | {
+        initial: string;
+        started?: string;
+        failed?: string;
+        completed?: string;
+    };
+    runWrapper?: (cb: () => any) => any;
+    run: (task: ListrTaskWrapper<any, any, any>, data: T[K]) => Promise<void | ListrTask[] | Listr | undefined> | void | undefined | ListrTask[] | Listr;
+    exitOnError?: boolean;
+    enabled?: boolean;
+    skip?: boolean;
+};
+type List3TaskResultObject<K, D extends Record<string, any>> = {
+    key: K;
+    keyIndex?: string;
+    data: D;
+    elapsed: number;
+    error?: Error;
+};
+type SummaryResult = List3TaskResultObject<"summary", {
+    errors: number;
+}>;
+export type Listr3TaskResult<T extends Listr3Context> = {
+    [K in keyof T]: List3TaskResultObject<K, T[K]>;
+}[keyof T];
+export type Listr3TaskResultEnd<T extends Listr3Context> = Listr3TaskResult<T> | SummaryResult;
+export declare class Listr3<T extends Listr3Context> extends Listr<void, "default", "simple"> {
+    readonly $options: {
+        streams?: Streams;
+        progressManager?: ProgressManager;
+    };
+    readonly resultMap: Record<string, Listr3TaskResult<T>>;
+    readonly resultList: Listr3TaskResult<T>[];
+    protected execTimer: Timer;
+    constructor($options: {
+        streams?: Streams;
+        progressManager?: ProgressManager;
+    });
+    private serializeKeyIndex;
+    private createResultIndex;
+    result(key: keyof T, keyIndex?: KeyIndex): Listr3TaskResult<T>;
+    $task<K extends keyof T>(item: Listr3Task<T, K>): ListrTask;
+    $tasks<K extends keyof T>(...items: (Listr3Task<T, K> | ListrTask | false)[]): ListrTask[];
+    add(tasks: ListrTask<void, ListrGetRendererClassFromValue<"default">> | ListrTask<void, ListrGetRendererClassFromValue<"default">>[]): this;
+    getSummaryResult(): SummaryResult;
+    getResult(): (SummaryResult | Listr3TaskResult<T>)[];
+    exec(): Promise<(Listr3TaskResult<T> | SummaryResult)[]>;
+}
+export {};

package/utils/list.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Listr3 = exports.List3Logger = void 0;
+const date_1 = require("./date");
+const stream_1 = require("./stream");
+const listr2_1 = require("listr2");
+class List3Logger extends listr2_1.ListrLogger {
+    constructor(options = {}) {
+        const streams = (0, stream_1.createStreams)(options.streams);
+        super({
+            processOutput: new listr2_1.ProcessOutput(streams.stdout, streams.stderr),
+        });
+    }
+}
+exports.List3Logger = List3Logger;
+class Listr3 extends listr2_1.Listr {
+    $options;
+    resultMap = {};
+    resultList = [];
+    execTimer;
+    constructor($options) {
+        super([], {
+            renderer: "default",
+            collectErrors: "minimal",
+            ...($options.progressManager && {
+                fallbackRendererCondition: () => !$options.progressManager.tty,
+            }),
+            fallbackRenderer: "simple",
+            fallbackRendererOptions: {
+                logger: new List3Logger(),
+                timestamp: listr2_1.PRESET_TIMESTAMP,
+                timer: listr2_1.PRESET_TIMER,
+            },
+            rendererOptions: {
+                logger: new List3Logger(),
+                collapseSubtasks: false,
+                collapseErrors: false,
+                timer: listr2_1.PRESET_TIMER,
+            },
+        });
+        this.$options = $options;
+        this.execTimer = (0, date_1.createTimer)();
+    }
+    serializeKeyIndex(keyIndex) {
+        return keyIndex
+            ? Array.isArray(keyIndex)
+                ? keyIndex.map((k) => k.toString())
+                : [keyIndex.toString()]
+            : [];
+    }
+    createResultIndex(key, keyIndex) {
+        return [key, ...this.serializeKeyIndex(keyIndex)].join(".");
+    }
+    result(key, keyIndex) {
+        const index = this.createResultIndex(key, keyIndex);
+        const result = this.resultMap[index];
+        if (!result)
+            throw new Error(`Task result not found: ${index}`);
+        return result;
+    }
+    $task(item) {
+        const index = this.createResultIndex(item.key, item.keyIndex);
+        if (this.resultMap[index])
+            throw new Error(`Duplicated task index: ${index}`);
+        this.resultMap[index] = {
+            key: item.key,
+            keyIndex: item.keyIndex
+                ? this.serializeKeyIndex(item.keyIndex).join(".")
+                : undefined,
+            elapsed: 0,
+            error: undefined,
+            data: item.data,
+        };
+        this.resultList.push(this.resultMap[index]);
+        const title = typeof item.title === "string" ? { initial: item.title } : item.title;
+        return {
+            title: title.initial,
+            exitOnError: item.exitOnError,
+            enabled: item.enabled,
+            skip: item.skip,
+            task: async (_, task) => {
+                const result = this.result(item.key, item.keyIndex);
+                if (title.started)
+                    task.title = title.started;
+                const timer = (0, date_1.createTimer)();
+                if (title)
+                    try {
+                        const runResult = item.runWrapper
+                            ? await item.runWrapper(async () => await item.run(task, result.data))
+                            : await item.run(task, result.data);
+                        if (title.completed)
+                            task.title = title.completed;
+                        return Array.isArray(runResult)
+                            ? task.newListr(runResult)
+                            : runResult;
+                    }
+                    catch (error) {
+                        result.error = error;
+                        if (title.failed)
+                            task.title = title.failed;
+                        throw error;
+                    }
+                    finally {
+                        result.elapsed = timer.elapsed();
+                    }
+            },
+        };
+    }
+    $tasks(...items) {
+        return items
+            .map((item) => (item ? ("key" in item ? this.$task(item) : item) : null))
+            .filter(Boolean);
+    }
+    add(tasks) {
+        super.add(tasks);
+        return this;
+    }
+    getSummaryResult() {
+        return {
+            key: "summary",
+            elapsed: this.execTimer.elapsed(),
+            data: {
+                errors: this.resultList.filter((i) => i.error).length,
+            },
+        };
+    }
+    getResult() {
+        return [...this.resultList, this.getSummaryResult()];
+    }
+    async exec() {
+        try {
+            this.$options.progressManager?.start();
+            this.execTimer.reset();
+            await super.run();
+            return this.getResult();
+        }
+        catch (error) {
+            throw error;
+        }
+        finally {
+            this.$options.progressManager?.dispose();
+        }
+    }
+}
+exports.Listr3 = Listr3;

package/utils/mysql.d.ts

@@ -9,6 +9,7 @@ export type MysqlCliOptions = {
     verbose?: boolean;
     database?: string;
 };
+export declare function assertDumpFile(path: string): Promise<void>;
 export declare function createMysqlCli(options: MysqlCliOptions): Promise<{
     options: MysqlCliOptions;
     initSharedDir: (sharedDir?: string) => Promise<string>;
@@ -28,6 +29,7 @@ export declare function createMysqlCli(options: MysqlCliOptions): Promise<{
             totalBytes: number;
         }) => void) | undefined;
     }) => Promise<[void, import("./process").ExecResultType]>;
+    assertDumpFile: typeof assertDumpFile;
     fetchTableNames: (database: string, include?: string[], exclude?: string[]) => Promise<string[]>;
     importFile: (input: {
         path: string;

package/utils/mysql.js

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createMysqlCli = void 0;
+exports.createMysqlCli = exports.assertDumpFile = void 0;
 const AppError_1 = require("../Error/AppError");
 const cli_1 = require("./cli");
 const fs_1 = require("./fs");
 const process_1 = require("./process");
 const string_1 = require("./string");
+const temp_1 = require("./temp");
 const crypto_1 = require("crypto");
 const fs_2 = require("fs");
 const promises_1 = require("fs/promises");
@@ -22,6 +23,23 @@ function flatQuery(query, params) {
         })
         : query;
 }
+async function assertDumpFile(path) {
+    const headerContents = await (0, fs_1.readPartialFile)(path, [0, 100]);
+    const footerContents = await (0, fs_1.readPartialFile)(path, [-100]);
+    const successHeader = headerContents.split(/\r?\n/).some((line) => {
+        const firstLine = line.trim().toLowerCase();
+        return (firstLine.startsWith("-- mysql dump") ||
+            firstLine.startsWith("-- mariadb dump"));
+    });
+    if (!successHeader)
+        throw new AppError_1.AppError("No start line found");
+    const successFooter = footerContents
+        .split(/\r?\n/)
+        .some((line) => line.trim().toLowerCase().startsWith("-- dump completed"));
+    if (!successFooter)
+        throw new AppError_1.AppError("No end line found (incomplete backup)");
+}
+exports.assertDumpFile = assertDumpFile;
 async function createMysqlCli(options) {
     let sqlConfigPath;
     const password = (await (0, fs_1.fetchData)(options.password, (p) => p.path)) ?? "";
@@ -35,7 +53,7 @@ async function createMysqlCli(options) {
     async function createSqlConfig() {
         if (sqlConfigPath)
             return sqlConfigPath;
-        const dir = await (0, fs_1.mkTmpDir)("mysql-cli");
+        const dir = await (0, temp_1.mkTmpDir)("mysql", "config");
         const password = await (0, fs_1.fetchData)(options.password, (p) => p.path);
         const data = [
             `[client]`,
@@ -266,6 +284,7 @@ async function createMysqlCli(options) {
         changeDatabase,
         fetchAll,
         dump,
+        assertDumpFile,
         fetchTableNames,
         importFile,
         isDatabaseEmpty,

package/utils/process.d.ts

@@ -38,6 +38,7 @@ export interface ExecSettingsInterface {
     };
     stderr?: {
         save?: boolean;
+        parseLines?: boolean | "skip-empty";
         onData?: (data: string) => void;
         toExitCode?: boolean;
     };

package/utils/process.js

@@ -189,7 +189,7 @@ async function exec(command, argv = [], options = null, settings = {}) {
             });
         }
         if (typeof options?.cwd === "string" && !(await (0, fs_1.existsDir)(options.cwd)))
-            throw new Error(`Current working directory does not exist: ${options.cwd}`);
+            return reject(new Error(`Current working directory does not exist: ${options.cwd}`));
         if (pipe?.stream instanceof fs_2.ReadStream && "onReadProgress" in pipe) {
             const fileInfo = await (0, promises_1.stat)(pipe.stream.path);
             const totalBytes = fileInfo.size;
@@ -216,6 +216,8 @@ async function exec(command, argv = [], options = null, settings = {}) {
             finishListeners++;
         if (settings.stdout?.parseLines)
             finishListeners++;
+        if (settings.stderr?.parseLines)
+            finishListeners++;
         let streamError;
         const tryFinish = () => {
             if (!--finishListeners)
@@ -282,10 +284,18 @@ async function exec(command, argv = [], options = null, settings = {}) {
                 pipe.stream.pipe(p.stdin);
             }
         }
-        if (log.stdout || settings.stdout) {
-            if (!p.stdout)
-                throw new Error(`stdout is not defined`);
-            const parseLines = settings.stdout?.parseLines;
+        const stdConfig = {
+            stdout: { log: log.stdout, settings: settings.stdout },
+            stderr: { log: log.stderr, settings: settings.stderr },
+        };
+        for (const inType in stdConfig) {
+            const type = inType;
+            const enabled = log[type] || settings[type];
+            if (!enabled)
+                continue;
+            if (!p[type])
+                throw new Error(`${type} is not defined`);
+            const parseLines = settings[type]?.parseLines;
             const skipEmptyLines = parseLines === "skip-empty";
             const onData = (inData) => {
                 let data = inData.toString();
@@ -294,46 +304,29 @@ async function exec(command, argv = [], options = null, settings = {}) {
                         return;
                     data = `${inData}\n`;
                 }
-                if (log.stdout)
+                if (log[type])
                     logExecStdout({
                         data,
                         stderr: log.allToStderr,
                         colorize: log.colorize,
                     });
-                if (settings.stdout?.save)
-                    spawnData.stdout += data;
-                if (settings.stdout?.onData)
-                    settings.stdout.onData(inData.toString());
+                if (settings[type]?.save ||
+                    (type === "stderr" && settings[type]?.toExitCode))
+                    spawnData[type] += data;
+                if (settings[type]?.onData)
+                    settings[type].onData(inData.toString());
             };
             if (parseLines) {
                 const rl = (0, readline_1.createInterface)({
-                    input: p.stdout,
+                    input: p[type],
                 });
                 rl.on("line", onData);
                 rl.on("close", tryFinish);
             }
-            else if (log.stdout ||
-                settings.stdout?.save ||
-                settings.stdout?.onData) {
-                p.stdout.on("data", onData);
+            else if (log[type] || settings[type]?.save || settings[type]?.onData) {
+                p[type].on("data", onData);
             }
         }
-        if (log.stderr || settings.stderr) {
-            if (!p.stderr)
-                throw new Error(`stderr is not defined`);
-            p.stderr.on("data", (data) => {
-                if (log.stderr)
-                    logExecStdout({
-                        data: data.toString(),
-                        stderr: log.allToStderr,
-                        colorize: log.colorize,
-                    });
-                if (settings.stderr?.save || settings.stderr?.toExitCode)
-                    spawnData.stderr += data.toString();
-                if (settings.stderr?.onData)
-                    settings.stderr.onData(data.toString());
-            });
-        }
         p.on("error", (error) => (spawnError = error)).on("close", (exitCode) => {
             spawnData.exitCode = exitCode ?? 0;
             if (pipe?.stream instanceof fs_2.WriteStream)

package/utils/progress.d.ts

@@ -1,3 +1,5 @@
+/// <reference types="node" />
+import { Timer } from "./date";
 export type ProgressStats = {
     percent?: number;
     total?: number;
@@ -10,3 +12,34 @@ export type Progress = {
     absolute?: ProgressStats;
     relative?: ProgressStats;
 };
+export declare class ProgressManager {
+    readonly options: {
+        verbose?: boolean;
+        /**
+         * @default true
+         */
+        tty?: boolean | "auto";
+        enabled?: boolean | "auto" | "interval";
+        interval?: number;
+    };
+    protected timer: Timer;
+    protected interval: Timer | undefined;
+    protected keydownListener: ((data: Buffer) => void) | undefined;
+    readonly tty: boolean;
+    readonly enabled: boolean | "interval";
+    constructor(options: {
+        verbose?: boolean;
+        /**
+         * @default true
+         */
+        tty?: boolean | "auto";
+        enabled?: boolean | "auto" | "interval";
+        interval?: number;
+    });
+    elapsed(): number;
+    start(): void;
+    dispose(): void;
+    update(progress: Progress, cb: (text: string) => void): void;
+}
+export declare function renderProgress(progress: Progress, bar?: boolean): string[];
+export declare function renderProgressStats(stats: ProgressStats, progressBar?: boolean): string;