typescript-virtual-container 1.5.11 → 1.6.0

package/dist/commands/runtime.js

@@ -40,6 +40,15 @@ export async function applyUserSwitch(newUser, hostname, cwd, shellEnv, shell) {
         catch { /* ignore */ }
     }
 }
+/**
+ * Creates the default shell environment variables for a given user and host.
+ * Sets PATH, HOME, USER, LOGNAME, SHELL, TERM, HOSTNAME, and a coloured PS1
+ * prompt that distinguishes root (red) from ordinary users (magenta).
+ *
+ * @param authUser - The authenticated username
+ * @param hostname - The machine hostname
+ * @returns A ShellEnv populated with default variable values
+ */
 export function makeDefaultEnv(authUser, hostname) {
     return {
         vars: {
@@ -98,7 +107,7 @@ function resolveVfsBinary(name, env, shell, authUser) {
                 continue;
             return full;
         }
-        catch { }
+        catch { /* not a regular file */ }
     }
     return null;
 }
@@ -133,7 +142,27 @@ async function runVfsStub(vfsBinary, cmdName, args, rawInput, authUser, hostname
     return { stderr: `${cmdName}: command not found`, exitCode: 127 };
 }
 let _callDepth = 0;
-export async function runCommandDirect(name, args, authUser, hostname, mode, cwd, shell, stdin, env) {
+/**
+ * Runs a command directly by name, bypassing shell parsing and expansion.
+ * Handles variable assignments prefixing the command, shell functions
+ * (stored as `__func_<name>`), aliases, registered modules, and VFS
+ * stub binaries. Includes an anti-loop guard via a module-level call depth
+ * counter and registers the process in the user's session table.
+ *
+ * @param name            - The command name to execute
+ * @param args            - Argument array (does not include the command name)
+ * @param authUser        - The authenticated user
+ * @param hostname        - The machine hostname
+ * @param mode            - The current command mode (shell, pipe, etc.)
+ * @param cwd             - The current working directory
+ * @param shell           - The VirtualShell instance
+ * @param stdin           - Optional stdin string
+ * @param env             - The current shell environment
+ * @param background      - Whether the command is run in the background
+ * @param abortController - Optional controller to abort a background process
+ * @returns The command result
+ */
+export async function runCommandDirect(name, args, authUser, hostname, mode, cwd, shell, stdin, env, background = false, abortController) {
     // Anti-loop guard: track call depth via env to avoid infinite recursion
     _callDepth++;
     if (_callDepth > MAX_CALL_DEPTH) {
@@ -143,15 +172,24 @@ export async function runCommandDirect(name, args, authUser, hostname, mode, cwd
     // 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 ?? "?")
+        ? shell.users.registerProcess(authUser, name, [name, ...args], env.vars.__TTY ?? "?", abortController)
         : -1;
     try {
+        if (background && abortController?.signal.aborted) {
+            return { stderr: "", exitCode: 130 };
+        }
         return await _runCommandDirectInner(name, args, authUser, hostname, mode, cwd, shell, stdin, env);
     }
     finally {
         _callDepth--;
-        if (isTopLevel && pid !== -1)
-            shell.users.unregisterProcess(pid);
+        if (isTopLevel && pid !== -1) {
+            if (background) {
+                shell.users.markProcessDone(pid);
+            }
+            else {
+                shell.users.unregisterProcess(pid);
+            }
+        }
     }
 }
 async function _runCommandDirectInner(name, args, authUser, hostname, mode, cwd, shell, stdin, env) {
@@ -253,6 +291,23 @@ async function _runCommandDirectInner(name, args, authUser, hostname, mode, cwd,
         };
     }
 }
+/**
+ * Parses and runs a command line string through the full execution pipeline:
+ * history expansion (`!!` / `!n`), alias expansion, sh-syntax detection
+ * (for/while/if/function/arithmetic), pipe/redirect routing via the shell
+ * parser, variable expansion, brace expansion, and glob expansion. Falls
+ * back to the `sh` interpreter for compound constructs.
+ *
+ * @param rawInput - The raw command line string to parse and run
+ * @param authUser - The authenticated user
+ * @param hostname - The machine hostname
+ * @param mode     - The current command mode (shell, pipe, etc.)
+ * @param cwd      - The current working directory
+ * @param shell    - The VirtualShell instance
+ * @param stdin    - Optional stdin string
+ * @param env      - Optional shell environment (created from defaults if omitted)
+ * @returns The command result
+ */
 export async function runCommand(rawInput, authUser, hostname, mode, cwd, shell, stdin, env) {
     const trimmed = rawInput.trim();
     if (trimmed.length === 0)

package/dist/commands/sh.d.ts

@@ -1,2 +1,7 @@
 import type { ShellModule } from "../types/commands";
+/**
+ * Execute shell script or command.
+ * @category shell
+ * @params ["-c <script>", "[<file>]"]
+ */
 export declare const shCommand: ShellModule;

package/dist/commands/sh.js

@@ -514,6 +514,11 @@ function splitShScript(script) {
         lines.push(t);
     return lines;
 }
+/**
+ * Execute shell script or command.
+ * @category shell
+ * @params ["-c <script>", "[<file>]"]
+ */
 export const shCommand = {
     name: "sh",
     aliases: ["bash"],

package/dist/commands/stat.js

@@ -20,7 +20,6 @@ export const statCommand = {
         }
         const st = shell.vfs.stat(p);
         const isDir = st.type === "directory";
-        const _isLink = shell.vfs.isSymlink(p);
         const isSymlink = shell.vfs.isSymlink(p);
         const modePerm = (mode) => {
             const bits = [0o400, 0o200, 0o100, 0o040, 0o020, 0o010, 0o004, 0o002, 0o001];
@@ -44,10 +43,12 @@ export const statCommand = {
                 .replace("%z", ts(st.updatedAt));
             return { stdout: `${out}\n`, exitCode: 0 };
         }
+        const statUid = "uid" in st ? st.uid : 0;
+        const statGid = "gid" in st ? st.gid : 0;
         const out = [
             `  File: ${file}${isSymlink ? ` -> ${shell.vfs.resolveSymlink(p)}` : ""}`,
             `  Size: ${size}${"\t".repeat(3)}${isSymlink ? "symbolic link" : isDir ? "directory" : "regular file"}`,
-            `Access: (${octal}/${modeStr})  Uid: (    0/    root)   Gid: (    0/    root)`,
+            `Access: (${octal}/${modeStr})  Uid: (${String(statUid).padStart(5)}/    root)   Gid: (${String(statGid).padStart(5)}/    root)`,
             `Modify: ${ts(st.updatedAt)}`,
             `Change: ${ts(st.updatedAt)}`,
         ].join("\n");

package/dist/commands/strace.js

@@ -11,7 +11,6 @@ export const straceCommand = {
         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`,

package/dist/commands/sysinfo.d.ts

@@ -0,0 +1,19 @@
+import type { ShellModule } from "../types/commands";
+/**
+ * Display CPU architecture information
+ * @category system
+ * @params []
+ */
+export declare const lscpuCommand: ShellModule;
+/**
+ * List USB devices
+ * @category system
+ * @params []
+ */
+export declare const lsusbCommand: ShellModule;
+/**
+ * List PCI devices
+ * @category system
+ * @params []
+ */
+export declare const lspciCommand: ShellModule;

package/dist/commands/sysinfo.js

@@ -0,0 +1,73 @@
+import * as os from "node:os";
+/**
+ * Display CPU architecture information
+ * @category system
+ * @params []
+ */
+export const lscpuCommand = {
+    name: "lscpu",
+    description: "Display CPU architecture information",
+    category: "system",
+    params: [],
+    run: () => {
+        const cpus = os.cpus();
+        const arch = os.arch();
+        const endian = os.endianness();
+        const cores = cpus.length;
+        const model = cpus.length > 0 ? cpus[0].model : "Unknown";
+        const lines = [
+            `Architecture:        ${arch}`,
+            `CPU op-mode(s):      32-bit, 64-bit`,
+            `Byte Order:          ${endian}`,
+            `CPU(s):              ${cores}`,
+            `On-line CPU(s) list: 0-${cores - 1}`,
+            `Model name:          ${model}`,
+            `Thread(s) per core:  1`,
+            `Core(s) per socket:  ${cores}`,
+            `Socket(s):           1`,
+            `Vendor ID:           GenuineIntel`,
+        ];
+        return { stdout: lines.join("\n") + "\n", exitCode: 0 };
+    },
+};
+/**
+ * List USB devices
+ * @category system
+ * @params []
+ */
+export const lsusbCommand = {
+    name: "lsusb",
+    description: "List USB devices",
+    category: "system",
+    params: [],
+    run: () => {
+        const devices = [
+            "Bus 001 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub",
+            "Bus 001 Device 002: ID 80ee:0021 VirtualBox USB Tablet",
+            "Bus 002 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub",
+        ];
+        return { stdout: devices.join("\n") + "\n", exitCode: 0 };
+    },
+};
+/**
+ * List PCI devices
+ * @category system
+ * @params []
+ */
+export const lspciCommand = {
+    name: "lspci",
+    description: "List PCI devices",
+    category: "system",
+    params: [],
+    run: () => {
+        const devices = [
+            "00:00.0 Host bridge: Intel Corporation 440FX - 82441FX PMC [Natoma]",
+            "00:01.0 ISA bridge: Intel Corporation 82371SB PIIX3 ISA [Natoma/Triton II]",
+            "00:01.1 IDE interface: Intel Corporation 82371SB PIIX3 IDE [Natoma/Triton II]",
+            "00:02.0 VGA compatible controller: VMware SVGA II Adapter",
+            "00:03.0 Ethernet controller: Intel Corporation 82540EM Gigabit Ethernet Controller",
+            "00:04.0 SATA controller: Intel Corporation 82801IR/IO (ICH9R) SATA Controller",
+        ];
+        return { stdout: devices.join("\n") + "\n", exitCode: 0 };
+    },
+};

package/dist/commands/test.d.ts

@@ -1,2 +1,7 @@
 import type { ShellModule } from "../types/commands";
+/**
+ * Evaluate conditional expression.
+ * @category shell
+ * @params ["<expression>"]
+ */
 export declare const testCommand: ShellModule;

package/dist/commands/test.js

@@ -96,6 +96,11 @@ function evalTest(tokens, shell, cwd) {
         return (tokens[0] ?? "").length > 0;
     return false;
 }
+/**
+ * Evaluate conditional expression.
+ * @category shell
+ * @params ["<expression>"]
+ */
 export const testCommand = {
     name: "test",
     aliases: ["["],

package/dist/commands/textutils.d.ts

@@ -0,0 +1,25 @@
+import type { ShellModule } from "../types/commands";
+/**
+ * Join lines of two files on a common field
+ * @category text
+ * @params ["[-t sep] <file1> <file2>"]
+ */
+export declare const joinCommand: ShellModule;
+/**
+ * Compare two sorted files line by line
+ * @category text
+ * @params ["<file1> <file2>"]
+ */
+export declare const commCommand: ShellModule;
+/**
+ * Split a file into pieces
+ * @category text
+ * @params ["[-l lines] [-b bytes] <file> [prefix]"]
+ */
+export declare const splitCommand: ShellModule;
+/**
+ * Split a file based on context patterns
+ * @category text
+ * @params ["<file> <pattern>..."]
+ */
+export declare const csplitCommand: ShellModule;

package/dist/commands/textutils.js

@@ -0,0 +1,171 @@
+import { parseArgs } from "./command-helpers";
+import { resolvePath } from "./helpers";
+function alphaSuffix(n) {
+    let result = "";
+    let x = n;
+    do {
+        result = String.fromCharCode(97 + (x % 26)) + result;
+        x = Math.floor(x / 26) - 1;
+    } while (x >= 0);
+    return result;
+}
+/**
+ * Join lines of two files on a common field
+ * @category text
+ * @params ["[-t sep] <file1> <file2>"]
+ */
+export const joinCommand = {
+    name: "join",
+    description: "Join lines of two files on a common field",
+    category: "text",
+    params: ["[-t sep] <file1> <file2>"],
+    run: ({ shell, cwd, args }) => {
+        const { flagsWithValues, positionals } = parseArgs(args, {
+            flagsWithValue: ["-t"],
+        });
+        const separator = flagsWithValues.get("-t") || " \t";
+        const [file1, file2] = positionals;
+        if (!file1 || !file2) {
+            return { stderr: "join: missing operand\n", exitCode: 1 };
+        }
+        const p1 = resolvePath(cwd, file1);
+        const p2 = resolvePath(cwd, file2);
+        if (!shell.vfs.exists(p1) || !shell.vfs.exists(p2)) {
+            return { stderr: "join: No such file\n", exitCode: 1 };
+        }
+        const lines1 = shell.vfs.readFile(p1).split("\n").filter(Boolean);
+        const lines2 = shell.vfs.readFile(p2).split("\n").filter(Boolean);
+        const sep = separator === " \t" ? /\s+/ : new RegExp(separator);
+        const map1 = new Map();
+        for (const line of lines1) {
+            const key = line.split(sep)[0] || line;
+            map1.set(key, line);
+        }
+        const results = [];
+        for (const line of lines2) {
+            const key = line.split(sep)[0] || line;
+            const match = map1.get(key);
+            if (match) {
+                results.push(`${match} ${line}`);
+            }
+        }
+        return { stdout: results.join("\n") + "\n", exitCode: 0 };
+    },
+};
+/**
+ * Compare two sorted files line by line
+ * @category text
+ * @params ["<file1> <file2>"]
+ */
+export const commCommand = {
+    name: "comm",
+    description: "Compare two sorted files line by line",
+    category: "text",
+    params: ["<file1> <file2>"],
+    run: ({ shell, cwd, args }) => {
+        const positionals = args.filter((a) => !a.startsWith("-"));
+        const [file1, file2] = positionals;
+        if (!file1 || !file2) {
+            return { stderr: "comm: missing operand\n", exitCode: 1 };
+        }
+        const p1 = resolvePath(cwd, file1);
+        const p2 = resolvePath(cwd, file2);
+        if (!shell.vfs.exists(p1) || !shell.vfs.exists(p2)) {
+            return { stderr: "comm: No such file\n", exitCode: 1 };
+        }
+        const lines1 = shell.vfs.readFile(p1).split("\n");
+        const lines2 = shell.vfs.readFile(p2).split("\n");
+        if (lines1[lines1.length - 1] === "")
+            lines1.pop();
+        if (lines2[lines2.length - 1] === "")
+            lines2.pop();
+        const set1 = new Set(lines1);
+        const set2 = new Set(lines2);
+        const only1 = [];
+        const only2 = [];
+        const both = [];
+        for (const line of lines1) {
+            if (set2.has(line)) {
+                both.push(line);
+            }
+            else {
+                only1.push(line);
+            }
+        }
+        for (const line of lines2) {
+            if (!set1.has(line)) {
+                only2.push(line);
+            }
+        }
+        const maxLen = Math.max(only1.length, only2.length, both.length);
+        const results = [];
+        for (let i = 0; i < maxLen; i++) {
+            const col1 = i < only1.length ? only1[i] : "";
+            const col2 = i < only2.length ? only2[i] : "";
+            const col3 = i < both.length ? both[i] : "";
+            results.push(`${col1}\t${col2}\t${col3}`);
+        }
+        return { stdout: results.join("\n") + "\n", exitCode: 0 };
+    },
+};
+/**
+ * Split a file into pieces
+ * @category text
+ * @params ["[-l lines] [-b bytes] <file> [prefix]"]
+ */
+export const splitCommand = {
+    name: "split",
+    description: "Split a file into pieces",
+    category: "text",
+    params: ["[-l lines] [-b bytes] <file> [prefix]"],
+    run: ({ authUser, shell, cwd, args }) => {
+        const { flagsWithValues, positionals } = parseArgs(args, {
+            flagsWithValue: ["-l", "-b"],
+        });
+        const linesPerFile = parseInt(flagsWithValues.get("-l") || "1000", 10);
+        const bytesPerFile = flagsWithValues.has("-b") ? parseInt(flagsWithValues.get("-b"), 10) : undefined;
+        const fileArg = positionals[0];
+        const prefix = positionals[1] || "x";
+        if (!fileArg) {
+            return { stderr: "split: missing file operand\n", exitCode: 1 };
+        }
+        const p = resolvePath(cwd, fileArg);
+        if (!shell.vfs.exists(p)) {
+            return { stderr: `split: ${fileArg}: No such file or directory\n`, exitCode: 1 };
+        }
+        const content = shell.vfs.readFile(p);
+        if (bytesPerFile !== undefined) {
+            let chunkIndex = 0;
+            for (let i = 0; i < content.length; i += bytesPerFile) {
+                const chunk = content.slice(i, i + bytesPerFile);
+                const outPath = resolvePath(cwd, `${prefix}${alphaSuffix(chunkIndex)}`);
+                shell.writeFileAsUser(authUser, outPath, chunk);
+                chunkIndex++;
+            }
+            return { exitCode: 0 };
+        }
+        const allLines = content.split("\n");
+        let chunkIndex = 0;
+        for (let i = 0; i < allLines.length; i += linesPerFile) {
+            const chunk = allLines.slice(i, i + linesPerFile).join("\n");
+            const outPath = resolvePath(cwd, `${prefix}${alphaSuffix(chunkIndex)}`);
+            shell.writeFileAsUser(authUser, outPath, chunk);
+            chunkIndex++;
+        }
+        return { exitCode: 0 };
+    },
+};
+/**
+ * Split a file based on context patterns
+ * @category text
+ * @params ["<file> <pattern>..."]
+ */
+export const csplitCommand = {
+    name: "csplit",
+    description: "Split a file based on context patterns",
+    category: "text",
+    params: ["<file> <pattern>..."],
+    run: () => {
+        return { stderr: "csplit: not implemented\n", exitCode: 1 };
+    },
+};

package/dist/commands/top.d.ts

@@ -0,0 +1,7 @@
+import type { ShellModule } from "../types/commands";
+/**
+ * Display processes
+ * @category system
+ * @params []
+ */
+export declare const topCommand: ShellModule;

package/dist/commands/top.js

@@ -0,0 +1,54 @@
+import * as os from "node:os";
+/**
+ * Display processes
+ * @category system
+ * @params []
+ */
+export const topCommand = {
+    name: "top",
+    description: "Display processes",
+    category: "system",
+    params: [],
+    run: ({ shell }) => {
+        const uptimeSec = Math.floor((Date.now() - shell.startTime) / 1000);
+        const sessions = shell.users.listActiveSessions();
+        const procs = shell.users.listProcesses();
+        const totalMem = os.totalmem();
+        const freeMem = os.freemem();
+        const usedMem = totalMem - freeMem;
+        const loadAverages = os.loadavg();
+        const lines = [];
+        const uptimeStr = `${Math.floor(uptimeSec / 3600)}:${String(Math.floor((uptimeSec % 3600) / 60)).padStart(2, "0")}`;
+        lines.push(`top - ${new Date().toLocaleTimeString()} up ${uptimeStr},  ${sessions.length} user(s), load average: ${loadAverages.map((l) => l.toFixed(2)).join(", ")}`);
+        lines.push(`Tasks: ${sessions.length + procs.length} total,   ${procs.filter((p) => p.status === "running").length || 1} running`);
+        const memTotalMb = (totalMem / 1024 / 1024).toFixed(0);
+        const memUsedMb = (usedMem / 1024 / 1024).toFixed(0);
+        const memFreeMb = (freeMem / 1024 / 1024).toFixed(0);
+        lines.push(`MiB Mem : ${memTotalMb.padStart(8)} total, ${memFreeMb.padStart(8)} free, ${memUsedMb.padStart(8)} used`);
+        const swapTotal = Math.floor(totalMem * 0.5);
+        const swapUsed = Math.floor(swapTotal * 0.05);
+        const swapFree = swapTotal - swapUsed;
+        lines.push(`MiB Swap: ${String(swapTotal).padStart(8)} total, ${String(swapFree).padStart(8)} free, ${String(swapUsed).padStart(8)} used`);
+        lines.push("");
+        lines.push("  PID USER      PR  NI    VIRT    RES    SHR S  %CPU  %MEM     TIME+ COMMAND");
+        sessions.forEach((s, i) => {
+            const pid = 1000 + i;
+            const virt = Math.floor(Math.random() * 200000 + 50000);
+            const res = Math.floor(Math.random() * 10000 + 2000);
+            const shr = Math.floor(res * 0.6);
+            const cpu = (Math.random() * 5).toFixed(1);
+            const mem = ((res / (totalMem / 1024)) * 100).toFixed(1);
+            lines.push(`${String(pid).padStart(5)} ${s.username.padEnd(8).slice(0, 8)}  20   0 ${String(virt).padStart(7)} ${String(res).padStart(6)} ${String(shr).padStart(6)} S  ${cpu.padStart(4)} ${mem.padStart(5)}   0:00.00 bash`);
+        });
+        procs.forEach((p) => {
+            const virt = Math.floor(Math.random() * 50000 + 10000);
+            const res = Math.floor(Math.random() * 5000 + 500);
+            const shr = Math.floor(res * 0.5);
+            const cpu = (Math.random() * 10).toFixed(1);
+            const mem = ((res / (totalMem / 1024)) * 100).toFixed(1);
+            const status = p.status === "running" ? "R" : "S";
+            lines.push(`${String(p.pid).padStart(5)} ${p.username.padEnd(8).slice(0, 8)}  20   0 ${String(virt).padStart(7)} ${String(res).padStart(6)} ${String(shr).padStart(6)} ${status} ${cpu.padStart(4)} ${mem.padStart(5)}   0:00.00 ${p.command}`);
+        });
+        return { stdout: lines.join("\n") + "\n", exitCode: 0 };
+    },
+};

package/dist/commands/touch.js

@@ -1,4 +1,5 @@
-import { assertPathAccess, resolvePath } from "./helpers";
+import * as path from "node:path";
+import { checkFilePermission, resolvePath } from "./helpers";
 /**
  * Create empty files or update file timestamps.
  * @category files
@@ -15,10 +16,13 @@ export const touchCommand = {
         }
         for (const file of args) {
             const target = resolvePath(cwd, file);
-            assertPathAccess(authUser, target, "touch");
             if (!shell.vfs.exists(target)) {
+                checkFilePermission(shell.vfs, shell.users, authUser, path.posix.dirname(target), 2);
                 shell.writeFileAsUser(authUser, target, "");
             }
+            else {
+                checkFilePermission(shell.vfs, shell.users, authUser, target, 2);
+            }
         }
         return { exitCode: 0 };
     },

package/dist/commands/tr.d.ts

@@ -1,2 +1,7 @@
 import type { ShellModule } from "../types/commands";
+/**
+ * Translate or delete characters.
+ * @category text
+ * @params ["[-d] [-s] <set1> [set2]"]
+ */
 export declare const trCommand: ShellModule;

package/dist/commands/tr.js

@@ -27,6 +27,11 @@ function expandTrSet(s) {
     }
     return chars;
 }
+/**
+ * Translate or delete characters.
+ * @category text
+ * @params ["[-d] [-s] <set1> [set2]"]
+ */
 export const trCommand = {
     name: "tr",
     description: "Translate or delete characters",

package/dist/commands/w.js

@@ -27,7 +27,7 @@ export const wCommand = {
                 const log = JSON.parse(shell.vfs.readFile(logPath));
                 loginTime = new Date(log.at).toTimeString().slice(0, 5);
             }
-            catch { }
+            catch { /* login log may be absent */ }
         }
         const header = ` ${timeStr} up ${uptimeStr},  1 user,  load average: 0.${Math.floor(Math.random() * 30).toString().padStart(2, "0")}, 0.${Math.floor(Math.random() * 15).toString().padStart(2, "0")}, 0.${Math.floor(Math.random() * 10).toString().padStart(2, "0")}`;
         const colHeader = "USER     TTY      FROM             LOGIN@   IDLE JCPU   PCPU WHAT";

package/dist/commands/which.d.ts

@@ -1,2 +1,7 @@
 import type { ShellModule } from "../types/commands";
+/**
+ * Locate a command in PATH.
+ * @category shell
+ * @params ["<command...>"]
+ */
 export declare const whichCommand: ShellModule;

package/dist/commands/which.js

@@ -1,3 +1,8 @@
+/**
+ * Locate a command in PATH.
+ * @category shell
+ * @params ["<command...>"]
+ */
 export const whichCommand = {
     name: "which",
     description: "Locate a command in PATH",

package/dist/index.d.ts

@@ -4,17 +4,25 @@ export { SftpMimic as VirtualSftpServer, SshMimic as VirtualSshServer } from "./
 export type { SftpMimicOptions as VirtualSftpServerOptions } from "./SSHMimic/sftp";
 export { default as VirtualFileSystem } from "./VirtualFileSystem/index";
 export { VirtualPackageManager } from "./VirtualPackageManager/index";
+export { VirtualNetworkManager } from "./modules/VirtualNetworkManager";
+export type { VirtualInterface, VirtualRoute, VirtualArpEntry } from "./modules/VirtualNetworkManager";
 export { VirtualShell } from "./VirtualShell/index";
 export { VirtualUserManager } from "./VirtualUserManager/index";
-export type { VirtualActiveSession, VirtualProcess } from "./VirtualUserManager/index";
+export type { VirtualActiveSession, VirtualProcess, VirtualUserRecord, ProcessStatus } from "./VirtualUserManager/index";
 export { IdleManager } from "./VirtualShell/idleManager";
 export type { IdleManagerOptions, IdleState } from "./VirtualShell/idleManager";
 export type { AuditLogEntry, HoneyPotStats } from "./Honeypot/index";
 export type { CommandContext, CommandMode, CommandOutcome, CommandResult, NanoEditorSession, PasswordChallenge, ShellEnv, ShellModule, SudoChallenge } from "./types/commands";
 export type { ExecStream, ShellStream } from "./types/streams";
-export type { RemoveOptions, VfsBaseNode, VfsDirectoryNode, VfsFileNode, VfsNodeStats, VfsNodeType, VfsSnapshot, VfsSnapshotBaseNode, VfsSnapshotDirectoryNode, VfsSnapshotFileNode, VfsSnapshotNode, WriteFileOptions } from "./types/vfs";
+export type { MountOptions, MountPoint, RemoveOptions, VfsBaseNode, VfsDirectoryNode, VfsFileNode, VfsNodeStats, VfsNodeType, VfsSnapshot, VfsSnapshotBaseNode, VfsSnapshotDirectoryNode, VfsSnapshotFileNode, VfsSnapshotNode, WriteFileOptions } from "./types/vfs";
 export type { VfsOptions, VfsPersistenceMode } from "./VirtualFileSystem/index";
 export type { ShellProperties, VirtualShellVfsLike, VirtualShellVfsOptions } from "./VirtualShell/index";
+export type { PipelineCommand, Pipeline, Statement, Script, LogicalOp } from "./types/pipeline";
+export { NanoEditor } from "./modules/nanoEditor";
+export type { NanoEditorOptions, NanoExitReason } from "./modules/nanoEditor";
+export { parseArgs } from "./commands/command-helpers";
+export { createPerfLogger } from "./utils/perfLogger";
+export type { PerfLogger } from "./utils/perfLogger";
 export type { InstalledPackage, PackageDefinition, PackageFile } from "./VirtualPackageManager/index";
 export { assertDiff, diffSnapshots, formatDiff } from "./utils/vfsDiff";
 export type { VfsDiff, VfsDiffEntry, VfsDiffModified } from "./utils/vfsDiff";

package/dist/index.js

@@ -3,8 +3,12 @@ export { SshClient } from "./SSHClient/index";
 export { SftpMimic as VirtualSftpServer, SshMimic as VirtualSshServer } from "./SSHMimic/index";
 export { default as VirtualFileSystem } from "./VirtualFileSystem/index";
 export { VirtualPackageManager } from "./VirtualPackageManager/index";
+export { VirtualNetworkManager } from "./modules/VirtualNetworkManager";
 export { VirtualShell } from "./VirtualShell/index";
 export { VirtualUserManager } from "./VirtualUserManager/index";
 export { IdleManager } from "./VirtualShell/idleManager";
+export { NanoEditor } from "./modules/nanoEditor";
+export { parseArgs } from "./commands/command-helpers";
+export { createPerfLogger } from "./utils/perfLogger";
 export { assertDiff, diffSnapshots, formatDiff } from "./utils/vfsDiff";
 export { getArg, getFlag, ifFlag } from "./commands/command-helpers";