@datatruck/cli 0.14.0 → 0.16.1

package/Repository/DatatruckRepository.js

@@ -19,6 +19,7 @@ const fs_1 = require("fs");
 const promises_1 = require("fs/promises");
 const micromatch_1 = require("micromatch");
 const path_1 = require("path");
+const perf_hooks_1 = require("perf_hooks");
 const readline_1 = require("readline");
 exports.datatruckRepositoryName = "datatruck";
 exports.datatruckRepositoryDefinition = {
@@ -75,8 +76,6 @@ class DatatruckRepository extends RepositoryAbstract_1.RepositoryAbstract {
         return `${date}_${pkgName}_${snapshotShortId}`;
     }
     static parseSnapshotName(name) {
-        if (!name.endsWith(".json"))
-            return null;
         name = name.replace(/\.json$/, "");
         const nameParts = name.split("_");
         if (nameParts.length !== 3)
@@ -103,6 +102,66 @@ class DatatruckRepository extends RepositoryAbstract_1.RepositoryAbstract {
     async onInit(data) {
         await (0, fs_util_1.mkdirIfNotExists)(this.config.outPath);
     }
+    async createFileScanner(options) {
+        const object = {
+            total: 0,
+            current: 0,
+            progress: async (description, data) => {
+                await options.onProgress({
+                    relative: {
+                        description,
+                        payload: data.path,
+                        percent: data.percent,
+                    },
+                    absolute: {
+                        total: object.total,
+                        current: object.current + data.current,
+                        percent: (0, math_util_1.progressPercent)(object.total, object.current + data.current),
+                    },
+                });
+                if (data.type === "end") {
+                    object.current += data.current;
+                }
+            },
+            updateProgress: async (end) => {
+                const currentTime = perf_hooks_1.performance.now();
+                const diff = currentTime - lastTime;
+                if (end || diff > 1000) {
+                    await options.onProgress({
+                        relative: {
+                            description: end ? "Scanned files" : "Scanning files",
+                            payload: object.total.toString(),
+                        },
+                    });
+                    lastTime = currentTime;
+                }
+            },
+            start: async (cb) => {
+                for await (const entry of (0, fs_util_1.pathIterator)(stream)) {
+                    if (!options.disableCounting)
+                        object.total++;
+                    await object.updateProgress();
+                    if (cb)
+                        await cb(entry);
+                }
+                if (!options.disableEndProgress)
+                    await object.updateProgress(true);
+            },
+        };
+        await options.onProgress({
+            relative: {
+                description: "Scanning files",
+            },
+        });
+        const stream = fast_glob_1.default.stream(options.glob.include, {
+            dot: true,
+            markDirectories: true,
+            stats: true,
+            ...options.glob,
+        });
+        let lastTime = perf_hooks_1.performance.now();
+        return object;
+    }
     async onPrune(data) {
         const snapshotName = DatatruckRepository.buildSnapshotName({
             snapshotId: data.snapshot.id,
@@ -110,15 +169,12 @@ class DatatruckRepository extends RepositoryAbstract_1.RepositoryAbstract {
             packageName: data.snapshot.packageName,
         });
         const snapshotPath = (0, path_1.join)(this.config.outPath, snapshotName);
-        const metaPath = `${snapshotPath}.json`;
         if (data.options.verbose)
             (0, cli_util_1.logExec)(`Deleting ${snapshotPath}`);
         if (await (0, fs_util_1.checkDir)(snapshotPath))
             await (0, promises_1.rm)(snapshotPath, {
                 recursive: true,
             });
-        if (await (0, fs_util_1.checkFile)(metaPath))
-            await (0, promises_1.rm)(metaPath);
     }
     async onSnapshots(data) {
         if (!(await (0, fs_util_1.checkDir)(this.config.outPath)))
@@ -137,7 +193,7 @@ class DatatruckRepository extends RepositoryAbstract_1.RepositoryAbstract {
             if (data.options.ids &&
                 !data.options.ids.some((id) => snapshotNameData.snapshotShortId.startsWith(id.slice(0, 8))))
                 continue;
-            const metaPath = (0, path_1.join)(this.config.outPath, snapshotName);
+            const metaPath = (0, path_1.join)(this.config.outPath, snapshotName, "meta.json");
             const meta = await DatatruckRepository.parseMetaData(metaPath);
             if (taskPatterns && !(0, string_util_1.checkMatch)(meta.task, taskPatterns))
                 continue;
@@ -199,34 +255,32 @@ class DatatruckRepository extends RepositoryAbstract_1.RepositoryAbstract {
                 verbose: data.options.verbose,
             })
             : undefined;
-        const stream = fast_glob_1.default.stream(include, {
-            cwd: sourcePath,
-            ignore: exclude,
-            dot: true,
-            onlyFiles: false,
-            markDirectories: true,
-            stats: true,
-        });
         const packs = compress?.packs || [];
         const tmpDir = await (0, fs_util_1.mkTmpDir)("path-lists");
-        const nonPackStream = (0, fs_1.createWriteStream)((0, path_1.join)(tmpDir, "nonpack.txt"));
+        const unpackedStream = (0, fs_1.createWriteStream)((0, path_1.join)(tmpDir, "unpacked.txt"));
         const singlePackStream = (0, fs_1.createWriteStream)((0, path_1.join)(tmpDir, "single-pack.txt"));
         const packStreams = Array.from({ length: packs.length }).map((v, i) => (0, fs_1.createWriteStream)((0, path_1.join)(tmpDir, `pack-${i}.txt`)));
-        let totalFiles = 0;
-        const streams = [nonPackStream, singlePackStream, ...packStreams];
+        const streams = [unpackedStream, singlePackStream, ...packStreams];
         if (data.options.verbose)
             (0, cli_util_1.logExec)(`Writing file lists in ${tmpDir}`);
-        await data.onProgress({
-            step: "Writing the file lists...",
+        const scanner = await this.createFileScanner({
+            glob: {
+                include,
+                cwd: sourcePath,
+                ignore: exclude,
+                onlyFiles: false,
+            },
+            onProgress: data.onProgress,
+            disableCounting: true,
         });
         await Promise.all([
             ...streams.map((p) => (0, fs_util_1.waitForClose)(p)),
             (async () => {
-                for await (const entry of (0, fs_util_1.pathIterator)(stream)) {
+                await scanner.start(async (entry) => {
                     const pathSubject = entry.stats.isDirectory()
                         ? entry.path.slice(0, -1)
                         : entry.path;
-                    let stream = nonPackStream;
+                    let stream = unpackedStream;
                     let successPackIndex;
                     for (const [packIndex, pack] of packs.entries()) {
                         if ((0, string_util_1.checkPath)(pathSubject, pack.include, pack.exclude)) {
@@ -237,60 +291,48 @@ class DatatruckRepository extends RepositoryAbstract_1.RepositoryAbstract {
                             break;
                         }
                     }
-                    const isNonPackStream = stream === nonPackStream;
-                    const isPackStream = stream !== nonPackStream;
+                    const isUnpackedStream = stream === unpackedStream;
+                    const isPackStream = stream !== unpackedStream;
                     const isSinglePackStream = stream === singlePackStream;
                     const include = isPackStream
                         ? entry.stats.isDirectory()
-                            ? await (0, fs_util_1.isEmptyDir)(entry.path)
+                            ? await (0, fs_util_1.isEmptyDir)((0, path_1.join)(sourcePath, entry.path))
                             : true
                         : true;
                     if (include) {
                         let value = entry.path;
-                        if (isNonPackStream) {
+                        if (isUnpackedStream) {
                             value += `:${entry.stats.uid}:${entry.stats.gid}:${entry.stats.mode}`;
                         }
                         else if (isSinglePackStream) {
                             value += `:${successPackIndex}`;
                         }
                         if (!entry.stats.isDirectory())
-                            totalFiles++;
+                            scanner.total++;
                         stream.write(`${value}\n`);
                     }
-                }
+                });
                 for (const stream of streams) {
                     stream.end();
                 }
             })(),
         ]);
-        let currentFiles = 0;
-        const dttFolder = `.dtt-${data.snapshot.id.slice(0, 8)}`;
-        const dttPath = (0, path_1.join)(outPath, dttFolder);
-        await (0, promises_1.mkdir)(dttPath);
+        const unpackedPath = (0, path_1.join)(outPath, "unpacked");
+        await (0, promises_1.mkdir)(unpackedPath);
+        await (0, promises_1.copyFile)(unpackedStream.path, (0, path_1.join)(outPath, "permissions.txt"));
         // Non pack
         if (data.options.verbose)
-            (0, cli_util_1.logExec)(`Copying files to ${outPath}`);
-        await (0, promises_1.copyFile)(nonPackStream.path, (0, path_1.join)(dttPath, "permissions.txt"));
+            (0, cli_util_1.logExec)(`Copying files from ${unpackedStream.path.toString()} to ${unpackedPath}`);
         await (0, fs_util_1.cpy)({
             input: {
                 type: "pathList",
-                path: nonPackStream.path.toString(),
+                path: unpackedStream.path.toString(),
                 basePath: sourcePath,
             },
-            targetPath: outPath,
+            targetPath: unpackedPath,
             skipNotFoundError: true,
             concurrency: this.config.fileCopyConcurrency,
-            async onPath({ isDir, entryPath }) {
-                if (isDir)
-                    return;
-                currentFiles++;
-                await data.onProgress({
-                    total: totalFiles,
-                    current: currentFiles,
-                    percent: (0, math_util_1.progressPercent)(totalFiles, currentFiles),
-                    step: entryPath,
-                });
-            },
+            onProgress: async (progress) => await scanner.progress(progress.type === "end" ? "Files copied" : "Copying file", progress),
         });
         // Single pack
         const singleReader = (0, readline_1.createInterface)({
@@ -304,48 +346,33 @@ class DatatruckRepository extends RepositoryAbstract_1.RepositoryAbstract {
             const outBasename = (`pack${pack.name ? `-${encodeURIComponent(pack.name)}` : ""}` +
                 `-${encodeURIComponent(packPath.replace(/[\\/]/g, "-"))}` +
                 `.zip`).slice(0, 255);
-            const target = (0, path_1.join)(dttPath, outBasename);
-            const stats = await (0, zip_util_1.zip)({
+            const target = (0, path_1.join)(outPath, outBasename);
+            await (0, zip_util_1.zip)({
                 path: pkg.path,
                 output: target,
                 filter: [{ patterns: [packPath] }],
                 verbose: data.options.verbose,
-                onStream: async (stream) => {
-                    if (stream.type === "progress")
-                        await data.onProgress({
-                            total: totalFiles,
-                            current: currentFiles + stream.data.files,
-                            percent: (0, math_util_1.progressPercent)(totalFiles, currentFiles + stream.data.files),
-                            step: stream.data.path,
-                            stepPercent: stream.data.progress,
-                        });
-                },
+                onProgress: async (progress) => await scanner.progress(progress.type === "start"
+                    ? "Starting compressing"
+                    : "Compressing file", progress),
             });
-            currentFiles += stats.files;
         }
         // Packs
         for (const [packIndex, packStream] of packStreams.entries()) {
             const pack = packs[packIndex];
-            const target = (0, path_1.join)(dttPath, `pack-${packIndex}${pack.name ? `-${pack.name}` : ""}.zip`);
-            const stats = await (0, zip_util_1.zip)({
+            const target = (0, path_1.join)(outPath, `pack-${packIndex}${pack.name ? `-${pack.name}` : ""}.zip`);
+            await (0, zip_util_1.zip)({
                 path: sourcePath,
                 output: target,
                 includeList: packStream.path.toString(),
                 verbose: data.options.verbose,
-                onStream: async (stream) => {
-                    if (stream.type === "progress")
-                        await data.onProgress({
-                            total: totalFiles,
-                            current: currentFiles + stream.data.files,
-                            percent: (0, math_util_1.progressPercent)(totalFiles, currentFiles + stream.data.files),
-                            step: stream.data.path,
-                        });
-                },
+                onProgress: async (progress) => await scanner.progress(progress.type === "start"
+                    ? "Starting compressing"
+                    : "Compressing file", progress),
             });
-            currentFiles += stats.files;
         }
         // Meta
-        const metaPath = `${outPath}.json`;
+        const metaPath = `${outPath}/meta.json`;
         const nodePkg = (0, fs_util_1.parsePackageFile)();
         const meta = {
             id: data.snapshot.id,
@@ -354,8 +381,7 @@ class DatatruckRepository extends RepositoryAbstract_1.RepositoryAbstract {
             package: data.package.name,
             task: data.package.task?.name,
             version: nodePkg.version,
-            size: (await (0, fs_util_1.fastFolderSizeAsync)(outPath)) -
-                (await (0, fs_util_1.fastFolderSizeAsync)(dttPath)),
+            size: await (0, fs_util_1.fastFolderSizeAsync)(outPath),
         };
         if (data.options.verbose)
             (0, cli_util_1.logExec)(`Writing metadata into ${metaPath}`);
@@ -369,19 +395,25 @@ class DatatruckRepository extends RepositoryAbstract_1.RepositoryAbstract {
         });
         const sourcePath = (0, path_1.resolve)((0, path_1.join)(this.config.outPath, snapshotName));
         const targetPath = (0, path_1.resolve)((0, path_1.join)(data.mirrorRepositoryConfig.outPath, snapshotName));
-        const sourceMetaPath = `${sourcePath}.json`;
-        const targetMetaPath = `${targetPath}.json`;
         if (data.options.verbose)
             (0, cli_util_1.logExec)(`Copying backup files to ${targetPath}`);
         await (0, promises_1.mkdir)(targetPath);
+        const scanner = await this.createFileScanner({
+            glob: {
+                include: ["**/*"],
+                cwd: sourcePath,
+            },
+            onProgress: data.onProgress,
+        });
+        await scanner.start();
         await (0, fs_util_1.cpy)({
             input: {
                 type: "glob",
                 sourcePath,
             },
             targetPath,
+            onProgress: async (progress) => await scanner.progress(progress.type === "end" ? "Files copied" : "Copying file", progress),
         });
-        await (0, promises_1.copyFile)(sourceMetaPath, targetMetaPath);
     }
     async onRestore(data) {
         const relRestorePath = data.targetPath ?? data.package.restorePath;
@@ -400,99 +432,71 @@ class DatatruckRepository extends RepositoryAbstract_1.RepositoryAbstract {
             packageName: data.package.name,
         });
         const sourcePath = (0, path_1.join)(this.config.outPath, snapshotName);
-        let totalFiles = 0;
-        let currentFiles = 0;
-        await data.onProgress({
-            step: "Counting files...",
+        const scanner = await this.createFileScanner({
+            glob: {
+                include: ["unpacked/**/*"],
+                cwd: sourcePath,
+            },
+            onProgress: data.onProgress,
+            disableEndProgress: true,
         });
-        const dttFolder = `.dtt-${data.snapshot.id.slice(0, 8)}`;
-        const dttPath = (0, path_1.join)(sourcePath, dttFolder);
-        const dttPathExists = await (0, fs_util_1.checkDir)(dttPath);
-        if (dttPathExists) {
-            const it = await (0, promises_1.opendir)(dttPath);
-            for await (const dirent of it) {
-                const path = (0, path_1.join)(dttPath, dirent.name);
-                if (dirent.name === "permissions.txt") {
-                    totalFiles++;
-                }
-                else if (dirent.name.endsWith(".zip")) {
-                    await (0, zip_util_1.listZip)({
-                        path,
-                        verbose: data.options.verbose,
-                        onStream: (item) => {
-                            const isDir = item.Folder === "+";
-                            if (!isDir)
-                                totalFiles++;
-                        },
-                    });
-                }
+        await scanner.start();
+        const it = await (0, promises_1.opendir)(sourcePath);
+        for await (const dirent of it) {
+            const path = (0, path_1.join)(sourcePath, dirent.name);
+            if (dirent.name === "permissions.txt") {
+                scanner.total++;
+                await scanner.updateProgress();
+            }
+            else if (dirent.name.endsWith(".zip")) {
+                await (0, zip_util_1.listZip)({
+                    path,
+                    verbose: data.options.verbose,
+                    onStream: async (item) => {
+                        const isDir = item.Folder === "+";
+                        if (!isDir)
+                            scanner.total++;
+                        await scanner.updateProgress();
+                    },
+                });
             }
         }
-        const allFiles = fast_glob_1.default.stream(["**"], {
-            cwd: sourcePath,
-            ignore: [dttFolder],
-            dot: true,
-            onlyFiles: true,
-        });
-        for await (const _file of allFiles) {
-            totalFiles++;
-        }
+        await scanner.updateProgress(true);
         if (data.options.verbose)
             (0, cli_util_1.logExec)(`Copying files to ${restorePath}`);
         await (0, fs_util_1.cpy)({
             input: {
                 type: "glob",
-                sourcePath,
-                exclude: [dttFolder],
+                sourcePath: (0, path_1.join)(sourcePath, "unpacked"),
             },
             targetPath: restorePath,
             concurrency: this.config.fileCopyConcurrency,
-            onPath: async ({ entryPath, isDir }) => {
-                if (!isDir) {
-                    currentFiles++;
-                    await data.onProgress({
-                        total: totalFiles,
-                        current: Math.max(currentFiles, 0),
-                        percent: (0, math_util_1.progressPercent)(totalFiles, Math.max(currentFiles, 0)),
-                        step: entryPath,
-                    });
-                }
-            },
+            onProgress: async (progress) => await scanner.progress(progress.type === "end" ? "Files copied" : "Copying file", progress),
         });
-        if (dttPathExists) {
-            const it = await (0, promises_1.opendir)(dttPath);
-            for await (const dirent of it) {
-                const path = (0, path_1.join)(dttPath, dirent.name);
-                if (dirent.name === "permissions.txt") {
-                    if (data.options.verbose)
-                        (0, cli_util_1.logExec)(`Applying permissions (${path})`);
-                    currentFiles++;
-                    await data.onProgress({
-                        total: totalFiles,
-                        current: currentFiles,
-                        percent: (0, math_util_1.progressPercent)(totalFiles, currentFiles),
-                        step: "Applying permissions",
-                    });
-                    await (0, fs_util_1.applyPermissions)(restorePath, path);
-                }
-                else if (dirent.name.endsWith(".zip")) {
-                    await (0, zip_util_1.unzip)({
-                        input: path,
-                        output: restorePath,
-                        verbose: data.options.verbose,
-                        onStream: async (stream) => {
-                            await data.onProgress({
-                                total: totalFiles,
-                                current: currentFiles + stream.data.files,
-                                percent: (0, math_util_1.progressPercent)(totalFiles, currentFiles + stream.data.files),
-                                step: stream.type === "progress"
-                                    ? `Extracting ${stream.data.path}`
-                                    : "",
-                                stepPercent: stream.data.progress,
-                            });
-                        },
-                    });
-                }
+        const it2 = await (0, promises_1.opendir)(sourcePath);
+        for await (const dirent of it2) {
+            const path = (0, path_1.join)(sourcePath, dirent.name);
+            if (dirent.name === "permissions.txt") {
+                if (data.options.verbose)
+                    (0, cli_util_1.logExec)(`Applying permissions (${path})`);
+                await scanner.progress("Applying permissions", {
+                    current: 0,
+                });
+                await (0, fs_util_1.applyPermissions)(restorePath, path);
+                await scanner.progress("Permissions applied", {
+                    current: 1,
+                    type: "end",
+                });
+            }
+            else if (dirent.name.endsWith(".zip")) {
+                await (0, zip_util_1.unzip)({
+                    input: path,
+                    output: restorePath,
+                    verbose: data.options.verbose,
+                    onProgress: async (progress) => await scanner.progress(progress.type === "start"
+                        ? "Starting extracting"
+                        : "Extracting file", progress),
+                });
             }
         }
     }

package/Repository/RepositoryAbstract.d.ts

@@ -4,6 +4,7 @@ import type { RestoreActionOptionsType } from "../Action/RestoreAction";
 import type { SnapshotExtendedType, SnapshotsActionOptionsType } from "../Action/SnapshotsAction";
 import type { PackageConfigType } from "../Config/PackageConfig";
 import type { RepositoryConfigType } from "../Config/RepositoryConfig";
+import { Progress } from "../util/progress";
 export declare type SnapshotType = {
     id: string;
     date: string;
@@ -15,13 +16,6 @@ export declare type SnapshotResultType = SnapshotType & {
     tags: string[];
     size: number;
 };
-export declare type ProgressDataType = {
-    total?: number;
-    current?: number;
-    percent?: number;
-    step?: string;
-    stepPercent?: number | null;
-};
 export declare type InitDataType = {
     options: InitActionOptionsType;
 };
@@ -33,7 +27,7 @@ export declare type CopyBackupType<TRepositoryConfig> = {
     snapshot: SnapshotType;
     package: PackageConfigType;
     mirrorRepositoryConfig: TRepositoryConfig;
-    onProgress: (data: ProgressDataType) => Promise<void>;
+    onProgress: (data: Progress) => Promise<void>;
 };
 export declare type BackupDataType<TPackageConfig> = {
     options: BackupActionOptionsType;
@@ -41,7 +35,7 @@ export declare type BackupDataType<TPackageConfig> = {
     package: PackageConfigType;
     targetPath: string | undefined;
     packageConfig: TPackageConfig | undefined;
-    onProgress: (data: ProgressDataType) => Promise<void>;
+    onProgress: (data: Progress) => Promise<void>;
 };
 export declare type RestoreDataType<TPackageConfig> = {
     options: RestoreActionOptionsType;
@@ -49,7 +43,7 @@ export declare type RestoreDataType<TPackageConfig> = {
     package: PackageConfigType;
     targetPath: string | undefined;
     packageConfig: TPackageConfig;
-    onProgress: (data: ProgressDataType) => Promise<void>;
+    onProgress: (data: Progress) => Promise<void>;
 };
 export declare type PruneDataType = {
     snapshot: SnapshotExtendedType;

package/Repository/ResticRepository.js

@@ -195,7 +195,9 @@ class ResticRepository extends RepositoryAbstract_1.RepositoryAbstract {
                 verbose: data.options.verbose,
             });
             await data.onProgress({
-                step: "Writing excluded paths list...",
+                relative: {
+                    description: "Writing excluded paths list",
+                },
             });
             const tmpDir = await (0, fs_util_1.mkTmpDir)("restic-exclude");
             const ignoredContents = (0, fs_util_1.fastglobToGitIgnore)(exclude, sourcePath).join("\n");
@@ -223,7 +225,9 @@ class ResticRepository extends RepositoryAbstract_1.RepositoryAbstract {
             if (data.options.verbose)
                 (0, cli_util_1.logExec)(`Writing paths lists`);
             await data.onProgress({
-                step: "Writing excluded paths list...",
+                relative: {
+                    description: "Writing excluded paths list",
+                },
             });
             gitignorePath = await (0, fs_util_1.writeGitIgnoreList)({
                 paths: stream,
@@ -233,7 +237,9 @@ class ResticRepository extends RepositoryAbstract_1.RepositoryAbstract {
             throw new AppError_1.AppError(`Tag prefix is not allowed`);
         const packageTag = ResticRepository.buildSnapshotTag(RepositoryAbstract_1.SnapshotTagEnum.PACKAGE, data.package.name);
         await data.onProgress({
-            step: "Fetching last snapshot...",
+            relative: {
+                description: "Fetching last snapshot",
+            },
         });
         const [lastSnapshot] = await restic.snapshots({
             json: true,
@@ -245,7 +251,9 @@ class ResticRepository extends RepositoryAbstract_1.RepositoryAbstract {
         let totalFilesChanges = 0;
         const totalFilesChangesLimit = 10;
         await data.onProgress({
-            step: "Executing backup action...",
+            relative: {
+                description: "Executing backup action",
+            },
         });
         let resticSnapshotId;
         let resticTotalBytes;
@@ -278,19 +286,24 @@ class ResticRepository extends RepositoryAbstract_1.RepositoryAbstract {
                     if (totalFilesChanges > totalFilesChangesLimit) {
                         showProgressBar = true;
                     }
-                    else if (lastProgress?.total !== streamData.total_files) {
+                    else if (lastProgress?.absolute?.total !== streamData.total_files) {
                         totalFilesChanges = 0;
                     }
                     else {
                         totalFilesChanges++;
                     }
                     await data.onProgress((lastProgress = {
-                        total: Math.max(lastProgress?.total || 0, streamData.total_files || 0),
-                        current: Math.max(lastProgress?.current || 0, streamData.files_done ?? 0),
-                        percent: showProgressBar
-                            ? Number((streamData.percent_done * 100).toFixed(2))
-                            : 0,
-                        step: streamData.current_files?.join(", ") ?? "-",
+                        relative: {
+                            description: "Copying file",
+                            payload: streamData.current_files?.join(", ") ?? "-",
+                        },
+                        absolute: {
+                            total: Math.max(lastProgress?.absolute?.total || 0, streamData.total_files || 0),
+                            current: Math.max(lastProgress?.absolute?.current || 0, streamData.files_done ?? 0),
+                            percent: showProgressBar
+                                ? Number((streamData.percent_done * 100).toFixed(2))
+                                : 0,
+                        },
                     }));
                 }
                 else if (streamData.message_type === "summary") {
@@ -306,9 +319,11 @@ class ResticRepository extends RepositoryAbstract_1.RepositoryAbstract {
         const sizeTag = ResticRepository.buildSnapshotTag(RepositoryAbstract_1.SnapshotTagEnum.SIZE, resticTotalBytes.toString());
         await restic.exec(["tag", "--add", sizeTag, resticSnapshotId]);
         await data.onProgress({
-            total: lastProgress?.total || 0,
-            current: lastProgress?.total || 0,
-            percent: 100,
+            absolute: {
+                total: lastProgress?.absolute?.total || 0,
+                current: lastProgress?.absolute?.total || 0,
+                percent: 100,
+            },
         });
     }
     async onCopyBackup(data) {
@@ -357,9 +372,11 @@ class ResticRepository extends RepositoryAbstract_1.RepositoryAbstract {
                 if (streamData.message_type === "restore-status") {
                     const current = Math.min(streamData.total_bytes, snapshot.size);
                     await data.onProgress({
-                        total: snapshot.size,
-                        current,
-                        percent: (0, math_util_1.progressPercent)(snapshot.size, current),
+                        absolute: {
+                            total: snapshot.size,
+                            current,
+                            percent: (0, math_util_1.progressPercent)(snapshot.size, current),
+                        },
                     });
                 }
             },

package/SessionDriver/ConsoleSessionDriver.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+import { Progress } from "../util/progress";
 import { WriteDataType, ReadResultType, SessionDriverAbstract, SessionDriverOptions } from "./SessionDriverAbstract";
 declare type BadgeType = {
     name: string;
@@ -12,20 +13,14 @@ declare type MessageType = {
     text?: string;
     badges: BadgeType[];
     errorBadge?: BadgeType;
-    progressCurrent?: number | null;
-    progressTotal?: number | null;
-    progressPercent?: number | null;
-    progressStep?: string | null;
-    progressStepPercent?: number | null;
+    progress?: Progress;
 };
 declare type ConsoleSessionDriverOptions = SessionDriverOptions & {
     progress?: "auto" | "tty" | "plain";
-    progressInterval?: number;
 };
 export declare class ConsoleSessionDriver extends SessionDriverAbstract<ConsoleSessionDriverOptions> {
     protected lastMessage: MessageType | undefined;
     protected lastMessageText: string | undefined;
-    protected lastProgressDate: number | undefined;
     protected prints: number;
     protected renderInterval: NodeJS.Timeout;
     protected rendering?: boolean;