typescript-virtual-container 1.5.7 → 1.5.9

package/dist/commands/coreutils.js

@@ -0,0 +1,275 @@
+/**
+ * timeout — run command with time limit (simulated: just runs the command)
+ * @category shell
+ * @params ["<duration> <command> [args...]"]
+ */
+export const timeoutCommand = {
+    name: "timeout",
+    description: "Run command with time limit",
+    category: "shell",
+    params: ["<duration>", "<command>", "[args...]"],
+    run: async ({ args, authUser, hostname, mode, cwd, shell, env, stdin }) => {
+        // First arg is duration (ignored in simulation), rest is the command
+        if (args.length < 2)
+            return { stderr: "timeout: missing operand", exitCode: 1 };
+        const { runCommand } = await import("./runtime");
+        const cmd = args.slice(1).join(" ");
+        return runCommand(cmd, authUser, hostname, mode, cwd, shell, stdin, env);
+    },
+};
+/**
+ * mktemp — create a temporary file or directory
+ * @category shell
+ * @params ["[TEMPLATE]"]
+ */
+export const mktempCommand = {
+    name: "mktemp",
+    description: "Create a temporary file or directory",
+    category: "shell",
+    params: ["[-d]", "[TEMPLATE]"],
+    run: ({ args, shell }) => {
+        const isDir = args.includes("-d");
+        const templateArg = args.find((a) => !a.startsWith("-")) ?? "tmp.XXXXXXXXXX";
+        const suffix = templateArg.replace(/X+$/, "") || "tmp.";
+        const rand = Math.random().toString(36).slice(2, 10);
+        const name = `${suffix}${rand}`;
+        const path = name.startsWith("/") ? name : `/tmp/${name}`;
+        try {
+            if (!shell.vfs.exists("/tmp"))
+                shell.vfs.mkdir("/tmp");
+            if (isDir) {
+                shell.vfs.mkdir(path);
+            }
+            else {
+                shell.vfs.writeFile(path, "");
+            }
+        }
+        catch {
+            return { stderr: `mktemp: failed to create ${isDir ? "directory" : "file"} via template '${templateArg}'`, exitCode: 1 };
+        }
+        return { stdout: path, exitCode: 0 };
+    },
+};
+/**
+ * nproc — print number of processing units
+ * @category system
+ * @params ["[--all]"]
+ */
+export const nprocCommand = {
+    name: "nproc",
+    description: "Print number of processing units",
+    category: "system",
+    params: ["[--all]"],
+    run: () => ({ stdout: "4", exitCode: 0 }),
+};
+/**
+ * wait — wait for background jobs (no-op: background jobs are fire-and-forget)
+ * @category shell
+ * @params ["[job_id...]"]
+ */
+export const waitCommand = {
+    name: "wait",
+    description: "Wait for background jobs to finish",
+    category: "shell",
+    params: ["[job_id...]"],
+    run: () => ({ exitCode: 0 }),
+};
+/**
+ * shuf — shuffle lines of input
+ * @category text
+ * @params ["[-n count] [-i lo-hi] [file]"]
+ */
+export const shufCommand = {
+    name: "shuf",
+    description: "Shuffle lines of input randomly",
+    category: "text",
+    params: ["[-n count]", "[-i lo-hi]", "[file]"],
+    run: ({ args, stdin, shell, cwd }) => {
+        const { resolvePath } = require("./helpers");
+        // -i lo-hi: generate range
+        const iIdx = args.indexOf("-i");
+        if (iIdx !== -1) {
+            const range = args[iIdx + 1] ?? "";
+            const m = range.match(/^(-?\d+)-(-?\d+)$/);
+            if (!m)
+                return { stderr: "shuf: invalid range", exitCode: 1 };
+            const lo = parseInt(m[1], 10);
+            const hi = parseInt(m[2], 10);
+            const nums = [];
+            for (let n = lo; n <= hi; n++)
+                nums.push(n);
+            for (let i = nums.length - 1; i > 0; i--) {
+                const j = Math.floor(Math.random() * (i + 1));
+                [nums[i], nums[j]] = [nums[j], nums[i]];
+            }
+            const nIdx = args.indexOf("-n");
+            const count = nIdx !== -1 ? parseInt(args[nIdx + 1] ?? "0", 10) : nums.length;
+            return { stdout: nums.slice(0, count).join("\n"), exitCode: 0 };
+        }
+        // file or stdin
+        let input = stdin ?? "";
+        const fileArg = args.find((a) => !a.startsWith("-"));
+        if (fileArg) {
+            const p = resolvePath(cwd ?? "/", fileArg);
+            if (!shell.vfs.exists(p))
+                return { stderr: `shuf: ${fileArg}: No such file or directory`, exitCode: 1 };
+            input = shell.vfs.readFile(p);
+        }
+        const lines = input.split("\n").filter((l) => l !== "");
+        for (let i = lines.length - 1; i > 0; i--) {
+            const j = Math.floor(Math.random() * (i + 1));
+            [lines[i], lines[j]] = [lines[j], lines[i]];
+        }
+        const nIdx = args.indexOf("-n");
+        const count = nIdx !== -1 ? parseInt(args[nIdx + 1] ?? "0", 10) : lines.length;
+        return { stdout: lines.slice(0, count).join("\n"), exitCode: 0 };
+    },
+};
+/**
+ * paste — merge lines of files side by side
+ * @category text
+ * @params ["[-d delimiter] file..."]
+ */
+export const pasteCommand = {
+    name: "paste",
+    description: "Merge lines of files",
+    category: "text",
+    params: ["[-d delimiter]", "file..."],
+    run: ({ args, stdin, shell, cwd }) => {
+        const { resolvePath } = require("./helpers");
+        let delim = "\t";
+        const files = [];
+        let i = 0;
+        while (i < args.length) {
+            if (args[i] === "-d" && args[i + 1]) {
+                delim = args[i + 1];
+                i += 2;
+            }
+            else {
+                files.push(args[i]);
+                i++;
+            }
+        }
+        // serial mode (-s not implemented; basic merge)
+        let sources;
+        if (files.length === 0 || files[0] === "-") {
+            sources = [(stdin ?? "").split("\n")];
+        }
+        else {
+            sources = files.map((f) => {
+                const p = resolvePath(cwd ?? "/", f);
+                if (!shell.vfs.exists(p))
+                    return [];
+                return shell.vfs.readFile(p).split("\n");
+            });
+        }
+        const maxLen = Math.max(...sources.map((s) => s.length));
+        const out = [];
+        for (let row = 0; row < maxLen; row++) {
+            out.push(sources.map((s) => s[row] ?? "").join(delim));
+        }
+        return { stdout: out.join("\n"), exitCode: 0 };
+    },
+};
+/**
+ * tac — concatenate files in reverse (line order)
+ * @category text
+ * @params ["[file...]"]
+ */
+export const tacCommand = {
+    name: "tac",
+    description: "Concatenate files in reverse line order",
+    category: "text",
+    params: ["[file...]"],
+    run: ({ args, stdin, shell, cwd }) => {
+        const { resolvePath } = require("./helpers");
+        let input = "";
+        if (args.length === 0 || (args.length === 1 && args[0] === "-")) {
+            input = stdin ?? "";
+        }
+        else {
+            for (const f of args) {
+                const p = resolvePath(cwd ?? "/", f);
+                if (!shell.vfs.exists(p))
+                    return { stderr: `tac: ${f}: No such file or directory`, exitCode: 1 };
+                input += shell.vfs.readFile(p);
+            }
+        }
+        const lines = input.split("\n");
+        // preserve trailing newline behaviour
+        if (lines[lines.length - 1] === "")
+            lines.pop();
+        return { stdout: lines.reverse().join("\n"), exitCode: 0 };
+    },
+};
+/**
+ * nl — number lines of files
+ * @category text
+ * @params ["[file]"]
+ */
+export const nlCommand = {
+    name: "nl",
+    description: "Number lines of files",
+    category: "text",
+    params: ["[-ba] [-nrz] [file]"],
+    run: ({ args, stdin, shell, cwd }) => {
+        const { resolvePath } = require("./helpers");
+        const fileArg = args.find((a) => !a.startsWith("-"));
+        let input = stdin ?? "";
+        if (fileArg) {
+            const p = resolvePath(cwd ?? "/", fileArg);
+            if (!shell.vfs.exists(p))
+                return { stderr: `nl: ${fileArg}: No such file or directory`, exitCode: 1 };
+            input = shell.vfs.readFile(p);
+        }
+        const lines = input.split("\n");
+        if (lines[lines.length - 1] === "")
+            lines.pop();
+        let n = 1;
+        const out = lines.map((l) => {
+            if (l.trim() === "")
+                return `\t${l}`;
+            return `${String(n++).padStart(6)}\t${l}`;
+        });
+        return { stdout: out.join("\n"), exitCode: 0 };
+    },
+};
+/**
+ * column — columnate lists
+ * @category text
+ * @params ["[-t] [-s sep] [file]"]
+ */
+export const columnCommand = {
+    name: "column",
+    description: "Columnate lists",
+    category: "text",
+    params: ["[-t]", "[-s sep]", "[file]"],
+    run: ({ args, stdin, shell, cwd }) => {
+        const { resolvePath } = require("./helpers");
+        const tableMode = args.includes("-t");
+        const sIdx = args.indexOf("-s");
+        const sep = sIdx !== -1 ? (args[sIdx + 1] ?? "\t") : /\s+/;
+        const fileArg = args.find((a) => !a.startsWith("-") && a !== args[sIdx + 1]);
+        let input = stdin ?? "";
+        if (fileArg) {
+            const p = resolvePath(cwd ?? "/", fileArg);
+            if (!shell.vfs.exists(p))
+                return { stderr: `column: ${fileArg}: No such file or directory`, exitCode: 1 };
+            input = shell.vfs.readFile(p);
+        }
+        const lines = input.split("\n").filter((l) => l !== "");
+        if (tableMode) {
+            const rows = lines.map((l) => (typeof sep === "string" ? l.split(sep) : l.split(sep)));
+            const colWidths = [];
+            for (const row of rows) {
+                row.forEach((cell, ci) => {
+                    colWidths[ci] = Math.max(colWidths[ci] ?? 0, cell.length);
+                });
+            }
+            const out = rows.map((row) => row.map((cell, ci) => cell.padEnd(colWidths[ci] ?? 0)).join("  ").trimEnd());
+            return { stdout: out.join("\n"), exitCode: 0 };
+        }
+        // Default: fill columns (simple: just output as-is)
+        return { stdout: lines.join("\n"), exitCode: 0 };
+    },
+};

package/dist/commands/id.js

@@ -4,11 +4,18 @@ export const idCommand = {
     category: "system",
     params: ["[user]"],
     run: ({ authUser, shell, args }) => {
-        const target = args[0] ?? authUser;
+        const flagU = args.includes("-u");
+        const flagG = args.includes("-g");
+        const flagN = args.includes("-n");
+        const target = args.find(a => !a.startsWith("-")) ?? authUser;
         const uid = target === "root" ? 0 : 1000;
         const gid = uid;
         const isSudo = shell.users.isSudoer(target);
         const groups = isSudo ? `${gid}(${target}),0(root)` : `${gid}(${target})`;
+        if (flagU)
+            return { stdout: flagN ? target : String(uid), exitCode: 0 };
+        if (flagG)
+            return { stdout: flagN ? target : String(gid), exitCode: 0 };
         return {
             stdout: `uid=${uid}(${target}) gid=${gid}(${target}) groups=${groups}`,
             exitCode: 0,

package/dist/commands/index.d.ts

@@ -1,2 +1,2 @@
 export { createCustomCommand, getCommandModulesPublic, getCommandNames, registerCommand, resolveModule } from "./registry";
-export { makeDefaultEnv, runCommand, runCommandDirect, userHome } from "./runtime";
+export { applyUserSwitch, makeDefaultEnv, runCommand, runCommandDirect, userHome } from "./runtime";

package/dist/commands/index.js

@@ -1,2 +1,2 @@
 export { createCustomCommand, getCommandModulesPublic, getCommandNames, registerCommand, resolveModule } from "./registry";
-export { makeDefaultEnv, runCommand, runCommandDirect, userHome } from "./runtime";
+export { applyUserSwitch, makeDefaultEnv, runCommand, runCommandDirect, userHome } from "./runtime";

package/dist/commands/manuals-bundle.js

@@ -187,6 +187,28 @@ OPTIONS
 
 EXAMPLES
        cmatrix`,
+    "column": `COLUMN(1)                User Commands                   COLUMN(1)
+
+NAME
+       column - columnate lists
+
+SYNOPSIS
+       column [OPTION]... [FILE]...
+
+DESCRIPTION
+       The column utility formats its input into multiple columns.
+       Rows are filled before columns. Input is taken from FILE or stdin.
+
+OPTIONS
+       -t    determine the number of columns the input contains and create
+             a table (useful for pretty-printing)
+       -s    specify a set of characters to be used to delimit columns
+             (default: whitespace)
+
+EXAMPLES
+       mount | column -t
+       cat /etc/passwd | column -t -s:
+       column -t file.txt`,
     "cowsay": `COWSAY(1)                User Commands                  COWSAY(1)
 
 NAME
@@ -810,6 +832,31 @@ SYNOPSIS
 
 OPTIONS
        -p     no error if existing, make parent directories as needed`,
+    "mktemp": `MKTEMP(1)                User Commands                   MKTEMP(1)
+
+NAME
+       mktemp - create a temporary file or directory
+
+SYNOPSIS
+       mktemp [OPTION]... [TEMPLATE]
+
+DESCRIPTION
+       Create a temporary file or directory, safely, and print its name.
+       TEMPLATE must contain at least 3 consecutive 'X's in last component.
+       If TEMPLATE is not specified, use tmp.XXXXXXXXXX.
+       Files are created in /tmp.
+
+OPTIONS
+       -d    create a directory, not a file
+
+EXIT STATUS
+       0  on success
+       1  if the file/directory could not be created
+
+EXAMPLES
+       mktemp
+       mktemp -d
+       mktemp /tmp/foo.XXXXXX`,
     "mv": `MV(1)                    User Commands                      MV(1)
 
 NAME
@@ -841,6 +888,30 @@ SYNOPSIS
 
 DESCRIPTION
        Print OS, kernel, uptime, package count, and related system details.`,
+    "nl": `NL(1)                    User Commands                      NL(1)
+
+NAME
+       nl - number lines of files
+
+SYNOPSIS
+       nl [OPTION]... [FILE]...
+
+DESCRIPTION
+       Write each FILE to standard output, with line numbers added.
+       With no FILE, or when FILE is -, read standard input.
+
+OPTIONS
+       -b, --body-numbering=STYLE    use STYLE for numbering body lines
+             a    number all lines
+             t    number only non-empty lines (default)
+       -n, --number-format=FORMAT    use FORMAT for line numbers
+             ln   left justified, no leading zeros
+             rn   right justified, no leading zeros (default)
+             rz   right justified, leading zeros
+
+EXAMPLES
+       nl /etc/passwd
+       cat file.txt | nl`,
     "node": `NODE(1)                  User Commands                    NODE(1)
 
 NAME
@@ -867,6 +938,24 @@ DESCRIPTION
 
 NOTES
        Requires package installation: apt install npm.`,
+    "nproc": `NPROC(1)                 User Commands                    NPROC(1)
+
+NAME
+       nproc - print the number of processing units available
+
+SYNOPSIS
+       nproc [OPTION]...
+
+DESCRIPTION
+       Print the number of processing units available to the current process.
+       In this environment, always returns 4.
+
+OPTIONS
+       --all    print the number of installed processors
+
+EXAMPLES
+       nproc
+       make -j$(nproc)`,
     "npx": `NPX(1)                   User Commands                      NPX(1)
 
 NAME
@@ -880,6 +969,41 @@ DESCRIPTION
 
 NOTES
        Requires package installation: apt install npm.`,
+    "pacman": `PACMAN(1)                User Commands                   PACMAN(1)
+
+NAME
+       pacman - play ASCII Pac-Man in the terminal
+
+SYNOPSIS
+       pacman
+
+DESCRIPTION
+       pacman launches an interactive ASCII Pac-Man game using myman
+       maze graphics. Eat all dots to win. Avoid ghosts or lose a life.
+       Eat a power pellet to enter fright mode and eat ghosts for points.
+
+CONTROLS
+       W, Up     move up
+       S, Down   move down
+       A, Left   move left
+       D, Right  move right
+       Q, Ctrl+C quit
+
+GHOSTS
+       Blinky (red)    directly chases Pac-Man
+       Pinky (pink)    targets 4 tiles ahead of Pac-Man
+       Inky (cyan)     uses Blinky's position to compute target
+       Clyde (orange)  chases when far, scatters when close
+
+SCORING
+       Dot          10 points
+       Power pellet 50 points
+       Ghost        200 points (during fright mode)
+
+NOTES
+       Ghosts slow down during fright mode. Fright mode ends after
+       a few seconds; ghosts flash before returning to normal.
+       Left and right tunnel exits wrap around the maze.`,
     "passwd": `PASSWD(1)                 User Commands                 PASSWD(1)
 
 NAME
@@ -891,6 +1015,26 @@ SYNOPSIS
 DESCRIPTION
        Update the authentication token (password) for USER.
        Without USER, change the current user's password.`,
+    "paste": `PASTE(1)                 User Commands                   PASTE(1)
+
+NAME
+       paste - merge lines of files
+
+SYNOPSIS
+       paste [OPTION]... [FILE]...
+
+DESCRIPTION
+       Write lines consisting of the sequentially corresponding lines from
+       each FILE, separated by TABs, to standard output.
+
+OPTIONS
+       -d, --delimiters=LIST    use characters from LIST instead of TABs
+       -s, --serial             paste one file at a time instead of in parallel
+
+EXAMPLES
+       paste file1 file2
+       paste -d: /etc/passwd /etc/shadow
+       paste -d, a.txt b.txt c.txt`,
     "ping": `PING(8)                   User Commands                   PING(8)
 
 NAME
@@ -993,7 +1137,16 @@ SYNOPSIS
        rm [OPTION]... FILE...
 
 OPTIONS
-       -r     remove directories and their contents recursively`,
+       -r, -R remove directories and their contents recursively
+
+       -f, --force
+              skip confirmation prompt, never prompt
+
+       -rf, -fr
+              recursive and force combined
+
+       Without -f, rm prompts for confirmation before removing each target.
+       Answer y or yes to confirm, anything else cancels.`,
     "sed": `SED(1)                   User Commands                      SED(1)
 
 NAME
@@ -1071,6 +1224,28 @@ SYNOPSIS
 
 DESCRIPTION
        Rename positional parameters by discarding the first N arguments.`,
+    "shuf": `SHUF(1)                  User Commands                    SHUF(1)
+
+NAME
+       shuf - generate random permutations
+
+SYNOPSIS
+       shuf [OPTION]... [FILE]
+       shuf -i LO-HI [OPTION]...
+       shuf -e [OPTION]... [ARG]...
+
+DESCRIPTION
+       Write a random permutation of the input lines to standard output.
+
+OPTIONS
+       -i LO-HI    treat each number LO through HI as an input line
+       -n COUNT    output at most COUNT lines
+       -e           treat each ARG as an input line
+
+EXAMPLES
+       shuf /etc/passwd
+       shuf -i 1-10
+       shuf -n 3 /etc/hosts`,
     "sl": `SL(1)                    User Commands                      SL(1)
 
 NAME
@@ -1186,6 +1361,24 @@ SYNOPSIS
 OPTIONS
        -i          run login shell as target user
        -u USER     run command as USER`,
+    "tac": `TAC(1)                   User Commands                     TAC(1)
+
+NAME
+       tac - concatenate and print files in reverse
+
+SYNOPSIS
+       tac [OPTION]... [FILE]...
+
+DESCRIPTION
+       Write each FILE to standard output, last line first.
+       With no FILE, or when FILE is -, read standard input.
+
+OPTIONS
+       -s, --separator=STRING    use STRING as the record separator
+
+EXAMPLES
+       tac /var/log/syslog
+       echo -e "a\\nb\\nc" | tac`,
     "tail": `TAIL(1)                  User Commands                    TAIL(1)
 
 NAME
@@ -1236,6 +1429,29 @@ SYNOPSIS
 
 DESCRIPTION
        Evaluate conditional expressions for scripts and shell logic.`,
+    "timeout": `TIMEOUT(1)               User Commands                  TIMEOUT(1)
+
+NAME
+       timeout - run a command with a time limit
+
+SYNOPSIS
+       timeout DURATION COMMAND [ARG]...
+
+DESCRIPTION
+       Start COMMAND, and kill it if still running after DURATION seconds.
+       In this environment, the time limit is simulated and the command
+       always runs to completion.
+
+OPTIONS
+       DURATION    An integer number of seconds (e.g. 5).
+
+EXIT STATUS
+       124  if the command times out
+       Otherwise the exit status of COMMAND.
+
+EXAMPLES
+       timeout 5 sleep 10
+       timeout 30 curl http://example.com/`,
     "touch": `TOUCH(1)                 User Commands                  TOUCH(1)
 
 NAME
@@ -1397,6 +1613,26 @@ DESCRIPTION
        The following entries are displayed for each user: login name,
        the tty name, the remote host, login time, idle time, JCPU, PCPU,
        and the command line of the current process.`,
+    "wait": `WAIT(1)                  Bash Builtin Commands             WAIT(1)
+
+NAME
+       wait - wait for job completion
+
+SYNOPSIS
+       wait [jobspec or pid ...]
+
+DESCRIPTION
+       Wait for each specified process or job and return its termination
+       status. If no arguments are given, wait for all currently active
+       background jobs.
+
+       In this environment, background jobs are fire-and-forget; wait
+       returns immediately with exit code 0.
+
+EXAMPLES
+       sleep 5 &
+       wait
+       echo "done"`,
     "wc": `WC(1)                    User Commands                      WC(1)
 
 NAME

package/dist/commands/pacman.d.ts

@@ -0,0 +1,8 @@
+import type { ShellModule } from "../types/commands";
+/**
+ * Play ASCII Pac-Man in the terminal (myman-wip-2009-10-30 maze graphics).
+ * Controls: WASD or arrow keys to move, Q to quit.
+ * @category misc
+ * @params [""]
+ */
+export declare const pacmanCommand: ShellModule;

package/dist/commands/pacman.js

@@ -0,0 +1,15 @@
+/**
+ * Play ASCII Pac-Man in the terminal (myman-wip-2009-10-30 maze graphics).
+ * Controls: WASD or arrow keys to move, Q to quit.
+ * @category misc
+ * @params [""]
+ */
+export const pacmanCommand = {
+    name: "pacman",
+    description: "Play ASCII Pac-Man (myman graphics, WASD/arrows)",
+    category: "misc",
+    params: [],
+    run: () => {
+        return { openPacman: true, exitCode: 0 };
+    },
+};

package/dist/commands/registry.js

@@ -5,6 +5,7 @@ import { awkCommand } from "./awk";
 import { base64Command } from "./base64";
 import { basenameCommand, dirnameCommand } from "./basename";
 import { bcCommand } from "./bc";
+import { columnCommand, mktempCommand, nlCommand, nprocCommand, pasteCommand, shufCommand, tacCommand, timeoutCommand, waitCommand } from "./coreutils";
 import { bunzip2Command, bzip2Command } from "./bzip2";
 import { lsofCommand } from "./lsof";
 import { perlCommand } from "./perl";
@@ -32,6 +33,7 @@ import { fileCommand } from "./file";
 import { findCommand } from "./find";
 import { freeCommand } from "./free";
 import { cmatrixCommand, cowsayCommand, cowthinkCommand, fortuneCommand, slCommand, yesCommand } from "./fun";
+import { pacmanCommand } from "./pacman";
 import { grepCommand } from "./grep";
 import { groupsCommand } from "./groups";
 import { gunzipCommand, gzipCommand } from "./gzip";
@@ -177,6 +179,7 @@ const BASE_COMMANDS = [
     cowthinkCommand,
     cmatrixCommand,
     slCommand,
+    pacmanCommand,
     htopCommand,
     // Network
     curlCommand,
@@ -227,6 +230,16 @@ const BASE_COMMANDS = [
     straceCommand,
     // Scripting
     perlCommand,
+    // Coreutils (extended)
+    timeoutCommand,
+    mktempCommand,
+    nprocCommand,
+    waitCommand,
+    shufCommand,
+    pasteCommand,
+    tacCommand,
+    nlCommand,
+    columnCommand,
 ];
 const customCommands = [];
 const commandRegistry = new Map();

package/dist/commands/rm.d.ts

@@ -2,6 +2,6 @@ import type { ShellModule } from "../types/commands";
 /**
  * Remove files or directories from the filesystem.
  * @category files
- * @params ["[-r|-rf] <path>"]
+ * @params ["[-r|-rf|-f] <path>"]
  */
 export declare const rmCommand: ShellModule;