@datatruck/cli 0.26.1 → 0.27.0

package/Action/RestoreAction.d.ts

@@ -14,7 +14,7 @@ export type RestoreActionOptionsType = {
     repositoryNames?: string[];
     repositoryTypes?: string[];
     verbose?: boolean;
-    noRestorePath?: boolean;
+    restorePath?: boolean;
 };
 type SnapshotType = SnapshotResultType & {
     repositoryName: string;

package/Action/RestoreAction.js

@@ -145,7 +145,7 @@ class RestoreAction {
         });
         let repoError;
         let repoInstance;
-        if (this.options.noRestorePath)
+        if (!this.options.restorePath)
             pkg = {
                 ...pkg,
                 restorePath: pkg.path,

package/Command/RestoreCommand.d.ts

@@ -9,7 +9,7 @@ export type RestoreCommandOptionsType<TResolved = false> = {
     repository?: If<TResolved, string[]>;
     repositoryType?: If<TResolved, RepositoryConfigType["type"][]>;
     tag?: If<TResolved, string[]>;
-    noRestorePath?: boolean;
+    restorePath?: boolean;
 };
 export declare class RestoreCommand extends CommandAbstract<RestoreCommandOptionsType<false>, RestoreCommandOptionsType<true>> {
     onOptions(): import("../utils/cli").OptionsType<RestoreCommandOptionsType<false>, RestoreCommandOptionsType<true>>;

package/Command/RestoreCommand.js

@@ -21,7 +21,7 @@ class RestoreCommand extends CommandAbstract_1.CommandAbstract {
                 option: "-p,--package <values>",
                 parser: string_1.parseStringList,
             },
-            noRestorePath: {
+            restorePath: {
                 description: "Disable restore path",
                 option: "--no-restore-path",
             },
@@ -63,7 +63,7 @@ class RestoreCommand extends CommandAbstract_1.CommandAbstract {
             repositoryTypes: this.options.repositoryType,
             tags: this.options.tag,
             verbose: verbose > 0,
-            noRestorePath: this.options.noRestorePath,
+            restorePath: this.options.restorePath,
         });
         const sessionManager = new RestoreSessionManager_1.RestoreSessionManager({
             driver: new SqliteSessionDriver_1.SqliteSessionDriver({

package/Command/StartServerCommand.d.ts

@@ -0,0 +1,6 @@
+import { CommandAbstract } from "./CommandAbstract";
+export type StartServerCommandOptionsType<TResolved = false> = {};
+export declare class StartServerCommand extends CommandAbstract<StartServerCommandOptionsType<false>, StartServerCommandOptionsType<true>> {
+    onOptions(): import("../utils/cli").OptionsType<StartServerCommandOptionsType<false>, StartServerCommandOptionsType<true>>;
+    onExec(): Promise<number>;
+}

package/Command/StartServerCommand.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StartServerCommand = void 0;
+const ConfigAction_1 = require("../Action/ConfigAction");
+const server_1 = require("../utils/datatruck/server");
+const CommandAbstract_1 = require("./CommandAbstract");
+class StartServerCommand extends CommandAbstract_1.CommandAbstract {
+    onOptions() {
+        return this.returnsOptions({});
+    }
+    async onExec() {
+        const config = await ConfigAction_1.ConfigAction.fromGlobalOptions(this.globalOptions);
+        const server = (0, server_1.createDatatruckServer)(config.server || {});
+        const port = config.server?.listen?.port ?? 8888;
+        const address = config.server?.listen?.address ?? "127.0.0.1";
+        console.info(`Listening on http://${address}:${port}`);
+        await new Promise((resolve, reject) => {
+            server.listen(port, address);
+            server.on("error", reject);
+        });
+        return 0;
+    }
+}
+exports.StartServerCommand = StartServerCommand;

package/Config/Config.d.ts

@@ -1,3 +1,4 @@
+import { DatatruckServerOptions } from "../utils/datatruck/server";
 import { PackageConfigType } from "./PackageConfig";
 import { RepositoryConfigType } from "./RepositoryConfig";
 import type { JSONSchema7 } from "json-schema";
@@ -5,5 +6,6 @@ export type ConfigType = {
     tempDir?: string;
     repositories: RepositoryConfigType[];
     packages: PackageConfigType[];
+    server?: DatatruckServerOptions;
 };
 export declare const configDefinition: JSONSchema7;

package/Config/Config.js

@@ -17,5 +17,31 @@ exports.configDefinition = {
             type: "array",
             items: (0, DefinitionEnum_1.makeRef)(DefinitionEnum_1.DefinitionEnum.package),
         },
+        server: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                path: { type: "string" },
+                users: {
+                    type: "array",
+                    items: {
+                        type: "object",
+                        additionalProperties: false,
+                        properties: {
+                            name: { type: "string" },
+                            password: { type: "string" },
+                        },
+                    },
+                },
+                listen: {
+                    type: "object",
+                    additionalProperties: false,
+                    properties: {
+                        port: { type: "integer" },
+                        address: { type: "string" },
+                    },
+                },
+            },
+        },
     },
 };

package/Factory/CommandFactory.d.ts

@@ -9,6 +9,7 @@ import { PruneCommandOptionsType } from "../Command/PruneCommand";
 import { RestoreCommandOptionsType } from "../Command/RestoreCommand";
 import { RestoreSessionsCommandOptionsType } from "../Command/RestoreSessionsCommand";
 import { SnapshotsCommandLogType, SnapshotsCommandOptionsType } from "../Command/SnapshotsCommand";
+import { StartServerCommandOptionsType } from "../Command/StartServerCommand";
 export declare enum CommandEnum {
     config = "config",
     init = "init",
@@ -18,7 +19,8 @@ export declare enum CommandEnum {
     backupSessions = "backup-sessions",
     restore = "restore",
     restoreSessions = "restore-sessions",
-    cleanCache = "clean-cache"
+    cleanCache = "clean-cache",
+    startServer = "start-server"
 }
 export type OptionsMapType = {
     [CommandEnum.config]: ConfigCommandOptionsType;
@@ -30,6 +32,7 @@ export type OptionsMapType = {
     [CommandEnum.restore]: RestoreCommandOptionsType;
     [CommandEnum.restoreSessions]: RestoreSessionsCommandOptionsType;
     [CommandEnum.cleanCache]: CleanCacheActionOptionsType;
+    [CommandEnum.startServer]: StartServerCommandOptionsType;
 };
 export type LogMapType = {
     [CommandEnum.config]: ConfigCommandLogType;

package/Factory/CommandFactory.js

@@ -10,6 +10,7 @@ const PruneCommand_1 = require("../Command/PruneCommand");
 const RestoreCommand_1 = require("../Command/RestoreCommand");
 const RestoreSessionsCommand_1 = require("../Command/RestoreSessionsCommand");
 const SnapshotsCommand_1 = require("../Command/SnapshotsCommand");
+const StartServerCommand_1 = require("../Command/StartServerCommand");
 const AppError_1 = require("../Error/AppError");
 var CommandEnum;
 (function (CommandEnum) {
@@ -22,6 +23,7 @@ var CommandEnum;
     CommandEnum["restore"] = "restore";
     CommandEnum["restoreSessions"] = "restore-sessions";
     CommandEnum["cleanCache"] = "clean-cache";
+    CommandEnum["startServer"] = "start-server";
 })(CommandEnum || (exports.CommandEnum = CommandEnum = {}));
 function CommandFactory(type, globalOptions, options) {
     const constructor = CommandConstructorFactory(type);
@@ -74,6 +76,7 @@ function makeParseLog(type) {
     const data = [];
     const consoleLog = console.log;
     console.log = console.info = (...items) => {
+        consoleLog.bind(console)(...items);
         data.push(...items);
     };
     return function parseLog() {
@@ -110,6 +113,9 @@ function CommandConstructorFactory(type) {
     else if (type === CommandEnum.cleanCache) {
         return CleanCacheCommand_1.CleanCacheCommand;
     }
+    else if (type === CommandEnum.startServer) {
+        return StartServerCommand_1.StartServerCommand;
+    }
     else {
         throw new AppError_1.AppError(`Invalid command type: ${type}`);
     }

package/Repository/DatatruckRepository.d.ts

@@ -11,10 +11,11 @@ export type MetaDataType = {
     size: number;
     tarStats?: Record<string, {
         files: number;
+        size: number;
     }>;
 };
 export type DatatruckRepositoryConfigType = {
-    outPath: string;
+    backend: string;
     compress?: boolean | CompressOptions;
 };
 type PackObject = {
@@ -33,10 +34,11 @@ export declare const datatruckRepositoryDefinition: JSONSchema7;
 export declare const datatruckPackageRepositoryDefinition: JSONSchema7;
 export declare class DatatruckRepository extends RepositoryAbstract<DatatruckRepositoryConfigType> {
     static zipBasenameTpl: string;
-    static buildSnapshotName(data: {
-        snapshotId: string;
-        snapshotDate: string;
-        packageName: string;
+    static buildSnapshotName(snapshot: {
+        id: string;
+        date: string;
+    }, pkg: {
+        name: string;
     }): string;
     static parseSnapshotName(name: string): {
         snapshotDate: string;
@@ -44,9 +46,7 @@ export declare class DatatruckRepository extends RepositoryAbstract<DatatruckRep
         snapshotShortId: string;
         sourcePath: string;
     } | null;
-    protected buildMetaPath(snapshotName: string, packageName: string): string;
-    static parseMetaData(path: string): Promise<MetaDataType | undefined>;
-    static stringifyMetaData(data: MetaDataType): string;
+    static parseMetaData(data: string): Promise<MetaDataType>;
     onGetSource(): string;
     onInit(data: InitDataType): Promise<void>;
     onPrune(data: PruneDataType): Promise<void>;

package/Repository/DatatruckRepository.js

@@ -4,6 +4,7 @@ exports.DatatruckRepository = exports.datatruckPackageRepositoryDefinition = exp
 const AppError_1 = require("../Error/AppError");
 const DefinitionEnum_1 = require("../JsonSchema/DefinitionEnum");
 const cli_1 = require("../utils/cli");
+const client_1 = require("../utils/datatruck/client");
 const paths_1 = require("../utils/datatruck/paths");
 const fs_1 = require("../utils/fs");
 const string_1 = require("../utils/string");
@@ -16,10 +17,10 @@ const path_1 = require("path");
 exports.datatruckRepositoryName = "datatruck";
 exports.datatruckRepositoryDefinition = {
     type: "object",
-    required: ["outPath"],
+    required: ["backend"],
     additionalProperties: false,
     properties: {
-        outPath: { type: "string" },
+        backend: { type: "string" },
         compress: {
             anyOf: [{ type: "boolean" }, (0, DefinitionEnum_1.makeRef)(DefinitionEnum_1.DefinitionEnum.compressUtil)],
         },
@@ -52,10 +53,10 @@ exports.datatruckPackageRepositoryDefinition = {
 };
 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, "@");
-        const snapshotShortId = data.snapshotId.slice(0, 8);
+    static buildSnapshotName(snapshot, pkg) {
+        const date = snapshot.date.replace(/:/g, "-");
+        const pkgName = encodeURIComponent(pkg.name).replace(/%40/g, "@");
+        const snapshotShortId = snapshot.id.slice(0, 8);
         return `${date}_${pkgName}_${snapshotShortId}`;
     }
     static parseSnapshotName(name) {
@@ -69,49 +70,32 @@ class DatatruckRepository extends RepositoryAbstract_1.RepositoryAbstract {
         packageName = decodeURIComponent(packageName);
         return { snapshotDate, packageName, snapshotShortId, sourcePath: name };
     }
-    buildMetaPath(snapshotName, packageName) {
-        return (0, path_1.join)(this.config.outPath, snapshotName, packageName) + ".meta.json";
-    }
-    static async parseMetaData(path) {
-        let contents;
-        try {
-            contents = await (0, promises_1.readFile)(path);
-        }
-        catch (error) {
-            if ((0, fs_1.isNotFoundError)(error))
-                return;
-            throw error;
-        }
-        return JSON.parse(contents.toString());
-    }
-    static stringifyMetaData(data) {
-        return JSON.stringify(data);
+    static async parseMetaData(data) {
+        return JSON.parse(data.toString());
     }
     onGetSource() {
-        return this.config.outPath;
+        return this.config.backend;
     }
     async onInit(data) {
-        await (0, fs_1.mkdirIfNotExists)(this.config.outPath);
+        const fs = (0, client_1.createFs)(this.config.backend);
+        await fs.mkdir(".");
     }
     async onPrune(data) {
-        const snapshotName = DatatruckRepository.buildSnapshotName({
-            snapshotId: data.snapshot.id,
-            snapshotDate: data.snapshot.date,
-            packageName: data.snapshot.packageName,
+        const fs = (0, client_1.createFs)(this.config.backend);
+        const snapshotName = DatatruckRepository.buildSnapshotName(data.snapshot, {
+            name: data.snapshot.packageName,
         });
-        const snapshotPath = (0, path_1.join)(this.config.outPath, snapshotName);
         if (data.options.verbose)
-            (0, cli_1.logExec)(`Deleting ${snapshotPath}`);
-        if (await (0, fs_1.existsDir)(snapshotPath))
-            await (0, promises_1.rm)(snapshotPath, {
-                recursive: true,
-            });
+            (0, cli_1.logExec)(`Deleting ${fs.resolvePath(snapshotName)}`);
+        if (await fs.existsDir(snapshotName))
+            await fs.rmAll(snapshotName);
     }
     async onSnapshots(data) {
-        if (!(await (0, fs_1.existsDir)(this.config.outPath)))
-            throw new Error(`Repository (${this.repository.name}) out path does not exist: ${this.config.outPath}`);
-        const snapshotNames = await (0, fs_1.readDir)(this.config.outPath);
+        const fs = (0, client_1.createFs)(this.config.backend);
+        if (!(await fs.existsDir(".")))
+            throw new Error(`Repository (${this.repository.name}) out path does not exist: ${fs.resolvePath(".")}`);
         const snapshots = [];
+        const snapshotNames = await fs.readdir(".");
         const packagePatterns = (0, string_1.makePathPatterns)(data.options.packageNames);
         const taskPatterns = (0, string_1.makePathPatterns)(data.options.packageTaskNames);
         for (const snapshotName of snapshotNames) {
@@ -124,8 +108,8 @@ 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, "meta.json");
-            const meta = await DatatruckRepository.parseMetaData(metaPath);
+            const metaData = await fs.readFileIfExists(`${snapshotName}/meta.json`);
+            const meta = !!metaData && (await DatatruckRepository.parseMetaData(metaData));
             if (!meta)
                 continue;
             if (taskPatterns && !(0, string_1.checkMatch)(meta.task, taskPatterns))
@@ -149,16 +133,15 @@ class DatatruckRepository extends RepositoryAbstract_1.RepositoryAbstract {
         return snapshots;
     }
     async onBackup(data) {
-        const snapshotName = DatatruckRepository.buildSnapshotName({
-            snapshotId: data.snapshot.id,
-            snapshotDate: data.snapshot.date,
-            packageName: data.package.name,
-        });
-        const outPath = (0, path_1.resolve)((0, path_1.join)(this.config.outPath, snapshotName));
+        const fs = (0, client_1.createFs)(this.config.backend);
+        const snapshotName = DatatruckRepository.buildSnapshotName(data.snapshot, data.package);
+        const outPath = fs.isLocal()
+            ? fs.resolvePath(snapshotName)
+            : await this.mkTmpDir("datatruck-backup");
         const pkg = data.package;
         const sourcePath = data.targetPath ?? pkg.path;
         (0, assert_1.ok)(sourcePath);
-        await (0, promises_1.mkdir)(outPath, { recursive: true });
+        await fs.mkdir(snapshotName);
         const backupPathsOptions = {
             package: data.package,
             snapshot: data.snapshot,
@@ -224,21 +207,28 @@ class DatatruckRepository extends RepositoryAbstract_1.RepositoryAbstract {
             if (includeList) {
                 tarStats[packBasename] = {
                     files: stream.lines(packIndex),
+                    size: 0,
                 };
+                const tarPath = (0, path_1.join)(outPath, packBasename);
                 await (0, tar_1.createTar)({
                     compress: pack.compress,
                     verbose: data.options.verbose,
                     includeList,
                     path: sourcePath,
-                    output: (0, path_1.join)(outPath, packBasename),
+                    output: tarPath,
                     onEntry: async (data) => await scanner.progress(pack.compress ? "Compressing" : "Packing", data.path),
                 });
+                tarStats[packBasename].size = (await (0, promises_1.stat)(tarPath)).size;
+                if (!fs.isLocal()) {
+                    await fs.upload(tarPath, `${snapshotName}/${packBasename}`);
+                    await (0, promises_1.rm)(tarPath);
+                }
             }
             packIndex++;
         }
         await scanner.end();
         // Meta
-        const metaPath = `${outPath}/meta.json`;
+        const metaPath = `${snapshotName}/meta.json`;
         const nodePkg = (0, fs_1.parsePackageFile)();
         const meta = {
             id: data.snapshot.id,
@@ -247,47 +237,42 @@ class DatatruckRepository extends RepositoryAbstract_1.RepositoryAbstract {
             package: data.package.name,
             task: data.package.task?.name,
             version: nodePkg.version,
-            size: await (0, fs_1.fastFolderSizeAsync)(outPath),
+            size: Object.values(tarStats).reduce((total, { size }) => total + size, 0),
             tarStats,
         };
         if (data.options.verbose)
-            (0, cli_1.logExec)(`Writing metadata into ${metaPath}`);
-        await (0, promises_1.writeFile)(metaPath, DatatruckRepository.stringifyMetaData(meta));
+            (0, cli_1.logExec)(`Writing metadata into ${fs.resolvePath(metaPath)}`);
+        await fs.writeFile(`${snapshotName}/meta.json`, JSON.stringify(meta));
     }
     async onCopyBackup(data) {
-        const snapshotName = DatatruckRepository.buildSnapshotName({
-            snapshotId: data.snapshot.id,
-            snapshotDate: data.snapshot.date,
-            packageName: data.package.name,
-        });
-        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 sourceFs = (0, client_1.createFs)(this.config.backend);
+        const targetFs = (0, client_1.createFs)(data.mirrorRepositoryConfig.backend);
+        const snapshotName = DatatruckRepository.buildSnapshotName(data.snapshot, data.package);
         if (data.options.verbose)
-            (0, cli_1.logExec)(`Copying backup files to ${targetPath}`);
-        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,
-            },
-        });
-        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);
+            (0, cli_1.logExec)(`Copying backup files to ${data.mirrorRepositoryConfig.backend}`);
+        await targetFs.mkdir(snapshotName);
+        await targetFs.ensureEmptyDir(snapshotName);
+        const entries = await sourceFs.readdir(snapshotName);
+        for (const entry of entries) {
+            const sourceEntry = `${snapshotName}/${entry}`;
+            if (targetFs.isLocal()) {
+                await sourceFs.download(sourceEntry, targetFs.resolvePath(sourceEntry));
+            }
+            else {
+                const tempDir = await this.mkTmpDir("remote-copy", entry);
+                const tempFile = (0, path_1.join)(tempDir, entry);
+                try {
+                    await sourceFs.download(sourceEntry, tempFile);
+                    await targetFs.upload(tempFile, sourceEntry);
+                }
+                finally {
+                    await (0, fs_1.tryRm)(tempFile);
+                }
+            }
         }
-        await scanner.end();
     }
     async onRestore(data) {
+        const fs = (0, client_1.createFs)(this.config.backend);
         const relRestorePath = data.targetPath ?? data.package.restorePath;
         (0, assert_1.ok)(relRestorePath);
         const restorePath = (0, path_1.resolve)(relRestorePath);
@@ -298,61 +283,41 @@ class DatatruckRepository extends RepositoryAbstract_1.RepositoryAbstract {
         });
         if (!snapshot)
             throw new AppError_1.AppError("Snapshot not found");
-        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);
-        const metaPath = (0, path_1.join)(sourcePath, "meta.json");
-        const meta = await DatatruckRepository.parseMetaData(metaPath);
-        const scanner = await (0, fs_1.createFileScanner)({
-            onProgress: data.onProgress,
-            glob: {
-                cwd: sourcePath,
-                include: ["**/*"],
-            },
-        });
-        const tarFiles = [];
+        const snapshotName = DatatruckRepository.buildSnapshotName(snapshot, data.package);
+        const meta = await DatatruckRepository.parseMetaData(await fs.readFile(`${snapshotName}/meta.json`));
+        const progress = (0, fs_1.createProgress)({ onProgress: data.onProgress });
+        await progress.update("Scanning files");
+        const entries = (await fs.readdir(snapshotName)).filter((v) => v.endsWith(".tar") || v.endsWith(".tar.gz"));
         const tarStats = meta?.tarStats || {};
-        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);
-                if (typeof tarStats[entry.name]?.files === "number") {
-                    scanner.total += tarStats[entry.name].files;
-                }
-                else {
-                    scanner.progress("Scanning", entry.name, false);
-                    const selfTarStats = (tarStats[entry.name] = { files: 0 });
-                    await (0, tar_1.listTar)({
-                        input: path,
-                        verbose: data.options.verbose,
-                        onEntry: () => {
-                            scanner.total++;
-                            selfTarStats.files++;
-                        },
-                    });
-                }
-            }
-            return false;
-        });
+        for (const file in tarStats)
+            progress.total += tarStats[file].files;
+        await progress.update(`Scanned files: ${progress.total}`);
         if (data.options.verbose)
             (0, cli_1.logExec)(`Unpacking files to ${restorePath}`);
-        for (const tarFile of tarFiles) {
-            const entryName = (0, path_1.basename)(tarFile);
-            await (0, tar_1.extractTar)({
-                total: tarStats[entryName].files,
-                input: tarFile,
-                output: restorePath,
-                decompress: tarFile.endsWith(".tar.gz"),
-                verbose: data.options.verbose,
-                onEntry: async (data) => await scanner.progress(tarFile.endsWith(".tar.gz") ? "Extracting" : "Unpacking", data.path),
-            });
+        for (const entry of entries) {
+            let tempEntry;
+            try {
+                const sourceEntry = `${snapshotName}/${entry}`;
+                if (!fs.isLocal()) {
+                    const tempDir = await this.mkTmpDir("remote-restore", entry);
+                    tempEntry = `${tempDir}/${entry}`;
+                    await fs.download(sourceEntry, tempEntry);
+                }
+                await (0, tar_1.extractTar)({
+                    total: tarStats[entry].files,
+                    input: tempEntry ?? fs.resolvePath(sourceEntry),
+                    output: restorePath,
+                    decompress: entry.endsWith(".tar.gz"),
+                    verbose: data.options.verbose,
+                    onEntry: async (data) => await progress.update(entry.endsWith(".tar.gz") ? "Extracting" : "Unpacking", data.path),
+                });
+            }
+            finally {
+                if (tempEntry)
+                    await (0, fs_1.tryRm)(tempEntry);
+            }
         }
-        await scanner.end();
+        await progress.update("Finished");
     }
 }
 exports.DatatruckRepository = DatatruckRepository;

package/Task/MysqlDumpTask.js

@@ -163,7 +163,7 @@ class MysqlDumpTask extends TaskAbstract_1.TaskAbstract {
         const database = {
             name: (0, config_1.resolveDatabaseName)(this.config.database, params),
         };
-        if (this.config.targetDatabase && !data.options.noRestorePath)
+        if (this.config.targetDatabase && data.options.restorePath)
             database.name = (0, config_1.resolveDatabaseName)(this.config.targetDatabase.name, {
                 ...params,
                 database: database.name,

package/Task/SqlDumpTaskAbstract.js

@@ -192,7 +192,7 @@ class SqlDumpTaskAbstract extends TaskAbstract_1.TaskAbstract {
                 database: undefined,
             }),
         };
-        if (this.config.targetDatabase && !data.options.noRestorePath) {
+        if (this.config.targetDatabase && data.options.restorePath) {
             database.name = (0, config_1.resolveDatabaseName)(this.config.targetDatabase.name, {
                 packageName: data.package.name,
                 snapshotId: data.options.snapshotId,

package/cli.js

@@ -83,6 +83,7 @@ program.option("-c,--config <path>", "Config path", process.env["DATATRUCK_CONFI
 program.option("--progress <value>", "Progress type (auto, plain, tty)", "auto");
 program.option("--progress-interval <ms>", "Progress interval", Number, 1000);
 program.option("-o,--output-format <format>", "Output format (json, pjson, yaml, table, custom=$, tpl=name)", "table");
+makeCommand(CommandFactory_1.CommandEnum.startServer).alias("start");
 makeCommand(CommandFactory_1.CommandEnum.config).alias("c");
 makeCommand(CommandFactory_1.CommandEnum.init).alias("i");
 makeCommand(CommandFactory_1.CommandEnum.snapshots).alias("s");

package/config.schema.json

@@ -444,11 +444,11 @@
     "datatruck-repository": {
       "type": "object",
       "required": [
-        "outPath"
+        "backend"
       ],
       "additionalProperties": false,
       "properties": {
-        "outPath": {
+        "backend": {
           "type": "string"
         },
         "compress": {
@@ -996,6 +996,42 @@
           "items": {
             "$ref": "#/definitions/package"
           }
+        },
+        "server": {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "path": {
+              "type": "string"
+            },
+            "users": {
+              "type": "array",
+              "items": {
+                "type": "object",
+                "additionalProperties": false,
+                "properties": {
+                  "name": {
+                    "type": "string"
+                  },
+                  "password": {
+                    "type": "string"
+                  }
+                }
+              }
+            },
+            "listen": {
+              "type": "object",
+              "additionalProperties": false,
+              "properties": {
+                "port": {
+                  "type": "integer"
+                },
+                "address": {
+                  "type": "string"
+                }
+              }
+            }
+          }
         }
       }
     },