typescript-virtual-container 1.5.3 → 1.5.4

package/src/commands/stat.ts

@@ -1,61 +0,0 @@
-import type { ShellModule } from "../types/commands";
-import { resolvePath } from "./helpers";
-
-/**
- * Display file or filesystem status.
- * Outputs: path, size, mode, type, timestamps — similar to `stat` on Linux.
- */
-export const statCommand: ShellModule = {
-	name: "stat",
-	description: "Display file status",
-	category: "files",
-	params: ["[-c <format>] <file>"],
-	run: ({ shell, cwd, args }) => {
-		const fmtIdx = args.findIndex((a) => a === "-c" || a === "--format");
-		const fmt = fmtIdx !== -1 ? args[fmtIdx + 1] : undefined;
-		const file = args.find((a) => !a.startsWith("-") && a !== fmt);
-		if (!file) return { stderr: "stat: missing operand\n", exitCode: 1 };
-
-		const p = resolvePath(cwd, file);
-		if (!shell.vfs.exists(p)) {
-			return { stderr: `stat: cannot stat '${file}': No such file or directory\n`, exitCode: 1 };
-		}
-
-		const st = shell.vfs.stat(p);
-		const isDir = st.type === "directory";
-		const _isLink = shell.vfs.isSymlink(p);
-		const isSymlink = shell.vfs.isSymlink(p);
-		const modePerm = (mode: number): string => {
-			const bits = [0o400,0o200,0o100,0o040,0o020,0o010,0o004,0o002,0o001];
-			const syms = ["r","w","x","r","w","x","r","w","x"];
-			return (isDir ? "d" : isSymlink ? "l" : "-") +
-				bits.map((b, i) => mode & b ? syms[i] : "-").join("");
-		};
-		const octal = (st.mode).toString(8).padStart(4, "0");
-		const modeStr = modePerm(st.mode);
-		const size = "size" in st ? (st as {size: number}).size : 0;
-		const ts = (d: Date) => d.toISOString().replace("T", " ").replace(/\.\d+Z$/, " +0000");
-
-		// -c format string support
-		if (fmt) {
-			const out = fmt
-				.replace("%n", file)
-				.replace("%s", String(size))
-				.replace("%a", octal.slice(1)) // access in octal (no leading 0)
-				.replace("%A", modeStr)
-				.replace("%F", isSymlink ? "symbolic link" : isDir ? "directory" : "regular file")
-				.replace("%y", ts(st.updatedAt))
-				.replace("%z", ts(st.updatedAt));
-			return { stdout: `${out}\n`, exitCode: 0 };
-		}
-
-		const out = [
-			`  File: ${file}${isSymlink ? ` -> ${shell.vfs.resolveSymlink(p)}` : ""}`,
-			`  Size: ${size}${"\t".repeat(3)}${isSymlink ? "symbolic link" : isDir ? "directory" : "regular file"}`,
-			`Access: (${octal}/${modeStr})  Uid: (    0/    root)   Gid: (    0/    root)`,
-			`Modify: ${ts(st.updatedAt)}`,
-			`Change: ${ts(st.updatedAt)}`,
-		].join("\n");
-		return { stdout: `${out}\n`, exitCode: 0 };
-	},
-};

package/src/commands/su.ts

@@ -1,72 +0,0 @@
-import type { ShellModule } from "../types/commands";
-import { runCommand } from "./runtime";
-
-/**
- * Switch to another user account.
- *
- * Usage:
- *   su [username]        — switch to username (defaults to root)
- *   su - [username]      — login shell (changes cwd to target home)
- *   su -c 'cmd' [user]   — run command as user
- *
- * - Root can switch to any user without a password.
- * - Non-root sudoers must enter the target user's password.
- * - Non-sudoers are denied.
- * - Switching to a non-existent user returns an error immediately.
- */
-export const suCommand: ShellModule = {
-	name: "su",
-	description: "Switch user",
-	category: "users",
-	params: ["[-] [-c <cmd>] [username]"],
-	run: async ({ authUser, shell, args, hostname, mode, cwd }) => {
-		const loginShellFlag = args.includes("-") || args.includes("-l") || args.includes("--login");
-		const cIdx = args.indexOf("-c");
-		const cmdLine = cIdx !== -1 ? args[cIdx + 1] : undefined;
-		const filteredArgs = args.filter((_, i) =>
-			i !== cIdx && i !== cIdx + 1
-		).filter((a) => a !== "-" && a !== "-l" && a !== "--login");
-		const targetUser = filteredArgs.find((a) => !a.startsWith("-")) ?? "root";
-
-		// Verify target user exists
-		if (!shell.users.listUsers().includes(targetUser)) {
-			return { stderr: `su: user '${targetUser}' does not exist\n`, exitCode: 1 };
-		}
-
-		// Root switches freely without any password
-		if (authUser === "root") {
-			if (cmdLine) {
-				return runCommand(
-					cmdLine,
-					targetUser,
-					hostname,
-					mode,
-					loginShellFlag ? `/home/${targetUser}` : cwd,
-					shell,
-				);
-			}
-			return {
-				switchUser: targetUser,
-				nextCwd: loginShellFlag ? `/home/${targetUser}` : undefined,
-				exitCode: 0,
-			};
-		}
-
-		// Non-sudoers denied
-		if (!shell.users.isSudoer(authUser)) {
-			return { stderr: "su: permission denied\n", exitCode: 1 };
-		}
-
-		// Sudoers must enter target user's password via challenge
-		return {
-			sudoChallenge: {
-				username: targetUser,
-				targetUser,
-				commandLine: cmdLine ?? null,
-				loginShell: loginShellFlag,
-				prompt: "Password: ",
-			},
-			exitCode: 0,
-		};
-	},
-};

package/src/commands/sudo.ts

@@ -1,76 +0,0 @@
-import type { ShellModule } from "../types/commands";
-import { parseArgs } from "./command-helpers";
-import { runCommand } from "./runtime";
-
-/**
- * Execute a command as another user (superuser by default).
- * @category users
- * @params ["[-u user] [-c cmd] [command]"]
- */
-function parseSudoArgs(args: string[]): {
-	targetUser: string;
-	loginShell: boolean;
-	commandLine: string | null;
-} {
-	const { flags, flagsWithValues, positionals } = parseArgs(args, {
-		flags: ["-i", "-S"],
-		flagsWithValue: ["-u", "--user"],
-	});
-
-	const loginShell = flags.has("-i");
-	const targetUser =
-		flagsWithValues.get("-u") || flagsWithValues.get("--user") || "root";
-	const commandLine = positionals.length > 0 ? positionals.join(" ") : null;
-
-	return { targetUser, loginShell, commandLine };
-}
-export const sudoCommand: ShellModule = {
-	name: "sudo",
-	description: "Execute as superuser",
-	category: "users",
-	params: ["<command...>"],
-	run: async ({ authUser, hostname, mode, cwd, shell, args }) => {
-		const { targetUser, loginShell, commandLine } = parseSudoArgs(args);
-
-		if (authUser !== "root" && !shell.users.isSudoer(authUser)) {
-			return { stderr: "sudo: permission denied", exitCode: 1 };
-		}
-
-		const effectiveUser = targetUser || "root";
-		const prompt = `[sudo] password for ${authUser}: `;
-
-		if (authUser === "root") {
-			if (!commandLine && loginShell) {
-				return {
-					switchUser: effectiveUser,
-					nextCwd: `/home/${effectiveUser}`,
-					exitCode: 0,
-				};
-			}
-
-			if (!commandLine) {
-				return { stderr: "sudo: missing command", exitCode: 1 };
-			}
-
-			return runCommand(
-				commandLine,
-				effectiveUser,
-				hostname,
-				mode,
-				loginShell ? `/home/${effectiveUser}` : cwd,
-				shell,
-			);
-		}
-
-		return {
-			sudoChallenge: {
-				username: authUser,
-				targetUser: effectiveUser,
-				commandLine,
-				loginShell,
-				prompt,
-			},
-			exitCode: 0,
-		};
-	},
-};

package/src/commands/tail.ts

@@ -1,53 +0,0 @@
-import type { ShellModule } from "../types/commands";
-import { getFlag } from "./command-helpers";
-import { assertPathAccess, resolvePath } from "./helpers";
-
-/**
- * Output the last part of files or stdin.
- * @category text
- * @params ["[-n <lines>] [file...]"]
- */
-export const tailCommand: ShellModule = {
-	name: "tail",
-	description: "Output last lines",
-	category: "text",
-	params: ["[-n <lines>] [file...]"],
-	run: ({ authUser, shell, cwd, args, stdin }) => {
-		const nArg = getFlag(args, ["-n"]);
-		const shortN = args.find((a) => /^-\d+$/.test(a));
-		const n = typeof nArg === "string"
-			? parseInt(nArg, 10)
-			: shortN ? parseInt(shortN.slice(1), 10) : 10;
-		const positionals = args.filter(
-			(a) => !a.startsWith("-") && a !== nArg && a !== String(n),
-		);
-
-		const take = (content: string) => {
-			const lines = content.split("\n");
-			// If content ends with \n, last element is ""; exclude from count
-			const hasTrailingNewline = content.endsWith("\n");
-			const meaningful = hasTrailingNewline ? lines.slice(0, -1) : lines;
-			const sliced = meaningful.slice(Math.max(0, meaningful.length - n));
-			return sliced.join("\n") + (hasTrailingNewline ? "\n" : "");
-		};
-
-		if (positionals.length === 0) {
-			return { stdout: take(stdin ?? ""), exitCode: 0 };
-		}
-
-		const results: string[] = [];
-		for (const file of positionals) {
-			const filePath = resolvePath(cwd, file);
-			try {
-				assertPathAccess(authUser, filePath, "tail");
-				results.push(take(shell.vfs.readFile(filePath)));
-			} catch {
-				return {
-					stderr: `tail: ${file}: No such file or directory`,
-					exitCode: 1,
-				};
-			}
-		}
-		return { stdout: results.join("\n"), exitCode: 0 };
-	},
-};

package/src/commands/tar.ts

@@ -1,102 +0,0 @@
-import type { ShellModule } from "../types/commands";
-import { resolvePath } from "./helpers";
-
-/**
- * Archive or extract files with tar and optional gzip compression.
- * @category archive
- * @params ["[-czf|-xzf|-tf] <archive> [files...]"]
- */
-export const tarCommand: ShellModule = {
-	name: "tar",
-	description: "Archive utility",
-	category: "archive",
-	params: ["[-czf|-xzf|-tf] <archive> [files...]"],
-	run: ({ authUser, shell, cwd, args }) => {
-		// Expand combined flags: -czf or czf (bare mode string) → ["-c", "-z", "-f"]
-		const expanded: string[] = [];
-		let foundModeStr = false;
-		for (const a of args) {
-			if (/^-[a-zA-Z]{2,}$/.test(a)) {
-				// -czf style
-				for (const ch of a.slice(1)) expanded.push(`-${ch}`);
-			} else if (!foundModeStr && /^[cxtdru]{1,}[a-zA-Z]*$/.test(a) && !a.includes("/") && !a.startsWith("-")) {
-				// czf bare style (first non-path arg)
-				foundModeStr = true;
-				for (const ch of a) expanded.push(`-${ch}`);
-			} else {
-				expanded.push(a);
-			}
-		}
-
-		const create  = expanded.includes("-c");
-		const extract = expanded.includes("-x");
-		const list    = expanded.includes("-t");
-		const fIdx    = expanded.indexOf("-f");
-		const archiveName = fIdx !== -1
-			? expanded[fIdx + 1]
-			: expanded.find((a) => a.endsWith(".tar") || a.endsWith(".tar.gz") || a.endsWith(".tgz"));
-
-		if (!create && !extract && !list) {
-			return { stderr: "tar: must specify -c, -x, or -t\n", exitCode: 1 };
-		}
-
-		if (!archiveName)
-			return { stderr: "tar: no archive specified\n", exitCode: 1 };
-		const archivePath = resolvePath(cwd, archiveName);
-
-		if (create) {
-			// Skip flags and archive name from file list
-			const skipNext2 = new Set<number>();
-			if (fIdx !== -1) skipNext2.add(fIdx + 1);
-			const fileArgs = expanded.filter((a, i) =>
-				!a.startsWith("-") && a !== archiveName && !skipNext2.has(i),
-			);
-			const entries: Record<string, string> = {};
-			for (const f of fileArgs) {
-				const p = resolvePath(cwd, f);
-				try {
-					const stat = shell.vfs.stat(p);
-					if (stat.type === "file") entries[f] = shell.vfs.readFile(p);
-					else {
-						const walk = (dir: string, prefix: string) => {
-							for (const e of shell.vfs.list(dir)) {
-								const full = `${dir}/${e}`,
-									rel = `${prefix}/${e}`;
-								const s = shell.vfs.stat(full);
-								if (s.type === "file") entries[rel] = shell.vfs.readFile(full);
-								else walk(full, rel);
-							}
-						};
-						walk(p, f);
-					}
-				} catch {
-					return {
-						stderr: `tar: ${f}: No such file or directory`,
-						exitCode: 1,
-					};
-				}
-			}
-			shell.writeFileAsUser(authUser, archivePath, JSON.stringify(entries));
-			return { exitCode: 0 };
-		}
-
-		if (list || extract) {
-			let entries: Record<string, string>;
-			try {
-				entries = JSON.parse(shell.vfs.readFile(archivePath));
-			} catch {
-				return {
-					stderr: `tar: ${archiveName}: cannot open archive`,
-					exitCode: 1,
-				};
-			}
-			if (list) return { stdout: Object.keys(entries).join("\n"), exitCode: 0 };
-			for (const [name, content] of Object.entries(entries)) {
-				shell.writeFileAsUser(authUser, resolvePath(cwd, name), content);
-			}
-			return { exitCode: 0 };
-		}
-
-		return { stderr: "tar: must specify -c, -x, or -t", exitCode: 1 };
-	},
-};

package/src/commands/tee.ts

@@ -1,36 +0,0 @@
-import type { ShellModule } from "../types/commands";
-import { ifFlag } from "./command-helpers";
-import { resolvePath } from "./helpers";
-
-/**
- * Read stdin and write to stdout and files simultaneously.
- * @category text
- * @params ["[-a] <file...>"]
- */
-export const teeCommand: ShellModule = {
-	name: "tee",
-	description: "Read stdin, write to stdout and files",
-	category: "text",
-	params: ["[-a] <file...>"],
-	run: ({ authUser, shell, cwd, args, stdin }) => {
-		const append = ifFlag(args, ["-a"]);
-		const files = args.filter((a) => !a.startsWith("-"));
-		const input = stdin ?? "";
-		for (const f of files) {
-			const p = resolvePath(cwd, f);
-			if (append) {
-				const existing = (() => {
-					try {
-						return shell.vfs.readFile(p);
-					} catch {
-						return "";
-					}
-				})();
-				shell.writeFileAsUser(authUser, p, existing + input);
-			} else {
-				shell.writeFileAsUser(authUser, p, input);
-			}
-		}
-		return { stdout: input, exitCode: 0 };
-	},
-};

package/src/commands/test.ts

@@ -1,137 +0,0 @@
-import type { ShellModule } from "../types/commands";
-import type { VfsFileNode } from "../types/vfs";
-import type { VirtualShell } from "../VirtualShell";
-
-/**
- * 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: 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 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/touch.ts

@@ -1,28 +0,0 @@
-import type { ShellModule } from "../types/commands";
-import { assertPathAccess, resolvePath } from "./helpers";
-
-/**
- * Create empty files or update file timestamps.
- * @category files
- * @params ["<file>"]
- */
-export const touchCommand: ShellModule = {
-	name: "touch",
-	description: "Create or update files",
-	category: "files",
-	params: ["<file>"],
-	run: ({ authUser, shell, cwd, args }) => {
-		if (args.length === 0) {
-			return { stderr: "touch: missing file operand", exitCode: 1 };
-		}
-
-		for (const file of args) {
-			const target = resolvePath(cwd, file);
-			assertPathAccess(authUser, target, "touch");
-			if (!shell.vfs.exists(target)) {
-				shell.writeFileAsUser(authUser, target, "");
-			}
-		}
-		return { exitCode: 0 };
-	},
-};

package/src/commands/tr.ts

@@ -1,70 +0,0 @@
-import type { ShellModule } from "../types/commands";
-import { ifFlag } from "./command-helpers";
-
-function unescapeTrSet(s: string): string {
-	return s
-		.replace(/\\n/g, "\n")
-		.replace(/\\t/g, "\t")
-		.replace(/\\r/g, "\r")
-		.replace(/\\\\/g, "\\");
-}
-
-function expandTrSet(s: string): string[] {
-	const chars: string[] = [];
-	const unescaped = unescapeTrSet(s);
-	let i = 0;
-	while (i < unescaped.length) {
-		// Range: a-z, A-Z, 0-9
-		if (i + 2 < unescaped.length && unescaped[i + 1] === "-") {
-			const from = unescaped.charCodeAt(i);
-			const to   = unescaped.charCodeAt(i + 2);
-			if (from <= to) {
-				for (let c = from; c <= to; c++) chars.push(String.fromCharCode(c));
-				i += 3;
-				continue;
-			}
-		}
-		chars.push(unescaped[i]!);
-		i++;
-	}
-	return chars;
-}
-
-export const trCommand: ShellModule = {
-	name: "tr",
-	description: "Translate or delete characters",
-	category: "text",
-	params: ["[-d] [-s] <set1> [set2]"],
-	run: ({ args, stdin }) => {
-		const del     = ifFlag(args, ["-d"]);
-		const squeeze = ifFlag(args, ["-s"]);
-		const positionals = args.filter((a) => !a.startsWith("-"));
-		const set1chars = expandTrSet(positionals[0] ?? "");
-		const set2chars = expandTrSet(positionals[1] ?? "");
-
-		let input = stdin ?? "";
-
-		if (del) {
-			const deleteSet = new Set(set1chars);
-			input = [...input].filter((c) => !deleteSet.has(c)).join("");
-		} else if (set2chars.length > 0) {
-			// Build translation map
-			const map = new Map<string, string>();
-			for (let i = 0; i < set1chars.length; i++) {
-				map.set(
-					set1chars[i]!,
-					set2chars[i] ?? set2chars[set2chars.length - 1] ?? "",
-				);
-			}
-			input = [...input].map((c) => map.get(c) ?? c).join("");
-		}
-
-		if (squeeze && set2chars.length > 0) {
-			// Squeeze repeated characters in set2
-			const squeezeSet = new Set(set2chars);
-			input = input.replace(/(.)\1+/g, (_, c) => squeezeSet.has(c) ? c : _);
-		}
-
-		return { stdout: input, exitCode: 0 };
-	},
-};

package/src/commands/tree.ts

@@ -1,20 +0,0 @@
-import type { ShellModule } from "../types/commands";
-import { getArg } from "./command-helpers";
-import { assertPathAccess, resolvePath } from "./helpers";
-
-/**
- * Display directory structure in a tree format.
- * @category navigation
- * @params ["[path]"]
- */
-export const treeCommand: ShellModule = {
-	name: "tree",
-	description: "Display directory tree",
-	category: "navigation",
-	params: ["[path]"],
-	run: ({ authUser, shell, cwd, args }) => {
-		const target = resolvePath(cwd, getArg(args, 0) ?? cwd);
-		assertPathAccess(authUser, target, "tree");
-		return { stdout: shell.vfs.tree(target), exitCode: 0 };
-	},
-};

package/src/commands/true.ts

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