typescript-virtual-container 1.2.8 → 1.3.0

package/src/commands/ls.ts

@@ -30,15 +30,18 @@ export const lsCommand: ShellModule = {
 	name: "ls",
 	description: "List directory contents",
 	category: "navigation",
-	params: ["[path]"],
+	params: ["[-la] [path]"],
 	run: ({ authUser, shell, cwd, args }) => {
 		const longFormat = ifFlag(args, ["-l", "--long"]);
-		const targetArg = getArg(args, 0, { flags: ["-l", "--long"] });
+		const showHidden = ifFlag(args, ["-a", "--all"]);
+		const targetArg = getArg(args, 0, {
+			flags: ["-l", "--long", "-a", "--all", "-la", "-al"],
+		});
 		const target = resolvePath(cwd, targetArg ?? cwd);
 		assertPathAccess(authUser, target, "ls");
 		const items = shell.vfs
 			.list(target)
-			.filter((name) => !name.startsWith("."));
+			.filter((name) => showHidden || !name.startsWith("."));
 		const rendered = longFormat
 			? items
 					.map((name) => {

package/src/commands/lsb-release.ts

@@ -0,0 +1,58 @@
+import type { ShellModule } from "../types/commands";
+import { ifFlag } from "./command-helpers";
+
+export const lsbReleaseCommand: ShellModule = {
+	name: "lsb_release",
+	description: "Print distribution-specific information",
+	category: "system",
+	params: ["[-a] [-i] [-d] [-r] [-c]"],
+	run: ({ args, shell }) => {
+		let osName = shell.properties?.os ?? "Fortune GNU/Linux x64";
+		let codename = "aurora";
+		let version = "1.0";
+
+		try {
+			const content = shell.vfs.readFile("/etc/os-release");
+			for (const line of content.split("\n")) {
+				if (line.startsWith("PRETTY_NAME="))
+					osName = line
+						.slice("PRETTY_NAME=".length)
+						.replace(/^"|"$/g, "")
+						.trim();
+				if (line.startsWith("VERSION_CODENAME="))
+					codename = line.slice("VERSION_CODENAME=".length).trim();
+				if (line.startsWith("VERSION_ID="))
+					version = line
+						.slice("VERSION_ID=".length)
+						.replace(/^"|"$/g, "")
+						.trim();
+			}
+		} catch {}
+
+		const all = ifFlag(args, ["-a", "--all"]);
+		const showId = ifFlag(args, ["-i", "--id"]);
+		const showDesc = ifFlag(args, ["-d", "--description"]);
+		const showRelease = ifFlag(args, ["-r", "--release"]);
+		const showCodename = ifFlag(args, ["-c", "--codename"]);
+
+		if (all || args.length === 0) {
+			return {
+				stdout: [
+					`Distributor ID:\tFortune`,
+					`Description:\t${osName}`,
+					`Release:\t${version}`,
+					`Codename:\t${codename}`,
+				].join("\n"),
+				exitCode: 0,
+			};
+		}
+
+		const lines: string[] = [];
+		if (showId) lines.push(`Distributor ID:\tFortune`);
+		if (showDesc) lines.push(`Description:\t${osName}`);
+		if (showRelease) lines.push(`Release:\t${version}`);
+		if (showCodename) lines.push(`Codename:\t${codename}`);
+
+		return { stdout: lines.join("\n"), exitCode: 0 };
+	},
+};

package/src/commands/man.ts

@@ -0,0 +1,166 @@
+import type { ShellModule } from "../types/commands";
+
+const MAN_PAGES: Record<string, string> = {
+	ls: `LS(1)                    User Commands                    LS(1)
+
+NAME
+       ls - list directory contents
+
+SYNOPSIS
+       ls [OPTION]... [FILE]...
+
+DESCRIPTION
+       List information about the FILEs (the current directory by default).
+
+OPTIONS
+       -l     use a long listing format
+       -a     do not ignore entries starting with .
+       -h     with -l, print human readable sizes
+       -r     reverse order while sorting
+       -t     sort by modification time
+
+AUTHOR
+       Written by Richard M. Stallman and David MacKenzie.`,
+
+	cat: `CAT(1)                   User Commands                    CAT(1)
+
+NAME
+       cat - concatenate files and print on the standard output
+
+SYNOPSIS
+       cat [OPTION]... [FILE]...
+
+DESCRIPTION
+       Concatenate FILE(s) to standard output.
+
+OPTIONS
+       -n, --number          number all output lines
+       -b, --number-nonblank number nonempty output lines`,
+
+	grep: `GREP(1)                  User Commands                    GREP(1)
+
+NAME
+       grep, egrep, fgrep - print lines that match patterns
+
+SYNOPSIS
+       grep [OPTION]... PATTERNS [FILE]...
+
+OPTIONS
+       -i, --ignore-case     ignore case distinctions in patterns and data
+       -v, --invert-match    select non-matching lines
+       -n, --line-number     print line number with output lines
+       -r, --recursive       read all files under each directory, recursively`,
+
+	apt: `APT(8)                   APT                             APT(8)
+
+NAME
+       apt - command-line interface
+
+SYNOPSIS
+       apt [options] command
+
+DESCRIPTION
+       apt provides a high-level commandline interface for the package
+       management system.
+
+COMMANDS
+       install pkg...   Install packages
+       remove pkg...    Remove packages
+       update           Download package information
+       upgrade          Upgrade installed packages
+       search term      Search in package descriptions
+       show pkg         Show package information
+       list             List packages`,
+
+	ssh: `SSH(1)                   OpenSSH                          SSH(1)
+
+NAME
+       ssh - OpenSSH remote login client
+
+SYNOPSIS
+       ssh [-p port] [user@]hostname [command]
+
+DESCRIPTION
+       ssh (SSH client) is a program for logging into a remote machine and
+       for executing commands on a remote machine.`,
+
+	curl: `CURL(1)                  User Commands                    CURL(1)
+
+NAME
+       curl - transfer a URL
+
+SYNOPSIS
+       curl [options / URLs]
+
+DESCRIPTION
+       curl is a tool for transferring data with URL syntax.
+
+OPTIONS
+       -o, --output <file>     Write output to <file>
+       -X, --request <method>  Specify request method
+       -d, --data <data>       HTTP POST data
+       -H, --header <header>   Pass custom header
+       -s, --silent            Silent mode
+       -I, --head              Show document info only
+       -L, --location          Follow redirects
+       -v, --verbose           Make the operation more talkative`,
+
+	chmod: `CHMOD(1)                 User Commands                    CHMOD(1)
+
+NAME
+       chmod - change file mode bits
+
+SYNOPSIS
+       chmod [OPTION]... MODE[,MODE]... FILE...
+       chmod [OPTION]... OCTAL-MODE FILE...
+
+DESCRIPTION
+       Change the file mode bits of each given file according to MODE.
+
+EXAMPLES
+       chmod 755 script.sh      rwxr-xr-x
+       chmod 644 file.txt       rw-r--r--
+       chmod +x script.sh       add execute permission`,
+
+	tar: `TAR(1)                   GNU tar Manual                   TAR(1)
+
+NAME
+       tar - an archiving utility
+
+SYNOPSIS
+       tar [OPTION...] [FILE]...
+
+DESCRIPTION
+       tar saves many files together into a single tape or disk archive,
+       and can restore individual files from the archive.
+
+OPTIONS
+       -c, --create           create a new archive
+       -x, --extract          extract files from an archive
+       -z, --gzip             filter the archive through gzip
+       -f, --file=ARCHIVE     use archive file or device ARCHIVE
+       -v, --verbose          verbosely list files processed
+       -t, --list             list the contents of an archive`,
+};
+
+export const manCommand: ShellModule = {
+	name: "man",
+	description: "Interface to the system reference manuals",
+	category: "shell",
+	params: ["<command>"],
+	run: ({ args, shell }) => {
+		const name = args[0];
+		if (!name) return { stderr: "What manual page do you want?", exitCode: 1 };
+
+		// VFS-installed man pages take priority
+		const manPath = `/usr/share/man/man1/${name}.1`;
+		if (shell.vfs.exists(manPath)) {
+			return { stdout: shell.vfs.readFile(manPath), exitCode: 0 };
+		}
+
+		const page = MAN_PAGES[name.toLowerCase()];
+		if (page) return { stdout: page, exitCode: 0 };
+
+		return { stderr: `No manual entry for ${name}`, exitCode: 16 };
+	},
+};

package/src/commands/nano.ts

@@ -5,7 +5,7 @@ import { assertPathAccess, resolvePath } from "./helpers";
 export const nanoCommand: ShellModule = {
 	name: "nano",
 	description: "Text editor",
-	category: "shell",
+	category: "files",
 	params: ["<file>"],
 	run: ({ authUser, shell, cwd, args }) => {
 		const fileArg = args[0];

package/src/commands/neofetch.ts

@@ -6,7 +6,7 @@ import { getAllEnvVars } from "./set";
 export const neofetchCommand: ShellModule = {
 	name: "neofetch",
 	description: "System info display",
-	category: "misc",
+	category: "system",
 	params: ["[--off]"],
 	run: ({ args, authUser, hostname, shell }) => {
 		const env = getAllEnvVars(authUser);
@@ -32,6 +32,11 @@ export const neofetchCommand: ShellModule = {
 				shell: env.SHELL,
 				shellProps: shell.properties,
 				terminal: env.TERM,
+				uptimeSeconds: Math.floor((Date.now() - shell.startTime) / 1000),
+				packages: (() => {
+					const count = shell.packageManager?.installedCount() ?? 0;
+					return `${count} (dpkg)`;
+				})(),
 			}),
 			exitCode: 0,
 		};

package/src/commands/node.ts

@@ -0,0 +1,341 @@
+/** biome-ignore-all lint/style/useNamingConvention: node globals and ENV VAR KEYS */
+/**
+ * node.ts — Virtual Node.js runtime.
+ *
+ * Uses `node:vm` for sandboxed evaluation with a controlled context that
+ * intercepts `process`, `require`, `console`, and all standard globals.
+ * No host filesystem access, no network, no child processes.
+ */
+import vm from "node:vm";
+import type { ShellModule } from "../types/commands";
+import { ifFlag } from "./command-helpers";
+import { resolvePath } from "./helpers";
+
+const VIRTUAL_VERSION = "v18.19.0";
+const VIRTUAL_VERSIONS = {
+	node: VIRTUAL_VERSION,
+	npm: "9.2.0",
+	v8: "10.2.154.26-node.22",
+};
+
+// ─── sandbox context ──────────────────────────────────────────────────────────
+
+function makeContext(outputLines: string[], stderrLines: string[]) {
+	const fakeProcess = {
+		version: VIRTUAL_VERSION,
+		versions: VIRTUAL_VERSIONS,
+		platform: "linux",
+		arch: "x64",
+		env: {
+			NODE_ENV: "production",
+			HOME: "/root",
+			PATH: "/usr/local/bin:/usr/bin:/bin",
+		},
+		argv: ["node"],
+		stdout: {
+			write: (s: string) => {
+				outputLines.push(s);
+				return true;
+			},
+		},
+		stderr: {
+			write: (s: string) => {
+				stderrLines.push(s);
+				return true;
+			},
+		},
+		exit: (code = 0) => {
+			throw new ExitSignal(code);
+		},
+		cwd: () => "/root",
+		hrtime: () => [0, 0],
+	};
+
+	const fakeConsole = {
+		log: (...a: unknown[]) => outputLines.push(a.map(formatValue).join(" ")),
+		error: (...a: unknown[]) => stderrLines.push(a.map(formatValue).join(" ")),
+		warn: (...a: unknown[]) => stderrLines.push(a.map(formatValue).join(" ")),
+		info: (...a: unknown[]) => outputLines.push(a.map(formatValue).join(" ")),
+		dir: (v: unknown) => outputLines.push(formatValue(v)),
+	};
+
+	const fakeRequire = (mod: string): unknown => {
+		// Provide stubs for common modules
+		switch (mod) {
+			case "path":
+				return {
+					join: (...parts: string[]) => parts.join("/").replace(/\/+/g, "/"),
+					resolve: (...parts: string[]) =>
+						`/${parts.join("/").replace(/^\/+/, "")}`,
+					dirname: (p: string) => p.split("/").slice(0, -1).join("/") || "/",
+					basename: (p: string) => p.split("/").pop() ?? "",
+					extname: (p: string) => {
+						const b = p.split("/").pop() ?? "";
+						const d = b.lastIndexOf(".");
+						return d > 0 ? b.slice(d) : "";
+					},
+					sep: "/",
+					delimiter: ":",
+				};
+			case "os":
+				return {
+					platform: () => "linux",
+					arch: () => "x64",
+					type: () => "Linux",
+					hostname: () => "fortune-vm",
+					homedir: () => "/root",
+					tmpdir: () => "/tmp",
+					EOL: "\n",
+				};
+			case "util":
+				return {
+					format: (...a: unknown[]) => a.map(formatValue).join(" "),
+					inspect: (v: unknown) => formatValue(v),
+				};
+			case "fs":
+			case "fs/promises":
+				throw new Error(
+					`Cannot require '${mod}': filesystem access not available in virtual runtime`,
+				);
+			case "child_process":
+			case "net":
+			case "http":
+			case "https":
+				throw new Error(
+					`Cannot require '${mod}': not available in virtual runtime`,
+				);
+			default:
+				throw new Error(`Cannot find module '${mod}'`);
+		}
+	};
+	fakeRequire.resolve = (id: string) => {
+		throw new Error(`Cannot resolve '${id}'`);
+	};
+	fakeRequire.cache = {};
+	fakeRequire.extensions = {};
+
+	return vm.createContext({
+		// Core globals
+		console: fakeConsole,
+		process: fakeProcess,
+		require: fakeRequire,
+
+		// JS built-ins
+		Math,
+		JSON,
+		Object,
+		Array,
+		String,
+		Number,
+		Boolean,
+		Symbol,
+		Date,
+		RegExp,
+		Error,
+		TypeError,
+		RangeError,
+		SyntaxError,
+		Promise,
+		Map,
+		Set,
+		WeakMap,
+		WeakSet,
+		parseInt,
+		parseFloat,
+		isNaN,
+		isFinite,
+		encodeURIComponent,
+		decodeURIComponent,
+		encodeURI,
+		decodeURI,
+		setTimeout: () => {},
+		clearTimeout: () => {},
+		setInterval: () => {},
+		clearInterval: () => {},
+		queueMicrotask: () => {},
+		globalThis: undefined as unknown, // set below
+		undefined,
+		Infinity,
+		NaN,
+	});
+}
+
+class ExitSignal {
+	constructor(public readonly code: number) {}
+}
+
+function formatValue(v: unknown): string {
+	if (v === null) return "null";
+	if (v === undefined) return "undefined";
+	if (typeof v === "string") return v;
+	if (typeof v === "function") return `[Function: ${v.name || "(anonymous)"}]`;
+	if (Array.isArray(v)) return `[ ${v.map(formatValue).join(", ")} ]`;
+	if (v instanceof Error) return `${v.name}: ${v.message}`;
+	if (typeof v === "object") {
+		try {
+			const entries = Object.entries(v as Record<string, unknown>)
+				.map(([k, val]) => `${k}: ${formatValue(val)}`)
+				.join(", ");
+			return `{ ${entries} }`;
+		} catch {
+			return "[Object]";
+		}
+	}
+	return String(v);
+}
+
+// ─── execution ────────────────────────────────────────────────────────────────
+
+function runJs(code: string): {
+	stdout: string;
+	stderr: string;
+	exitCode: number;
+} {
+	const outputLines: string[] = [];
+	const stderrLines: string[] = [];
+	const ctx = makeContext(outputLines, stderrLines);
+
+	let exitCode = 0;
+
+	try {
+		const result = vm.runInContext(code, ctx, { timeout: 5000 });
+		// If the expression returned a value and nothing was console.log'd, print it
+		if (result !== undefined && outputLines.length === 0) {
+			outputLines.push(formatValue(result));
+		}
+	} catch (err) {
+		if (err instanceof ExitSignal) {
+			exitCode = err.code;
+		} else if (err instanceof Error) {
+			stderrLines.push(`${err.name}: ${err.message}`);
+			exitCode = 1;
+		} else {
+			stderrLines.push(String(err));
+			exitCode = 1;
+		}
+	}
+
+	return {
+		stdout: outputLines.length ? `${outputLines.join("\n")}\n` : "",
+		stderr: stderrLines.length ? `${stderrLines.join("\n")}\n` : "",
+		exitCode,
+	};
+}
+
+function runJsFile(code: string): {
+	stdout: string;
+	stderr: string;
+	exitCode: number;
+} {
+	// If the code is a single expression (no semicolons, no newlines, no statements),
+	// wrap it to capture the return value like a REPL would
+	const trimmed = code.trim();
+	const isExpression =
+		!trimmed.includes("\n") &&
+		!trimmed.startsWith("const ") &&
+		!trimmed.startsWith("let ") &&
+		!trimmed.startsWith("var ") &&
+		!trimmed.startsWith("function ") &&
+		!trimmed.startsWith("class ") &&
+		!trimmed.startsWith("if ") &&
+		!trimmed.startsWith("for ") &&
+		!trimmed.startsWith("while ") &&
+		!trimmed.startsWith("import ") &&
+		!trimmed.startsWith("//");
+
+	if (isExpression) return runJs(trimmed);
+
+	// Multi-line: wrap in IIFE
+	return runJs(`(async () => { ${code} })()`);
+}
+
+// ─── command ──────────────────────────────────────────────────────────────────
+/**
+ * `node` virtual runtime command. Executes JS in a safe sandbox with
+ * limited globals and no host FS/child process access.
+ * @category system
+ * @params []
+ */
+export const nodeCommand: ShellModule = {
+	name: "node",
+	description: "JavaScript runtime (virtual)",
+	category: "system",
+	params: ["[--version] [-e <expr>] [-p <expr>] [file]"],
+	run: ({ args, shell, cwd }) => {
+		// Require explicit installation via `apt install nodejs`
+		if (!shell.packageManager.isInstalled("nodejs")) {
+			return {
+				stderr:
+					"bash: node: command not found\nHint: install it with: apt install nodejs\n",
+				exitCode: 127,
+			};
+		}
+		if (ifFlag(args, ["--version", "-v"])) {
+			return { stdout: `${VIRTUAL_VERSION}\n`, exitCode: 0 };
+		}
+
+		if (ifFlag(args, ["--versions"])) {
+			return {
+				stdout: `${JSON.stringify(VIRTUAL_VERSIONS, null, 2)}\n`,
+				exitCode: 0,
+			};
+		}
+
+		// -e 'expr'
+		const eIdx = args.findIndex((a) => a === "-e" || a === "--eval");
+		if (eIdx !== -1) {
+			const expr = args[eIdx + 1];
+			if (!expr)
+				return { stderr: "node: -e requires an argument\n", exitCode: 1 };
+			const { stdout, stderr, exitCode } = runJs(expr);
+			return {
+				stdout: stdout || undefined,
+				stderr: stderr || undefined,
+				exitCode,
+			};
+		}
+
+		// -p 'expr' — print mode
+		const pIdx = args.findIndex((a) => a === "-p" || a === "--print");
+		if (pIdx !== -1) {
+			const expr = args[pIdx + 1];
+			if (!expr)
+				return { stderr: "node: -p requires an argument\n", exitCode: 1 };
+			const { stdout, stderr, exitCode } = runJs(expr);
+			return {
+				stdout: stdout || (exitCode === 0 ? "\n" : undefined),
+				stderr: stderr || undefined,
+				exitCode,
+			};
+		}
+
+		// node <file>
+		const file = args.find((a) => !a.startsWith("-"));
+		if (file) {
+			const filePath = resolvePath(cwd, file);
+			if (!shell.vfs.exists(filePath)) {
+				return {
+					stderr: `node: cannot open file '${file}': No such file or directory\n`,
+					exitCode: 1,
+				};
+			}
+			const code = shell.vfs.readFile(filePath);
+			const { stdout, stderr, exitCode } = runJsFile(code);
+			return {
+				stdout: stdout || undefined,
+				stderr: stderr || undefined,
+				exitCode,
+			};
+		}
+
+		// No args — REPL hint
+		return {
+			stdout: [
+				`Welcome to Node.js ${VIRTUAL_VERSION}.`,
+				`Type ".exit" to exit the REPL.`,
+				`> `,
+			].join("\n"),
+			exitCode: 0,
+		};
+	},
+};