typescript-virtual-container 1.0.3 → 1.0.5

package/src/VirtualShell/commands/set.ts

@@ -0,0 +1,73 @@
+/** biome-ignore-all lint/style/useNamingConvention: env variables */
+import type { ShellModule } from "../../types/commands";
+import { getArg } from "./command-helpers";
+
+// 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 (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);
+					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/VirtualShell/commands/sh.ts

@@ -0,0 +1,58 @@
+import type { CommandContext, ShellModule } from "../../types/commands";
+import { getArg, getFlag } from "./command-helpers";
+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 (getFlag(args, "-c") && args.length >= 2) {
+			const script = getArg(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 = "";
+			const 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 };
+				}
+			}
+
+			return { stdout: output.trim(), exitCode };
+		}
+
+		return { stderr: "sh: invalid usage", exitCode: 1 };
+	},
+};

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

@@ -1,11 +1,11 @@
 import type { ShellModule } from "../../types/commands";
+import { getArg } from "./command-helpers";
 
 export const suCommand: ShellModule = {
 	name: "su",
 	params: ["- <username>"],
 	run: ({ authUser, users, args }) => {
-		const filtered = args.filter((arg) => arg !== "-");
-		const targetUser = filtered[0];
+		const targetUser = getArg(args, 0, { flags: ["-"] });
 
 		if (!targetUser) {
 			return { stderr: "su: missing username", exitCode: 1 };
@@ -16,7 +16,7 @@ export const suCommand: ShellModule = {
 		}
 
 		if (
-			!users.verifyPassword(targetUser, filtered[1] ?? "") &&
+			!users.verifyPassword(targetUser, getArg(args, 1) ?? "") &&
 			authUser !== "root"
 		) {
 			return { stderr: "su: authentication failure", exitCode: 1 };

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

@@ -1,4 +1,5 @@
 import type { ShellModule } from "../../types/commands";
+import { getArg, getFlag, ifFlag } from "./command-helpers";
 import { runCommand } from "./index";
 
 function parseSudoArgs(args: string[]): {
@@ -6,34 +7,23 @@ function parseSudoArgs(args: string[]): {
 	loginShell: boolean;
 	commandLine: string | null;
 } {
-	let targetUser = "root";
-	let loginShell = false;
-	const commandParts: string[] = [];
-
-	for (let index = 0; index < args.length; index += 1) {
-		const arg = args[index]!;
-
-		if (arg === "-i") {
-			loginShell = true;
-			continue;
-		}
-
-		if (arg === "-S") {
-			continue;
-		}
-
-		if (arg === "-u") {
-			targetUser = args[index + 1] ?? "root";
-			index += 1;
-			continue;
-		}
+	const loginShell = ifFlag(args, "-i");
+	const targetUserValue = getFlag(args, ["-u", "--user"]);
+	const targetUser =
+		typeof targetUserValue === "string" && targetUserValue.length > 0
+			? targetUserValue
+			: "root";
 
-		if (arg.startsWith("-u=")) {
-			targetUser = arg.slice(3) || "root";
-			continue;
+	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(arg);
+		commandParts.push(part);
 	}
 
 	const commandLine = commandParts.length > 0 ? commandParts.join(" ") : null;

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

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

package/src/VirtualShell/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 → VirtualShell}/commands/wget.ts

@@ -3,10 +3,10 @@ import { mkdtemp, readFile, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import type { ShellModule } from "../../types/commands";
+import { getArg, getFlag, ifFlag } from "./command-helpers";
 import {
 	assertPathAccess,
 	normalizeTerminalOutput,
-	parseOutputPath,
 	resolvePath,
 	stripUrlFilename,
 } from "./helpers";
@@ -83,12 +83,29 @@ export const wgetCommand: ShellModule = {
 	name: "wget",
 	params: ["[url]"],
 	run: async ({ authUser, vfs, cwd, args }) => {
-		const { outputPath, inputArgs } = parseOutputPath(args);
+		const outputPathValue = getFlag(args, [
+			"-o",
+			"-O",
+			"--output",
+			"--output-document",
+		]);
+		const outputPath =
+			typeof outputPathValue === "string" && outputPathValue.length > 0
+				? outputPathValue
+				: null;
+		const parserOptions = {
+			flagsWithValue: ["-o", "-O", "--output", "--output-document"],
+		};
+		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: "wget: missing URL", exitCode: 1 };

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

@@ -1,5 +1,5 @@
+import { formatLoginDate } from "../../SSHMimic/loginFormat";
 import type { ShellModule } from "../../types/commands";
-import { formatLoginDate } from "../loginFormat";
 
 export const whoCommand: ShellModule = {
 	name: "who",

package/src/VirtualShell/index.ts

@@ -0,0 +1,69 @@
+import type { VirtualUserManager } from "../SSHMimic/users";
+import type { CommandContext, CommandResult } from "../types/commands";
+import type { ShellStream } from "../types/streams";
+import type VirtualFileSystem from "../VirtualFileSystem";
+import { createCustomCommand, registerCommand, runCommand } from "./commands";
+import { startShell } from "./shell";
+
+class VirtualShell {
+	private vfs: VirtualFileSystem;
+	private users: VirtualUserManager;
+	private hostname: string;
+
+	constructor(
+		vfs: VirtualFileSystem,
+		users: VirtualUserManager,
+		hostname: string,
+	) {
+		this.vfs = vfs;
+		this.users = users;
+		this.hostname = hostname;
+	}
+
+	addCommand(
+		name: string,
+		params: string[],
+		callback: (ctx: CommandContext) => CommandResult | Promise<CommandResult>,
+	): void {
+		const normalized = name.trim().toLowerCase();
+		if (normalized.length === 0 || /\s/.test(normalized)) {
+			throw new Error("Command name must be non-empty and contain no spaces");
+		}
+
+		registerCommand(createCustomCommand(normalized, params, callback));
+	}
+
+	executeCommand(rawInput: string, authUser: string, cwd: string): void {
+		runCommand(
+			rawInput,
+			authUser,
+			this.hostname,
+			this.users,
+			"shell",
+			cwd,
+			this.vfs,
+		);
+	}
+
+	startInteractiveSession(
+		stream: ShellStream,
+		authUser: string,
+		sessionId: string | null,
+		remoteAddress: string,
+		terminalSize: { cols: number; rows: number },
+	): void {
+		// Interactive shell logic
+		startShell(
+			stream,
+			authUser,
+			this.vfs!,
+			this.hostname,
+			this.users!,
+			sessionId,
+			remoteAddress,
+			terminalSize,
+		);
+	}
+}
+
+export { VirtualShell };

package/src/{SSHMimic → VirtualShell}/shell.ts

@@ -1,12 +1,12 @@
 import { type ChildProcessWithoutNullStreams, spawn } from "node:child_process";
 import { readFile, unlink, writeFile } from "node:fs/promises";
 import * as path from "node:path";
+import { formatLoginDate } from "../SSHMimic/loginFormat";
+import { buildPrompt } from "../SSHMimic/prompt";
+import type { VirtualUserManager } from "../SSHMimic/users";
 import type { ShellStream } from "../types/streams";
 import type VirtualFileSystem from "../VirtualFileSystem";
 import { getCommandNames, runCommand } from "./commands";
-import { formatLoginDate } from "./loginFormat";
-import { buildPrompt } from "./prompt";
-import type { VirtualUserManager } from "./users";
 
 interface NanoSession {
 	kind: "nano" | "htop";

package/src/VirtualShell/shellParser.ts

@@ -0,0 +1,203 @@
+import type { Pipeline, PipelineCommand } from "../types/pipeline";
+
+/** Parse a shell command line into a structured pipeline */
+export function parseShellPipeline(rawInput: string): Pipeline {
+	const trimmed = rawInput.trim();
+
+	if (!trimmed) {
+		return { commands: [], isValid: true };
+	}
+
+	const commands: PipelineCommand[] = [];
+	const pipeTokens = tokenizePipeline(trimmed);
+
+	for (const token of pipeTokens) {
+		const cmd = parseCommandWithRedirections(token);
+		if (!cmd.isValid) {
+			return {
+				commands: [],
+				isValid: false,
+				error: cmd.error,
+			};
+		}
+		if (cmd.command) {
+			commands.push(cmd.command);
+		}
+	}
+
+	return { commands, isValid: true };
+}
+
+/** Tokenize input by pipes, respecting quoted strings */
+function tokenizePipeline(input: string): string[] {
+	const tokens: string[] = [];
+	let current = "";
+	let inQuotes = false;
+	let quoteChar = "";
+	let i = 0;
+
+	while (i < input.length) {
+		const ch = input[i];
+
+		if ((ch === '"' || ch === "'") && (i === 0 || input[i - 1] !== "\\")) {
+			if (!inQuotes) {
+				inQuotes = true;
+				quoteChar = ch;
+			} else if (ch === quoteChar) {
+				inQuotes = false;
+			}
+			current += ch;
+			i++;
+		} else if (ch === "|" && !inQuotes) {
+			if (current.trim()) {
+				tokens.push(current.trim());
+			}
+			current = "";
+			i++;
+		} else {
+			current += ch;
+			i++;
+		}
+	}
+
+	if (current.trim()) {
+		tokens.push(current.trim());
+	}
+
+	return tokens;
+}
+
+interface ParseResult {
+	command?: PipelineCommand;
+	isValid: boolean;
+	error?: string;
+}
+
+/** Parse a single command with its redirections (>, >>, <) */
+function parseCommandWithRedirections(token: string): ParseResult {
+	const parts = tokenizeCommand(token);
+
+	if (parts.length === 0) {
+		return { isValid: true };
+	}
+
+	const cmdParts: string[] = [];
+	let inputFile: string | undefined;
+	let outputFile: string | undefined;
+	let appendOutput = false;
+
+	let i = 0;
+	while (i < parts.length) {
+		const part = parts[i] as string;
+
+		if (part === "<") {
+			i++;
+			if (i >= parts.length) {
+				return {
+					isValid: false,
+					error: "Syntax error: expected filename after <",
+				};
+			}
+			inputFile = parts[i];
+			i++;
+		} else if (part === ">>") {
+			i++;
+			if (i >= parts.length) {
+				return {
+					isValid: false,
+					error: "Syntax error: expected filename after >>",
+				};
+			}
+			outputFile = parts[i];
+			appendOutput = true;
+			i++;
+		} else if (part === ">") {
+			i++;
+			if (i >= parts.length) {
+				return {
+					isValid: false,
+					error: "Syntax error: expected filename after >",
+				};
+			}
+			outputFile = parts[i];
+			appendOutput = false;
+			i++;
+		} else {
+			cmdParts.push(part);
+			i++;
+		}
+	}
+
+	if (cmdParts.length === 0) {
+		return { isValid: true };
+	}
+
+	const name = (cmdParts[0] as string).toLowerCase();
+	const args = cmdParts.slice(1);
+
+	return {
+		command: {
+			name,
+			args,
+			inputFile,
+			outputFile,
+			appendOutput,
+		},
+		isValid: true,
+	};
+}
+
+/** Tokenize a command, respecting quotes and handling >> vs > */
+function tokenizeCommand(input: string): string[] {
+	const tokens: string[] = [];
+	let current = "";
+	let inQuotes = false;
+	let quoteChar = "";
+	let i = 0;
+
+	while (i < input.length) {
+		const ch = input[i];
+		const next = input[i + 1];
+
+		// Handle quotes
+		if ((ch === '"' || ch === "'") && (i === 0 || input[i - 1] !== "\\")) {
+			if (!inQuotes) {
+				inQuotes = true;
+				quoteChar = ch;
+			} else if (ch === quoteChar) {
+				inQuotes = false;
+				quoteChar = "";
+			} else {
+				current += ch;
+			}
+			i++;
+		} else if (ch === " " && !inQuotes) {
+			if (current) {
+				tokens.push(current);
+				current = "";
+			}
+			i++;
+		} else if ((ch === ">" || ch === "<") && !inQuotes) {
+			if (current) {
+				tokens.push(current);
+				current = "";
+			}
+			if (ch === ">" && next === ">") {
+				tokens.push(">>");
+				i += 2;
+			} else {
+				tokens.push(ch);
+				i++;
+			}
+		} else {
+			current += ch;
+			i++;
+		}
+	}
+
+	if (current) {
+		tokens.push(current);
+	}
+
+	return tokens;
+}

package/src/index.ts

@@ -2,6 +2,7 @@ import { SshClient } from "./SSHMimic/client";
 import { SshMimic } from "./SSHMimic/index";
 import { VirtualUserManager } from "./SSHMimic/users";
 import VirtualFileSystem from "./VirtualFileSystem";
+import type { VirtualShell } from "./VirtualShell";
 
 export type {
 	CommandContext,
@@ -33,4 +34,11 @@ export {
 	VirtualFileSystem,
 	SshMimic as VirtualMachine,
 	VirtualUserManager,
+	type VirtualShell,
 };
+
+export {
+	getArg,
+	getFlag,
+	ifFlag,
+} from "./VirtualShell/commands/command-helpers";

package/src/standalone.ts

@@ -6,7 +6,16 @@ const sshMimic = new VirtualMachine({ port: 2222, hostname: sshHostname });
 sshMimic
 	.start()
 	.then((port: number) => {
-		console.log(`SSH Mimic initialized. Listening on port ${port}.`);
+		if (!sshMimic.shell) console.error("Failed to initialize SSH Mimic shell.");
+		else {
+			console.log(`SSH Mimic initialized. Listening on port ${port}.`);
+			sshMimic.shell.addCommand("demo", [], () => {
+				return {
+					stdout: "This is a demo command. It does nothing useful.",
+					exitCode: 0,
+				};
+			});
+		}
 	})
 	.catch((error: unknown) => {
 		console.error("Failed to start SSH Mimic:", error);

package/src/types/commands.ts

@@ -76,6 +76,8 @@ export interface CommandContext {
 	mode: CommandMode;
 	/** Tokenized arguments excluding command name. */
 	args: string[];
+	/** Optional stdin payload (used by pipes/redirections). */
+	stdin?: string;
 	/** Current working directory for command execution. */
 	cwd: string;
 	/** Virtual filesystem instance for IO operations. */

package/src/types/pipeline.ts

@@ -0,0 +1,23 @@
+/** Represents a single command in a pipeline. */
+export interface PipelineCommand {
+	/** Command name */
+	name: string;
+	/** Command arguments */
+	args: string[];
+	/** Input redirection file path (< file) */
+	inputFile?: string;
+	/** Output redirection file path (> file) */
+	outputFile?: string;
+	/** Append to output file (>> file) */
+	appendOutput?: boolean;
+}
+
+/** Represents a parsed shell pipeline */
+export interface Pipeline {
+	/** List of commands in the pipeline */
+	commands: PipelineCommand[];
+	/** Whether this is a valid pipeline */
+	isValid: boolean;
+	/** Error message if parsing failed */
+	error?: string;
+}