typescript-virtual-container 1.5.4 → 1.5.6

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

@@ -11,11 +11,31 @@ export const setCommand = {
     run: ({ args, env }) => {
         if (args.length === 0) {
             const out = Object.entries(env.vars)
+                .filter(([k]) => !k.startsWith("__"))
                 .map(([k, v]) => `${k}=${v}`)
                 .join("\n");
             return { stdout: out, exitCode: 0 };
         }
         for (const arg of args) {
+            const flagMatch = arg.match(/^([+-])([a-zA-Z]+)$/);
+            if (flagMatch) {
+                const on = flagMatch[1] === "-";
+                for (const flag of flagMatch[2]) {
+                    if (flag === "e") {
+                        if (on)
+                            env.vars.__errexit = "1";
+                        else
+                            delete env.vars.__errexit;
+                    }
+                    if (flag === "x") {
+                        if (on)
+                            env.vars.__xtrace = "1";
+                        else
+                            delete env.vars.__xtrace;
+                    }
+                }
+                continue;
+            }
             if (arg.includes("=")) {
                 const eq = arg.indexOf("=");
                 env.vars[arg.slice(0, eq)] = arg.slice(eq + 1);

package/dist/commands/sh.js

@@ -125,6 +125,69 @@ 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 = [];
+            i++;
+            while (i < lines.length && lines[i]?.trim() !== "esac") {
+                const pl = lines[i].trim();
+                if (!pl || pl === "esac") {
+                    i++;
+                    continue;
+                }
+                // pattern) or pattern1|pattern2)
+                const patMatch = pl.match(/^(.+?)\)\s*(.*)$/);
+                if (patMatch) {
+                    const pat = patMatch[1].trim();
+                    const body = [];
+                    if (patMatch[2]?.trim() && patMatch[2].trim() !== ";;") {
+                        body.push(patMatch[2].trim());
+                    }
+                    i++;
+                    while (i < lines.length) {
+                        const bl = lines[i].trim();
+                        if (bl === ";;" || bl === "esac")
+                            break;
+                        if (bl)
+                            body.push(bl);
+                        i++;
+                    }
+                    if (lines[i]?.trim() === ";;")
+                        i++; // skip ;;
+                    patterns.push({ pattern: pat, body });
+                }
+                else {
+                    i++;
+                }
+            }
+            blocks.push({ type: "case", expr: caseExpr, patterns });
+        }
         else {
             blocks.push({ type: "cmd", line });
         }
@@ -189,9 +252,12 @@ async function evalCondition(cond, ctx) {
 async function runBlocks(blocks, ctx) {
     let lastResult = { exitCode: 0 };
     let output = "";
+    let traceOutput = "";
     for (const block of blocks) {
         if (block.type === "cmd") {
             const expanded = await expandVars(block.line, ctx.env.vars, ctx.env.lastExitCode, ctx);
+            if (ctx.env.vars.__xtrace)
+                traceOutput += `+ ${expanded}\n`;
             // Bare VAR=val assignment(s) — handle before dispatching to runCommand
             const assignRe = /^([A-Za-z_][A-Za-z0-9_]*)=(.*)/;
             const tokens = expanded.trim().split(/\s+/);
@@ -231,6 +297,8 @@ async function runBlocks(blocks, ctx) {
                 output += `${r.stdout}\n`;
             if (r.stderr)
                 return { ...r, stdout: output.trim() };
+            if (ctx.env.vars.__errexit && (r.exitCode ?? 0) !== 0)
+                return { ...r, stdout: output.trim() };
             lastResult = r;
         }
         else if (block.type === "if") {
@@ -311,8 +379,50 @@ 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) {
+                const alts = pat.pattern.split("|").map((p) => p.trim());
+                const matched = alts.some((p) => {
+                    if (p === "*")
+                        return true;
+                    if (p.includes("*") || p.includes("?")) {
+                        const re = new RegExp(`^${p.replace(/\./g, "\\.").replace(/\*/g, ".*").replace(/\?/g, ".")}$`);
+                        return re.test(expanded);
+                    }
+                    return p === expanded;
+                });
+                if (matched) {
+                    const sub = await runBlocks(parseBlocks(pat.body), ctx);
+                    if (sub.stdout)
+                        output += `${sub.stdout}\n`;
+                    break;
+                }
+            }
+        }
+    }
+    const finalStdout = output.trim() || lastResult.stdout;
+    if (traceOutput) {
+        const traceStderr = (lastResult.stderr ? `${lastResult.stderr}\n` : "") + traceOutput.trim();
+        return { ...lastResult, stdout: finalStdout, stderr: traceStderr || lastResult.stderr };
     }
-    return { ...lastResult, stdout: output.trim() || lastResult.stdout };
+    return { ...lastResult, stdout: finalStdout };
 }
 /**
  * Execute shell scripts or commands with a minimal shell interpreter.

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