@datatruck/cli 0.12.1 → 0.14.0

package/util/fs-util.js

@@ -3,21 +3,59 @@ 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.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");
 const crypto_1 = require("crypto");
+const fast_folder_size_1 = __importDefault(require("fast-folder-size"));
 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);
 }
@@ -57,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"];
@@ -130,6 +166,10 @@ function tmpDir(prefix, id) {
     return (0, path_1.join)(sessionTmpDir(), `${prefix}-${id}`);
 }
 exports.tmpDir = tmpDir;
+async function fastFolderSizeAsync(path) {
+    return (await (0, util_1.promisify)(fast_folder_size_1.default)(path)) || 0;
+}
+exports.fastFolderSizeAsync = fastFolderSizeAsync;
 async function mkTmpDir(prefix, id) {
     const path = tmpDir(prefix, id);
     await (0, promises_1.mkdir)(path, { recursive: true });
@@ -181,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;
@@ -256,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);
@@ -367,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();
@@ -381,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));
@@ -404,17 +372,34 @@ async function cpy(options) {
             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;

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)
@@ -34,7 +35,9 @@ async function exec(command, argv = [], options = null, settings = {}) {
     return new Promise(async (resolve, reject) => {
         if (log.exec) {
             const logEnv = log.envNames?.reduce((env, key) => {
-                env[key] = options?.env?.[key] ?? "";
+                const value = options?.env?.[key];
+                if (typeof value !== "undefined")
+                    env[key] = value;
                 return env;
             }, {});
             (0, cli_util_1.logExec)(command, pipe
@@ -68,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)
@@ -127,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,
                     });
@@ -138,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,7 @@ export interface ZipDataType {
     includeList?: string;
     excludeList?: string;
     verbose?: boolean;
-    onStream?: (data: ZipStreamDataType) => void;
+    onStream?: (data: ZipStream) => void;
 }
 export interface UnzipDataType {
     command?: string;
@@ -34,19 +20,60 @@ export interface UnzipDataType {
     files?: (ZipDataFilterType | string)[];
     output: string;
     verbose?: boolean;
-    onStream?: (data: UnzipStreamDataType) => void;
+    onStream?: (data: UnzipStream) => 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) => 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 type UnzipStream = {
+    type: "progress";
+    data: {
+        progress: number;
+        files: number;
+        path: string;
+    };
+};
 export declare function unzip(data: UnzipDataType): Promise<import("./process-util").ExecResultType>;
+export {};

package/util/zip-util.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.unzip = exports.zip = exports.buildArguments = void 0;
+exports.unzip = exports.zip = exports.listZip = exports.checkSSEOption = exports.buildArguments = void 0;
 const process_util_1 = require("./process-util");
 const path_1 = require("path");
 function buildArguments(filters) {
@@ -30,45 +30,94 @@ function buildArguments(filters) {
     return args;
 }
 exports.buildArguments = buildArguments;
-function parseZipStream(chunk, buffer, cb) {
-    const lines = chunk.replaceAll("\b", "").trim().split(/\r?\n/);
-    for (const line of lines) {
-        let matches = null;
-        if ((matches = /^(\d+)% (\d+ )?\+/.exec(line))) {
-            const path = line.slice(line.indexOf("+") + 1).trim();
-            const progress = Number(matches[1]);
-            if (!buffer.currentPaths)
-                buffer.currentPaths = 0;
-            if (path !== buffer.lastPath)
-                buffer.currentPaths++;
-            buffer.lastPath = path;
-            cb({
-                type: "progress",
-                data: { progress, path, files: buffer.currentPaths },
-            });
+let checkSSEOptionResult;
+async function checkSSEOption(command = "7z") {
+    const result = await (0, process_util_1.exec)(command);
+    if (typeof checkSSEOptionResult === "boolean")
+        return checkSSEOptionResult;
+    return (checkSSEOptionResult = result.stdout.includes(" -sse"));
+}
+exports.checkSSEOption = checkSSEOption;
+const listZipLineEqChar = " = ";
+function parseListZipLine(line, buffer) {
+    if (buffer.started) {
+        if (line === "") {
+            if (buffer.opened) {
+                const { stream } = buffer;
+                buffer.stream = {};
+                buffer.opened = false;
+                return stream;
+            }
         }
-        else if (line.startsWith("Add new data to archive:")) {
-            const [, folders] = /(\d+) folders?/i.exec(line) || [, 0];
-            const [, files] = /(\d+) files?/i.exec(line) || [, 0];
-            cb({
-                type: "summary",
-                data: {
-                    folders: Number(folders),
-                    files: Number(files),
-                },
-            });
+        else {
+            const separator = line.indexOf(listZipLineEqChar);
+            const key = line.slice(0, separator);
+            const value = line.slice(separator + listZipLineEqChar.length);
+            buffer.opened = true;
+            buffer.stream[key] = value;
         }
     }
+    else if (line.startsWith("----------")) {
+        buffer.started = true;
+        buffer.stream = {};
+    }
+}
+async function listZip(data) {
+    const buffer = {};
+    await (0, process_util_1.exec)(data.command ?? "7z", ["l", data.path, "-slt"], {}, {
+        log: {
+            exec: data.verbose ?? false,
+            stderr: data.verbose ?? false,
+            stdout: false,
+        },
+        onExitCodeError: (data, error) => (data.exitCode > 2 ? error : false),
+        stdout: {
+            parseLines: true,
+            onData: (line) => {
+                const stream = parseListZipLine(line, buffer);
+                if (stream) {
+                    data.onStream?.(stream);
+                }
+            },
+        },
+    });
+}
+exports.listZip = listZip;
+function parseZipLine(line) {
+    let matches = null;
+    if (!line.trim().length)
+        return;
+    if ((matches = /^\s*(\d+)% (\d+ )?\+/.exec(line))) {
+        const path = line.slice(line.indexOf("+") + 1).trim();
+        const progress = Number(matches[1]);
+        const files = Number(matches[2]);
+        return {
+            type: "progress",
+            data: { progress, path, files },
+        };
+    }
+    else if (line.startsWith("Add new data to archive:")) {
+        const [, folders] = /(\d+) folders?/i.exec(line) || [, 0];
+        const [, files] = /(\d+) files?/i.exec(line) || [, 0];
+        return {
+            type: "summary",
+            data: {
+                folders: Number(folders),
+                files: Number(files),
+            },
+        };
+    }
 }
 async function zip(data) {
     let result = {
         folders: 0,
         files: 0,
     };
-    let buffer = {};
     await (0, process_util_1.exec)(data.command ?? "7z", [
         "a",
-        "-mmt1",
+        // https://sourceforge.net/p/sevenzip/bugs/2099/,
+        // https://github.com/mcmilk/7-Zip/commit/87ba6f01ba3c5b2ce3186bddfe3d7d880639193c#diff-779d6b1bfa6196b288478f78ca96c4d4c6d7ac6cf8be15a28a20dabc9137ca36L515
+        ...((await checkSSEOption(data.command)) ? [] : ["-mmt1"]),
         "-bsp1",
         ...(data.deleteOnZip ? ["-sdel"] : []),
         (0, path_1.normalize)(data.output),
@@ -79,41 +128,36 @@ async function zip(data) {
         cwd: data.path,
     }, {
         log: data.verbose ?? false,
-        stderr: {
-            toExitCode: true,
-        },
+        onExitCodeError: (data, error) => (data.exitCode > 2 ? error : false),
         stdout: {
-            onData: (chunk) => {
-                parseZipStream(chunk, buffer, (stream) => {
+            onData: (line) => {
+                const stream = parseZipLine(line);
+                if (stream) {
                     data.onStream?.(stream);
                     if (stream.type === "summary")
                         result = stream.data;
-                });
+                }
             },
         },
     });
     return result;
 }
 exports.zip = zip;
-function parseUnzipStream(chunk, cb) {
-    const lines = chunk.trim().split(/\r?\n/g);
-    for (const line of lines) {
-        let matches = null;
-        if ((matches = /^(\d+)% (\d+) \-/.exec(line))) {
-            const progress = Number(matches[1]);
-            const files = Number(matches[2]);
-            const path = line.slice(line.indexOf("-") + 1).trim();
-            cb({
-                type: "progress",
-                data: { progress, path, files },
-            });
-        }
+function parseUnzipLine(line) {
+    let matches = null;
+    if ((matches = /^\s*(\d+)% (\d+) \-/.exec(line))) {
+        const progress = Number(matches[1]);
+        const files = Number(matches[2]);
+        const path = line.slice(line.indexOf("-") + 1).trim();
+        return {
+            type: "progress",
+            data: { progress, path, files },
+        };
     }
 }
 async function unzip(data) {
     return await (0, process_util_1.exec)(data.command ?? "7z", [
         "x",
-        "-mmt1",
         "-bsp1",
         (0, path_1.normalize)(data.input),
         ...buildArguments(data.files ?? []),
@@ -124,9 +168,11 @@ async function unzip(data) {
         stderr: { toExitCode: true },
         stdout: {
             ...(data.onStream && {
-                onData: (chunk) => {
-                    if (data.onStream)
-                        parseUnzipStream(chunk, data.onStream);
+                parseLines: true,
+                onData: (line) => {
+                    const stream = parseUnzipLine(line);
+                    if (stream)
+                        data.onStream(stream);
                 },
             }),
         },