@datatruck/cli 0.13.0 → 0.15.0

package/migrations/001-initial.sql

@@ -14,7 +14,8 @@ CREATE TABLE "backup_session" (
 	"progressCurrent" INTEGER,
 	"progressTotal" INTEGER,
 	"progressPercent" INTEGER,
-	"progressStep" TEXT,
+	"progressStepDescription" TEXT,
+	"progressStepItem" TEXT,
 	"progressStepPercent" INTEGER,
 
 	"snapshotId"	TEXT NOT NULL,
@@ -35,7 +36,8 @@ CREATE TABLE "backup_session_task" (
 	"progressCurrent" INTEGER,
 	"progressTotal" INTEGER,
 	"progressPercent" INTEGER,
-	"progressStep" TEXT,
+	"progressStepDescription" TEXT,
+	"progressStepItem" TEXT,
 	"progressStepPercent" INTEGER,
 
 	"sessionId"	INTEGER NOT NULL,
@@ -54,7 +56,8 @@ CREATE TABLE "backup_session_repository" (
 	"progressCurrent" INTEGER,
 	"progressTotal" INTEGER,
 	"progressPercent" INTEGER,
-	"progressStep" TEXT,
+	"progressStepDescription" TEXT,
+	"progressStepItem" TEXT,
 	"progressStepPercent" INTEGER,
 
 	"sessionId"	INTEGER NOT NULL,
@@ -74,7 +77,8 @@ CREATE TABLE "restore_session" (
 	"progressCurrent" INTEGER,
 	"progressTotal" INTEGER,
 	"progressPercent" INTEGER,
-	"progressStep" TEXT,
+	"progressStepDescription" TEXT,
+	"progressStepItem" TEXT,
 	"progressStepPercent" INTEGER,
 
 	"snapshotId"	TEXT NOT NULL,
@@ -94,7 +98,8 @@ CREATE TABLE "restore_session_task" (
 	"progressCurrent" INTEGER,
 	"progressTotal" INTEGER,
 	"progressPercent" INTEGER,
-	"progressStep" TEXT,
+	"progressStepDescription" TEXT,
+	"progressStepItem" TEXT,
 	"progressStepPercent" INTEGER,
 
 	"sessionId"	INTEGER NOT NULL,
@@ -113,7 +118,8 @@ CREATE TABLE "restore_session_repository" (
 	"progressCurrent" INTEGER,
 	"progressTotal" INTEGER,
 	"progressPercent" INTEGER,
-	"progressStep" TEXT,
+	"progressStepDescription" TEXT,
+	"progressStepItem" TEXT,
 	"progressStepPercent" INTEGER,
 
 	"sessionId"	INTEGER NOT NULL,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@datatruck/cli",
-  "version": "0.13.0",
+  "version": "0.15.0",
   "dependencies": {
     "ajv": "^8.11.0",
     "async": "^3.2.4",

package/util/fs-util.d.ts

@@ -1,9 +1,20 @@
 /// <reference types="node" />
 /// <reference types="node" />
 /// <reference types="node" />
-import { Stats } from "fs";
+/// <reference types="node" />
+import { Dirent, Stats } from "fs";
+import { WriteStream } from "fs";
 import { Interface } from "readline";
 export declare const isWSLSystem: boolean;
+export declare function isEmptyDir(path: string): Promise<boolean>;
+declare type EntryObject = {
+    name: string;
+    path: string;
+    dirent: Dirent;
+    stats: Stats;
+};
+export declare function applyPermissions(baseDir: string, permissionsPath: string): Promise<void>;
+export declare function pathIterator(stream: AsyncIterable<string | Buffer>): AsyncIterable<EntryObject>;
 export declare function isLocalDir(path: string): boolean;
 export declare function isDirEmpty(path: string): Promise<boolean>;
 export declare function mkdirIfNotExists(path: string): Promise<string>;
@@ -28,7 +39,7 @@ export declare function mkTmpDir(prefix: string, id?: string): Promise<string>;
 export declare function readPartialFile(path: string, positions: [number, number?]): Promise<string>;
 export declare function checkFile(path: string): Promise<boolean>;
 export declare function checkDir(path: string): Promise<boolean>;
-export declare function readDir(path: string): Promise<string[]>;
+export declare function readDir(path: string, optional?: boolean): Promise<string[]>;
 export declare function forEachFile(dirPath: string, cb: (path: string, dir: boolean) => void, includeDir?: boolean): Promise<void>;
 /**
  * @experimental
@@ -37,26 +48,10 @@ export declare function fastglobToGitIgnore(patterns: string[], baseDir: string)
 export declare function writeGitIgnoreList(options: {
     paths: NodeJS.ReadableStream | string[];
 }): Promise<string>;
-export declare function writePathLists(options: {
-    paths: NodeJS.ReadableStream | string[];
-    packs?: {
-        include: string[];
-        exclude?: string[];
-        multiple?: boolean;
-    }[];
-}): Promise<{
-    path: string;
-    includedPackPaths: string[];
-    excludedPackPaths: string[];
-    total: {
-        all: number;
-        path: number;
-        packsPaths: number[];
-        multipleStats: Record<string, number>;
-    };
-}>;
+export declare function waitForClose(stream: WriteStream): Promise<WriteStream>;
 export declare function copyFileWithStreams(source: string, target: string): Promise<unknown>;
 export declare function updateFileStats(path: string, fileInfo: Stats): Promise<void>;
+export declare function isNotFoundError(error: unknown): boolean;
 export declare function cpy(options: {
     input: {
         type: "glob";
@@ -77,6 +72,12 @@ export declare function cpy(options: {
      * @default 1
      */
     concurrency?: number;
+    skipNotFoundError?: boolean;
+    onProgress?: (data: {
+        current: number;
+        path?: string;
+        type?: "start" | "end";
+    }) => Promise<boolean | void>;
     onPath?: (data: {
         isDir: boolean;
         entryPath: string;
@@ -88,4 +89,9 @@ export declare function cpy(options: {
             dirs: number;
         };
     }) => Promise<boolean | void>;
-}): Promise<void>;
+}): Promise<{
+    paths: number;
+    files: number;
+    dirs: number;
+}>;
+export {};

package/util/fs-util.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.cpy = exports.updateFileStats = exports.copyFileWithStreams = exports.writePathLists = exports.writeGitIgnoreList = exports.fastglobToGitIgnore = exports.forEachFile = exports.readDir = exports.checkDir = exports.checkFile = exports.readPartialFile = exports.mkTmpDir = exports.fastFolderSizeAsync = exports.tmpDir = exports.sessionTmpDir = exports.parentTmpDir = exports.existsFile = exports.findFile = exports.parsePackageFile = exports.parseFile = exports.parseFileExtensions = exports.readdirIfExists = exports.writeJSONFile = exports.existsDir = exports.ensureEmptyDir = exports.mkdirIfNotExists = exports.isDirEmpty = exports.isLocalDir = exports.isWSLSystem = void 0;
+exports.cpy = exports.isNotFoundError = exports.updateFileStats = exports.copyFileWithStreams = exports.waitForClose = exports.writeGitIgnoreList = exports.fastglobToGitIgnore = exports.forEachFile = exports.readDir = exports.checkDir = exports.checkFile = exports.readPartialFile = exports.mkTmpDir = exports.fastFolderSizeAsync = exports.tmpDir = exports.sessionTmpDir = exports.parentTmpDir = exports.existsFile = exports.findFile = exports.parsePackageFile = exports.parseFile = exports.parseFileExtensions = exports.readdirIfExists = exports.writeJSONFile = exports.existsDir = exports.ensureEmptyDir = exports.mkdirIfNotExists = exports.isDirEmpty = exports.isLocalDir = exports.pathIterator = exports.applyPermissions = exports.isEmptyDir = exports.isWSLSystem = void 0;
 const globalData_1 = __importDefault(require("../globalData"));
 const path_util_1 = require("./path-util");
 const async_1 = require("async");
@@ -13,13 +13,49 @@ const fast_glob_1 = __importDefault(require("fast-glob"));
 const fs_1 = require("fs");
 const fs_2 = require("fs");
 const promises_1 = require("fs/promises");
-const micromatch_1 = require("micromatch");
 const os_1 = require("os");
 const path_1 = require("path");
 const path_2 = require("path");
 const readline_1 = require("readline");
 const util_1 = require("util");
 exports.isWSLSystem = (0, os_1.release)().includes("microsoft-standard-WSL");
+async function isEmptyDir(path) {
+    const iterator = await (0, promises_1.opendir)(path);
+    let done = false;
+    try {
+        const next = await iterator[Symbol.asyncIterator]().next();
+        done = !!next.done;
+        return done;
+    }
+    finally {
+        if (!done) {
+            await iterator.close();
+        }
+    }
+}
+exports.isEmptyDir = isEmptyDir;
+async function applyPermissions(baseDir, permissionsPath) {
+    const singleReader = (0, readline_1.createInterface)({
+        input: (0, fs_1.createReadStream)(permissionsPath),
+    });
+    for await (const line of singleReader) {
+        const [rpath, rawUid, rawGui, rawMode] = line.split(":");
+        const path = (0, path_1.join)(baseDir, rpath);
+        if (!path.startsWith(baseDir)) {
+            throw new Error(`Entry path is out of the base dir: (${path}, ${baseDir})`);
+        }
+        const uid = Number(rawUid);
+        const guid = Number(rawGui);
+        await (0, promises_1.chown)(path, uid, guid);
+        const mode = Number(rawMode);
+        await (0, promises_1.chmod)(path, mode);
+    }
+}
+exports.applyPermissions = applyPermissions;
+function pathIterator(stream) {
+    return stream;
+}
+exports.pathIterator = pathIterator;
 function isLocalDir(path) {
     return /^[\/\.]|([A-Z]:)/i.test(path);
 }
@@ -59,9 +95,7 @@ async function writeJSONFile(path, json) {
 }
 exports.writeJSONFile = writeJSONFile;
 async function readdirIfExists(path) {
-    if (!(await existsDir(path)))
-        return [];
-    return await readDir(path);
+    return await readDir(path, true);
 }
 exports.readdirIfExists = readdirIfExists;
 exports.parseFileExtensions = ["json", "js", "ts", "yaml", "yml"];
@@ -187,13 +221,15 @@ async function checkDir(path) {
     }
 }
 exports.checkDir = checkDir;
-async function readDir(path) {
+async function readDir(path, optional) {
     try {
         return await (0, promises_1.readdir)(path);
     }
     catch (anyError) {
         const nodeError = anyError;
         if (nodeError.code === "ENOENT") {
+            if (optional)
+                return [];
             const error = new Error(nodeError.message);
             error.code = nodeError.code;
             error.errno = nodeError.errno;
@@ -262,93 +298,14 @@ async function writeGitIgnoreList(options) {
     return path;
 }
 exports.writeGitIgnoreList = writeGitIgnoreList;
-async function writePathLists(options) {
-    const tempDir = await mkTmpDir("path-lists");
-    const includedPaths = [];
-    const excludedPaths = [];
-    const included = [];
-    const excluded = [];
-    const multipleStats = {};
-    const total = new Array((options.packs?.length || 0) + 1).fill(0);
-    await Promise.all([
-        ...new Array((options.packs?.length || 0) + 1).fill(null).map((_, index) => new Promise((resolve, reject) => {
-            const path = (0, path_1.join)(tempDir, `${index}-included.txt`);
-            const stream = (0, fs_2.createWriteStream)(path);
-            includedPaths.push(path);
-            included.push(stream);
-            stream.on("close", resolve);
-            stream.on("error", reject);
-        })),
-        ...new Array(options.packs?.length || 0).fill(null).map((_, index) => new Promise((resolve, reject) => {
-            const path = (0, path_1.join)(tempDir, `${index}-excluded.txt`);
-            const stream = (0, fs_2.createWriteStream)(path);
-            excludedPaths.push(path);
-            excluded.push(stream);
-            stream.on("close", resolve);
-            stream.on("error", reject);
-        })),
-        new Promise(async (resolve) => {
-            const packDirectories = [];
-            for await (const value of options.paths) {
-                const entry = value.toString();
-                const isDir = entry.endsWith("/");
-                const matchEntry = isDir ? entry.slice(0, -1) : entry;
-                let packIndex = 1;
-                let matches = false;
-                for (const pack of options.packs || []) {
-                    if ((0, micromatch_1.isMatch)(matchEntry, pack.include) &&
-                        (!pack.exclude || !(0, micromatch_1.isMatch)(matchEntry, pack.exclude))) {
-                        if (isDir)
-                            packDirectories.push([packIndex - 1, entry]);
-                        included[packIndex].write(`${entry}\n`);
-                        if (!isDir)
-                            total[packIndex]++;
-                        matches = true;
-                        break;
-                    }
-                    packIndex++;
-                }
-                if (!matches) {
-                    const packDir = packDirectories.find(([, p]) => entry.startsWith(p));
-                    if (packDir) {
-                        const [i, v] = packDir;
-                        const multipleExclude = options.packs?.[i].exclude;
-                        if (multipleExclude && (0, micromatch_1.isMatch)(matchEntry, multipleExclude)) {
-                            included[0].write(`${entry}\n`);
-                            excluded[i].write(`${entry}\n`);
-                        }
-                        else {
-                            if (!multipleStats[v])
-                                multipleStats[v] = 0;
-                            multipleStats[v]++;
-                        }
-                    }
-                    else {
-                        included[0].write(`${entry}\n`);
-                    }
-                    if (!isDir)
-                        total[0]++;
-                }
-            }
-            for (const stream of [...included, ...excluded]) {
-                stream.end();
-            }
-            resolve();
-        }),
-    ]);
-    return {
-        path: includedPaths[0],
-        includedPackPaths: includedPaths.slice(1),
-        excludedPackPaths: excludedPaths,
-        total: {
-            all: total.reduce((p, v) => p + v, 0),
-            path: total[0],
-            packsPaths: total.slice(1),
-            multipleStats,
-        },
-    };
+async function waitForClose(stream) {
+    return new Promise(async (resolve, reject) => {
+        stream.on("close", resolve);
+        stream.on("error", reject);
+        return stream;
+    });
 }
-exports.writePathLists = writePathLists;
+exports.waitForClose = waitForClose;
 async function copyFileWithStreams(source, target) {
     const r = (0, fs_1.createReadStream)(source);
     const w = (0, fs_2.createWriteStream)(target);
@@ -373,6 +330,10 @@ async function updateFileStats(path, fileInfo) {
     await (0, promises_1.chown)(path, fileInfo.uid, fileInfo.gid);
 }
 exports.updateFileStats = updateFileStats;
+function isNotFoundError(error) {
+    return error.code === "ENOENT";
+}
+exports.isNotFoundError = isNotFoundError;
 async function cpy(options) {
     const stats = { paths: 0, files: 0, dirs: 0 };
     const dirs = new Set();
@@ -387,6 +348,7 @@ async function cpy(options) {
         }
     };
     const task = async (rawEntryPath, basePath) => {
+        [rawEntryPath] = rawEntryPath.split(":");
         const isDir = rawEntryPath.endsWith("/");
         const entryPath = (0, path_1.normalize)(rawEntryPath);
         const entrySourcePath = (0, path_1.resolve)((0, path_1.join)(basePath, rawEntryPath));
@@ -407,20 +369,41 @@ async function cpy(options) {
         else {
             const dir = (0, path_1.dirname)(entryTargetPath);
             await makeRecursiveDir(dir);
+            await options.onProgress?.({
+                current: stats.files,
+                path: entryPath,
+            });
             stats.files++;
             // https://github.com/nodejs/node/issues/44261
             if (exports.isWSLSystem) {
-                const fileInfo = await (0, promises_1.stat)(entrySourcePath);
-                const isWritable = (fileInfo.mode & 0o200) === 0o200;
-                if (!isWritable) {
-                    await copyFileWithStreams(entrySourcePath, entryTargetPath);
-                    await updateFileStats(entryTargetPath, fileInfo);
-                    return;
+                let fileInfo;
+                try {
+                    fileInfo = await (0, promises_1.stat)(entrySourcePath);
+                }
+                catch (error) {
+                    const skipError = options.skipNotFoundError && isNotFoundError(error);
+                    if (!skipError)
+                        throw error;
+                }
+                if (fileInfo) {
+                    const isWritable = (fileInfo.mode & 0o200) === 0o200;
+                    if (!isWritable) {
+                        await copyFileWithStreams(entrySourcePath, entryTargetPath);
+                        await updateFileStats(entryTargetPath, fileInfo);
+                        return;
+                    }
                 }
             }
-            await (0, promises_1.cp)(entrySourcePath, entryTargetPath, {
-                preserveTimestamps: true,
-            });
+            try {
+                await (0, promises_1.cp)(entrySourcePath, entryTargetPath, {
+                    preserveTimestamps: true,
+                });
+            }
+            catch (error) {
+                const skipError = options.skipNotFoundError && isNotFoundError(error);
+                if (!skipError)
+                    throw error;
+            }
         }
     };
     const { input } = options;
@@ -450,5 +433,10 @@ async function cpy(options) {
             },
         });
     }
+    await options.onProgress?.({
+        current: stats.files,
+        type: "end",
+    });
+    return stats;
 }
 exports.cpy = cpy;

package/util/math-util.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.progressPercent = void 0;
 function progressPercent(total, current) {
+    if (total === 0 && current === 0)
+        return 0;
     return Number(((current / total) * 100).toFixed(2));
 }
 exports.progressPercent = progressPercent;

package/util/process-util.d.ts

@@ -24,6 +24,7 @@ export interface ExecSettingsInterface {
     onSpawn?: (p: ChildProcess) => void;
     stdout?: {
         save?: boolean;
+        parseLines?: boolean;
         onData?: (data: string) => void;
     };
     stderr?: {

package/util/process-util.js

@@ -11,6 +11,7 @@ const chalk_1 = __importDefault(require("chalk"));
 const child_process_1 = require("child_process");
 const fs_1 = require("fs");
 const promises_1 = require("fs/promises");
+const readline_1 = require("readline");
 function logExecStdout(input) {
     let text = input.colorize ? chalk_1.default.grey(input.data) : input.data;
     if (input.lineSalt)
@@ -70,7 +71,11 @@ async function exec(command, argv = [], options = null, settings = {}) {
             stderr: "",
             exitCode: 0,
         };
-        let finishListeners = pipe?.stream instanceof fs_1.WriteStream ? 2 : 1;
+        let finishListeners = 1;
+        if (pipe?.stream instanceof fs_1.WriteStream)
+            finishListeners++;
+        if (settings.stdout?.parseLines)
+            finishListeners++;
         let streamError;
         const tryFinish = () => {
             if (!--finishListeners)
@@ -129,10 +134,11 @@ async function exec(command, argv = [], options = null, settings = {}) {
         if (log.stdout || settings.stdout) {
             if (!p.stdout)
                 throw new Error(`stdout is not defined`);
-            p.stdout.on("data", (data) => {
+            const parseLines = settings.stdout?.parseLines;
+            const onData = (data) => {
                 if (log.stdout)
                     logExecStdout({
-                        data: data.toString(),
+                        data: parseLines ? `${data}\n` : data.toString(),
                         stderr: log.allToStderr,
                         colorize: log.colorize,
                     });
@@ -140,7 +146,17 @@ async function exec(command, argv = [], options = null, settings = {}) {
                     spawnData.stdout += data.toString();
                 if (settings.stdout?.onData)
                     settings.stdout.onData(data.toString());
-            });
+            };
+            if (parseLines) {
+                const rl = (0, readline_1.createInterface)({
+                    input: p.stdout,
+                });
+                rl.on("line", onData);
+                rl.on("close", tryFinish);
+            }
+            else {
+                p.stdout.on("data", onData);
+            }
         }
         if (log.stderr || settings.stderr) {
             if (!p.stderr)

package/util/string-util.d.ts

@@ -15,5 +15,6 @@ export declare type UriType = {
 export declare function formatUri(input: UriType, hidePassword?: boolean): string;
 export declare function formatSeconds(seconds: number): string;
 export declare function makePathPatterns(values: string[] | undefined): string[] | undefined;
+export declare function checkPath(path: string, include: string[], exclude?: string[]): boolean;
 export declare function checkMatch(subject: string | undefined, patterns: string[]): boolean;
 export declare function formatDateTime(datetime: string): string;

package/util/string-util.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatDateTime = exports.checkMatch = exports.makePathPatterns = exports.formatSeconds = exports.formatUri = exports.parseStringList = exports.render = exports.snakeCase = exports.lcfirst = exports.ucfirst = exports.serialize = void 0;
+exports.formatDateTime = exports.checkMatch = exports.checkPath = exports.makePathPatterns = exports.formatSeconds = exports.formatUri = exports.parseStringList = exports.render = exports.snakeCase = exports.lcfirst = exports.ucfirst = exports.serialize = void 0;
 const AppError_1 = require("../Error/AppError");
 const micromatch_1 = require("micromatch");
 function serialize(message, data) {
@@ -99,6 +99,13 @@ function makePathPatterns(values) {
     });
 }
 exports.makePathPatterns = makePathPatterns;
+function checkPath(path, include, exclude) {
+    return ((0, micromatch_1.isMatch)(path, include, {
+        dot: true,
+    }) &&
+        (!exclude || !(0, micromatch_1.isMatch)(path, exclude, { dot: true })));
+}
+exports.checkPath = checkPath;
 function checkMatch(subject, patterns) {
     if (!subject?.length)
         subject = "<empty>";

package/util/zip-util.d.ts

@@ -3,20 +3,6 @@ export interface ZipDataFilterType {
     exclude?: boolean;
     patterns: string[];
 }
-export declare type ZipStreamDataType = {
-    type: "progress";
-    data: {
-        progress: number;
-        files: number;
-        path: string;
-    };
-} | {
-    type: "summary";
-    data: {
-        folders: number;
-        files: number;
-    };
-};
 export interface ZipDataType {
     command?: string;
     path: string;
@@ -26,7 +12,14 @@ export interface ZipDataType {
     includeList?: string;
     excludeList?: string;
     verbose?: boolean;
-    onStream?: (data: ZipStreamDataType) => void;
+    onProgress?: (data: {
+        percent: number;
+        total: number;
+        current: number;
+        path?: string;
+        type?: "start" | "end";
+    }) => void | Promise<void>;
+    onStream?: (data: ZipStream) => void | Promise<void>;
 }
 export interface UnzipDataType {
     command?: string;
@@ -34,19 +27,71 @@ export interface UnzipDataType {
     files?: (ZipDataFilterType | string)[];
     output: string;
     verbose?: boolean;
-    onStream?: (data: UnzipStreamDataType) => void;
+    onProgress?: (data: {
+        percent: number;
+        current: number;
+        path?: string;
+        type?: "start" | "end";
+    }) => void | Promise<void>;
+    onStream?: (data: UnzipStream) => void | Promise<void>;
 }
-export declare type UnzipStreamDataType = {
+export declare function buildArguments(filters: (ZipDataFilterType | string)[]): string[];
+export declare function checkSSEOption(command?: string): Promise<boolean>;
+declare type ListZipStream = {
+    Path?: string;
+    Folder?: string;
+    Size?: string;
+    "Packed Size"?: string;
+    Modified?: string;
+    Created?: string;
+    Accessed?: string;
+    Attributes?: string;
+    Encrypted?: string;
+    Comment?: string;
+    CRC?: string;
+    Method?: string;
+    Characteristics?: string;
+    "Host OS"?: string;
+    Version?: string;
+    Volume?: string;
+    Offset?: string;
+};
+export declare function listZip(data: {
+    command?: string;
+    path: string;
+    onStream: (item: ListZipStream) => Promise<void>;
+    verbose?: boolean;
+}): Promise<void>;
+export declare type ZipStream = {
     type: "progress";
     data: {
         progress: number;
         files: number;
         path: string;
     };
+} | {
+    type: "summary";
+    data: {
+        folders: number;
+        files: number;
+    };
 };
-export declare function buildArguments(filters: (ZipDataFilterType | string)[]): string[];
 export declare function zip(data: ZipDataType): Promise<{
     folders: number;
     files: number;
 }>;
-export declare function unzip(data: UnzipDataType): Promise<import("./process-util").ExecResultType>;
+export declare type UnzipStream = {
+    type: "progress";
+    data: {
+        percent: number;
+        files: number;
+        path: string;
+    };
+};
+export declare function unzip(data: UnzipDataType): Promise<{
+    files: number;
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}>;
+export {};