@datatruck/cli 0.34.0 → 0.34.1

package/lib/repositories/ResticRepository.js

@@ -316,7 +316,7 @@ class ResticRepository extends RepositoryAbstract_1.RepositoryAbstract {
         await restic.restore({
             id: snapshot.originalId,
             target: restorePath,
-            onStream: async (streamData) => {
+            onStream: (streamData) => {
                 if (streamData.message_type === "restore-status") {
                     const current = Math.min(streamData.total_bytes, snapshot.size);
                     data.onProgress({

package/lib/tasks/GitTask.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GitTask = exports.gitTaskName = void 0;
+const async_process_1 = require("../utils/async-process");
 const cli_1 = require("../utils/cli");
 const fs_1 = require("../utils/fs");
 const math_1 = require("../utils/math");
-const process_1 = require("../utils/process");
 const temp_1 = require("../utils/temp");
 const TaskAbstract_1 = require("./TaskAbstract");
 const assert_1 = require("assert");
@@ -12,7 +12,6 @@ const fs_2 = require("fs");
 const promises_1 = require("fs/promises");
 const micromatch_1 = require("micromatch");
 const path_1 = require("path");
-const readline_1 = require("readline");
 exports.gitTaskName = "git";
 class GitTask extends TaskAbstract_1.TaskAbstract {
     verbose;
@@ -34,10 +33,9 @@ class GitTask extends TaskAbstract_1.TaskAbstract {
                 description: "Creating bundle",
             },
         });
-        await (0, process_1.exec)(this.command, ["bundle", "create", bundlePath, "--all"], {
+        await async_process_1.AsyncProcess.exec(this.command, ["bundle", "create", bundlePath, "--all"], {
             cwd: path,
-        }, {
-            log: this.verbose,
+            $log: this.verbose,
         });
         // Config
         if (this.config.includeConfig ?? true) {
@@ -70,48 +68,33 @@ class GitTask extends TaskAbstract_1.TaskAbstract {
                 continue;
             option.pathsPath = (0, path_1.join)(snapshotPath, `repo.${option.name}-paths.txt`);
             const stream = (0, fs_2.createWriteStream)(option.pathsPath);
-            let streamError;
-            stream.on("error", (e) => (streamError = e));
-            try {
-                await (0, process_1.exec)(this.command, [
-                    "-c",
-                    "core.quotepath=off",
-                    "ls-files",
-                    ...option.argv,
-                    "--exclude-standard",
-                ], {
-                    cwd: data.package.path,
-                }, {
-                    log: {
-                        exec: this.verbose,
-                    },
-                    onSpawn: (p) => {
-                        const iface = (0, readline_1.createInterface)(p.stdout, stream);
-                        iface.on("close", () => stream.end());
-                        iface.on("line", (path) => {
-                            path = path.trim();
-                            if (!path.length)
-                                return;
-                            let found = false;
-                            if (option.include === true) {
-                                found = true;
-                            }
-                            else if (option.include) {
-                                found = (0, micromatch_1.isMatch)(path, option.include);
-                            }
-                            if (found) {
-                                total++;
-                                stream.write(`${path}\n`);
-                            }
-                        });
-                    },
-                });
-            }
-            finally {
-                await new Promise((resolve) => stream.end(resolve));
-                if (streamError)
-                    throw streamError;
-            }
+            const p = new async_process_1.AsyncProcess(this.command, [
+                "-c",
+                "core.quotepath=off",
+                "ls-files",
+                ...option.argv,
+                "--exclude-standard",
+            ], {
+                cwd: data.package.path,
+                $log: this.verbose,
+            });
+            await Promise.all([
+                p.stdout.parseLines((path) => {
+                    let found = false;
+                    if (option.include === true) {
+                        found = true;
+                    }
+                    else if (option.include) {
+                        found = (0, micromatch_1.isMatch)(path, option.include);
+                    }
+                    if (found) {
+                        total++;
+                        stream.write(`${path}\n`);
+                    }
+                }),
+                p.child.on("close", () => stream.end()),
+                (0, fs_1.waitForClose)(stream),
+            ]);
         }
         // Copy
         for (const option of lsFilesConfig) {
@@ -176,10 +159,9 @@ class GitTask extends TaskAbstract_1.TaskAbstract {
         };
         // Bundle
         const bundlePath = (0, path_1.join)(snapshotPath, "repo.bundle");
-        await (0, process_1.exec)(this.command, ["clone", bundlePath, "."], {
+        await async_process_1.AsyncProcess.exec(this.command, ["clone", bundlePath, "."], {
             cwd: restorePath,
-        }, {
-            log: this.verbose,
+            $log: this.verbose,
         });
         await incrementProgress();
         // Config

package/lib/tasks/MariadbTask.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MariadbTask = exports.mariadbTaskName = void 0;
+const async_process_1 = require("../utils/async-process");
 const cli_1 = require("../utils/cli");
 const fs_1 = require("../utils/fs");
 const math_1 = require("../utils/math");
-const process_1 = require("../utils/process");
 const tar_1 = require("../utils/tar");
 const temp_1 = require("../utils/temp");
 const TaskAbstract_1 = require("./TaskAbstract");
@@ -92,15 +92,15 @@ class MariadbTask extends TaskAbstract_1.TaskAbstract {
         await (0, fs_1.forEachFile)(sourcePath, () => {
             total++;
         });
-        let p1;
         let lastLineText;
+        const controller = new AbortController();
         const pathRegex = /((Copying|Streaming) .+) to/;
         const onData = async (line) => {
             const { text } = parseLine(line);
             lastLineText = text;
             if (line.includes("[ERROR] InnoDB: Unsupported redo log format.") ||
                 line.includes("Error: cannot read redo log header")) {
-                p1.kill();
+                controller.abort();
             }
             else {
                 const matches = pathRegex.exec(text);
@@ -121,41 +121,34 @@ class MariadbTask extends TaskAbstract_1.TaskAbstract {
         const stats = { xbFiles: total };
         await (0, promises_1.writeFile)((0, path_1.join)(snapshotPath, "stats.dtt.json"), JSON.stringify(stats));
         if (compress) {
-            const p0 = (0, fs_2.createWriteStream)((0, path_1.join)(snapshotPath, "db.xb.gz"));
-            p1 = (0, process_1.createProcess)(command, args, {
+            const fileStream = (0, fs_2.createWriteStream)((0, path_1.join)(snapshotPath, "db.xb.gz"));
+            const dumpProcess = new async_process_1.AsyncProcess(command, args, {
                 $log: {
                     exec: this.verbose,
                     stderr: this.verbose,
                 },
-                $stderr: {
-                    parseLines: true,
-                    onData,
-                },
-                $onExitCode: (code) => `Exit code: ${code} - ${lastLineText}`,
+                $controller: controller,
+                $exitCode: (code) => `Exit code: ${code} - ${lastLineText}`,
             });
-            const p2 = (0, process_1.createProcess)(compress.command, compress.args);
-            p1.stdout.pipe(p2.stdin, { end: true });
-            p2.stdout.pipe(p0, { end: true });
-            await Promise.all([p1, p2, (0, fs_1.waitForClose)(p0)]);
+            const compressProcess = new async_process_1.AsyncProcess(compress.command, compress.args);
+            await Promise.all([
+                dumpProcess.stdout.pipe(compressProcess.stdin),
+                dumpProcess.stderr.parseLines(onData),
+                compressProcess.stdout.pipe(fileStream),
+            ]);
         }
         else {
-            p1 = (0, process_1.createProcess)(command, args, {
+            const dumpProcess = new async_process_1.AsyncProcess(command, args, {
                 $log: this.verbose,
-                $stdout: {
-                    parseLines: true,
-                    onData,
-                },
-                $stderr: {
-                    parseLines: true,
-                    onData,
-                },
-                $onExitCode: (code) => `Exit code: ${code} - ${lastLineText}`,
-            });
-            await p1;
-            await (0, process_1.exec)(command, [`--prepare`, `--target-dir=${snapshotPath}`], undefined, {
-                log: this.verbose,
-                stderr: { onData: () => { } },
+                $controller: controller,
+                $exitCode: (code) => `Exit code: ${code} - ${lastLineText}`,
             });
+            await Promise.all([
+                dumpProcess.stdout.parseLines(onData),
+                dumpProcess.stderr.parseLines(onData),
+            ]);
+            const prepareProcess = new async_process_1.AsyncProcess(command, [`--prepare`, `--target-dir=${snapshotPath}`], { $log: this.verbose });
+            await prepareProcess.waitForClose();
         }
         return { snapshotPath };
     }
@@ -230,29 +223,25 @@ class MariadbTask extends TaskAbstract_1.TaskAbstract {
             });
             let currentXbFiles = 0;
             const { parallel } = normalizeConfig({ parallel: this.config.parallel });
-            const p1 = (0, process_1.createProcess)("mbstream", ["-x", "-C", snapshotPath, "-v", "-p", parallel], {
-                $log: this.verbose,
-                $stderr: {
-                    parseLines: true,
-                    onData(line) {
-                        const { text: path } = parseLine(line);
-                        data.onProgress({
-                            absolute,
-                            relative: {
-                                payload: path,
-                                format: "amount",
-                                current: ++currentXbFiles,
-                                total: stats?.xbFiles,
-                                percent: stats?.xbFiles
-                                    ? (0, math_1.progressPercent)(stats.xbFiles, currentXbFiles)
-                                    : undefined,
-                            },
-                        });
-                    },
-                },
-            });
-            xbStream.pipe(p1.stdin, { end: true });
-            await Promise.all([(0, fs_1.waitForClose)(xbStream), p1]);
+            const p1 = new async_process_1.AsyncProcess("mbstream", ["-x", "-C", snapshotPath, "-v", "-p", parallel], { $log: this.verbose });
+            await Promise.all([
+                p1.stdin.pipe(xbStream),
+                p1.stderr.parseLines((line) => {
+                    const { text: path } = parseLine(line);
+                    data.onProgress({
+                        absolute,
+                        relative: {
+                            payload: path,
+                            format: "amount",
+                            current: ++currentXbFiles,
+                            total: stats?.xbFiles,
+                            percent: stats?.xbFiles
+                                ? (0, math_1.progressPercent)(stats.xbFiles, currentXbFiles)
+                                : undefined,
+                        },
+                    });
+                }),
+            ]);
         }
         // Prepare
         absolute.current++;
@@ -262,10 +251,8 @@ class MariadbTask extends TaskAbstract_1.TaskAbstract {
             data.onProgress({
                 absolute,
             });
-            await (0, process_1.exec)(this.command, [`--prepare`, `--target-dir=${snapshotPath}`], undefined, {
-                log: this.verbose,
-                stderr: { onData: () => { } },
-            });
+            const p = new async_process_1.AsyncProcess(this.command, [`--prepare`, `--target-dir=${snapshotPath}`], { $log: this.verbose });
+            await p.waitForClose();
         }
         await reloadFiles();
         removeFiles.push(...files.filter((file) => file.startsWith("ib_logfile")));

package/lib/tasks/MssqlTask.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MssqlTask = exports.mssqlTaskName = void 0;
+const async_process_1 = require("../utils/async-process");
 const config_1 = require("../utils/datatruck/config");
 const error_1 = require("../utils/datatruck/error");
 const fs_1 = require("../utils/fs");
-const process_1 = require("../utils/process");
 const temp_1 = require("../utils/temp");
 const TaskAbstract_1 = require("./TaskAbstract");
 const promises_1 = require("fs/promises");
@@ -18,7 +18,7 @@ class MssqlTask extends TaskAbstract_1.TaskAbstract {
         return this.config.command ?? "sqlcmd";
     }
     async exec(query) {
-        const result = await (0, process_1.exec)(this.command, [
+        const stdout = await async_process_1.AsyncProcess.stdout(this.command, [
             ...(this.config.hostname ? ["-S", this.config.hostname] : []),
             ...(this.config.username ? ["-U", this.config.username] : []),
             ...(this.config.passwordFile
@@ -32,16 +32,10 @@ class MssqlTask extends TaskAbstract_1.TaskAbstract {
             "999",
             "-Q",
             `SET nocount ON; ${query.replace(/[\n\t]/g, " ")}`,
-        ], undefined, {
-            log: this.verbose,
-            stderr: {
-                toExitCode: true,
-            },
-            stdout: {
-                save: true,
-            },
+        ], {
+            $log: this.verbose,
         });
-        return result.stdout
+        return stdout
             .split(/\n/g)
             .map((row) => row.split(","))
             .filter((row) => row.length);

package/lib/tasks/MysqlDumpTask.js

@@ -80,7 +80,7 @@ class MysqlDumpTask extends TaskAbstract_1.TaskAbstract {
                                 sharedPath: tableSharedPath,
                                 items: [tableName],
                                 database: this.config.database,
-                                onSpawn: (p) => (controller.stop = () => p.kill()),
+                                controller,
                             });
                             const files = await (0, promises_1.readdir)(tableSharedPath);
                             const schemaFile = `${tableName}.sql`;
@@ -106,7 +106,7 @@ class MysqlDumpTask extends TaskAbstract_1.TaskAbstract {
                             output: outPath,
                             items: [tableName],
                             database: this.config.database,
-                            onSpawn: (p) => (controller.stop = () => p.kill()),
+                            controller,
                             ...(concurrency === 1 && {
                                 onProgress(progress) {
                                     data.onProgress({
@@ -256,7 +256,7 @@ class MysqlDumpTask extends TaskAbstract_1.TaskAbstract {
                     await sql.importFile({
                         path,
                         database: database.name,
-                        onSpawn: (p) => (controller.stop = () => p.kill()),
+                        controller,
                     });
                 }
                 finally {
@@ -306,7 +306,7 @@ class MysqlDumpTask extends TaskAbstract_1.TaskAbstract {
                         path: csvFile,
                         database: database.name,
                         table: tableName,
-                        onSpawn: (p) => (controller.stop = () => p.kill()),
+                        controller,
                     });
                 }
                 finally {

package/lib/tasks/PostgresqlDumpTask.d.ts

@@ -5,7 +5,7 @@ export declare class PostgresqlDumpTask extends SqlDumpTaskAbstract<PostgresqlDu
     buildConnectionArgs(database?: string): Promise<string[]>;
     onDatabaseIsEmpty(name: string): Promise<boolean>;
     onCreateDatabase(database: TargetDatabase): Promise<void>;
-    onExecQuery(query: string): Promise<import("../utils/process").ExecResult>;
+    onExecQuery(query: string): Promise<string>;
     onFetchTableNames(database: string): Promise<string[]>;
     onExportTables(tableNames: string[], output: string, onProgress: (progress: {
         totalBytes: number;

package/lib/tasks/PostgresqlDumpTask.js

@@ -1,9 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PostgresqlDumpTask = exports.postgresqlDumpTaskName = void 0;
-const process_1 = require("../utils/process");
+const async_process_1 = require("../utils/async-process");
 const SqlDumpTaskAbstract_1 = require("./SqlDumpTaskAbstract");
-const fs_1 = require("fs");
 const path_1 = require("path");
 exports.postgresqlDumpTaskName = "postgresql-dump";
 class PostgresqlDumpTask extends SqlDumpTaskAbstract_1.SqlDumpTaskAbstract {
@@ -41,20 +40,12 @@ class PostgresqlDumpTask extends SqlDumpTaskAbstract_1.SqlDumpTaskAbstract {
         await this.onExecQuery(query);
     }
     async onExecQuery(query) {
-        return await (0, process_1.exec)("psql", [
+        return await async_process_1.AsyncProcess.stdout("psql", [
             ...(await this.buildConnectionArgs()),
             "-t",
             "-c",
             query.replace(/\s{1,}/g, " "),
-        ], undefined, {
-            log: this.verbose,
-            stderr: {
-                toExitCode: true,
-            },
-            stdout: {
-                save: true,
-            },
-        });
+        ], { $log: this.verbose });
     }
     async onFetchTableNames(database) {
         return await this.fetchValues(`
@@ -70,31 +61,17 @@ class PostgresqlDumpTask extends SqlDumpTaskAbstract_1.SqlDumpTaskAbstract {
 	  `);
     }
     async onExportTables(tableNames, output, onProgress) {
-        const stream = (0, fs_1.createWriteStream)(output);
-        await Promise.all([
-            new Promise((resolve, reject) => {
-                stream.on("close", resolve);
-                stream.on("error", reject);
-            }),
-            (0, process_1.exec)("pg_dump", [
-                ...(await this.buildConnectionArgs(this.config.database)),
-                ...(tableNames?.flatMap((v) => ["-t", v]) ?? []),
-            ], null, {
-                pipe: { stream, onWriteProgress: onProgress },
-                stderr: {
-                    toExitCode: true,
-                },
-                log: this.verbose,
-            }),
-        ]);
+        const dumpProcess = new async_process_1.AsyncProcess("pg_dump", [
+            ...(await this.buildConnectionArgs(this.config.database)),
+            ...(tableNames?.flatMap((v) => ["-t", v]) ?? []),
+        ], { $log: this.verbose });
+        await dumpProcess.stdout.pipe(output, onProgress);
     }
     async onExportStoredPrograms() {
         throw new Error(`Method not implemented: onExportStoredPrograms`);
     }
     async onImport(path, database) {
-        await (0, process_1.exec)("psql", [...(await this.buildConnectionArgs(database)), "-f", (0, path_1.normalize)(path)], undefined, {
-            log: this.verbose,
-        });
+        await async_process_1.AsyncProcess.exec("psql", [...(await this.buildConnectionArgs(database)), "-f", (0, path_1.normalize)(path)], { $log: this.verbose });
     }
 }
 exports.PostgresqlDumpTask = PostgresqlDumpTask;

package/lib/tasks/SqlDumpTaskAbstract.d.ts

@@ -1,4 +1,3 @@
-import { exec } from "../utils/process";
 import { TaskBackupData, TaskPrepareRestoreData, TaskRestoreData, TaskAbstract } from "./TaskAbstract";
 export type TargetDatabase = {
     name: string;
@@ -29,7 +28,7 @@ export declare abstract class SqlDumpTaskAbstract<TConfig extends SqlDumpTaskCon
     abstract onCreateDatabase(database: TargetDatabase): Promise<void>;
     abstract onDatabaseIsEmpty(databaseName: string): Promise<boolean>;
     abstract onFetchTableNames(database: string): Promise<string[]>;
-    abstract onExecQuery(query: string): ReturnType<typeof exec>;
+    abstract onExecQuery(query: string): Promise<string>;
     abstract onExportTables(tableNames: string[], output: string, onProgress: (data: {
         totalBytes: number;
     }) => void): Promise<void>;

package/lib/tasks/SqlDumpTaskAbstract.js

@@ -56,7 +56,7 @@ class SqlDumpTaskAbstract extends TaskAbstract_1.TaskAbstract {
     }
     async fetchValues(query) {
         const result = await this.onExecQuery(query);
-        return result.stdout.split(/\r?\n/).reduce((result, value) => {
+        return result.split(/\r?\n/).reduce((result, value) => {
             value = value.trim();
             if (value.length)
                 result.push(value);

package/lib/utils/Git.d.ts

@@ -1,4 +1,4 @@
-import { ExecSettingsInterface } from "./process";
+import { AsyncProcessOptions } from "./async-process";
 export declare class Git {
     readonly options: {
         dir: string;
@@ -8,22 +8,24 @@ export declare class Git {
         dir: string;
         log?: boolean;
     });
-    exec(args: string[], settings?: ExecSettingsInterface, cwd?: boolean): Promise<import("./process").ExecResult>;
+    private createProcess;
+    exec(args: string[], options?: AsyncProcessOptions): Promise<number>;
+    private stdout;
     canBeInit(repo: string): Promise<boolean>;
     clone(options: {
         repo: string;
         branch?: string;
         orphan?: boolean;
-    }): Promise<import("./process").ExecResult>;
+    }): Promise<void>;
     checkout(options: {
         branchName: string;
         orphan?: boolean;
-    }): Promise<import("./process").ExecResult>;
+    }): Promise<void>;
     checkBranch(options: {
         name: string;
         repo?: string;
     }): Promise<boolean>;
-    removeAll(): Promise<import("./process").ExecResult>;
+    removeAll(): Promise<void>;
     haveChanges(): Promise<boolean>;
     fetchCommitId(tag: string): Promise<string>;
     getTags(names?: string[]): Promise<{
@@ -31,8 +33,8 @@ export declare class Git {
         message?: string | undefined;
     }[]>;
     addTag(name: string, message?: string): Promise<void>;
-    pushTags(): Promise<import("./process").ExecResult>;
+    pushTags(): Promise<void>;
     push(options: {
         branchName: string;
-    }): Promise<import("./process").ExecResult>;
+    }): Promise<void>;
 }

package/lib/utils/Git.js

@@ -1,25 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Git = void 0;
+const async_process_1 = require("./async-process");
 const fs_1 = require("./fs");
-const process_1 = require("./process");
 class Git {
     options;
     constructor(options) {
         this.options = options;
     }
-    async exec(args, settings, cwd) {
-        return await (0, process_1.exec)("git", args, { cwd: cwd === false ? undefined : this.options.dir }, {
-            log: this.options.log,
-            ...(settings ?? {}),
+    createProcess(args, options = {}) {
+        return new async_process_1.AsyncProcess("git", args, {
+            $log: this.options.log,
+            cwd: this.options.dir,
+            ...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 canBeInit(repo) {
         return ((0, fs_1.isLocalDir)(repo) &&
             (!(await (0, fs_1.existsDir)(repo)) || !(await (0, fs_1.readDir)(repo)).length));
     }
     async clone(options) {
-        return await this.exec([
+        await this.exec([
             "clone",
             ...(/^\w+\:\/\//.test(options.repo) ? ["--depth=1"] : []),
             ...(options.orphan ? ["--orphan"] : []),
@@ -31,42 +38,41 @@ class Git {
         ]);
     }
     async checkout(options) {
-        return await this.exec([
+        await this.exec([
             "checkout",
             ...(options.orphan ? ["--orphan"] : []),
             options.branchName,
         ]);
     }
     async checkBranch(options) {
-        const result = await this.exec([
+        const stdout = await this.stdout([
             "ls-remote",
             "--exit-code",
             ...(options.repo ? [options.repo] : ["--heads", "origin"]),
         ], {
-            stdout: { save: true },
-            onExitCodeError: () => false,
-        }, options.repo ? false : true);
-        return result.stdout
+            ...(options.repo && {
+                cwd: undefined,
+            }),
+            cwd: options.repo ? undefined : this.options.dir,
+            $exitCode: false,
+        });
+        return stdout
             .split(/\r?\n/g)
             .some((line) => line.endsWith(`refs/heads/${options.name}`));
     }
     async removeAll() {
-        return await this.exec(["rm", "--force", "--ignore-unmatch", "*"]);
+        await this.exec(["rm", "--force", "--ignore-unmatch", "*"]);
     }
     async haveChanges() {
-        const statusResult = await this.exec(["status", "-s"], {
-            stdout: { save: true },
-        });
-        return !!statusResult.stdout.trim().length;
+        const stdout = await this.stdout(["status", "-s"]);
+        return !!stdout.trim().length;
     }
     async fetchCommitId(tag) {
-        return (await this.exec(["rev-list", "-n", "1", tag], { stdout: { save: true } })).stdout?.trim();
+        return (await this.stdout(["rev-list", "-n", "1", tag])).trim();
     }
     async getTags(names) {
-        const result = await this.exec(["tag", "-n", ...(names ?? [])], {
-            stdout: { save: true },
-        });
-        return result.stdout.split(/\r?\n/).reduce((result, value) => {
+        const stdout = await this.stdout(["tag", "-n", ...(names ?? [])]);
+        return stdout.split(/\r?\n/).reduce((result, value) => {
             value = value.trim();
             if (!value.length)
                 return result;
@@ -91,15 +97,10 @@ class Git {
         }
     }
     async pushTags() {
-        return await this.exec(["push", "--tags"]);
+        await this.exec(["push", "--tags"]);
     }
     async push(options) {
-        return await this.exec([
-            "push",
-            "--progress",
-            "origin",
-            options.branchName,
-        ]);
+        await this.exec(["push", "--progress", "origin", options.branchName]);
     }
 }
 exports.Git = Git;