typescript-virtual-container 1.5.5 → 1.5.7

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();
@@ -242,7 +255,12 @@ export function registerCommand(module) {
         throw new Error("Command names must be non-empty and contain no spaces");
     }
     customCommands.push(normalized);
-    buildCache();
+    // Incremental insert — avoids full Map rebuild for every registerCommand call
+    commandRegistry.set(normalized.name, normalized);
+    for (const alias of normalized.aliases ?? [])
+        commandRegistry.set(alias, normalized);
+    // Invalidate sorted names cache; rebuilt lazily on next getCommandNames()
+    cachedCommandNames = null;
 }
 export function createCustomCommand(name, params, run) {
     return { name, params, run };

package/dist/commands/runtime.js

@@ -4,6 +4,16 @@ import { parseScript } from "../VirtualShell/shellParser";
 import { expandAsync, expandBraces, expandGlob } from "../utils/expand";
 import { tokenizeCommand } from "../utils/tokenize";
 import { resolveModule } from "./registry";
+// Module-level compiled regexes — avoids recompilation on every runCommand call
+const ASSIGN_RE = /^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/;
+const RE_FOR = /\bfor\s+\w+\s+in\b/;
+const RE_WHILE = /\bwhile\s+/;
+const RE_IF = /\bif\s+/;
+const RE_FUNC_BRACE = /\w+\s*\(\s*\)\s*\{/;
+const RE_FUNC_KW = /\bfunction\s+\w+/;
+const RE_ARITH = /\(\(\s*.+\s*\)\)/;
+const RE_PIPE = /(?<![|&])[|](?![|])/;
+const RE_OPERATORS = /[><;&]|\|\|/;
 /** Returns the home directory path for a given user. Root lives at /root. */
 export function userHome(authUser) {
     return authUser === "root" ? "/root" : `/home/${authUser}`;
@@ -43,7 +53,13 @@ function resolveVfsBinary(name, env, shell, authUser) {
             return null;
         }
     }
-    const pathDirs = (env.vars.PATH ?? "/usr/local/bin:/usr/bin:/bin").split(":");
+    const rawPath = env.vars.PATH ?? "/usr/local/bin:/usr/bin:/bin";
+    // Cache split PATH on the env object to avoid re-splitting on every binary lookup
+    if (!env._pathDirs || env._pathRaw !== rawPath) {
+        env._pathRaw = rawPath;
+        env._pathDirs = rawPath.split(":");
+    }
+    const pathDirs = env._pathDirs;
     for (const dir of pathDirs) {
         if ((dir === "/sbin" || dir === "/usr/sbin") && authUser !== "root")
             continue;
@@ -63,6 +79,35 @@ function resolveVfsBinary(name, env, shell, authUser) {
     return null;
 }
 const MAX_CALL_DEPTH = 8;
+/** Run a VFS stub file as a command, handling `exec builtin <name>` and `sh -c` stubs. */
+async function runVfsStub(vfsBinary, cmdName, args, rawInput, authUser, hostname, mode, cwd, shell, env, stdin) {
+    const stubContent = shell.vfs.readFile(vfsBinary);
+    const builtinMatch = stubContent.match(/exec\s+builtin\s+(\S+)/);
+    if (builtinMatch) {
+        const builtinMod = resolveModule(builtinMatch[1]);
+        if (builtinMod) {
+            return builtinMod.run({
+                authUser, hostname,
+                activeSessions: shell.users.listActiveSessions(),
+                rawInput, mode, args, stdin, cwd, shell, env,
+            });
+        }
+        // Guard: missing builtin — stop here to avoid sh -c infinite loop
+        return { stderr: `${cmdName}: exec builtin '${builtinMatch[1]}' not found`, exitCode: 127 };
+    }
+    const shMod = resolveModule("sh");
+    if (shMod) {
+        return shMod.run({
+            authUser, hostname,
+            activeSessions: shell.users.listActiveSessions(),
+            rawInput: `sh -c ${JSON.stringify(stubContent)}`,
+            mode,
+            args: ["-c", stubContent, "--", ...args],
+            stdin, cwd, shell, env,
+        });
+    }
+    return { stderr: `${cmdName}: command not found`, exitCode: 127 };
+}
 let _callDepth = 0;
 export async function runCommandDirect(name, args, authUser, hostname, mode, cwd, shell, stdin, env) {
     // Anti-loop guard: track call depth via env to avoid infinite recursion
@@ -81,7 +126,7 @@ export async function runCommandDirect(name, args, authUser, hostname, mode, cwd
     }
 }
 async function _runCommandDirectInner(name, args, authUser, hostname, mode, cwd, shell, stdin, env) {
-    const assignRe = /^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/;
+    const assignRe = ASSIGN_RE;
     const invocation = [name, ...args];
     let assignCount = 0;
     while (assignCount < invocation.length && assignRe.test(invocation[assignCount])) {
@@ -119,42 +164,7 @@ async function _runCommandDirectInner(name, args, authUser, hostname, mode, cwd,
     if (!mod) {
         const vfsBinary = resolveVfsBinary(name, env, shell, authUser);
         if (vfsBinary) {
-            const stubContent = shell.vfs.readFile(vfsBinary);
-            const builtinMatch = stubContent.match(/exec\s+builtin\s+(\S+)/);
-            if (builtinMatch) {
-                const builtinMod = resolveModule(builtinMatch[1]);
-                if (builtinMod) {
-                    return await builtinMod.run({
-                        authUser,
-                        hostname,
-                        activeSessions: shell.users.listActiveSessions(),
-                        rawInput: [name, ...args].join(" "),
-                        mode,
-                        args,
-                        stdin,
-                        cwd,
-                        shell,
-                        env,
-                    });
-                }
-                // builtin not found — stop here, don't fall through to sh -c (avoids infinite loop)
-                return { stderr: `${name}: exec builtin '${builtinMatch[1]}' not found`, exitCode: 127 };
-            }
-            const shMod = resolveModule("sh");
-            if (shMod) {
-                return await shMod.run({
-                    authUser,
-                    hostname,
-                    activeSessions: shell.users.listActiveSessions(),
-                    rawInput: `sh -c ${JSON.stringify(stubContent)}`,
-                    mode,
-                    args: ["-c", stubContent, "--", ...args],
-                    stdin,
-                    cwd,
-                    shell,
-                    env,
-                });
-            }
+            return runVfsStub(vfsBinary, name, args, [name, ...args].join(" "), authUser, hostname, mode, cwd, shell, env, stdin);
         }
         return { stderr: `${name}: command not found`, exitCode: 127 };
     }
@@ -220,18 +230,13 @@ export async function runCommand(rawInput, authUser, hostname, mode, cwd, shell,
             ? trimmed.replace(rawFirstWord, aliasVal)
             : trimmed;
         // Detect sh-syntax constructs that must be handled by the sh interpreter
-        const isShScript = /\bfor\s+\w+\s+in\b/.test(aliasExpanded) ||
-            /\bwhile\s+/.test(aliasExpanded) ||
-            /\bif\s+/.test(aliasExpanded) ||
-            /\w+\s*\(\s*\)\s*\{/.test(aliasExpanded) ||
-            /\bfunction\s+\w+/.test(aliasExpanded) ||
-            /\(\(\s*.+\s*\)\)/.test(aliasExpanded);
-        const hasOperators = /(?<![|&])[|](?![|])/.test(aliasExpanded) ||
-            aliasExpanded.includes(">") ||
-            aliasExpanded.includes("<") ||
-            aliasExpanded.includes("&&") ||
-            aliasExpanded.includes("||") ||
-            aliasExpanded.includes(";");
+        const isShScript = RE_FOR.test(aliasExpanded) ||
+            RE_WHILE.test(aliasExpanded) ||
+            RE_IF.test(aliasExpanded) ||
+            RE_FUNC_BRACE.test(aliasExpanded) ||
+            RE_FUNC_KW.test(aliasExpanded) ||
+            RE_ARITH.test(aliasExpanded);
+        const hasOperators = RE_PIPE.test(aliasExpanded) || RE_OPERATORS.test(aliasExpanded);
         if ((isShScript && rawFirstWord !== "sh" && rawFirstWord !== "bash") || hasOperators) {
             // sh-syntax: route through sh interpreter to handle for/while/functions
             if (isShScript && rawFirstWord !== "sh" && rawFirstWord !== "bash") {
@@ -267,52 +272,25 @@ export async function runCommand(rawInput, authUser, hostname, mode, cwd, shell,
         const parts = tokenizeCommand(expanded.trim());
         if (parts.length === 0)
             return { exitCode: 0 };
-        const assignRe = /^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/;
+        const assignRe = ASSIGN_RE;
         if (assignRe.test(parts[0])) {
             return runCommandDirect(parts[0], parts.slice(1), authUser, hostname, mode, cwd, shell, stdin, shellEnv);
         }
         const commandName = parts[0]?.toLowerCase() ?? "";
         // Apply brace expansion to each arg token
-        const args = parts.slice(1).flatMap(expandBraces).flatMap(token => expandGlob(token, cwd, shell.vfs));
+        const rawArgs = parts.slice(1);
+        const args = [];
+        for (const token of rawArgs) {
+            for (const brace of expandBraces(token)) {
+                for (const glob of expandGlob(brace, cwd, shell.vfs))
+                    args.push(glob);
+            }
+        }
         const mod = resolveModule(commandName);
         if (!mod) {
             const vfsBinary = resolveVfsBinary(commandName, shellEnv, shell, authUser);
             if (vfsBinary) {
-                const stubContent = shell.vfs.readFile(vfsBinary);
-                const builtinMatch = stubContent.match(/exec\s+builtin\s+(\S+)/);
-                if (builtinMatch) {
-                    const builtinName = builtinMatch[1];
-                    const builtinMod = resolveModule(builtinName);
-                    if (builtinMod) {
-                        return await builtinMod.run({
-                            authUser,
-                            hostname,
-                            activeSessions: shell.users.listActiveSessions(),
-                            rawInput: [commandName, ...args].join(" "),
-                            mode,
-                            args,
-                            stdin,
-                            cwd,
-                            shell,
-                            env: shellEnv,
-                        });
-                    }
-                }
-                const shMod = resolveModule("sh");
-                if (shMod) {
-                    return await shMod.run({
-                        authUser,
-                        hostname,
-                        activeSessions: shell.users.listActiveSessions(),
-                        rawInput: `sh -c ${JSON.stringify(stubContent)}`,
-                        mode,
-                        args: ["-c", stubContent, "--", ...args],
-                        stdin,
-                        cwd,
-                        shell,
-                        env: shellEnv,
-                    });
-                }
+                return runVfsStub(vfsBinary, commandName, args, expanded, authUser, hostname, mode, cwd, shell, shellEnv, stdin);
             }
             return { stderr: `${commandName}: command not found`, exitCode: 127 };
         }

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;

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...]"]
  */