@datatruck/cli 0.34.4 → 0.35.0

package/lib/repositories/DatatruckRepository.js

@@ -45,15 +45,15 @@ class DatatruckRepository extends RepositoryAbstract_1.RepositoryAbstract {
         return this.config.backend;
     }
     fetchDiskStats(config) {
-        const fs = (0, client_1.createFs)(config.backend);
+        const fs = (0, client_1.createFs)(config.backend, this.verbose);
         return fs.fetchDiskStats(".");
     }
     async init(data) {
-        const fs = (0, client_1.createFs)(this.config.backend);
+        const fs = (0, client_1.createFs)(this.config.backend, this.verbose);
         await fs.mkdir(".");
     }
     async prune(data) {
-        const fs = (0, client_1.createFs)(this.config.backend);
+        const fs = (0, client_1.createFs)(this.config.backend, this.verbose);
         const snapshotName = DatatruckRepository.buildSnapshotName(data.snapshot, {
             name: data.snapshot.packageName,
         });
@@ -63,7 +63,7 @@ class DatatruckRepository extends RepositoryAbstract_1.RepositoryAbstract {
             await fs.rmAll(snapshotName);
     }
     async fetchSnapshots(data) {
-        const fs = (0, client_1.createFs)(this.config.backend);
+        const fs = (0, client_1.createFs)(this.config.backend, this.verbose);
         if (!(await fs.existsDir(".")))
             throw new error_1.AppError(`Repository (${this.repository.name}) out path does not exist: ${fs.resolvePath(".")}`);
         const snapshots = [];
@@ -105,7 +105,7 @@ class DatatruckRepository extends RepositoryAbstract_1.RepositoryAbstract {
         return snapshots;
     }
     async backup(data) {
-        const fs = (0, client_1.createFs)(this.config.backend);
+        const fs = (0, client_1.createFs)(this.config.backend, this.verbose);
         const snapshotName = DatatruckRepository.buildSnapshotName(data.snapshot, data.package);
         const outPath = fs.isLocal()
             ? fs.resolvePath(snapshotName)
@@ -177,11 +177,11 @@ class DatatruckRepository extends RepositoryAbstract_1.RepositoryAbstract {
                 .join("-") + (pack.compress ? `.tar.gz` : `.tar`);
             const includeList = stream.path(packIndex);
             if (includeList) {
-                tarStats[packBasename] = {
+                const stats = (tarStats[packBasename] = {
                     files: stream.lines(packIndex),
                     size: 0,
                     checksum: "",
-                };
+                });
                 const tarPath = (0, path_1.join)(outPath, packBasename);
                 await (0, tar_1.createTar)({
                     compress: pack.compress,
@@ -192,8 +192,8 @@ class DatatruckRepository extends RepositoryAbstract_1.RepositoryAbstract {
                     onEntry: async (data) => scanner.progress(pack.compress ? "Compressing" : "Packing", data.path),
                 });
                 scanner.progress("Fetching tar stats", (0, path_1.basename)(tarPath), false);
-                tarStats[packBasename].checksum = await (0, crypto_1.calcFileHash)(tarPath, "sha1");
-                tarStats[packBasename].size = (await (0, promises_1.stat)(tarPath)).size;
+                stats.checksum = await (0, crypto_1.calcFileHash)(tarPath, "sha1");
+                stats.size = (await (0, promises_1.stat)(tarPath)).size;
                 if (!fs.isLocal()) {
                     scanner.progress("Uploading tar", (0, path_1.basename)(tarPath), false);
                     await fs.upload(tarPath, `${snapshotName}/${packBasename}`);
@@ -204,7 +204,7 @@ class DatatruckRepository extends RepositoryAbstract_1.RepositoryAbstract {
         }
         scanner.end();
         // Meta
-        const size = Object.values(tarStats).reduce((total, { size }) => total + size, 0);
+        const size = Object.values(tarStats).reduce((total, stat) => total + stat.size, 0);
         const metaPath = `${snapshotName}/meta.json`;
         const nodePkg = (0, fs_1.parsePackageFile)();
         const meta = {
@@ -225,8 +225,8 @@ class DatatruckRepository extends RepositoryAbstract_1.RepositoryAbstract {
         };
     }
     async copy(data) {
-        const sourceFs = (0, client_1.createFs)(this.config.backend);
-        const targetFs = (0, client_1.createFs)(data.mirrorRepositoryConfig.backend);
+        const sourceFs = (0, client_1.createFs)(this.config.backend, this.verbose);
+        const targetFs = (0, client_1.createFs)(data.mirrorRepositoryConfig.backend, this.verbose);
         const snapshotName = DatatruckRepository.buildSnapshotName(data.snapshot, data.package);
         if (data.options.verbose)
             (0, cli_1.logExec)(`Copying backup files to ${data.mirrorRepositoryConfig.backend}`);
@@ -296,7 +296,7 @@ class DatatruckRepository extends RepositoryAbstract_1.RepositoryAbstract {
         return { bytes };
     }
     async restore(data) {
-        const fs = (0, client_1.createFs)(this.config.backend);
+        const fs = (0, client_1.createFs)(this.config.backend, this.verbose);
         const relRestorePath = data.snapshotPath;
         (0, assert_1.ok)(relRestorePath);
         const restorePath = (0, path_1.resolve)(relRestorePath);
@@ -325,10 +325,20 @@ class DatatruckRepository extends RepositoryAbstract_1.RepositoryAbstract {
                 if (!fs.isLocal()) {
                     const tempDir = await (0, temp_1.mkTmpDir)(exports.datatruckRepositoryName, "repo", "restore", "remote-fs", entry);
                     tempEntry = `${tempDir}/${entry}`;
-                    await fs.download(sourceEntry, tempEntry);
+                    await fs.download(sourceEntry, tempEntry, {
+                        onProgress: (stats) => {
+                            progress.updateRelative("Downloading", entry, {
+                                ...stats,
+                                format: "size",
+                            });
+                        },
+                    });
                 }
+                const stats = tarStats[entry];
+                if (data.options.verbose)
+                    (0, cli_1.logExec)(`Stats of '${entry}' is not available`);
                 await (0, tar_1.extractTar)({
-                    total: tarStats[entry].files,
+                    total: stats?.files,
                     input: tempEntry ?? fs.resolvePath(sourceEntry),
                     output: restorePath,
                     decompress: entry.endsWith(".tar.gz"),

package/lib/repositories/GitRepository.js

@@ -68,7 +68,11 @@ class GitRepository extends RepositoryAbstract_1.RepositoryAbstract {
                 branchName,
                 orphan: true,
             });
-            await git.exec(["commit", "-m", "Initial commit", "--allow-empty"]);
+            await git.commit("Initial commit", {
+                allowEmpty: true,
+                userName: "datatruck",
+                userEmail: "datatruck@localhost",
+            });
             await git.push({ branchName });
         }
     }
@@ -184,8 +188,12 @@ class GitRepository extends RepositoryAbstract_1.RepositoryAbstract {
         if (data.options.verbose)
             console.info(`Copied ${files} files`);
         await git.exec(["add", "--verbose", "."]);
-        if (await git.haveChanges())
-            await git.exec(["commit", "-m", data.snapshot.id]);
+        if (await git.haveChanges()) {
+            await git.commit(data.snapshot.id, {
+                userName: "datatruck",
+                userEmail: "datatruck@localhost",
+            });
+        }
         const nodePkg = (0, fs_1.parsePackageFile)();
         const size = (await (0, fs_1.fastFolderSizeAsync)(tmpPath)) -
             (await (0, fs_1.fastFolderSizeAsync)((0, path_1.join)(tmpPath, ".git")));

package/lib/repositories/RepositoryAbstract.d.ts

@@ -75,8 +75,9 @@ export type SnapshotTagObject = {
 };
 export declare abstract class RepositoryAbstract<TConfig> {
     readonly repository: RepositoryConfig;
+    readonly verbose: boolean;
     readonly config: TConfig;
-    constructor(repository: RepositoryConfig);
+    constructor(repository: RepositoryConfig, verbose: boolean);
     abstract getSource(): string;
     abstract fetchDiskStats(config: TConfig): Promise<DiskStats | undefined>;
     ensureFreeDiskSpace(config: TConfig, minFreeDiskSpace: number | string): Promise<void>;

package/lib/repositories/RepositoryAbstract.js

@@ -15,9 +15,11 @@ var SnapshotTagEnum;
 })(SnapshotTagEnum || (exports.SnapshotTagEnum = SnapshotTagEnum = {}));
 class RepositoryAbstract {
     repository;
+    verbose;
     config;
-    constructor(repository) {
+    constructor(repository, verbose) {
         this.repository = repository;
+        this.verbose = verbose;
         this.config = repository.config;
     }
     async ensureFreeDiskSpace(config, minFreeDiskSpace) {

package/lib/tasks/MongoDumpTask.d.ts

@@ -0,0 +1,21 @@
+import { TaskBackupData, TaskRestoreData, TaskAbstract } from "./TaskAbstract";
+export type MongoDumpTaskConfig = {
+    command?: string;
+    hostname?: string;
+    port?: number;
+    username?: string;
+    password?: string | {
+        path: string;
+    };
+    compress?: boolean;
+    concurrency?: number;
+};
+export declare const mongodumpTaskName = "mongo-dump";
+export declare class MongoDumpTask extends TaskAbstract<MongoDumpTaskConfig> {
+    protected verbose?: boolean;
+    private get command();
+    backup(data: TaskBackupData): Promise<{
+        snapshotPath: string;
+    }>;
+    restore(data: TaskRestoreData): Promise<void>;
+}

package/lib/tasks/MongoDumpTask.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoDumpTask = exports.mongodumpTaskName = void 0;
+const async_process_1 = require("../utils/async-process");
+const fs_1 = require("../utils/fs");
+const temp_1 = require("../utils/temp");
+const TaskAbstract_1 = require("./TaskAbstract");
+exports.mongodumpTaskName = "mongo-dump";
+class MongoDumpTask extends TaskAbstract_1.TaskAbstract {
+    verbose;
+    get command() {
+        return this.config.command ?? "mongodump";
+    }
+    async backup(data) {
+        this.verbose = data.options.verbose;
+        const snapshotPath = data.package.path ??
+            (await (0, temp_1.mkTmpDir)(exports.mongodumpTaskName, "task", "backup", "snapshot"));
+        await (0, fs_1.mkdirIfNotExists)(snapshotPath);
+        await (0, fs_1.ensureEmptyDir)(snapshotPath);
+        const p = new async_process_1.AsyncProcess(this.command, [
+            ...(this.config.hostname ? ["/h", this.config.hostname] : []),
+            ...(this.config.port ? ["/p", this.config.port] : []),
+            ...(this.config.username ? ["/u", this.config.username] : []),
+            ...(this.config.compress ? ["/gzip"] : []),
+            ...(this.config.concurrency ? ["/j", this.config.concurrency] : []),
+            "/o",
+            snapshotPath,
+        ], {
+            $log: this.verbose,
+        });
+        const password = this.config.password !== undefined
+            ? (await (0, fs_1.fetchData)(this.config.password, (p) => p.path)) ?? ""
+            : "";
+        p.stdin.writable.write(`${password}\n`);
+        await p.stderr.parseLines((line) => {
+            data.onProgress({
+                absolute: {
+                    description: line.slice(0, 255),
+                },
+            });
+        });
+        return { snapshotPath };
+    }
+    async restore(data) {
+        throw new Error("Not implemented");
+    }
+}
+exports.MongoDumpTask = MongoDumpTask;

package/lib/tasks/PostgresqlDumpTask.js

@@ -64,14 +64,26 @@ class PostgresqlDumpTask extends SqlDumpTaskAbstract_1.SqlDumpTaskAbstract {
         const dumpProcess = new async_process_1.AsyncProcess("pg_dump", [
             ...(await this.buildConnectionArgs(this.config.database)),
             ...(tableNames?.flatMap((v) => ["-t", v]) ?? []),
-        ], { $log: this.verbose });
+        ], {
+            $log: {
+                exec: this.verbose,
+                stderr: this.verbose,
+                allToStderr: true,
+            },
+        });
         await dumpProcess.stdout.pipe(output, onProgress);
     }
     async onExportStoredPrograms() {
         throw new Error(`Method not implemented: onExportStoredPrograms`);
     }
     async onImport(path, database) {
-        await async_process_1.AsyncProcess.exec("psql", [...(await this.buildConnectionArgs(database)), "-f", (0, path_1.normalize)(path)], { $log: this.verbose });
+        await async_process_1.AsyncProcess.exec("psql", [...(await this.buildConnectionArgs(database)), "-f", (0, path_1.normalize)(path)], {
+            $log: {
+                exec: this.verbose,
+                stderr: this.verbose,
+                allToStderr: true,
+            },
+        });
     }
 }
 exports.PostgresqlDumpTask = PostgresqlDumpTask;

package/lib/utils/datatruck/client.d.ts

@@ -2,10 +2,14 @@ import { DiskStats } from "../fs";
 import { BasicProgress } from "../progress";
 import { AbstractFs, FsOptions } from "../virtual-fs";
 export declare class RemoteFs extends AbstractFs {
-    readonly options: FsOptions;
+    readonly options: FsOptions & {
+        verbose?: boolean;
+    };
     protected url: string;
     protected headers: Record<string, string>;
-    constructor(options: FsOptions);
+    constructor(options: FsOptions & {
+        verbose?: boolean;
+    });
     isLocal(): boolean;
     protected fetchJson(name: string, params: any[]): Promise<any>;
     protected post(name: string, params: any[], data: string): Promise<void>;
@@ -28,4 +32,4 @@ export declare class RemoteFs extends AbstractFs {
     }>;
 }
 export declare function isRemoteBackend(backend: string): boolean;
-export declare function createFs(backend: string): AbstractFs;
+export declare function createFs(backend: string, verbose: boolean | undefined): AbstractFs;

package/lib/utils/datatruck/client.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createFs = exports.isRemoteBackend = exports.RemoteFs = void 0;
+const cli_1 = require("../cli");
 const http_1 = require("../http");
 const virtual_fs_1 = require("../virtual-fs");
 const repository_server_1 = require("./repository-server");
@@ -69,9 +70,13 @@ class RemoteFs extends virtual_fs_1.AbstractFs {
         await this.fetchJson("rmAll", [path]);
     }
     async fetchDiskStats(path) {
+        if (this.options.verbose)
+            (0, cli_1.logExec)("fs.fetchDiskStats", [path]);
         return await this.fetchJson("fetchDiskStats", [path]);
     }
     async upload(source, target) {
+        if (this.options.verbose)
+            (0, cli_1.logExec)("fs.upload", [source, target]);
         await (0, http_1.uploadFile)(`${this.url}/upload`, source, {
             headers: this.headers,
             query: {
@@ -80,6 +85,8 @@ class RemoteFs extends virtual_fs_1.AbstractFs {
         });
     }
     async download(source, target, options = {}) {
+        if (this.options.verbose)
+            (0, cli_1.logExec)("fs.download", [source, target]);
         return await (0, http_1.downloadFile)(`${this.url}/download`, target, {
             ...options,
             headers: this.headers,
@@ -92,9 +99,9 @@ function isRemoteBackend(backend) {
     return backend.startsWith("http:") || backend.startsWith("https:");
 }
 exports.isRemoteBackend = isRemoteBackend;
-function createFs(backend) {
+function createFs(backend, verbose) {
     return isRemoteBackend(backend)
-        ? new RemoteFs({ backend })
+        ? new RemoteFs({ backend, verbose })
         : new virtual_fs_1.LocalFs({ backend });
 }
 exports.createFs = createFs;

package/lib/utils/datatruck/config-task-type.d.ts

@@ -1,5 +1,6 @@
 import type { GitTaskConfig, gitTaskName } from "../../tasks/GitTask";
 import type { MariadbTaskConfig, mariadbTaskName } from "../../tasks/MariadbTask";
+import { MongoDumpTaskConfig, mongodumpTaskName } from "../../tasks/MongoDumpTask";
 import type { MssqlTaskConfig, mssqlTaskName } from "../../tasks/MssqlTask";
 import type { MysqlDumpTaskConfig, mysqlDumpTaskName } from "../../tasks/MysqlDumpTask";
 import type { PostgresqlDumpTaskConfig, postgresqlDumpTaskName } from "../../tasks/PostgresqlDumpTask";
@@ -24,8 +25,12 @@ export type PostgresqlDumpTaskConfigItem = {
     name: typeof postgresqlDumpTaskName;
     config: PostgresqlDumpTaskConfig;
 };
+export type MongodumpTaskConfigItem = {
+    name: typeof mongodumpTaskName;
+    config: MongoDumpTaskConfig;
+};
 export type ScriptTaskConfigItem = {
     name: typeof scriptTaskName;
     config: ScriptTaskConfig;
 };
-export type TaskConfig = GitTaskConfigItem | MariadbTaskConfigItem | MssqlTaskConfigItem | MysqlDumpTaskConfigItem | PostgresqlDumpTaskConfigItem | ScriptTaskConfigItem;
+export type TaskConfig = GitTaskConfigItem | MariadbTaskConfigItem | MssqlTaskConfigItem | MysqlDumpTaskConfigItem | PostgresqlDumpTaskConfigItem | MongodumpTaskConfigItem | ScriptTaskConfigItem;

package/lib/utils/datatruck/config.js

@@ -8,14 +8,14 @@ const micromatch_1 = require("micromatch");
 function findRepositoryOrFail(config, repositoryName) {
     const repo = config.repositories.find((v) => v.name === repositoryName);
     if (!repo)
-        throw new error_1.AppError(`Repository '${repositoryName}' not found`);
+        throw new error_1.AppError(`Repository '${repositoryName}' not found in the config`);
     return repo;
 }
 exports.findRepositoryOrFail = findRepositoryOrFail;
 function findPackageOrFail(config, packageName) {
     const pkg = config.packages.find((v) => v.name === packageName);
     if (!pkg)
-        throw new error_1.AppError(`Package '${packageName}' not found`);
+        throw new error_1.AppError(`Package '${packageName}' not found in the config`);
     return pkg;
 }
 exports.findPackageOrFail = findPackageOrFail;

package/lib/utils/datatruck/repository.d.ts

@@ -9,8 +9,8 @@ declare const repoMap: {
     datatruck: typeof DatatruckRepository;
 };
 export declare function getRepoConstructor(type: keyof typeof repoMap): {
-    new (config: RepositoryConfig): RepositoryAbstract<any>;
+    new (config: RepositoryConfig, verbose?: boolean): RepositoryAbstract<any>;
 };
-export declare function createRepo(repository: RepositoryConfig): RepositoryAbstract<any>;
-export declare function createAndInitRepo(repository: RepositoryConfig, verbose?: boolean): Promise<RepositoryAbstract<any>>;
+export declare function createRepo(repository: RepositoryConfig, verbose: boolean | undefined): RepositoryAbstract<any>;
+export declare function createAndInitRepo(repository: RepositoryConfig, verbose: boolean | undefined): Promise<RepositoryAbstract<any>>;
 export {};

package/lib/utils/datatruck/repository.js

@@ -17,13 +17,13 @@ function getRepoConstructor(type) {
     return Constructor;
 }
 exports.getRepoConstructor = getRepoConstructor;
-function createRepo(repository) {
+function createRepo(repository, verbose) {
     const Constructor = getRepoConstructor(repository.type);
-    return new Constructor(repository);
+    return new Constructor(repository, verbose);
 }
 exports.createRepo = createRepo;
 async function createAndInitRepo(repository, verbose) {
-    const repo = createRepo(repository);
+    const repo = createRepo(repository, verbose);
     await repo.init({ options: { verbose } });
     return repo;
 }

package/lib/utils/datatruck/task.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createTask = void 0;
 const GitTask_1 = require("../../tasks/GitTask");
 const MariadbTask_1 = require("../../tasks/MariadbTask");
+const MongoDumpTask_1 = require("../../tasks/MongoDumpTask");
 const MssqlTask_1 = require("../../tasks/MssqlTask");
 const MysqlDumpTask_1 = require("../../tasks/MysqlDumpTask");
 const PostgresqlDumpTask_1 = require("../../tasks/PostgresqlDumpTask");
@@ -24,6 +25,9 @@ function createTask(task) {
     else if (task.name === MssqlTask_1.mssqlTaskName) {
         return new MssqlTask_1.MssqlTask(task.config ?? {});
     }
+    else if (task.name === MongoDumpTask_1.mongodumpTaskName) {
+        return new MongoDumpTask_1.MongoDumpTask(task.config ?? {});
+    }
     else if (task.name === ScriptTask_1.scriptTaskName) {
         return new ScriptTask_1.ScriptTask(task.config ?? {});
     }

package/lib/utils/fs.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 /// <reference types="node" />
 /// <reference types="node" />
-import { Progress } from "./progress";
+import { Progress, ProgressStats } from "./progress";
 import { Entry, Options } from "fast-glob";
 import { Stats } from "fs";
 import { WriteStream } from "fs";
@@ -90,6 +90,7 @@ type ProgressObject = {
     total: number;
     current: number;
     update: (description: string, path?: string, increment?: boolean) => void;
+    updateRelative: (description: string, path: string, stats: ProgressStats) => void;
 };
 export declare function createProgress(options: {
     onProgress: (data: Progress) => void;

package/lib/utils/fs.js

@@ -400,11 +400,29 @@ function createProgress(options) {
         disposed: false,
         total: 0,
         current: 0,
+        updateRelative(description, path, stats) {
+            if (progress.disposed)
+                return;
+            options.onProgress({
+                relative: {
+                    ...stats,
+                    description,
+                    payload: path,
+                },
+                absolute: {
+                    total: progress.total,
+                    current: progress.current,
+                    percent: (0, math_1.progressPercent)(progress.total, progress.current),
+                },
+            });
+        },
         update: (description, path, increment = true) => {
             if (progress.disposed)
                 return;
             if (path && increment)
                 progress.current++;
+            if (path === "." || path === "./")
+                return;
             options.onProgress({
                 relative: {
                     description,

package/lib/utils/git.d.ts

@@ -28,6 +28,11 @@ export declare class Git {
     removeAll(): Promise<void>;
     haveChanges(): Promise<boolean>;
     fetchCommitId(tag: string): Promise<string>;
+    commit(description: string, options?: {
+        allowEmpty?: boolean;
+        userName?: string;
+        userEmail?: string;
+    }): Promise<void>;
     getTags(names?: string[]): Promise<{
         name: string;
         message?: string | undefined;

package/lib/utils/git.js

@@ -70,6 +70,16 @@ class Git {
     async fetchCommitId(tag) {
         return (await this.stdout(["rev-list", "-n", "1", tag])).trim();
     }
+    async commit(description, options = {}) {
+        await this.exec([
+            ...(options.userName ? ["-c", `user.name='${options.userName}'`] : []),
+            ...(options.userEmail ? ["-c", `user.email='${options.userEmail}'`] : []),
+            "commit",
+            "-m",
+            description,
+            ...(options.allowEmpty ? ["--allow-empty"] : []),
+        ]);
+    }
     async getTags(names) {
         const stdout = await this.stdout(["tag", "-n", ...(names ?? [])]);
         return stdout.split(/\r?\n/).reduce((result, value) => {

package/lib/utils/list.d.ts

@@ -1,6 +1,7 @@
 import { Timer } from "./date";
 import { ProgressManager } from "./progress";
 import { StdStreams } from "./stream";
+import { GargabeCollector } from "./temp";
 import { Listr, ListrGetRendererClassFromValue, ListrLogger, ListrTask, ListrTaskWrapper } from "listr2";
 export declare class List3Logger<Levels extends string = string> extends ListrLogger<Levels> {
     constructor(options?: {
@@ -19,7 +20,6 @@ type Listr3Task<T extends Listr3Context, K extends keyof T> = {
         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;
@@ -43,6 +43,7 @@ export declare class Listr3<T extends Listr3Context> extends Listr<void, "defaul
     readonly $options: {
         streams?: StdStreams;
         progressManager?: ProgressManager;
+        gargabeCollector?: GargabeCollector;
     };
     readonly resultMap: Record<string, Listr3TaskResult<T>>;
     readonly resultList: Listr3TaskResult<T>[];
@@ -51,6 +52,7 @@ export declare class Listr3<T extends Listr3Context> extends Listr<void, "defaul
     constructor($options: {
         streams?: StdStreams;
         progressManager?: ProgressManager;
+        gargabeCollector?: GargabeCollector;
     });
     private serializeKeyIndex;
     private createResultIndex;

package/lib/utils/list.js

@@ -89,9 +89,7 @@ class Listr3 extends listr2_1.Listr {
                 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);
+                        const runResult = await item.run(task, result.data);
                         if (title.completed)
                             task.title = title.completed;
                         return Array.isArray(runResult)
@@ -153,6 +151,7 @@ class Listr3 extends listr2_1.Listr {
             throw error;
         }
         finally {
+            await this.$options.gargabeCollector?.dispose();
             dispose();
         }
     }

package/lib/utils/mysql.js

@@ -62,8 +62,9 @@ async function createMysqlCli(options) {
             `user = "${options.username}"`,
             `password = "${password}"`,
         ];
-        await (0, promises_1.writeFile)((sqlConfigPath = (0, path_1.join)(dir, "mysql.conf")), data.join("\n"));
-        return sqlConfigPath;
+        const path = (0, path_1.join)(dir, "mysql.conf");
+        await (0, promises_1.writeFile)(path, data.join("\n"));
+        return (sqlConfigPath = path);
     }
     async function args() {
         return [`--defaults-file=${await createSqlConfig()}`];

package/lib/utils/progress.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import { Timer } from "./date";
 export type BasicProgress = {
     percent: number;
@@ -35,6 +36,7 @@ export declare class ProgressManager {
     protected interval: Timer | undefined;
     protected intervalMs: number;
     protected keydownListener: ((data: Buffer | undefined) => void) | undefined;
+    protected pendingProgress: Progress | undefined;
     readonly tty: Exclude<ProgressTty, "auto">;
     readonly mode: Exclude<ProgressMode, "auto" | `interval:${number}`>;
     constructor(options: {
@@ -51,7 +53,12 @@ export declare class ProgressManager {
     elapsed(): number;
     start(): void;
     dispose(): void;
-    update(progress: Progress, cb: (text: string) => void): void;
+    create(input: ((text: string) => void) | {
+        output: string;
+    }, delay?: number): Disposable & {
+        update: (progress: Progress) => void;
+    };
+    renderProgress(progress: Progress, force?: boolean): string | undefined;
 }
 export declare function renderProgress(progress: Progress, bar?: boolean): string[];
 export declare function renderProgressStats(stats: ProgressStats, progressBar?: boolean): string;