typescript-virtual-container 1.2.9 → 1.3.1

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,
+		};
+	},
+};

package/src/commands/npm.ts

@@ -0,0 +1,132 @@
+/**
+ * npm.ts — Virtual npm command.
+ * Gated behind `apt install npm`. Provides version info and informative
+ * stubs for common subcommands.
+ */
+import type { ShellModule } from "../types/commands";
+import { ifFlag } from "./command-helpers";
+
+const NPM_VERSION = "9.2.0";
+const NODE_VERSION = "18.19.0";
+
+/**
+ * `npm` virtual CLI. Requires `apt install npm` in the virtual package manager.
+ * @category system
+ * @params ["<command> [args]"]
+ */
+export const npmCommand: ShellModule = {
+	name: "npm",
+	description: "Node.js package manager (virtual)",
+	category: "system",
+	params: ["<command> [args]"],
+	run: ({ args, shell }) => {
+		// Require explicit installation
+		if (!shell.packageManager.isInstalled("npm")) {
+			return {
+				stderr:
+					"bash: npm: command not found\nHint: install it with: apt install npm\n",
+				exitCode: 127,
+			};
+		}
+
+		if (ifFlag(args, ["--version", "-v"])) {
+			return { stdout: `${NPM_VERSION}\n`, exitCode: 0 };
+		}
+
+		const sub = args[0]?.toLowerCase();
+
+		switch (sub) {
+			case "version":
+			case "-version":
+				return {
+					stdout: `{ npm: '${NPM_VERSION}', node: '${NODE_VERSION}', v8: '10.2.154.26' }\n`,
+					exitCode: 0,
+				};
+
+			case "install":
+			case "i":
+			case "add":
+				return {
+					stderr:
+						"npm warn: package installation is not available in the virtual runtime.\nnpm warn: This environment simulates npm CLI behaviour only.\n",
+					exitCode: 1,
+				};
+
+			case "run":
+			case "exec":
+			case "x":
+				return {
+					stderr: `npm error: script execution is not available in the virtual runtime.\n`,
+					exitCode: 1,
+				};
+
+			case "init":
+				return {
+					stdout: "Wrote to /home/user/package.json\n",
+					exitCode: 0,
+				};
+
+			case "list":
+			case "ls":
+				return {
+					stdout: `${sub === "ls" || sub === "list" ? "virtual-env@1.0.0" : ""}\n└── (empty)\n`,
+					exitCode: 0,
+				};
+
+			case "help":
+			case undefined:
+				return {
+					stdout: `${[
+						`npm ${NPM_VERSION}`,
+						"",
+						"Usage: npm <command>",
+						"",
+						"Commands:",
+						"  install       (not available in virtual runtime)",
+						"  run           (not available in virtual runtime)",
+						"  exec          (not available in virtual runtime)",
+						"  list          List installed packages",
+						"  version       Print versions",
+						"  --version     Print npm version",
+					].join("\n")}\n`,
+					exitCode: 0,
+				};
+
+			default:
+				return {
+					stderr: `npm error: unknown command: ${sub}\n`,
+					exitCode: 1,
+				};
+		}
+	},
+};
+
+/**
+ * `npx` virtual runner. Requires `apt install npm` in the virtual package manager.
+ * @category system
+ * @params ["<package> [args]"]
+ */
+export const npxCommand: ShellModule = {
+	name: "npx",
+	description: "Node.js package runner (virtual)",
+	category: "system",
+	params: ["<package> [args]"],
+	run: ({ args, shell }) => {
+		if (!shell.packageManager.isInstalled("npm")) {
+			return {
+				stderr:
+					"bash: npx: command not found\nHint: install it with: apt install npm\n",
+				exitCode: 127,
+			};
+		}
+
+		if (ifFlag(args, ["--version"])) {
+			return { stdout: `${NPM_VERSION}\n`, exitCode: 0 };
+		}
+
+		return {
+			stderr: `npx: package execution is not available in the virtual runtime.\n`,
+			exitCode: 1,
+		};
+	},
+};

package/src/commands/ping.ts

@@ -7,7 +7,9 @@ export const pingCommand: ShellModule = {
 	category: "network",
 	params: ["[-c <count>] <host>"],
 	run: ({ args }) => {
-		const { flagsWithValues, positionals } = parseArgs(args, { flagsWithValue: ["-c", "-i", "-W"] });
+		const { flagsWithValues, positionals } = parseArgs(args, {
+			flagsWithValue: ["-c", "-i", "-W"],
+		});
 		const host = positionals[0] ?? "localhost";
 		const countArg = flagsWithValues.get("-c");
 		const count = countArg ? Math.max(1, parseInt(countArg, 10) || 4) : 4;
@@ -17,7 +19,9 @@ export const pingCommand: ShellModule = {
 			lines.push(`64 bytes from ${host}: icmp_seq=${i} ttl=64 time=${ms} ms`);
 		}
 		lines.push(`--- ${host} ping statistics ---`);
-		lines.push(`${count} packets transmitted, ${count} received, 0% packet loss`);
+		lines.push(
+			`${count} packets transmitted, ${count} received, 0% packet loss`,
+		);
 		return { stdout: lines.join("\n"), exitCode: 0 };
 	},
 };

package/src/commands/printf.ts

@@ -0,0 +1,112 @@
+import type { ShellModule } from "../types/commands";
+
+/**
+ * Render a printf format string with given arguments.
+ * Supports: %s %d %i %f %o %x %X %% \n \t \r \\
+ */
+function renderPrintf(fmt: string, args: string[]): string {
+	let argIdx = 0;
+	let out = "";
+	let i = 0;
+	while (i < fmt.length) {
+		if (fmt[i] === "\\" && i + 1 < fmt.length) {
+			switch (fmt[i + 1]) {
+				case "n":
+					out += "\n";
+					i += 2;
+					continue;
+				case "t":
+					out += "\t";
+					i += 2;
+					continue;
+				case "r":
+					out += "\r";
+					i += 2;
+					continue;
+				case "\\":
+					out += "\\";
+					i += 2;
+					continue;
+				case "a":
+					out += "\x07";
+					i += 2;
+					continue;
+				case "b":
+					out += "\x08";
+					i += 2;
+					continue;
+				case "f":
+					out += "\x0C";
+					i += 2;
+					continue;
+				case "v":
+					out += "\x0B";
+					i += 2;
+					continue;
+				default:
+					out += fmt[i]!;
+					i++;
+					continue;
+			}
+		}
+		if (fmt[i] === "%" && i + 1 < fmt.length) {
+			// Optional width/precision: %[-][width][.prec]spec
+			let j = i + 1;
+			if (fmt[j] === "-") j++;
+			while (j < fmt.length && /\d/.test(fmt[j]!)) j++;
+			if (fmt[j] === ".") {
+				j++;
+				while (j < fmt.length && /\d/.test(fmt[j]!)) j++;
+			}
+			const spec = fmt[j];
+			const arg = args[argIdx++] ?? "";
+			switch (spec) {
+				case "s":
+					out += arg;
+					break;
+				case "d":
+				case "i":
+					out += String(parseInt(arg, 10) || 0);
+					break;
+				case "f":
+					out += String(parseFloat(arg) || 0);
+					break;
+				case "o":
+					out += (parseInt(arg, 10) || 0).toString(8);
+					break;
+				case "x":
+					out += (parseInt(arg, 10) || 0).toString(16);
+					break;
+				case "X":
+					out += (parseInt(arg, 10) || 0).toString(16).toUpperCase();
+					break;
+				case "%":
+					out += "%";
+					argIdx--;
+					break;
+				default:
+					out += fmt[i]!;
+					i++;
+					continue;
+			}
+			i = j + 1;
+			continue;
+		}
+		out += fmt[i]!;
+		i++;
+	}
+	return out;
+}
+
+export const printfCommand: ShellModule = {
+	name: "printf",
+	description: "Format and print data",
+	category: "shell",
+	params: ["<format> [args...]"],
+	run: ({ args }) => {
+		const fmt = args[0];
+		if (!fmt) return { stderr: "printf: missing format string", exitCode: 1 };
+		const output = renderPrintf(fmt, args.slice(1));
+		return { stdout: output, exitCode: 0 };
+	},
+};

package/src/commands/ps.ts

@@ -8,22 +8,32 @@ export const psCommand: ShellModule = {
 	params: ["[-a] [-u] [-x] [aux]"],
 	run: ({ authUser, shell, args }) => {
 		const sessions = shell.users.listActiveSessions();
-		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");
+		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");
 
 		if (showUser) {
-			const header = "USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND";
+			const header =
+				"USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND";
 			const rows: string[] = [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`);
+				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(`root       ${String(pid).padStart(6)}  0.0   0.0      0      0 ?        S    00:00   0:00 ps`);
+			rows.push(
+				`root       ${String(pid).padStart(6)}  0.0   0.0      0      0 ?        S    00:00   0:00 ps`,
+			);
 			return { stdout: rows.join("\n"), exitCode: 0 };
 		}
 
@@ -32,7 +42,9 @@ export const psCommand: ShellModule = {
 		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})`}`);
+			rows.push(
+				`${String(pid).padStart(5)} ${s.tty.padEnd(12)} 00:00:00 ${s.username === authUser ? "bash" : `bash (${s.username})`}`,
+			);
 			pid++;
 		}
 		rows.push(`${String(pid).padStart(5)} pts/0        00:00:00 ps`);