@datatruck/cli 0.26.2 → 0.27.0

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/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"
+                }
+              }
+            }
+          }
         }
       }
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@datatruck/cli",
-  "version": "0.26.2",
+  "version": "0.27.0",
   "dependencies": {
     "@supercharge/promise-pool": "^3.1.0",
     "ajv": "^8.12.0",

package/utils/datatruck/client.d.ts

@@ -0,0 +1,22 @@
+import { AbstractFs, FsOptions } from "../virtual-fs";
+export declare class RemoteFs extends AbstractFs {
+    readonly options: FsOptions;
+    protected url: string;
+    protected headers: Record<string, string>;
+    constructor(options: FsOptions);
+    isLocal(): boolean;
+    protected fetchJson(name: string, params: any[]): Promise<any>;
+    protected post(name: string, params: any[], data: string): Promise<void>;
+    existsDir(path: string): Promise<any>;
+    mkdir(path: string): Promise<any>;
+    readFile(path: string): Promise<any>;
+    readdir(path: string): Promise<any>;
+    readFileIfExists(path: string): Promise<string | undefined>;
+    ensureEmptyDir(path: string): Promise<void>;
+    writeFile(path: string, contents: string): Promise<void>;
+    rmAll(path: string): Promise<void>;
+    upload(source: string, target: string): Promise<void>;
+    download(source: string, target: string, timeout?: number): Promise<void>;
+}
+export declare function isRemoteBackend(backend: string): boolean;
+export declare function createFs(backend: string): AbstractFs;

package/utils/datatruck/client.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFs = exports.isRemoteBackend = exports.RemoteFs = void 0;
+const http_1 = require("../http");
+const virtual_fs_1 = require("../virtual-fs");
+const server_1 = require("./server");
+class RemoteFs extends virtual_fs_1.AbstractFs {
+    options;
+    url;
+    headers;
+    constructor(options) {
+        super(options);
+        this.options = options;
+        const url = new URL(options.backend);
+        this.headers = {
+            [server_1.headerKey.user]: url.username,
+            [server_1.headerKey.password]: url.password,
+        };
+        url.username = "";
+        url.password = "";
+        this.url = url.href;
+        if (this.url.endsWith("/"))
+            this.url = this.url.slice(0, -1);
+    }
+    isLocal() {
+        return false;
+    }
+    async fetchJson(name, params) {
+        return await (0, http_1.fetchJson)(`${this.url}/${name}`, {
+            headers: this.headers,
+            query: {
+                params: JSON.stringify(params),
+            },
+        });
+    }
+    async post(name, params, data) {
+        return await (0, http_1.post)(`${this.url}/${name}`, data, {
+            headers: this.headers,
+            query: {
+                params: JSON.stringify(params),
+            },
+        });
+    }
+    async existsDir(path) {
+        return await this.fetchJson("existsDir", [path]);
+    }
+    async mkdir(path) {
+        return await this.fetchJson("mkdir", [path]);
+    }
+    async readFile(path) {
+        return await this.fetchJson("readFile", [path]);
+    }
+    async readdir(path) {
+        return await this.fetchJson("readdir", [path]);
+    }
+    async readFileIfExists(path) {
+        return await this.fetchJson("readFileIfExists", [path]);
+    }
+    async ensureEmptyDir(path) {
+        return await this.fetchJson("readdir", [path]);
+    }
+    async writeFile(path, contents) {
+        await this.post("writeFile", [path], contents);
+    }
+    async rmAll(path) {
+        await this.fetchJson("rmAll", [path]);
+    }
+    async upload(source, target) {
+        await (0, http_1.uploadFile)(`${this.url}/upload`, source, {
+            headers: this.headers,
+            query: {
+                params: JSON.stringify([target]),
+            },
+        });
+    }
+    async download(source, target, timeout = 100000) {
+        await (0, http_1.downloadFile)(`${this.url}/download`, target, {
+            timeout,
+            headers: this.headers,
+            query: {
+                params: JSON.stringify([source]),
+            },
+        });
+    }
+}
+exports.RemoteFs = RemoteFs;
+function isRemoteBackend(backend) {
+    return backend.startsWith("http:") || backend.startsWith("https:");
+}
+exports.isRemoteBackend = isRemoteBackend;
+function createFs(backend) {
+    return isRemoteBackend(backend)
+        ? new RemoteFs({ backend })
+        : new virtual_fs_1.LocalFs({ backend });
+}
+exports.createFs = createFs;

package/utils/datatruck/config.d.ts

@@ -31,18 +31,18 @@ export declare const pkgPathParams: {
     [name in "temp" | Exclude<keyof ResolvePackagePathParamsType, "path">]: string;
 };
 export declare const pkgIncludeParams: {
+    action: string;
     packageName: string;
     temp: string;
     snapshotId: string;
     snapshotDate: string;
-    action: string;
 };
 export declare const pkgExcludeParams: {
+    action: string;
     packageName: string;
     temp: string;
     snapshotId: string;
     snapshotDate: string;
-    action: string;
 };
 export declare const pkgRestorePathParams: {
     [name in "temp" | keyof ResolvePackagePathParamsType]: string;
@@ -52,33 +52,33 @@ export declare const dbNameParams: {
 };
 export declare const params: {
     pkgPath: {
+        action: string;
         packageName: string;
         temp: string;
         snapshotId: string;
         snapshotDate: string;
-        action: string;
     };
     pkgRestorePath: {
         path: string;
+        action: string;
         packageName: string;
         temp: string;
         snapshotId: string;
         snapshotDate: string;
-        action: string;
     };
     pkgInclude: {
+        action: string;
         packageName: string;
         temp: string;
         snapshotId: string;
         snapshotDate: string;
-        action: string;
     };
     pkgExclude: {
+        action: string;
         packageName: string;
         temp: string;
         snapshotId: string;
         snapshotDate: string;
-        action: string;
     };
     dbName: {
         snapshotId: string;

package/utils/datatruck/server.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="node" />
+import { IncomingMessage } from "http";
+type User = {
+    name: string;
+    password: string;
+};
+export type DatatruckServerOptions = {
+    path?: string;
+    log?: boolean;
+    listen?: {
+        port?: number;
+        address?: string;
+    };
+    users?: User[];
+};
+export declare const headerKey: {
+    user: string;
+    password: string;
+};
+export declare function createDatatruckServer(options: DatatruckServerOptions): import("node:http").Server<typeof IncomingMessage, typeof import("node:http").ServerResponse>;
+export {};

package/utils/datatruck/server.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDatatruckServer = exports.headerKey = void 0;
+const http_1 = require("../http");
+const virtual_fs_1 = require("../virtual-fs");
+const fs_1 = require("fs");
+const http_2 = require("http");
+function parseUrl(inUrl) {
+    const url = new URL(`http://127.0.0.1${inUrl}`);
+    const inParams = url.searchParams.get("params");
+    const action = url.pathname.slice(1);
+    if (typeof inParams === "string") {
+        const params = JSON.parse(inParams);
+        if (!Array.isArray(params))
+            throw new Error(`Invalid params`);
+        return { action, params };
+    }
+    else {
+        return { action, params: [] };
+    }
+}
+exports.headerKey = {
+    user: "x-dtt-user",
+    password: "x-dtt-password",
+};
+function validateRequest(req, users) {
+    const name = req.headers[exports.headerKey.user];
+    const password = req.headers[exports.headerKey.password];
+    return users.some((user) => user.name.length &&
+        user.password.length &&
+        user.name === name &&
+        user.password === password);
+}
+function createDatatruckServer(options) {
+    const log = options.log ?? true;
+    return (0, http_2.createServer)(async (req, res) => {
+        try {
+            if (req.url === "/" || req.url === "/favicon.ico") {
+                return res.end();
+            }
+            else if (!validateRequest(req, options.users || [])) {
+                res.statusCode = 401;
+                return res.end();
+            }
+            if (log)
+                console.info(`> ${req.url}`);
+            const fs = new virtual_fs_1.LocalFs({
+                backend: options.path ?? ".",
+            });
+            const { action, params } = parseUrl(req.url);
+            if (action === "upload") {
+                const [target] = params;
+                const file = (0, fs_1.createWriteStream)(fs.resolvePath(target));
+                req.pipe(file);
+                await new Promise((resolve, reject) => {
+                    req.on("error", reject);
+                    file.on("error", reject);
+                    file.on("close", resolve);
+                });
+            }
+            else if (action === "download") {
+                const [target] = params;
+                const file = (0, fs_1.createReadStream)(fs.resolvePath(target));
+                file.pipe(res);
+                await new Promise((resolve, reject) => {
+                    req.on("error", reject);
+                    file.on("error", reject);
+                    res.on("error", reject);
+                    res.on("close", resolve);
+                });
+            }
+            else if (action === "writeFile") {
+                const data = await (0, http_1.readRequestData)(req);
+                const [target] = params;
+                await fs.writeFile(target, data);
+            }
+            else {
+                const object = fs[action]?.bind(fs);
+                if (!object)
+                    throw new Error(`Invalid action: ${action}`);
+                const json = await object(...params);
+                if (json !== undefined)
+                    res.write(JSON.stringify(json));
+            }
+            res.end();
+            if (log)
+                console.info(`<${action}`);
+        }
+        catch (error) {
+            if (log)
+                console.error(`<${req.url}`, error);
+            res.statusCode = 500;
+        }
+    });
+}
+exports.createDatatruckServer = createDatatruckServer;

package/utils/fs.d.ts

@@ -87,18 +87,24 @@ export declare function cpy(options: {
     files: number;
     dirs: number;
 }>;
+type ProgressObject = {
+    disposed: boolean;
+    total: number;
+    current: number;
+    update: (description: string, path?: string, increment?: boolean) => Promise<void>;
+};
+export declare function createProgress(options: {
+    onProgress: (data: Progress) => Promise<void>;
+}): ProgressObject;
 export declare function createFileScanner(options: {
     glob: Options & {
         include: string[];
     };
     onProgress: (data: Progress) => Promise<void>;
-}): Promise<{
-    disposed: boolean;
-    total: number;
-    current: number;
-    progress: (description: string, path?: string, increment?: boolean) => Promise<void>;
+}): Promise<ProgressObject & {
+    progress: ProgressObject["update"];
+    start: (cb?: (entry: Required<Entry>) => any) => Promise<void>;
     end: () => Promise<void>;
-    start: (cb?: ((entry: Required<Entry>) => any) | undefined) => Promise<void>;
 }>;
 type StreamItem = {
     key: string;
@@ -121,4 +127,5 @@ export declare function createWriteStreamPool(options: {
 export declare function countFileLines(path: string): Promise<number>;
 export declare function fetchData<T>(input: T, onPath?: (input: Exclude<T, string>) => string | undefined): Promise<string | null>;
 export declare function safeRename(oldPath: string, newPath: string): Promise<void>;
+export declare function tryRm(path: string): Promise<void>;
 export {};

package/utils/fs.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.safeRename = exports.fetchData = exports.countFileLines = exports.createWriteStreamPool = exports.createFileScanner = exports.cpy = exports.isNotFoundError = exports.updateFileStats = exports.copyFileWithStreams = exports.waitForClose = exports.writeGitIgnoreList = exports.fastglobToGitIgnore = exports.forEachFile = exports.readDir = exports.readPartialFile = exports.mkTmpDir = exports.fastFolderSizeAsync = exports.tmpDir = exports.rmTmpDir = exports.isTmpDir = exports.sessionTmpDir = exports.parentTmpDir = exports.findFile = exports.parsePackageFile = exports.parseFile = exports.parseFileExtensions = exports.writeJSONFile = exports.existsFile = exports.existsDir = exports.safeStat = exports.ensureEmptyDir = exports.mkdirIfNotExists = exports.isLocalDir = exports.isEmptyDir = exports.isWSLSystem = void 0;
+exports.tryRm = exports.safeRename = exports.fetchData = exports.countFileLines = exports.createWriteStreamPool = exports.createFileScanner = exports.createProgress = exports.cpy = exports.isNotFoundError = exports.updateFileStats = exports.copyFileWithStreams = exports.waitForClose = exports.writeGitIgnoreList = exports.fastglobToGitIgnore = exports.forEachFile = exports.readDir = exports.readPartialFile = exports.mkTmpDir = exports.fastFolderSizeAsync = exports.tmpDir = exports.rmTmpDir = exports.isTmpDir = exports.sessionTmpDir = exports.parentTmpDir = exports.findFile = exports.parsePackageFile = exports.parseFile = exports.parseFileExtensions = exports.writeJSONFile = exports.existsFile = exports.existsDir = exports.safeStat = exports.ensureEmptyDir = exports.mkdirIfNotExists = exports.isLocalDir = exports.isEmptyDir = exports.isWSLSystem = void 0;
 const globalData_1 = __importDefault(require("../globalData"));
 const math_1 = require("./math");
 const path_1 = require("./path");
@@ -404,57 +404,65 @@ async function cpy(options) {
     return stats;
 }
 exports.cpy = cpy;
-async function createFileScanner(options) {
-    const object = {
+function createProgress(options) {
+    const progress = {
         disposed: false,
         total: 0,
         current: 0,
-        progress: async (description, path, increment = true) => {
-            if (object.disposed)
+        update: async (description, path, increment = true) => {
+            if (progress.disposed)
                 return;
             if (path && increment)
-                object.current++;
+                progress.current++;
             await options.onProgress({
                 relative: {
                     description,
                     payload: path,
                 },
                 absolute: {
-                    total: object.total,
-                    current: object.current,
-                    percent: (0, math_1.progressPercent)(object.total, object.current),
+                    total: progress.total,
+                    current: progress.current,
+                    percent: (0, math_1.progressPercent)(progress.total, progress.current),
                 },
             });
         },
+    };
+    return progress;
+}
+exports.createProgress = createProgress;
+async function createFileScanner(options) {
+    const progress = createProgress(options);
+    Object.assign(progress, {
+        progress: progress.update,
         end: async () => {
-            if (!object.disposed)
-                await object.progress("Finished");
-            object.disposed = true;
+            if (!progress.disposed)
+                await progress.update("Finished");
+            progress.disposed = true;
         },
         start: async (cb) => {
             let lastTime = performance.now();
-            await object.progress("Scanning files");
+            await progress.update("Scanning files");
             for await (const entry of pathIterator(stream)) {
                 if (cb) {
                     if (await cb(entry))
-                        object.total++;
+                        progress.total++;
                 }
                 else {
-                    object.total++;
+                    progress.total++;
                 }
                 if (lastTime - performance.now() > 500)
-                    await object.progress("Scanning files");
+                    await progress.update("Scanning files");
             }
-            await object.progress("Scanned files");
+            await progress.update("Scanned files");
         },
-    };
+    });
     const stream = fast_glob_1.default.stream(options.glob.include, {
         dot: true,
         markDirectories: true,
         stats: true,
         ...options.glob,
     });
-    return object;
+    return progress;
 }
 exports.createFileScanner = createFileScanner;
 function createWriteStreamPool(options) {
@@ -560,3 +568,10 @@ async function safeRename(oldPath, newPath) {
     }
 }
 exports.safeRename = safeRename;
+async function tryRm(path) {
+    try {
+        await (0, promises_1.rm)(path);
+    }
+    catch (_) { }
+}
+exports.tryRm = tryRm;

package/utils/http.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="node" />
+import { IncomingMessage, Server } from "http";
+export declare function closeServer(server: Server): Promise<void>;
+export declare function readRequestData(req: IncomingMessage): Promise<string | undefined>;
+export declare function fetchJson<T = any>(url: string, options?: {
+    headers?: Record<string, string>;
+    query?: Record<string, string>;
+}): Promise<T>;
+export declare function post(url: string, data: string, options?: {
+    headers?: Record<string, string>;
+    query?: Record<string, string>;
+}): Promise<void>;
+export declare function downloadFile(url: string, output: string, options?: {
+    headers?: Record<string, string>;
+    query?: Record<string, string>;
+    timeout?: number;
+}): Promise<void>;
+export declare function uploadFile(url: string, path: string, options?: {
+    headers?: Record<string, string>;
+    query?: Record<string, string>;
+}): Promise<void>;

package/utils/http.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadFile = exports.downloadFile = exports.post = exports.fetchJson = exports.readRequestData = exports.closeServer = void 0;
+const fs_1 = require("fs");
+const promises_1 = require("fs/promises");
+const http_1 = require("http");
+const https_1 = require("https");
+const request = (url, options, callback) => {
+    return url.startsWith("https://")
+        ? (0, https_1.request)(url, options, callback)
+        : (0, http_1.request)(url, options, callback);
+};
+function href(inUrl, query) {
+    const url = new URL(inUrl);
+    for (const key in query || {})
+        url.searchParams.set(key, query[key]);
+    return url.href;
+}
+async function closeServer(server) {
+    await new Promise((resolve, reject) => server.close((error) => (error ? reject(error) : resolve())));
+}
+exports.closeServer = closeServer;
+function readRequestData(req) {
+    let data;
+    return new Promise((resolve, reject) => {
+        req
+            .on("error", reject)
+            .on("data", (chunk) => {
+            if (data === undefined)
+                data = "";
+            data += chunk;
+        })
+            .on("close", async () => {
+            resolve(data);
+        });
+    });
+}
+exports.readRequestData = readRequestData;
+async function fetchJson(url, options = {}) {
+    return new Promise((resolve, reject) => {
+        let data;
+        request(href(url, options.query), {
+            method: "GET",
+            headers: options.headers,
+        }, (res) => {
+            if (res.statusCode !== 200)
+                return reject(new Error(`GET failed: ${res.statusCode} ${res.statusMessage}`));
+            res
+                .on("data", (chunk) => {
+                if (data === undefined)
+                    data = "";
+                data += chunk;
+            })
+                .on("error", reject)
+                .on("close", () => {
+                if (data === undefined) {
+                    resolve(undefined);
+                }
+                else {
+                    try {
+                        resolve(JSON.parse(data));
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
+                }
+            });
+        })
+            .on("error", reject)
+            .end();
+    });
+}
+exports.fetchJson = fetchJson;
+async function post(url, data, options = {}) {
+    await new Promise((resolve, reject) => {
+        const req = request(href(url, options.query), { method: "POST", headers: options.headers }, (res) => {
+            res.on("error", reject);
+            if (res.statusCode !== 200) {
+                reject(new Error(`Post failed: ${res.statusCode} ${res.statusMessage}`));
+            }
+            else {
+                resolve();
+            }
+        });
+        req.on("error", reject);
+        req.write(data);
+        req.end();
+    });
+}
+exports.post = post;
+async function downloadFile(url, output, options = {}) {
+    const timeout = options.timeout ?? 3600 * 100;
+    const file = (0, fs_1.createWriteStream)(output);
+    await new Promise((resolve, reject) => {
+        const req = request(href(url, options.query), {
+            headers: options.headers,
+        }, (res) => {
+            if (res.statusCode === 200) {
+                res
+                    .on("error", async (error) => {
+                    file.destroy();
+                    try {
+                        await (0, promises_1.unlink)(output);
+                    }
+                    catch (_) { }
+                    reject(error);
+                })
+                    .pipe(file);
+                file.on("finish", () => {
+                    file.close((error) => {
+                        error ? reject(error) : resolve();
+                    });
+                });
+            }
+            else {
+                reject(new Error(`Download failed: ${res.statusCode} ${res.statusMessage}`));
+            }
+        }).on("error", async (error) => {
+            try {
+                await (0, promises_1.unlink)(output);
+            }
+            catch (_) { }
+            reject(error);
+        });
+        req.setTimeout(timeout, () => {
+            req.destroy();
+            reject(new Error(`Request timeout after ${timeout / 1000}s`));
+        });
+        req.end();
+    });
+}
+exports.downloadFile = downloadFile;
+async function uploadFile(url, path, options = {}) {
+    const { size } = await (0, promises_1.stat)(path);
+    const readStream = (0, fs_1.createReadStream)(path);
+    await new Promise((resolve, reject) => {
+        const req = request(href(url, options.query), {
+            method: "POST",
+            headers: {
+                ...options.headers,
+                "Content-length": size,
+            },
+        }, (res) => {
+            if (res.statusCode !== 200) {
+                reject(new Error(`Upload failed: ${res.statusCode} ${res.statusMessage}`));
+            }
+            else {
+                resolve();
+            }
+        }).on("error", reject);
+        readStream.on("error", reject).pipe(req);
+    });
+}
+exports.uploadFile = uploadFile;

package/utils/virtual-fs.d.ts

@@ -0,0 +1,33 @@
+export declare function resolvePath(path: string): string;
+export type FsOptions = {
+    backend: string;
+};
+export declare abstract class AbstractFs {
+    readonly options: FsOptions;
+    constructor(options: FsOptions);
+    resolvePath(path: string): string;
+    abstract isLocal(): boolean;
+    abstract existsDir(path: string): Promise<boolean>;
+    abstract mkdir(path: string): Promise<void>;
+    abstract readFile(path: string): Promise<string>;
+    abstract rmAll(path: string): Promise<void>;
+    abstract readFileIfExists(path: string): Promise<string | undefined>;
+    abstract readdir(path: string): Promise<string[]>;
+    abstract ensureEmptyDir(path: string): Promise<void>;
+    abstract writeFile(path: string, contents: string): Promise<void>;
+    abstract upload(url: string, path: string): Promise<void>;
+    abstract download(url: string, path: string): Promise<void>;
+}
+export declare class LocalFs extends AbstractFs {
+    isLocal(): boolean;
+    existsDir(path: string): Promise<boolean>;
+    mkdir(path: string): Promise<void>;
+    ensureEmptyDir(path: string): Promise<void>;
+    readFile(path: string): Promise<string>;
+    readFileIfExists(inPath: string): Promise<string | undefined>;
+    readdir(path: string): Promise<string[]>;
+    writeFile(path: string, contents: string): Promise<void>;
+    rmAll(path: string): Promise<void>;
+    upload(source: string, target: string): Promise<void>;
+    download(source: string, target: string): Promise<void>;
+}

package/utils/virtual-fs.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalFs = exports.AbstractFs = exports.resolvePath = void 0;
+const fs_1 = require("./fs");
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+function resolvePath(path) {
+    const { pathname } = new URL(`file:///${path}`);
+    return pathname;
+}
+exports.resolvePath = resolvePath;
+class AbstractFs {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    resolvePath(path) {
+        return (0, path_1.resolve)((0, path_1.join)(this.options.backend ?? ".", resolvePath(path)));
+    }
+}
+exports.AbstractFs = AbstractFs;
+class LocalFs extends AbstractFs {
+    isLocal() {
+        return true;
+    }
+    async existsDir(path) {
+        return (0, fs_1.existsDir)(this.resolvePath(path));
+    }
+    async mkdir(path) {
+        await (0, fs_1.mkdirIfNotExists)(this.resolvePath(path));
+    }
+    async ensureEmptyDir(path) {
+        await (0, fs_1.ensureEmptyDir)(this.resolvePath(path));
+    }
+    async readFile(path) {
+        return (await (0, promises_1.readFile)(this.resolvePath(path))).toString();
+    }
+    async readFileIfExists(inPath) {
+        return (await (0, fs_1.existsFile)(this.resolvePath(inPath)))
+            ? await this.readFile(inPath)
+            : undefined;
+    }
+    async readdir(path) {
+        return await (0, promises_1.readdir)(this.resolvePath(path));
+    }
+    async writeFile(path, contents) {
+        await (0, promises_1.writeFile)(this.resolvePath(path), contents);
+    }
+    async rmAll(path) {
+        await (0, promises_1.rm)(this.resolvePath(path), { recursive: true });
+    }
+    async upload(source, target) {
+        await (0, promises_1.cp)(source, this.resolvePath(target));
+    }
+    async download(source, target) {
+        await (0, promises_1.cp)(this.resolvePath(source), target);
+    }
+}
+exports.LocalFs = LocalFs;