typescript-virtual-container 1.2.7 → 1.2.9

package/src/commands/test.ts

@@ -0,0 +1,100 @@
+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/type.ts

@@ -0,0 +1,40 @@
+import { resolveModule } from ".";
+import type { ShellModule } from "../types/commands";
+
+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/uptime.ts

@@ -0,0 +1,46 @@
+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,93 @@
-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";
+import { assertPathAccess, resolvePath, stripUrlFilename } from "./helpers";
 
-function runHostWget(args: string[]): Promise<{
-	stdout: string;
-	stderr: string;
-	exitCode: number;
-}> {
-	return new Promise((resolve) => {
-		let childProcess: ReturnType<typeof spawn>;
+export const wgetCommand: ShellModule = {
+	name: "wget",
+	description: "File downloader (pure fetch)",
+	category: "network",
+	params: ["[options] <url>"],
+	run: async ({ authUser, cwd, args, shell }) => {
+		const { flagsWithValues, positionals } = parseArgs(args, {
+			flagsWithValue: ["-O", "--output-document", "-o", "--output-file", "-P", "--directory-prefix", "--tries", "--timeout"],
+		});
 
-		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;
+		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,
+			};
 		}
 
-		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;
+		if (ifFlag(args, ["-V", "--version"])) {
+			return { stdout: "GNU Wget 1.21.3 (virtual) built on Fortune GNU/Linux.", exitCode: 0 };
 		}
 
-		stdoutStream.setEncoding("utf8");
-		stderrStream.setEncoding("utf8");
+		const url = positionals[0];
+		if (!url) return { stderr: "wget: missing URL\nUsage: wget [OPTION]... [URL]...", exitCode: 1 };
 
-		stdoutStream.on("data", (chunk: string) => {
-			stdout += chunk;
-		});
+		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"]);
 
-		stderrStream.on("data", (chunk: string) => {
-			stderr += chunk;
-		});
+		// Derive target filename
+		const filename = outputArg === "-" ? null : (outputArg ?? stripUrlFilename(url));
+		const targetPath = filename
+			? resolvePath(cwd, dirPrefix ? `${dirPrefix}/${filename}` : filename)
+			: null;
 
-		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,
-			});
-		});
+		if (targetPath) assertPathAccess(authUser, targetPath, "wget");
 
-		childProcess.on("close", (code) => {
-			resolve({
-				stdout,
-				stderr,
-				exitCode: code ?? 1,
-			});
-		});
-	});
-}
-
-export const wgetCommand: ShellModule = {
-	name: "wget",
-	description: "File downloader",
-	category: "network",
-	params: ["[url]"],
-	run: async ({ authUser, cwd, args, shell }) => {
-		const { flagsWithValues, positionals } = parseArgs(args, {
-			flagsWithValue: ["-o", "-O", "--output", "--output-document"],
-		});
-		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 };
+		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}...`);
 		}
 
-		const isHelpLike = ifFlag(args, ["-h", "--help", "-V", "--version"]);
-
-		if (isHelpLike) {
-			const result = await runHostWget(args);
-			return {
-				stdout: normalizeTerminalOutput(result.stdout),
-				stderr: result.stderr
-					? normalizeTerminalOutput(result.stderr)
-					: undefined,
-				exitCode: result.exitCode,
-			};
+		let response: Response;
+		try {
+			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 };
 		}
 
-		const tempDir = await mkdtemp(join(tmpdir(), "virtual-env-js-wget-"));
-		const tempFile = join(tempDir, "download");
+		if (!response.ok) {
+			stderrLines.push(`ERROR ${response.status}: ${response.statusText}`);
+			return { stderr: stderrLines.join("\n"), exitCode: 8 };
+		}
 
-		try {
-			const hostArgs = [...positionals, "-O", tempFile];
-			const result = await runHostCommand("wget", hostArgs);
+		let body: string;
+		try { body = await response.text(); } catch { return { stderr: "wget: failed to read response", exitCode: 1 }; }
 
-			if (result.exitCode !== 0) {
-				return {
-					stderr: normalizeTerminalOutput(
-						result.stderr || `wget: exited with code ${result.exitCode}`,
-					),
-					exitCode: result.exitCode,
-				};
-			}
+		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}]`);
+		}
 
-			const content = await readFile(tempFile, "utf8");
-			const target = resolvePath(cwd, outputPath || stripUrlFilename(url));
-			assertPathAccess(authUser, target, "wget");
-			shell.writeFileAsUser(authUser, target, content);
+		// Output to stdout (pipe) or file
+		if (outputArg === "-") {
+			return { stdout: body, stderr: stderrLines.join("\n") || undefined, exitCode: 0 };
+		}
 
-			return {
-				stdout: `saved ${target}`,
-				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,34 @@
+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/index.ts

@@ -4,6 +4,7 @@ import { SftpMimic, SshMimic } from "./SSHMimic/index";
 import VirtualFileSystem from "./VirtualFileSystem/index";
 import { VirtualShell } from "./VirtualShell/index";
 import { VirtualUserManager } from "./VirtualUserManager/index";
+import { VirtualPackageManager } from "./VirtualPackageManager/index";
 
 export type {
 	AuditLogEntry,
@@ -15,9 +16,11 @@ export type {
 	CommandOutcome,
 	CommandResult,
 	NanoEditorSession,
+	ShellEnv,
 	ShellModule,
 	SudoChallenge,
 } from "./types/commands";
+export type { ShellProperties } from "./VirtualShell/index";
 export type { ExecStream, ShellStream } from "./types/streams";
 export type {
 	RemoveOptions,
@@ -35,6 +38,12 @@ export type {
 } from "./types/vfs";
 export type { VfsOptions, VfsPersistenceMode } from "./VirtualFileSystem/index";
 
+export type {
+	PackageDefinition,
+	PackageFile,
+	InstalledPackage,
+} from "./VirtualPackageManager/index";
+
 export {
 	HoneyPot,
 	SshClient,
@@ -43,6 +52,7 @@ export {
 	VirtualShell,
 	SshMimic as VirtualSshServer,
 	VirtualUserManager,
+	VirtualPackageManager,
 };
 
 export {