typescript-virtual-container 1.2.8 → 1.3.0

package/src/commands/test.ts

@@ -0,0 +1,135 @@
+import type { ShellModule } from "../types/commands";
+
+/**
+ * Evaluate a POSIX test expression.
+ * Supports: -f, -d, -e, -r, -w, -x, -s, -z, -n,
+ *           string =, !=, numeric -eq -ne -lt -le -gt -ge,
+ *           ! (negate), -a (and), -o (or).
+ */
+function evalTest(
+	tokens: string[],
+	shell: import("../VirtualShell").VirtualShell,
+	cwd: string,
+): boolean {
+	// When called via [ command, ] is the last arg — strip it
+	// When called via test command, no brackets present
+	if (tokens[tokens.length - 1] === "]") {
+		tokens = tokens.slice(0, -1);
+	}
+	// Also strip leading [ if present (shouldn't normally happen but be safe)
+	if (tokens[0] === "[") {
+		tokens = tokens.slice(1);
+	}
+
+	if (tokens.length === 0) return false;
+
+	// Negation
+	if (tokens[0] === "!") return !evalTest(tokens.slice(1), shell, cwd);
+
+	// Boolean -a / -o (simple left-right, no precedence)
+	const andIdx = tokens.indexOf("-a");
+	if (andIdx !== -1) {
+		return (
+			evalTest(tokens.slice(0, andIdx), shell, cwd) &&
+			evalTest(tokens.slice(andIdx + 1), shell, cwd)
+		);
+	}
+	const orIdx = tokens.indexOf("-o");
+	if (orIdx !== -1) {
+		return (
+			evalTest(tokens.slice(0, orIdx), shell, cwd) ||
+			evalTest(tokens.slice(orIdx + 1), shell, cwd)
+		);
+	}
+
+	// Unary file tests
+	if (tokens.length === 2) {
+		const [flag, operand = ""] = tokens;
+		const resolvePath = (p: string) =>
+			p.startsWith("/") ? p : `${cwd}/${p}`.replace(/\/+/g, "/");
+		const path = resolvePath(operand);
+
+		switch (flag) {
+			case "-e":
+				return shell.vfs.exists(path);
+			case "-f":
+				return shell.vfs.exists(path) && shell.vfs.stat(path).type === "file";
+			case "-d":
+				return (
+					shell.vfs.exists(path) && shell.vfs.stat(path).type === "directory"
+				);
+			case "-r":
+				return shell.vfs.exists(path); // all readable in virtual env
+			case "-w":
+				return shell.vfs.exists(path);
+			case "-x":
+				return shell.vfs.exists(path) && !!(shell.vfs.stat(path).mode & 0o111);
+			case "-s":
+				return (
+					shell.vfs.exists(path) &&
+					shell.vfs.stat(path).type === "file" &&
+					(shell.vfs.stat(path) as import("../types/vfs").VfsFileNode).size > 0
+				);
+			case "-z":
+				return operand.length === 0;
+			case "-n":
+				return operand.length > 0;
+			case "-L":
+				return shell.vfs.isSymlink(path);
+		}
+	}
+
+	// Binary comparisons
+	if (tokens.length === 3) {
+		const [left = "", op, right = ""] = tokens;
+		const leftN = Number(left);
+		const rightN = Number(right);
+
+		switch (op) {
+			// String
+			case "=":
+			case "==":
+				return left === right;
+			case "!=":
+				return left !== right;
+			case "<":
+				return left < right;
+			case ">":
+				return left > right;
+			// Numeric
+			case "-eq":
+				return leftN === rightN;
+			case "-ne":
+				return leftN !== rightN;
+			case "-lt":
+				return leftN < rightN;
+			case "-le":
+				return leftN <= rightN;
+			case "-gt":
+				return leftN > rightN;
+			case "-ge":
+				return leftN >= rightN;
+		}
+	}
+
+	// Single string (truthy if non-empty)
+	if (tokens.length === 1) return (tokens[0] ?? "").length > 0;
+
+	return false;
+}
+
+export const testCommand: ShellModule = {
+	name: "test",
+	aliases: ["["],
+	description: "Evaluate conditional expression",
+	category: "shell",
+	params: ["<expression>"],
+	run: ({ args, shell, cwd }) => {
+		try {
+			const result = evalTest([...args], shell, cwd);
+			return { exitCode: result ? 0 : 1 };
+		} catch {
+			return { stderr: "test: malformed expression", exitCode: 2 };
+		}
+	},
+};

package/src/commands/tr.ts

@@ -16,7 +16,9 @@ export const trCommand: ShellModule = {
 			for (const c of set1) input = input.split(c).join("");
 		} else if (set2) {
 			for (let i = 0; i < set1.length; i++) {
-				input = input.split(set1[i]!).join(set2[i] ?? set2[set2.length - 1] ?? "");
+				input = input
+					.split(set1[i]!)
+					.join(set2[i] ?? set2[set2.length - 1] ?? "");
 			}
 		}
 		return { stdout: input, exitCode: 0 };

package/src/commands/true.ts

@@ -0,0 +1,17 @@
+import type { ShellModule } from "../types/commands";
+
+export const trueCommand: ShellModule = {
+	name: "true",
+	description: "Return success exit code",
+	category: "shell",
+	params: [],
+	run: () => ({ exitCode: 0 }),
+};
+
+export const falseCommand: ShellModule = {
+	name: "false",
+	description: "Return failure exit code",
+	category: "shell",
+	params: [],
+	run: () => ({ exitCode: 1 }),
+};

package/src/commands/type.ts

@@ -0,0 +1,43 @@
+import type { ShellModule } from "../types/commands";
+import { resolveModule } from "./registry";
+
+export const typeCommand: ShellModule = {
+	name: "type",
+	description: "Describe how a command would be interpreted",
+	category: "shell",
+	params: ["<command...>"],
+	run: ({ args, shell, env }) => {
+		if (args.length === 0)
+			return { stderr: "type: missing argument", exitCode: 1 };
+
+		const pathDirs = (env?.vars?.PATH ?? "/usr/local/bin:/usr/bin:/bin").split(
+			":",
+		);
+		const lines: string[] = [];
+		let exitCode = 0;
+
+		for (const name of args) {
+			if (resolveModule(name)) {
+				lines.push(`${name} is a shell builtin`);
+				continue;
+			}
+
+			let found = false;
+			for (const dir of pathDirs) {
+				const full = `${dir}/${name}`;
+				if (shell.vfs.exists(full)) {
+					lines.push(`${name} is ${full}`);
+					found = true;
+					break;
+				}
+			}
+
+			if (!found) {
+				lines.push(`${name}: not found`);
+				exitCode = 1;
+			}
+		}
+
+		return { stdout: lines.join("\n"), exitCode };
+	},
+};

package/src/commands/uname.ts

@@ -12,7 +12,11 @@ export const unameCommand: ShellModule = {
 		const release = shell.properties?.kernel ?? "5.15.0";
 		const machine = shell.properties?.arch ?? "x86_64";
 		const hostname = shell.hostname;
-		if (all) return { stdout: `${sysname} ${hostname} ${release} #1 SMP ${machine} GNU/Linux`, exitCode: 0 };
+		if (all)
+			return {
+				stdout: `${sysname} ${hostname} ${release} #1 SMP ${machine} GNU/Linux`,
+				exitCode: 0,
+			};
 		if (ifFlag(args, ["-r"])) return { stdout: release, exitCode: 0 };
 		if (ifFlag(args, ["-m"])) return { stdout: machine, exitCode: 0 };
 		return { stdout: sysname, exitCode: 0 };

package/src/commands/uniq.ts

@@ -18,8 +18,14 @@ export const uniqCommand: ShellModule = {
 			while (j < lines.length && lines[j] === lines[i]) j++;
 			const n = j - i;
 			const line = lines[i]!;
-			if (dupOnly && n === 1) { i = j; continue; }
-			if (uniqOnly && n > 1) { i = j; continue; }
+			if (dupOnly && n === 1) {
+				i = j;
+				continue;
+			}
+			if (uniqOnly && n > 1) {
+				i = j;
+				continue;
+			}
 			out.push(count ? `${String(n).padStart(4)} ${line}` : line);
 			i = j;
 		}

package/src/commands/uptime.ts

@@ -0,0 +1,49 @@
+import type { ShellModule } from "../types/commands";
+import { ifFlag } from "./command-helpers";
+
+export const uptimeCommand: ShellModule = {
+	name: "uptime",
+	description: "Tell how long the system has been running",
+	category: "system",
+	params: ["[-p] [-s]"],
+	run: ({ args, shell }) => {
+		const pretty = ifFlag(args, ["-p"]);
+		const since = ifFlag(args, ["-s"]);
+
+		const uptimeSec = Math.floor((Date.now() - shell.startTime) / 1000);
+		const days = Math.floor(uptimeSec / 86400);
+		const hours = Math.floor((uptimeSec % 86400) / 3600);
+		const mins = Math.floor((uptimeSec % 3600) / 60);
+
+		if (since) {
+			return {
+				stdout: new Date(shell.startTime)
+					.toISOString()
+					.slice(0, 19)
+					.replace("T", " "),
+				exitCode: 0,
+			};
+		}
+
+		if (pretty) {
+			const parts: string[] = [];
+			if (days > 0) parts.push(`${days} day${days > 1 ? "s" : ""}`);
+			if (hours > 0) parts.push(`${hours} hour${hours > 1 ? "s" : ""}`);
+			parts.push(`${mins} minute${mins !== 1 ? "s" : ""}`);
+			return { stdout: `up ${parts.join(", ")}`, exitCode: 0 };
+		}
+
+		const timeStr = new Date().toTimeString().slice(0, 8);
+		const uptimeStr =
+			days > 0
+				? `${days} day${days > 1 ? "s" : ""}, ${String(hours).padStart(2)}:${String(mins).padStart(2, "0")}`
+				: `${String(hours).padStart(2)}:${String(mins).padStart(2, "0")}`;
+		const sessions = shell.users.listActiveSessions().length;
+		const load = (Math.random() * 0.5).toFixed(2);
+
+		return {
+			stdout: ` ${timeStr} up ${uptimeStr},  ${sessions} user${sessions !== 1 ? "s" : ""},  load average: ${load}, ${load}, ${load}`,
+			exitCode: 0,
+		};
+	},
+};

package/src/commands/wget.ts

@@ -1,146 +1,132 @@
-import { spawn } from "node:child_process";
-import { mkdtemp, readFile, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
 import type { ShellModule } from "../types/commands";
 import { ifFlag, parseArgs } from "./command-helpers";
-import {
-	assertPathAccess,
-	normalizeTerminalOutput,
-	resolvePath,
-	runHostCommand,
-	stripUrlFilename,
-} from "./helpers";
-
-function runHostWget(args: string[]): Promise<{
-	stdout: string;
-	stderr: string;
-	exitCode: number;
-}> {
-	return new Promise((resolve) => {
-		let childProcess: ReturnType<typeof spawn>;
-
-		try {
-			childProcess = spawn("wget", args, {
-				stdio: ["ignore", "pipe", "pipe"],
-			});
-		} catch (error) {
-			resolve({
-				stdout: "",
-				stderr: `wget: ${error instanceof Error ? error.message : String(error)}`,
-				exitCode: 1,
-			});
-			return;
-		}
-
-		let stdout = "";
-		let stderr = "";
-		const stdoutStream = childProcess.stdout;
-		const stderrStream = childProcess.stderr;
-
-		if (!stdoutStream || !stderrStream) {
-			resolve({
-				stdout: "",
-				stderr: "wget: failed to capture process output",
-				exitCode: 1,
-			});
-			return;
-		}
-
-		stdoutStream.setEncoding("utf8");
-		stderrStream.setEncoding("utf8");
-
-		stdoutStream.on("data", (chunk: string) => {
-			stdout += chunk;
-		});
-
-		stderrStream.on("data", (chunk: string) => {
-			stderr += chunk;
-		});
-
-		childProcess.on("error", (error) => {
-			const errorCode =
-				error instanceof Error && "code" in error
-					? String((error as NodeJS.ErrnoException).code ?? "")
-					: "";
-			resolve({
-				stdout: "",
-				stderr: `wget: ${error.message}`,
-				exitCode: errorCode === "ENOENT" ? 127 : 1,
-			});
-		});
-
-		childProcess.on("close", (code) => {
-			resolve({
-				stdout,
-				stderr,
-				exitCode: code ?? 1,
-			});
-		});
-	});
-}
+import { assertPathAccess, resolvePath, stripUrlFilename } from "./helpers";
 
 export const wgetCommand: ShellModule = {
 	name: "wget",
-	description: "File downloader",
+	description: "File downloader (pure fetch)",
 	category: "network",
-	params: ["[url]"],
+	params: ["[options] <url>"],
 	run: async ({ authUser, cwd, args, shell }) => {
 		const { flagsWithValues, positionals } = parseArgs(args, {
-			flagsWithValue: ["-o", "-O", "--output", "--output-document"],
+			flagsWithValue: [
+				"-O",
+				"--output-document",
+				"-o",
+				"--output-file",
+				"-P",
+				"--directory-prefix",
+				"--tries",
+				"--timeout",
+			],
 		});
-		const outputPath =
-			flagsWithValues.get("-o") ||
-			flagsWithValues.get("-O") ||
-			flagsWithValues.get("--output") ||
-			flagsWithValues.get("--output-document") ||
-			null;
-		const url = positionals[0];
 
-		if (!url) {
-			return { stderr: "wget: missing URL", exitCode: 1 };
+		if (ifFlag(args, ["-h", "--help"])) {
+			return {
+				stdout: [
+					"Usage: wget [option]... [URL]...",
+					"  -O, --output-document=FILE  Write to FILE ('-' for stdout)",
+					"  -P, --directory-prefix=DIR  Save files in DIR",
+					"  -q, --quiet                 Quiet mode",
+					"  -v, --verbose               Verbose output (default)",
+					"  -c, --continue              Continue partial download",
+					"  --tries=N                   Retry N times",
+					"  --timeout=N                 Timeout in seconds",
+				].join("\n"),
+				exitCode: 0,
+			};
 		}
 
-		const isHelpLike = ifFlag(args, ["-h", "--help", "-V", "--version"]);
-
-		if (isHelpLike) {
-			const result = await runHostWget(args);
+		if (ifFlag(args, ["-V", "--version"])) {
 			return {
-				stdout: normalizeTerminalOutput(result.stdout),
-				stderr: result.stderr
-					? normalizeTerminalOutput(result.stderr)
-					: undefined,
-				exitCode: result.exitCode,
+				stdout: "GNU Wget 1.21.3 (virtual) built on Fortune GNU/Linux.",
+				exitCode: 0,
 			};
 		}
 
-		const tempDir = await mkdtemp(join(tmpdir(), "virtual-env-js-wget-"));
-		const tempFile = join(tempDir, "download");
+		const url = positionals[0];
+		if (!url)
+			return {
+				stderr: "wget: missing URL\nUsage: wget [OPTION]... [URL]...",
+				exitCode: 1,
+			};
+
+		const outputArg =
+			flagsWithValues.get("-O") ??
+			flagsWithValues.get("--output-document") ??
+			null;
+		const dirPrefix =
+			flagsWithValues.get("-P") ??
+			flagsWithValues.get("--directory-prefix") ??
+			null;
+		const quiet = ifFlag(args, ["-q", "--quiet"]);
+
+		// Derive target filename
+		const filename =
+			outputArg === "-" ? null : (outputArg ?? stripUrlFilename(url));
+		const targetPath = filename
+			? resolvePath(cwd, dirPrefix ? `${dirPrefix}/${filename}` : filename)
+			: null;
+
+		if (targetPath) assertPathAccess(authUser, targetPath, "wget");
+
+		const stderrLines: string[] = [];
+		if (!quiet) {
+			stderrLines.push(`--${new Date().toISOString()}--  ${url}`);
+			stderrLines.push(`Resolving ${new URL(url).host}...`);
+			stderrLines.push(`Connecting to ${new URL(url).host}...`);
+		}
 
+		let response: Response;
 		try {
-			const hostArgs = [...positionals, "-O", tempFile];
-			const result = await runHostCommand("wget", hostArgs);
+			response = await fetch(url, {
+				headers: { "User-Agent": "Wget/1.21.3 (Fortune GNU/Linux)" },
+			});
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			stderrLines.push(`wget: unable to resolve host: ${msg}`);
+			return { stderr: stderrLines.join("\n"), exitCode: 4 };
+		}
+
+		if (!response.ok) {
+			stderrLines.push(`ERROR ${response.status}: ${response.statusText}`);
+			return { stderr: stderrLines.join("\n"), exitCode: 8 };
+		}
 
-			if (result.exitCode !== 0) {
-				return {
-					stderr: normalizeTerminalOutput(
-						result.stderr || `wget: exited with code ${result.exitCode}`,
-					),
-					exitCode: result.exitCode,
-				};
-			}
+		let body: string;
+		try {
+			body = await response.text();
+		} catch {
+			return { stderr: "wget: failed to read response", exitCode: 1 };
+		}
 
-			const content = await readFile(tempFile, "utf8");
-			const target = resolvePath(cwd, outputPath || stripUrlFilename(url));
-			assertPathAccess(authUser, target, "wget");
-			shell.writeFileAsUser(authUser, target, content);
+		if (!quiet) {
+			const ct =
+				response.headers.get("content-type") ?? "application/octet-stream";
+			stderrLines.push(
+				`HTTP request sent, awaiting response... ${response.status} ${response.statusText}`,
+			);
+			stderrLines.push(`Length: ${body.length} [${ct}]`);
+		}
 
+		// Output to stdout (pipe) or file
+		if (outputArg === "-") {
 			return {
-				stdout: `saved ${target}`,
+				stdout: body,
+				stderr: stderrLines.join("\n") || undefined,
 				exitCode: 0,
 			};
-		} finally {
-			await rm(tempDir, { recursive: true, force: true });
 		}
+
+		if (targetPath) {
+			shell.writeFileAsUser(authUser, targetPath, body);
+			if (!quiet)
+				stderrLines.push(
+					`Saving to: '${targetPath}'\n${targetPath}            100%[==================>]  ${body.length} B`,
+				);
+			return { stderr: stderrLines.join("\n") || undefined, exitCode: 0 };
+		}
+
+		return { stdout: body, exitCode: 0 };
 	},
 };

package/src/commands/which.ts

@@ -0,0 +1,37 @@
+import type { ShellModule } from "../types/commands";
+
+export const whichCommand: ShellModule = {
+	name: "which",
+	description: "Locate a command in PATH",
+	category: "shell",
+	params: ["<command...>"],
+	run: ({ args, shell, env }) => {
+		if (args.length === 0)
+			return { stderr: "which: missing argument", exitCode: 1 };
+
+		const pathDirs = (env?.vars?.PATH ?? "/usr/local/bin:/usr/bin:/bin").split(
+			":",
+		);
+		const lines: string[] = [];
+		let anyMissing = false;
+
+		for (const name of args) {
+			let found = false;
+			for (const dir of pathDirs) {
+				const full = `${dir}/${name}`;
+				if (shell.vfs.exists(full)) {
+					const st = shell.vfs.stat(full);
+					if (st.type === "file") {
+						lines.push(full);
+						found = true;
+						break;
+					}
+				}
+			}
+			if (!found) anyMissing = true;
+		}
+
+		if (lines.length === 0) return { exitCode: 1 };
+		return { stdout: lines.join("\n"), exitCode: anyMissing ? 1 : 0 };
+	},
+};

package/src/commands/xargs.ts

@@ -1,5 +1,5 @@
 import type { ShellModule } from "../types/commands";
-import { runCommand } from "./index";
+import { runCommand } from "./runtime";
 
 export const xargsCommand: ShellModule = {
 	name: "xargs",
@@ -12,6 +12,15 @@ export const xargsCommand: ShellModule = {
 		const items = (stdin ?? "").trim().split(/\s+/).filter(Boolean);
 		if (items.length === 0) return { exitCode: 0 };
 		const fullCmd = [baseCmd, ...extraArgs, ...items].join(" ");
-		return runCommand(fullCmd, authUser, hostname, mode, cwd, shell, undefined, env);
+		return runCommand(
+			fullCmd,
+			authUser,
+			hostname,
+			mode,
+			cwd,
+			shell,
+			undefined,
+			env,
+		);
 	},
 };

package/src/index.ts

@@ -1,13 +1,14 @@
-import { HoneyPot } from "./Honeypot/index";
-import { SshClient } from "./SSHClient/index";
-import { SftpMimic, SshMimic } from "./SSHMimic/index";
-import VirtualFileSystem from "./VirtualFileSystem/index";
-import { VirtualShell } from "./VirtualShell/index";
-import { VirtualUserManager } from "./VirtualUserManager/index";
+export { HoneyPot } from "./Honeypot/index";
+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 { VirtualShell } from "./VirtualShell/index";
+export { VirtualUserManager } from "./VirtualUserManager/index";
 
 export type {
 	AuditLogEntry,
-	HoneyPotStats,
+	HoneyPotStats
 } from "./Honeypot/index";
 export type {
 	CommandContext,
@@ -15,8 +16,9 @@ export type {
 	CommandOutcome,
 	CommandResult,
 	NanoEditorSession,
+	ShellEnv,
 	ShellModule,
-	SudoChallenge,
+	SudoChallenge
 } from "./types/commands";
 export type { ExecStream, ShellStream } from "./types/streams";
 export type {
@@ -31,22 +33,29 @@ export type {
 	VfsSnapshotDirectoryNode,
 	VfsSnapshotFileNode,
 	VfsSnapshotNode,
-	WriteFileOptions,
+	WriteFileOptions
 } from "./types/vfs";
 export type { VfsOptions, VfsPersistenceMode } from "./VirtualFileSystem/index";
+export type { ShellProperties } from "./VirtualShell/index";
+
+export type {
+	InstalledPackage, PackageDefinition,
+	PackageFile
+} from "./VirtualPackageManager/index";
 
 export {
-	HoneyPot,
-	SshClient,
-	VirtualFileSystem,
-	SftpMimic as VirtualSftpServer,
-	VirtualShell,
-	SshMimic as VirtualSshServer,
-	VirtualUserManager,
-};
+	assertDiff, diffSnapshots,
+	formatDiff
+} from "./utils/vfsDiff";
+export type {
+	VfsDiff,
+	VfsDiffEntry,
+	VfsDiffModified
+} from "./utils/vfsDiff";
 
 export {
 	getArg,
 	getFlag,
-	ifFlag,
+	ifFlag
 } from "./commands/command-helpers";
+