typescript-virtual-container 1.5.5 → 1.5.6

package/dist/commands/sed.js

@@ -1,22 +1,74 @@
-import { getFlag, ifFlag } from "./command-helpers";
+import { ifFlag } from "./command-helpers";
 import { resolvePath } from "./helpers";
 /**
- * Stream editor for filtering and transforming text lines.
+ * Stream editor — supports s/pat/rep/[gI], d, p, q, =, addresses (N, /re/, N,M, /re/,/re/, $).
  * @category text
- * @params ["-e <expr> [file]", "s/pattern/replace/[g]"]
+ * @params ["[-n] [-e <expr>] [file]"]
  */
 export const sedCommand = {
     name: "sed",
     description: "Stream editor for filtering and transforming text",
     category: "text",
-    params: ["-e <expr> [file]", "s/pattern/replace/[g]"],
+    params: ["[-n] [-e <expr>] [file]"],
     run: ({ authUser, shell, cwd, args, stdin }) => {
         const inPlace = ifFlag(args, ["-i"]);
-        const expr = getFlag(args, ["-e"]) ??
-            args.find((a) => !a.startsWith("-"));
-        const fileArg = args.filter((a) => !a.startsWith("-") && a !== expr).pop();
-        if (!expr)
+        const suppressAuto = ifFlag(args, ["-n"]);
+        // Collect all -e expressions and the first non-flag positional
+        const exprs = [];
+        let fileArg;
+        let i = 0;
+        while (i < args.length) {
+            const a = args[i];
+            if (a === "-e" || a === "--expression") {
+                i++;
+                if (args[i])
+                    exprs.push(args[i]);
+                i++;
+            }
+            else if (a === "-n" || a === "-i") {
+                i++;
+            }
+            else if (a.startsWith("-e")) {
+                exprs.push(a.slice(2));
+                i++;
+            }
+            else if (!a.startsWith("-")) {
+                if (exprs.length === 0)
+                    exprs.push(a);
+                else
+                    fileArg = a;
+                i++;
+            }
+            else {
+                i++;
+            }
+        }
+        // If only one positional collected as expr and no file yet, check for file after
+        // Re-parse: first non-flag that follows all -e is the file
+        if (exprs.length === 0)
             return { stderr: "sed: no expression", exitCode: 1 };
+        // Re-check: if exprs[0] was set from positional, remaining positionals are files
+        {
+            let foundExprFromFlag = false;
+            let j = 0;
+            while (j < args.length) {
+                const a = args[j];
+                if (a === "-e" || a === "--expression") {
+                    foundExprFromFlag = true;
+                    j += 2;
+                }
+                else if (a.startsWith("-e")) {
+                    foundExprFromFlag = true;
+                    j++;
+                }
+                else
+                    j++;
+            }
+            if (!foundExprFromFlag) {
+                // expr is first positional, file is second
+                fileArg = args.filter((a) => !a.startsWith("-")).slice(1)[0];
+            }
+        }
         let content = stdin ?? "";
         if (fileArg) {
             const p = resolvePath(cwd, fileArg);
@@ -24,32 +76,162 @@ export const sedCommand = {
                 content = shell.vfs.readFile(p);
             }
             catch {
-                return {
-                    stderr: `sed: ${fileArg}: No such file or directory`,
-                    exitCode: 1,
-                };
-            }
-        }
-        // Parse s/from/to/[g]
-        const sMatch = expr.match(/^s([^a-zA-Z0-9])(.+?)\1(.*?)\1([gi]*)$/);
-        if (!sMatch)
-            return { stderr: `sed: unrecognized command: ${expr}`, exitCode: 1 };
-        const [, , from, to, flags] = sMatch;
-        const regexFlags = (flags ?? "").includes("i")
-            ? "gi"
-            : (flags ?? "").includes("g")
-                ? "g"
-                : "";
-        let regex;
-        try {
-            regex = new RegExp(from, regexFlags || "");
-        }
-        catch (_e) {
-            return { stderr: `sed: invalid regex: ${from}`, exitCode: 1 };
-        }
-        const result = (flags ?? "").includes("g") || regexFlags.includes("g")
-            ? content.replace(regex, to ?? "")
-            : content.replace(regex, to ?? "");
+                return { stderr: `sed: ${fileArg}: No such file or directory`, exitCode: 1 };
+            }
+        }
+        function parseAddr(s) {
+            if (!s)
+                return [undefined, s];
+            if (s[0] === "$")
+                return [{ type: "last" }, s.slice(1)];
+            if (/^\d/.test(s)) {
+                const m = s.match(/^(\d+)(.*)/s);
+                if (m)
+                    return [{ type: "line", n: parseInt(m[1], 10) }, m[2]];
+            }
+            if (s[0] === "/") {
+                const end = s.indexOf("/", 1);
+                if (end !== -1) {
+                    try {
+                        const re = new RegExp(s.slice(1, end));
+                        return [{ type: "regex", re }, s.slice(end + 1)];
+                    }
+                    catch { /* bad regex */ }
+                }
+            }
+            return [undefined, s];
+        }
+        function parseInstrs(expr) {
+            const instrs = [];
+            // Split on unquoted semicolons or newlines
+            const parts = expr.split(/\n|(?<=^|[^\\]);/);
+            for (const raw of parts) {
+                const part = raw.trim();
+                if (!part || part.startsWith("#"))
+                    continue;
+                let rest = part;
+                const [addr1, after1] = parseAddr(rest);
+                rest = after1.trim();
+                let addr2;
+                if (rest[0] === ",") {
+                    rest = rest.slice(1).trim();
+                    const [a2, after2] = parseAddr(rest);
+                    addr2 = a2;
+                    rest = after2.trim();
+                }
+                const op = rest[0];
+                if (!op)
+                    continue;
+                if (op === "s") {
+                    // s/from/to/flags
+                    const delim = rest[1] ?? "/";
+                    const sRe = new RegExp(`^s${re(delim)}((?:[^${re(delim)}\\\\]|\\\\.)*)${re(delim)}((?:[^${re(delim)}\\\\]|\\\\.)*)${re(delim)}([gGiIp]*)$`);
+                    const m = rest.match(sRe);
+                    if (!m) {
+                        instrs.push({ op: "d", addr1, addr2 });
+                        continue;
+                    } // bad expr, skip
+                    const flags = m[3] ?? "";
+                    let from;
+                    try {
+                        from = new RegExp(m[1], flags.includes("i") || flags.includes("I") ? "i" : "");
+                    }
+                    catch {
+                        continue;
+                    }
+                    instrs.push({ op: "s", addr1, addr2, from, to: m[2], global: flags.includes("g") || flags.includes("G"), print: flags.includes("p") });
+                }
+                else if (op === "d") {
+                    instrs.push({ op: "d", addr1, addr2 });
+                }
+                else if (op === "p") {
+                    instrs.push({ op: "p", addr1, addr2 });
+                }
+                else if (op === "q") {
+                    instrs.push({ op: "q", addr1 });
+                }
+                else if (op === "=") {
+                    instrs.push({ op: "=", addr1, addr2 });
+                }
+            }
+            return instrs;
+        }
+        function re(c) {
+            return c.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        }
+        const allInstrs = exprs.flatMap(parseInstrs);
+        const lines = content.split("\n");
+        // Remove trailing empty string from trailing newline
+        if (lines[lines.length - 1] === "")
+            lines.pop();
+        const total = lines.length;
+        function matchesAddr(addr, lineNo, line) {
+            if (!addr)
+                return true;
+            if (addr.type === "line")
+                return lineNo === addr.n;
+            if (addr.type === "last")
+                return lineNo === total;
+            return addr.re.test(line);
+        }
+        function inRange(instr, lineNo, line, rangeActive) {
+            const { addr1, addr2 } = instr;
+            if (!addr1)
+                return true;
+            if (!addr2)
+                return matchesAddr(addr1, lineNo, line);
+            // Two-address range
+            let active = rangeActive.get(instr) ?? false;
+            if (!active && matchesAddr(addr1, lineNo, line)) {
+                active = true;
+                rangeActive.set(instr, true);
+            }
+            if (active && matchesAddr(addr2, lineNo, line)) {
+                rangeActive.set(instr, false);
+                return true;
+            }
+            if (active)
+                return true;
+            return false;
+        }
+        const out = [];
+        const rangeActive = new Map();
+        let quit = false;
+        for (let li = 0; li < lines.length && !quit; li++) {
+            let line = lines[li];
+            const lineNo = li + 1;
+            let deleted = false;
+            for (const instr of allInstrs) {
+                if (!inRange(instr, lineNo, line, rangeActive))
+                    continue;
+                if (instr.op === "d") {
+                    deleted = true;
+                    break;
+                }
+                if (instr.op === "p") {
+                    out.push(line);
+                }
+                if (instr.op === "=") {
+                    out.push(String(lineNo));
+                }
+                if (instr.op === "q") {
+                    quit = true;
+                }
+                if (instr.op === "s") {
+                    const replaced = instr.global
+                        ? line.replace(new RegExp(instr.from.source, instr.from.flags.includes("i") ? "gi" : "g"), instr.to)
+                        : line.replace(instr.from, instr.to);
+                    if (replaced !== line) {
+                        line = replaced;
+                        if (instr.print && suppressAuto)
+                            out.push(line);
+                    }
+                }
+            }
+            if (!deleted && !suppressAuto)
+                out.push(line);
+        }
+        const result = out.join("\n") + (out.length > 0 ? "\n" : "");
         if (inPlace && fileArg) {
             const p = resolvePath(cwd, fileArg);
             shell.writeFileAsUser(authUser, p, result);

package/dist/commands/sh.js

@@ -125,6 +125,32 @@ function parseBlocks(lines) {
             }
             blocks.push({ type: "while", cond, body });
         }
+        else if (line.startsWith("until ")) {
+            const cond = line
+                .replace(/^until\s+/, "")
+                .replace(/;\s*do\s*$/, "")
+                .trim();
+            const body = [];
+            i++;
+            while (i < lines.length && lines[i]?.trim() !== "done") {
+                const l = lines[i].trim().replace(/^do\s+/, "");
+                if (l && l !== "do")
+                    body.push(l);
+                i++;
+            }
+            blocks.push({ type: "until", cond, body });
+        }
+        else if (/^[A-Za-z_][A-Za-z0-9_]*=\s*\(/.test(line)) {
+            // Array assignment: arr=(elem1 elem2 ...)
+            const arrMatch = line.match(/^([A-Za-z_][A-Za-z0-9_]*)=\s*\(([^)]*)\)$/);
+            if (arrMatch) {
+                const elems = arrMatch[2].trim().split(/\s+/).filter(Boolean);
+                blocks.push({ type: "array", name: arrMatch[1], elements: elems });
+            }
+            else {
+                blocks.push({ type: "cmd", line });
+            }
+        }
         else if (line.startsWith("case ") && line.endsWith(" in") || line.match(/^case\s+.+\s+in$/)) {
             const caseExpr = line.replace(/^case\s+/, "").replace(/\s+in$/, "").trim();
             const patterns = [];
@@ -353,6 +379,22 @@ async function runBlocks(blocks, ctx) {
                 iterations++;
             }
         }
+        else if (block.type === "until") {
+            let iterations = 0;
+            while (iterations < 1000 && !(await evalCondition(block.cond, ctx))) {
+                const sub = await runBlocks(parseBlocks(block.body), ctx);
+                if (sub.stdout)
+                    output += `${sub.stdout}\n`;
+                if (sub.closeSession)
+                    return sub;
+                iterations++;
+            }
+        }
+        else if (block.type === "array") {
+            // Store array: arr[0]=e0, arr[1]=e1, ..., arr=space-joined (for ${arr[@]})
+            block.elements.forEach((el, idx) => { ctx.env.vars[`${block.name}[${idx}]`] = el; });
+            ctx.env.vars[block.name] = block.elements.join(" ");
+        }
         else if (block.type === "case") {
             const expanded = await expandVars(block.expr, ctx.env.vars, ctx.env.lastExitCode, ctx);
             for (const pat of block.patterns) {

package/dist/commands/strace.d.ts

@@ -0,0 +1,6 @@
+import type { ShellModule } from "../types/commands";
+/**
+ * Trace system calls and signals (stub — runs command, emits fake strace output).
+ * @category system
+ */
+export declare const straceCommand: ShellModule;

package/dist/commands/strace.js

@@ -0,0 +1,26 @@
+/**
+ * Trace system calls and signals (stub — runs command, emits fake strace output).
+ * @category system
+ */
+export const straceCommand = {
+    name: "strace",
+    description: "Trace system calls and signals",
+    category: "system",
+    params: ["[-e <expr>] [-o <file>] <command> [args]"],
+    run: ({ args }) => {
+        const cmd = args.find((a) => !a.startsWith("-"));
+        if (!cmd)
+            return { stderr: "strace: must have PROG [ARGS] or -p PID", exitCode: 1 };
+        const pid = Math.floor(Math.random() * 30000) + 1000;
+        const lines = [
+            `execve("/usr/bin/${cmd}", ["${cmd}"${args.slice(1).map((a) => `, "${a}"`).join("")}], 0x... /* ... vars */) = 0`,
+            `brk(NULL)                               = 0x${(Math.random() * 0xfffff | 0).toString(16)}000`,
+            `access("/etc/ld.so.preload", R_OK)      = -1 ENOENT (No such file or directory)`,
+            `openat(AT_FDCWD, "/etc/ld.so.cache", O_RDONLY|O_CLOEXEC) = 3`,
+            `fstat(3, {st_mode=S_IFREG|0644, st_size=...}) = 0`,
+            `close(3)                                = 0`,
+            `+++ exited with 0 +++`,
+        ];
+        return { stderr: lines.join("\n"), exitCode: 0 };
+    },
+};

package/dist/commands/tar.d.ts

@@ -1,6 +1,7 @@
 import type { ShellModule } from "../types/commands";
 /**
- * Archive or extract files with tar and optional gzip compression.
+ * Archive or extract files with tar — writes real POSIX ustar binary format.
+ * Supports -c/-x/-t, -z (gzip), -j (bzip2 stub), -v (verbose), -f.
  * @category archive
  * @params ["[-czf|-xzf|-tf] <archive> [files...]"]
  */

package/dist/commands/tar.js

@@ -1,6 +1,71 @@
+import { gunzipSync, gzipSync } from "fflate";
 import { resolvePath } from "./helpers";
+// ── POSIX ustar tar format ────────────────────────────────────────────────────
+function makeTarHeader(name, size, isDir) {
+    const hdr = Buffer.alloc(512);
+    const enc = (s, off, len) => {
+        const b = Buffer.from(s, "ascii");
+        b.copy(hdr, off, 0, Math.min(b.length, len));
+    };
+    enc(isDir ? `${name}/` : name, 0, 100);
+    enc(isDir ? "0000755\0" : "0000644\0", 100, 8);
+    enc("0000000\0", 108, 8);
+    enc("0000000\0", 116, 8);
+    enc(size.toString(8).padStart(11, "0") + "\0", 124, 12);
+    enc(Math.floor(Date.now() / 1000).toString(8).padStart(11, "0") + "\0", 136, 12);
+    hdr[156] = isDir ? 0x35 : 0x30; // '5' dir, '0' file
+    enc("ustar\0", 257, 6);
+    enc("00", 263, 2);
+    enc("root\0", 265, 32); // uname
+    enc("root\0", 297, 32); // gname
+    // Checksum: fill field with spaces, compute, write
+    for (let i = 148; i < 156; i++)
+        hdr[i] = 0x20;
+    let sum = 0;
+    for (let i = 0; i < 512; i++)
+        sum += hdr[i];
+    Buffer.from(`${sum.toString(8).padStart(6, "0")}\0 `).copy(hdr, 148);
+    return hdr;
+}
+function tarPad(size) {
+    const rem = size % 512;
+    return rem === 0 ? Buffer.alloc(0) : Buffer.alloc(512 - rem);
+}
+function buildTar(entries) {
+    const parts = [];
+    for (const { name, content, isDir } of entries) {
+        parts.push(makeTarHeader(name, isDir ? 0 : content.length, isDir));
+        if (!isDir) {
+            parts.push(content);
+            parts.push(tarPad(content.length));
+        }
+    }
+    parts.push(Buffer.alloc(1024)); // end-of-archive
+    return Buffer.concat(parts);
+}
+function parseTar(raw) {
+    const files = [];
+    let off = 0;
+    while (off + 512 <= raw.length) {
+        const hdr = raw.slice(off, off + 512);
+        if (hdr.every((b) => b === 0))
+            break;
+        const name = hdr.slice(0, 100).toString("ascii").replace(/\0.*/, "");
+        const sizeStr = hdr.slice(124, 135).toString("ascii").replace(/\0.*/, "").trim();
+        const size = parseInt(sizeStr, 8) || 0;
+        const typeflag = hdr[156];
+        off += 512;
+        if (name && typeflag !== 0x35 && typeflag !== 53) { // not a directory
+            const content = raw.slice(off, off + size);
+            files.push({ name, content });
+        }
+        off += Math.ceil(size / 512) * 512;
+    }
+    return files;
+}
 /**
- * Archive or extract files with tar and optional gzip compression.
+ * Archive or extract files with tar — writes real POSIX ustar binary format.
+ * Supports -c/-x/-t, -z (gzip), -j (bzip2 stub), -v (verbose), -f.
  * @category archive
  * @params ["[-czf|-xzf|-tf] <archive> [files...]"]
  */
@@ -10,17 +75,15 @@ export const tarCommand = {
     category: "archive",
     params: ["[-czf|-xzf|-tf] <archive> [files...]"],
     run: ({ authUser, shell, cwd, args }) => {
-        // Expand combined flags: -czf or czf (bare mode string) → ["-c", "-z", "-f"]
+        // Expand combined flags: -czf → ["-c", "-z", "-f"]
         const expanded = [];
         let foundModeStr = false;
         for (const a of args) {
             if (/^-[a-zA-Z]{2,}$/.test(a)) {
-                // -czf style
                 for (const ch of a.slice(1))
                     expanded.push(`-${ch}`);
             }
-            else if (!foundModeStr && /^[cxtdru]{1,}[a-zA-Z]*$/.test(a) && !a.includes("/") && !a.startsWith("-")) {
-                // czf bare style (first non-path arg)
+            else if (!foundModeStr && /^[cxtdru][a-zA-Z]*$/.test(a) && !a.includes("/") && !a.startsWith("-")) {
                 foundModeStr = true;
                 for (const ch of a)
                     expanded.push(`-${ch}`);
@@ -32,70 +95,93 @@ export const tarCommand = {
         const create = expanded.includes("-c");
         const extract = expanded.includes("-x");
         const list = expanded.includes("-t");
+        const useGzip = expanded.includes("-z");
+        const verbose = expanded.includes("-v");
         const fIdx = expanded.indexOf("-f");
         const archiveName = fIdx !== -1
             ? expanded[fIdx + 1]
-            : expanded.find((a) => a.endsWith(".tar") || a.endsWith(".tar.gz") || a.endsWith(".tgz"));
-        if (!create && !extract && !list) {
-            return { stderr: "tar: must specify -c, -x, or -t\n", exitCode: 1 };
-        }
+            : expanded.find((a) => a.endsWith(".tar") || a.endsWith(".tar.gz") || a.endsWith(".tgz") || a.endsWith(".tar.bz2"));
+        if (!create && !extract && !list)
+            return { stderr: "tar: must specify -c, -x, or -t", exitCode: 1 };
         if (!archiveName)
-            return { stderr: "tar: no archive specified\n", exitCode: 1 };
+            return { stderr: "tar: no archive specified", exitCode: 1 };
         const archivePath = resolvePath(cwd, archiveName);
+        const autoGzip = useGzip || archiveName.endsWith(".gz") || archiveName.endsWith(".tgz");
         if (create) {
-            // Skip flags and archive name from file list
-            const skipNext2 = new Set();
-            if (fIdx !== -1)
-                skipNext2.add(fIdx + 1);
-            const fileArgs = expanded.filter((a, i) => !a.startsWith("-") && a !== archiveName && !skipNext2.has(i));
-            const entries = {};
+            const skipSet = new Set();
+            if (fIdx !== -1 && expanded[fIdx + 1])
+                skipSet.add(expanded[fIdx + 1]);
+            const fileArgs = expanded.filter((a) => !a.startsWith("-") && !skipSet.has(a));
+            const entries = [];
+            const verboseLines = [];
             for (const f of fileArgs) {
                 const p = resolvePath(cwd, f);
-                try {
-                    const stat = shell.vfs.stat(p);
-                    if (stat.type === "file")
-                        entries[f] = shell.vfs.readFile(p);
-                    else {
-                        const walk = (dir, prefix) => {
-                            for (const e of shell.vfs.list(dir)) {
-                                const full = `${dir}/${e}`, rel = `${prefix}/${e}`;
-                                const s = shell.vfs.stat(full);
-                                if (s.type === "file")
-                                    entries[rel] = shell.vfs.readFile(full);
-                                else
-                                    walk(full, rel);
-                            }
-                        };
-                        walk(p, f);
-                    }
+                if (!shell.vfs.exists(p))
+                    return { stderr: `tar: ${f}: No such file or directory`, exitCode: 1 };
+                const st = shell.vfs.stat(p);
+                if (st.type === "file") {
+                    const content = shell.vfs.readFileRaw(p);
+                    entries.push({ name: f, content, isDir: false });
+                    if (verbose)
+                        verboseLines.push(f);
                 }
-                catch {
-                    return {
-                        stderr: `tar: ${f}: No such file or directory`,
-                        exitCode: 1,
+                else {
+                    entries.push({ name: f, content: Buffer.alloc(0), isDir: true });
+                    if (verbose)
+                        verboseLines.push(`${f}/`);
+                    const walk = (dir, prefix) => {
+                        for (const e of shell.vfs.list(dir)) {
+                            const full = `${dir}/${e}`, rel = `${prefix}/${e}`;
+                            const s = shell.vfs.stat(full);
+                            if (s.type === "directory") {
+                                entries.push({ name: rel, content: Buffer.alloc(0), isDir: true });
+                                if (verbose)
+                                    verboseLines.push(`${rel}/`);
+                                walk(full, rel);
+                            }
+                            else {
+                                const content = shell.vfs.readFileRaw(full);
+                                entries.push({ name: rel, content, isDir: false });
+                                if (verbose)
+                                    verboseLines.push(rel);
+                            }
+                        }
                     };
+                    walk(p, f);
                 }
             }
-            shell.writeFileAsUser(authUser, archivePath, JSON.stringify(entries));
-            return { exitCode: 0 };
+            const tarBuf = buildTar(entries);
+            const finalBuf = autoGzip ? Buffer.from(gzipSync(tarBuf)) : tarBuf;
+            shell.vfs.writeFile(archivePath, finalBuf);
+            return { stdout: verbose ? verboseLines.join("\n") : undefined, exitCode: 0 };
         }
         if (list || extract) {
-            let entries;
-            try {
-                entries = JSON.parse(shell.vfs.readFile(archivePath));
+            const rawArchive = shell.vfs.readFileRaw(archivePath);
+            let raw;
+            if (autoGzip) {
+                try {
+                    raw = Buffer.from(gunzipSync(rawArchive));
+                }
+                catch {
+                    return { stderr: `tar: ${archiveName}: not a gzip file`, exitCode: 1 };
+                }
+            }
+            else {
+                raw = rawArchive;
             }
-            catch {
-                return {
-                    stderr: `tar: ${archiveName}: cannot open archive`,
-                    exitCode: 1,
-                };
+            const files = parseTar(raw);
+            if (list) {
+                const names = files.map((f) => (verbose ? `-rw-r--r-- 0/0 ${f.content.length.toString().padStart(8)} 1970-01-01 00:00 ${f.name}` : f.name));
+                return { stdout: names.join("\n"), exitCode: 0 };
             }
-            if (list)
-                return { stdout: Object.keys(entries).join("\n"), exitCode: 0 };
-            for (const [name, content] of Object.entries(entries)) {
-                shell.writeFileAsUser(authUser, resolvePath(cwd, name), content);
+            const verboseLines = [];
+            for (const { name, content } of files) {
+                const destPath = resolvePath(cwd, name);
+                shell.writeFileAsUser(authUser, destPath, content);
+                if (verbose)
+                    verboseLines.push(name);
             }
-            return { exitCode: 0 };
+            return { stdout: verbose ? verboseLines.join("\n") : undefined, exitCode: 0 };
         }
         return { stderr: "tar: must specify -c, -x, or -t", exitCode: 1 };
     },

package/dist/commands/zip.d.ts

@@ -0,0 +1,11 @@
+import type { ShellModule } from "../types/commands";
+/**
+ * Create ZIP archives using real PKZIP format with DEFLATE compression.
+ * @category archive
+ */
+export declare const zipCommand: ShellModule;
+/**
+ * Extract ZIP archives (real PKZIP DEFLATE format).
+ * @category archive
+ */
+export declare const unzipCommand: ShellModule;