@datatruck/cli 0.14.0 → 0.15.0

package/SessionDriver/ConsoleSessionDriver.js

@@ -83,8 +83,15 @@ class ConsoleSessionDriver extends SessionDriverAbstract_1.SessionDriverAbstract
             typeof message.progressTotal === "number") {
             parts.push(`${message.progressCurrent ?? "?"}/${message.progressTotal ?? "?"}`);
         }
-        if (typeof message.progressStep === "string")
-            parts.push(message.progressStep);
+        if (message.progressStepDescription && message.progressStepItem) {
+            parts.push(`${message.progressStepDescription}: ${message.progressStepItem}`);
+        }
+        else if (message.progressStepDescription) {
+            parts.push(message.progressStepDescription);
+        }
+        else if (message.progressStepItem) {
+            parts.push(message.progressStepItem);
+        }
         if (typeof message.progressStepPercent === "number") {
             parts.push((0, chalk_1.cyan)((0, cli_util_1.renderProgressBar)(message.progressStepPercent ?? 0, 10)));
         }
@@ -93,13 +100,6 @@ class ConsoleSessionDriver extends SessionDriverAbstract_1.SessionDriverAbstract
     async onWrite(data) {
         if (data.action === SessionDriverAbstract_1.ActionEnum.Init)
             return;
-        if (data.action === SessionDriverAbstract_1.ActionEnum.Progress && this.options.progressInterval) {
-            const skip = this.lastProgressDate &&
-                Date.now() - this.lastProgressDate < this.options.progressInterval;
-            if (skip)
-                return;
-            this.lastProgressDate = Date.now();
-        }
         const message = {
             sessionId: "sessionId" in data.data ? data.data.sessionId : data.data.id,
             badges: [],
@@ -135,7 +135,8 @@ class ConsoleSessionDriver extends SessionDriverAbstract_1.SessionDriverAbstract
             message.progressPercent = data.data.progressPercent;
             message.progressCurrent = data.data.progressCurrent;
             message.progressTotal = data.data.progressTotal;
-            message.progressStep = data.data.progressStep;
+            message.progressStepDescription = data.data.progressStepDescription;
+            message.progressStepItem = data.data.progressStepItem;
             message.progressStepPercent = data.data.progressStepPercent;
         }
         if (data.entity === SessionDriverAbstract_1.EntityEnum.BackupSession ||

package/SessionManager/BackupSessionManager.d.ts

@@ -2,19 +2,14 @@ import { BackupSessionsActionOptionsType } from "../Action/BackupSessionsAction"
 import { BackupSessionEntity } from "../Entity/BackupSessionEntity";
 import { BackupSessionRepositoryEntity } from "../Entity/BackupSessionRepositoryEntity";
 import { BackupSessionTaskEntity } from "../Entity/BackupSessionTaskEntity";
-import { WriteDataType, SessionDriverAbstract } from "../SessionDriver/SessionDriverAbstract";
+import { ProgressDataType } from "../Repository/RepositoryAbstract";
+import { WriteDataType } from "../SessionDriver/SessionDriverAbstract";
 import { ObjectVault } from "../util/ObjectVault";
-export declare type OptionsType = {
-    driver: SessionDriverAbstract;
-    altDrivers?: SessionDriverAbstract[];
-    verbose?: boolean;
-};
-export declare class BackupSessionManager {
-    readonly options: OptionsType;
+import SessionManagerAbstract from "./SessionManagerAbstract";
+export declare class BackupSessionManager extends SessionManagerAbstract {
     sessionVault: ObjectVault<BackupSessionEntity>;
     taskVault: ObjectVault<BackupSessionTaskEntity>;
     repositoryVault: ObjectVault<BackupSessionRepositoryEntity>;
-    constructor(options: OptionsType);
     findId(data: {
         packageName: string;
     }): number;
@@ -36,9 +31,13 @@ export declare class BackupSessionManager {
     start(input: Pick<BackupSessionEntity, "id">): Promise<number>;
     end(input: Pick<BackupSessionEntity, "id" | "error">): Promise<number>;
     startTask(input: Pick<BackupSessionTaskEntity, "id">): Promise<number>;
-    progressTask(input: Pick<BackupSessionTaskEntity, "id" | "progressTotal" | "progressCurrent" | "progressPercent" | "progressStep" | "progressStepPercent">): Promise<number>;
+    progressTask(input: {
+        id: number;
+    } & ProgressDataType): Promise<number>;
     endTask(input: Pick<BackupSessionTaskEntity, "id" | "error">): Promise<number>;
     startRepository(input: Pick<BackupSessionRepositoryEntity, "id">): Promise<number>;
-    progressRepository(input: Pick<BackupSessionTaskEntity, "id" | "progressTotal" | "progressCurrent" | "progressPercent" | "progressStep" | "progressStepPercent">): Promise<number>;
+    progressRepository(input: {
+        id: number;
+    } & ProgressDataType): Promise<number>;
     endRepository(input: Pick<BackupSessionRepositoryEntity, "id" | "error">): Promise<number>;
 }

package/SessionManager/BackupSessionManager.js

@@ -1,11 +1,15 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BackupSessionManager = void 0;
 const SessionDriverAbstract_1 = require("../SessionDriver/SessionDriverAbstract");
 const ObjectVault_1 = require("../util/ObjectVault");
-class BackupSessionManager {
-    constructor(options) {
-        this.options = options;
+const SessionManagerAbstract_1 = __importDefault(require("./SessionManagerAbstract"));
+class BackupSessionManager extends SessionManagerAbstract_1.default {
+    constructor() {
+        super(...arguments);
         this.sessionVault = new ObjectVault_1.ObjectVault();
         this.taskVault = new ObjectVault_1.ObjectVault();
         this.repositoryVault = new ObjectVault_1.ObjectVault();
@@ -35,6 +39,9 @@ class BackupSessionManager {
     }
     async alter(data) {
         const drivers = [this.options.driver, ...(this.options.altDrivers ?? [])];
+        if (data.action === SessionDriverAbstract_1.ActionEnum.Progress &&
+            !this.checkProgress(data.data.progressStepDescription))
+            return data.data.id;
         for (const driver of drivers) {
             await driver.onWrite(data);
         }
@@ -139,7 +146,13 @@ class BackupSessionManager {
             sessionData: this.sessionVault.get(object.sessionId),
             data: {
                 ...object,
-                ...input,
+                id: input.id,
+                progressCurrent: input.stats?.current,
+                progressTotal: input.stats?.total,
+                progressPercent: input.stats?.percent,
+                progressStepDescription: input.step?.description,
+                progressStepItem: input.step?.item,
+                progressStepPercent: input.step?.percent,
                 updatingDate: new Date().toISOString(),
             },
         });
@@ -182,7 +195,13 @@ class BackupSessionManager {
             sessionData: this.sessionVault.get(object.sessionId),
             data: {
                 ...object,
-                ...input,
+                id: input.id,
+                progressCurrent: input.stats?.current,
+                progressTotal: input.stats?.total,
+                progressPercent: input.stats?.percent,
+                progressStepDescription: input.step?.description,
+                progressStepItem: input.step?.item,
+                progressStepPercent: input.step?.percent,
                 updatingDate: new Date().toISOString(),
             },
         });

package/SessionManager/RestoreSessionManager.d.ts

@@ -2,19 +2,16 @@ import { BackupSessionsActionOptionsType } from "../Action/BackupSessionsAction"
 import { RestoreSessionEntity } from "../Entity/RestoreSessionEntity";
 import { RestoreSessionRepositoryEntity } from "../Entity/RestoreSessionRepositoryEntity";
 import { RestoreSessionTaskEntity } from "../Entity/RestoreSessionTaskEntity";
-import { WriteDataType, SessionDriverAbstract } from "../SessionDriver/SessionDriverAbstract";
+import { ProgressDataType } from "../Repository/RepositoryAbstract";
+import { WriteDataType } from "../SessionDriver/SessionDriverAbstract";
 import { ObjectVault } from "../util/ObjectVault";
-export declare type OptionsType = {
-    driver: SessionDriverAbstract;
-    altDrivers?: SessionDriverAbstract[];
-    verbose?: boolean;
-};
-export declare class RestoreSessionManager {
-    readonly options: OptionsType;
+import SessionManagerAbstract from "./SessionManagerAbstract";
+export declare class RestoreSessionManager extends SessionManagerAbstract {
     sessionVault: ObjectVault<RestoreSessionEntity>;
     repositoryVault: ObjectVault<RestoreSessionRepositoryEntity>;
     taskVault: ObjectVault<RestoreSessionTaskEntity>;
-    constructor(options: OptionsType);
+    protected lastProgressDate: number | undefined;
+    protected lastProgressStepDescription: string | null | undefined;
     findId(data: {
         packageName: string;
     }): number;
@@ -37,8 +34,12 @@ export declare class RestoreSessionManager {
     end(input: Pick<RestoreSessionEntity, "id" | "error">): Promise<number>;
     startTask(input: Pick<RestoreSessionTaskEntity, "id">): Promise<number>;
     startRepository(input: Pick<RestoreSessionRepositoryEntity, "id">): Promise<number>;
-    progressTask(input: Pick<RestoreSessionTaskEntity, "id" | "progressTotal" | "progressCurrent" | "progressPercent" | "progressStep" | "progressStepPercent">): Promise<number>;
+    progressTask(input: {
+        id: number;
+    } & ProgressDataType): Promise<number>;
     endTask(input: Pick<RestoreSessionTaskEntity, "id" | "error">): Promise<number>;
-    progressRepository(input: Pick<RestoreSessionRepositoryEntity, "id" | "progressTotal" | "progressCurrent" | "progressPercent" | "progressStep" | "progressStepPercent">): Promise<number>;
+    progressRepository(input: {
+        id: number;
+    } & ProgressDataType): Promise<number>;
     endRepository(input: Pick<RestoreSessionRepositoryEntity, "id" | "error">): Promise<number>;
 }

package/SessionManager/RestoreSessionManager.js

@@ -1,11 +1,15 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RestoreSessionManager = void 0;
 const SessionDriverAbstract_1 = require("../SessionDriver/SessionDriverAbstract");
 const ObjectVault_1 = require("../util/ObjectVault");
-class RestoreSessionManager {
-    constructor(options) {
-        this.options = options;
+const SessionManagerAbstract_1 = __importDefault(require("./SessionManagerAbstract"));
+class RestoreSessionManager extends SessionManagerAbstract_1.default {
+    constructor() {
+        super(...arguments);
         this.sessionVault = new ObjectVault_1.ObjectVault();
         this.repositoryVault = new ObjectVault_1.ObjectVault();
         this.taskVault = new ObjectVault_1.ObjectVault();
@@ -35,6 +39,9 @@ class RestoreSessionManager {
     }
     async alter(data) {
         const drivers = [this.options.driver, ...(this.options.altDrivers ?? [])];
+        if (data.action === SessionDriverAbstract_1.ActionEnum.Progress &&
+            !this.checkProgress(data.data.progressStepDescription))
+            return data.data.id;
         for (const driver of drivers) {
             await driver.onWrite(data);
         }
@@ -154,7 +161,13 @@ class RestoreSessionManager {
             sessionData: this.sessionVault.get(object.sessionId),
             data: {
                 ...object,
-                ...input,
+                id: input.id,
+                progressCurrent: input.stats?.current,
+                progressTotal: input.stats?.total,
+                progressPercent: input.stats?.percent,
+                progressStepDescription: input.step?.description,
+                progressStepItem: input.step?.item,
+                progressStepPercent: input.step?.percent,
                 updatingDate: new Date().toISOString(),
             },
         });
@@ -182,7 +195,13 @@ class RestoreSessionManager {
             sessionData: this.sessionVault.get(object.sessionId),
             data: {
                 ...object,
-                ...input,
+                id: input.id,
+                progressCurrent: input.stats?.current,
+                progressTotal: input.stats?.total,
+                progressPercent: input.stats?.percent,
+                progressStepDescription: input.step?.description,
+                progressStepItem: input.step?.item,
+                progressStepPercent: input.step?.percent,
                 updatingDate: new Date().toISOString(),
             },
         });

package/SessionManager/SessionManagerAbstract.d.ts

@@ -0,0 +1,14 @@
+import { SessionDriverAbstract } from "../SessionDriver/SessionDriverAbstract";
+export declare type OptionsType = {
+    driver: SessionDriverAbstract;
+    altDrivers?: SessionDriverAbstract[];
+    progressInterval?: number;
+    verbose?: boolean;
+};
+export default abstract class SessionManagerAbstract {
+    readonly options: OptionsType;
+    protected lastProgressDate: number | undefined;
+    protected lastProgressStepDescription: string | null | undefined;
+    constructor(options: OptionsType);
+    protected checkProgress(description: string | null | undefined): boolean;
+}

package/SessionManager/SessionManagerAbstract.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class SessionManagerAbstract {
+    constructor(options) {
+        this.options = options;
+    }
+    checkProgress(description) {
+        const progressInterval = this.options.progressInterval;
+        if (progressInterval) {
+            const skip = this.lastProgressDate &&
+                description === this.lastProgressStepDescription &&
+                Date.now() - this.lastProgressDate < progressInterval;
+            if (skip)
+                return false;
+            this.lastProgressDate = Date.now();
+            this.lastProgressStepDescription = description;
+        }
+        return true;
+    }
+}
+exports.default = SessionManagerAbstract;

package/Task/GitTask.js

@@ -73,7 +73,9 @@ class GitTask extends TaskAbstract_1.TaskAbstract {
         // Bundle
         const bundlePath = (0, path_1.join)(targetPath, "repo.bundle");
         await data.onProgress({
-            step: "Creating bundle...",
+            step: {
+                description: "Creating bundle",
+            },
         });
         await (0, process_util_1.exec)(this.command, ["bundle", "create", bundlePath, "--all"], {
             cwd: path,
@@ -174,10 +176,15 @@ class GitTask extends TaskAbstract_1.TaskAbstract {
                 onPath: async ({ entryPath }) => {
                     currentFiles++;
                     await data.onProgress({
-                        total,
-                        current: currentFiles,
-                        percent: (0, math_util_1.progressPercent)(total, currentFiles),
-                        step: entryPath,
+                        step: {
+                            description: "Copying file",
+                            item: entryPath,
+                        },
+                        stats: {
+                            total,
+                            current: currentFiles,
+                            percent: (0, math_util_1.progressPercent)(total, currentFiles),
+                        },
                     });
                 },
             });
@@ -201,14 +208,17 @@ class GitTask extends TaskAbstract_1.TaskAbstract {
         let totalFiles = 0;
         let currentFiles = 0;
         await (0, fs_util_1.forEachFile)(targetPath, () => totalFiles++, true);
-        const incrementProgress = async (step = "") => {
+        const incrementProgress = async (description, item, count = true) => {
             await data.onProgress({
-                total: totalFiles,
-                current: Math.max(currentFiles, 0),
-                percent: (0, math_util_1.progressPercent)(totalFiles, Math.max(currentFiles, 0)),
-                step,
+                stats: {
+                    total: totalFiles,
+                    current: Math.max(currentFiles, 0),
+                    percent: (0, math_util_1.progressPercent)(totalFiles, Math.max(currentFiles, 0)),
+                },
+                step: { description, item },
             });
-            currentFiles++;
+            if (count)
+                currentFiles++;
         };
         // Bundle
         const bundlePath = (0, path_1.join)(targetPath, "repo.bundle");
@@ -237,9 +247,7 @@ class GitTask extends TaskAbstract_1.TaskAbstract {
                     },
                     targetPath: restorePath,
                     concurrency: this.config.fileCopyConcurrency,
-                    onPath: async ({ entryPath }) => {
-                        await incrementProgress(entryPath);
-                    },
+                    onProgress: async (progress) => await incrementProgress(progress.type === "end" ? "Files copied" : "Copying file", progress.path, !progress.type),
                 });
             }
         }

package/Task/MariadbTask.js

@@ -108,10 +108,15 @@ class MariadbTask extends TaskAbstract_1.TaskAbstract {
             else if (paths.length) {
                 const path = (0, posix_1.normalize)(paths[0]);
                 await data.onProgress({
-                    current,
-                    percent: (0, math_util_1.progressPercent)(total, current),
-                    total,
-                    step: `Copying ${path}`,
+                    step: {
+                        description: "Copying file",
+                        item: path,
+                    },
+                    stats: {
+                        current,
+                        percent: (0, math_util_1.progressPercent)(total, current),
+                        total,
+                    },
                 });
             }
         };

package/Task/SqlDumpTaskAbstract.js

@@ -118,24 +118,39 @@ class SqlDumpTaskAbstract extends TaskAbstract_1.TaskAbstract {
             await (0, promises_1.mkdir)(outputPath, { recursive: true });
         if (!this.config.oneFileByTable) {
             const outPath = (0, path_1.join)(outputPath, serializeSqlFile({ database: this.config.database }));
+            data.onProgress({
+                step: {
+                    description: "Exporting",
+                },
+            });
             await this.onExportTables(tableNames, outPath);
         }
         else {
             let current = 0;
             for (const tableName of tableNames) {
                 data.onProgress({
-                    total: tableNames.length,
-                    current: current,
-                    percent: (0, math_util_1.progressPercent)(tableNames.length, current),
-                    step: tableName,
+                    step: {
+                        description: "Exporting",
+                        item: tableName,
+                    },
+                    stats: {
+                        total: tableNames.length,
+                        current: current,
+                        percent: (0, math_util_1.progressPercent)(tableNames.length, current),
+                    },
                 });
-                current++;
                 const outPath = (0, path_1.join)(outputPath, serializeSqlFile({ table: tableName }));
                 await this.onExportTables([tableName], outPath);
+                current++;
             }
         }
         if (this.config.storedPrograms) {
             const outPath = (0, path_1.join)(outputPath, "stored-programs.sql");
+            data.onProgress({
+                step: {
+                    description: "Exporting storaged programs",
+                },
+            });
             await this.onExportStoredPrograms(outPath);
         }
     }
@@ -184,13 +199,18 @@ class SqlDumpTaskAbstract extends TaskAbstract_1.TaskAbstract {
         for (const item of items) {
             const path = (0, path_1.join)(restorePath, item.fileName);
             data.onProgress({
-                total: items.length,
-                current: current,
-                percent: (0, math_util_1.progressPercent)(items.length, current),
-                step: item.fileName,
+                step: {
+                    description: "Importing",
+                    item: item.fileName,
+                },
+                stats: {
+                    total: items.length,
+                    current: current,
+                    percent: (0, math_util_1.progressPercent)(items.length, current),
+                },
             });
-            current++;
             await this.onImport(path, database.name);
+            current++;
         }
     }
 }

package/Task/TaskAbstract.d.ts

@@ -3,11 +3,16 @@ import { RestoreActionOptionsType } from "../Action/RestoreAction";
 import { PackageConfigType } from "../Config/PackageConfig";
 import { SnapshotType } from "../Repository/RepositoryAbstract";
 export declare type ProgressDataType = {
-    total?: number;
-    current?: number;
-    percent?: number;
-    step?: string;
-    stepPercent?: number;
+    stats?: {
+        total?: number;
+        current?: number;
+        percent?: number;
+    };
+    step?: {
+        description?: string;
+        item?: string;
+        percent?: number;
+    };
 };
 export declare type BackupDataType = {
     onProgress: (data: ProgressDataType) => Promise<void>;

package/cli.js

@@ -81,7 +81,7 @@ program.usage("dtt");
 program.option("-v,--verbose", "Verbose", (_, previous) => previous + 1, 0);
 program.option("-c,--config <path>", "Config path", process.env["DATATRUCK_CONFIG"] ?? (cwd.endsWith(path_1.sep) ? cwd : `${cwd}${path_1.sep}`));
 program.option("--progress <value>", "Progress type (auto, plain, tty)", "auto");
-program.option("--progress-interval <ms>", "Progress interval");
+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.config).alias("c");
 makeCommand(CommandFactory_1.CommandEnum.init).alias("i");

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.14.0",
+  "version": "0.15.0",
   "dependencies": {
     "ajv": "^8.11.0",
     "async": "^3.2.4",

package/util/fs-util.d.ts

@@ -73,6 +73,11 @@ export declare function cpy(options: {
      */
     concurrency?: number;
     skipNotFoundError?: boolean;
+    onProgress?: (data: {
+        current: number;
+        path?: string;
+        type?: "start" | "end";
+    }) => Promise<boolean | void>;
     onPath?: (data: {
         isDir: boolean;
         entryPath: string;
@@ -84,5 +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

@@ -369,6 +369,10 @@ 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) {
@@ -429,5 +433,10 @@ async function cpy(options) {
             },
         });
     }
+    await options.onProgress?.({
+        current: stats.files,
+        type: "end",
+    });
+    return stats;
 }
 exports.cpy = cpy;

package/util/zip-util.d.ts

@@ -12,7 +12,14 @@ export interface ZipDataType {
     includeList?: string;
     excludeList?: string;
     verbose?: boolean;
-    onStream?: (data: ZipStream) => 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;
@@ -20,7 +27,13 @@ export interface UnzipDataType {
     files?: (ZipDataFilterType | string)[];
     output: string;
     verbose?: boolean;
-    onStream?: (data: UnzipStream) => void;
+    onProgress?: (data: {
+        percent: number;
+        current: number;
+        path?: string;
+        type?: "start" | "end";
+    }) => void | Promise<void>;
+    onStream?: (data: UnzipStream) => void | Promise<void>;
 }
 export declare function buildArguments(filters: (ZipDataFilterType | string)[]): string[];
 export declare function checkSSEOption(command?: string): Promise<boolean>;
@@ -46,7 +59,7 @@ declare type ListZipStream = {
 export declare function listZip(data: {
     command?: string;
     path: string;
-    onStream: (item: ListZipStream) => void;
+    onStream: (item: ListZipStream) => Promise<void>;
     verbose?: boolean;
 }): Promise<void>;
 export declare type ZipStream = {
@@ -70,10 +83,15 @@ export declare function zip(data: ZipDataType): Promise<{
 export declare type UnzipStream = {
     type: "progress";
     data: {
-        progress: number;
+        percent: number;
         files: number;
         path: string;
     };
 };
-export declare function unzip(data: UnzipDataType): Promise<import("./process-util").ExecResultType>;
+export declare function unzip(data: UnzipDataType): Promise<{
+    files: number;
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}>;
 export {};