@datatruck/cli 0.17.2 → 0.19.0

package/Repository/DatatruckRepository.js

@@ -1,7 +1,4 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DatatruckRepository = exports.datatruckPackageRepositoryDefinition = exports.datatruckRepositoryDefinition = exports.datatruckRepositoryName = void 0;
 const AppError_1 = require("../Error/AppError");
@@ -9,18 +6,13 @@ const DefinitionEnum_1 = require("../JsonSchema/DefinitionEnum");
 const cli_1 = require("../utils/cli");
 const paths_1 = require("../utils/datatruck/paths");
 const fs_1 = require("../utils/fs");
-const math_1 = require("../utils/math");
 const string_1 = require("../utils/string");
-const zip_1 = require("../utils/zip");
+const tar_1 = require("../utils/tar");
 const RepositoryAbstract_1 = require("./RepositoryAbstract");
 const assert_1 = require("assert");
-const fast_glob_1 = __importDefault(require("fast-glob"));
-const fs_2 = 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 = {
     type: "object",
@@ -36,39 +28,26 @@ exports.datatruckPackageRepositoryDefinition = {
     additionalProperties: false,
     properties: {
         compress: {
-            anyOf: [
-                {
-                    type: "boolean",
-                },
-                {
-                    type: "object",
-                    additionalProperties: false,
-                    properties: {
-                        packs: {
-                            type: "array",
-                            items: {
-                                type: "object",
-                                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" },
-                                },
-                            },
-                        },
-                    },
-                },
-            ],
+            type: "boolean",
         },
-        fileCopyConcurrency: {
-            type: "integer",
-            minimum: 1,
+        packs: {
+            type: "array",
+            items: {
+                type: "object",
+                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" },
+                },
+            },
         },
     },
 };
 class DatatruckRepository extends RepositoryAbstract_1.RepositoryAbstract {
+    static zipBasenameTpl = `.*.dd.tar.gz`;
     static buildSnapshotName(data) {
         const date = data.snapshotDate.replace(/:/g, "-");
         const pkgName = encodeURIComponent(data.packageName).replace(/%40/g, "@");
@@ -110,66 +89,6 @@ class DatatruckRepository extends RepositoryAbstract_1.RepositoryAbstract {
     async onInit(data) {
         await (0, fs_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_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_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,
@@ -225,22 +144,6 @@ class DatatruckRepository extends RepositoryAbstract_1.RepositoryAbstract {
         }
         return snapshots;
     }
-    normalizeCompressConfig(packageConfig) {
-        let compress = packageConfig?.compress ?? this.config.compress;
-        if (compress === true || (compress && !Array.isArray(compress.packs))) {
-            return {
-                packs: [
-                    {
-                        include: ["**"],
-                    },
-                ],
-            };
-        }
-        else if (!compress) {
-            return undefined;
-        }
-        return compress;
-    }
     async onBackup(data) {
         const snapshotName = DatatruckRepository.buildSnapshotName({
             snapshotId: data.snapshot.id,
@@ -249,134 +152,74 @@ class DatatruckRepository extends RepositoryAbstract_1.RepositoryAbstract {
         });
         const outPath = (0, path_1.resolve)((0, path_1.join)(this.config.outPath, snapshotName));
         const pkg = data.package;
-        await (0, promises_1.mkdir)(outPath, {
-            recursive: true,
-        });
         const sourcePath = data.targetPath ?? pkg.path;
         (0, assert_1.ok)(sourcePath);
-        const compress = this.normalizeCompressConfig(data.packageConfig);
-        const include = await (0, paths_1.parsePaths)(pkg.include ?? ["**"], {
-            cwd: sourcePath,
-            verbose: data.options.verbose,
-        });
-        const exclude = pkg.exclude
-            ? await (0, paths_1.parsePaths)(pkg.exclude, {
-                cwd: sourcePath,
-                verbose: data.options.verbose,
-            })
-            : undefined;
-        const packs = compress?.packs || [];
-        const tmpDir = await this.mkTmpDir("path-lists");
-        const unpackedStream = (0, fs_2.createWriteStream)((0, path_1.join)(tmpDir, "unpacked.txt"));
-        const singlePackStream = (0, fs_2.createWriteStream)((0, path_1.join)(tmpDir, "single-pack.txt"));
-        const packStreams = Array.from({ length: packs.length }).map((v, i) => (0, fs_2.createWriteStream)((0, path_1.join)(tmpDir, `pack-${i}.txt`)));
-        const streams = [unpackedStream, singlePackStream, ...packStreams];
-        if (data.options.verbose)
-            (0, cli_1.logExec)(`Writing file lists in ${tmpDir}`);
-        const scanner = await this.createFileScanner({
+        await (0, promises_1.mkdir)(outPath, { recursive: true });
+        const scanner = await (0, fs_1.createFileScanner)({
+            onProgress: data.onProgress,
             glob: {
-                include,
                 cwd: sourcePath,
-                ignore: exclude,
                 onlyFiles: false,
+                include: await (0, paths_1.parsePaths)(pkg.include ?? ["**"], {
+                    cwd: sourcePath,
+                    verbose: data.options.verbose,
+                }),
+                ignore: pkg.exclude
+                    ? await (0, paths_1.parsePaths)(pkg.exclude, {
+                        cwd: sourcePath,
+                        verbose: data.options.verbose,
+                    })
+                    : undefined,
             },
-            onProgress: data.onProgress,
-            disableCounting: true,
         });
-        await Promise.all([
-            ...streams.map((p) => (0, fs_1.waitForClose)(p)),
-            (async () => {
-                await scanner.start(async (entry) => {
-                    const pathSubject = entry.stats.isDirectory()
-                        ? entry.path.slice(0, -1)
-                        : entry.path;
-                    let stream = unpackedStream;
-                    let successPackIndex;
-                    for (const [packIndex, pack] of packs.entries()) {
-                        if ((0, string_1.checkPath)(pathSubject, pack.include, pack.exclude)) {
-                            stream = pack.onePackByResult
-                                ? singlePackStream
-                                : packStreams[packIndex];
-                            successPackIndex = packIndex;
-                            break;
-                        }
-                    }
-                    const isUnpackedStream = stream === unpackedStream;
-                    const isPackStream = stream !== unpackedStream;
-                    const isSinglePackStream = stream === singlePackStream;
-                    const include = isPackStream
-                        ? entry.stats.isDirectory()
-                            ? await (0, fs_1.isEmptyDir)((0, path_1.join)(sourcePath, entry.path))
-                            : true
-                        : true;
-                    if (include) {
-                        let value = entry.path;
-                        if (isUnpackedStream) {
-                            value += `:${entry.stats.uid}:${entry.stats.gid}:${entry.stats.mode}`;
-                        }
-                        else if (isSinglePackStream) {
-                            value += `:${successPackIndex}`;
-                        }
-                        if (!entry.stats.isDirectory())
-                            scanner.total++;
-                        stream.write(`${value}\n`);
-                    }
+        const configPacks = (data.packageConfig?.packs ?? []).map((p) => ({
+            ...p,
+            compress: p.compress ?? data.packageConfig?.compress ?? this.config.compress,
+            includeResult: [],
+        }));
+        const defaultsPack = {
+            name: "defaults",
+            compress: data.packageConfig?.compress ?? this.config.compress,
+            include: [],
+            includeResult: [],
+        };
+        const packs = [...configPacks, defaultsPack];
+        await scanner.start(async (entry) => {
+            if (entry.dirent.isDirectory() &&
+                !(await (0, fs_1.isEmptyDir)((0, path_1.join)(sourcePath, entry.path))))
+                return false;
+            const pack = configPacks.find((pack) => (0, string_1.checkPath)(entry.path, pack.include, pack.exclude)) || defaultsPack;
+            if (pack.onePackByResult) {
+                const subname = (0, path_1.basename)(entry.path);
+                packs.push({
+                    ...pack,
+                    name: pack.name ? `${pack.name}-${subname}` : subname,
+                    includeResult: [entry.path],
                 });
-                for (const stream of streams) {
-                    stream.end();
-                }
-            })(),
-        ]);
-        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_1.logExec)(`Copying files from ${unpackedStream.path.toString()} to ${unpackedPath}`);
-        await (0, fs_1.cpy)({
-            input: {
-                type: "pathList",
-                path: unpackedStream.path.toString(),
-                basePath: sourcePath,
-            },
-            targetPath: unpackedPath,
-            skipNotFoundError: true,
-            concurrency: this.config.fileCopyConcurrency,
-            onProgress: async (progress) => await scanner.progress(progress.type === "end" ? "Files copied" : "Copying file", progress),
-        });
-        // Single pack
-        const singleReader = (0, readline_1.createInterface)({
-            input: (0, fs_2.createReadStream)(singlePackStream.path),
+            }
+            else {
+                pack.includeResult.push(entry.path);
+            }
+            return true;
         });
-        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)(outPath, outBasename);
-            await (0, zip_1.zip)({
-                path: pkg.path,
-                output: target,
-                filter: [{ patterns: [packPath] }],
-                verbose: data.options.verbose,
-                onProgress: async (progress) => await scanner.progress("Compressing file", progress),
-            });
-        }
-        // Packs
-        for (const [packIndex, packStream] of packStreams.entries()) {
-            const pack = packs[packIndex];
-            const target = (0, path_1.join)(outPath, `pack-${packIndex}${pack.name ? `-${pack.name}` : ""}.zip`);
-            await (0, zip_1.zip)({
-                path: sourcePath,
-                output: target,
-                includeList: packStream.path.toString(),
-                verbose: data.options.verbose,
-                onProgress: async (progress) => await scanner.progress("Compressing file", progress),
-            });
+        let packIndex = 0;
+        for (const pack of packs) {
+            const packBasename = [`pack`, (packIndex++).toString(), pack.name]
+                .filter((v) => typeof v === "string")
+                .map((v) => encodeURIComponent(v.toString().replace(/[\\/]/g, "-")))
+                .join("-");
+            const ext = pack.compress ? `.tar.gz` : `.tar`;
+            if (pack.includeResult.length)
+                await (0, tar_1.createTar)({
+                    compress: pack.compress,
+                    verbose: data.options.verbose,
+                    include: pack.includeResult,
+                    path: sourcePath,
+                    output: (0, path_1.join)(outPath, packBasename) + ext,
+                    onEntry: async (data) => await scanner.progress(pack.compress ? "Compressing" : "Packing", data.path),
+                });
         }
+        await scanner.end();
         // Meta
         const metaPath = `${outPath}/meta.json`;
         const nodePkg = (0, fs_1.parsePackageFile)();
@@ -403,23 +246,28 @@ class DatatruckRepository extends RepositoryAbstract_1.RepositoryAbstract {
         const targetPath = (0, path_1.resolve)((0, path_1.join)(data.mirrorRepositoryConfig.outPath, snapshotName));
         if (data.options.verbose)
             (0, cli_1.logExec)(`Copying backup files to ${targetPath}`);
-        await (0, promises_1.mkdir)(targetPath);
-        const scanner = await this.createFileScanner({
+        await (0, promises_1.mkdir)(targetPath, { recursive: true });
+        await (0, fs_1.ensureEmptyDir)(targetPath);
+        const scanner = await (0, fs_1.createFileScanner)({
+            onProgress: data.onProgress,
             glob: {
                 include: ["**/*"],
                 cwd: sourcePath,
             },
-            onProgress: data.onProgress,
         });
-        await scanner.start();
-        await (0, fs_1.cpy)({
-            input: {
-                type: "glob",
-                sourcePath,
-            },
-            targetPath,
-            onProgress: async (progress) => await scanner.progress(progress.type === "end" ? "Files copied" : "Copying file", progress),
+        const entryPaths = [];
+        await scanner.start(async (entry) => {
+            entryPaths.push(entry.path);
+            return true;
         });
+        for (const entryPath of entryPaths) {
+            const sourceFile = (0, path_1.join)(sourcePath, entryPath);
+            const targetFile = (0, path_1.join)(targetPath, entryPath);
+            await scanner.progress("Copying", entryPath);
+            await (0, promises_1.mkdir)((0, path_1.dirname)(targetFile), { recursive: true });
+            await (0, promises_1.cp)(sourceFile, targetFile);
+        }
+        await scanner.end();
     }
     async onRestore(data) {
         const relRestorePath = data.targetPath ?? data.package.restorePath;
@@ -438,72 +286,41 @@ class DatatruckRepository extends RepositoryAbstract_1.RepositoryAbstract {
             packageName: data.package.name,
         });
         const sourcePath = (0, path_1.join)(this.config.outPath, snapshotName);
-        const scanner = await this.createFileScanner({
+        const scanner = await (0, fs_1.createFileScanner)({
+            onProgress: data.onProgress,
             glob: {
-                include: ["unpacked/**/*"],
                 cwd: sourcePath,
+                include: ["**/*"],
             },
-            onProgress: data.onProgress,
-            disableEndProgress: true,
         });
-        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_1.listZip)({
-                    path,
+        const tarFiles = [];
+        await scanner.start(async (entry) => {
+            const path = (0, path_1.join)(sourcePath, entry.name);
+            const isTar = entry.name.endsWith(".tar");
+            const isTarGz = entry.name.endsWith(".tar.gz");
+            if (isTar || isTarGz) {
+                tarFiles.push(path);
+                await (0, tar_1.listTar)({
+                    input: path,
                     verbose: data.options.verbose,
-                    onStream: async (item) => {
-                        const isDir = item.Folder === "+";
-                        if (!isDir)
-                            scanner.total++;
-                        await scanner.updateProgress();
+                    onEntry: () => {
+                        scanner.total++;
                     },
                 });
             }
-        }
-        await scanner.updateProgress(true);
-        if (data.options.verbose)
-            (0, cli_1.logExec)(`Copying files to ${restorePath}`);
-        await (0, fs_1.cpy)({
-            input: {
-                type: "glob",
-                sourcePath: (0, path_1.join)(sourcePath, "unpacked"),
-            },
-            targetPath: restorePath,
-            concurrency: this.config.fileCopyConcurrency,
-            onProgress: async (progress) => await scanner.progress(progress.type === "end" ? "Files copied" : "Copying file", progress),
+            return false;
         });
-        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_1.logExec)(`Applying permissions (${path})`);
-                await scanner.progress("Applying permissions", {
-                    current: 0,
-                });
-                await (0, fs_1.applyPermissions)(restorePath, path);
-                await scanner.progress("Permissions applied", {
-                    current: 1,
-                    type: "end",
-                });
-            }
-            else if (dirent.name.endsWith(".zip")) {
-                await (0, zip_1.unzip)({
-                    input: path,
-                    output: restorePath,
-                    verbose: data.options.verbose,
-                    onProgress: async (progress) => await scanner.progress("Extracting file", progress),
-                });
-            }
+        if (data.options.verbose)
+            (0, cli_1.logExec)(`Unpacking files to ${restorePath}`);
+        for (const tarFile of tarFiles) {
+            await (0, tar_1.extractTar)({
+                input: tarFile,
+                output: restorePath,
+                verbose: data.options.verbose,
+                onEntry: async (data) => await scanner.progress(tarFile.endsWith(".tar.gz") ? "Extracting" : "Unpacking", data.path),
+            });
         }
+        await scanner.end();
     }
 }
 exports.DatatruckRepository = DatatruckRepository;
-DatatruckRepository.zipBasenameTpl = `.*.dd.zip`;

package/Repository/GitRepository.js

@@ -32,6 +32,7 @@ exports.gitPackageRepositoryDefinition = {
     properties: {},
 };
 class GitRepository extends RepositoryAbstract_1.RepositoryAbstract {
+    static refPrefix = "dt";
     onGetSource() {
         return this.config.repo;
     }
@@ -244,4 +245,3 @@ class GitRepository extends RepositoryAbstract_1.RepositoryAbstract {
     }
 }
 exports.GitRepository = GitRepository;
-GitRepository.refPrefix = "dt";

package/Repository/RepositoryAbstract.js

@@ -12,11 +12,13 @@ var SnapshotTagEnum;
     SnapshotTagEnum["TAGS"] = "tags";
     SnapshotTagEnum["VERSION"] = "version";
     SnapshotTagEnum["SIZE"] = "size";
-})(SnapshotTagEnum = exports.SnapshotTagEnum || (exports.SnapshotTagEnum = {}));
+})(SnapshotTagEnum || (exports.SnapshotTagEnum = SnapshotTagEnum = {}));
 class RepositoryAbstract {
+    repository;
+    config;
+    tmpDirs = [];
     constructor(repository) {
         this.repository = repository;
-        this.tmpDirs = [];
         this.config = repository.config;
     }
     async mkTmpDir(prefix, id) {

package/Repository/ResticRepository.js

@@ -81,6 +81,8 @@ exports.resticPackageRepositoryDefinition = {
     properties: {},
 };
 class ResticRepository extends RepositoryAbstract_1.RepositoryAbstract {
+    static refPrefix = "dt-";
+    env;
     async buildEnv() {
         if (this.env)
             return this.env;
@@ -386,4 +388,3 @@ class ResticRepository extends RepositoryAbstract_1.RepositoryAbstract {
     }
 }
 exports.ResticRepository = ResticRepository;
-ResticRepository.refPrefix = "dt-";

package/SessionDriver/ConsoleSessionDriver.js

@@ -14,11 +14,15 @@ const sep = (0, chalk_1.grey)(`|`);
 const renderBadge = (badge) => `${badge.color(badge.name)}${(0, chalk_1.grey)(`:`)} ${(0, chalk_1.white)(badge.value)}`;
 const renderBadges = (badges) => badges.map(renderBadge).join(` ${sep} `);
 class ConsoleSessionDriver extends SessionDriverAbstract_1.SessionDriverAbstract {
-    constructor() {
-        super(...arguments);
-        this.prints = 0;
-        this.chron = (0, date_1.createChron)();
-    }
+    lastMessage;
+    lastMessageText;
+    prints = 0;
+    renderInterval;
+    rendering;
+    lastColumns;
+    startTime;
+    chron = (0, date_1.createChron)();
+    tty;
     async onInit() {
         this.tty = this.options.verbose
             ? false

package/SessionDriver/SessionDriverAbstract.js

@@ -7,7 +7,7 @@ var ActionEnum;
     ActionEnum[ActionEnum["Start"] = 1] = "Start";
     ActionEnum[ActionEnum["Progress"] = 2] = "Progress";
     ActionEnum[ActionEnum["End"] = 3] = "End";
-})(ActionEnum = exports.ActionEnum || (exports.ActionEnum = {}));
+})(ActionEnum || (exports.ActionEnum = ActionEnum = {}));
 var EntityEnum;
 (function (EntityEnum) {
     EntityEnum[EntityEnum["BackupSession"] = 0] = "BackupSession";
@@ -16,8 +16,9 @@ var EntityEnum;
     EntityEnum[EntityEnum["RestoreSession"] = 3] = "RestoreSession";
     EntityEnum[EntityEnum["RestoreSessionTask"] = 4] = "RestoreSessionTask";
     EntityEnum[EntityEnum["RestoreSessionRepository"] = 5] = "RestoreSessionRepository";
-})(EntityEnum = exports.EntityEnum || (exports.EntityEnum = {}));
+})(EntityEnum || (exports.EntityEnum = EntityEnum = {}));
 class SessionDriverAbstract {
+    options;
     constructor(options) {
         this.options = options;
     }

package/SessionDriver/SqliteSessionDriver.js

@@ -20,10 +20,8 @@ const path_2 = require("path");
 const sqlite_1 = require("sqlite");
 const sqlite3_1 = __importDefault(require("sqlite3"));
 class SqliteSessionDriver extends SessionDriverAbstract_1.SessionDriverAbstract {
-    constructor() {
-        super(...arguments);
-        this.idMap = {};
-    }
+    idMap = {};
+    db;
     async onInit() {
         this.db = await (0, sqlite_1.open)({
             filename: process.env["DATATRUCK_SQLITE_DB"] ??

package/SessionManager/BackupSessionManager.js

@@ -8,12 +8,9 @@ const SessionDriverAbstract_1 = require("../SessionDriver/SessionDriverAbstract"
 const ObjectVault_1 = require("../utils/ObjectVault");
 const SessionManagerAbstract_1 = __importDefault(require("./SessionManagerAbstract"));
 class BackupSessionManager extends SessionManagerAbstract_1.default {
-    constructor() {
-        super(...arguments);
-        this.sessionVault = new ObjectVault_1.ObjectVault();
-        this.taskVault = new ObjectVault_1.ObjectVault();
-        this.repositoryVault = new ObjectVault_1.ObjectVault();
-    }
+    sessionVault = new ObjectVault_1.ObjectVault();
+    taskVault = new ObjectVault_1.ObjectVault();
+    repositoryVault = new ObjectVault_1.ObjectVault();
     findId(data) {
         return this.sessionVault.getId([data.packageName]);
     }

package/SessionManager/RestoreSessionManager.js

@@ -8,12 +8,9 @@ const SessionDriverAbstract_1 = require("../SessionDriver/SessionDriverAbstract"
 const ObjectVault_1 = require("../utils/ObjectVault");
 const SessionManagerAbstract_1 = __importDefault(require("./SessionManagerAbstract"));
 class RestoreSessionManager extends SessionManagerAbstract_1.default {
-    constructor() {
-        super(...arguments);
-        this.sessionVault = new ObjectVault_1.ObjectVault();
-        this.repositoryVault = new ObjectVault_1.ObjectVault();
-        this.taskVault = new ObjectVault_1.ObjectVault();
-    }
+    sessionVault = new ObjectVault_1.ObjectVault();
+    repositoryVault = new ObjectVault_1.ObjectVault();
+    taskVault = new ObjectVault_1.ObjectVault();
     findId(data) {
         return this.sessionVault.getId([data.packageName]);
     }

package/SessionManager/SessionManagerAbstract.js

@@ -1,6 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 class SessionManagerAbstract {
+    options;
+    lastProgressDate;
+    lastRelativeProgressDescription;
+    progressTimeout;
     constructor(options) {
         this.options = options;
     }

package/Task/GitTask.js

@@ -55,6 +55,7 @@ exports.gitTaskDefinition = {
     },
 };
 class GitTask extends TaskAbstract_1.TaskAbstract {
+    verbose;
     get command() {
         return this.config.command ?? "git";
     }