typescript-virtual-container 1.5.2 → 1.5.4

package/src/commands/sort.ts

@@ -1,46 +0,0 @@
-import type { ShellModule } from "../types/commands";
-import { ifFlag } from "./command-helpers";
-import { assertPathAccess, resolvePath } from "./helpers";
-
-/**
- * Sort lines of text with various options (reverse, numeric, unique).
- * @category text
- * @params ["[-r] [-n] [-u] [-k <col>] [file...]"]
- */
-export const sortCommand: ShellModule = {
-	name: "sort",
-	description: "Sort lines of text",
-	category: "text",
-	params: ["[-r] [-n] [-u] [-k <col>] [file...]"],
-	run: ({ authUser, shell, cwd, args, stdin }) => {
-		const reverse = ifFlag(args, ["-r"]);
-		const numeric = ifFlag(args, ["-n"]);
-		const unique = ifFlag(args, ["-u"]);
-		const files = args.filter((a) => !a.startsWith("-"));
-
-		const getContent = (): string => {
-			if (files.length > 0) {
-				return files
-					.map((f) => {
-						try {
-							assertPathAccess(authUser, resolvePath(cwd, f), "sort");
-							return shell.vfs.readFile(resolvePath(cwd, f));
-						} catch {
-							return "";
-						}
-					})
-					.join("\n");
-			}
-			return stdin ?? "";
-		};
-
-		const lines = getContent().split("\n").filter(Boolean);
-		const sorted = [...lines].sort((a, b) => {
-			if (numeric) return Number(a) - Number(b);
-			return a.localeCompare(b);
-		});
-		const result = reverse ? sorted.reverse() : sorted;
-		const out = unique ? [...new Set(result)] : result;
-		return { stdout: out.join("\n"), exitCode: 0 };
-	},
-};

package/src/commands/source.ts

@@ -1,52 +0,0 @@
-import type { ShellModule } from "../types/commands";
-import { resolvePath } from "./helpers";
-import { runCommand } from "./runtime";
-
-/**
- * Execute commands from a file in the current shell environment.
- * @category shell
- * @params ["<file> [args...]"]
- */
-export const sourceCommand: ShellModule = {
-	name: "source",
-	aliases: ["."],
-	description: "Execute commands from a file in the current shell environment",
-	category: "shell",
-	params: ["<file> [args...]"],
-	run: async ({ args, authUser, hostname, cwd, shell, env }) => {
-		const fileArg = args[0];
-		if (!fileArg) {
-			return { stderr: "source: missing filename", exitCode: 1 };
-		}
-
-		const filePath = resolvePath(cwd, fileArg);
-		if (!shell.vfs.exists(filePath)) {
-			return {
-				stderr: `source: ${fileArg}: No such file or directory`,
-				exitCode: 1,
-			};
-		}
-
-		const content = shell.vfs.readFile(filePath);
-		let lastExitCode = 0;
-
-		for (const line of content.split("\n")) {
-			const l = line.trim();
-			if (!l || l.startsWith("#")) continue;
-			const result = await runCommand(
-				l,
-				authUser,
-				hostname,
-				"shell",
-				cwd,
-				shell,
-				undefined,
-				env,
-			);
-			lastExitCode = result.exitCode ?? 0;
-			if (result.closeSession || result.switchUser) return result;
-		}
-
-		return { exitCode: lastExitCode };
-	},
-};

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