typescript-virtual-container 1.2.5 → 1.2.7

package/dist/commands/sed.js

@@ -0,0 +1,47 @@
+import { getFlag, ifFlag } from "./command-helpers";
+import { resolvePath } from "./helpers";
+export const sedCommand = {
+    name: "sed",
+    description: "Stream editor for filtering and transforming text",
+    category: "text",
+    params: ["-e <expr> [file]", "s/pattern/replace/[g]"],
+    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)
+            return { stderr: "sed: no expression", exitCode: 1 };
+        let content = stdin ?? "";
+        if (fileArg) {
+            const p = resolvePath(cwd, fileArg);
+            try {
+                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 ?? "");
+        if (inPlace && fileArg) {
+            const p = resolvePath(cwd, fileArg);
+            shell.writeFileAsUser(authUser, p, result);
+            return { exitCode: 0 };
+        }
+        return { stdout: result, exitCode: 0 };
+    },
+};

package/dist/commands/set.d.ts

@@ -1,7 +1,10 @@
 /** biome-ignore-all lint/style/useNamingConvention: env variables */
 import type { ShellModule } from "../types/commands";
+/** @deprecated use env.vars from CommandContext */
 export declare function getEnvVar(name: string): string | undefined;
+/** @deprecated use env.vars from CommandContext */
 export declare function setEnvVar(name: string, value: string): void;
+/** @deprecated use env.vars from CommandContext */
 export declare function getAllEnvVars(authUser: string): Record<string, string>;
 export declare const setCommand: ShellModule;
 //# sourceMappingURL=set.d.ts.map

package/dist/commands/set.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"set.d.ts","sourceRoot":"","sources":["../../src/commands/set.ts"],"names":[],"mappings":"AAAA,qEAAqE;AACrE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAarD,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAE1D;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAE3D;AAED,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAItE;AAED,eAAO,MAAM,UAAU,EAAE,WA4CxB,CAAC"}
+{"version":3,"file":"set.d.ts","sourceRoot":"","sources":["../../src/commands/set.ts"],"names":[],"mappings":"AAAA,qEAAqE;AACrE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAWrD,mDAAmD;AACnD,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAA6B;AACxF,mDAAmD;AACnD,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAA8B;AAC1F,mDAAmD;AACnD,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAItE;AAED,eAAO,MAAM,UAAU,EAAE,WAkBxB,CAAC"}

package/dist/commands/set.js

@@ -1,64 +1,37 @@
-import { getArg } from "./command-helpers";
-// Simple in-memory environment variables store
-// In a real implementation, this would be per-session/per-user
-const envVars = {
+// Legacy global store kept for compatibility with older callers
+const _globalEnv = {
     PATH: "/usr/local/bin:/usr/bin:/bin",
     HOME: "/home/user",
     SHELL: "/bin/sh",
     TERM: "xterm-256color",
     USER: "user",
 };
-export function getEnvVar(name) {
-    return envVars[name];
-}
-export function setEnvVar(name, value) {
-    envVars[name] = value;
-}
+/** @deprecated use env.vars from CommandContext */
+export function getEnvVar(name) { return _globalEnv[name]; }
+/** @deprecated use env.vars from CommandContext */
+export function setEnvVar(name, value) { _globalEnv[name] = value; }
+/** @deprecated use env.vars from CommandContext */
 export function getAllEnvVars(authUser) {
-    envVars.USER = authUser;
-    envVars.HOME = `/home/${authUser}`;
-    return { ...envVars };
+    _globalEnv.USER = authUser;
+    _globalEnv.HOME = `/home/${authUser}`;
+    return { ..._globalEnv };
 }
 export const setCommand = {
     name: "set",
+    description: "Display or set shell variables",
+    category: "shell",
     params: ["[VAR=value]"],
-    run: ({ args }) => {
-        // No arguments: display all environment variables
+    run: ({ args, env }) => {
         if (args.length === 0) {
-            const output = Object.entries(envVars)
-                .map(([key, value]) => `${key}=${value}`)
-                .sort()
-                .join("\n");
-            return { stdout: output, exitCode: 0 };
+            const out = Object.entries(env.vars).map(([k, v]) => `${k}=${v}`).join("\n");
+            return { stdout: out, exitCode: 0 };
         }
-        // Parse VAR=value format
-        const assignments = [];
-        for (let index = 0;; index += 1) {
-            const arg = getArg(args, index);
-            if (!arg) {
-                break;
-            }
+        for (const arg of args) {
             if (arg.includes("=")) {
-                const [varName, varValue] = arg.split("=", 2);
-                if (varName && varValue !== undefined) {
-                    setEnvVar(varName, varValue);
-                    assignments.push(arg);
-                }
-            }
-            else {
-                // If no '=' present, display that specific variable
-                const value = getEnvVar(arg);
-                if (value !== undefined) {
-                    assignments.push(`${arg}=${value}`);
-                }
-                else {
-                    assignments.push(`${arg}: not set`);
-                }
+                const eq = arg.indexOf("=");
+                env.vars[arg.slice(0, eq)] = arg.slice(eq + 1);
             }
         }
-        return {
-            stdout: assignments.length > 0 ? assignments.join("\n") : "",
-            exitCode: 0,
-        };
+        return { exitCode: 0 };
     },
 };

package/dist/commands/sh.d.ts

@@ -1,4 +1,3 @@
 import type { ShellModule } from "../types/commands";
-/** Simple shell script executor with basic variable support */
 export declare const shCommand: ShellModule;
 //# sourceMappingURL=sh.d.ts.map

package/dist/commands/sh.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sh.d.ts","sourceRoot":"","sources":["../../src/commands/sh.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAkB,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAIrE,+DAA+D;AAC/D,eAAO,MAAM,SAAS,EAAE,WAmDvB,CAAC"}
+{"version":3,"file":"sh.d.ts","sourceRoot":"","sources":["../../src/commands/sh.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAiC,WAAW,EAAE,MAAM,mBAAmB,CAAC;AA+KpF,eAAO,MAAM,SAAS,EAAE,WA+BvB,CAAC"}

package/dist/commands/sh.js

@@ -1,45 +1,239 @@
-import { getArg, getFlag } from "./command-helpers";
+import { getArg, ifFlag } from "./command-helpers";
+import { resolvePath } from "./helpers";
 import { runCommand } from "./index";
-/** Simple shell script executor with basic variable support */
+/** Expand $VAR and ${VAR:-default} in a line using the current env */
+function expandVars(line, env, lastExit) {
+    return line
+        .replace(/\$\?/g, String(lastExit))
+        .replace(/\$\{([^}:]+):-([^}]*)\}/g, (_, n, d) => env[n] ?? d)
+        .replace(/\$\{([^}]+)\}/g, (_, n) => env[n] ?? "")
+        .replace(/\$([A-Za-z_][A-Za-z0-9_]*)/g, (_, n) => env[n] ?? "")
+        .replace(/^~(\/|$)/, `${env.HOME ?? "/home/user"}$1`);
+}
+/** Very small shell interpreter: supports if/elif/else/fi, for/do/done, while/do/done */
+function parseBlocks(lines) {
+    const blocks = [];
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i].trim();
+        if (!line || line.startsWith("#")) {
+            i++;
+            continue;
+        }
+        if (line.startsWith("if ") || line === "if") {
+            const cond = line.replace(/^if\s+/, "").replace(/;\s*then\s*$/, "").trim();
+            const thenLines = [];
+            const elifBlocks = [];
+            const elseLines = [];
+            let section = "then";
+            let elifCond = "";
+            i++;
+            while (i < lines.length && lines[i]?.trim() !== "fi") {
+                const l = lines[i].trim();
+                if (l.startsWith("elif ")) {
+                    section = "elif";
+                    elifCond = l.replace(/^elif\s+/, "").replace(/;\s*then\s*$/, "").trim();
+                    elifBlocks.push({ cond: elifCond, body: [] });
+                }
+                else if (l === "else") {
+                    section = "else";
+                }
+                else if (l !== "then") {
+                    if (section === "then")
+                        thenLines.push(l);
+                    else if (section === "elif" && elifBlocks.length > 0)
+                        elifBlocks[elifBlocks.length - 1].body.push(l);
+                    else
+                        elseLines.push(l);
+                }
+                i++;
+            }
+            // biome-ignore lint/suspicious/noThenProperty: expected behavior for if/elif parsing
+            blocks.push({ type: "if", cond, then: thenLines, elif: elifBlocks, else_: elseLines });
+        }
+        else if (line.startsWith("for ")) {
+            const m = line.match(/^for\s+(\w+)\s+in\s+(.+?)(?:\s*;\s*do)?$/);
+            if (m) {
+                const body = [];
+                i++;
+                while (i < lines.length && lines[i]?.trim() !== "done") {
+                    const l = lines[i].trim();
+                    if (l !== "do")
+                        body.push(l);
+                    i++;
+                }
+                blocks.push({ type: "for", var: m[1], list: m[2], body });
+            }
+            else {
+                blocks.push({ type: "cmd", line });
+            }
+        }
+        else if (line.startsWith("while ")) {
+            const cond = line.replace(/^while\s+/, "").replace(/;\s*do\s*$/, "").trim();
+            const body = [];
+            i++;
+            while (i < lines.length && lines[i]?.trim() !== "done") {
+                const l = lines[i].trim();
+                if (l !== "do")
+                    body.push(l);
+                i++;
+            }
+            blocks.push({ type: "while", cond, body });
+        }
+        else {
+            blocks.push({ type: "cmd", line });
+        }
+        i++;
+    }
+    return blocks;
+}
+async function evalCondition(cond, ctx) {
+    const expanded = expandVars(cond, ctx.env.vars, ctx.env.lastExitCode);
+    // test -f / test -d / [ ... ]
+    const testMatch = expanded.match(/^\[?\s*(.+?)\s*\]?$/);
+    if (testMatch) {
+        const expr = testMatch[1];
+        // -f file
+        const fTest = expr.match(/^-([fdeznr])\s+(.+)$/);
+        if (fTest) {
+            const [, flag, arg] = fTest;
+            const p = resolvePath(ctx.cwd, arg);
+            if (flag === "f")
+                return ctx.shell.vfs.exists(p) && ctx.shell.vfs.stat(p).type === "file";
+            if (flag === "d")
+                return ctx.shell.vfs.exists(p) && ctx.shell.vfs.stat(p).type === "directory";
+            if (flag === "e")
+                return ctx.shell.vfs.exists(p);
+            if (flag === "z")
+                return (arg ?? "").length === 0;
+            if (flag === "n")
+                return (arg ?? "").length > 0;
+        }
+        // string comparison
+        const cmpMatch = expr.match(/^"?([^"]*)"?\s*(==|!=|=|<|>)\s*"?([^"]*)"?$/);
+        if (cmpMatch) {
+            const [, a, op, b] = cmpMatch;
+            if (op === "==" || op === "=")
+                return a === b;
+            if (op === "!=")
+                return a !== b;
+        }
+        // numeric
+        const numMatch = expr.match(/^(\S+)\s+(-eq|-ne|-lt|-le|-gt|-ge)\s+(\S+)$/);
+        if (numMatch) {
+            const [, a, op, b] = numMatch;
+            const na = Number(a), nb = Number(b);
+            if (op === "-eq")
+                return na === nb;
+            if (op === "-ne")
+                return na !== nb;
+            if (op === "-lt")
+                return na < nb;
+            if (op === "-le")
+                return na <= nb;
+            if (op === "-gt")
+                return na > nb;
+            if (op === "-ge")
+                return na >= nb;
+        }
+    }
+    // fallback: run command and check exit code
+    const r = await runCommand(expanded, ctx.authUser, ctx.hostname, ctx.mode, ctx.cwd, ctx.shell, undefined, ctx.env);
+    return (r.exitCode ?? 0) === 0;
+}
+async function runBlocks(blocks, ctx) {
+    let lastResult = { exitCode: 0 };
+    let output = "";
+    for (const block of blocks) {
+        if (block.type === "cmd") {
+            const expanded = expandVars(block.line, ctx.env.vars, ctx.env.lastExitCode);
+            const r = await runCommand(expanded, ctx.authUser, ctx.hostname, ctx.mode, ctx.cwd, ctx.shell, undefined, ctx.env);
+            ctx.env.lastExitCode = r.exitCode ?? 0;
+            if (r.stdout)
+                output += `${r.stdout}\n`;
+            if (r.stderr)
+                return { ...r, stdout: output.trim() };
+            lastResult = r;
+        }
+        else if (block.type === "if") {
+            let ran = false;
+            if (await evalCondition(block.cond, ctx)) {
+                const sub = await runBlocks(parseBlocks(block.then), ctx);
+                if (sub.stdout)
+                    output += `${sub.stdout}\n`;
+                ran = true;
+            }
+            else {
+                for (const elif of block.elif) {
+                    if (await evalCondition(elif.cond, ctx)) {
+                        const sub = await runBlocks(parseBlocks(elif.body), ctx);
+                        if (sub.stdout)
+                            output += `${sub.stdout}\n`;
+                        ran = true;
+                        break;
+                    }
+                }
+                if (!ran && block.else_.length > 0) {
+                    const sub = await runBlocks(parseBlocks(block.else_), ctx);
+                    if (sub.stdout)
+                        output += `${sub.stdout}\n`;
+                }
+            }
+        }
+        else if (block.type === "for") {
+            const listExpanded = expandVars(block.list, ctx.env.vars, ctx.env.lastExitCode);
+            const items = listExpanded.trim().split(/\s+/);
+            for (const item of items) {
+                ctx.env.vars[block.var] = item;
+                const sub = await runBlocks(parseBlocks(block.body), ctx);
+                if (sub.stdout)
+                    output += `${sub.stdout}\n`;
+                if (sub.closeSession)
+                    return sub;
+            }
+        }
+        else if (block.type === "while") {
+            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++;
+            }
+        }
+    }
+    return { ...lastResult, stdout: output.trim() || lastResult.stdout };
+}
 export const shCommand = {
     name: "sh",
-    params: ["-c <script>", "[<file>]"],
     aliases: ["bash"],
+    description: "Execute shell script or command",
+    category: "shell",
+    params: ["-c <script>", "[<file>]"],
     run: async (ctx) => {
-        const { args, authUser, hostname, mode, cwd } = ctx;
-        // Handle -c option: sh -c "command"
-        if (getFlag(args, "-c") && args.length >= 2) {
+        const { args, shell, cwd } = ctx;
+        // sh -c "inline script"
+        if (ifFlag(args, "-c")) {
             const script = getArg(args, 1) ?? "";
-            if (!script) {
+            if (!script)
                 return { stderr: "sh: -c requires a script", exitCode: 1 };
-            }
-            const scriptArgs = args.slice(2);
-            // Split by semicolon and newline
-            const lines = script
-                .split(/[;\n]/)
-                .map((line) => line.trim())
-                .filter((line) => line && !line.startsWith("#"));
-            let output = "";
-            const exitCode = 0;
-            for (const line of lines) {
-                // Simple variable substitution
-                let command = line;
-                for (let i = 0; i < scriptArgs.length; i++) {
-                    const arg = scriptArgs[i] ?? "";
-                    command = command.replaceAll(`$${i}`, arg);
-                }
-                command = command.replaceAll("$@", scriptArgs.join(" "));
-                // Execute the command
-                const result = await Promise.resolve(runCommand(command, authUser, hostname, mode, cwd, ctx.shell));
-                if (result.stdout) {
-                    output += `${result.stdout}\n`;
-                }
-                if (result.stderr) {
-                    return { stderr: result.stderr, exitCode: result.exitCode ?? 1 };
-                }
-            }
-            return { stdout: output.trim(), exitCode };
+            const lines = script.split(/[;\n]/).map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
+            const blocks = parseBlocks(lines);
+            return runBlocks(blocks, ctx);
+        }
+        // sh <file>
+        const fileArg = args[0];
+        if (fileArg) {
+            const p = resolvePath(cwd, fileArg);
+            if (!shell.vfs.exists(p))
+                return { stderr: `sh: ${fileArg}: No such file or directory`, exitCode: 1 };
+            const content = shell.vfs.readFile(p);
+            const lines = content.split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
+            const blocks = parseBlocks(lines);
+            return runBlocks(blocks, ctx);
         }
-        return { stderr: "sh: invalid usage", exitCode: 1 };
+        return { stderr: "sh: invalid usage. Use: sh -c 'cmd' or sh <file>", exitCode: 1 };
     },
 };

package/dist/commands/sleep.d.ts

@@ -0,0 +1,3 @@
+import type { ShellModule } from "../types/commands";
+export declare const sleepCommand: ShellModule;
+//# sourceMappingURL=sleep.d.ts.map

package/dist/commands/sleep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sleep.d.ts","sourceRoot":"","sources":["../../src/commands/sleep.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD,eAAO,MAAM,YAAY,EAAE,WAW1B,CAAC"}

package/dist/commands/sleep.js

@@ -0,0 +1,13 @@
+export const sleepCommand = {
+    name: "sleep",
+    description: "Delay execution",
+    category: "system",
+    params: ["<seconds>"],
+    run: async ({ args }) => {
+        const secs = parseFloat(args[0] ?? "1");
+        if (Number.isNaN(secs) || secs < 0)
+            return { stderr: "sleep: invalid time", exitCode: 1 };
+        await new Promise((r) => setTimeout(r, secs * 1000));
+        return { exitCode: 0 };
+    },
+};

package/dist/commands/sort.d.ts

@@ -0,0 +1,3 @@
+import type { ShellModule } from "../types/commands";
+export declare const sortCommand: ShellModule;
+//# sourceMappingURL=sort.d.ts.map

package/dist/commands/sort.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sort.d.ts","sourceRoot":"","sources":["../../src/commands/sort.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAIrD,eAAO,MAAM,WAAW,EAAE,WAgCzB,CAAC"}

package/dist/commands/sort.js

@@ -0,0 +1,37 @@
+import { ifFlag } from "./command-helpers";
+import { assertPathAccess, resolvePath } from "./helpers";
+export const sortCommand = {
+    name: "sort",
+    description: "Sort lines of text",
+    category: "text",
+    params: ["[-r] [-n] [-u] [-k <col>] [file...]"],
+    run: ({ authUser, shell, cwd, args, stdin }) => {
+        const reverse = ifFlag(args, ["-r"]);
+        const numeric = ifFlag(args, ["-n"]);
+        const unique = ifFlag(args, ["-u"]);
+        const files = args.filter((a) => !a.startsWith("-"));
+        const getContent = () => {
+            if (files.length > 0) {
+                return files.map((f) => {
+                    try {
+                        assertPathAccess(authUser, resolvePath(cwd, f), "sort");
+                        return shell.vfs.readFile(resolvePath(cwd, f));
+                    }
+                    catch {
+                        return "";
+                    }
+                }).join("\n");
+            }
+            return stdin ?? "";
+        };
+        const lines = getContent().split("\n").filter(Boolean);
+        const sorted = [...lines].sort((a, b) => {
+            if (numeric)
+                return Number(a) - Number(b);
+            return a.localeCompare(b);
+        });
+        const result = reverse ? sorted.reverse() : sorted;
+        const out = unique ? [...new Set(result)] : result;
+        return { stdout: out.join("\n"), exitCode: 0 };
+    },
+};

package/dist/commands/su.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"su.d.ts","sourceRoot":"","sources":["../../src/commands/su.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGrD,eAAO,MAAM,SAAS,EAAE,WA4BvB,CAAC"}
+{"version":3,"file":"su.d.ts","sourceRoot":"","sources":["../../src/commands/su.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGrD,eAAO,MAAM,SAAS,EAAE,WA8BvB,CAAC"}

package/dist/commands/su.js

@@ -1,6 +1,8 @@
 import { getArg } from "./command-helpers";
 export const suCommand = {
     name: "su",
+    description: "Switch user",
+    category: "users",
     params: ["- <username>"],
     run: ({ authUser, shell, args }) => {
         const users = shell.users;

package/dist/commands/sudo.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sudo.d.ts","sourceRoot":"","sources":["../../src/commands/sudo.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAqBrD,eAAO,MAAM,WAAW,EAAE,WA+CzB,CAAC"}
+{"version":3,"file":"sudo.d.ts","sourceRoot":"","sources":["../../src/commands/sudo.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAqBrD,eAAO,MAAM,WAAW,EAAE,WAiDzB,CAAC"}

package/dist/commands/sudo.js

@@ -12,6 +12,8 @@ function parseSudoArgs(args) {
 }
 export const sudoCommand = {
     name: "sudo",
+    description: "Execute as superuser",
+    category: "users",
     params: ["<command...>"],
     run: async ({ authUser, hostname, mode, cwd, shell, args }) => {
         const { targetUser, loginShell, commandLine } = parseSudoArgs(args);

package/dist/commands/tail.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tail.d.ts","sourceRoot":"","sources":["../../src/commands/tail.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAIrD,eAAO,MAAM,WAAW,EAAE,WAgCzB,CAAC"}
+{"version":3,"file":"tail.d.ts","sourceRoot":"","sources":["../../src/commands/tail.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAIrD,eAAO,MAAM,WAAW,EAAE,WAkCzB,CAAC"}

package/dist/commands/tail.js

@@ -2,6 +2,8 @@ import { getFlag } from "./command-helpers";
 import { assertPathAccess, resolvePath } from "./helpers";
 export const tailCommand = {
     name: "tail",
+    description: "Output last lines",
+    category: "text",
     params: ["[-n <lines>] [file...]"],
     run: ({ authUser, shell, cwd, args, stdin }) => {
         const nArg = getFlag(args, ["-n"]);

package/dist/commands/tar.d.ts

@@ -0,0 +1,3 @@
+import type { ShellModule } from "../types/commands";
+export declare const tarCommand: ShellModule;
+//# sourceMappingURL=tar.d.ts.map

package/dist/commands/tar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tar.d.ts","sourceRoot":"","sources":["../../src/commands/tar.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAIrD,eAAO,MAAM,UAAU,EAAE,WAqDxB,CAAC"}

package/dist/commands/tar.js

@@ -0,0 +1,64 @@
+import { ifFlag } from "./command-helpers";
+import { resolvePath } from "./helpers";
+export const tarCommand = {
+    name: "tar",
+    description: "Archive utility",
+    category: "archive",
+    params: ["[-czf|-xzf|-tf] <archive> [files...]"],
+    run: ({ authUser, shell, cwd, args }) => {
+        const create = ifFlag(args, ["-c"]);
+        const extract = ifFlag(args, ["-x"]);
+        const list = ifFlag(args, ["-t"]);
+        const fFlag = args.findIndex((a) => a.includes("f"));
+        const archiveName = fFlag !== -1 ? args[fFlag + 1] : args.find((a) => a.endsWith(".tar") || a.endsWith(".tar.gz") || a.endsWith(".tgz"));
+        if (!archiveName)
+            return { stderr: "tar: no archive specified", exitCode: 1 };
+        const archivePath = resolvePath(cwd, archiveName);
+        if (create) {
+            const fileArgs = args.filter((a) => !a.startsWith("-") && a !== archiveName);
+            const entries = {};
+            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);
+                    }
+                }
+                catch {
+                    return { stderr: `tar: ${f}: No such file or directory`, exitCode: 1 };
+                }
+            }
+            shell.writeFileAsUser(authUser, archivePath, JSON.stringify(entries));
+            return { exitCode: 0 };
+        }
+        if (list || extract) {
+            let entries;
+            try {
+                entries = JSON.parse(shell.vfs.readFile(archivePath));
+            }
+            catch {
+                return { stderr: `tar: ${archiveName}: cannot open archive`, exitCode: 1 };
+            }
+            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);
+            }
+            return { exitCode: 0 };
+        }
+        return { stderr: "tar: must specify -c, -x, or -t", exitCode: 1 };
+    },
+};

package/dist/commands/tee.d.ts

@@ -0,0 +1,3 @@
+import type { ShellModule } from "../types/commands";
+export declare const teeCommand: ShellModule;
+//# sourceMappingURL=tee.d.ts.map

package/dist/commands/tee.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tee.d.ts","sourceRoot":"","sources":["../../src/commands/tee.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAIrD,eAAO,MAAM,UAAU,EAAE,WAoBxB,CAAC"}