@datatruck/cli 0.34.4 → 0.34.5

package/lib/actions/BackupAction.js

@@ -1,4 +1,49 @@
 "use strict";
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        function next() {
+            while (env.stack.length) {
+                var rec = env.stack.pop();
+                try {
+                    var result = rec.dispose && rec.dispose.call(rec.value);
+                    if (rec.async) return Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -166,6 +211,7 @@ class BackupAction {
     }
     async exec() {
         const { options } = this;
+        const gc = new temp_1.GargabeCollector();
         const pm = new progress_1.ProgressManager({
             verbose: options.verbose,
             tty: options.tty,
@@ -174,6 +220,7 @@ class BackupAction {
         const l = new list_1.Listr3({
             streams: this.options.streams,
             progressManager: pm,
+            gargabeCollector: gc,
         });
         return l
             .add([
@@ -197,11 +244,11 @@ class BackupAction {
                     return [
                         ...packages.flatMap((pkg) => {
                             let taskResult = {};
-                            const gc = new temp_1.GargabeCollector();
                             const repositories = this.getRepositoryNames(pkg.repositoryNames ?? []);
                             const mirrorRepositories = repositories
                                 .filter((r) => r.mirrors.length)
                                 .flatMap(({ name, mirrors }) => mirrors.map((mirror) => ({ name, mirror })));
+                            const taskGc = gc.create();
                             return l.$tasks(!!pkg.task &&
                                 l.$task({
                                     key: "task",
@@ -214,13 +261,25 @@ class BackupAction {
                                         completed: `Task executed: ${pkg.name} (${pkg.task.name})`,
                                     },
                                     exitOnError: false,
-                                    runWrapper: gc.cleanupIfFail.bind(gc),
                                     run: async (task) => {
-                                        taskResult = await (0, task_1.createTask)(pkg.task).backup({
-                                            options,
-                                            package: pkg,
-                                            snapshot,
-                                            onProgress: (p) => pm.update(p, (t) => (task.output = t)),
+                                        await taskGc.disposeIfFail(async () => {
+                                            const env_1 = { stack: [], error: void 0, hasError: false };
+                                            try {
+                                                const progress = __addDisposableResource(env_1, pm.create(task), false);
+                                                taskResult = await (0, task_1.createTask)(pkg.task).backup({
+                                                    options,
+                                                    package: pkg,
+                                                    snapshot,
+                                                    onProgress: progress.update,
+                                                });
+                                            }
+                                            catch (e_1) {
+                                                env_1.error = e_1;
+                                                env_1.hasError = true;
+                                            }
+                                            finally {
+                                                __disposeResources(env_1);
+                                            }
                                         });
                                     },
                                 }), ...repositories.map(({ name: repositoryName }) => l.$task({
@@ -238,21 +297,34 @@ class BackupAction {
                                     failed: `Backup create failed: ${pkg.name} (${repositoryName})`,
                                 },
                                 exitOnError: false,
-                                runWrapper: gc.cleanupOnFinish.bind(gc),
                                 run: async (task, data) => {
-                                    const taskSummary = pkg.task
-                                        ? l.result("task", pkg.name)
-                                        : undefined;
-                                    if (taskSummary?.error)
-                                        throw new error_1.AppError(`Task failed`);
-                                    const backup = await this.backup({
-                                        pkg,
-                                        repositoryName,
-                                        snapshot,
-                                        snapshotPath: taskResult?.snapshotPath,
-                                        onProgress: (p) => pm.update(p, (t) => (task.output = t)),
-                                    });
-                                    data.bytes = backup.bytes;
+                                    const env_2 = { stack: [], error: void 0, hasError: false };
+                                    try {
+                                        const _ = __addDisposableResource(env_2, gc.create().disposeOnFinish(), true);
+                                        const taskSummary = pkg.task
+                                            ? l.result("task", pkg.name)
+                                            : undefined;
+                                        if (taskSummary?.error)
+                                            throw new error_1.AppError(`Task failed`);
+                                        const progress = __addDisposableResource(env_2, pm.create(task), false);
+                                        const backup = await this.backup({
+                                            pkg,
+                                            repositoryName,
+                                            snapshot,
+                                            snapshotPath: taskResult?.snapshotPath,
+                                            onProgress: progress.update,
+                                        });
+                                        data.bytes = backup.bytes;
+                                    }
+                                    catch (e_2) {
+                                        env_2.error = e_2;
+                                        env_2.hasError = true;
+                                    }
+                                    finally {
+                                        const result_1 = __disposeResources(env_2);
+                                        if (result_1)
+                                            await result_1;
+                                    }
                                 },
                             })), l.$task({
                                 key: "cleanup",
@@ -265,8 +337,8 @@ class BackupAction {
                                     failed: "Task files clean failed",
                                 },
                                 exitOnError: false,
-                                enabled: gc.pending,
-                                run: () => gc.cleanup(),
+                                enabled: taskGc.pending(),
+                                run: () => taskGc.dispose(),
                             }), ...mirrorRepositories.map(({ name, mirror }) => l.$task({
                                 key: "copy",
                                 keyIndex: [pkg.name, mirror],
@@ -283,22 +355,35 @@ class BackupAction {
                                     failed: `Snapshot copy failed: ${pkg.name} (${mirror})`,
                                 },
                                 exitOnError: false,
-                                runWrapper: gc.cleanup.bind(gc),
                                 run: async (task, data) => {
-                                    const backupSummary = l.result("backup", [
-                                        pkg.name,
-                                        name,
-                                    ]);
-                                    if (backupSummary.error)
-                                        throw new error_1.AppError(`Backup failed`);
-                                    const copy = await this.copy({
-                                        repositoryName: name,
-                                        mirrorRepositoryName: mirror,
-                                        pkg,
-                                        snapshot,
-                                        onProgress: (p) => pm.update(p, (t) => (task.output = t)),
-                                    });
-                                    data.bytes = copy.bytes;
+                                    const env_3 = { stack: [], error: void 0, hasError: false };
+                                    try {
+                                        const _ = __addDisposableResource(env_3, gc.create().disposeOnFinish(), true);
+                                        const backupSummary = l.result("backup", [
+                                            pkg.name,
+                                            name,
+                                        ]);
+                                        if (backupSummary.error)
+                                            throw new error_1.AppError(`Backup failed`);
+                                        const progress = __addDisposableResource(env_3, pm.create(task), false);
+                                        const copy = await this.copy({
+                                            repositoryName: name,
+                                            mirrorRepositoryName: mirror,
+                                            pkg,
+                                            snapshot,
+                                            onProgress: progress.update,
+                                        });
+                                        data.bytes = copy.bytes;
+                                    }
+                                    catch (e_3) {
+                                        env_3.error = e_3;
+                                        env_3.hasError = true;
+                                    }
+                                    finally {
+                                        const result_2 = __disposeResources(env_3);
+                                        if (result_2)
+                                            await result_2;
+                                    }
                                 },
                             })), !!this.options.prune &&
                                 l.$task({

package/lib/actions/CopyAction.js

@@ -269,26 +269,48 @@ class CopyAction {
                                             ? sourceRepo.get()
                                             : undefined;
                                     if ($sourceRepo) {
-                                        const copy = await $sourceRepo.copy({
-                                            mirrorRepositoryConfig: mirrorConfig.config,
-                                            options: { verbose: this.options.verbose },
-                                            package: { name: snapshot.packageName },
-                                            snapshot,
-                                            onProgress: (p) => pm.update(p, (d) => (task.output = d)),
-                                        });
-                                        data.bytes = copy.bytes;
+                                        const env_2 = { stack: [], error: void 0, hasError: false };
+                                        try {
+                                            const progress = __addDisposableResource(env_2, pm.create(task), false);
+                                            const copy = await $sourceRepo.copy({
+                                                mirrorRepositoryConfig: mirrorConfig.config,
+                                                options: { verbose: this.options.verbose },
+                                                package: { name: snapshot.packageName },
+                                                snapshot,
+                                                onProgress: progress.update,
+                                            });
+                                            data.bytes = copy.bytes;
+                                        }
+                                        catch (e_2) {
+                                            env_2.error = e_2;
+                                            env_2.hasError = true;
+                                        }
+                                        finally {
+                                            __disposeResources(env_2);
+                                        }
                                     }
                                     else {
-                                        const copy = await this.copyCrossRepository({
-                                            mirrorConfig,
-                                            mirrorRepo,
-                                            repo,
-                                            repoConfig,
-                                            snapshot,
-                                            onProgress: (p) => pm.update(p, (d) => (task.output = d)),
-                                        });
-                                        data.bytes = copy.bytes;
-                                        sourceRepo.set(mirrorRepo);
+                                        const env_3 = { stack: [], error: void 0, hasError: false };
+                                        try {
+                                            const progress = __addDisposableResource(env_3, pm.create(task), false);
+                                            const copy = await this.copyCrossRepository({
+                                                mirrorConfig,
+                                                mirrorRepo,
+                                                repo,
+                                                repoConfig,
+                                                snapshot,
+                                                onProgress: progress.update,
+                                            });
+                                            data.bytes = copy.bytes;
+                                            sourceRepo.set(mirrorRepo);
+                                        }
+                                        catch (e_3) {
+                                            env_3.error = e_3;
+                                            env_3.hasError = true;
+                                        }
+                                        finally {
+                                            __disposeResources(env_3);
+                                        }
                                     }
                                 },
                             });

package/lib/actions/InitAction.js

@@ -21,7 +21,7 @@ class InitAction {
             if (this.options.repositoryTypes &&
                 !this.options.repositoryTypes.includes(repoConfig.type))
                 continue;
-            const repo = (0, repository_1.createRepo)(repoConfig);
+            const repo = (0, repository_1.createRepo)(repoConfig, this.options.verbose);
             let initError = null;
             try {
                 await repo.init({

package/lib/actions/RestoreAction.d.ts

@@ -5,7 +5,6 @@ import type { Config, PackageConfig } from "../utils/datatruck/config-type";
 import { Listr3TaskResultEnd } from "../utils/list";
 import { Progress, ProgressMode } from "../utils/progress";
 import { StdStreams } from "../utils/stream";
-import { GargabeCollector } from "../utils/temp";
 import { IfRequireKeys } from "../utils/ts";
 export type RestoreActionOptions = {
     snapshotId: string;
@@ -47,7 +46,6 @@ export declare class RestoreAction<TRequired extends boolean = true> {
         pkg: PackageConfig;
         task: TaskAbstract | undefined;
         snapshot: RestoreSnapshot;
-        gc: GargabeCollector;
         onProgress: (progress: Progress) => void;
     }): Promise<{
         snapshotPath: string | undefined;

package/lib/actions/RestoreAction.js

@@ -1,4 +1,49 @@
 "use strict";
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        function next() {
+            while (env.stack.length) {
+                var rec = env.stack.pop();
+                try {
+                    var result = rec.dispose && rec.dispose.call(rec.value);
+                    if (rec.async) return Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -71,27 +116,25 @@ class RestoreAction {
         const repoConfig = (0, config_1.findRepositoryOrFail)(this.config, snapshot.repositoryName);
         const repo = await (0, repository_1.createAndInitRepo)(repoConfig, this.options.verbose);
         let snapshotPath = pkg.restorePath ?? pkg.path;
-        await data.gc.cleanupIfFail(async () => {
-            if (task) {
-                const taskResult = await task.prepareRestore({
-                    options: this.options,
-                    package: pkg,
-                    snapshot,
-                });
-                snapshotPath = taskResult?.snapshotPath;
-            }
-            await (0, fs_1.initEmptyDir)(snapshotPath);
-            if (this.config.minFreeDiskSpace)
-                await (0, fs_1.ensureFreeDiskSpace)([snapshotPath], this.config.minFreeDiskSpace);
-            await repo.restore({
+        if (task) {
+            const taskResult = await task.prepareRestore({
                 options: this.options,
-                snapshot: data.snapshot,
                 package: pkg,
-                snapshotPath: snapshotPath,
-                packageConfig: pkg.repositoryConfigs?.find((config) => config.type === repoConfig.type &&
-                    (!config.names || config.names.includes(repoConfig.name)))?.config,
-                onProgress: data.onProgress,
+                snapshot,
             });
+            snapshotPath = taskResult?.snapshotPath;
+        }
+        await (0, fs_1.initEmptyDir)(snapshotPath);
+        if (this.config.minFreeDiskSpace)
+            await (0, fs_1.ensureFreeDiskSpace)([snapshotPath], this.config.minFreeDiskSpace);
+        await repo.restore({
+            options: this.options,
+            snapshot: data.snapshot,
+            package: pkg,
+            snapshotPath: snapshotPath,
+            packageConfig: pkg.repositoryConfigs?.find((config) => config.type === repoConfig.type &&
+                (!config.names || config.names.includes(repoConfig.name)))?.config,
+            onProgress: data.onProgress,
         });
         return { snapshotPath };
     }
@@ -139,6 +182,7 @@ class RestoreAction {
     }
     async exec() {
         const { options } = this;
+        const gc = new temp_1.GargabeCollector();
         const pm = new progress_1.ProgressManager({
             verbose: options.verbose,
             tty: options.tty,
@@ -147,6 +191,7 @@ class RestoreAction {
         const l = new list_1.Listr3({
             streams: options.streams,
             progressManager: pm,
+            gargabeCollector: gc,
         });
         return l
             .add(l.$task({
@@ -184,48 +229,71 @@ class RestoreAction {
                     },
                     exitOnError: false,
                     run: async (listTask) => {
-                        let pkg = (0, config_1.resolvePackage)((0, config_1.findPackageOrFail)(this.config, snapshot.packageName), {
-                            snapshotId: options.snapshotId,
-                            snapshotDate: snapshot.date,
-                            action: "restore",
-                        });
-                        if (this.options.initial)
-                            pkg = { ...pkg, restorePath: pkg.path };
-                        const gc = new temp_1.GargabeCollector();
-                        const task = pkg.task ? (0, task_1.createTask)(pkg.task) : undefined;
-                        const restore = await this.restore({
-                            gc,
-                            pkg,
-                            task,
-                            snapshot: snapshot,
-                            onProgress: (p) => pm.update(p, (t) => (listTask.output = t)),
-                        });
-                        if (!task)
-                            return await gc.cleanup();
-                        return l.$tasks({
-                            key: "task",
-                            keyIndex: pkg.name,
-                            data: { taskName: pkg.task.name, packageName: pkg.name },
-                            title: {
-                                initial: `Execute task: ${pkg.name} (${pkg.task.name})`,
-                                started: `Executing task: ${pkg.name} (${pkg.task.name})`,
-                                completed: `Task executed: ${pkg.name} (${pkg.task.name})`,
-                                failed: `Task execute failed: ${pkg.name} (${pkg.task.name})`,
-                            },
-                            exitOnError: false,
-                            runWrapper: gc.cleanup.bind(gc),
-                            run: async (listTask) => {
-                                const { snapshotPath } = restore;
-                                (0, assert_1.ok)(snapshotPath);
-                                await task.restore({
-                                    package: pkg,
-                                    options,
-                                    snapshot,
-                                    snapshotPath,
-                                    onProgress: (p) => pm.update(p, (t) => (listTask.output = t)),
-                                });
-                            },
-                        });
+                        const env_1 = { stack: [], error: void 0, hasError: false };
+                        try {
+                            let pkg = (0, config_1.resolvePackage)((0, config_1.findPackageOrFail)(this.config, snapshot.packageName), {
+                                snapshotId: options.snapshotId,
+                                snapshotDate: snapshot.date,
+                                action: "restore",
+                            });
+                            if (this.options.initial)
+                                pkg = { ...pkg, restorePath: pkg.path };
+                            const task = pkg.task ? (0, task_1.createTask)(pkg.task) : undefined;
+                            const progress = __addDisposableResource(env_1, pm.create(listTask), false);
+                            const restoreGc = gc.create();
+                            const restore = await restoreGc.disposeIfFail(() => this.restore({
+                                pkg,
+                                task,
+                                snapshot: snapshot,
+                                onProgress: progress.update,
+                            }));
+                            if (!task)
+                                return await restoreGc.dispose();
+                            return l.$tasks({
+                                key: "task",
+                                keyIndex: pkg.name,
+                                data: { taskName: pkg.task.name, packageName: pkg.name },
+                                title: {
+                                    initial: `Execute task: ${pkg.name} (${pkg.task.name})`,
+                                    started: `Executing task: ${pkg.name} (${pkg.task.name})`,
+                                    completed: `Task executed: ${pkg.name} (${pkg.task.name})`,
+                                    failed: `Task execute failed: ${pkg.name} (${pkg.task.name})`,
+                                },
+                                exitOnError: false,
+                                run: async (listTask) => {
+                                    const env_2 = { stack: [], error: void 0, hasError: false };
+                                    try {
+                                        const _ = __addDisposableResource(env_2, restoreGc.disposeOnFinish(), true);
+                                        const { snapshotPath } = restore;
+                                        (0, assert_1.ok)(snapshotPath);
+                                        const progress = __addDisposableResource(env_2, pm.create(listTask), false);
+                                        await task.restore({
+                                            package: pkg,
+                                            options,
+                                            snapshot,
+                                            snapshotPath,
+                                            onProgress: progress.update,
+                                        });
+                                    }
+                                    catch (e_2) {
+                                        env_2.error = e_2;
+                                        env_2.hasError = true;
+                                    }
+                                    finally {
+                                        const result_1 = __disposeResources(env_2);
+                                        if (result_1)
+                                            await result_1;
+                                    }
+                                },
+                            });
+                        }
+                        catch (e_1) {
+                            env_1.error = e_1;
+                            env_1.hasError = true;
+                        }
+                        finally {
+                            __disposeResources(env_1);
+                        }
                     },
                 }));
             },

package/lib/repositories/DatatruckRepository.d.ts

@@ -12,7 +12,7 @@ export type MetaData = {
         files: number;
         size: number;
         checksum: string;
-    }>;
+    } | undefined>;
 };
 export type DatatruckRepositoryConfig = {
     backend: string;

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/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.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/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/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;

package/lib/utils/progress.js

@@ -13,6 +13,7 @@ class ProgressManager {
     interval = (0, date_1.createTimer)();
     intervalMs;
     keydownListener;
+    pendingProgress;
     tty;
     mode;
     constructor(options) {
@@ -66,19 +67,51 @@ class ProgressManager {
             this.keydownListener = undefined;
         }
     }
-    update(progress, cb) {
-        if (!this.mode)
+    create(input, delay = 1000) {
+        const update = (progress, force) => {
+            const text = this.renderProgress(progress, force);
+            if (typeof text === "string") {
+                if (typeof input === "function") {
+                    input(text);
+                }
+                else {
+                    input.output = text;
+                }
+            }
+        };
+        const updatePending = () => {
+            const pendingProgress = this.pendingProgress;
+            if (pendingProgress) {
+                this.pendingProgress = undefined;
+                update(pendingProgress, true);
+            }
+        };
+        const interval = setInterval(updatePending, delay);
+        return {
+            update,
+            [Symbol.dispose]: () => {
+                clearInterval(interval);
+                updatePending();
+            },
+        };
+    }
+    renderProgress(progress, force = false) {
+        if (!this.mode) {
             return;
-        if (this.mode === "interval") {
+        }
+        else if (this.mode === "interval") {
             if (this.interval) {
-                if (!this.interval.reset(this.intervalMs))
+                if (!this.interval.reset(this.intervalMs) && !force) {
+                    this.pendingProgress = progress;
                     return;
+                }
             }
             else {
                 this.interval = (0, date_1.createTimer)();
             }
         }
-        cb(renderProgress(progress, this.tty).join("\n"));
+        this.pendingProgress = undefined;
+        return renderProgress(progress, this.tty).join("\n");
     }
 }
 exports.ProgressManager = ProgressManager;

package/lib/utils/temp.d.ts

@@ -5,6 +5,7 @@ export declare function ensureFreeDiskTempSpace(size: number | string): Promise<
 export declare function isTmpDir(path: string): boolean;
 export declare function rmTmpDir(input: string | string[]): Promise<void>;
 export declare function tmpDir(...keys: [string, ...string[]]): string;
+export declare const collectors: Set<GargabeCollector>;
 export declare function mkTmpDir(...keys: [string, ...string[]]): Promise<string>;
 export declare function useTempDir(...keys: [string, ...string[]]): Promise<AsyncDisposable & {
     path: string;
@@ -12,15 +13,17 @@ export declare function useTempDir(...keys: [string, ...string[]]): Promise<Asyn
 export declare function useTempFile(path: string): AsyncDisposable & {
     path: string;
 };
-export declare class CleanupListener {
-    readonly paths: string[];
-    stop(): void;
-    dispose(): Promise<void>;
-}
 export declare class GargabeCollector {
-    protected listeners: Set<CleanupListener>;
-    get pending(): boolean;
-    cleanup(cb?: () => any): Promise<void>;
-    cleanupOnFinish(cb: () => any): Promise<void>;
-    cleanupIfFail(cb: () => any): Promise<CleanupListener>;
+    protected parent?: GargabeCollector | undefined;
+    readonly paths: Set<string>;
+    readonly children: Set<GargabeCollector>;
+    constructor(parent?: GargabeCollector | undefined);
+    pending(): boolean;
+    cleanup(): Promise<void>;
+    dispose(): Promise<void>;
+    disposeIfFail<T>(cb: () => Promise<T>): Promise<T>;
+    disposeOnFinish(): {
+        [Symbol.asyncDispose]: () => Promise<void>;
+    };
+    create(): GargabeCollector;
 }

package/lib/utils/temp.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GargabeCollector = exports.CleanupListener = exports.useTempFile = exports.useTempDir = exports.mkTmpDir = exports.tmpDir = exports.rmTmpDir = exports.isTmpDir = exports.ensureFreeDiskTempSpace = exports.sessionTmpDir = exports.parentTmpDir = void 0;
+exports.GargabeCollector = exports.useTempFile = exports.useTempDir = exports.mkTmpDir = exports.collectors = exports.tmpDir = exports.rmTmpDir = exports.isTmpDir = exports.ensureFreeDiskTempSpace = exports.sessionTmpDir = exports.parentTmpDir = void 0;
 const globalData_1 = __importDefault(require("../globalData"));
 const fs_1 = require("./fs");
 const crypto_1 = require("crypto");
@@ -44,12 +44,15 @@ exports.rmTmpDir = rmTmpDir;
 function tmpDir(...keys) {
     const id = (0, crypto_1.randomUUID)().slice(0, 8);
     const path = (0, path_1.join)(sessionTmpDir(), [...keys, id].map(encodeURIComponent).join("-"));
-    for (const listener of listeners)
-        listener.paths.push(path);
+    if (exports.collectors.size) {
+        const lastListener = [...exports.collectors.values()].at(exports.collectors.size - 1);
+        if (lastListener)
+            lastListener.paths.add(path);
+    }
     return path;
 }
 exports.tmpDir = tmpDir;
-const listeners = new Set();
+exports.collectors = new Set();
 async function mkTmpDir(...keys) {
     const path = tmpDir(...keys);
     await (0, promises_1.mkdir)(path, { recursive: true });
@@ -81,53 +84,57 @@ function useTempFile(path) {
     };
 }
 exports.useTempFile = useTempFile;
-class CleanupListener {
-    paths = [];
-    stop() {
-        listeners.delete(this);
-    }
-    async dispose() {
-        this.stop();
-        await rmTmpDir(this.paths);
-    }
-}
-exports.CleanupListener = CleanupListener;
 class GargabeCollector {
-    listeners = new Set();
-    get pending() {
-        return this.listeners.size > 0;
+    parent;
+    paths = new Set();
+    children = new Set();
+    constructor(parent) {
+        this.parent = parent;
+        exports.collectors.add(this);
     }
-    async cleanup(cb) {
-        try {
-            await cb?.();
-        }
-        finally {
-            for (const listener of this.listeners) {
-                this.listeners.delete(listener);
-                await listener.dispose();
+    pending() {
+        if (this.paths.size)
+            return true;
+        for (const child of this.children)
+            if (child.pending())
+                return true;
+        return false;
+    }
+    async cleanup() {
+        for (const path of this.paths) {
+            try {
+                await rmTmpDir(path);
+                this.paths.delete(path);
             }
+            catch (_) { }
         }
+        for (const child of this.children)
+            await child.cleanup();
     }
-    async cleanupOnFinish(cb) {
-        const cleanup = new CleanupListener();
-        try {
-            await cb();
-        }
-        finally {
-            cleanup.dispose();
-        }
+    async dispose() {
+        await this.cleanup();
+        exports.collectors.delete(this);
     }
-    async cleanupIfFail(cb) {
-        const cleanup = new CleanupListener();
+    async disposeIfFail(cb) {
         try {
-            await cb();
+            return await cb();
         }
         catch (error) {
-            await cleanup.dispose();
+            await this.dispose();
             throw error;
         }
-        this.listeners.add(cleanup);
-        return cleanup;
+    }
+    disposeOnFinish() {
+        return {
+            [Symbol.asyncDispose]: async () => {
+                return this.dispose();
+            },
+        };
+    }
+    create() {
+        const gc = new GargabeCollector();
+        this.children.add(gc);
+        return gc;
     }
 }
 exports.GargabeCollector = GargabeCollector;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@datatruck/cli",
-  "version": "0.34.4",
+  "version": "0.34.5",
   "description": "Tool for creating and managing backups",
   "homepage": "https://github.com/swordev/datatruck#readme",
   "bugs": {