typescript-virtual-container 1.5.2 → 1.5.4

package/src/commands/read.ts

@@ -1,46 +0,0 @@
-import type { ShellModule } from "../types/commands";
-import { ifFlag } from "./command-helpers";
-
-/**
- * Read a line from stdin into one or more variables.
- * @category shell
- * @params ["[-r] [-p prompt] <var...>"]
- */
-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

@@ -1,249 +0,0 @@
-/** 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, readlinkCommand } from "./ln";
-import { seqCommand } from "./seq";
-import { statCommand } from "./stat";
-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,
-	readlinkCommand,
-	chmodCommand,
-	seqCommand,
-	statCommand,
-	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/rm.ts

@@ -1,42 +0,0 @@
-import type { ShellModule } from "../types/commands";
-import { getArg, ifFlag } from "./command-helpers";
-import { assertPathAccess, resolvePath } from "./helpers";
-
-/**
- * Remove files or directories from the filesystem.
- * @category files
- * @params ["[-r|-rf] <path>"]
- */
-export const rmCommand: ShellModule = {
-	name: "rm",
-	description: "Remove files or directories",
-	category: "files",
-	params: ["[-r|-rf] <path>"],
-	run: ({ authUser, shell, cwd, args }) => {
-		if (args.length === 0) {
-			return { stderr: "rm: missing operand", exitCode: 1 };
-		}
-
-		const recursive = ifFlag(args, ["-r", "-rf", "-fr"]);
-		const targets: string[] = [];
-		for (let index = 0; ; index += 1) {
-			const target = getArg(args, index, { flags: ["-r", "-rf", "-fr"] });
-			if (!target) {
-				break;
-			}
-			targets.push(target);
-		}
-
-		if (targets.length === 0) {
-			return { stderr: "rm: missing operand", exitCode: 1 };
-		}
-
-		for (const target of targets) {
-			const resolvedTarget = resolvePath(cwd, target);
-			assertPathAccess(authUser, resolvedTarget, "rm");
-			shell.vfs.remove(resolvedTarget, { recursive });
-		}
-
-		return { exitCode: 0 };
-	},
-};

package/src/commands/runtime.ts

@@ -1,378 +0,0 @@
-/** 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, expandBraces } from "../utils/expand";
-import { tokenizeCommand } from "../utils/tokenize";
-import { resolveModule } from "./registry";
-
-/** Returns the home directory path for a given user. Root lives at /root. */
-export function userHome(authUser: string): string {
-	return authUser === "root" ? "/root" : `/home/${authUser}`;
-}
-
-export function makeDefaultEnv(authUser: string, hostname: string): ShellEnv {
-	return {
-		vars: {
-			PATH: "/usr/local/bin:/usr/bin:/bin",
-			HOME: userHome(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 assignRe = /^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/;
-	const invocation = [name, ...args];
-	let assignCount = 0;
-	while (assignCount < invocation.length && assignRe.test(invocation[assignCount]!)) {
-		assignCount += 1;
-	}
-	if (assignCount > 0) {
-		const assignments = invocation.slice(0, assignCount).map((token) => token.match(assignRe)!);
-		const remaining = invocation.slice(assignCount);
-		const restored: Array<[string, string | undefined]> = [];
-		for (const [, key, value] of assignments) {
-			restored.push([key!, env.vars[key!]]);
-			env.vars[key!] = value!;
-		}
-		if (remaining.length === 0) {
-			return { exitCode: 0 };
-		}
-		try {
-			const result = await runCommandDirect(
-				remaining[0]!,
-				remaining.slice(1),
-				authUser,
-				hostname,
-				mode,
-				cwd,
-				shell,
-				stdin,
-				env,
-			);
-			return result;
-		} finally {
-			for (const [key, value] of restored) {
-				if (value === undefined) delete env.vars[key];
-				else env.vars[key] = value;
-			}
-		}
-	}
-
-	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;
-
-	// Detect sh-syntax constructs that must be handled by the sh interpreter
-	const isShScript =
-		/\bfor\s+\w+\s+in\b/.test(aliasExpanded) ||
-		/\bwhile\s+/.test(aliasExpanded) ||
-		/\bif\s+/.test(aliasExpanded) ||
-		/\w+\s*\(\s*\)\s*\{/.test(aliasExpanded) ||
-		/\bfunction\s+\w+/.test(aliasExpanded) ||
-		/\(\(\s*.+\s*\)\)/.test(aliasExpanded);
-
-	const hasOperators =
-		/(?<![|&])[|](?![|])/.test(aliasExpanded) ||
-		aliasExpanded.includes(">") ||
-		aliasExpanded.includes("<") ||
-		aliasExpanded.includes("&&") ||
-		aliasExpanded.includes("||") ||
-		aliasExpanded.includes(";");
-
-	if ((isShScript && rawFirstWord !== "sh" && rawFirstWord !== "bash") || hasOperators) {
-		// sh-syntax: route through sh interpreter to handle for/while/functions
-		if (isShScript && rawFirstWord !== "sh" && rawFirstWord !== "bash") {
-			const shMod = resolveModule("sh");
-			if (shMod) {
-				return await shMod.run({
-					authUser, hostname,
-					activeSessions: shell.users.listActiveSessions(),
-					rawInput: aliasExpanded,
-					mode,
-					args: ["-c", aliasExpanded],
-					stdin: undefined,
-					cwd,
-					shell,
-					env: shellEnv,
-				});
-			}
-		}
-		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());
-	if (parts.length === 0) return { exitCode: 0 };
-	const assignRe = /^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/;
-	if (assignRe.test(parts[0]!)) {
-		return runCommandDirect(
-			parts[0]!,
-			parts.slice(1),
-			authUser,
-			hostname,
-			mode,
-			cwd,
-			shell,
-			stdin,
-			shellEnv,
-		);
-	}
-	const commandName = parts[0]?.toLowerCase() ?? "";
-	// Apply brace expansion to each arg token
-	const args = parts.slice(1).flatMap(expandBraces);
-	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,
-		};
-	}
-}