typescript-virtual-container 1.5.5 → 1.5.7

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/test.js

@@ -1,3 +1,4 @@
+import { resolvePath } from "./helpers";
 /**
  * Evaluate a POSIX test expression.
  * Supports: -f, -d, -e, -r, -w, -x, -s, -z, -n,
@@ -33,8 +34,7 @@ function evalTest(tokens, shell, cwd) {
     // Unary file tests
     if (tokens.length === 2) {
         const [flag, operand = ""] = tokens;
-        const resolvePath = (p) => p.startsWith("/") ? p : `${cwd}/${p}`.replace(/\/+/g, "/");
-        const path = resolvePath(operand);
+        const path = resolvePath(cwd, operand);
         switch (flag) {
             case "-e":
                 return shell.vfs.exists(path);

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;

package/dist/commands/zip.js

@@ -0,0 +1,232 @@
+import { deflateSync, inflateSync } from "fflate";
+import { resolvePath } from "./helpers";
+// ── CRC32 ─────────────────────────────────────────────────────────────────────
+const CRC_TABLE = (() => {
+    const t = new Uint32Array(256);
+    for (let i = 0; i < 256; i++) {
+        let c = i;
+        for (let j = 0; j < 8; j++)
+            c = c & 1 ? (0xedb88320 ^ (c >>> 1)) : (c >>> 1);
+        t[i] = c;
+    }
+    return t;
+})();
+function crc32(buf) {
+    let crc = 0xffffffff;
+    for (let i = 0; i < buf.length; i++)
+        crc = (CRC_TABLE[(crc ^ buf[i]) & 0xff] ^ (crc >>> 8)) >>> 0;
+    return (crc ^ 0xffffffff) >>> 0;
+}
+// ── DOS date/time from JS Date ────────────────────────────────────────────────
+function dosDateTime() {
+    const d = new Date();
+    const date = ((d.getFullYear() - 1980) << 9) | ((d.getMonth() + 1) << 5) | d.getDate();
+    const time = (d.getHours() << 11) | (d.getMinutes() << 5) | Math.floor(d.getSeconds() / 2);
+    return [time, date];
+}
+// ── ZIP builder ───────────────────────────────────────────────────────────────
+function buildZip(entries) {
+    const parts = [];
+    const cdParts = [];
+    let offset = 0;
+    const [modTime, modDate] = dosDateTime();
+    for (const { name, content } of entries) {
+        const nameBuf = Buffer.from(name, "utf8");
+        const compressed = Buffer.from(deflateSync(content, { level: 6 }));
+        const useDeflate = compressed.length < content.length;
+        const stored = useDeflate ? compressed : content;
+        const crc = crc32(content);
+        const method = useDeflate ? 8 : 0;
+        // Local file header
+        const lfh = Buffer.alloc(30 + nameBuf.length);
+        lfh.writeUInt32LE(0x04034b50, 0);
+        lfh.writeUInt16LE(20, 4);
+        lfh.writeUInt16LE(0x0800, 6); // UTF-8 flag
+        lfh.writeUInt16LE(method, 8);
+        lfh.writeUInt16LE(modTime, 10);
+        lfh.writeUInt16LE(modDate, 12);
+        lfh.writeUInt32LE(crc, 14);
+        lfh.writeUInt32LE(stored.length, 18);
+        lfh.writeUInt32LE(content.length, 22);
+        lfh.writeUInt16LE(nameBuf.length, 26);
+        lfh.writeUInt16LE(0, 28);
+        nameBuf.copy(lfh, 30);
+        // Central directory entry
+        const cd = Buffer.alloc(46 + nameBuf.length);
+        cd.writeUInt32LE(0x02014b50, 0);
+        cd.writeUInt16LE(20, 4);
+        cd.writeUInt16LE(20, 6);
+        cd.writeUInt16LE(0x0800, 8);
+        cd.writeUInt16LE(method, 10);
+        cd.writeUInt16LE(modTime, 12);
+        cd.writeUInt16LE(modDate, 14);
+        cd.writeUInt32LE(crc, 16);
+        cd.writeUInt32LE(stored.length, 20);
+        cd.writeUInt32LE(content.length, 24);
+        cd.writeUInt16LE(nameBuf.length, 28);
+        cd.writeUInt16LE(0, 30); // extra
+        cd.writeUInt16LE(0, 32); // comment
+        cd.writeUInt16LE(0, 34); // disk start
+        cd.writeUInt16LE(0, 36); // int attr
+        cd.writeUInt32LE(0x81a40000, 38); // ext attr: -rw-r--r--
+        cd.writeUInt32LE(offset, 42);
+        nameBuf.copy(cd, 46);
+        parts.push(lfh, stored);
+        cdParts.push(cd);
+        offset += lfh.length + stored.length;
+    }
+    const cdBuf = Buffer.concat(cdParts);
+    const eocd = Buffer.alloc(22);
+    eocd.writeUInt32LE(0x06054b50, 0);
+    eocd.writeUInt16LE(0, 4);
+    eocd.writeUInt16LE(0, 6);
+    eocd.writeUInt16LE(entries.length, 8);
+    eocd.writeUInt16LE(entries.length, 10);
+    eocd.writeUInt32LE(cdBuf.length, 12);
+    eocd.writeUInt32LE(offset, 16);
+    eocd.writeUInt16LE(0, 20);
+    return Buffer.concat([...parts, cdBuf, eocd]);
+}
+// ── ZIP parser ────────────────────────────────────────────────────────────────
+function parseZip(raw) {
+    const files = [];
+    let off = 0;
+    while (off + 4 <= raw.length) {
+        const sig = raw.readUInt32LE(off);
+        if (sig === 0x02014b50 || sig === 0x06054b50)
+            break; // central dir / EOCD
+        if (sig !== 0x04034b50) {
+            off++;
+            continue;
+        }
+        const method = raw.readUInt16LE(off + 8);
+        const compSize = raw.readUInt32LE(off + 18);
+        const uncompSize = raw.readUInt32LE(off + 22);
+        const nameLen = raw.readUInt16LE(off + 26);
+        const extraLen = raw.readUInt16LE(off + 28);
+        const name = raw.subarray(off + 30, off + 30 + nameLen).toString("utf8");
+        const dataOff = off + 30 + nameLen + extraLen;
+        const compData = raw.subarray(dataOff, dataOff + compSize);
+        let content;
+        if (method === 8) {
+            try {
+                content = Buffer.from(inflateSync(compData));
+            }
+            catch {
+                content = compData;
+            }
+        }
+        else {
+            content = compData;
+        }
+        if (name && !name.endsWith("/")) {
+            // Validate size
+            if (content.length === uncompSize || method !== 0)
+                files.push({ name, content });
+            else
+                files.push({ name, content });
+        }
+        off = dataOff + compSize;
+    }
+    return files;
+}
+// ── Commands ──────────────────────────────────────────────────────────────────
+/**
+ * Create ZIP archives using real PKZIP format with DEFLATE compression.
+ * @category archive
+ */
+export const zipCommand = {
+    name: "zip",
+    description: "Package and compress files",
+    category: "archive",
+    params: ["[-r] <archive.zip> <file...>"],
+    run: ({ shell, cwd, args }) => {
+        const recursive = args.includes("-r") || args.includes("-R");
+        const files = args.filter((a) => !a.startsWith("-"));
+        const archiveArg = files[0];
+        const sources = files.slice(1);
+        if (!archiveArg)
+            return { stderr: "zip: no archive specified", exitCode: 1 };
+        if (sources.length === 0)
+            return { stderr: "zip: nothing to do!", exitCode: 12 };
+        const archivePath = resolvePath(cwd, archiveArg.endsWith(".zip") ? archiveArg : `${archiveArg}.zip`);
+        const entries = [];
+        const verboseLines = [];
+        for (const src of sources) {
+            const p = resolvePath(cwd, src);
+            if (!shell.vfs.exists(p))
+                return { stderr: `zip warning: name not matched: ${src}`, exitCode: 12 };
+            const st = shell.vfs.stat(p);
+            if (st.type === "file") {
+                const content = shell.vfs.readFileRaw(p);
+                entries.push({ name: src, content });
+                verboseLines.push(`  adding: ${src} (deflated)`);
+            }
+            else if (recursive) {
+                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")
+                            walk(full, rel);
+                        else {
+                            const content = shell.vfs.readFileRaw(full);
+                            entries.push({ name: rel, content });
+                            verboseLines.push(`  adding: ${rel} (deflated)`);
+                        }
+                    }
+                };
+                walk(p, src);
+            }
+        }
+        if (entries.length === 0)
+            return { stderr: "zip: nothing to do!", exitCode: 12 };
+        const zipBuf = buildZip(entries);
+        shell.vfs.writeFile(archivePath, zipBuf);
+        return { stdout: verboseLines.join("\n"), exitCode: 0 };
+    },
+};
+/**
+ * Extract ZIP archives (real PKZIP DEFLATE format).
+ * @category archive
+ */
+export const unzipCommand = {
+    name: "unzip",
+    description: "Extract compressed files from ZIP archives",
+    category: "archive",
+    params: ["[-l] [-o] <archive.zip> [-d <dir>]"],
+    run: ({ shell, cwd, args }) => {
+        const listOnly = args.includes("-l");
+        const dIdx = args.indexOf("-d");
+        const destDir = dIdx !== -1 ? args[dIdx + 1] : undefined;
+        const archive = args.find((a) => !a.startsWith("-") && a !== destDir);
+        if (!archive)
+            return { stderr: "unzip: missing archive operand", exitCode: 1 };
+        const archivePath = resolvePath(cwd, archive);
+        if (!shell.vfs.exists(archivePath))
+            return { stderr: `unzip: cannot find or open ${archive}`, exitCode: 9 };
+        const raw = shell.vfs.readFileRaw(archivePath);
+        let files;
+        try {
+            files = parseZip(raw);
+        }
+        catch {
+            return { stderr: `unzip: ${archive}: not a valid ZIP file`, exitCode: 1 };
+        }
+        const dest = destDir ? resolvePath(cwd, destDir) : cwd;
+        if (listOnly) {
+            const header = `Archive:  ${archive}\n  Length      Date    Time    Name\n---------  ---------- -----   ----`;
+            const rows = files.map((f) => `  ${String(f.content.length).padStart(8)}  2024-01-01 00:00   ${f.name}`);
+            const total = files.reduce((s, f) => s + f.content.length, 0);
+            const footer = `---------                     -------\n  ${String(total).padStart(8)}                     ${files.length} file${files.length !== 1 ? "s" : ""}`;
+            return { stdout: `${header}\n${rows.join("\n")}\n${footer}`, exitCode: 0 };
+        }
+        const out = [`Archive:  ${archive}`];
+        for (const { name, content } of files) {
+            const destPath = `${dest}/${name}`;
+            shell.vfs.writeFile(destPath, content);
+            out.push(`  inflating: ${destPath}`);
+        }
+        return { stdout: out.join("\n"), exitCode: 0 };
+    },
+};

package/dist/modules/linuxRootfs.js

@@ -1281,7 +1281,7 @@ Installed-Size: 6800
 Maintainer: Fortune Package Team <dpkg@fortune.local>
 Architecture: amd64
 Version: 1.22.6nyx1
-Depends: libc6 (>= 2.17), libzstd1 (>= 1.5.5)
+Depends: libc6 (>= 2.17), libzstd1 (>= 1.5.7)
 Description: Fortune package management system
  This package provides the low-level infrastructure for handling the
  installation and removal of Fortune software packages.
@@ -1547,12 +1547,9 @@ export function bootstrapLinuxRootfs(vfs, users, hostname, props, shellStartTime
     const snapshot = getStaticRootfsSnapshot(hostname, props);
     const hasRestoredData = vfs.getMode() === "fs" && vfs.exists("/home");
     if (hasRestoredData) {
-        // Snapshot was already restored — merge static rootfs without
-        // clobbering user files and directories.
         vfs.mergeRootTree(decodeVfs(snapshot));
     }
     else {
-        // Fresh start — replace the empty tree with the full static rootfs.
         vfs.importRootTree(decodeVfs(snapshot));
     }
     bootstrapRoot(vfs);

package/dist/modules/neofetch.js

@@ -208,10 +208,10 @@ function resolveDefaults(info) {
             os: info.osName ?? `${readOsPrettyName() ?? os.type()} ${os.arch()}`,
             arch: os.arch(),
         },
-        resolution: info.resolution ?? "n/a (ssh)",
+        resolution: info.resolution ?? shellProps?.resolution ?? "n/a (ssh)",
         terminal: info.terminal ?? "unknown",
         cpu: info.cpu ?? resolveCpuLabel(),
-        gpu: info.gpu ?? "n/a",
+        gpu: info.gpu ?? shellProps?.gpu ?? "n/a",
         memoryUsedMiB: info.memoryUsedMiB ?? toMiB(usedMem),
         memoryTotalMiB: info.memoryTotalMiB ?? toMiB(totalMem),
     };

package/dist/types/commands.d.ts

@@ -94,6 +94,10 @@ export interface ShellEnv {
     vars: Record<string, string>;
     /** Exit status of the last executed command. */
     lastExitCode: number;
+    /** @internal Cached split of vars.PATH — invalidated when _pathRaw !== vars.PATH. */
+    _pathRaw?: string;
+    /** @internal Pre-split PATH directories for resolveVfsBinary hot-path. */
+    _pathDirs?: string[];
 }
 /** Runtime context object passed to each command module. */
 export interface CommandContext {

package/dist/utils/argv.d.ts

@@ -0,0 +1,6 @@
+/** Returns true if `name` appears in `argv`. */
+export declare function getFlag(argv: string[], name: string): boolean;
+/** Returns the string value for `--name=VALUE` or `--name VALUE`, or `fallback`. */
+export declare function getOptionString(argv: string[], name: string, fallback: string): string;
+/** Returns the integer value for `--name=VALUE` or `--name VALUE`, or `fallback`. */
+export declare function getOptionInt(argv: string[], name: string, fallback: number): number;

package/dist/utils/argv.js

@@ -0,0 +1,32 @@
+/** Returns true if `name` appears in `argv`. */
+export function getFlag(argv, name) {
+    return argv.includes(name);
+}
+/** Returns the string value for `--name=VALUE` or `--name VALUE`, or `fallback`. */
+export function getOptionString(argv, name, fallback) {
+    const prefix = `${name}=`;
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a.startsWith(prefix))
+            return a.slice(prefix.length);
+        if (a === name) {
+            const next = argv[i + 1];
+            return (next && !next.startsWith("--")) ? next : fallback;
+        }
+    }
+    return fallback;
+}
+/** Returns the integer value for `--name=VALUE` or `--name VALUE`, or `fallback`. */
+export function getOptionInt(argv, name, fallback) {
+    const prefix = `${name}=`;
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a.startsWith(prefix))
+            return parseInt(a.slice(prefix.length), 10);
+        if (a === name) {
+            const next = argv[i + 1];
+            return next ? parseInt(next, 10) : fallback;
+        }
+    }
+    return fallback;
+}

package/dist/utils/expand.d.ts

@@ -61,10 +61,13 @@ export declare function expandAsync(input: string, env: Record<string, string>,
  * Supports * (any chars in segment) and ** (any path).
  * Returns the original pattern if no matches found (bash behavior).
  */
-export declare function expandGlob(pattern: string, cwd: string, vfs: {
+type GlobVfs = {
     list: (p: string) => string[];
     exists: (p: string) => boolean;
     stat: (p: string) => {
         type: string;
     };
-}): string[];
+    statType?: (p: string) => string | null;
+};
+export declare function expandGlob(pattern: string, cwd: string, vfs: GlobVfs): string[];
+export {};