typescript-virtual-container 1.0.1 → 1.0.4

package/src/SSHMimic/commands/index.ts

@@ -1,6 +1,7 @@
 import type {
 	CommandMode,
 	CommandOutcome,
+	CommandResult,
 	ShellModule,
 } from "../../types/commands";
 import type VirtualFileSystem from "../../VirtualFileSystem";
@@ -11,7 +12,11 @@ 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";
@@ -20,10 +25,13 @@ 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";
@@ -36,6 +44,7 @@ const BASE_COMMANDS: ShellModule[] = [
 	lsCommand,
 	cdCommand,
 	catCommand,
+	echoCommand,
 	mkdirCommand,
 	touchCommand,
 	rmCommand,
@@ -47,7 +56,13 @@ const BASE_COMMANDS: ShellModule[] = [
 	sudoCommand,
 	suCommand,
 	curlCommand,
+	envCommand,
 	wgetCommand,
+	grepCommand,
+	exportCommand,
+	setCommand,
+	unsetCommand,
+	shCommand,
 	clearCommand,
 	exitCommand,
 ];
@@ -68,14 +83,134 @@ function resolveModule(name: string): ShellModule | undefined {
 	);
 }
 
+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 = rawInput.trim().split(/\s+/).filter(Boolean);
+	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("../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,
@@ -84,6 +219,7 @@ export function runCommand(
 	mode: CommandMode,
 	cwd: string,
 	vfs: VirtualFileSystem,
+	stdin?: string,
 ): CommandOutcome {
 	const trimmed = rawInput.trim();
 
@@ -91,6 +227,21 @@ export function runCommand(
 		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);
 
@@ -110,6 +261,7 @@ export function runCommand(
 			rawInput: trimmed,
 			mode,
 			args,
+			stdin,
 			cwd,
 			vfs,
 		});

package/src/SSHMimic/commands/ls.ts

@@ -1,5 +1,5 @@
 import type { ShellModule } from "../../types/commands";
-import { joinListWithType, resolvePath } from "./helpers";
+import { assertPathAccess, joinListWithType, resolvePath } from "./helpers";
 
 function formatPermissions(mode: number, isDirectory: boolean): string {
 	const fileType = isDirectory ? "d" : "-";
@@ -28,10 +28,11 @@ function formatDate(date: Date): string {
 export const lsCommand: ShellModule = {
 	name: "ls",
 	params: ["[path]"],
-	run: ({ vfs, cwd, args }) => {
+	run: ({ authUser, vfs, cwd, args }) => {
 		const longFormat = args.includes("-l") || args.includes("--long");
 		const targetArg = args.find((arg) => !arg.startsWith("-"));
 		const target = resolvePath(cwd, targetArg ?? cwd);
+		assertPathAccess(authUser, target, "ls");
 		const items = vfs.list(target).filter((name) => !name.startsWith("."));
 		const rendered = longFormat
 			? items

package/src/SSHMimic/commands/mkdir.ts

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

package/src/SSHMimic/commands/nano.ts

@@ -1,17 +1,18 @@
 import * as path from "node:path";
 import type { ShellModule } from "../../types/commands";
-import { resolvePath } from "./helpers";
+import { assertPathAccess, resolvePath } from "./helpers";
 
 export const nanoCommand: ShellModule = {
 	name: "nano",
 	params: ["<file>"],
-	run: ({ vfs, cwd, args }) => {
+	run: ({ authUser, vfs, cwd, args }) => {
 		const fileArg = args[0];
 		if (!fileArg) {
 			return { stderr: "nano: missing file operand", exitCode: 1 };
 		}
 
 		const targetPath = resolvePath(cwd, fileArg);
+		assertPathAccess(authUser, targetPath, "nano");
 		const initialContent = vfs.exists(targetPath)
 			? vfs.readFile(targetPath)
 			: "";

package/src/SSHMimic/commands/rm.ts

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

package/src/SSHMimic/commands/set.ts

@@ -0,0 +1,67 @@
+/** biome-ignore-all lint/style/useNamingConvention: env variables */
+import type { ShellModule } from "../../types/commands";
+
+// Simple in-memory environment variables store
+// In a real implementation, this would be per-session/per-user
+const envVars: Record<string, string> = {
+	PATH: "/usr/local/bin:/usr/bin:/bin",
+	HOME: "/home/user",
+	SHELL: "/bin/sh",
+	TERM: "xterm-256color",
+	USER: "user",
+};
+
+export function getEnvVar(name: string): string | undefined {
+	return envVars[name];
+}
+
+export function setEnvVar(name: string, value: string): void {
+	envVars[name] = value;
+}
+
+export function getAllEnvVars(authUser: string): Record<string, string> {
+	envVars.USER = authUser;
+	envVars.HOME = `/home/${authUser}`;
+	return { ...envVars };
+}
+
+export const setCommand: ShellModule = {
+	name: "set",
+	params: ["[VAR=value]"],
+	run: ({ args }) => {
+		// No arguments: display all environment variables
+		if (args.length === 0) {
+			const output = Object.entries(envVars)
+				.map(([key, value]) => `${key}=${value}`)
+				.sort()
+				.join("\n");
+
+			return { stdout: output, exitCode: 0 };
+		}
+
+		// Parse VAR=value format
+		const assignments: string[] = [];
+		for (const arg of args) {
+			if (arg.includes("=")) {
+				const [varName, varValue] = arg.split("=", 2);
+				if (varName && varValue !== undefined) {
+					setEnvVar(varName, varValue);
+					assignments.push(arg);
+				}
+			} else {
+				// If no '=' present, display that specific variable
+				const value = getEnvVar(arg);
+				if (value !== undefined) {
+					assignments.push(`${arg}=${value}`);
+				} else {
+					assignments.push(`${arg}: not set`);
+				}
+			}
+		}
+
+		return {
+			stdout: assignments.length > 0 ? assignments.join("\n") : "",
+			exitCode: 0,
+		};
+	},
+};

package/src/SSHMimic/commands/sh.ts

@@ -0,0 +1,121 @@
+import type { CommandContext, ShellModule } from "../../types/commands";
+import { runCommand } from "./index";
+
+/** Simple shell script executor with basic variable support */
+export const shCommand: ShellModule = {
+	name: "sh",
+	params: ["-c <script>", "[<file>]"],
+	aliases: ["bash"],
+	run: async (ctx: CommandContext) => {
+		const { vfs, args, authUser, hostname, users, mode, cwd } = ctx;
+
+		// Handle -c option: sh -c "command"
+		if (args[0] === "-c" && args.length >= 2) {
+			const script = args[1] ?? "";
+			if (!script) {
+				return { stderr: "sh: -c requires a script", exitCode: 1 };
+			}
+			const scriptArgs = args.slice(2);
+
+			// Split by semicolon and newline
+			const lines = script
+				.split(/[;\n]/)
+				.map((line) => line.trim())
+				.filter((line) => line && !line.startsWith("#"));
+
+			let output = "";
+			let exitCode = 0;
+
+			for (const line of lines) {
+				// Simple variable substitution
+				let command = line;
+				for (let i = 0; i < scriptArgs.length; i++) {
+					const arg = scriptArgs[i] ?? "";
+					command = command.replaceAll(`$${i}`, arg);
+				}
+				command = command.replaceAll("$@", scriptArgs.join(" "));
+
+				// Execute the command
+				const result = await Promise.resolve(
+					runCommand(command, authUser, hostname, users, mode, cwd, vfs),
+				);
+
+				if (result.stdout) {
+					output += `${result.stdout}\n`;
+				}
+
+				if (result.stderr) {
+					return { stderr: result.stderr, exitCode: result.exitCode ?? 1 };
+				}
+
+				exitCode = result.exitCode ?? 0;
+				if (exitCode !== 0) {
+					break;
+				}
+			}
+
+			return {
+				stdout: output.trimEnd(),
+				exitCode,
+			};
+		}
+
+		// Handle script file execution: sh <file>
+		if (args.length > 0 && args[0]) {
+			try {
+				const scriptFile = args[0];
+				const content = vfs.readFile(scriptFile);
+				const scriptArgs = args.slice(1);
+
+				// Split by newline
+				const lines = content
+					.split("\n")
+					.map((line) => line.trim())
+					.filter((line) => line && !line.startsWith("#"));
+
+				let output = "";
+				let exitCode = 0;
+
+				for (const line of lines) {
+					// Simple variable substitution
+					let command = line;
+					for (let i = 0; i < scriptArgs.length; i++) {
+						const arg = scriptArgs[i] ?? "";
+						command = command.replaceAll(`$${i}`, arg);
+					}
+					command = command.replaceAll("$@", scriptArgs.join(" "));
+
+					// Execute the command
+					const result = await Promise.resolve(
+						runCommand(command, authUser, hostname, users, mode, cwd, vfs),
+					);
+
+					if (result.stdout) {
+						output += `${result.stdout}\n`;
+					}
+
+					if (result.stderr) {
+						return { stderr: result.stderr, exitCode: result.exitCode ?? 1 };
+					}
+
+					exitCode = result.exitCode ?? 0;
+					if (exitCode !== 0) {
+						break;
+					}
+				}
+
+				return {
+					stdout: output.trimEnd(),
+					exitCode,
+				};
+			} catch {
+				return {
+					stderr: `sh: ${args[0]}: No such file or directory`,
+					exitCode: 1,
+				};
+			}
+		}
+
+		return { stderr: "sh: missing operand or script", exitCode: 1 };
+	},
+};

package/src/SSHMimic/commands/touch.ts

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

package/src/SSHMimic/commands/tree.ts

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

package/src/SSHMimic/commands/unset.ts

@@ -0,0 +1,19 @@
+import type { ShellModule } from "../../types/commands";
+import { setEnvVar } from "./set";
+
+export const unsetCommand: ShellModule = {
+	name: "unset",
+	params: ["<VAR...>"],
+	run: ({ args }) => {
+		if (args.length === 0) {
+			return { stderr: "unset: missing variable name", exitCode: 1 };
+		}
+
+		// Unset (remove) all specified variables
+		for (const varName of args) {
+			setEnvVar(varName, "");
+		}
+
+		return { exitCode: 0 };
+	},
+};

package/src/SSHMimic/commands/wget.ts

@@ -4,6 +4,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import type { ShellModule } from "../../types/commands";
 import {
+	assertPathAccess,
 	normalizeTerminalOutput,
 	parseOutputPath,
 	resolvePath,
@@ -81,7 +82,7 @@ function runHostWget(args: string[]): Promise<{
 export const wgetCommand: ShellModule = {
 	name: "wget",
 	params: ["[url]"],
-	run: async ({ vfs, cwd, args }) => {
+	run: async ({ authUser, vfs, cwd, args }) => {
 		const { outputPath, inputArgs } = parseOutputPath(args);
 		const url = inputArgs[0];
 		const isHelpLike = inputArgs.some(
@@ -122,6 +123,7 @@ export const wgetCommand: ShellModule = {
 
 			const content = await readFile(tempFile, "utf8");
 			const target = resolvePath(cwd, outputPath ?? stripUrlFilename(url));
+			assertPathAccess(authUser, target, "wget");
 			vfs.writeFile(target, content);
 
 			return {