typescript-virtual-container 1.5.5 → 1.5.6

package/dist/commands/bzip2.js

@@ -0,0 +1,91 @@
+import { gunzipSync, gzipSync } from "fflate";
+import { resolvePath } from "./helpers";
+// BZ2 magic bytes: "BZh" — we store gzip data after this marker so our tools
+// can round-trip. Real bzip2 files won't be decompressable this way, but files
+// created and extracted within this VM will work correctly.
+const BZ2_MAGIC = Buffer.from("BZhVFS\0");
+function vfsBzip2(data) {
+    const gz = Buffer.from(gzipSync(data));
+    return Buffer.concat([BZ2_MAGIC, gz]);
+}
+function vfsBunzip2(data) {
+    if (!data.subarray(0, BZ2_MAGIC.length).equals(BZ2_MAGIC))
+        return null;
+    try {
+        return Buffer.from(gunzipSync(data.subarray(BZ2_MAGIC.length)));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Compress files using bzip2 (VFS-internal gzip with BZ2 marker — round-trips within VM).
+ * @category archive
+ */
+export const bzip2Command = {
+    name: "bzip2",
+    description: "Compress files using Burrows-Wheeler algorithm",
+    category: "archive",
+    params: ["[-k] [-d] <file>"],
+    run: ({ authUser, shell, cwd, args }) => {
+        const keepOrig = args.includes("-k") || args.includes("--keep");
+        const decompress = args.includes("-d") || args.includes("--decompress");
+        const file = args.find((a) => !a.startsWith("-"));
+        if (!file)
+            return { stderr: "bzip2: no file specified", exitCode: 1 };
+        const p = resolvePath(cwd, file);
+        if (!shell.vfs.exists(p))
+            return { stderr: `bzip2: ${file}: No such file or directory`, exitCode: 1 };
+        if (decompress) {
+            if (!file.endsWith(".bz2"))
+                return { stderr: `bzip2: ${file}: unknown suffix -- ignored`, exitCode: 1 };
+            const raw = shell.vfs.readFileRaw(p);
+            const result = vfsBunzip2(raw);
+            if (!result)
+                return { stderr: `bzip2: ${file}: data integrity error`, exitCode: 2 };
+            const dest = p.slice(0, -4);
+            shell.writeFileAsUser(authUser, dest, result);
+            if (!keepOrig)
+                shell.vfs.remove(p);
+            return { exitCode: 0 };
+        }
+        if (file.endsWith(".bz2"))
+            return { stderr: `bzip2: ${file}: already has .bz2 suffix -- unchanged`, exitCode: 1 };
+        const raw = shell.vfs.readFileRaw(p);
+        shell.vfs.writeFile(`${p}.bz2`, vfsBzip2(raw));
+        if (!keepOrig)
+            shell.vfs.remove(p);
+        return { exitCode: 0 };
+    },
+};
+/**
+ * Decompress bzip2 files (VFS-internal format).
+ * @category archive
+ */
+export const bunzip2Command = {
+    name: "bunzip2",
+    description: "Decompress bzip2 files",
+    category: "archive",
+    aliases: ["bzcat"],
+    params: ["[-k] <file>"],
+    run: ({ authUser, shell, cwd, args }) => {
+        const keepOrig = args.includes("-k") || args.includes("--keep");
+        const file = args.find((a) => !a.startsWith("-"));
+        if (!file)
+            return { stderr: "bunzip2: no file specified", exitCode: 1 };
+        const p = resolvePath(cwd, file);
+        if (!shell.vfs.exists(p))
+            return { stderr: `bunzip2: ${file}: No such file or directory`, exitCode: 1 };
+        if (!file.endsWith(".bz2"))
+            return { stderr: `bunzip2: ${file}: unknown suffix -- ignored`, exitCode: 1 };
+        const raw = shell.vfs.readFileRaw(p);
+        const result = vfsBunzip2(raw);
+        if (!result)
+            return { stderr: `bunzip2: ${file}: data integrity error`, exitCode: 2 };
+        const dest = p.slice(0, -4);
+        shell.writeFileAsUser(authUser, dest, result);
+        if (!keepOrig)
+            shell.vfs.remove(p);
+        return { exitCode: 0 };
+    },
+};

package/dist/commands/find.d.ts

@@ -1,7 +1,7 @@
 import type { ShellModule } from "../types/commands";
 /**
- * Find files and directories by name and type with minimal pattern support.
+ * Find files and directories with filtering, -exec, -maxdepth, -not, -o, -a.
  * @category files
- * @params ["[path] [-name <pattern>] [-type f|d]"]
+ * @params ["[path] [expression...]"]
  */
 export declare const findCommand: ShellModule;

package/dist/commands/find.js

@@ -1,55 +1,230 @@
-import { getFlag } from "./command-helpers";
 import { assertPathAccess, resolvePath } from "./helpers";
+import { runCommand } from "./runtime";
 /**
- * Find files and directories by name and type with minimal pattern support.
+ * Find files and directories with filtering, -exec, -maxdepth, -not, -o, -a.
  * @category files
- * @params ["[path] [-name <pattern>] [-type f|d]"]
+ * @params ["[path] [expression...]"]
  */
 export const findCommand = {
     name: "find",
     description: "Search for files",
     category: "files",
-    params: ["[path] [-name <pattern>] [-type f|d]"],
-    run: ({ authUser, shell, cwd, args }) => {
-        const namePattern = getFlag(args, ["-name"]);
-        const typeFilter = getFlag(args, ["-type"]);
-        const positionals = args.filter((a) => !a.startsWith("-") && a !== namePattern && a !== typeFilter);
-        const rootArg = positionals[0] ?? ".";
-        const rootPath = resolvePath(cwd, rootArg);
-        try {
-            assertPathAccess(authUser, rootPath, "find");
-            if (!shell.vfs.exists(rootPath)) {
-                return {
-                    stderr: `find: ${rootArg}: No such file or directory`,
-                    exitCode: 1,
-                };
+    params: ["[path] [expression...]"],
+    run: async ({ authUser, shell, cwd, args, env, hostname, mode }) => {
+        // Collect root paths (positional args before first - option)
+        const roots = [];
+        let i = 0;
+        while (i < args.length && !args[i].startsWith("-") && args[i] !== "!" && args[i] !== "(") {
+            roots.push(args[i]);
+            i++;
+        }
+        if (roots.length === 0)
+            roots.push(".");
+        const exprArgs = args.slice(i);
+        let maxDepth = Infinity;
+        let minDepth = 0;
+        const execCmds = [];
+        function parseExpr(tokens, pos) {
+            return parseOr(tokens, pos);
+        }
+        function parseOr(tokens, pos) {
+            let [left, p] = parseAnd(tokens, pos);
+            while (tokens[p] === "-o" || tokens[p] === "-or") {
+                p++;
+                const [right, np] = parseAnd(tokens, p);
+                left = { type: "or", left, right };
+                p = np;
             }
+            return [left, p];
         }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            return { stderr: `find: ${msg}`, exitCode: 1 };
+        function parseAnd(tokens, pos) {
+            let [left, p] = parseNot(tokens, pos);
+            while (p < tokens.length && tokens[p] !== "-o" && tokens[p] !== "-or" && tokens[p] !== ")") {
+                if (tokens[p] === "-a" || tokens[p] === "-and")
+                    p++;
+                if (p >= tokens.length || tokens[p] === "-o" || tokens[p] === ")")
+                    break;
+                const [right, np] = parseNot(tokens, p);
+                left = { type: "and", left, right };
+                p = np;
+            }
+            return [left, p];
+        }
+        function parseNot(tokens, pos) {
+            if (tokens[pos] === "!" || tokens[pos] === "-not") {
+                const [pred, np] = parsePrimary(tokens, pos + 1);
+                return [{ type: "not", pred }, np];
+            }
+            return parsePrimary(tokens, pos);
+        }
+        function parsePrimary(tokens, pos) {
+            const tok = tokens[pos];
+            if (!tok)
+                return [{ type: "true" }, pos];
+            if (tok === "(") {
+                const [pred, np] = parseExpr(tokens, pos + 1);
+                const closePos = tokens[np] === ")" ? np + 1 : np;
+                return [pred, closePos];
+            }
+            if (tok === "-name")
+                return [{ type: "name", pat: tokens[pos + 1] ?? "*", ignoreCase: false }, pos + 2];
+            if (tok === "-iname")
+                return [{ type: "name", pat: tokens[pos + 1] ?? "*", ignoreCase: true }, pos + 2];
+            if (tok === "-type")
+                return [{ type: "type", t: tokens[pos + 1] ?? "f" }, pos + 2];
+            if (tok === "-maxdepth") {
+                maxDepth = parseInt(tokens[pos + 1] ?? "0", 10);
+                return [{ type: "true" }, pos + 2];
+            }
+            if (tok === "-mindepth") {
+                minDepth = parseInt(tokens[pos + 1] ?? "0", 10);
+                return [{ type: "true" }, pos + 2];
+            }
+            if (tok === "-empty")
+                return [{ type: "empty" }, pos + 1];
+            if (tok === "-print" || tok === "-print0")
+                return [{ type: "print" }, pos + 1];
+            if (tok === "-true")
+                return [{ type: "true" }, pos + 1];
+            if (tok === "-false")
+                return [{ type: "false" }, pos + 1];
+            if (tok === "-size") {
+                const raw = tokens[pos + 1] ?? "0";
+                const unit = raw.slice(-1);
+                const n = parseInt(raw, 10);
+                return [{ type: "size", n, unit }, pos + 2];
+            }
+            if (tok === "-exec" || tok === "-execdir") {
+                const useDir = tok === "-execdir";
+                const cmd = [];
+                let j = pos + 1;
+                while (j < tokens.length && tokens[j] !== ";") {
+                    cmd.push(tokens[j]);
+                    j++;
+                }
+                execCmds.push({ cmd, useDir });
+                return [{ type: "exec", cmd, useDir }, j + 1];
+            }
+            // Unknown predicate — skip
+            return [{ type: "true" }, pos + 1];
+        }
+        const pred = exprArgs.length > 0 ? parseExpr(exprArgs, 0)[0] : { type: "true" };
+        function globToRegex(pat, flags = "") {
+            const esc = pat.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+            return new RegExp(`^${esc}$`, flags);
+        }
+        function matchPred(p, fullPath, depth) {
+            switch (p.type) {
+                case "true": return true;
+                case "false": return false;
+                case "not": return !matchPred(p.pred, fullPath, depth);
+                case "and": return matchPred(p.left, fullPath, depth) && matchPred(p.right, fullPath, depth);
+                case "or": return matchPred(p.left, fullPath, depth) || matchPred(p.right, fullPath, depth);
+                case "name": {
+                    const base = fullPath.split("/").pop() ?? "";
+                    return globToRegex(p.pat, p.ignoreCase ? "i" : "").test(base);
+                }
+                case "type": {
+                    try {
+                        const st = shell.vfs.stat(fullPath);
+                        if (p.t === "f")
+                            return st.type === "file";
+                        if (p.t === "d")
+                            return st.type === "directory";
+                        if (p.t === "l")
+                            return false; // VFS has no symlink type
+                    }
+                    catch {
+                        return false;
+                    }
+                    return false;
+                }
+                case "empty": {
+                    try {
+                        const st = shell.vfs.stat(fullPath);
+                        if (st.type === "directory")
+                            return shell.vfs.list(fullPath).length === 0;
+                        return shell.vfs.readFile(fullPath).length === 0;
+                    }
+                    catch {
+                        return false;
+                    }
+                }
+                case "size": {
+                    try {
+                        const content = shell.vfs.readFile(fullPath);
+                        const bytes = content.length;
+                        const unit = p.unit;
+                        let fileSize = bytes;
+                        if (unit === "k" || unit === "K")
+                            fileSize = Math.ceil(bytes / 1024);
+                        else if (unit === "M")
+                            fileSize = Math.ceil(bytes / (1024 * 1024));
+                        else if (unit === "c")
+                            fileSize = bytes;
+                        return fileSize === p.n;
+                    }
+                    catch {
+                        return false;
+                    }
+                }
+                case "print": return true;
+                case "exec": return true; // handled separately
+                default: return true;
+            }
         }
-        const nameRegex = namePattern
-            ? new RegExp(`^${namePattern.replace(/\./g, "\\.").replace(/\*/g, ".*").replace(/\?/g, ".")}$`)
-            : null;
         const results = [];
-        const walk = (currentPath, display) => {
-            const stat = shell.vfs.stat(currentPath);
-            const matchesType = !typeFilter ||
-                (typeFilter === "f" && stat.type === "file") ||
-                (typeFilter === "d" && stat.type === "directory");
-            const matchesName = !nameRegex || nameRegex.test(currentPath.split("/").pop() ?? "");
-            if (matchesType && matchesName)
+        function walk(currentPath, display, depth) {
+            if (depth > maxDepth)
+                return;
+            try {
+                assertPathAccess(authUser, currentPath, "find");
+            }
+            catch {
+                return;
+            }
+            if (depth >= minDepth && matchPred(pred, currentPath, depth)) {
                 results.push(display);
-            if (stat.type === "directory") {
+            }
+            let stat;
+            try {
+                stat = shell.vfs.stat(currentPath);
+            }
+            catch {
+                return;
+            }
+            if (stat.type === "directory" && depth < maxDepth) {
                 for (const entry of shell.vfs.list(currentPath)) {
-                    const full = `${currentPath}/${entry}`;
-                    const disp = `${display}/${entry}`;
-                    walk(full, disp);
+                    walk(`${currentPath}/${entry}`, `${display}/${entry}`, depth + 1);
                 }
             }
-        };
-        walk(rootPath, rootArg);
-        return { stdout: results.join("\n"), exitCode: 0 };
+        }
+        for (const root of roots) {
+            const rootPath = resolvePath(cwd, root);
+            if (!shell.vfs.exists(rootPath)) {
+                return { stderr: `find: '${root}': No such file or directory`, exitCode: 1 };
+            }
+            walk(rootPath, root === "." ? "." : root, 0);
+        }
+        // Execute -exec commands
+        if (execCmds.length > 0 && results.length > 0) {
+            const execOutputs = [];
+            for (const { cmd } of execCmds) {
+                for (const filePath of results) {
+                    const expanded = cmd.map((t) => t === "{}" ? filePath : t);
+                    const cmdStr = expanded.map((t) => (t.includes(" ") ? `"${t}"` : t)).join(" ");
+                    const r = await runCommand(cmdStr, authUser, hostname, mode, cwd, shell, undefined, env);
+                    if (r.stdout)
+                        execOutputs.push(r.stdout.replace(/\n$/, ""));
+                    if (r.stderr)
+                        execOutputs.push(r.stderr.replace(/\n$/, ""));
+                }
+            }
+            if (execOutputs.length > 0) {
+                return { stdout: `${execOutputs.join("\n")}\n`, exitCode: 0 };
+            }
+            return { exitCode: 0 };
+        }
+        return { stdout: results.join("\n") + (results.length > 0 ? "\n" : ""), exitCode: 0 };
     },
 };

package/dist/commands/lsof.d.ts

@@ -0,0 +1,6 @@
+import type { ShellModule } from "../types/commands";
+/**
+ * List open files (stub — returns simulated process file descriptors).
+ * @category system
+ */
+export declare const lsofCommand: ShellModule;

package/dist/commands/lsof.js

@@ -0,0 +1,30 @@
+/**
+ * List open files (stub — returns simulated process file descriptors).
+ * @category system
+ */
+export const lsofCommand = {
+    name: "lsof",
+    description: "List open files",
+    category: "system",
+    params: ["[-p <pid>] [-u <user>] [-i [addr]]"],
+    run: ({ authUser, args }) => {
+        const iNet = args.includes("-i");
+        if (iNet) {
+            const header = "COMMAND    PID     USER   FD   TYPE DEVICE SIZE/OFF NODE NAME";
+            const rows = [
+                `sshd       1234     root    3u  IPv4  12345      0t0  TCP *:22 (LISTEN)`,
+                `nginx       567     root    6u  IPv4  23456      0t0  TCP *:80 (LISTEN)`,
+            ];
+            return { stdout: `${header}\n${rows.join("\n")}`, exitCode: 0 };
+        }
+        const header = "COMMAND    PID     USER   FD   TYPE DEVICE SIZE/OFF NODE NAME";
+        const rows = [
+            `bash      1001 ${authUser}  cwd    DIR    8,1     4096    2 /home/${authUser}`,
+            `bash      1001 ${authUser}  txt    REG    8,1  1183448   23 /bin/bash`,
+            `bash      1001 ${authUser}    0u   CHR  136,0      0t0    3 /dev/pts/0`,
+            `bash      1001 ${authUser}    1u   CHR  136,0      0t0    3 /dev/pts/0`,
+            `bash      1001 ${authUser}    2u   CHR  136,0      0t0    3 /dev/pts/0`,
+        ];
+        return { stdout: `${header}\n${rows.join("\n")}`, exitCode: 0 };
+    },
+};

package/dist/commands/perl.d.ts

@@ -0,0 +1,6 @@
+import type { ShellModule } from "../types/commands";
+/**
+ * Perl interpreter stub — supports -e one-liners with print, say, basic regex, and -p/-n/-i.
+ * @category scripting
+ */
+export declare const perlCommand: ShellModule;

package/dist/commands/perl.js

@@ -0,0 +1,76 @@
+/**
+ * Perl interpreter stub — supports -e one-liners with print, say, basic regex, and -p/-n/-i.
+ * @category scripting
+ */
+export const perlCommand = {
+    name: "perl",
+    description: "Practical Extraction and Report Language",
+    category: "scripting",
+    params: ["[-e <expr>] [-p] [-n] [-i] [file]"],
+    run: ({ args, stdin }) => {
+        const eIdx = args.indexOf("-e");
+        const code = eIdx !== -1 ? args[eIdx + 1] : undefined;
+        const printLoop = args.includes("-p");
+        const noAutoprint = args.includes("-n");
+        const hasLoop = printLoop || noAutoprint;
+        if (!code) {
+            return { stderr: "perl: no code specified (only -e one-liners supported)", exitCode: 1 };
+        }
+        const input = stdin ?? "";
+        const lines = input.split("\n");
+        if (lines[lines.length - 1] === "")
+            lines.pop();
+        const out = [];
+        if (hasLoop) {
+            for (let li = 0; li < lines.length; li++) {
+                let line = lines[li];
+                // $_ = line, $. = line number
+                let processed = code
+                    .replace(/\$_/g, JSON.stringify(line))
+                    .replace(/\$\./g, String(li + 1));
+                // s/pat/rep/[g] substitution on $_
+                const sMatch = processed.match(/^s([^a-zA-Z0-9])(.*?)\1(.*?)\1([gi]*)$/);
+                if (sMatch) {
+                    const flags = sMatch[4] ?? "";
+                    try {
+                        const re = new RegExp(sMatch[2], flags.includes("i") ? (flags.includes("g") ? "gi" : "i") : flags.includes("g") ? "g" : "");
+                        line = line.replace(re, sMatch[3]);
+                    }
+                    catch { /* ignore */ }
+                    if (printLoop)
+                        out.push(line);
+                    continue;
+                }
+                // print / say
+                const printM = processed.match(/^(?:print|say)\s+(?:STDOUT\s+)?(?:"([^"]*)"|'([^']*)'|(.+))(?:\s*;)?$/);
+                if (printM) {
+                    const val = (printM[1] ?? printM[2] ?? printM[3] ?? "")
+                        .replace(/\\n/g, "\n").replace(/\\t/g, "\t");
+                    out.push(code.startsWith("say") ? val : val.replace(/\n$/, ""));
+                    if (printLoop)
+                        out.push(line);
+                    continue;
+                }
+                if (printLoop)
+                    out.push(line);
+            }
+        }
+        else {
+            // Single expression
+            const printM = code.match(/^(?:print|say)\s+(?:STDOUT\s+)?(?:"([^"]*)"|'([^']*)'|(.*))(?:\s*;)?$/);
+            if (printM) {
+                const val = (printM[1] ?? printM[2] ?? printM[3] ?? "")
+                    .replace(/\\n/g, "\n").replace(/\\t/g, "\t");
+                out.push(val);
+            }
+            else {
+                // Version string
+                if (code.trim() === 'print $]' || code.includes("version")) {
+                    out.push("5.036001");
+                }
+            }
+        }
+        const result = out.join("\n");
+        return { stdout: result + (result && !result.endsWith("\n") ? "\n" : ""), exitCode: 0 };
+    },
+};

package/dist/commands/registry.js

@@ -5,6 +5,11 @@ import { awkCommand } from "./awk";
 import { base64Command } from "./base64";
 import { basenameCommand, dirnameCommand } from "./basename";
 import { bcCommand } from "./bc";
+import { bunzip2Command, bzip2Command } from "./bzip2";
+import { lsofCommand } from "./lsof";
+import { perlCommand } from "./perl";
+import { straceCommand } from "./strace";
+import { unzipCommand, zipCommand } from "./zip";
 import { catCommand } from "./cat";
 import { cdCommand } from "./cd";
 import { chmodCommand } from "./chmod";
@@ -127,6 +132,10 @@ const BASE_COMMANDS = [
     tarCommand,
     gzipCommand,
     gunzipCommand,
+    zipCommand,
+    unzipCommand,
+    bzip2Command,
+    bunzip2Command,
     base64Command,
     // System info
     whoamiCommand,
@@ -214,6 +223,10 @@ const BASE_COMMANDS = [
     uptimeCommand,
     freeCommand,
     lsbReleaseCommand,
+    lsofCommand,
+    straceCommand,
+    // Scripting
+    perlCommand,
 ];
 const customCommands = [];
 const commandRegistry = new Map();

package/dist/commands/sed.d.ts

@@ -1,7 +1,7 @@
 import type { ShellModule } from "../types/commands";
 /**
- * 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 declare const sedCommand: ShellModule;