typescript-virtual-container 1.5.8 → 1.5.10

package/dist/commands/htop.js

@@ -1,17 +1,152 @@
+import * as os from "node:os";
+const C = {
+    reset: "\x1b[0m",
+    bold: "\x1b[1m",
+    rev: "\x1b[7m",
+    green: "\x1b[32m",
+    cyan: "\x1b[36m",
+    yellow: "\x1b[33m",
+    red: "\x1b[31m",
+    blue: "\x1b[34m",
+    magenta: "\x1b[35m",
+    white: "\x1b[97m",
+    bgBlue: "\x1b[44m",
+    bgGreen: "\x1b[42m",
+    bgRed: "\x1b[41m",
+    dim: "\x1b[2m",
+};
+function bar(ratio, width) {
+    const filled = Math.round(ratio * width);
+    const empty = width - filled;
+    const color = ratio > 0.8 ? C.red : ratio > 0.5 ? C.yellow : C.green;
+    return `${color}${"█".repeat(filled)}${C.dim}${"░".repeat(empty)}${C.reset}`;
+}
+function fmtBytes(b) {
+    if (b >= 1024 ** 3)
+        return `${(b / 1024 ** 3).toFixed(1)}G`;
+    if (b >= 1024 ** 2)
+        return `${(b / 1024 ** 2).toFixed(1)}M`;
+    if (b >= 1024)
+        return `${(b / 1024).toFixed(1)}K`;
+    return `${b}B`;
+}
+function fmtUptime(ms) {
+    const s = Math.floor(ms / 1000);
+    const d = Math.floor(s / 86400);
+    const h = Math.floor((s % 86400) / 3600);
+    const m = Math.floor((s % 3600) / 60);
+    const sec = s % 60;
+    if (d > 0)
+        return `${d}d ${String(h).padStart(2, "0")}:${String(m).padStart(2, "0")}:${String(sec).padStart(2, "0")}`;
+    return `${String(h).padStart(2, "0")}:${String(m).padStart(2, "0")}:${String(sec).padStart(2, "0")}`;
+}
 /**
- * Interactive system monitor (requires terminal interaction).
+ * Interactive system monitor — full ANSI output in exec/ssh mode, interactive panel in shell mode.
  * @category system
- * @params []
+ * @params ["[-d delay] [-p pid]"]
  */
 export const htopCommand = {
     name: "htop",
-    description: "System monitor",
+    description: "Interactive system monitor",
     category: "system",
-    params: [],
-    run: ({ mode }) => {
-        if (mode === "exec") {
-            return { stderr: "htop: interactive terminal required", exitCode: 1 };
+    params: ["[-d delay]", "[-p pid]"],
+    run: ({ shell, authUser }) => {
+        // Render ANSI snapshot in all modes — real htop child_process unavailable in-process
+        const totalMem = os.totalmem();
+        const freeMem = os.freemem();
+        const usedMem = totalMem - freeMem;
+        const swapTotal = Math.floor(totalMem * 0.5);
+        const swapUsed = Math.floor(swapTotal * 0.02);
+        const cpus = os.cpus();
+        const cpuCount = cpus.length || 4;
+        const uptimeMs = Date.now() - shell.startTime;
+        const sessions = shell.users.listActiveSessions();
+        const taskCount = sessions.length + shell.users.listProcesses().length + 3; // bash sessions + running cmds + kernel threads
+        const now = new Date().toTimeString().slice(0, 8);
+        const memRatio = usedMem / totalMem;
+        const swapRatio = swapUsed / swapTotal;
+        const barWidth = 20;
+        const lines = [];
+        // ── Header ─────────────────────────────────────────────────────────────
+        const cpuLoads = [];
+        for (let i = 0; i < cpuCount; i++) {
+            cpuLoads.push(Math.random() * 0.3 + 0.02);
+        }
+        // CPU bars (up to 4 shown)
+        const shownCpus = Math.min(cpuCount, 4);
+        for (let i = 0; i < shownCpus; i++) {
+            const load = cpuLoads[i];
+            const pct = (load * 100).toFixed(1).padStart(5);
+            lines.push(`${C.bold}${C.cyan}${String(i + 1).padStart(3)}${C.reset}[${bar(load, barWidth)}${C.reset}] ${pct}%`);
+        }
+        if (cpuCount > 4) {
+            lines.push(`${C.dim}    ... ${cpuCount - 4} more CPU(s) not shown${C.reset}`);
+        }
+        lines.push(`${C.bold}${C.cyan}Mem${C.reset}[${bar(memRatio, barWidth)}${C.reset}] ${fmtBytes(usedMem)}/${fmtBytes(totalMem)}`);
+        lines.push(`${C.bold}${C.cyan}Swp${C.reset}[${bar(swapRatio, barWidth)}${C.reset}] ${fmtBytes(swapUsed)}/${fmtBytes(swapTotal)}`);
+        lines.push("");
+        // ── Summary line ───────────────────────────────────────────────────────
+        const avgLoad = cpuLoads.slice(0, cpuCount).reduce((a, b) => a + b, 0) / cpuCount;
+        const load1 = (avgLoad * cpuCount).toFixed(2);
+        const load5 = (avgLoad * cpuCount * 0.9).toFixed(2);
+        const load15 = (avgLoad * cpuCount * 0.8).toFixed(2);
+        lines.push(`${C.bold}Tasks:${C.reset} ${C.green}${taskCount}${C.reset} total  ` +
+            `${C.bold}Load average:${C.reset} ${load1} ${load5} ${load15}  ` +
+            `${C.bold}Uptime:${C.reset} ${fmtUptime(uptimeMs)}`);
+        lines.push("");
+        // ── Process table header ───────────────────────────────────────────────
+        const hdr = `${C.bgBlue}${C.bold}${C.white}` +
+            "  PID USER       PRI  NI  VIRT   RES  SHR S  CPU%  MEM% TIME+     COMMAND" +
+            `${C.reset}`;
+        lines.push(hdr);
+        // Kernel / system processes
+        const sysProcs = [
+            { pid: 1, user: "root", cmd: "systemd", cpu: 0.0, mem: 0.1 },
+            { pid: 2, user: "root", cmd: "kthreadd", cpu: 0.0, mem: 0.0 },
+            { pid: 9, user: "root", cmd: "rcu_sched", cpu: (Math.random() * 0.2), mem: 0.0 },
+            { pid: 127, user: "root", cmd: "sshd", cpu: 0.0, mem: 0.2 },
+        ];
+        // Active sessions (bash processes)
+        let pid = 1000;
+        const sessionProcs = sessions.map((s) => ({
+            pid: pid++,
+            user: s.username,
+            cmd: "bash",
+            cpu: Math.random() * 0.5,
+            mem: (usedMem / totalMem * 100 / Math.max(sessions.length, 1) * 0.3),
+        }));
+        // Currently running commands
+        const runningProcs = shell.users.listProcesses().map((p) => ({
+            pid: p.pid,
+            user: p.username,
+            cmd: p.argv.join(" ").slice(0, 40),
+            cpu: Math.random() * 2.0 + 0.1,
+            mem: (usedMem / totalMem * 100 * 0.5),
+        }));
+        // htop itself
+        const htopProc = { pid: pid++, user: authUser, cmd: "htop", cpu: 0.1, mem: 0.1 };
+        const procs = [...sysProcs, ...sessionProcs, ...runningProcs, htopProc];
+        for (const p of procs) {
+            const virt = fmtBytes(Math.floor(Math.random() * 200 * 1024 * 1024 + 10 * 1024 * 1024));
+            const res = fmtBytes(Math.floor(Math.random() * 20 * 1024 * 1024 + 1024 * 1024));
+            const shr = fmtBytes(Math.floor(Math.random() * 5 * 1024 * 1024 + 512 * 1024));
+            const cpuPct = p.cpu.toFixed(1).padStart(5);
+            const memPct = p.mem.toFixed(1).padStart(5);
+            const time = `${String(Math.floor(Math.random() * 10)).padStart(2)}:${String(Math.floor(Math.random() * 60)).padStart(2, "0")}.${String(Math.floor(Math.random() * 100)).padStart(2, "0")}`;
+            const userColor = p.user === "root" ? C.red : p.user === authUser ? C.green : C.cyan;
+            const cmdColor = p.cmd === "htop" ? C.green : p.cmd === "bash" ? C.cyan : C.reset;
+            lines.push(`${String(p.pid).padStart(5)} ` +
+                `${userColor}${p.user.padEnd(10).slice(0, 10)}${C.reset} ` +
+                ` 20   0 ` +
+                `${virt.padStart(6)} ${res.padStart(6)} ${shr.padStart(5)} ` +
+                `S ${cpuPct} ${memPct} ` +
+                `${time.padStart(9)}  ` +
+                `${cmdColor}${p.cmd}${C.reset}`);
         }
-        return { openHtop: true, exitCode: 0 };
+        lines.push("");
+        // ── Footer ─────────────────────────────────────────────────────────────
+        lines.push(`${C.dim}${now} — htop snapshot (non-interactive mode)  ` +
+            `press ${C.reset}${C.bold}q${C.reset}${C.dim} to quit in interactive mode${C.reset}`);
+        return { stdout: lines.join("\n"), exitCode: 0 };
     },
 };

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
@@ -1080,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
@@ -1195,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
@@ -1245,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
@@ -1406,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/ps.js

@@ -11,36 +11,50 @@ export const psCommand = {
     params: ["[-a] [-u] [-x] [aux]"],
     run: ({ authUser, shell, args }) => {
         const sessions = shell.users.listActiveSessions();
+        const procs = shell.users.listProcesses();
         const showUser = ifFlag(args, ["-u"]) ||
             args.includes("u") ||
             args.includes("aux") ||
             args.includes("au");
         const showAll = ifFlag(args, ["-a", "-x"]) || args.includes("a") || args.includes("aux");
+        // Build bash-entry pid map from sessions (stable pids based on index)
+        const sessionPids = new Map(sessions.map((s, i) => [s.id, 1000 + i]));
+        const nextPid = 1000 + sessions.length;
         if (showUser) {
             const header = "USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND";
             const rows = [header];
-            let pid = 1000;
             for (const s of sessions) {
                 const user = s.username.padEnd(10).slice(0, 10);
                 const mem = (Math.random() * 0.5).toFixed(1);
                 const vsz = Math.floor(Math.random() * 20000 + 5000);
                 const rss = Math.floor(Math.random() * 5000 + 1000);
-                rows.push(`${user} ${String(pid).padStart(6)}  0.0  ${mem.padStart(4)} ${String(vsz).padStart(6)} ${String(rss).padStart(5)} ${s.tty.padEnd(8)} Ss   00:00   0:00 bash`);
-                pid++;
+                rows.push(`${user} ${String(sessionPids.get(s.id)).padStart(6)}  0.0  ${mem.padStart(4)} ${String(vsz).padStart(6)} ${String(rss).padStart(5)} ${s.tty.padEnd(8)} Ss   00:00   0:00 bash`);
             }
-            rows.push(`root       ${String(pid).padStart(6)}  0.0   0.0      0      0 ?        S    00:00   0:00 ps`);
+            for (const p of procs) {
+                if (!showAll && p.username !== authUser)
+                    continue;
+                const user = p.username.padEnd(10).slice(0, 10);
+                const mem = (Math.random() * 1.5).toFixed(1);
+                const vsz = Math.floor(Math.random() * 50000 + 10000);
+                const rss = Math.floor(Math.random() * 10000 + 2000);
+                rows.push(`${user} ${String(p.pid).padStart(6)}  0.1  ${mem.padStart(4)} ${String(vsz).padStart(6)} ${String(rss).padStart(5)} ${p.tty.padEnd(8)} S    00:00   0:00 ${p.command}`);
+            }
+            rows.push(`root       ${String(nextPid).padStart(6)}  0.0   0.0      0      0 ?        S    00:00   0:00 ps`);
             return { stdout: rows.join("\n"), exitCode: 0 };
         }
         const header = "  PID TTY          TIME CMD";
         const rows = [header];
-        let pid = 1000;
         for (const s of sessions) {
             if (!showAll && s.username !== authUser)
                 continue;
-            rows.push(`${String(pid).padStart(5)} ${s.tty.padEnd(12)} 00:00:00 ${s.username === authUser ? "bash" : `bash (${s.username})`}`);
-            pid++;
+            rows.push(`${String(sessionPids.get(s.id)).padStart(5)} ${s.tty.padEnd(12)} 00:00:00 ${s.username === authUser ? "bash" : `bash (${s.username})`}`);
+        }
+        for (const p of procs) {
+            if (!showAll && p.username !== authUser)
+                continue;
+            rows.push(`${String(p.pid).padStart(5)} ${p.tty.padEnd(12)} 00:00:00 ${p.command}`);
         }
-        rows.push(`${String(pid).padStart(5)} pts/0        00:00:00 ps`);
+        rows.push(`${String(nextPid).padStart(5)} pts/0        00:00:00 ps`);
         return { stdout: rows.join("\n"), 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/runtime.js

@@ -136,17 +136,22 @@ 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
     _callDepth++;
-    // console.debug(`[depth=${_callDepth}] runCommandDirect: ${name}`);
     if (_callDepth > MAX_CALL_DEPTH) {
         _callDepth--;
-        // console.debug(`[LOOP DETECTED] runCommandDirect blocked: ${name}`);
         return { stderr: `${name}: maximum call depth (${MAX_CALL_DEPTH}) exceeded`, exitCode: 126 };
     }
+    // Register as visible process only at the outermost call level
+    const isTopLevel = _callDepth === 1;
+    const pid = isTopLevel
+        ? shell.users.registerProcess(authUser, name, [name, ...args], env.vars.__TTY ?? "?")
+        : -1;
     try {
         return await _runCommandDirectInner(name, args, authUser, hostname, mode, cwd, shell, stdin, env);
     }
     finally {
         _callDepth--;
+        if (isTopLevel && pid !== -1)
+            shell.users.unregisterProcess(pid);
     }
 }
 async function _runCommandDirectInner(name, args, authUser, hostname, mode, cwd, shell, stdin, env) {
@@ -180,6 +185,41 @@ async function _runCommandDirectInner(name, args, authUser, hostname, mode, cwd,
             }
         }
     }
+    // Shell function defined via sh.ts (stored as __func_<name>)
+    const funcBody = env.vars[`__func_${name}`];
+    if (funcBody) {
+        const shMod = resolveModule("sh");
+        if (!shMod)
+            return { stderr: `${name}: sh not available`, exitCode: 127 };
+        const savedPositional = {};
+        args.forEach((a, i) => {
+            savedPositional[String(i + 1)] = env.vars[String(i + 1)];
+            env.vars[String(i + 1)] = a;
+        });
+        savedPositional["0"] = env.vars["0"];
+        env.vars["0"] = name;
+        try {
+            return await shMod.run({
+                authUser, hostname,
+                activeSessions: shell.users.listActiveSessions(),
+                rawInput: funcBody,
+                mode,
+                args: ["-c", funcBody],
+                stdin,
+                cwd,
+                shell,
+                env,
+            });
+        }
+        finally {
+            for (const [k, v] of Object.entries(savedPositional)) {
+                if (v === undefined)
+                    delete env.vars[k];
+                else
+                    env.vars[k] = v;
+            }
+        }
+    }
     const aliasVal = env.vars[`__alias_${name}`];
     if (aliasVal) {
         return runCommand(`${aliasVal} ${args.join(" ")}`, authUser, hostname, mode, cwd, shell, stdin, env);

package/dist/commands/sh.js

@@ -2,6 +2,12 @@ import { evalArith, expandAsync, expandBraces } from "../utils/expand";
 import { ifFlag } from "./command-helpers";
 import { resolvePath } from "./helpers";
 import { runCommand } from "./runtime";
+// Module-level compiled regexes for function definition matching.
+// Rebuilt per-line inside parseBlocks would recompile on every script line — hoisted here instead.
+const _funcNamePat = "[^\\s(){}]+";
+const RE_FUNC_INLINE = new RegExp(`^(?:function\\s+)?(${_funcNamePat})\\s*\\(\\s*\\)\\s*\\{(.+)\\}\\s*$`);
+const RE_FUNC_MULTI = new RegExp(`^(?:function\\s+)?(${_funcNamePat})\\s*\\(\\s*\\)\\s*\\{?\\s*$`);
+const RE_FUNC_KW_ONLY = new RegExp(`^function\\s+(${_funcNamePat})\\s*\\{?\\s*$`);
 /**
  * Expand all shell forms including $(cmd) substitution.
  * Delegates to centralised expandAsync (single-quote-aware, depth-tracked).
@@ -20,9 +26,10 @@ function parseBlocks(lines) {
             continue;
         }
         // Function definition: name() { or function name { or name() { body }
-        const funcMatchInline = line.match(/^(?:function\s+)?(\w+)\s*\(\s*\)\s*\{(.+)\}\s*$/);
-        const funcMatch = funcMatchInline ?? (line.match(/^(?:function\s+)?(\w+)\s*\(\s*\)\s*\{?\s*$/) ||
-            line.match(/^function\s+(\w+)\s*\{?\s*$/));
+        // Shell allows any non-whitespace identifier as function name (incl. ':')
+        const funcMatchInline = line.match(RE_FUNC_INLINE);
+        const funcMatch = funcMatchInline ?? (line.match(RE_FUNC_MULTI) ||
+            line.match(RE_FUNC_KW_ONLY));
         if (funcMatch) {
             const funcName = funcMatch[1];
             const body = [];

package/dist/index.d.ts

@@ -6,7 +6,7 @@ export { default as VirtualFileSystem } from "./VirtualFileSystem/index";
 export { VirtualPackageManager } from "./VirtualPackageManager/index";
 export { VirtualShell } from "./VirtualShell/index";
 export { VirtualUserManager } from "./VirtualUserManager/index";
-export type { VirtualActiveSession } from "./VirtualUserManager/index";
+export type { VirtualActiveSession, VirtualProcess } from "./VirtualUserManager/index";
 export { IdleManager } from "./VirtualShell/idleManager";
 export type { IdleManagerOptions, IdleState } from "./VirtualShell/idleManager";
 export type { AuditLogEntry, HoneyPotStats } from "./Honeypot/index";