typescript-virtual-container 1.5.3 → 1.5.4

package/src/bun.d.ts

@@ -1 +0,0 @@
-/// <reference types="@types/bun" />

package/src/commands/adduser.ts

@@ -1,103 +0,0 @@
-import type { CommandResult, ShellModule } from "../types/commands";
-import type { VirtualShell } from "../VirtualShell";
-
-/**
- * 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>"],
-	run: ({ authUser, shell, args }) => {
-		if (authUser !== "root") {
-			return { stderr: "adduser: permission denied\n", exitCode: 1 };
-		}
-
-		const username = args[0];
-		if (!username) {
-			return {
-				stderr: "Usage: adduser <username>\n",
-				exitCode: 1,
-			};
-		}
-
-		// 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

@@ -1,69 +0,0 @@
-import type { ShellModule } from "../types/commands";
-import { ifFlag } from "./command-helpers";
-/**
- * Manage shell aliases (list / set / remove).
- * @category shell
- * @params ["[name[=value] ...]"]
- */
-export const aliasCommand: ShellModule = {
-	name: "alias",
-	description: "Define or display aliases",
-	category: "shell",
-	params: ["[name[=value] ...]"],
-	run: ({ args, env }) => {
-		if (!env) return { exitCode: 0 };
-
-		// Aliases stored in env.vars under prefix __alias_
-		if (args.length === 0) {
-			const aliases = Object.entries(env.vars)
-				.filter(([k]) => k.startsWith("__alias_"))
-				.map(([k, v]) => `alias ${k.slice("__alias_".length)}='${v}'`);
-			return { stdout: aliases.join("\n") || "", exitCode: 0 };
-		}
-
-		const lines: string[] = [];
-		for (const arg of args) {
-			const eq = arg.indexOf("=");
-			if (eq === -1) {
-				// Display single alias
-				const val = env.vars[`__alias_${arg}`];
-				if (val) lines.push(`alias ${arg}='${val}'`);
-				else return { stderr: `alias: ${arg}: not found`, exitCode: 1 };
-			} else {
-				// Set alias
-				const name = arg.slice(0, eq);
-				const val = arg.slice(eq + 1).replace(/^['"]|['"]$/g, "");
-				env.vars[`__alias_${name}`] = val;
-			}
-		}
-
-		return { stdout: lines.join("\n") || undefined, exitCode: 0 };
-	},
-};
-
-/**
- * Remove shell aliases.
- * @category shell
- * @params ["<name...>"]
- */
-export const unaliasCommand: ShellModule = {
-	name: "unalias",
-	description: "Remove alias definitions",
-	category: "shell",
-	params: ["<name...> | -a"],
-	run: ({ args, env }) => {
-		if (!env) return { exitCode: 0 };
-
-		if (ifFlag(args, ["-a"])) {
-			for (const k of Object.keys(env.vars)) {
-				if (k.startsWith("__alias_")) delete env.vars[k];
-			}
-			return { exitCode: 0 };
-		}
-
-		for (const name of args) {
-			delete env.vars[`__alias_${name}`];
-		}
-		return { exitCode: 0 };
-	},
-};

package/src/commands/apt.ts

@@ -1,233 +0,0 @@
-import type { ShellModule } from "../types/commands";
-import { ifFlag } from "./command-helpers";
-import { getPackageManager } from "./helpers";
-
-/**
- * APT package manager front-end (simulated).
- * @category package
- * @params ["<install|remove|update|upgrade|search|show|list> [pkg...]"]
- */
-export const aptCommand: ShellModule = {
-	name: "apt",
-	aliases: ["apt-get"],
-	description: "Package manager",
-	category: "package",
-	params: ["<install|remove|update|upgrade|search|show|list> [pkg...]"],
-	run: ({ args, shell, authUser }) => {
-		const pm = getPackageManager(shell);
-		if (!pm)
-			return { stderr: "apt: package manager not initialised", exitCode: 1 };
-
-		const sub = args[0]?.toLowerCase();
-		const rest = args.slice(1);
-
-		const quiet = ifFlag(rest, ["-q", "--quiet", "-qq"]);
-		const purge = ifFlag(rest, ["--purge"]);
-		const pkgs = rest.filter((a) => !a.startsWith("-"));
-
-		// Non-root check
-		const restricted = ["install", "remove", "purge", "upgrade", "update"];
-		if (restricted.includes(sub ?? "") && authUser !== "root") {
-			return {
-				stderr:
-					"E: Could not open lock file /var/lib/dpkg/lock-frontend - open (13: Permission denied)\nE: Unable to acquire the dpkg frontend lock, are you root?",
-				exitCode: 100,
-			};
-		}
-
-		switch (sub) {
-			case "install": {
-				if (pkgs.length === 0)
-					return { stderr: "apt: no packages specified", exitCode: 1 };
-				const { output, exitCode } = pm.install(pkgs, { quiet });
-				return { stdout: output || undefined, exitCode };
-			}
-
-			case "remove":
-			case "purge": {
-				if (pkgs.length === 0)
-					return { stderr: "apt: no packages specified", exitCode: 1 };
-				const { output, exitCode } = pm.remove(pkgs, {
-					purge: sub === "purge" || purge,
-					quiet,
-				});
-				return { stdout: output || undefined, exitCode };
-			}
-
-			case "update": {
-				return {
-					stdout: [
-						"Hit:1 fortune://packages.fortune.local nyx InRelease",
-						"Hit:2 fortune://security.fortune.local nyx-security InRelease",
-						"Reading package lists... Done",
-						"Building dependency tree... Done",
-						"Reading state information... Done",
-						`All packages are up to date.`,
-					].join("\n"),
-					exitCode: 0,
-				};
-			}
-
-			case "upgrade": {
-				return {
-					stdout: [
-						"Reading package lists... Done",
-						"Building dependency tree... Done",
-						"Reading state information... Done",
-						"Calculating upgrade... Done",
-						"0 upgraded, 0 newly installed, 0 to remove and 0 not upgraded.",
-					].join("\n"),
-					exitCode: 0,
-				};
-			}
-
-			case "search": {
-				const term = pkgs[0];
-				if (!term)
-					return { stderr: "apt: search requires a term", exitCode: 1 };
-				const results = pm.search(term);
-				if (results.length === 0)
-					return {
-						stdout: `Sorting... Done\nFull Text Search... Done\n(no results)`,
-						exitCode: 0,
-					};
-				const lines = results.map(
-					(p) =>
-						`${p.name}/${p.section ?? "misc"} ${p.version} amd64\n  ${p.shortDesc ?? p.description}`,
-				);
-				return {
-					stdout: `Sorting... Done\nFull Text Search... Done\n${lines.join("\n")}`,
-					exitCode: 0,
-				};
-			}
-
-			case "show": {
-				const name = pkgs[0];
-				if (!name)
-					return { stderr: "apt: show requires a package name", exitCode: 1 };
-				const info = pm.show(name);
-				if (!info)
-					return {
-						stderr: `N: Unable to locate package ${name}`,
-						exitCode: 100,
-					};
-				return { stdout: info, exitCode: 0 };
-			}
-
-			case "list": {
-				const installedFlag = ifFlag(rest, ["--installed"]);
-				if (installedFlag) {
-					const pkgList = pm.listInstalled();
-					if (pkgList.length === 0)
-						return {
-							stdout: "Listing... Done\n(no packages installed)",
-							exitCode: 0,
-						};
-					const lines = pkgList.map(
-						(p) =>
-							`${p.name}/${p.section} ${p.version} ${p.architecture} [installed]`,
-					);
-					return {
-						stdout: `Listing... Done\n${lines.join("\n")}`,
-						exitCode: 0,
-					};
-				}
-				// all available
-				const all = pm.listAvailable();
-				const lines = all.map(
-					(p) => `${p.name}/${p.section ?? "misc"} ${p.version} amd64`,
-				);
-				return { stdout: `Listing... Done\n${lines.join("\n")}`, exitCode: 0 };
-			}
-
-			default: {
-				return {
-					stdout: [
-						"Usage: apt [options] command",
-						"",
-						"Commands:",
-						"  install <pkg...>   Install packages",
-						"  remove <pkg...>    Remove packages",
-						"  purge <pkg...>     Remove packages and config files",
-						"  update             Refresh package index",
-						"  upgrade            Upgrade all packages",
-						"  search <term>      Search in package descriptions",
-						"  show <pkg>         Show package details",
-						"  list [--installed] List packages",
-					].join("\n"),
-					exitCode: 0,
-				};
-			}
-		}
-	},
-};
-
-/**
- * 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",
-	category: "package",
-	params: ["<search|show|policy> [pkg]"],
-	run: ({ args, shell }) => {
-		const pm = getPackageManager(shell);
-		if (!pm)
-			return {
-				stderr: "apt-cache: package manager not initialised",
-				exitCode: 1,
-			};
-
-		const sub = args[0]?.toLowerCase();
-		const pkgName = args[1];
-
-		switch (sub) {
-			case "search": {
-				if (!pkgName) return { stderr: "Need a search term", exitCode: 1 };
-				const results = pm.search(pkgName);
-				return {
-					stdout:
-						results
-							.map((p) => `${p.name} - ${p.shortDesc ?? p.description}`)
-							.join("\n") || "(no results)",
-					exitCode: 0,
-				};
-			}
-			case "show": {
-				if (!pkgName) return { stderr: "Need a package name", exitCode: 1 };
-				const info = pm.show(pkgName);
-				return info
-					? { stdout: info, exitCode: 0 }
-					: { stderr: `N: Unable to locate package ${pkgName}`, exitCode: 100 };
-			}
-			case "policy": {
-				if (!pkgName) return { stderr: "Need a package name", exitCode: 1 };
-				const def = pm.findInRegistry(pkgName);
-				if (!def)
-					return {
-						stderr: `N: Unable to locate package ${pkgName}`,
-						exitCode: 100,
-					};
-				const inst = pm.isInstalled(pkgName);
-				return {
-					stdout: [
-						`${pkgName}:`,
-						`  Installed: ${inst ? def.version : "(none)"}`,
-						`  Candidate: ${def.version}`,
-						`  Version table:`,
-						`     ${def.version} 500`,
-						`        500 fortune://packages.fortune.local nyx/main amd64 Packages`,
-					].join("\n"),
-					exitCode: 0,
-				};
-			}
-			default:
-				return {
-					stderr: `apt-cache: unknown command '${sub ?? ""}'`,
-					exitCode: 1,
-				};
-		}
-	},
-};

package/src/commands/awk.ts

@@ -1,168 +0,0 @@
-import type { ShellModule } from "../types/commands";
-import { getFlag } from "./command-helpers";
-import { assertPathAccess, resolvePath } from "./helpers";
-
-/**
- * Minimal awk-like pattern scanner.
- *
- * 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",
-	category: "text",
-	params: ["[-F <sep>] '<program>' [file]"],
-	run: ({ authUser, args, stdin, cwd, shell }) => {
-		const sep = (getFlag(args, ["-F"]) as string | undefined) ?? " ";
-		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 };
-
-		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)) {
-					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/base64.ts

@@ -1,29 +0,0 @@
-import type { ShellModule } from "../types/commands";
-import { ifFlag } from "./command-helpers";
-
-/**
- * Encode or decode base64 data.
- * @category text
- * @params ["[-d] [file]"]
- */
-export const base64Command: ShellModule = {
-	name: "base64",
-	description: "Encode/decode base64",
-	category: "text",
-	params: ["[-d] [file]"],
-	run: ({ args, stdin }) => {
-		const decode = ifFlag(args, ["-d", "--decode"]);
-		const input = stdin ?? "";
-		if (decode) {
-			try {
-				return {
-					stdout: Buffer.from(input.trim(), "base64").toString("utf8"),
-					exitCode: 0,
-				};
-			} catch {
-				return { stderr: "base64: invalid input", exitCode: 1 };
-			}
-		}
-		return { stdout: Buffer.from(input).toString("base64"), exitCode: 0 };
-	},
-};

package/src/commands/cat.ts

@@ -1,52 +0,0 @@
-import type { ShellModule } from "../types/commands";
-import { ifFlag } from "./command-helpers";
-import { assertPathAccess, resolveReadablePath } from "./helpers";
-
-/**
- * Concatenate and print files to stdout.
- * @category files
- * @params ["[-n] [-b] <file...>"]
- */
-export const catCommand: ShellModule = {
-	name: "cat",
-	description: "Concatenate and print files",
-	category: "files",
-	params: ["[-n] [-b] <file...>"],
-	run: ({ authUser, shell, cwd, args, stdin }) => {
-		const numberAll = ifFlag(args, ["-n", "--number"]);
-		const numberNonBlank = ifFlag(args, ["-b", "--number-nonblank"]);
-		const fileArgs = args.filter((a) => !a.startsWith("-"));
-
-		if (fileArgs.length === 0 && stdin !== undefined) {
-			return { stdout: stdin, exitCode: 0 };
-		}
-
-		if (fileArgs.length === 0) {
-			return { stderr: "cat: missing file operand", exitCode: 1 };
-		}
-
-		const parts: string[] = [];
-		for (const fileArg of fileArgs) {
-			const target = resolveReadablePath(shell.vfs, cwd, fileArg);
-			assertPathAccess(authUser, target, "cat");
-			parts.push(shell.vfs.readFile(target));
-		}
-
-		const combined = parts.join("");
-
-		if (!numberAll && !numberNonBlank) {
-			return { stdout: combined, exitCode: 0 };
-		}
-
-		let lineNum = 1;
-		const numbered = combined
-			.split("\n")
-			.map((line) => {
-				if (numberNonBlank && line.trim() === "") return line;
-				return `${String(lineNum++).padStart(6)}\t${line}`;
-			})
-			.join("\n");
-
-		return { stdout: numbered, exitCode: 0 };
-	},
-};

package/src/commands/cd.ts

@@ -1,25 +0,0 @@
-import type { ShellModule } from "../types/commands";
-import { assertPathAccess, resolvePath } from "./helpers";
-import { userHome } from "./runtime";
-
-/**
- * Change current working directory.
- * @category navigation
- * @params ["[path]"]
- */
-export const cdCommand: ShellModule = {
-	name: "cd",
-	description: "Change directory",
-	category: "navigation",
-	params: ["[path]"],
-	run: ({ authUser, shell, cwd, args }) => {
-		const target = resolvePath(cwd, args[0] ?? "~", userHome(authUser));
-		assertPathAccess(authUser, target, "cd");
-		const stats = shell.vfs.stat(target);
-		if (stats.type !== "directory") {
-			return { stderr: `cd: not a directory: ${target}`, exitCode: 1 };
-		}
-
-		return { nextCwd: target, exitCode: 0 };
-	},
-};