typescript-virtual-container 1.2.9 → 1.3.1

package/src/commands/read.ts

@@ -0,0 +1,41 @@
+import type { ShellModule } from "../types/commands";
+import { ifFlag } from "./command-helpers";
+
+export const readCommand: ShellModule = {
+	name: "read",
+	description: "Read a line from stdin into variables",
+	category: "shell",
+	params: ["[-r] [-p prompt] <var...>"],
+	run: ({ args, stdin, env }) => {
+		const _promptIdx = args.indexOf("-p");
+		const varNames = args.filter(
+			(a, i) => a !== "-r" && a !== "-p" && args[i - 1] !== "-p",
+		);
+
+		// In non-interactive context, read from stdin pipe
+		const input = (stdin ?? "").split("\n")[0] ?? "";
+		const line = ifFlag(args, ["-r"])
+			? input
+			: input.replace(/\\(?:\r?\n|.)/g, (m) =>
+					m[1] === "\n" || m[1] === "\r" ? "" : m[1]!,
+				);
+
+		if (!env) return { exitCode: 0 };
+
+		if (varNames.length === 0) {
+			// No var names: store into REPLY
+			env.vars.REPLY = line;
+		} else if (varNames.length === 1) {
+			env.vars[varNames[0]!] = line;
+		} else {
+			// Split on whitespace, last var gets remainder
+			const parts = line.split(/\s+/);
+			for (let i = 0; i < varNames.length; i++) {
+				env.vars[varNames[i]!] =
+					i < varNames.length - 1 ? (parts[i] ?? "") : parts.slice(i).join(" ");
+			}
+		}
+
+		return { exitCode: 0 };
+	},
+};

package/src/commands/registry.ts

@@ -0,0 +1,244 @@
+/** biome-ignore-all lint/style/useNamingConvention: ENV VARIABLES */
+import type { CommandContext, CommandResult, ShellModule } from "../types/commands";
+import { adduserCommand } from "./adduser";
+import { aliasCommand, unaliasCommand } from "./alias";
+import { aptCacheCommand, aptCommand } from "./apt";
+import { awkCommand } from "./awk";
+import { base64Command } from "./base64";
+import { catCommand } from "./cat";
+import { cdCommand } from "./cd";
+import { chmodCommand } from "./chmod";
+import { clearCommand } from "./clear";
+import { cpCommand } from "./cp";
+import { curlCommand } from "./curl";
+import { cutCommand } from "./cut";
+import { dateCommand } from "./date";
+import { declareCommand } from "./declare";
+import { deluserCommand } from "./deluser";
+import { dfCommand } from "./df";
+import { diffCommand } from "./diff";
+import { dpkgCommand, dpkgQueryCommand } from "./dpkg";
+import { duCommand } from "./du";
+import { echoCommand } from "./echo";
+import { envCommand } from "./env";
+import { exitCommand } from "./exit";
+import { exportCommand } from "./export";
+import { findCommand } from "./find";
+import { freeCommand } from "./free";
+import { grepCommand } from "./grep";
+import { groupsCommand } from "./groups";
+import { gunzipCommand, gzipCommand } from "./gzip";
+import { headCommand } from "./head";
+import { createHelpCommand } from "./help";
+import { historyCommand } from "./history";
+import { hostnameCommand } from "./hostname";
+import { htopCommand } from "./htop";
+import { idCommand } from "./id";
+import { killCommand } from "./kill";
+import { lnCommand } from "./ln";
+import { lsCommand } from "./ls";
+import { lsbReleaseCommand } from "./lsb-release";
+import { manCommand } from "./man";
+import { mkdirCommand } from "./mkdir";
+import { mvCommand } from "./mv";
+import { nanoCommand } from "./nano";
+import { neofetchCommand } from "./neofetch";
+import { nodeCommand } from "./node";
+import { npmCommand, npxCommand } from "./npm";
+import { passwdCommand } from "./passwd";
+import { pingCommand } from "./ping";
+import { printfCommand } from "./printf";
+import { psCommand } from "./ps";
+import { pwdCommand } from "./pwd";
+import { python3Command } from "./python";
+import { readCommand } from "./read";
+import { rmCommand } from "./rm";
+import { sedCommand } from "./sed";
+import { setCommand } from "./set";
+import { shCommand } from "./sh";
+import { returnCommand, shiftCommand, trapCommand } from "./shift";
+import { sleepCommand } from "./sleep";
+import { sortCommand } from "./sort";
+import { sourceCommand } from "./source";
+import { suCommand } from "./su";
+import { sudoCommand } from "./sudo";
+import { tailCommand } from "./tail";
+import { tarCommand } from "./tar";
+import { teeCommand } from "./tee";
+import { testCommand } from "./test";
+import { touchCommand } from "./touch";
+import { trCommand } from "./tr";
+import { treeCommand } from "./tree";
+import { falseCommand, trueCommand } from "./true";
+import { typeCommand } from "./type";
+import { unameCommand } from "./uname";
+import { uniqCommand } from "./uniq";
+import { unsetCommand } from "./unset";
+import { uptimeCommand } from "./uptime";
+import { wcCommand } from "./wc";
+import { wgetCommand } from "./wget";
+import { whichCommand } from "./which";
+import { whoCommand } from "./who";
+import { whoamiCommand } from "./whoami";
+import { xargsCommand } from "./xargs";
+
+const BASE_COMMANDS: ShellModule[] = [
+	// Navigation
+	pwdCommand,
+	cdCommand,
+	lsCommand,
+	treeCommand,
+	// Files
+	catCommand,
+	touchCommand,
+	rmCommand,
+	mkdirCommand,
+	cpCommand,
+	mvCommand,
+	lnCommand,
+	chmodCommand,
+	findCommand,
+	// Text processing
+	grepCommand,
+	sedCommand,
+	awkCommand,
+	sortCommand,
+	uniqCommand,
+	wcCommand,
+	headCommand,
+	tailCommand,
+	cutCommand,
+	trCommand,
+	teeCommand,
+	xargsCommand,
+	diffCommand,
+	// Archives
+	tarCommand,
+	gzipCommand,
+	gunzipCommand,
+	base64Command,
+	// System info
+	whoamiCommand,
+	whoCommand,
+	hostnameCommand,
+	idCommand,
+	groupsCommand,
+	unameCommand,
+	psCommand,
+	killCommand,
+	dfCommand,
+	duCommand,
+	dateCommand,
+	sleepCommand,
+	pingCommand,
+	// Shell
+	echoCommand,
+	envCommand,
+	exportCommand,
+	setCommand,
+	unsetCommand,
+	shCommand,
+	clearCommand,
+	exitCommand,
+	// Editors
+	nanoCommand,
+	htopCommand,
+	// Network
+	curlCommand,
+	wgetCommand,
+	// Users
+	adduserCommand,
+	passwdCommand,
+	deluserCommand,
+	sudoCommand,
+	suCommand,
+	// Misc
+	neofetchCommand,
+	// Package management
+	aptCommand,
+	aptCacheCommand,
+	dpkgCommand,
+	dpkgQueryCommand,
+	// Shell (extended)
+	whichCommand,
+	typeCommand,
+	manCommand,
+	aliasCommand,
+	unaliasCommand,
+	testCommand,
+	sourceCommand,
+	historyCommand,
+	printfCommand,
+	readCommand,
+	declareCommand,
+	shiftCommand,
+	trapCommand,
+	returnCommand,
+	trueCommand,
+	falseCommand,
+	npmCommand,
+	npxCommand,
+	nodeCommand,
+	python3Command,
+	// System (extended)
+	uptimeCommand,
+	freeCommand,
+	lsbReleaseCommand,
+];
+
+const customCommands: ShellModule[] = [];
+const commandRegistry = new Map<string, ShellModule>();
+let cachedCommandNames: string[] | null = null;
+
+const helpCommand = createHelpCommand(() =>
+	getCommandModules().map((cmd) => cmd.name),
+);
+
+function buildCache(): void {
+	commandRegistry.clear();
+	for (const mod of getCommandModules()) {
+		commandRegistry.set(mod.name, mod);
+		for (const alias of mod.aliases ?? []) commandRegistry.set(alias, mod);
+	}
+	cachedCommandNames = Array.from(commandRegistry.keys()).sort();
+}
+
+function getCommandModules(): ShellModule[] {
+	return [...BASE_COMMANDS, ...customCommands, helpCommand];
+}
+
+export function registerCommand(module: ShellModule): void {
+	const normalized: ShellModule = {
+		...module,
+		name: module.name.trim().toLowerCase(),
+		aliases: module.aliases?.map((a) => a.trim().toLowerCase()),
+	};
+	const names = [normalized.name, ...(normalized.aliases ?? [])];
+	if (names.some((n) => n.length === 0 || /\s/.test(n))) {
+		throw new Error("Command names must be non-empty and contain no spaces");
+	}
+	customCommands.push(normalized);
+	buildCache();
+}
+
+export function createCustomCommand(
+	name: string,
+	params: string[],
+	run: (ctx: CommandContext) => CommandResult | Promise<CommandResult>,
+): ShellModule {
+	return { name, params, run };
+}
+
+export function getCommandNames(): string[] {
+	if (!cachedCommandNames) buildCache();
+	return cachedCommandNames!;
+}
+
+export function getCommandModulesPublic(): ShellModule[] {
+	return getCommandModules();
+}
+
+export function resolveModule(name: string): ShellModule | undefined {
+	if (!cachedCommandNames) buildCache();
+	return commandRegistry.get(name.toLowerCase());
+}

package/src/commands/runtime.ts

@@ -0,0 +1,353 @@
+/** biome-ignore-all lint/style/useNamingConvention: ENV VARIABLES */
+import { executeStatements } from "../SSHMimic/executor";
+import type { VirtualShell } from "../VirtualShell";
+import { parseScript } from "../VirtualShell/shellParser";
+import type {
+    CommandMode,
+    CommandResult,
+    ShellEnv,
+} from "../types/commands";
+import { expandAsync } from "../utils/expand";
+import { resolveModule } from "./registry";
+
+// ── Tokenize command input respecting quotes ──────────────────────────────────
+function tokenizeCommand(input: string): string[] {
+	const tokens: string[] = [];
+	let current = "";
+	let inQ = false;
+	let qChar = "";
+	let i = 0;
+
+	while (i < input.length) {
+		const ch = input[i]!;
+		const next = input[i + 1];
+
+		if ((ch === '"' || ch === "'") && !inQ) {
+			inQ = true;
+			qChar = ch;
+			i++;
+			continue;
+		}
+		if (inQ && ch === qChar) {
+			inQ = false;
+			qChar = "";
+			i++;
+			continue;
+		}
+		if (inQ) {
+			current += ch;
+			i++;
+			continue;
+		}
+
+		if (ch === " ") {
+			if (current) {
+				tokens.push(current);
+				current = "";
+			}
+			i++;
+			continue;
+		}
+
+		if ((ch === ">" || ch === "<") && !inQ) {
+			if (current) {
+				tokens.push(current);
+				current = "";
+			}
+			if (ch === ">" && next === ">") {
+				tokens.push(">>");
+				i += 2;
+			} else {
+				tokens.push(ch);
+				i++;
+			}
+			continue;
+		}
+
+		current += ch;
+		i++;
+	}
+	if (current) tokens.push(current);
+	return tokens;
+}
+
+export function makeDefaultEnv(authUser: string, hostname: string): ShellEnv {
+	return {
+		vars: {
+			PATH: "/usr/local/bin:/usr/bin:/bin",
+			HOME: `/home/${authUser}`,
+			USER: authUser,
+			LOGNAME: authUser,
+			SHELL: "/bin/sh",
+			TERM: "xterm-256color",
+			HOSTNAME: hostname,
+			PS1: "\\u@\\h:\\w\\$ ",
+		},
+		lastExitCode: 0,
+	};
+}
+
+function resolveVfsBinary(
+	name: string,
+	env: ShellEnv,
+	shell: VirtualShell,
+	authUser: string,
+): string | null {
+	if (name.startsWith("/")) {
+		if (!shell.vfs.exists(name)) return null;
+		try {
+			const st = shell.vfs.stat(name);
+			if (st.type !== "file") return null;
+			if (!(st.mode & 0o111)) return null;
+			if (
+				(name.startsWith("/sbin/") || name.startsWith("/usr/sbin/")) &&
+				authUser !== "root"
+			)
+				return null;
+			return name;
+		} catch {
+			return null;
+		}
+	}
+
+	const pathDirs = (env.vars.PATH ?? "/usr/local/bin:/usr/bin:/bin").split(":");
+	for (const dir of pathDirs) {
+		if ((dir === "/sbin" || dir === "/usr/sbin") && authUser !== "root")
+			continue;
+		const full = `${dir}/${name}`;
+		if (!shell.vfs.exists(full)) continue;
+		try {
+			const st = shell.vfs.stat(full);
+			if (st.type !== "file") continue;
+			if (!(st.mode & 0o111)) continue;
+			return full;
+		} catch {}
+	}
+	return null;
+}
+
+export async function runCommandDirect(
+	name: string,
+	args: string[],
+	authUser: string,
+	hostname: string,
+	mode: CommandMode,
+	cwd: string,
+	shell: VirtualShell,
+	stdin: string | undefined,
+	env: ShellEnv,
+): Promise<CommandResult> {
+	const aliasVal = env.vars[`__alias_${name}`];
+	if (aliasVal) {
+		return runCommand(
+			`${aliasVal} ${args.join(" ")}`,
+			authUser,
+			hostname,
+			mode,
+			cwd,
+			shell,
+			stdin,
+			env,
+		);
+	}
+
+	const mod = resolveModule(name);
+	if (!mod) {
+		const vfsBinary = resolveVfsBinary(name, env, shell, authUser);
+		if (vfsBinary) {
+			const stubContent = shell.vfs.readFile(vfsBinary);
+			const builtinMatch = stubContent.match(/exec\s+builtin\s+(\S+)/);
+			if (builtinMatch) {
+				const builtinMod = resolveModule(builtinMatch[1]!);
+				if (builtinMod) {
+					return await builtinMod.run({
+						authUser,
+						hostname,
+						activeSessions: shell.users.listActiveSessions(),
+						rawInput: [name, ...args].join(" "),
+						mode,
+						args,
+						stdin,
+						cwd,
+						shell,
+						env,
+					});
+				}
+			}
+			const shMod = resolveModule("sh");
+			if (shMod) {
+				return await shMod.run({
+					authUser,
+					hostname,
+					activeSessions: shell.users.listActiveSessions(),
+					rawInput: `sh -c ${JSON.stringify(stubContent)}`,
+					mode,
+					args: ["-c", stubContent, "--", ...args],
+					stdin,
+					cwd,
+					shell,
+					env,
+				});
+			}
+		}
+		return { stderr: `${name}: command not found`, exitCode: 127 };
+	}
+
+	try {
+		return await mod.run({
+			authUser,
+			hostname,
+			activeSessions: shell.users.listActiveSessions(),
+			rawInput: [name, ...args].join(" "),
+			mode,
+			args,
+			stdin,
+			cwd,
+			shell,
+			env,
+		});
+	} catch (error: unknown) {
+		return {
+			stderr: error instanceof Error ? error.message : "Command failed",
+			exitCode: 1,
+		};
+	}
+}
+
+export async function runCommand(
+	rawInput: string,
+	authUser: string,
+	hostname: string,
+	mode: CommandMode,
+	cwd: string,
+	shell: VirtualShell,
+	stdin?: string,
+	env?: ShellEnv,
+): Promise<CommandResult> {
+	const trimmed = rawInput.trim();
+	if (trimmed.length === 0) return { exitCode: 0 };
+
+	const shellEnv: ShellEnv = env ?? makeDefaultEnv(authUser, hostname);
+
+	const rawTokens = tokenizeCommand(trimmed);
+	const rawFirstWord = rawTokens[0]?.toLowerCase() ?? "";
+	const aliasVal = shellEnv.vars[`__alias_${rawFirstWord}`];
+	const aliasExpanded = aliasVal
+		? trimmed.replace(rawFirstWord, aliasVal)
+		: trimmed;
+
+	const hasOperators =
+		/(?<![|&])[|](?![|])/.test(aliasExpanded) ||
+		aliasExpanded.includes(">") ||
+		aliasExpanded.includes("<") ||
+		aliasExpanded.includes("&&") ||
+		aliasExpanded.includes("||") ||
+		aliasExpanded.includes(";");
+
+	if (hasOperators) {
+		const script = parseScript(aliasExpanded);
+		if (!script.isValid)
+			return { stderr: script.error || "Syntax error", exitCode: 1 };
+		try {
+			return await executeStatements(
+				script.statements,
+				authUser,
+				hostname,
+				mode,
+				cwd,
+				shell,
+				shellEnv,
+			);
+		} catch (error: unknown) {
+			return {
+				stderr: error instanceof Error ? error.message : "Execution failed",
+				exitCode: 1,
+			};
+		}
+	}
+
+	const expanded = await expandAsync(
+		aliasExpanded,
+		shellEnv.vars,
+		shellEnv.lastExitCode,
+		(sub) =>
+			runCommand(
+				sub,
+				authUser,
+				hostname,
+				mode,
+				cwd,
+				shell,
+				undefined,
+				shellEnv,
+			).then((r) => r.stdout ?? ""),
+	);
+
+	const parts = tokenizeCommand(expanded.trim());
+	const commandName = parts[0]?.toLowerCase() ?? "";
+	const args = parts.slice(1);
+	const mod = resolveModule(commandName);
+
+	if (!mod) {
+		const vfsBinary = resolveVfsBinary(commandName, shellEnv, shell, authUser);
+		if (vfsBinary) {
+			const stubContent = shell.vfs.readFile(vfsBinary);
+			const builtinMatch = stubContent.match(/exec\s+builtin\s+(\S+)/);
+			if (builtinMatch) {
+				const builtinName = builtinMatch[1]!;
+				const builtinMod = resolveModule(builtinName);
+				if (builtinMod) {
+					return await builtinMod.run({
+						authUser,
+						hostname,
+						activeSessions: shell.users.listActiveSessions(),
+						rawInput: [commandName, ...args].join(" "),
+						mode,
+						args,
+						stdin,
+						cwd,
+						shell,
+						env: shellEnv,
+					});
+				}
+			}
+			const shMod = resolveModule("sh");
+			if (shMod) {
+				return await shMod.run({
+					authUser,
+					hostname,
+					activeSessions: shell.users.listActiveSessions(),
+					rawInput: `sh -c ${JSON.stringify(stubContent)}`,
+					mode,
+					args: ["-c", stubContent, "--", ...args],
+					stdin,
+					cwd,
+					shell,
+					env: shellEnv,
+				});
+			}
+		}
+
+		return { stderr: `${commandName}: command not found`, exitCode: 127 };
+	}
+
+	try {
+		return await mod.run({
+			authUser,
+			hostname,
+			activeSessions: shell.users.listActiveSessions(),
+			rawInput: expanded,
+			mode,
+			args,
+			stdin,
+			cwd,
+			shell,
+			env: shellEnv,
+		});
+	} catch (error: unknown) {
+		return {
+			stderr: error instanceof Error ? error.message : "Command failed",
+			exitCode: 1,
+		};
+	}
+}

package/src/commands/sed.ts

@@ -9,7 +9,9 @@ export const sedCommand: ShellModule = {
 	params: ["-e <expr> [file]", "s/pattern/replace/[g]"],
 	run: ({ authUser, shell, cwd, args, stdin }) => {
 		const inPlace = ifFlag(args, ["-i"]);
-		const expr = (getFlag(args, ["-e"]) as string | undefined) ?? args.find((a) => !a.startsWith("-"));
+		const expr =
+			(getFlag(args, ["-e"]) as string | undefined) ??
+			args.find((a) => !a.startsWith("-"));
 		const fileArg = args.filter((a) => !a.startsWith("-") && a !== expr).pop();
 
 		if (!expr) return { stderr: "sed: no expression", exitCode: 1 };
@@ -17,22 +19,38 @@ export const sedCommand: ShellModule = {
 		let content = stdin ?? "";
 		if (fileArg) {
 			const p = resolvePath(cwd, fileArg);
-			try { content = shell.vfs.readFile(p); } catch { return { stderr: `sed: ${fileArg}: No such file or directory`, exitCode: 1 }; }
+			try {
+				content = shell.vfs.readFile(p);
+			} catch {
+				return {
+					stderr: `sed: ${fileArg}: No such file or directory`,
+					exitCode: 1,
+				};
+			}
 		}
 
 		// Parse s/from/to/[g]
 		const sMatch = expr.match(/^s([^a-zA-Z0-9])(.+?)\1(.*?)\1([gi]*)$/);
-		if (!sMatch) return { stderr: `sed: unrecognized command: ${expr}`, exitCode: 1 };
+		if (!sMatch)
+			return { stderr: `sed: unrecognized command: ${expr}`, exitCode: 1 };
 
 		const [, , from, to, flags] = sMatch;
-		const regexFlags = (flags ?? "").includes("i") ? "gi" : (flags ?? "").includes("g") ? "g" : "";
+		const regexFlags = (flags ?? "").includes("i")
+			? "gi"
+			: (flags ?? "").includes("g")
+				? "g"
+				: "";
 		let regex: RegExp;
-		try { regex = new RegExp(from!, regexFlags || ""); }
-		catch (_e) { return { stderr: `sed: invalid regex: ${from}`, exitCode: 1 }; }
+		try {
+			regex = new RegExp(from!, regexFlags || "");
+		} catch (_e) {
+			return { stderr: `sed: invalid regex: ${from}`, exitCode: 1 };
+		}
 
-		const result = (flags ?? "").includes("g") || regexFlags.includes("g")
-			? content.replace(regex, to ?? "")
-			: content.replace(regex, to ?? "");
+		const result =
+			(flags ?? "").includes("g") || regexFlags.includes("g")
+				? content.replace(regex, to ?? "")
+				: content.replace(regex, to ?? "");
 
 		if (inPlace && fileArg) {
 			const p = resolvePath(cwd, fileArg);