typescript-virtual-container 1.0.7 → 1.1.0

package/src/VirtualShell/commands/grep.ts

@@ -1,23 +1,16 @@
 import type { ShellModule } from "../../types/commands";
-import { getArg, ifFlag } from "./command-helpers";
+import { parseArgs } from "./command-helpers";
 import { assertPathAccess, resolvePath } from "./helpers";
 
 export const grepCommand: ShellModule = {
 	name: "grep",
 	params: ["[-i] [-v] <pattern> [file...]"],
-	run: ({ authUser, vfs, cwd, args, stdin }) => {
-		const caseInsensitive = ifFlag(args, "-i");
-		const invertMatch = ifFlag(args, "-v");
-		const parserOptions = { flags: ["-i", "-v"] };
-		const pattern = getArg(args, 0, parserOptions);
-		const files: string[] = [];
-		for (let index = 1; ; index += 1) {
-			const file = getArg(args, index, parserOptions);
-			if (!file) {
-				break;
-			}
-			files.push(file);
-		}
+	run: ({ authUser, shell, cwd, args, stdin }) => {
+		const { flags, positionals } = parseArgs(args, { flags: ["-i", "-v"] });
+		const caseInsensitive = flags.has("-i");
+		const invertMatch = flags.has("-v");
+		const pattern = positionals[0];
+		const files = positionals.slice(1);
 
 		if (!pattern) {
 			return { stderr: "grep: no pattern specified", exitCode: 1 };
@@ -33,7 +26,6 @@ export const grepCommand: ShellModule = {
 
 		const results: string[] = [];
 
-		// If no files specified, read from stdin (pipe/input redirection).
 		if (files.length === 0) {
 			if (!stdin) {
 				return { stdout: "", exitCode: 1 };
@@ -60,7 +52,7 @@ export const grepCommand: ShellModule = {
 			const target = resolvePath(cwd, file);
 			try {
 				assertPathAccess(authUser, target, "grep");
-				const content = vfs.readFile(target);
+				const content = shell.vfs.readFile(target);
 				const lines = content.split("\n");
 
 				for (const line of lines) {

package/src/VirtualShell/commands/helpers.ts

@@ -1,3 +1,4 @@
+import { spawn } from "node:child_process";
 import * as path from "node:path";
 import type VirtualFileSystem from "../../VirtualFileSystem";
 
@@ -76,6 +77,79 @@ export async function fetchResource(
 	};
 }
 
+/**
+ * Run a host command like curl or wget and capture its output.
+ * @param binary - The binary to execute (e.g., "curl", "wget").
+ * @param args - Arguments to pass to the binary.
+ * @returns Promise resolving with stdout, stderr, and exit code.
+ */
+export function runHostCommand(
+	binary: string,
+	args: string[],
+): Promise<{ stdout: string; stderr: string; exitCode: number }> {
+	return new Promise((resolve) => {
+		let childProcess: ReturnType<typeof spawn>;
+
+		try {
+			childProcess = spawn(binary, args, {
+				stdio: ["ignore", "pipe", "pipe"],
+			});
+		} catch (error) {
+			resolve({
+				stdout: "",
+				stderr: `${binary}: ${error instanceof Error ? error.message : String(error)}`,
+				exitCode: 1,
+			});
+			return;
+		}
+
+		let stdout = "";
+		let stderr = "";
+		const stdoutStream = childProcess.stdout;
+		const stderrStream = childProcess.stderr;
+
+		if (!stdoutStream || !stderrStream) {
+			resolve({
+				stdout: "",
+				stderr: `${binary}: failed to capture process output`,
+				exitCode: 1,
+			});
+			return;
+		}
+
+		stdoutStream.setEncoding("utf8");
+		stderrStream.setEncoding("utf8");
+
+		stdoutStream.on("data", (chunk: string) => {
+			stdout += chunk;
+		});
+
+		stderrStream.on("data", (chunk: string) => {
+			stderr += chunk;
+		});
+
+		childProcess.on("error", (error) => {
+			const errorCode =
+				error instanceof Error && "code" in error
+					? String((error as NodeJS.ErrnoException).code ?? "")
+					: "";
+			resolve({
+				stdout: "",
+				stderr: `${binary}: ${error.message}`,
+				exitCode: errorCode === "ENOENT" ? 127 : 1,
+			});
+		});
+
+		childProcess.on("close", (code) => {
+			resolve({
+				stdout,
+				stderr,
+				exitCode: code ?? 1,
+			});
+		});
+	});
+}
+
 function levenshtein(a: string, b: string): number {
 	const dp: number[][] = Array.from({ length: a.length + 1 }, () =>
 		Array<number>(b.length + 1).fill(0),

package/src/VirtualShell/commands/index.ts

@@ -1,13 +1,10 @@
-import type { ShellProperties } from "..";
-import type { VirtualUserManager } from "../../SSHMimic/users";
+import type { VirtualShell } from "..";
 import type {
 	CommandContext,
 	CommandMode,
-	CommandOutcome,
 	CommandResult,
 	ShellModule,
 } from "../../types/commands";
-import type VirtualFileSystem from "../../VirtualFileSystem";
 import { adduserCommand } from "./adduser";
 import { catCommand } from "./cat";
 import { cdCommand } from "./cd";
@@ -77,19 +74,28 @@ const helpCommand = createHelpCommand(() =>
 	getCommandModules().map((cmd) => cmd.name),
 );
 
-function getCommandModules(): ShellModule[] {
-	return [...BASE_COMMANDS, ...customCommands, helpCommand];
-}
+const commandRegistry = new Map<string, ShellModule>();
+let cachedCommandNames: string[] | null = null;
 
-function getTakenCommandNames(modules: ShellModule[]): Set<string> {
-	const taken = new Set<string>();
-	for (const mod of modules) {
-		taken.add(mod.name);
+function buildCache(): void {
+	for (const mod of getCommandModules()) {
+		commandRegistry.set(mod.name, mod);
 		for (const alias of mod.aliases ?? []) {
-			taken.add(alias);
+			commandRegistry.set(alias, mod);
 		}
 	}
-	return taken;
+	cachedCommandNames = Array.from(commandRegistry.keys()).sort();
+}
+
+function getCommandModules(): ShellModule[] {
+	// console.log("Loading command modules...");
+	// console.log(
+	// 	`Base commands: ${BASE_COMMANDS.map((cmd) => cmd.name).join(", ")}`,
+	// );
+	// console.log(
+	// 	`Custom commands: ${customCommands.map((cmd) => cmd.name).join(", ")}`,
+	// );
+	return [...BASE_COMMANDS, ...customCommands, helpCommand];
 }
 
 export function registerCommand(module: ShellModule): void {
@@ -106,13 +112,14 @@ export function registerCommand(module: ShellModule): void {
 		);
 	}
 
-	const takenNames = getTakenCommandNames(getCommandModules());
-	const conflict = names.find((name) => takenNames.has(name));
-	if (conflict) {
-		throw new Error(`Command '${conflict}' already exists`);
+	for (const name of names) {
+		if (commandRegistry.has(name)) {
+			throw new Error(`Command '${name}' already exists`);
+		}
+		commandRegistry.set(name, normalized);
 	}
 
-	customCommands.push(normalized);
+	buildCache();
 }
 
 export function createCustomCommand(
@@ -128,17 +135,14 @@ export function createCustomCommand(
 }
 
 export function getCommandNames(): string[] {
-	return getCommandModules().flatMap((cmd) => [
-		cmd.name,
-		...(cmd.aliases ?? []),
-	]);
+	if (!cachedCommandNames) {
+		buildCache();
+	}
+	return cachedCommandNames!;
 }
 
-function resolveModule(name: string): ShellModule | undefined {
-	const lowered = name.toLowerCase();
-	return getCommandModules().find(
-		(cmd) => cmd.name === lowered || cmd.aliases?.includes(lowered),
-	);
+export function resolveModule(name: string): ShellModule | undefined {
+	return commandRegistry.get(name.toLowerCase());
 }
 
 function splitArgsRespectingQuotes(input: string): string[] {
@@ -192,28 +196,27 @@ function parseInput(rawInput: string): { commandName: string; args: string[] } {
 }
 
 // Internal async function for pipeline execution
-async function runCommandInternal(
+
+export async function runCommand(
 	rawInput: string,
 	authUser: string,
 	hostname: string,
-	users: VirtualUserManager,
 	mode: CommandMode,
 	cwd: string,
-	shellProps: ShellProperties,
-	vfs: VirtualFileSystem,
+	shell: VirtualShell,
 	stdin?: string,
 ): Promise<CommandResult> {
-	// Check if input contains pipes or redirections
-	if (
-		rawInput.includes("|") ||
-		rawInput.includes(">") ||
-		rawInput.includes("<")
-	) {
-		// Use pipeline executor
+	const trimmed = rawInput.trim();
+
+	if (trimmed.length === 0) {
+		return { exitCode: 0 };
+	}
+
+	if (trimmed.includes("|") || trimmed.includes(">") || trimmed.includes("<")) {
 		const { parseShellPipeline } = await import("../shellParser");
 		const { executePipeline } = await import("../../SSHMimic/executor");
 
-		const pipeline = parseShellPipeline(rawInput);
+		const pipeline = parseShellPipeline(trimmed);
 		if (!pipeline.isValid) {
 			return {
 				stderr: pipeline.error || "Syntax error",
@@ -226,10 +229,9 @@ async function runCommandInternal(
 				pipeline,
 				authUser,
 				hostname,
-				users,
 				mode,
 				cwd,
-				vfs,
+				shell,
 			);
 		} catch (error: unknown) {
 			const message =
@@ -238,72 +240,6 @@ async function runCommandInternal(
 		}
 	}
 
-	// Regular command execution
-	const { commandName, args } = parseInput(rawInput);
-	const mod = resolveModule(commandName);
-
-	if (!mod) {
-		return {
-			stderr: `Command '${rawInput}' not found`,
-			exitCode: 127,
-		};
-	}
-
-	try {
-		const result = mod.run({
-			authUser,
-			hostname,
-			users,
-			activeSessions: users.listActiveSessions(),
-			rawInput,
-			mode,
-			args,
-			shellProps,
-			stdin,
-			cwd,
-			vfs,
-		});
-
-		return await Promise.resolve(result);
-	} catch (error: unknown) {
-		const message = error instanceof Error ? error.message : "Command failed";
-		return { stderr: message, exitCode: 1 };
-	}
-}
-
-export function runCommand(
-	rawInput: string,
-	authUser: string,
-	hostname: string,
-	users: VirtualUserManager,
-	mode: CommandMode,
-	cwd: string,
-	shellProps: ShellProperties,
-	vfs: VirtualFileSystem,
-	stdin?: string,
-): CommandOutcome {
-	const trimmed = rawInput.trim();
-
-	if (trimmed.length === 0) {
-		return { exitCode: 0 };
-	}
-
-	// Check if input contains pipes or redirections - use async version
-	if (trimmed.includes("|") || trimmed.includes(">") || trimmed.includes("<")) {
-		return runCommandInternal(
-			trimmed,
-			authUser,
-			hostname,
-			users,
-			mode,
-			cwd,
-			shellProps,
-			vfs,
-			stdin,
-		);
-	}
-
-	// Regular synchronous command execution
 	const { commandName, args } = parseInput(trimmed);
 	const mod = resolveModule(commandName);
 
@@ -315,18 +251,16 @@ export function runCommand(
 	}
 
 	try {
-		return mod.run({
+		return await mod.run({
 			authUser,
 			hostname,
-			users,
-			activeSessions: users.listActiveSessions(),
+			activeSessions: shell.users.listActiveSessions(),
 			rawInput: trimmed,
 			mode,
 			args,
 			stdin,
 			cwd,
-			vfs,
-			shellProps,
+			shell,
 		});
 	} catch (error: unknown) {
 		const message = error instanceof Error ? error.message : "Command failed";

package/src/VirtualShell/commands/ls.ts

@@ -29,22 +29,24 @@ function formatDate(date: Date): string {
 export const lsCommand: ShellModule = {
 	name: "ls",
 	params: ["[path]"],
-	run: ({ authUser, vfs, cwd, args }) => {
+	run: ({ authUser, shell, cwd, args }) => {
 		const longFormat = ifFlag(args, ["-l", "--long"]);
 		const targetArg = getArg(args, 0, { flags: ["-l", "--long"] });
 		const target = resolvePath(cwd, targetArg ?? cwd);
 		assertPathAccess(authUser, target, "ls");
-		const items = vfs.list(target).filter((name) => !name.startsWith("."));
+		const items = shell.vfs
+			.list(target)
+			.filter((name) => !name.startsWith("."));
 		const rendered = longFormat
 			? items
 					.map((name) => {
 						const childPath = resolvePath(target, name);
-						const stat = vfs.stat(childPath);
+						const stat = shell.vfs.stat(childPath);
 						const size = stat.type === "file" ? stat.size : stat.childrenCount;
 						return `${formatPermissions(stat.mode, stat.type === "directory")} 1 ${size} ${formatDate(stat.updatedAt)} ${name}${stat.type === "directory" ? "/" : ""}`;
 					})
 					.join("\n")
-			: joinListWithType(target, items, (p) => vfs.stat(p));
+			: joinListWithType(target, items, (p) => shell.vfs.stat(p));
 		return { stdout: rendered, exitCode: 0 };
 	},
 };

package/src/VirtualShell/commands/mkdir.ts

@@ -5,7 +5,7 @@ import { assertPathAccess, resolvePath } from "./helpers";
 export const mkdirCommand: ShellModule = {
 	name: "mkdir",
 	params: ["<dir>"],
-	run: ({ authUser, vfs, cwd, args }) => {
+	run: ({ authUser, shell, cwd, args }) => {
 		if (args.length === 0) {
 			return { stderr: "mkdir: missing operand", exitCode: 1 };
 		}
@@ -17,7 +17,7 @@ export const mkdirCommand: ShellModule = {
 			}
 			const target = resolvePath(cwd, dir);
 			assertPathAccess(authUser, target, "mkdir");
-			vfs.mkdir(target);
+			shell.vfs.mkdir(target);
 		}
 		return { exitCode: 0 };
 	},

package/src/VirtualShell/commands/nano.ts

@@ -5,7 +5,7 @@ import { assertPathAccess, resolvePath } from "./helpers";
 export const nanoCommand: ShellModule = {
 	name: "nano",
 	params: ["<file>"],
-	run: ({ authUser, vfs, cwd, args }) => {
+	run: ({ authUser, shell, cwd, args }) => {
 		const fileArg = args[0];
 		if (!fileArg) {
 			return { stderr: "nano: missing file operand", exitCode: 1 };
@@ -13,8 +13,8 @@ export const nanoCommand: ShellModule = {
 
 		const targetPath = resolvePath(cwd, fileArg);
 		assertPathAccess(authUser, targetPath, "nano");
-		const initialContent = vfs.exists(targetPath)
-			? vfs.readFile(targetPath)
+		const initialContent = shell.vfs.exists(targetPath)
+			? shell.vfs.readFile(targetPath)
 			: "";
 		const safeName = path.posix.basename(targetPath) || "buffer";
 		const tempPath = `/tmp/sshmimic-nano-${Date.now()}-${safeName}.tmp`;

package/src/VirtualShell/commands/neofetch.ts

@@ -6,7 +6,7 @@ import { getAllEnvVars } from "./set";
 export const neofetchCommand: ShellModule = {
 	name: "neofetch",
 	params: ["[--off]"],
-	run: ({ args, authUser, hostname, shellProps }) => {
+	run: ({ args, authUser, hostname, shell }) => {
 		const env = getAllEnvVars(authUser);
 
 		if (ifFlag(args, "--help")) {
@@ -28,7 +28,7 @@ export const neofetchCommand: ShellModule = {
 				user: authUser,
 				host: hostname,
 				shell: env.SHELL,
-				shellProps: shellProps,
+				shellProps: shell.properties,
 				terminal: env.TERM,
 			}),
 			exitCode: 0,

package/src/VirtualShell/commands/rm.ts

@@ -5,7 +5,7 @@ import { assertPathAccess, resolvePath } from "./helpers";
 export const rmCommand: ShellModule = {
 	name: "rm",
 	params: ["[-r|-rf] <path>"],
-	run: ({ authUser, vfs, cwd, args }) => {
+	run: ({ authUser, shell, cwd, args }) => {
 		if (args.length === 0) {
 			return { stderr: "rm: missing operand", exitCode: 1 };
 		}
@@ -27,7 +27,7 @@ export const rmCommand: ShellModule = {
 		for (const target of targets) {
 			const resolvedTarget = resolvePath(cwd, target);
 			assertPathAccess(authUser, resolvedTarget, "rm");
-			vfs.remove(resolvedTarget, { recursive });
+			shell.vfs.remove(resolvedTarget, { recursive });
 		}
 
 		return { exitCode: 0 };

package/src/VirtualShell/commands/sh.ts

@@ -1,4 +1,3 @@
-import { defaultShellProperties } from "..";
 import type { CommandContext, ShellModule } from "../../types/commands";
 import { getArg, getFlag } from "./command-helpers";
 import { runCommand } from "./index";
@@ -9,8 +8,7 @@ export const shCommand: ShellModule = {
 	params: ["-c <script>", "[<file>]"],
 	aliases: ["bash"],
 	run: async (ctx: CommandContext) => {
-		const { vfs, args, authUser, hostname, users, mode, cwd } = ctx;
-
+		const { args, authUser, hostname, mode, cwd } = ctx;
 		// Handle -c option: sh -c "command"
 		if (getFlag(args, "-c") && args.length >= 2) {
 			const script = getArg(args, 1) ?? "";
@@ -39,16 +37,7 @@ export const shCommand: ShellModule = {
 
 				// Execute the command
 				const result = await Promise.resolve(
-					runCommand(
-						command,
-						authUser,
-						hostname,
-						users,
-						mode,
-						cwd,
-						defaultShellProperties,
-						vfs,
-					),
+					runCommand(command, authUser, hostname, mode, cwd, ctx.shell),
 				);
 
 				if (result.stdout) {

package/src/VirtualShell/commands/su.ts

@@ -4,7 +4,8 @@ import { getArg } from "./command-helpers";
 export const suCommand: ShellModule = {
 	name: "su",
 	params: ["- <username>"],
-	run: ({ authUser, users, args }) => {
+	run: ({ authUser, shell, args }) => {
+		const users = shell.users!;
 		const targetUser = getArg(args, 0, { flags: ["-"] });
 
 		if (!targetUser) {

package/src/VirtualShell/commands/sudo.ts

@@ -1,6 +1,5 @@
-import { defaultShellProperties } from "..";
 import type { ShellModule } from "../../types/commands";
-import { getArg, getFlag, ifFlag } from "./command-helpers";
+import { parseArgs } from "./command-helpers";
 import { runCommand } from "./index";
 
 function parseSudoArgs(args: string[]): {
@@ -8,35 +7,25 @@ function parseSudoArgs(args: string[]): {
 	loginShell: boolean;
 	commandLine: string | null;
 } {
-	const loginShell = ifFlag(args, "-i");
-	const targetUserValue = getFlag(args, ["-u", "--user"]);
-	const targetUser =
-		typeof targetUserValue === "string" && targetUserValue.length > 0
-			? targetUserValue
-			: "root";
+	const { flags, flagsWithValues, positionals } = parseArgs(args, {
+		flags: ["-i", "-S"],
+		flagsWithValue: ["-u", "--user"],
+	});
 
-	const commandParts: string[] = [];
-	for (let index = 0; ; index += 1) {
-		const part = getArg(args, index, {
-			flags: ["-i", "-S"],
-			flagsWithValue: ["-u", "--user"],
-		});
-		if (!part) {
-			break;
-		}
-		commandParts.push(part);
-	}
+	const loginShell = flags.has("-i");
+	const targetUser =
+		flagsWithValues.get("-u") || flagsWithValues.get("--user") || "root";
+	const commandLine = positionals.length > 0 ? positionals.join(" ") : null;
 
-	const commandLine = commandParts.length > 0 ? commandParts.join(" ") : null;
 	return { targetUser, loginShell, commandLine };
 }
 export const sudoCommand: ShellModule = {
 	name: "sudo",
 	params: ["<command...>"],
-	run: async ({ authUser, hostname, users, mode, cwd, vfs, args }) => {
+	run: async ({ authUser, hostname, mode, cwd, shell, args }) => {
 		const { targetUser, loginShell, commandLine } = parseSudoArgs(args);
 
-		if (authUser !== "root" && !users.isSudoer(authUser)) {
+		if (authUser !== "root" && !shell.users.isSudoer(authUser)) {
 			return { stderr: "sudo: permission denied", exitCode: 1 };
 		}
 
@@ -60,11 +49,9 @@ export const sudoCommand: ShellModule = {
 				commandLine,
 				effectiveUser,
 				hostname,
-				users,
 				mode,
 				loginShell ? `/home/${effectiveUser}` : cwd,
-				defaultShellProperties,
-				vfs,
+				shell,
 			);
 		}
 

package/src/VirtualShell/commands/touch.ts

@@ -4,7 +4,7 @@ import { assertPathAccess, resolvePath } from "./helpers";
 export const touchCommand: ShellModule = {
 	name: "touch",
 	params: ["<file>"],
-	run: ({ authUser, vfs, cwd, args }) => {
+	run: ({ authUser, shell, cwd, args }) => {
 		if (args.length === 0) {
 			return { stderr: "touch: missing file operand", exitCode: 1 };
 		}
@@ -12,8 +12,8 @@ export const touchCommand: ShellModule = {
 		for (const file of args) {
 			const target = resolvePath(cwd, file);
 			assertPathAccess(authUser, target, "touch");
-			if (!vfs.exists(target)) {
-				vfs.writeFile(target, "");
+			if (!shell.vfs.exists(target)) {
+				shell.vfs.writeFile(target, "");
 			}
 		}
 		return { exitCode: 0 };

package/src/VirtualShell/commands/tree.ts

@@ -5,9 +5,9 @@ import { assertPathAccess, resolvePath } from "./helpers";
 export const treeCommand: ShellModule = {
 	name: "tree",
 	params: ["[path]"],
-	run: ({ authUser, vfs, cwd, args }) => {
+	run: ({ authUser, shell, cwd, args }) => {
 		const target = resolvePath(cwd, getArg(args, 0) ?? cwd);
 		assertPathAccess(authUser, target, "tree");
-		return { stdout: vfs.tree(target), exitCode: 0 };
+		return { stdout: shell.vfs.tree(target), exitCode: 0 };
 	},
 };