typescript-virtual-container 1.2.9 → 1.3.1

package/src/modules/linuxRootfs.ts

@@ -1,3 +1,4 @@
+/** biome-ignore-all lint/style/useNamingConvention: ENV VAR KEYS */
 /**
  * linuxRootfs.ts
  *
@@ -62,21 +63,12 @@ function bootstrapEtc(
 		].join("\n")}\n`,
 	);
 
-	ensureFile(
-		vfs,
-		"/etc/issue",
-		`Fortune GNU/Linux 1.0 \\n \\l\n`,
-	);
+	ensureFile(vfs, "/etc/issue", `Fortune GNU/Linux 1.0 \\n \\l\n`);
 
 	ensureFile(
 		vfs,
 		"/etc/motd",
-		[
-			"",
-			`Welcome to ${props.os}`,
-			`Kernel: ${props.kernel}`,
-			"",
-		].join("\n"),
+		["", `Welcome to ${props.os}`, `Kernel: ${props.kernel}`, ""].join("\n"),
 	);
 
 	// APT sources
@@ -130,6 +122,12 @@ function bootstrapEtc(
 
 // ─── /etc/passwd + /etc/group + /etc/shadow ─────────────────────────────────
 
+/**
+ * Sync `/etc/passwd`, `/etc/group`, and `/etc/shadow` from the
+ * VirtualUserManager's current user list into the VFS.
+ * @param vfs VirtualFileSystem instance to write files into
+ * @param users VirtualUserManager to source users from
+ */
 export function syncEtcPasswd(
 	vfs: VirtualFileSystem,
 	users: VirtualUserManager,
@@ -175,16 +173,90 @@ export function syncEtcPasswd(
 
 // ─── /proc ───────────────────────────────────────────────────────────────────
 
+/** Derive a stable virtual PID from a tty string like "pts/0" → 1000, "pts/1" → 1001 */
+function ttyToPid(tty: string): number {
+	const match = tty.match(/(\d+)$/);
+	return 1000 + (match?.[1] ? parseInt(match[1], 10) : 0);
+}
+
+/** Write /proc/<pid>/ subtree for a single virtual process */
+function writeProcPid(
+	vfs: VirtualFileSystem,
+	pid: number,
+	username: string,
+	_tty: string,
+	cmdline: string,
+	startedAt: string,
+	env: Record<string, string>,
+): void {
+	const dir = `/proc/${pid}`;
+	ensureDir(vfs, dir);
+	ensureDir(vfs, `${dir}/fd`);
+	ensureDir(vfs, `${dir}/fdinfo`);
+
+	const uptimeSec = Math.floor(
+		(Date.now() - new Date(startedAt).getTime()) / 1000,
+	);
+
+	vfs.writeFile(`${dir}/cmdline`, `${cmdline.replace(/\s+/g, "\0")}\0`);
+	vfs.writeFile(`${dir}/comm`, cmdline.split(/\s+/)[0] ?? "bash");
+	vfs.writeFile(
+		`${dir}/status`,
+		`${[
+			`Name:   ${cmdline.split(/\s+/)[0] ?? "bash"}`,
+			`State:  S (sleeping)`,
+			`Pid:    ${pid}`,
+			`PPid:   1`,
+			`Uid:    0\t0\t0\t0`,
+			`Gid:    0\t0\t0\t0`,
+			`VmRSS:  4096 kB`,
+			`VmSize: 16384 kB`,
+			`Threads: 1`,
+		].join("\n")}\n`,
+	);
+	vfs.writeFile(
+		`${dir}/stat`,
+		`${pid} (${cmdline.split(/\s+/)[0] ?? "bash"}) S 1 ${pid} ${pid} 0 -1 4194304 0 0 0 0 ${uptimeSec} 0 0 0 20 0 1 0 0 16384 4096 0\n`,
+	);
+	vfs.writeFile(
+		`${dir}/environ`,
+		`${Object.entries(env)
+			.map(([k, v]) => `${k}=${v}`)
+			.join("\0")}\0`,
+	);
+	vfs.writeFile(`${dir}/cwd`, `/home/${username}\0`);
+	vfs.writeFile(`${dir}/exe`, "/bin/bash\0");
+
+	// Standard fd entries
+	vfs.writeFile(`${dir}/fd/0`, "");
+	vfs.writeFile(`${dir}/fd/1`, "");
+	vfs.writeFile(`${dir}/fd/2`, "");
+}
+
+/**
+ * Populate and refresh `/proc` virtual entries based on host stats and
+ * provided active sessions. Rewrites `/proc/uptime`, `/proc/meminfo`,
+ * `/proc/cpuinfo`, `/proc/<pid>` entries and `/proc/self` content.
+ * @param vfs VirtualFileSystem instance
+ * @param props ShellProperties used for version strings
+ * @param hostname Hostname to write into /proc/hostname
+ * @param shellStartTime Start time used to compute uptime
+ * @param sessions Optional active sessions list to populate per-pid entries
+ */
 export function refreshProc(
 	vfs: VirtualFileSystem,
 	props: ShellProperties,
 	hostname: string,
 	shellStartTime: number,
+	sessions?: import("../VirtualUserManager").VirtualActiveSession[],
 ): void {
 	ensureDir(vfs, "/proc");
 
 	const uptimeSec = Math.floor((Date.now() - shellStartTime) / 1000);
-	vfs.writeFile("/proc/uptime", `${uptimeSec}.00 ${Math.floor(uptimeSec * 0.9)}.00\n`);
+	vfs.writeFile(
+		"/proc/uptime",
+		`${uptimeSec}.00 ${Math.floor(uptimeSec * 0.9)}.00\n`,
+	);
 
 	const totalMemKb = Math.floor(os.totalmem() / 1024);
 	const freeMemKb = Math.floor(os.freemem() / 1024);
@@ -207,7 +279,7 @@ export function refreshProc(
 	for (let i = 0; i < cpus.length; i++) {
 		const c = cpus[i];
 		if (!c) continue;
-		const mhz = (c.speed).toFixed(3);
+		const mhz = c.speed.toFixed(3);
 		cpuLines.push(
 			`processor\t: ${i}`,
 			`model name\t: ${c.model}`,
@@ -227,7 +299,11 @@ export function refreshProc(
 
 	// /proc/loadavg
 	const load = (Math.random() * 0.5).toFixed(2);
-	vfs.writeFile("/proc/loadavg", `${load} ${load} ${load} 1/1 1\n`);
+	const numProcs = 1 + (sessions?.length ?? 0);
+	vfs.writeFile(
+		"/proc/loadavg",
+		`${load} ${load} ${load} ${numProcs}/${numProcs} 1\n`,
+	);
 
 	// /proc/net stubs
 	ensureDir(vfs, "/proc/net");
@@ -241,6 +317,85 @@ export function refreshProc(
 			"  eth0:  131072    1024    0    0    0     0          0         0    65536     512    0    0    0     0       0          0",
 		].join("\n")}\n`,
 	);
+
+	// ── /proc/1 — init process ────────────────────────────────────────────────
+	writeProcPid(
+		vfs,
+		1,
+		"root",
+		"pts/0",
+		"/sbin/init",
+		new Date(shellStartTime).toISOString(),
+		{},
+	);
+
+	// ── /proc/<pid> per session ───────────────────────────────────────────────
+	const activeSessions = sessions ?? [];
+	for (const session of activeSessions) {
+		const pid = ttyToPid(session.tty);
+		writeProcPid(
+			vfs,
+			pid,
+			session.username,
+			session.tty,
+			"bash",
+			session.startedAt,
+			{
+				USER: session.username,
+				HOME: `/home/${session.username}`,
+				TERM: "xterm-256color",
+				SHELL: "/bin/bash",
+			},
+		);
+	}
+
+	// ── /proc/self — symlink to current session PID or 1 ────────────────────
+	// We can't know which session is "current" at populate time,
+	// so /proc/self is a directory that mirrors the most recent session,
+	// or init if no sessions. Commands that read /proc/self get consistent data.
+	const selfPid =
+		activeSessions.length > 0
+			? ttyToPid(activeSessions[activeSessions.length - 1]!.tty)
+			: 1;
+
+	// Remove existing /proc/self and recreate as content copy
+	if (vfs.exists("/proc/self")) {
+		try {
+			vfs.remove("/proc/self");
+		} catch {}
+	}
+	// /proc/self is a real directory (not a symlink, which VFS may not support for dirs)
+	const selfSrc = `/proc/${selfPid}`;
+	if (vfs.exists(selfSrc)) {
+		ensureDir(vfs, "/proc/self");
+		ensureDir(vfs, "/proc/self/fd");
+		for (const entry of vfs.list(selfSrc)) {
+			const srcPath = `${selfSrc}/${entry}`;
+			const dstPath = `/proc/self/${entry}`;
+			try {
+				const st = vfs.stat(srcPath);
+				if (st.type === "file") {
+					vfs.writeFile(dstPath, vfs.readFile(srcPath));
+				}
+			} catch {}
+		}
+		vfs.writeFile(
+			"/proc/self/status",
+			vfs.exists(`${selfSrc}/status`) ? vfs.readFile(`${selfSrc}/status`) : "",
+		);
+	} else {
+		// Fallback minimal /proc/self
+		ensureDir(vfs, "/proc/self");
+		vfs.writeFile("/proc/self/cmdline", "bash\0");
+		vfs.writeFile("/proc/self/comm", "bash");
+		vfs.writeFile(
+			"/proc/self/status",
+			"Name:\tbash\nState:\tS (sleeping)\nPid:\t1\nPPid:\t0\n",
+		);
+		vfs.writeFile("/proc/self/environ", "");
+		vfs.writeFile("/proc/self/cwd", "/root\0");
+		vfs.writeFile("/proc/self/exe", "/bin/bash\0");
+	}
 }
 
 // ─── /sys ─────────────────────────────────────────────────────────────────────
@@ -252,8 +407,16 @@ function bootstrapSys(vfs: VirtualFileSystem, props: ShellProperties): void {
 	ensureDir(vfs, "/sys/devices/virtual/dmi");
 	ensureDir(vfs, "/sys/devices/virtual/dmi/id");
 
-	ensureFile(vfs, "/sys/devices/virtual/dmi/id/sys_vendor", "Fortune Systems\n");
-	ensureFile(vfs, "/sys/devices/virtual/dmi/id/product_name", "VirtualContainer v1\n");
+	ensureFile(
+		vfs,
+		"/sys/devices/virtual/dmi/id/sys_vendor",
+		"Fortune Systems\n",
+	);
+	ensureFile(
+		vfs,
+		"/sys/devices/virtual/dmi/id/product_name",
+		"VirtualContainer v1\n",
+	);
 	ensureFile(vfs, "/sys/devices/virtual/dmi/id/board_name", "fortune-board\n");
 
 	ensureDir(vfs, "/sys/class");
@@ -261,11 +424,7 @@ function bootstrapSys(vfs: VirtualFileSystem, props: ShellProperties): void {
 
 	ensureDir(vfs, "/sys/kernel");
 	ensureFile(vfs, "/sys/kernel/hostname", "fortune-vm\n");
-	ensureFile(
-		vfs,
-		"/sys/kernel/osrelease",
-		`${props.kernel}\n`,
-	);
+	ensureFile(vfs, "/sys/kernel/osrelease", `${props.kernel}\n`);
 	ensureFile(vfs, "/sys/kernel/ostype", "Linux\n");
 }
 
@@ -299,22 +458,66 @@ function bootstrapUsr(vfs: VirtualFileSystem): void {
 
 	// Stub binaries so `which` can find built-in commands
 	const builtins = [
-		"sh", "bash", "ls", "cat", "echo", "grep", "find", "sort",
-		"head", "tail", "cut", "tr", "sed", "awk", "wc", "tee",
-		"tar", "gzip", "gunzip", "touch", "mkdir", "rm", "mv", "cp",
-		"chmod", "ln", "pwd", "env", "date", "sleep", "id", "whoami",
-		"hostname", "uname", "ps", "kill", "df", "du", "curl", "wget",
-		"nano", "diff", "uniq", "xargs", "base64",
+		"sh",
+		"bash",
+		"ls",
+		"cat",
+		"echo",
+		"grep",
+		"find",
+		"sort",
+		"head",
+		"tail",
+		"cut",
+		"tr",
+		"sed",
+		"awk",
+		"wc",
+		"tee",
+		"tar",
+		"gzip",
+		"gunzip",
+		"touch",
+		"mkdir",
+		"rm",
+		"mv",
+		"cp",
+		"chmod",
+		"ln",
+		"pwd",
+		"env",
+		"date",
+		"sleep",
+		"id",
+		"whoami",
+		"hostname",
+		"uname",
+		"ps",
+		"kill",
+		"df",
+		"du",
+		"curl",
+		"wget",
+		"nano",
+		"diff",
+		"uniq",
+		"xargs",
+		"base64",
 	];
 	for (const bin of builtins) {
-		ensureFile(vfs, `/usr/bin/${bin}`, `#!/bin/sh\nexec builtin ${bin} "$@"\n`, 0o755);
+		ensureFile(
+			vfs,
+			`/usr/bin/${bin}`,
+			`#!/bin/sh\nexec builtin ${bin} "$@"\n`,
+			0o755,
+		);
 	}
 
 	// lsb_release script
 	ensureFile(
 		vfs,
 		"/usr/bin/lsb_release",
-		"#!/bin/sh\nexec lsb_release \"$@\"\n",
+		'#!/bin/sh\nexec lsb_release "$@"\n',
 		0o755,
 	);
 }
@@ -434,6 +637,6 @@ export function bootstrapLinuxRootfs(
 	bootstrapTmp(vfs);
 	bootstrapRoot(vfs);
 	bootstrapMisc(vfs);
-	refreshProc(vfs, props, hostname, shellStartTime);
+	refreshProc(vfs, props, hostname, shellStartTime, []);
 	syncEtcPasswd(vfs, users);
 }

package/src/standalone-wo-sftp.ts

@@ -0,0 +1,38 @@
+import { SshMimic } from "./SSHMimic/index";
+import { VirtualShell } from "./VirtualShell";
+
+const hostname = process.env.SSH_MIMIC_HOSTNAME ?? "typescript-vm";
+const virtualShell = new VirtualShell(hostname, undefined, {
+	mode: "fs",
+	snapshotPath: ".vfs",
+});
+
+virtualShell.addCommand("demo", [], () => {
+	return {
+		stdout: "This is a demo command. It does nothing useful.",
+		exitCode: 0,
+	};
+});
+
+new SshMimic({
+	port: 2222,
+	hostname,
+	shell: virtualShell,
+})
+	.start()
+	.catch((error: unknown) => {
+		console.error("Failed to start SSH Mimic:", error);
+		process.exit(1);
+	});
+
+process.on("uncaughtException", (error) => {
+	console.log("Oh my god, something terrible happened: ", error);
+});
+
+process.on("unhandledRejection", (error, promise) => {
+	console.log(
+		" Oh Lord! We forgot to handle a promise rejection here: ",
+		promise,
+	);
+	console.log(" The error was: ", error);
+});

package/src/utils/expand.ts

@@ -0,0 +1,238 @@
+/**
+ * expand.ts
+ *
+ * Centralised shell variable and expression expansion.
+ * Used by `runCommand` (index.ts), `echo`, and `sh.ts`.
+ *
+ * Handles (in order):
+ *   ~             tilde to $HOME
+ *   $?            last exit code
+ *   $$            mock PID
+ *   $#            argument count (0 outside scripts)
+ *   ${#VAR}       string length
+ *   ${VAR:-def}   default if unset/empty
+ *   ${VAR:=def}   assign default if unset/empty
+ *   ${VAR:+val}   alternate value if set
+ *   ${VAR}        simple braced reference
+ *   $VAR          simple reference
+ *   $((expr))     arithmetic (integer)
+ */
+
+// ─── arithmetic evaluator ────────────────────────────────────────────────────
+
+/**
+ * Evaluate a simple integer arithmetic expression.
+ * Supports: +  -  *  /  %  **  unary-  ( )
+ * Variables are resolved from `env` before evaluation.
+ * Returns NaN on syntax error.
+ */
+export function evalArith(expr: string, env: Record<string, string>): number {
+	// Substitute variable names before evaluating
+	const substituted = expr.replace(
+		/\b([A-Za-z_][A-Za-z0-9_]*)\b/g,
+		(_, name) => {
+			const val = env[name];
+			return val !== undefined && val !== "" ? val : "0";
+		},
+	);
+
+	// Whitelist: only digits, operators, spaces, parens
+	if (!/^[\d\s+\-*/%()^!&|<>=,. ]+$/.test(substituted)) return NaN;
+
+	try {
+		// Use Function constructor for safe subset (no identifiers remain)
+		// eslint-disable-next-line no-new-func
+		const result = Function(
+			`"use strict"; return (${substituted.replace(/\*\*/g, "**")});`,
+		)();
+		return typeof result === "number" ? Math.trunc(result) : NaN;
+	} catch {
+		return NaN;
+	}
+}
+
+// ─── synchronous expansion ───────────────────────────────────────────────────
+
+/**
+ * Apply a replacer only to portions of `input` that are NOT inside single quotes.
+ * Single-quoted content is passed through verbatim (POSIX sh behaviour).
+ */
+function outsideSingleQuotes(
+	input: string,
+	replacer: (chunk: string) => string,
+): string {
+	const parts: string[] = [];
+	let i = 0;
+	while (i < input.length) {
+		const sqIdx = input.indexOf("'", i);
+		if (sqIdx === -1) {
+			// No more single quotes — expand the rest
+			parts.push(replacer(input.slice(i)));
+			break;
+		}
+		// Expand the part before the single quote
+		parts.push(replacer(input.slice(i, sqIdx)));
+		// Find closing single quote — everything inside is literal
+		const closeIdx = input.indexOf("'", sqIdx + 1);
+		if (closeIdx === -1) {
+			// Unclosed quote — treat rest as literal
+			parts.push(input.slice(sqIdx));
+			break;
+		}
+		parts.push(input.slice(sqIdx, closeIdx + 1)); // include quotes
+		i = closeIdx + 1;
+	}
+	return parts.join("");
+}
+
+/**
+ * Expand all shell variable and expression forms synchronously.
+ * Does NOT handle `$(cmd)` — that requires async; see `expandAsync`.
+ * Content inside single quotes is left verbatim per POSIX sh rules.
+ *
+ * @param input     Raw string possibly containing `$VAR`, `${...}`, `$((...))`.
+ * @param env       Current session env vars.
+ * @param lastExit  Last command exit code (for `$?`).
+ * @param home      Home directory path (for `~`).
+ */
+export function expandSync(
+	input: string,
+	env: Record<string, string>,
+	lastExit = 0,
+	home?: string,
+): string {
+	const homePath = home ?? env.HOME ?? "/home/user";
+
+	return outsideSingleQuotes(input, (chunk) => {
+		let s = chunk;
+
+		// Tilde expansion — only at start of token or after `:` or whitespace
+		s = s.replace(
+			/(^|[\s:])~(\/|$)/g,
+			(_, pre, post) => `${pre}${homePath}${post}`,
+		);
+
+		// $? $$ $#
+		s = s.replace(/\$\?/g, String(lastExit));
+		s = s.replace(/\$\$/g, "1");
+		s = s.replace(/\$#/g, "0");
+
+		// $(( arithmetic )) — must come before ${ and $VAR to avoid conflicts
+		s = s.replace(/\$\(\(([^)]+(?:\([^)]*\)[^)]*)*)\)\)/g, (_, expr) => {
+			const result = evalArith(expr, env);
+			return Number.isNaN(result) ? "0" : String(result);
+		});
+
+		// ${#VAR} — string length
+		s = s.replace(/\$\{#([A-Za-z_][A-Za-z0-9_]*)\}/g, (_, name) =>
+			String((env[name] ?? "").length),
+		);
+
+		// ${VAR:-default}
+		s = s.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*):-([^}]*)\}/g, (_, name, def) =>
+			env[name] !== undefined && env[name] !== "" ? (env[name] as string) : def,
+		);
+
+		// ${VAR:=default} — also assigns to env
+		s = s.replace(
+			/\$\{([A-Za-z_][A-Za-z0-9_]*):=([^}]*)\}/g,
+			(_, name, def) => {
+				if (env[name] === undefined || env[name] === "") env[name] = def;
+				return env[name] as string;
+			},
+		);
+
+		// ${VAR:+alternate}
+		s = s.replace(
+			/\$\{([A-Za-z_][A-Za-z0-9_]*):\+([^}]*)\}/g,
+			(_, name, alt) =>
+				env[name] !== undefined && env[name] !== "" ? alt : "",
+		);
+
+		// ${VAR}
+		s = s.replace(
+			/\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g,
+			(_, name) => env[name] ?? "",
+		);
+
+		// $VAR
+		s = s.replace(/\$([A-Za-z_][A-Za-z0-9_]*)/g, (_, name) => env[name] ?? "");
+
+		return s;
+	});
+}
+
+// ─── async expansion (includes $(cmd)) ──────────────────────────────────────
+
+/**
+ * Expand all shell forms including `$(cmd)` command substitution.
+ *
+ * Processes `$(...)` blocks depth-first, respecting single-quote boundaries.
+ * Then delegates to `expandSync` for the remaining forms.
+ *
+ * @param input     Raw string.
+ * @param env       Current session env vars.
+ * @param lastExit  Last exit code.
+ * @param runCmd    Async callback to execute a command and return its stdout.
+ */
+export async function expandAsync(
+	input: string,
+	env: Record<string, string>,
+	lastExit: number,
+	runCmd: (cmd: string) => Promise<string>,
+): Promise<string> {
+	// $(cmd) substitution — skip content inside single quotes
+	if (input.includes("$(")) {
+		let result = "";
+		let inSingle = false;
+		let i = 0;
+
+		while (i < input.length) {
+			const ch = input[i]!;
+
+			if (ch === "'" && !inSingle) {
+				inSingle = true;
+				result += ch;
+				i++;
+				continue;
+			}
+			if (ch === "'" && inSingle) {
+				inSingle = false;
+				result += ch;
+				i++;
+				continue;
+			}
+
+			if (!inSingle && ch === "$" && input[i + 1] === "(") {
+				// $((expr)) arithmetic — NOT a $(cmd) substitution, skip it
+				if (input[i + 2] === "(") {
+					result += ch;
+					i++;
+					continue;
+				}
+				// Find matching ) with depth tracking
+				let depth = 0;
+				let j = i + 1;
+				while (j < input.length) {
+					if (input[j] === "(") depth++;
+					else if (input[j] === ")") {
+						depth--;
+						if (depth === 0) break;
+					}
+					j++;
+				}
+				const sub = input.slice(i + 2, j).trim();
+				const out = (await runCmd(sub)).replace(/\n$/, "");
+				result += out;
+				i = j + 1;
+				continue;
+			}
+
+			result += ch;
+			i++;
+		}
+		input = result;
+	}
+
+	return expandSync(input, env, lastExit);
+}