@datatruck/cli 0.41.3 → 0.41.4

package/lib/repositories/ResticRepository.js

@@ -96,7 +96,6 @@ class ResticRepository extends RepositoryAbstract_1.RepositoryAbstract {
             log: data.options.verbose,
         });
         const result = await restic.snapshots({
-            json: true,
             tags: [
                 ...(data.options.ids?.map((id) => ResticRepository.createSnapshotTag(id.length === 8 ? RepositoryAbstract_1.SnapshotTagEnum.SHORT_ID : RepositoryAbstract_1.SnapshotTagEnum.ID, id)) ?? []),
             ],
@@ -196,7 +195,6 @@ class ResticRepository extends RepositoryAbstract_1.RepositoryAbstract {
             },
         });
         const [lastSnapshot] = await restic.snapshots({
-            json: true,
             tags: [packageTag],
             latest: 1,
         });
@@ -289,18 +287,14 @@ class ResticRepository extends RepositoryAbstract_1.RepositoryAbstract {
         if (!snapshot)
             throw new error_1.AppError(`Snapshot not found`);
         const restic = new restic_1.Restic({
-            env: {
-                ...(await this.buildEnv()),
-                ...(typeof config.password === "string"
-                    ? { RESTIC_PASSWORD2: config.password }
-                    : { RESTIC_PASSWORD_FILE2: (0, path_1.resolve)(config.password.path) }),
-                RESTIC_REPOSITORY2: await restic_1.Restic.formatRepository(config.repository),
-            },
+            env: await this.buildEnv(),
             log: data.options.verbose,
         });
         let bytes = 0;
         await restic.copy({
-            id: snapshot.originalId,
+            ids: [snapshot.originalId],
+            fromRepo: await restic_1.Restic.formatRepository(config.repository),
+            fromRepoPassword: config.password,
             onStream(data) {
                 if (data.message_type === "status") {
                     bytes = data.total_bytes;

package/lib/utils/restic.d.ts

@@ -40,16 +40,24 @@ export type ResticBackupStream = {
 export declare class Restic {
     readonly options: {
         log?: boolean;
-        env: Record<string, string>;
+        env: {
+            RESTIC_REPOSITORY: string;
+            RESTIC_PASSWORD?: string;
+            RESTIC_PASSWORD_FILE?: string;
+        };
     };
     constructor(options: {
         log?: boolean;
-        env: Record<string, string>;
+        env: {
+            RESTIC_REPOSITORY: string;
+            RESTIC_PASSWORD?: string;
+            RESTIC_PASSWORD_FILE?: string;
+        };
     });
     static formatRepository(input: ResticRepositoryUri, hidePassword?: boolean): Promise<string>;
     private createProcess;
     exec(args: string[], options?: AsyncProcessOptions): Promise<number>;
-    private stdout;
+    json<T>(args: string[], options?: AsyncProcessOptions): Promise<T>;
     checkRepository(): Promise<boolean>;
     forget(options: {
         snapshotId?: string;
@@ -63,13 +71,16 @@ export declare class Restic {
         keepTag?: string[];
         tag?: string[];
         prune?: boolean;
+        args?: string[];
     }): Promise<void>;
     snapshots(options: {
+        ids?: string[];
         tags?: string[];
         paths?: string[];
         latest?: number;
         json?: boolean;
-        snapshotIds?: string[];
+        group?: ("path" | "tags" | "host")[];
+        args?: string[];
     }): Promise<{
         time: string;
         tree: string;
@@ -92,10 +103,16 @@ export declare class Restic {
         allowEmptySnapshot?: boolean;
         onStream?: (data: ResticBackupStream) => void;
         createEmptyDir?: () => Promise<string>;
+        args?: string[];
     }): Promise<void>;
     copy(options: {
-        id: string;
+        ids: string[];
+        fromRepo?: string;
+        fromRepoPassword?: string | {
+            path: string;
+        };
         onStream?: (data: ResticBackupStream) => void;
+        args?: string[];
     }): Promise<void>;
     restore(options: {
         id: string;
@@ -105,5 +122,6 @@ export declare class Restic {
          */
         progressInterval?: number | false;
         onStream?: (data: ResticBackupStream) => void;
+        args?: string[];
     }): Promise<AsyncProcess>;
 }

package/lib/utils/restic.js

@@ -1,9 +1,62 @@
 "use strict";
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Restic = void 0;
 const async_process_1 = require("./async-process");
 const fs_1 = require("./fs");
 const string_1 = require("./string");
+const temp_1 = require("./temp");
 const promises_1 = require("fs/promises");
 const path_1 = require("path");
 const emptySnapshotTag = "empty-snapshot";
@@ -31,7 +84,8 @@ class Restic {
     createProcess(args, options) {
         return new async_process_1.AsyncProcess("restic", args, {
             stdio: ["ignore", "pipe", "pipe"],
-            env: { ...process.env, ...this.options.env },
+            ...(options ?? {}),
+            env: { ...process.env, ...this.options.env, ...options?.env },
             $log: this.options.log
                 ? {
                     exec: true,
@@ -46,14 +100,14 @@ class Restic {
                     ],
                 }
                 : {},
-            ...(options ?? {}),
         });
     }
     async exec(args, options) {
         return await this.createProcess(args, options).waitForClose();
     }
-    async stdout(args, options) {
-        return await this.createProcess(args, options).stdout.fetch();
+    async json(args, options) {
+        const stdout = await this.createProcess(args, options).stdout.fetch();
+        return JSON.parse(stdout);
     }
     async checkRepository() {
         return ((await this.exec(["cat", "config"], {
@@ -87,19 +141,22 @@ class Restic {
                 : []),
             ...(options.tag ? options.tag.flatMap((v) => ["--tag", v]) : []),
             ...(options.prune ? ["--prune"] : []),
+            ...(options.args || []),
             ...(options.snapshotId ? [options.snapshotId] : []),
         ]);
     }
     async snapshots(options) {
-        const json = await this.stdout([
+        const json = options.json ?? true;
+        return await this.json([
             "snapshots",
+            ...(json ? ["--json"] : []),
             ...(options.tags?.flatMap((tag) => [`--tag`, tag]) ?? []),
-            ...(options.json ? ["--json"] : []),
             ...(options.paths?.flatMap((path) => ["--path", path]) ?? []),
+            ...(options.group ? ["--group-by", options.group.join(",")] : []),
             ...(options.latest ? ["--latest", options.latest.toString()] : []),
-            ...(options.snapshotIds || []),
+            ...(options.args || []),
+            ...(options.ids || []),
         ]);
-        return JSON.parse(json);
     }
     async backup(options) {
         try {
@@ -111,6 +168,7 @@ class Restic {
                 ...(options.tags?.flatMap((v) => ["--tag", v]) ?? []),
                 ...(options.setPaths?.flatMap((v) => ["--set-path", v]) ?? []),
                 ...(options.parent ? ["--parent", options.parent] : []),
+                ...(options.args || []),
                 ...options.paths,
             ], { cwd: options.cwd });
             if (options.onStream) {
@@ -151,16 +209,51 @@ class Restic {
         }
     }
     async copy(options) {
-        const copy = this.createProcess(["copy", "--json", options.id]);
-        if (options.onStream) {
-            await copy.stdout.parseLines((line) => {
-                if (line.startsWith("{") && line.endsWith("}")) {
-                    options.onStream?.(JSON.parse(line));
-                }
+        const env_1 = { stack: [], error: void 0, hasError: false };
+        try {
+            const rawPassword = typeof options.fromRepoPassword === "string"
+                ? options.fromRepoPassword
+                : undefined;
+            const fromPasswordDir = __addDisposableResource(env_1, rawPassword
+                ? await (0, temp_1.useTempDir)("restic-copy")
+                : undefined, true);
+            const fromPasswordFile = fromPasswordDir
+                ? (0, path_1.join)(fromPasswordDir.path, "password.txt")
+                : !!options.fromRepoPassword &&
+                    typeof options.fromRepoPassword !== "string"
+                    ? options.fromRepoPassword.path
+                    : undefined;
+            if (fromPasswordFile && rawPassword)
+                await (0, promises_1.writeFile)(fromPasswordFile, rawPassword);
+            const copy = this.createProcess([
+                "copy",
+                "--json",
+                ...(fromPasswordFile ? ["--from-password-file", fromPasswordFile] : []),
+                ...(options.fromRepo ? ["--from-repo", options.fromRepo] : []),
+                ...(options.args || []),
+                ...options.ids,
+            ], {
+                env: {},
             });
+            if (options.onStream) {
+                await copy.stdout.parseLines((line) => {
+                    if (line.startsWith("{") && line.endsWith("}")) {
+                        options.onStream?.(JSON.parse(line));
+                    }
+                });
+            }
+            else {
+                await copy.waitForClose();
+            }
+        }
+        catch (e_1) {
+            env_1.error = e_1;
+            env_1.hasError = true;
         }
-        else {
-            await copy.waitForClose();
+        finally {
+            const result_1 = __disposeResources(env_1);
+            if (result_1)
+                await result_1;
         }
     }
     async restore(options) {
@@ -180,8 +273,7 @@ class Restic {
             }
         }
         const snapshots = await this.snapshots({
-            snapshotIds: [options.id],
-            json: true,
+            ids: [options.id],
         });
         if (typeof progressInterval === "number")
             progressRutine();
@@ -192,6 +284,7 @@ class Restic {
                 options.id,
                 "--target",
                 options.target,
+                ...(options.args || []),
             ]);
             if (options.onStream) {
                 await result.stdout.parseLines((line) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@datatruck/cli",
-  "version": "0.41.3",
+  "version": "0.41.4",
   "description": "Tool for creating and managing backups",
   "homepage": "https://github.com/swordev/datatruck#readme",
   "bugs": {