typescript-virtual-container 1.5.2 → 1.5.4

package/src/commands/declare.ts

@@ -1,49 +0,0 @@
-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"],
-	description: "Declare variables and give them attributes",
-	category: "shell",
-	params: ["[-i] [-r] [-x] [-a] [name[=value]...]"],
-	run: ({ args, env }) => {
-		if (!env) return { exitCode: 0 };
-
-		const integer = ifFlag(args, ["-i"]);
-		const _readonly = ifFlag(args, ["-r"]);
-		const _export_ = ifFlag(args, ["-x"]);
-		const printAll = args.filter((a) => !a.startsWith("-")).length === 0;
-
-		if (printAll) {
-			const lines = Object.entries(env.vars).map(
-				([k, v]) => `declare -- ${k}="${v}"`,
-			);
-			return { stdout: lines.join("\n"), exitCode: 0 };
-		}
-
-		const assignments = args.filter((a) => !a.startsWith("-"));
-		for (const token of assignments) {
-			const eq = token.indexOf("=");
-			if (eq === -1) {
-				// Just declare (no value)
-				if (!(token in env.vars)) env.vars[token] = "";
-			} else {
-				const name = token.slice(0, eq);
-				let val = token.slice(eq + 1);
-				if (integer) {
-					const n = parseInt(val, 10);
-					val = Number.isNaN(n) ? "0" : String(n);
-				}
-				env.vars[name] = val;
-			}
-		}
-
-		return { exitCode: 0 };
-	},
-};

package/src/commands/deluser.ts

@@ -1,98 +0,0 @@
-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: ["[-f] <username>"],
-	run: async ({ authUser, args, shell }) => {
-		if (authUser !== "root") {
-			return { stderr: "deluser: permission denied\n", exitCode: 1 };
-		}
-
-		const force =
-			args.includes("-f") ||
-			args.includes("--force") ||
-			args.includes("-y");
-		const username = args.find((a) => !a.startsWith("-"));
-
-		if (!username) {
-			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,
-			};
-		}
-
-		// 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,23 +0,0 @@
-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",
-	category: "system",
-	params: ["[-h]"],
-	run: ({ shell }) => {
-		const bytes = shell.vfs.getUsageBytes();
-		const used = (bytes / 1024).toFixed(0);
-		const total = "1048576"; // 1GB virtual
-		const avail = String(Number(total) - Number(used));
-		const pct = Math.round((Number(used) / Number(total)) * 100);
-		const hdr = "Filesystem     1K-blocks    Used Available Use% Mounted on";
-		const row = `virtual-fs     ${total.padStart(9)} ${used.padStart(7)} ${avail.padStart(9)} ${pct}% /`;
-		return { stdout: `${hdr}\n${row}`, exitCode: 0 };
-	},
-};

package/src/commands/diff.ts

@@ -1,43 +0,0 @@
-import type { ShellModule } from "../types/commands";
-import { resolvePath } from "./helpers";
-
-/**
- * Compare files line-by-line and print differing lines.
- * @category text
- * @params ["<file1> <file2>"]
- */
-export const diffCommand: ShellModule = {
-	name: "diff",
-	description: "Compare files line by line",
-	category: "text",
-	params: ["<file1> <file2>"],
-	run: ({ shell, cwd, args }) => {
-		const [f1, f2] = args;
-		if (!f1 || !f2) return { stderr: "diff: missing operand", exitCode: 1 };
-		const p1 = resolvePath(cwd, f1);
-		const p2 = resolvePath(cwd, f2);
-		let a: string[], b: string[];
-		try {
-			a = shell.vfs.readFile(p1).split("\n");
-		} catch {
-			return { stderr: `diff: ${f1}: No such file or directory`, exitCode: 2 };
-		}
-		try {
-			b = shell.vfs.readFile(p2).split("\n");
-		} catch {
-			return { stderr: `diff: ${f2}: No such file or directory`, exitCode: 2 };
-		}
-
-		const out: string[] = [];
-		const max = Math.max(a.length, b.length);
-		for (let i = 0; i < max; i++) {
-			const la = a[i];
-			const lb = b[i];
-			if (la !== lb) {
-				if (la !== undefined) out.push(`< ${la}`);
-				if (lb !== undefined) out.push(`> ${lb}`);
-			}
-		}
-		return { stdout: out.join("\n"), exitCode: out.length > 0 ? 1 : 0 };
-	},
-};

package/src/commands/dpkg.ts

@@ -1,180 +0,0 @@
-import type { ShellModule } from "../types/commands";
-import { ifFlag, parseArgs } from "./command-helpers";
-import { getPackageManager } from "./helpers";
-
-/**
- * dpkg compatibility command (query/remove/list) backed by the virtual package manager.
- * @category package
- * @params ["[-l] [-s pkg] [-L pkg] [-i pkg] [--remove pkg]"]
- */
-export const dpkgCommand: ShellModule = {
-	name: "dpkg",
-	description: "Debian package manager low-level tool",
-	category: "package",
-	params: ["[-l] [-s pkg] [-L pkg] [-i pkg] [--remove pkg]"],
-	run: ({ args, authUser, shell }) => {
-		const pm = getPackageManager(shell);
-		if (!pm)
-			return { stderr: "dpkg: package manager not initialised", exitCode: 1 };
-
-		const listFlag = ifFlag(args, ["-l", "--list"]);
-		const statusFlag = ifFlag(args, ["-s", "--status"]);
-		const listFilesFlag = ifFlag(args, ["-L", "--listfiles"]);
-		const removeFlag = ifFlag(args, ["-r", "--remove"]);
-		const purgeFlag = ifFlag(args, ["-P", "--purge"]);
-
-		const { positionals } = parseArgs(args, {
-			flags: [
-				"-l",
-				"--list",
-				"-s",
-				"--status",
-				"-L",
-				"--listfiles",
-				"-r",
-				"--remove",
-				"-P",
-				"--purge",
-			],
-		});
-
-		if (listFlag) {
-			const pkgList = pm.listInstalled();
-			if (pkgList.length === 0) {
-				return {
-					stdout: [
-						"Desired=Unknown/Install/Remove/Purge/Hold",
-						"|Status=Not/Inst/Conf-files/Unpacked/halF-conf/Half-inst/trig-aWait/Trig-pend",
-						"|/ Err?=(none)/Reinst-required (Status,Err: uppercase=bad)",
-						"||/ Name           Version         Architecture Description",
-						"+++-==============-===============-============-========================================",
-						"(no packages installed)",
-					].join("\n"),
-					exitCode: 0,
-				};
-			}
-
-			const header = [
-				"Desired=Unknown/Install/Remove/Purge/Hold",
-				"|Status=Not/Inst/Conf-files/Unpacked/halF-conf/Half-inst/trig-aWait/Trig-pend",
-				"|/ Err?=(none)/Reinst-required (Status,Err: uppercase=bad)",
-				"||/ Name           Version         Architecture Description",
-				"+++-==============-===============-============-========================================",
-			];
-
-			const rows = pkgList.map((p) => {
-				const name = p.name.padEnd(14).slice(0, 14);
-				const ver = p.version.padEnd(15).slice(0, 15);
-				const arch = p.architecture.padEnd(12).slice(0, 12);
-				const desc = (p.description || "").slice(0, 40);
-				return `ii  ${name} ${ver} ${arch} ${desc}`;
-			});
-
-			return { stdout: [...header, ...rows].join("\n"), exitCode: 0 };
-		}
-
-		if (statusFlag) {
-			const pkgName = positionals[0];
-			if (!pkgName)
-				return { stderr: "dpkg: -s needs a package name", exitCode: 1 };
-			const info = pm.show(pkgName);
-			if (!info)
-				return {
-					stderr: `dpkg-query: package '${pkgName}' is not installed and no information is available`,
-					exitCode: 1,
-				};
-			return { stdout: info, exitCode: 0 };
-		}
-
-		if (listFilesFlag) {
-			const pkgName = positionals[0];
-			if (!pkgName)
-				return { stderr: "dpkg: -L needs a package name", exitCode: 1 };
-			const installed = pm.listInstalled().find((p) => p.name === pkgName);
-			if (!installed)
-				return {
-					stderr: `dpkg-query: package '${pkgName}' is not installed`,
-					exitCode: 1,
-				};
-			if (installed.files.length === 0)
-				return { stdout: "/.keep", exitCode: 0 };
-			return { stdout: installed.files.join("\n"), exitCode: 0 };
-		}
-
-		if (removeFlag || purgeFlag) {
-			if (authUser !== "root")
-				return {
-					stderr:
-						"dpkg: error: requested operation requires superuser privilege",
-					exitCode: 2,
-				};
-			if (positionals.length === 0)
-				return { stderr: "dpkg: error: need an action option", exitCode: 2 };
-			const { output, exitCode } = pm.remove(positionals, { purge: purgeFlag });
-			return { stdout: output || undefined, exitCode };
-		}
-
-		// Default: show help
-		return {
-			stdout: [
-				"Usage: dpkg [<option>...] <command>",
-				"",
-				"Commands:",
-				"  -l, --list                  List packages matching given pattern",
-				"  -s, --status <pkg>...       Report status of specified package",
-				"  -L, --listfiles <pkg>...    List files owned by package",
-				"  -r, --remove <pkg>...       Remove <pkg> but leave its configuration",
-				"  -P, --purge <pkg>...        Remove <pkg> and its configuration",
-			].join("\n"),
-			exitCode: 0,
-		};
-	},
-};
-
-export const dpkgQueryCommand: ShellModule = {
-	name: "dpkg-query",
-	description: "Show information about installed packages",
-	category: "package",
-	params: ["-W [pkg] | -l [pattern]"],
-	run: ({ args, shell }) => {
-		const pm = getPackageManager(shell);
-		if (!pm)
-			return {
-				stderr: "dpkg-query: package manager not initialised",
-				exitCode: 1,
-			};
-
-		const listFlag = ifFlag(args, ["-l"]);
-		const showFlag = ifFlag(args, ["-W", "--show"]);
-		const { positionals } = parseArgs(args, {
-			flags: ["-l", "-W", "--show"],
-		});
-
-		if (listFlag || showFlag) {
-			const pkgList = pm.listInstalled();
-			const pattern = positionals[0];
-			const filtered = pattern
-				? pkgList.filter((p) => p.name.includes(pattern))
-				: pkgList;
-
-			if (showFlag) {
-				return {
-					stdout: filtered.map((p) => `${p.name}\t${p.version}`).join("\n"),
-					exitCode: 0,
-				};
-			}
-
-			const rows = filtered.map((p) => {
-				const name = p.name.padEnd(14).slice(0, 14);
-				const ver = p.version.padEnd(15).slice(0, 15);
-				return `ii  ${name} ${ver} amd64 ${(p.description || "").slice(0, 40)}`;
-			});
-			return {
-				stdout: rows.join("\n") || "(no packages match)",
-				exitCode: 0,
-			};
-		}
-
-		return { stderr: "dpkg-query: need a flag (-l, -W)", exitCode: 1 };
-	},
-};

package/src/commands/du.ts

@@ -1,56 +0,0 @@
-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",
-	category: "system",
-	params: ["[-h] [-s] [path]"],
-	run: ({ shell, cwd, args }) => {
-		const human = ifFlag(args, ["-h"]);
-		const summary = ifFlag(args, ["-s"]);
-		const target = args.find((a) => !a.startsWith("-")) ?? ".";
-		const p = resolvePath(cwd, target);
-
-		const fmt = (b: number) =>
-			human ? `${(b / 1024).toFixed(1)}K` : String(Math.ceil(b / 1024));
-
-		if (!shell.vfs.exists(p))
-			return {
-				stderr: `du: ${target}: No such file or directory`,
-				exitCode: 1,
-			};
-
-		if (summary || shell.vfs.stat(p).type === "file") {
-			return {
-				stdout: `${fmt(shell.vfs.getUsageBytes(p))}\t${target}`,
-				exitCode: 0,
-			};
-		}
-
-		const lines: string[] = [];
-		const walk = (dir: string, rel: string) => {
-			let total = 0;
-			for (const e of shell.vfs.list(dir)) {
-				const full = `${dir}/${e}`,
-					r = `${rel}/${e}`;
-				const st = shell.vfs.stat(full);
-				if (st.type === "directory") total += walk(full, r);
-				else {
-					total += st.size;
-					if (!summary) lines.push(`${fmt(st.size)}\t${r}`);
-				}
-			}
-			lines.push(`${fmt(total)}\t${rel}`);
-			return total;
-		};
-		walk(p, target);
-		return { stdout: lines.join("\n"), exitCode: 0 };
-	},
-};

package/src/commands/echo.ts

@@ -1,58 +0,0 @@
-import type { ShellModule } from "../types/commands";
-import { parseArgs } from "./command-helpers";
-import { expandSync } from "../utils/expand";
-
-/**
- * Expand escape sequences for `echo -e`.
- * Handles \n \t \r \\ \a \b \f \v and \0NNN (octal).
- */
-function expandEscapes(text: string): string {
-	return text
-		.replace(/\\n/g, "\n")
-		.replace(/\\t/g, "\t")
-		.replace(/\\r/g, "\r")
-		.replace(/\\\\/g, "\\")
-		.replace(/\\a/g, "\x07")
-		.replace(/\\b/g, "\x08")
-		.replace(/\\f/g, "\x0C")
-		.replace(/\\v/g, "\x0B")
-		.replace(/\\0(\d{1,3})/g, (_, oct) =>
-			String.fromCharCode(parseInt(oct, 8)),
-		);
-}
-
-/**
- * Echo text to stdout with shell-style expansion and escape support.
- * @category shell
- * @params ["[-n] [-e] [text...]"]
- */
-export const echoCommand: ShellModule = {
-	name: "echo",
-	description: "Display text",
-	category: "shell",
-	params: ["[-n] [-e] [text...]"],
-	run: ({ args, stdin, env }) => {
-		const { flags, positionals } = parseArgs(args, {
-			flags: ["-n", "-e", "-E"],
-		});
-		const noNewline = flags.has("-n");
-		const escapes = flags.has("-e");
-
-		const rawText =
-			positionals.length > 0 ? positionals.join(" ") : (stdin ?? "");
-
-		// Full expansion: $? ${#VAR} $((expr)) ~ ${VAR:-def} $VAR etc.
-		// $(cmd) is already resolved upstream by runCommand before echo.run is called.
-		const expanded = expandSync(
-			rawText,
-			env?.vars ?? {},
-			env?.lastExitCode ?? 0,
-		);
-		const text = escapes ? expandEscapes(expanded) : expanded;
-
-		return {
-			stdout: noNewline ? text : `${text}\n`,
-			exitCode: 0,
-		};
-	},
-};

package/src/commands/env.ts

@@ -1,23 +0,0 @@
-/** biome-ignore-all lint/style/useNamingConvention: ENV VARS */
-import type { ShellModule } from "../types/commands";
-
-/**
- * Print environment variables for the current session.
- * @category shell
- * @params []
- */
-export const envCommand: ShellModule = {
-	name: "env",
-	description: "Print environment variables",
-	category: "shell",
-	params: [],
-	run: ({ env, authUser }) => {
-		const vars = { ...env.vars, USER: authUser, HOME: `/home/${authUser}` };
-		return {
-			stdout: Object.entries(vars)
-				.map(([k, v]) => `${k}=${v}`)
-				.join("\n"),
-			exitCode: 0,
-		};
-	},
-};

package/src/commands/exit.ts

@@ -1,18 +0,0 @@
-import type { ShellModule } from "../types/commands";
-
-/**
- * Exit the current shell session (closeSession flag).
- * @category shell
- * @params ["[code]"]
- */
-export const exitCommand: ShellModule = {
-	name: "exit",
-	aliases: ["bye"],
-	description: "Exit the shell session",
-	category: "shell",
-	params: ["[code]"],
-	run: ({ args }) => ({
-		closeSession: true,
-		exitCode: parseInt(args[0] ?? "0", 10) || 0,
-	}),
-};

package/src/commands/export.ts

@@ -1,34 +0,0 @@
-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",
-	category: "shell",
-	params: ["[VAR=value]"],
-	run: ({ args, env }) => {
-		// export -p or export with no args — list all exported vars
-		if (args.length === 0 || (args.length === 1 && args[0] === "-p")) {
-			const out = Object.entries(env.vars)
-				.filter(([k]) => k && /^[A-Za-z_][A-Za-z0-9_]*$/.test(k))
-				.map(([k, v]) => `declare -x ${k}="${v}"`)
-				.join("\n");
-			return { stdout: out ? `${out}\n` : "", exitCode: 0 };
-		}
-		for (const arg of args.filter((a) => a !== "-p")) {
-			if (arg.includes("=")) {
-				const eq = arg.indexOf("=");
-				const name = arg.slice(0, eq);
-				const value = arg.slice(eq + 1);
-				env.vars[name] = value;
-			} else {
-				// mark existing as exported (already is)
-			}
-		}
-		return { exitCode: 0 };
-	},
-};

package/src/commands/find.ts

@@ -1,68 +0,0 @@
-import type { ShellModule } from "../types/commands";
-import { getFlag } from "./command-helpers";
-import { assertPathAccess, resolvePath } from "./helpers";
-
-/**
- * Find files and directories by name and type with minimal pattern support.
- * @category files
- * @params ["[path] [-name <pattern>] [-type f|d]"]
- */
-export const findCommand: ShellModule = {
-	name: "find",
-	description: "Search for files",
-	category: "files",
-	params: ["[path] [-name <pattern>] [-type f|d]"],
-	run: ({ authUser, shell, cwd, args }) => {
-		const namePattern = getFlag(args, ["-name"]);
-		const typeFilter = getFlag(args, ["-type"]);
-		const positionals = args.filter(
-			(a) => !a.startsWith("-") && a !== namePattern && a !== typeFilter,
-		);
-		const rootArg = positionals[0] ?? ".";
-		const rootPath = resolvePath(cwd, rootArg);
-
-		try {
-			assertPathAccess(authUser, rootPath, "find");
-			if (!shell.vfs.exists(rootPath)) {
-				return {
-					stderr: `find: ${rootArg}: No such file or directory`,
-					exitCode: 1,
-				};
-			}
-		} catch (err) {
-			const msg = err instanceof Error ? err.message : String(err);
-			return { stderr: `find: ${msg}`, exitCode: 1 };
-		}
-
-		const nameRegex = namePattern
-			? new RegExp(
-					`^${(namePattern as string).replace(/\./g, "\\.").replace(/\*/g, ".*").replace(/\?/g, ".")}$`,
-				)
-			: null;
-
-		const results: string[] = [];
-		const walk = (currentPath: string, display: string) => {
-			const stat = shell.vfs.stat(currentPath);
-
-			const matchesType =
-				!typeFilter ||
-				(typeFilter === "f" && stat.type === "file") ||
-				(typeFilter === "d" && stat.type === "directory");
-			const matchesName =
-				!nameRegex || nameRegex.test(currentPath.split("/").pop() ?? "");
-
-			if (matchesType && matchesName) results.push(display);
-
-			if (stat.type === "directory") {
-				for (const entry of shell.vfs.list(currentPath)) {
-					const full = `${currentPath}/${entry}`;
-					const disp = `${display}/${entry}`;
-					walk(full, disp);
-				}
-			}
-		};
-
-		walk(rootPath, rootArg);
-		return { stdout: results.join("\n"), exitCode: 0 };
-	},
-};