typescript-virtual-container 1.3.4 → 1.4.0

package/src/commands/adduser.ts

@@ -1,30 +1,103 @@
-import type { ShellModule } from "../types/commands";
+import type { CommandResult, ShellModule } from "../types/commands";
+import type { VirtualShell } from "../VirtualShell";
 
 /**
- * Add a new user to the virtual user database.
- * @category users
- * @params ["<username> <password>"]
- * @returns ShellModule
+ * Add a new user interactively.
+ *
+ * Usage: `adduser <username>`
+ *
+ * Prompts for:
+ *   New password: ****
+ *   Retype new password: ****
+ *
+ * Mirrors the real `adduser` behaviour — password is never passed on the
+ * command line. Root-only.
  */
 export const adduserCommand: ShellModule = {
 	name: "adduser",
 	description: "Add a new user",
 	category: "users",
-	params: ["<username> <password>"],
-	run: async ({ authUser, shell, args }) => {
+	params: ["<username>"],
+	run: ({ authUser, shell, args }) => {
 		if (authUser !== "root") {
-			return { stderr: "adduser: permission denied", exitCode: 1 };
+			return { stderr: "adduser: permission denied\n", exitCode: 1 };
 		}
 
-		const [username, password] = args;
-		if (!username || !password) {
+		const username = args[0];
+		if (!username) {
 			return {
-				stderr: "adduser: usage: adduser <username> <password>",
+				stderr: "Usage: adduser <username>\n",
 				exitCode: 1,
 			};
 		}
 
-		await shell.users.addUser(username, password);
-		return { stdout: `adduser: user '${username}' created`, exitCode: 0 };
+		// Reject if user already exists
+		if (shell.users.listUsers().includes(username)) {
+			return {
+				stderr: `adduser: user '${username}' already exists\n`,
+				exitCode: 1,
+			};
+		}
+
+		let newPassword = "";
+		type Step = "new" | "retype";
+		let step: Step = "new";
+
+		const onPassword = async (
+			input: string,
+			sh: VirtualShell,
+		): Promise<{ result: CommandResult | null; nextPrompt?: string }> => {
+			if (step === "new") {
+				if (input.length < 1) {
+					return {
+						result: {
+							stderr: "adduser: password cannot be empty\n",
+							exitCode: 1,
+						},
+					};
+				}
+				newPassword = input;
+				step = "retype";
+				return { result: null, nextPrompt: "Retype new password: " };
+			}
+
+			// step === "retype"
+			if (input !== newPassword) {
+				return {
+					result: {
+						stderr: "adduser: passwords do not match — user not created\n",
+						exitCode: 1,
+					},
+				};
+			}
+
+			await sh.users.addUser(username, newPassword);
+			return {
+				result: {
+					stdout: `${[
+						`Adding user '${username}' ...`,
+						`Adding new group '${username}' (1001) ...`,
+						`Adding new user '${username}' (1001) with group '${username}' ...`,
+						`Creating home directory '/home/${username}' ...`,
+						`passwd: password set for '${username}'`,
+						`adduser: done.`,
+					].join("\n")}\n`,
+					exitCode: 0,
+				},
+			};
+		};
+
+		return {
+			sudoChallenge: {
+				username,
+				targetUser: username,
+				commandLine: null,
+				loginShell: false,
+				prompt: "New password: ",
+				mode: "passwd",
+				onPassword,
+			},
+			exitCode: 0,
+		};
 	},
 };

package/src/commands/alias.ts

@@ -41,6 +41,11 @@ export const aliasCommand: ShellModule = {
 	},
 };
 
+/**
+ * Remove shell aliases.
+ * @category shell
+ * @params ["<name...>"]
+ */
 export const unaliasCommand: ShellModule = {
 	name: "unalias",
 	description: "Remove alias definitions",

package/src/commands/apt.ts

@@ -162,6 +162,11 @@ export const aptCommand: ShellModule = {
 	},
 };
 
+/**
+ * Query the package cache and retrieve package information.
+ * @category package
+ * @params ["<search|show|policy> [pkg]"]
+ */
 export const aptCacheCommand: ShellModule = {
 	name: "apt-cache",
 	description: "Query the package cache",

package/src/commands/awk.ts

@@ -1,44 +1,169 @@
 import type { ShellModule } from "../types/commands";
 import { getFlag } from "./command-helpers";
+import { resolvePath, assertPathAccess } from "./helpers";
 
 /**
- * Minimal `awk`-like pattern scanner (supports simple print patterns).
- * @category text
- * @params ["[-F <sep>] '<program>' [file]"]
+ * Minimal awk-like pattern scanner.
  *
- * Supported program patterns:
- * - `print $N` (e.g. `print $1`, `print $2, $3`, `print $0`)
- * - `{print $N}` (e.g. `{print $1}`, `{print $2, $3}`, `{print $0}`)
- *
- * The field separator can be set with `-F` (default is space, which splits on any whitespace).
+ * Supported:
+ *   - `NR==N` pattern (line number condition)
+ *   - `NF` (number of fields)
+ *   - `/regex/` pattern
+ *   - `{ print $N, $M, ... }` action
+ *   - `{ print }` / `{ print $0 }`
+ *   - `BEGIN { ... }` and `END { ... }` blocks (no side effects)
+ *   - `$NF` (last field)
+ *   - `-F sep` field separator
  */
 export const awkCommand: ShellModule = {
 	name: "awk",
-	description: "Pattern scanning and processing language (minimal)",
+	description: "Pattern scanning and processing language",
 	category: "text",
 	params: ["[-F <sep>] '<program>' [file]"],
-	run: ({ args, stdin }) => {
+	run: ({ authUser, args, stdin, cwd, shell }) => {
 		const sep = (getFlag(args, ["-F"]) as string | undefined) ?? " ";
-		const prog = args.find((a) => !a.startsWith("-") && a !== sep);
+		const nonFlagArgs = args.filter((a) => !a.startsWith("-") && a !== sep);
+		const prog = nonFlagArgs[0];
+		const fileArg = nonFlagArgs[1];
+
 		if (!prog) return { stderr: "awk: no program", exitCode: 1 };
 
-		// Only support print $N and {print $N} patterns
-		const printMatch = prog.match(/^\{?\s*print\s+([^}]+)\s*\}?$/);
-		if (!printMatch)
-			return { stderr: `awk: unsupported program: ${prog}`, exitCode: 1 };
-
-		const fields = printMatch[1]!.split(/\s*,\s*/).map((f) => f.trim());
-		const lines = (stdin ?? "").split("\n").filter(Boolean);
-		const out = lines.map((line) => {
-			const parts = line.split(sep === " " ? /\s+/ : sep);
-			return fields
-				.map((f) => {
-					if (f === "$0") return line;
-					const n = parseInt(f.replace("$", ""), 10);
-					return Number.isNaN(n) ? f.replace(/"/g, "") : (parts[n - 1] ?? "");
-				})
-				.join(sep === " " ? "\t" : sep);
-		});
-		return { stdout: out.join("\n"), exitCode: 0 };
+		let input = stdin ?? "";
+		if (fileArg) {
+			const filePath = resolvePath(cwd, fileArg);
+			try {
+				assertPathAccess(authUser, filePath, "awk");
+				input = shell.vfs.readFile(filePath);
+			} catch {
+				return { stderr: `awk: ${fileArg}: No such file or directory`, exitCode: 1 };
+			}
+		}
+
+		const lines = input.split("\n");
+		// Remove empty last element if input ends with \n
+		if (lines[lines.length - 1] === "") lines.pop();
+
+		// Parse program into clauses: [pattern, action]
+		type Clause = { pattern: string; action: string };
+		const clauses: Clause[] = [];
+
+		const progTrim = prog.trim();
+
+		// Handle single unbraced pattern (NR==2, /regex/)
+		if (!progTrim.startsWith("{") && !progTrim.includes("{")) {
+			clauses.push({ pattern: progTrim, action: "print $0" });
+		} else {
+			// Parse "pattern { action } pattern2 { action2 }"
+			const clauseRe = /([^{]*)\{([^}]*)\}/g;
+			let m2 = clauseRe.exec(progTrim);
+			while (m2 !== null) {
+				clauses.push({ pattern: m2[1]!.trim(), action: m2[2]!.trim() });
+				m2 = clauseRe.exec(progTrim);
+			}
+			if (clauses.length === 0) {
+				clauses.push({ pattern: "", action: progTrim.replace(/[{}]/g, "").trim() });
+			}
+		}
+
+		const out: string[] = [];
+
+		// BEGIN / END
+		const beginClause = clauses.find((c) => c.pattern === "BEGIN");
+		const endClause   = clauses.find((c) => c.pattern === "END");
+		const mainClauses = clauses.filter((c) => c.pattern !== "BEGIN" && c.pattern !== "END");
+
+		function splitFields(line: string): string[] {
+			if (sep === " ") return line.trim().split(/\s+/).filter(Boolean);
+			return line.split(sep);
+		}
+
+		function evalAction(action: string, line: string, nr: number): void {
+			const parts = splitFields(line);
+			const nf = parts.length;
+
+			// Expand variables
+			const resolve = (expr: string): string => {
+				expr = expr.trim();
+				if (expr === "NR") return String(nr);
+				if (expr === "NF") return String(nf);
+				if (expr === "$0") return line;
+				if (expr === "$NF") return parts[nf - 1] ?? "";
+				if (/^\$\d+$/.test(expr)) return parts[parseInt(expr.slice(1), 10) - 1] ?? "";
+				// Arithmetic NR+1, NF-1
+				const arith = expr.replace(/\bNR\b/g, String(nr)).replace(/\bNF\b/g, String(nf));
+				if (/^[\d\s+\-*/()]+$/.test(arith)) {
+					// biome-ignore lint/security/noGlobalEval: safe arithmetic — input contains only digits and operators after variable substitution
+					try { return String(Function(`"use strict"; return (${arith});`)()); } catch {}  				}
+				return expr.replace(/"/g, "");
+			};
+
+			const stmts = action.split(";").map((s) => s.trim()).filter(Boolean);
+			for (const stmt of stmts) {
+				if (stmt === "print" || stmt === "print $0") {
+					out.push(line);
+				} else if (stmt.startsWith("print ")) {
+					const args2 = stmt.slice(6).split(/\s*,\s*/);
+					out.push(args2.map(resolve).join("\t"));
+				}
+			}
+		}
+
+		function matchPattern(pattern: string, line: string, nr: number): boolean {
+			if (!pattern) return true;
+			if (pattern === "1") return true;
+
+			// NR==N or NR>N etc.
+			const nrCond = pattern.match(/^NR\s*([=!<>]=?|==)\s*(\d+)$/);
+			if (nrCond) {
+				const op = nrCond[1]!;
+				const val = parseInt(nrCond[2]!, 10);
+				switch (op) {
+					case "==": return nr === val;
+					case "!=": return nr !== val;
+					case ">":  return nr > val;
+					case ">=": return nr >= val;
+					case "<":  return nr < val;
+					case "<=": return nr <= val;
+				}
+			}
+
+			// NR%N==M
+			const nrMod = pattern.match(/^NR%(\d+)==(\d+)$/);
+			if (nrMod) {
+				return nr % parseInt(nrMod[1]!, 10) === parseInt(nrMod[2]!, 10);
+			}
+
+			// /regex/ pattern
+			if (pattern.startsWith("/") && pattern.endsWith("/")) {
+				try {
+					return new RegExp(pattern.slice(1, -1)).test(line);
+				} catch { return false; }
+			}
+
+			// $N~/regex/
+			const fieldMatch = pattern.match(/^\$(\d+)~\/(.*)\/$/);
+			if (fieldMatch) {
+				const parts = splitFields(line);
+				const field = parts[parseInt(fieldMatch[1]!, 10) - 1] ?? "";
+				try { return new RegExp(fieldMatch[2]!).test(field); } catch { return false; }
+			}
+
+			return false;
+		}
+
+		if (beginClause) evalAction(beginClause.action, "", 0);
+
+		for (let nr = 1; nr <= lines.length; nr++) {
+			const line = lines[nr - 1]!;
+			for (const clause of mainClauses) {
+				if (matchPattern(clause.pattern, line, nr)) {
+					evalAction(clause.action, line, nr);
+				}
+			}
+		}
+
+		if (endClause) evalAction(endClause.action, "", lines.length + 1);
+
+		return { stdout: out.join("\n") + (out.length > 0 ? "\n" : ""), exitCode: 0 };
 	},
 };

package/src/commands/cd.ts

@@ -19,10 +19,6 @@ export const cdCommand: ShellModule = {
 			return { stderr: `cd: not a directory: ${target}`, exitCode: 1 };
 		}
 
-		if (mode === "exec") {
-			return { exitCode: 0 };
-		}
-
 		return { nextCwd: target, exitCode: 0 };
 	},
 };

package/src/commands/clear.ts

@@ -1,5 +1,10 @@
 import type { ShellModule } from "../types/commands";
 
+/**
+ * Clear the terminal screen.
+ * @category shell
+ * @params []
+ */
 export const clearCommand: ShellModule = {
 	name: "clear",
 	description: "Clear the terminal screen",

package/src/commands/command-helpers.ts

@@ -15,11 +15,20 @@ function matchFlagToken(
 		return { matched: true, inlineValue: null };
 	}
 
+	// --flag=value style
 	const prefix = `${flag}=`;
 	if (token.startsWith(prefix)) {
 		return { matched: true, inlineValue: token.slice(prefix.length) };
 	}
 
+	// Short flag inline value: -f2, -d: (single char flag like -f, -d, -n)
+	// Only applies to single-char flags (-X), not long flags (--flag)
+	if (flag.length === 2 && flag.startsWith("-") && !flag.startsWith("--")) {
+		if (token.startsWith(flag) && token.length > flag.length) {
+			return { matched: true, inlineValue: token.slice(flag.length) };
+		}
+	}
+
 	return { matched: false, inlineValue: null };
 }
 

package/src/commands/declare.ts

@@ -1,6 +1,11 @@
 import type { ShellModule } from "../types/commands";
 import { ifFlag } from "./command-helpers";
 
+/**
+ * Declare variables and give them attributes (integer, readonly, export, array).
+ * @category shell
+ * @params ["[-i] [-r] [-x] [-a] [name[=value]...]"]
+ */
 export const declareCommand: ShellModule = {
 	name: "declare",
 	aliases: ["local", "typeset"],

package/src/commands/deluser.ts

@@ -1,21 +1,98 @@
-import type { ShellModule } from "../types/commands";
+import type { CommandResult, ShellModule } from "../types/commands";
+import type { VirtualShell } from "../VirtualShell";
 
+/**
+ * Delete a user. Root-only.
+ *
+ * Without `-f`: prompts for confirmation — the user must type the exact
+ * username to proceed.
+ *
+ * With `-f` / `--force`: deletes without confirmation.
+ *
+ * Usage:
+ *   deluser <username>
+ *   deluser -f <username>
+ */
 export const deluserCommand: ShellModule = {
 	name: "deluser",
 	description: "Delete a user",
 	category: "users",
-	params: ["<username>"],
+	params: ["[-f] <username>"],
 	run: async ({ authUser, args, shell }) => {
 		if (authUser !== "root") {
-			return { stderr: "deluser: permission denied", exitCode: 1 };
+			return { stderr: "deluser: permission denied\n", exitCode: 1 };
 		}
 
-		const [username] = args;
+		const force =
+			args.includes("-f") ||
+			args.includes("--force") ||
+			args.includes("-y");
+		const username = args.find((a) => !a.startsWith("-"));
+
 		if (!username) {
-			return { stderr: "deluser: usage: deluser <username>", exitCode: 1 };
+			return {
+				stderr: "Usage: deluser [-f] <username>\n",
+				exitCode: 1,
+			};
+		}
+
+		if (!shell.users.listUsers().includes(username)) {
+			return {
+				stderr: `deluser: user '${username}' does not exist\n`,
+				exitCode: 1,
+			};
+		}
+
+		if (username === "root") {
+			return {
+				stderr: "deluser: cannot remove the root account\n",
+				exitCode: 1,
+			};
 		}
 
-		await shell.users.deleteUser(username);
-		return { stdout: `deluser: user '${username}' deleted`, exitCode: 0 };
+		// Force mode — delete without confirmation
+		if (force) {
+			await shell.users.deleteUser(username);
+			return {
+				stdout: `Removing user '${username}' ...\ndeluser: done.\n`,
+				exitCode: 0,
+			};
+		}
+
+		// Interactive confirmation
+		const onPassword = async (
+			input: string,
+			sh: VirtualShell,
+		): Promise<{ result: CommandResult | null; nextPrompt?: string }> => {
+			if (input.trim() !== username) {
+				return {
+					result: {
+						stderr: "deluser: confirmation did not match — user not deleted\n",
+						exitCode: 1,
+					},
+				};
+			}
+
+			await sh.users.deleteUser(username);
+			return {
+				result: {
+					stdout: `Removing user '${username}' ...\ndeluser: done.\n`,
+					exitCode: 0,
+				},
+			};
+		};
+
+		return {
+			sudoChallenge: {
+				username,
+				targetUser: username,
+				commandLine: null,
+				loginShell: false,
+				prompt: `Warning: deleting user '${username}'.\nType the username to confirm: `,
+				mode: "confirm",
+				onPassword,
+			},
+			exitCode: 0,
+		};
 	},
 };

package/src/commands/df.ts

@@ -1,5 +1,10 @@
 import type { ShellModule } from "../types/commands";
 
+/**
+ * Report filesystem disk space usage.
+ * @category system
+ * @params ["[-h]"]
+ */
 export const dfCommand: ShellModule = {
 	name: "df",
 	description: "Report filesystem disk space usage",

package/src/commands/du.ts

@@ -2,6 +2,11 @@ import type { ShellModule } from "../types/commands";
 import { ifFlag } from "./command-helpers";
 import { resolvePath } from "./helpers";
 
+/**
+ * Estimate file and directory space usage.
+ * @category system
+ * @params ["[-h] [-s] [path]"]
+ */
 export const duCommand: ShellModule = {
 	name: "du",
 	description: "Estimate file space usage",

package/src/commands/export.ts

@@ -1,5 +1,10 @@
 import type { ShellModule } from "../types/commands";
 
+/**
+ * Set or display shell environment variables for child processes.
+ * @category shell
+ * @params ["[VAR=value]"]
+ */
 export const exportCommand: ShellModule = {
 	name: "export",
 	description: "Set shell environment variable",

package/src/commands/grep.ts

@@ -14,12 +14,15 @@ export const grepCommand: ShellModule = {
 	params: ["[-i] [-v] [-n] [-r] <pattern> [file...]"],
 	run: ({ authUser, shell, cwd, args, stdin }) => {
 		const { flags, positionals } = parseArgs(args, {
-			flags: ["-i", "-v", "-n", "-r"],
+			flags: ["-i", "-v", "-n", "-r", "-c", "-l", "-L", "-q", "--quiet", "--silent"],
 		});
-		const caseInsensitive = flags.has("-i");
-		const invertMatch = flags.has("-v");
-		const showLineNumbers = flags.has("-n");
-		const recursive = flags.has("-r");
+		const caseInsensitive  = flags.has("-i");
+		const invertMatch      = flags.has("-v");
+		const showLineNumbers  = flags.has("-n");
+		const recursive        = flags.has("-r");
+		const countOnly        = flags.has("-c");
+		const filesWithMatches = flags.has("-l");
+		const quiet            = flags.has("-q") || flags.has("--quiet") || flags.has("--silent");
 		const pattern = positionals[0];
 		const files = positionals.slice(1);
 
@@ -73,7 +76,10 @@ export const grepCommand: ShellModule = {
 
 		if (files.length === 0) {
 			if (!stdin) return { stdout: "", exitCode: 1 };
-			results.push(...matchLines(stdin));
+			const matched = matchLines(stdin);
+			if (countOnly) return { stdout: `${matched.length}\n`, exitCode: matched.length > 0 ? 0 : 1 };
+			if (quiet) return { exitCode: matched.length > 0 ? 0 : 1 };
+			results.push(...matched);
 		} else {
 			const resolvedPaths = files.flatMap((f) => {
 				const target = resolvePath(cwd, f);
@@ -85,7 +91,14 @@ export const grepCommand: ShellModule = {
 					assertPathAccess(authUser, filePath, "grep");
 					const content = shell.vfs.readFile(filePath);
 					const prefix = resolvedPaths.length > 1 ? `${file}:` : "";
-					results.push(...matchLines(content, prefix));
+					const matched = matchLines(content, prefix);
+					if (countOnly) {
+						results.push(resolvedPaths.length > 1 ? `${file}:${matched.length}` : String(matched.length));
+					} else if (filesWithMatches) {
+						if (matched.length > 0) results.push(file);
+					} else {
+						results.push(...matched);
+					}
 				} catch {
 					return {
 						stderr: `grep: ${file}: No such file or directory`,
@@ -96,7 +109,7 @@ export const grepCommand: ShellModule = {
 		}
 
 		return {
-			stdout: results.length > 0 ? results.join("\n") : "",
+			stdout: results.length > 0 ? `${results.join("\n")}\n` : "",
 			exitCode: results.length > 0 ? 0 : 1,
 		};
 	},

package/src/commands/groups.ts

@@ -1,5 +1,10 @@
 import type { ShellModule } from "../types/commands";
 
+/**
+ * Print group memberships for a user.
+ * @category system
+ * @params ["[user]"]
+ */
 export const groupsCommand: ShellModule = {
 	name: "groups",
 	description: "Print group memberships",