@datatruck/cli 0.12.1 → 0.14.0

package/Repository/{LocalRepository.js → DatatruckRepository.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.LocalRepository = exports.localPackageRepositoryDefinition = exports.localRepositoryDefinition = exports.localRepositoryName = void 0;
+exports.DatatruckRepository = exports.datatruckPackageRepositoryDefinition = exports.datatruckRepositoryDefinition = exports.datatruckRepositoryName = void 0;
 const AppError_1 = require("../Error/AppError");
 const DefinitionEnum_1 = require("../JsonSchema/DefinitionEnum");
 const cli_util_1 = require("../util/cli-util");
@@ -20,8 +20,8 @@ const promises_1 = require("fs/promises");
 const micromatch_1 = require("micromatch");
 const path_1 = require("path");
 const readline_1 = require("readline");
-exports.localRepositoryName = "local";
-exports.localRepositoryDefinition = {
+exports.datatruckRepositoryName = "datatruck";
+exports.datatruckRepositoryDefinition = {
     type: "object",
     required: ["outPath"],
     additionalProperties: false,
@@ -30,7 +30,7 @@ exports.localRepositoryDefinition = {
         compress: { type: "boolean" },
     },
 };
-exports.localPackageRepositoryDefinition = {
+exports.datatruckPackageRepositoryDefinition = {
     type: "object",
     additionalProperties: false,
     properties: {
@@ -50,6 +50,7 @@ exports.localPackageRepositoryDefinition = {
                                 additionalProperties: false,
                                 required: ["include"],
                                 properties: {
+                                    name: { type: "string" },
                                     include: (0, DefinitionEnum_1.makeRef)(DefinitionEnum_1.DefinitionEnum.stringListUtil),
                                     exclude: (0, DefinitionEnum_1.makeRef)(DefinitionEnum_1.DefinitionEnum.stringListUtil),
                                     onePackByResult: { type: "boolean" },
@@ -66,7 +67,7 @@ exports.localPackageRepositoryDefinition = {
         },
     },
 };
-class LocalRepository extends RepositoryAbstract_1.RepositoryAbstract {
+class DatatruckRepository extends RepositoryAbstract_1.RepositoryAbstract {
     static buildSnapshotName(data) {
         const date = data.snapshotDate.replace(/:/g, "-");
         const pkgName = encodeURIComponent(data.packageName).replace(/%40/g, "@");
@@ -103,7 +104,7 @@ class LocalRepository extends RepositoryAbstract_1.RepositoryAbstract {
         await (0, fs_util_1.mkdirIfNotExists)(this.config.outPath);
     }
     async onPrune(data) {
-        const snapshotName = LocalRepository.buildSnapshotName({
+        const snapshotName = DatatruckRepository.buildSnapshotName({
             snapshotId: data.snapshot.id,
             snapshotDate: data.snapshot.date,
             packageName: data.snapshot.packageName,
@@ -127,7 +128,7 @@ class LocalRepository extends RepositoryAbstract_1.RepositoryAbstract {
         const packagePatterns = (0, string_util_1.makePathPatterns)(data.options.packageNames);
         const taskPatterns = (0, string_util_1.makePathPatterns)(data.options.packageTaskNames);
         for (const snapshotName of snapshotNames) {
-            const snapshotNameData = LocalRepository.parseSnapshotName(snapshotName);
+            const snapshotNameData = DatatruckRepository.parseSnapshotName(snapshotName);
             if (!snapshotNameData)
                 continue;
             if (packagePatterns &&
@@ -137,7 +138,7 @@ class LocalRepository extends RepositoryAbstract_1.RepositoryAbstract {
                 !data.options.ids.some((id) => snapshotNameData.snapshotShortId.startsWith(id.slice(0, 8))))
                 continue;
             const metaPath = (0, path_1.join)(this.config.outPath, snapshotName);
-            const meta = await LocalRepository.parseMetaData(metaPath);
+            const meta = await DatatruckRepository.parseMetaData(metaPath);
             if (taskPatterns && !(0, string_util_1.checkMatch)(meta.task, taskPatterns))
                 continue;
             if (data.options.ids &&
@@ -153,13 +154,14 @@ class LocalRepository extends RepositoryAbstract_1.RepositoryAbstract {
                 packageName: meta.package,
                 packageTaskName: meta.task,
                 tags: meta.tags,
+                size: meta.size || 0,
             });
         }
         return snapshots;
     }
     normalizeCompressConfig(packageConfig) {
         let compress = packageConfig?.compress ?? this.config.compress;
-        if (compress === true) {
+        if (compress === true || (compress && !Array.isArray(compress.packs))) {
             return {
                 packs: [
                     {
@@ -174,7 +176,7 @@ class LocalRepository extends RepositoryAbstract_1.RepositoryAbstract {
         return compress;
     }
     async onBackup(data) {
-        const snapshotName = LocalRepository.buildSnapshotName({
+        const snapshotName = DatatruckRepository.buildSnapshotName({
             snapshotId: data.snapshot.id,
             snapshotDate: data.snapshot.date,
             packageName: data.package.name,
@@ -201,90 +203,148 @@ class LocalRepository extends RepositoryAbstract_1.RepositoryAbstract {
             cwd: sourcePath,
             ignore: exclude,
             dot: true,
-            onlyFiles: compress ? false : 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 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];
         if (data.options.verbose)
-            (0, cli_util_1.logExec)(`Writing paths lists`);
-        const pathLists = await (0, fs_util_1.writePathLists)({
-            paths: stream,
-            packs: compress?.packs,
+            (0, cli_util_1.logExec)(`Writing file lists in ${tmpDir}`);
+        await data.onProgress({
+            step: "Writing the file lists...",
         });
-        if (data.options.verbose)
-            (0, cli_util_1.logExec)(`Path lists: ${pathLists.path}`);
-        let currentFiles = 0;
-        if (compress?.packs) {
-            let packIndex = 0;
-            for (const packsPath of pathLists.includedPackPaths) {
-                const pack = compress.packs[packIndex];
-                if (pack.onePackByResult) {
-                    const reader = (0, readline_1.createInterface)({
-                        input: (0, fs_1.createReadStream)(packsPath),
-                    });
-                    let multipleIndex = 0;
-                    for await (let packPath of reader) {
-                        if (packPath.endsWith("/"))
-                            packPath = packPath.slice(0, -1);
-                        const target = (0, path_1.join)(outPath, `.${packIndex}-${multipleIndex++}-${encodeURIComponent(packPath.replace(/[\\/]/g, "-")).slice(0, 255)}.dd.zip`);
-                        const stats = await (0, zip_util_1.zip)({
-                            path: pkg.path,
-                            output: target,
-                            filter: [{ patterns: [packPath] }],
-                            excludeList: pathLists.excludedPackPaths[packIndex],
-                            verbose: data.options.verbose,
-                            onStream: async (stream) => await data.onProgress({
-                                total: pathLists.total.all,
-                                current: currentFiles + stream.data.files,
-                                percent: (0, math_util_1.progressPercent)(pathLists.total.all, currentFiles + stream.data.files),
-                                step: stream.type === "progress" ? stream.data.path : "",
-                                stepPercent: stream.type === "progress" ? stream.data.progress : null,
-                            }),
-                        });
-                        currentFiles += stats.files;
+        await Promise.all([
+            ...streams.map((p) => (0, fs_util_1.waitForClose)(p)),
+            (async () => {
+                for await (const entry of (0, fs_util_1.pathIterator)(stream)) {
+                    const pathSubject = entry.stats.isDirectory()
+                        ? entry.path.slice(0, -1)
+                        : entry.path;
+                    let stream = nonPackStream;
+                    let successPackIndex;
+                    for (const [packIndex, pack] of packs.entries()) {
+                        if ((0, string_util_1.checkPath)(pathSubject, pack.include, pack.exclude)) {
+                            stream = pack.onePackByResult
+                                ? singlePackStream
+                                : packStreams[packIndex];
+                            successPackIndex = packIndex;
+                            break;
+                        }
+                    }
+                    const isNonPackStream = stream === nonPackStream;
+                    const isPackStream = stream !== nonPackStream;
+                    const isSinglePackStream = stream === singlePackStream;
+                    const include = isPackStream
+                        ? entry.stats.isDirectory()
+                            ? await (0, fs_util_1.isEmptyDir)(entry.path)
+                            : true
+                        : true;
+                    if (include) {
+                        let value = entry.path;
+                        if (isNonPackStream) {
+                            value += `:${entry.stats.uid}:${entry.stats.gid}:${entry.stats.mode}`;
+                        }
+                        else if (isSinglePackStream) {
+                            value += `:${successPackIndex}`;
+                        }
+                        if (!entry.stats.isDirectory())
+                            totalFiles++;
+                        stream.write(`${value}\n`);
                     }
                 }
-                else {
-                    const target = (0, path_1.join)(outPath, `.${packIndex}.dd.zip`);
-                    const stats = await (0, zip_util_1.zip)({
-                        path: sourcePath,
-                        output: target,
-                        includeList: packsPath,
-                        excludeList: pathLists.excludedPackPaths[packIndex],
-                        verbose: data.options.verbose,
-                        onStream: async (stream) => await data.onProgress({
-                            total: pathLists.total.all,
-                            current: currentFiles + stream.data.files,
-                            percent: (0, math_util_1.progressPercent)(pathLists.total.all, currentFiles + stream.data.files),
-                            step: stream.type === "progress" ? stream.data.path : "",
-                        }),
-                    });
-                    currentFiles += stats.files;
+                for (const stream of streams) {
+                    stream.end();
                 }
-                packIndex++;
-            }
-        }
+            })(),
+        ]);
+        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);
+        // 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"));
         await (0, fs_util_1.cpy)({
             input: {
                 type: "pathList",
-                path: pathLists.path,
+                path: nonPackStream.path.toString(),
                 basePath: sourcePath,
             },
             targetPath: outPath,
+            skipNotFoundError: true,
             concurrency: this.config.fileCopyConcurrency,
             async onPath({ isDir, entryPath }) {
                 if (isDir)
                     return;
                 currentFiles++;
                 await data.onProgress({
-                    total: pathLists.total.all,
+                    total: totalFiles,
                     current: currentFiles,
-                    percent: (0, math_util_1.progressPercent)(pathLists.total.all, currentFiles),
+                    percent: (0, math_util_1.progressPercent)(totalFiles, currentFiles),
                     step: entryPath,
                 });
             },
         });
+        // Single pack
+        const singleReader = (0, readline_1.createInterface)({
+            input: (0, fs_1.createReadStream)(singlePackStream.path),
+        });
+        for await (const line of singleReader) {
+            let [packPath, packIndex] = line.split(":");
+            const pack = packs[packIndex];
+            if (packPath.endsWith("/"))
+                packPath = packPath.slice(0, -1);
+            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)({
+                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,
+                        });
+                },
+            });
+            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)({
+                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,
+                        });
+                },
+            });
+            currentFiles += stats.files;
+        }
+        // Meta
         const metaPath = `${outPath}.json`;
         const nodePkg = (0, fs_util_1.parsePackageFile)();
         const meta = {
@@ -294,13 +354,15 @@ class LocalRepository 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)),
         };
         if (data.options.verbose)
             (0, cli_util_1.logExec)(`Writing metadata into ${metaPath}`);
-        await (0, promises_1.writeFile)(metaPath, LocalRepository.stringifyMetaData(meta));
+        await (0, promises_1.writeFile)(metaPath, DatatruckRepository.stringifyMetaData(meta));
     }
     async onCopyBackup(data) {
-        const snapshotName = LocalRepository.buildSnapshotName({
+        const snapshotName = DatatruckRepository.buildSnapshotName({
             snapshotId: data.snapshot.id,
             snapshotDate: data.snapshot.date,
             packageName: data.package.name,
@@ -310,7 +372,7 @@ class LocalRepository extends RepositoryAbstract_1.RepositoryAbstract {
         const sourceMetaPath = `${sourcePath}.json`;
         const targetMetaPath = `${targetPath}.json`;
         if (data.options.verbose)
-            (0, cli_util_1.logExec)(`Copying files to ${targetPath}`);
+            (0, cli_util_1.logExec)(`Copying backup files to ${targetPath}`);
         await (0, promises_1.mkdir)(targetPath);
         await (0, fs_util_1.cpy)({
             input: {
@@ -332,57 +394,108 @@ class LocalRepository extends RepositoryAbstract_1.RepositoryAbstract {
         });
         if (!snapshot)
             throw new AppError_1.AppError("Snapshot not found");
-        const snapshotName = LocalRepository.buildSnapshotName({
+        const snapshotName = DatatruckRepository.buildSnapshotName({
             snapshotId: data.snapshot.id,
             snapshotDate: data.snapshot.date,
             packageName: data.package.name,
         });
         const sourcePath = (0, path_1.join)(this.config.outPath, snapshotName);
         let totalFiles = 0;
-        let currentFiles = -1;
-        await (0, fs_util_1.forEachFile)(sourcePath, () => {
+        let currentFiles = 0;
+        await data.onProgress({
+            step: "Counting files...",
+        });
+        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++;
+                        },
+                    });
+                }
+            }
+        }
+        const allFiles = fast_glob_1.default.stream(["**"], {
+            cwd: sourcePath,
+            ignore: [dttFolder],
+            dot: true,
+            onlyFiles: true,
+        });
+        for await (const _file of allFiles) {
             totalFiles++;
-        }, 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],
             },
             targetPath: restorePath,
             concurrency: this.config.fileCopyConcurrency,
-            onPath: async ({ entryPath, entrySourcePath }) => {
-                const isRootFile = (0, path_1.basename)(entryPath) === entryPath;
-                const isZipFile = isRootFile &&
-                    entryPath.startsWith(".") &&
-                    entryPath.endsWith(".dd.zip");
-                await data.onProgress({
-                    total: totalFiles,
-                    current: Math.max(currentFiles, 0),
-                    percent: (0, math_util_1.progressPercent)(totalFiles, Math.max(currentFiles, 0)),
-                    step: entryPath,
-                });
-                if (isZipFile) {
+            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,
+                    });
+                }
+            },
+        });
+        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: entrySourcePath,
+                        input: path,
                         output: restorePath,
                         verbose: data.options.verbose,
-                        onStream: async (stream) => await data.onProgress({
-                            total: totalFiles,
-                            current: currentFiles + 1,
-                            percent: (0, math_util_1.progressPercent)(totalFiles, currentFiles + 1),
-                            step: stream.type === "progress"
-                                ? `Extracting ${stream.data.path}`
-                                : "",
-                        }),
+                        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,
+                            });
+                        },
                     });
                 }
-                currentFiles++;
-                return isZipFile ? false : true;
-            },
-        });
+            }
+        }
     }
 }
-exports.LocalRepository = LocalRepository;
-LocalRepository.zipBasenameTpl = `.*.dd.zip`;
+exports.DatatruckRepository = DatatruckRepository;
+DatatruckRepository.zipBasenameTpl = `.*.dd.zip`;

package/Repository/GitRepository.js

@@ -136,6 +136,7 @@ class GitRepository extends RepositoryAbstract_1.RepositoryAbstract {
                 packageName: parsedTag.package,
                 packageTaskName: parsedTag.task,
                 tags: parsedTag.tags,
+                size: Number(parsedTag.size) || 0,
             });
             return result;
         }, [])
@@ -207,6 +208,8 @@ class GitRepository extends RepositoryAbstract_1.RepositoryAbstract {
             package: data.package.name,
             task: data.package.task?.name,
             version: nodePkg.version,
+            size: ((await (0, fs_util_1.fastFolderSizeAsync)(tmpPath)) -
+                (await (0, fs_util_1.fastFolderSizeAsync)((0, path_1.join)(tmpPath, ".git")))).toString(),
         });
         await git.addTag(meta.name, meta.message);
         await git.push({ branchName });

package/Repository/RepositoryAbstract.d.ts

@@ -13,6 +13,7 @@ export declare type SnapshotResultType = SnapshotType & {
     packageName: string;
     packageTaskName: string | undefined;
     tags: string[];
+    size: number;
 };
 export declare type ProgressDataType = {
     total?: number;
@@ -63,7 +64,8 @@ export declare enum SnapshotTagEnum {
     PACKAGE = "package",
     TASK = "task",
     TAGS = "tags",
-    VERSION = "version"
+    VERSION = "version",
+    SIZE = "size"
 }
 export declare type SnapshotTagObjectType = {
     [SnapshotTagEnum.ID]: string;
@@ -73,6 +75,7 @@ export declare type SnapshotTagObjectType = {
     [SnapshotTagEnum.TASK]: string | undefined;
     [SnapshotTagEnum.TAGS]: string[];
     [SnapshotTagEnum.VERSION]: string;
+    [SnapshotTagEnum.SIZE]: string;
 };
 export declare abstract class RepositoryAbstract<TConfig> {
     readonly repository: RepositoryConfigType;

package/Repository/RepositoryAbstract.js

@@ -10,6 +10,7 @@ var SnapshotTagEnum;
     SnapshotTagEnum["TASK"] = "task";
     SnapshotTagEnum["TAGS"] = "tags";
     SnapshotTagEnum["VERSION"] = "version";
+    SnapshotTagEnum["SIZE"] = "size";
 })(SnapshotTagEnum = exports.SnapshotTagEnum || (exports.SnapshotTagEnum = {}));
 class RepositoryAbstract {
     constructor(repository) {

package/Repository/ResticRepository.js

@@ -9,6 +9,7 @@ const ResticUtil_1 = require("../util/ResticUtil");
 const cli_util_1 = require("../util/cli-util");
 const paths_util_1 = require("../util/datatruck/paths-util");
 const fs_util_1 = require("../util/fs-util");
+const math_util_1 = require("../util/math-util");
 const string_util_1 = require("../util/string-util");
 const RepositoryAbstract_1 = require("./RepositoryAbstract");
 const assert_1 = require("assert");
@@ -164,6 +165,7 @@ class ResticRepository extends RepositoryAbstract_1.RepositoryAbstract {
                 date: tag.date,
                 id: tag.id,
                 tags: itemTags,
+                size: Number(tag.size) || 0,
             });
             return items;
         }, []);
@@ -245,6 +247,8 @@ class ResticRepository extends RepositoryAbstract_1.RepositoryAbstract {
         await data.onProgress({
             step: "Executing backup action...",
         });
+        let resticSnapshotId;
+        let resticTotalBytes;
         await restic.backup({
             cwd: sourcePath,
             paths: ["."],
@@ -281,7 +285,7 @@ class ResticRepository extends RepositoryAbstract_1.RepositoryAbstract {
                         totalFilesChanges++;
                     }
                     await data.onProgress((lastProgress = {
-                        total: Math.max(lastProgress?.total || 0, streamData.total_files),
+                        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))
@@ -289,8 +293,18 @@ class ResticRepository extends RepositoryAbstract_1.RepositoryAbstract {
                         step: streamData.current_files?.join(", ") ?? "-",
                     }));
                 }
+                else if (streamData.message_type === "summary") {
+                    resticSnapshotId = streamData.snapshot_id;
+                    resticTotalBytes = streamData.total_bytes_processed;
+                }
             },
         });
+        if (typeof resticSnapshotId !== "string")
+            throw new AppError_1.AppError(`Restic snapshot id is is not defined`);
+        if (typeof resticTotalBytes !== "number")
+            throw new AppError_1.AppError(`Restic snapshot total bytes is not defined`);
+        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,
@@ -339,6 +353,16 @@ class ResticRepository extends RepositoryAbstract_1.RepositoryAbstract {
         await restic.restore({
             id: snapshot.originalId,
             target: restorePath,
+            onStream: async (streamData) => {
+                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),
+                    });
+                }
+            },
         });
     }
 }

package/SessionDriver/ConsoleSessionDriver.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { WriteDataType, ReadResultType, SessionDriverAbstract } from "./SessionDriverAbstract";
+import { WriteDataType, ReadResultType, SessionDriverAbstract, SessionDriverOptions } from "./SessionDriverAbstract";
 declare type BadgeType = {
     name: string;
     value: string;
@@ -18,9 +18,14 @@ declare type MessageType = {
     progressStep?: string | null;
     progressStepPercent?: number | null;
 };
-export declare class ConsoleSessionDriver extends SessionDriverAbstract {
+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;
@@ -30,6 +35,7 @@ export declare class ConsoleSessionDriver extends SessionDriverAbstract {
         start: () => number;
         elapsed: (formatted?: boolean | undefined) => string | number;
     };
+    protected tty: boolean;
     onInit(): Promise<void>;
     onEnd(data?: Record<string, any>): Promise<void>;
     onRead(): Promise<ReadResultType[]>;