typescript-virtual-container 1.0.3 → 1.0.5

package/src/{SSHMimic → VirtualShell}/commands/curl.ts

@@ -1,43 +1,12 @@
 import { spawn } from "node:child_process";
 import type { ShellModule } from "../../types/commands";
+import { getArg, getFlag, ifFlag } from "./command-helpers";
 import {
 	assertPathAccess,
 	normalizeTerminalOutput,
 	resolvePath,
 } from "./helpers";
 
-function parseCurlOutputPath(args: string[]): {
-	outputPath: string | null;
-	inputArgs: string[];
-} {
-	const filtered: string[] = [];
-	let outputPath: string | null = null;
-
-	for (let index = 0; index < args.length; index += 1) {
-		const arg = args[index]!;
-
-		if (arg === "-o" || arg === "--output") {
-			outputPath = args[index + 1] ?? null;
-			index += 1;
-			continue;
-		}
-
-		if (arg.startsWith("-o=")) {
-			outputPath = arg.slice(3);
-			continue;
-		}
-
-		if (arg.startsWith("--output=")) {
-			outputPath = arg.slice("--output=".length);
-			continue;
-		}
-
-		filtered.push(arg);
-	}
-
-	return { outputPath, inputArgs: filtered };
-}
-
 function runHostCurl(args: string[]): Promise<{
 	stdout: string;
 	stderr: string;
@@ -110,12 +79,22 @@ export const curlCommand: ShellModule = {
 	name: "curl",
 	params: ["[-o file] <url>"],
 	run: async ({ authUser, vfs, cwd, args }) => {
-		const { outputPath, inputArgs } = parseCurlOutputPath(args);
+		const outputPathValue = getFlag(args, ["-o", "--output"]);
+		const outputPath =
+			typeof outputPathValue === "string" && outputPathValue.length > 0
+				? outputPathValue
+				: null;
+		const parserOptions = { flagsWithValue: ["-o", "--output"] };
+		const inputArgs: string[] = [];
+		for (let index = 0; ; index += 1) {
+			const arg = getArg(args, index, parserOptions);
+			if (!arg) {
+				break;
+			}
+			inputArgs.push(arg);
+		}
 		const url = inputArgs[0];
-		const isHelpLike = inputArgs.some(
-			(arg) =>
-				arg === "-h" || arg === "--help" || arg === "-V" || arg === "--version",
-		);
+		const isHelpLike = ifFlag(args, ["-h", "--help", "-V", "--version"]);
 
 		if (!url) {
 			return { stderr: "curl: missing URL", exitCode: 1 };

package/src/VirtualShell/commands/echo.ts

@@ -0,0 +1,34 @@
+import type { ShellModule } from "../../types/commands";
+import { getArg, ifFlag } from "./command-helpers";
+import { getAllEnvVars } from "./set";
+
+function expandEnvVars(input: string, env: Record<string, string>): string {
+	return input.replace(/\$([A-Za-z_][A-Za-z0-9_]*)/g, (_, name: string) => {
+		return env[name] ?? "";
+	});
+}
+
+export const echoCommand: ShellModule = {
+	name: "echo",
+	params: ["[options] [text...]"],
+	run: ({ args, authUser, stdin }) => {
+		const newline = !ifFlag(args, "-n");
+		const filteredArgs: string[] = [];
+		for (let index = 0; ; index += 1) {
+			const value = getArg(args, index, { flags: ["-n"] });
+			if (value === undefined) {
+				break;
+			}
+			filteredArgs.push(value);
+		}
+		const env = getAllEnvVars(authUser);
+		const rawText =
+			filteredArgs.length > 0 ? filteredArgs.join(" ") : (stdin ?? "");
+		const text = expandEnvVars(rawText, env);
+
+		return {
+			stdout: newline ? text : text.trimEnd(),
+			exitCode: 0,
+		};
+	},
+};

package/src/VirtualShell/commands/env.ts

@@ -0,0 +1,22 @@
+import type { ShellModule } from "../../types/commands";
+import { getAllEnvVars } from "./set";
+
+export const envCommand: ShellModule = {
+	name: "env",
+	params: ["[VAR=value...] [command]"],
+	run: ({ authUser }) => {
+		// For now, just display all environment variables
+		// In a full implementation, this would also handle running commands with modified env
+
+		const allVars = getAllEnvVars(authUser);
+		const envVarsOutput = Object.entries(allVars)
+			.map(([key, value]) => `${key}=${value}`)
+			.sort()
+			.join("\n");
+
+		return {
+			stdout: envVarsOutput,
+			exitCode: 0,
+		};
+	},
+};

package/src/VirtualShell/commands/export.ts

@@ -0,0 +1,38 @@
+import type { ShellModule } from "../../types/commands";
+import { getArg } from "./command-helpers";
+import { getEnvVar, setEnvVar } from "./set";
+
+export const exportCommand: ShellModule = {
+	name: "export",
+	params: ["[VAR=value]"],
+	run: ({ args }) => {
+		// export VAR=value or export VAR (to make it available to child processes)
+		if (args.length === 0) {
+			// List all exported variables
+			return {
+				stdout: "# export command - sets variables for child processes",
+				exitCode: 0,
+			};
+		}
+
+		// Parse VAR=value format
+		for (let index = 0; ; index += 1) {
+			const arg = getArg(args, index);
+			if (!arg) {
+				break;
+			}
+
+			if (arg.includes("=")) {
+				const [varName, varValue] = arg.split("=", 2);
+				if (varName && varValue !== undefined) {
+					setEnvVar(varName, varValue);
+				}
+			} else {
+				// export VAR_NAME makes it available but we just set it
+				setEnvVar(arg, getEnvVar(arg) || "");
+			}
+		}
+
+		return { exitCode: 0 };
+	},
+};

package/src/VirtualShell/commands/grep.ts

@@ -0,0 +1,88 @@
+import type { ShellModule } from "../../types/commands";
+import { getArg, ifFlag } 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);
+		}
+
+		if (!pattern) {
+			return { stderr: "grep: no pattern specified", exitCode: 1 };
+		}
+
+		let regex: RegExp;
+		try {
+			const flags = caseInsensitive ? "gmi" : "gm";
+			regex = new RegExp(pattern, flags);
+		} catch {
+			return { stderr: `grep: invalid regex: ${pattern}`, exitCode: 1 };
+		}
+
+		const results: string[] = [];
+
+		// If no files specified, read from stdin (pipe/input redirection).
+		if (files.length === 0) {
+			if (!stdin) {
+				return { stdout: "", exitCode: 1 };
+			}
+
+			const lines = stdin.split("\n");
+			for (const line of lines) {
+				regex.lastIndex = 0;
+				const matches = regex.test(line);
+				const shouldInclude = invertMatch ? !matches : matches;
+
+				if (shouldInclude) {
+					results.push(line);
+				}
+			}
+
+			return {
+				stdout: results.length > 0 ? results.join("\n") : "",
+				exitCode: results.length > 0 ? 0 : 1,
+			};
+		}
+
+		for (const file of files) {
+			const target = resolvePath(cwd, file);
+			try {
+				assertPathAccess(authUser, target, "grep");
+				const content = vfs.readFile(target);
+				const lines = content.split("\n");
+
+				for (const line of lines) {
+					regex.lastIndex = 0;
+					const matches = regex.test(line);
+					const shouldInclude = invertMatch ? !matches : matches;
+
+					if (shouldInclude) {
+						results.push(line);
+					}
+				}
+			} catch {
+				return {
+					stderr: `grep: ${file}: No such file or directory`,
+					exitCode: 1,
+				};
+			}
+		}
+
+		return {
+			stdout: results.length > 0 ? results.join("\n") : "",
+			exitCode: results.length > 0 ? 0 : 1,
+		};
+	},
+};

package/src/{SSHMimic → VirtualShell}/commands/helpers.ts

@@ -58,43 +58,6 @@ export function assertPathAccess(
 	}
 }
 
-export function parseOutputPath(args: string[]): {
-	outputPath: string | null;
-	inputArgs: string[];
-} {
-	const filtered: string[] = [];
-	let outputPath: string | null = null;
-
-	for (let index = 0; index < args.length; index += 1) {
-		const arg = args[index]!;
-
-		if (
-			arg === "-o" ||
-			arg === "-O" ||
-			arg === "--output" ||
-			arg === "--output-document"
-		) {
-			outputPath = args[index + 1] ?? null;
-			index += 1;
-			continue;
-		}
-
-		if (arg.startsWith("-o=")) {
-			outputPath = arg.slice(3);
-			continue;
-		}
-
-		if (arg.startsWith("-O=")) {
-			outputPath = arg.slice(3);
-			continue;
-		}
-
-		filtered.push(arg);
-	}
-
-	return { outputPath, inputArgs: filtered };
-}
-
 export function stripUrlFilename(url: string): string {
 	const cleaned = url.split("?")[0]?.split("#")[0] ?? url;
 	const lastPart = cleaned.split("/").filter(Boolean).pop();

package/src/VirtualShell/commands/index.ts

@@ -0,0 +1,327 @@
+import type { VirtualUserManager } from "../../SSHMimic/users";
+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";
+import { clearCommand } from "./clear";
+import { curlCommand } from "./curl";
+import { deluserCommand } from "./deluser";
+import { echoCommand } from "./echo";
+import { envCommand } from "./env";
+import { exitCommand } from "./exit";
+import { exportCommand } from "./export";
+import { grepCommand } from "./grep";
+import { createHelpCommand } from "./help";
+import { hostnameCommand } from "./hostname";
+import { htopCommand } from "./htop";
+import { lsCommand } from "./ls";
+import { mkdirCommand } from "./mkdir";
+import { nanoCommand } from "./nano";
+import { pwdCommand } from "./pwd";
+import { rmCommand } from "./rm";
+import { setCommand } from "./set";
+import { shCommand } from "./sh";
+import { suCommand } from "./su";
+import { sudoCommand } from "./sudo";
+import { touchCommand } from "./touch";
+import { treeCommand } from "./tree";
+import { unsetCommand } from "./unset";
+import { wgetCommand } from "./wget";
+import { whoCommand } from "./who";
+import { whoamiCommand } from "./whoami";
+
+const BASE_COMMANDS: ShellModule[] = [
+	pwdCommand,
+	whoamiCommand,
+	whoCommand,
+	hostnameCommand,
+	lsCommand,
+	cdCommand,
+	catCommand,
+	echoCommand,
+	mkdirCommand,
+	touchCommand,
+	rmCommand,
+	treeCommand,
+	nanoCommand,
+	htopCommand,
+	adduserCommand,
+	deluserCommand,
+	sudoCommand,
+	suCommand,
+	curlCommand,
+	envCommand,
+	wgetCommand,
+	grepCommand,
+	exportCommand,
+	setCommand,
+	unsetCommand,
+	shCommand,
+	clearCommand,
+	exitCommand,
+];
+
+const customCommands: ShellModule[] = [];
+
+const helpCommand = createHelpCommand(() =>
+	getCommandModules().map((cmd) => cmd.name),
+);
+
+function getCommandModules(): ShellModule[] {
+	return [...BASE_COMMANDS, ...customCommands, helpCommand];
+}
+
+function getTakenCommandNames(modules: ShellModule[]): Set<string> {
+	const taken = new Set<string>();
+	for (const mod of modules) {
+		taken.add(mod.name);
+		for (const alias of mod.aliases ?? []) {
+			taken.add(alias);
+		}
+	}
+	return taken;
+}
+
+export function registerCommand(module: ShellModule): void {
+	const normalized: ShellModule = {
+		...module,
+		name: module.name.trim().toLowerCase(),
+		aliases: module.aliases?.map((alias) => alias.trim().toLowerCase()),
+	};
+
+	const names = [normalized.name, ...(normalized.aliases ?? [])];
+	if (names.some((name) => name.length === 0 || /\s/.test(name))) {
+		throw new Error(
+			"Command names and aliases must be non-empty and contain no spaces",
+		);
+	}
+
+	const takenNames = getTakenCommandNames(getCommandModules());
+	const conflict = names.find((name) => takenNames.has(name));
+	if (conflict) {
+		throw new Error(`Command '${conflict}' already exists`);
+	}
+
+	customCommands.push(normalized);
+}
+
+export function createCustomCommand(
+	name: string,
+	params: string[],
+	run: (ctx: CommandContext) => CommandResult | Promise<CommandResult>,
+): ShellModule {
+	return {
+		name,
+		params,
+		run,
+	};
+}
+
+export function getCommandNames(): string[] {
+	return getCommandModules().flatMap((cmd) => [
+		cmd.name,
+		...(cmd.aliases ?? []),
+	]);
+}
+
+function resolveModule(name: string): ShellModule | undefined {
+	const lowered = name.toLowerCase();
+	return getCommandModules().find(
+		(cmd) => cmd.name === lowered || cmd.aliases?.includes(lowered),
+	);
+}
+
+function splitArgsRespectingQuotes(input: string): string[] {
+	const tokens: string[] = [];
+	let current = "";
+	let inQuotes = false;
+	let quoteChar = "";
+
+	for (let i = 0; i < input.length; i += 1) {
+		const ch = input[i] || "";
+		const prev = i > 0 ? input[i - 1] : "";
+
+		if ((ch === '"' || ch === "'") && prev !== "\\") {
+			if (!inQuotes) {
+				inQuotes = true;
+				quoteChar = ch;
+				continue;
+			}
+
+			if (ch === quoteChar) {
+				inQuotes = false;
+				quoteChar = "";
+				continue;
+			}
+		}
+
+		if (/\s/.test(ch) && !inQuotes) {
+			if (current.length > 0) {
+				tokens.push(current);
+				current = "";
+			}
+			continue;
+		}
+
+		current += ch;
+	}
+
+	if (current.length > 0) {
+		tokens.push(current);
+	}
+
+	return tokens;
+}
+
+function parseInput(rawInput: string): { commandName: string; args: string[] } {
+	const parts = splitArgsRespectingQuotes(rawInput.trim());
+	return {
+		commandName: parts[0]?.toLowerCase() ?? "",
+		args: parts.slice(1),
+	};
+}
+
+// Internal async function for pipeline execution
+async function runCommandInternal(
+	rawInput: string,
+	authUser: string,
+	hostname: string,
+	users: VirtualUserManager,
+	mode: CommandMode,
+	cwd: string,
+	vfs: VirtualFileSystem,
+	stdin?: string,
+): Promise<CommandResult> {
+	// Check if input contains pipes or redirections
+	if (
+		rawInput.includes("|") ||
+		rawInput.includes(">") ||
+		rawInput.includes("<")
+	) {
+		// Use pipeline executor
+		const { parseShellPipeline } = await import("../shellParser");
+		const { executePipeline } = await import("../../SSHMimic/executor");
+
+		const pipeline = parseShellPipeline(rawInput);
+		if (!pipeline.isValid) {
+			return {
+				stderr: pipeline.error || "Syntax error",
+				exitCode: 1,
+			};
+		}
+
+		try {
+			return await executePipeline(
+				pipeline,
+				authUser,
+				hostname,
+				users,
+				mode,
+				cwd,
+				vfs,
+			);
+		} catch (error: unknown) {
+			const message =
+				error instanceof Error ? error.message : "Pipeline execution failed";
+			return { stderr: message, exitCode: 1 };
+		}
+	}
+
+	// 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,
+			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,
+	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,
+			vfs,
+			stdin,
+		);
+	}
+
+	// Regular synchronous command execution
+	const { commandName, args } = parseInput(trimmed);
+	const mod = resolveModule(commandName);
+
+	if (!mod) {
+		return {
+			stderr: `Command '${trimmed}' not found`,
+			exitCode: 127,
+		};
+	}
+
+	try {
+		return mod.run({
+			authUser,
+			hostname,
+			users,
+			activeSessions: users.listActiveSessions(),
+			rawInput: trimmed,
+			mode,
+			args,
+			stdin,
+			cwd,
+			vfs,
+		});
+	} catch (error: unknown) {
+		const message = error instanceof Error ? error.message : "Command failed";
+		return { stderr: message, exitCode: 1 };
+	}
+}

package/src/{SSHMimic → VirtualShell}/commands/ls.ts

@@ -1,4 +1,5 @@
 import type { ShellModule } from "../../types/commands";
+import { getArg, ifFlag } from "./command-helpers";
 import { assertPathAccess, joinListWithType, resolvePath } from "./helpers";
 
 function formatPermissions(mode: number, isDirectory: boolean): string {
@@ -29,8 +30,8 @@ export const lsCommand: ShellModule = {
 	name: "ls",
 	params: ["[path]"],
 	run: ({ authUser, vfs, cwd, args }) => {
-		const longFormat = args.includes("-l") || args.includes("--long");
-		const targetArg = args.find((arg) => !arg.startsWith("-"));
+		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("."));

package/src/{SSHMimic → VirtualShell}/commands/mkdir.ts

@@ -1,4 +1,5 @@
 import type { ShellModule } from "../../types/commands";
+import { getArg } from "./command-helpers";
 import { assertPathAccess, resolvePath } from "./helpers";
 
 export const mkdirCommand: ShellModule = {
@@ -9,7 +10,11 @@ export const mkdirCommand: ShellModule = {
 			return { stderr: "mkdir: missing operand", exitCode: 1 };
 		}
 
-		for (const dir of args) {
+		for (let index = 0; index < args.length; index++) {
+			const dir = getArg(args, index);
+			if (!dir) {
+				return { stderr: "mkdir: missing operand", exitCode: 1 };
+			}
 			const target = resolvePath(cwd, dir);
 			assertPathAccess(authUser, target, "mkdir");
 			vfs.mkdir(target);

package/src/{SSHMimic → VirtualShell}/commands/rm.ts

@@ -1,4 +1,5 @@
 import type { ShellModule } from "../../types/commands";
+import { getArg, ifFlag } from "./command-helpers";
 import { assertPathAccess, resolvePath } from "./helpers";
 
 export const rmCommand: ShellModule = {
@@ -9,9 +10,15 @@ export const rmCommand: ShellModule = {
 			return { stderr: "rm: missing operand", exitCode: 1 };
 		}
 
-		const recursive =
-			args.includes("-r") || args.includes("-rf") || args.includes("-fr");
-		const targets = args.filter((arg) => !arg.startsWith("-"));
+		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 };