typescript-virtual-container 1.2.5 → 1.2.6

package/src/commands/index.ts

@@ -1,28 +1,41 @@
+/** biome-ignore-all lint/style/useNamingConvention: ENV VARIABLES */
 import type { VirtualShell } from "../VirtualShell";
 import type {
 	CommandContext,
 	CommandMode,
 	CommandResult,
+	ShellEnv,
 	ShellModule,
 } from "../types/commands";
 import { adduserCommand } from "./adduser";
+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 { deluserCommand } from "./deluser";
+import { dfCommand } from "./df";
+import { diffCommand } from "./diff";
+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 { grepCommand } from "./grep";
+import { groupsCommand } from "./groups";
+import { gunzipCommand, gzipCommand } from "./gzip";
 import { headCommand } from "./head";
 import { createHelpCommand } from "./help";
 import { hostnameCommand } from "./hostname";
 import { htopCommand } from "./htop";
+import { idCommand } from "./id";
+import { killCommand } from "./kill";
 import { lnCommand } from "./ln";
 import { lsCommand } from "./ls";
 import { mkdirCommand } from "./mkdir";
@@ -30,78 +43,71 @@ import { mvCommand } from "./mv";
 import { nanoCommand } from "./nano";
 import { neofetchCommand } from "./neofetch";
 import { passwdCommand } from "./passwd";
+import { pingCommand } from "./ping";
+import { psCommand } from "./ps";
 import { pwdCommand } from "./pwd";
 import { rmCommand } from "./rm";
+import { sedCommand } from "./sed";
 import { setCommand } from "./set";
 import { shCommand } from "./sh";
+import { sleepCommand } from "./sleep";
+import { sortCommand } from "./sort";
 import { suCommand } from "./su";
 import { sudoCommand } from "./sudo";
 import { tailCommand } from "./tail";
+import { tarCommand } from "./tar";
+import { teeCommand } from "./tee";
 import { touchCommand } from "./touch";
+import { trCommand } from "./tr";
 import { treeCommand } from "./tree";
+import { unameCommand } from "./uname";
+import { uniqCommand } from "./uniq";
 import { unsetCommand } from "./unset";
 import { wcCommand } from "./wc";
 import { wgetCommand } from "./wget";
 import { whoCommand } from "./who";
 import { whoamiCommand } from "./whoami";
+import { xargsCommand } from "./xargs";
 
 const BASE_COMMANDS: ShellModule[] = [
-	pwdCommand,
-	whoamiCommand,
-	whoCommand,
-	hostnameCommand,
-	lsCommand,
-	cdCommand,
-	catCommand,
-	echoCommand,
-	mkdirCommand,
-	touchCommand,
-	rmCommand,
-	treeCommand,
-	nanoCommand,
+	// Navigation
+	pwdCommand, cdCommand, lsCommand, treeCommand,
+	// Files
+	catCommand, touchCommand, rmCommand, mkdirCommand, cpCommand, mvCommand, lnCommand,
+	chmodCommand, 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,
-	htopCommand,
-	adduserCommand,
-	passwdCommand,
-	deluserCommand,
-	sudoCommand,
-	suCommand,
-	curlCommand,
-	envCommand,
-	wgetCommand,
-	grepCommand,
-	exportCommand,
-	setCommand,
-	unsetCommand,
-	shCommand,
-	clearCommand,
-	exitCommand,
-	cpCommand,
-	mvCommand,
-	lnCommand,
-	findCommand,
-	wcCommand,
-	headCommand,
-	tailCommand,
-	chmodCommand,
 ];
 
 const customCommands: ShellModule[] = [];
-
-const helpCommand = createHelpCommand(() =>
-	getCommandModules().map((cmd) => cmd.name),
-);
-
 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);
-		}
+		for (const alias of mod.aliases ?? []) commandRegistry.set(alias, mod);
 	}
 	cachedCommandNames = Array.from(commandRegistry.keys()).sort();
 }
@@ -114,16 +120,12 @@ export function registerCommand(module: ShellModule): void {
 	const normalized: ShellModule = {
 		...module,
 		name: module.name.trim().toLowerCase(),
-		aliases: module.aliases?.map((alias) => alias.trim().toLowerCase()),
+		aliases: module.aliases?.map((a) => a.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",
-		);
+	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();
 }
@@ -141,6 +143,10 @@ export function getCommandNames(): string[] {
 	return cachedCommandNames!;
 }
 
+export function getCommandModulesPublic(): ShellModule[] {
+	return getCommandModules();
+}
+
 export function resolveModule(name: string): ShellModule | undefined {
 	if (!cachedCommandNames) buildCache();
 	return commandRegistry.get(name.toLowerCase());
@@ -152,43 +158,41 @@ function splitArgsRespectingQuotes(input: string): string[] {
 	let inQuotes = false;
 	let quoteChar = "";
 
-	for (let i = 0; i < input.length; i += 1) {
+	for (let i = 0; i < input.length; i++) {
 		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 (!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 = "";
-			}
+			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) };
+}
+
+export function makeDefaultEnv(authUser: string, hostname: string): ShellEnv {
 	return {
-		commandName: parts[0]?.toLowerCase() ?? "",
-		args: parts.slice(1),
+		vars: {
+			PATH: "/usr/local/bin:/usr/bin:/bin",
+			HOME: `/home/${authUser}`,
+			USER: authUser,
+			LOGNAME: authUser,
+			SHELL: "/bin/sh",
+			TERM: "xterm-256color",
+			HOSTNAME: hostname,
+			PS1: "\\u@\\h:\\w\\$ ",
+		},
+		lastExitCode: 0,
 	};
 }
 
@@ -200,42 +204,37 @@ export async function runCommand(
 	cwd: string,
 	shell: VirtualShell,
 	stdin?: string,
+	env?: ShellEnv,
 ): Promise<CommandResult> {
 	const trimmed = rawInput.trim();
-
 	if (trimmed.length === 0) return { exitCode: 0 };
 
-	if (trimmed.includes("|") || trimmed.includes(">") || trimmed.includes("<")) {
-		const { parseShellPipeline } = await import("../VirtualShell/shellParser");
-		const { executePipeline } = await import("../SSHMimic/executor");
-
-		const pipeline = parseShellPipeline(trimmed);
-		if (!pipeline.isValid) {
-			return { stderr: pipeline.error || "Syntax error", exitCode: 1 };
-		}
-
+	const shellEnv: ShellEnv = env ?? makeDefaultEnv(authUser, hostname);
+
+	// Detect shell operators
+	if (
+		/(?<![|&])[|](?![|])/.test(trimmed) ||
+		trimmed.includes(">") ||
+		trimmed.includes("<") ||
+		trimmed.includes("&&") ||
+		trimmed.includes("||") ||
+		trimmed.includes(";")
+	) {
+		const { parseScript } = await import("../VirtualShell/shellParser");
+		const { executeStatements } = await import("../SSHMimic/executor");
+		const script = parseScript(trimmed);
+		if (!script.isValid) return { stderr: script.error || "Syntax error", exitCode: 1 };
 		try {
-			return await executePipeline(
-				pipeline,
-				authUser,
-				hostname,
-				mode,
-				cwd,
-				shell,
-			);
+			return await executeStatements(script.statements, authUser, hostname, mode, cwd, shell, shellEnv);
 		} catch (error: unknown) {
-			const message =
-				error instanceof Error ? error.message : "Pipeline execution failed";
-			return { stderr: message, exitCode: 1 };
+			return { stderr: error instanceof Error ? error.message : "Execution failed", exitCode: 1 };
 		}
 	}
 
 	const { commandName, args } = parseInput(trimmed);
 	const mod = resolveModule(commandName);
 
-	if (!mod) {
-		return { stderr: `Command '${trimmed}' not found`, exitCode: 127 };
-	}
+	if (!mod) return { stderr: `${commandName}: command not found`, exitCode: 127 };
 
 	try {
 		return await mod.run({
@@ -248,9 +247,9 @@ export async function runCommand(
 			stdin,
 			cwd,
 			shell,
+			env: shellEnv,
 		});
 	} catch (error: unknown) {
-		const message = error instanceof Error ? error.message : "Command failed";
-		return { stderr: message, exitCode: 1 };
+		return { stderr: error instanceof Error ? error.message : "Command failed", exitCode: 1 };
 	}
 }

package/src/commands/kill.ts

@@ -0,0 +1,14 @@
+import type { ShellModule } from "../types/commands";
+
+export const killCommand: ShellModule = {
+	name: "kill",
+	description: "Send signal to process",
+	category: "system",
+	params: ["[-9] <pid>"],
+	run: ({ args }) => {
+		const pid = args.find((a) => !a.startsWith("-"));
+		if (!pid) return { stderr: "kill: no pid specified", exitCode: 1 };
+		// In virtual env, we just acknowledge the kill
+		return { stdout: ``, exitCode: 0 };
+	},
+};

package/src/commands/ln.ts

@@ -4,6 +4,8 @@ import { assertPathAccess, resolvePath } from "./helpers";
 
 export const lnCommand: ShellModule = {
 	name: "ln",
+	description: "Create links",
+	category: "files",
 	params: ["[-s] <target> <link_name>"],
 	run: ({ authUser, shell, cwd, args }) => {
 		const symbolic = ifFlag(args, ["-s", "--symbolic"]);

package/src/commands/ls.ts

@@ -28,6 +28,8 @@ function formatDate(date: Date): string {
 
 export const lsCommand: ShellModule = {
 	name: "ls",
+	description: "List directory contents",
+	category: "navigation",
 	params: ["[path]"],
 	run: ({ authUser, shell, cwd, args }) => {
 		const longFormat = ifFlag(args, ["-l", "--long"]);

package/src/commands/mkdir.ts

@@ -4,6 +4,8 @@ import { assertPathAccess, resolvePath } from "./helpers";
 
 export const mkdirCommand: ShellModule = {
 	name: "mkdir",
+	description: "Make directories",
+	category: "files",
 	params: ["<dir>"],
 	run: ({ authUser, shell, cwd, args }) => {
 		if (args.length === 0) {

package/src/commands/mv.ts

@@ -3,6 +3,8 @@ import { assertPathAccess, resolvePath } from "./helpers";
 
 export const mvCommand: ShellModule = {
 	name: "mv",
+	description: "Move or rename files",
+	category: "files",
 	params: ["<source> <dest>"],
 	run: ({ authUser, shell, cwd, args }) => {
 		const positionals = args.filter((a) => !a.startsWith("-"));

package/src/commands/nano.ts

@@ -4,6 +4,8 @@ import { assertPathAccess, resolvePath } from "./helpers";
 
 export const nanoCommand: ShellModule = {
 	name: "nano",
+	description: "Text editor",
+	category: "shell",
 	params: ["<file>"],
 	run: ({ authUser, shell, cwd, args }) => {
 		const fileArg = args[0];

package/src/commands/neofetch.ts

@@ -5,6 +5,8 @@ import { getAllEnvVars } from "./set";
 
 export const neofetchCommand: ShellModule = {
 	name: "neofetch",
+	description: "System info display",
+	category: "misc",
 	params: ["[--off]"],
 	run: ({ args, authUser, hostname, shell }) => {
 		const env = getAllEnvVars(authUser);

package/src/commands/passwd.ts

@@ -2,6 +2,8 @@ import type { ShellModule } from "../types/commands";
 
 export const passwdCommand: ShellModule = {
 	name: "passwd",
+	description: "Change user password",
+	category: "users",
 	params: ["<username> <password>"],
 	run: async ({ authUser, args, shell }) => {
 		const [username, password] = args;

package/src/commands/ping.ts

@@ -0,0 +1,20 @@
+import type { ShellModule } from "../types/commands";
+
+export const pingCommand: ShellModule = {
+	name: "ping",
+	description: "Send ICMP ECHO_REQUEST (mock)",
+	category: "network",
+	params: ["[-c <count>] <host>"],
+	run: ({ args }) => {
+		const host = args.find((a) => !a.startsWith("-")) ?? "localhost";
+		const count = 4;
+		const lines = [`PING ${host}: 56 data bytes`];
+		for (let i = 0; i < count; i++) {
+			const ms = (Math.random() * 10 + 1).toFixed(3);
+			lines.push(`64 bytes from ${host}: icmp_seq=${i} ttl=64 time=${ms} ms`);
+		}
+		lines.push(`--- ${host} ping statistics ---`);
+		lines.push(`${count} packets transmitted, ${count} received, 0% packet loss`);
+		return { stdout: lines.join("\n"), exitCode: 0 };
+	},
+};

package/src/commands/ps.ts

@@ -0,0 +1,19 @@
+import type { ShellModule } from "../types/commands";
+
+export const psCommand: ShellModule = {
+	name: "ps",
+	description: "Report process status",
+	category: "system",
+	params: ["[-a] [-u] [-x]"],
+	run: ({ authUser, shell }) => {
+		const sessions = shell.users.listActiveSessions();
+		const lines = ["  PID TTY          TIME CMD"];
+		let pid = 1000;
+		for (const s of sessions) {
+			lines.push(`${String(pid).padStart(5)} ${s.tty.padEnd(12)} 00:00:00 ${s.username === authUser ? "bash" : `bash (${s.username})`}`);
+			pid++;
+		}
+		lines.push(`${String(pid).padStart(5)} pts/0        00:00:00 ps`);
+		return { stdout: lines.join("\n"), exitCode: 0 };
+	},
+};

package/src/commands/pwd.ts

@@ -2,6 +2,8 @@ import type { ShellModule } from "../types/commands";
 
 export const pwdCommand: ShellModule = {
 	name: "pwd",
+	description: "Print working directory",
+	category: "navigation",
 	params: [],
 	run: ({ cwd }) => ({ stdout: cwd, exitCode: 0 }),
 };

package/src/commands/rm.ts

@@ -4,6 +4,8 @@ import { assertPathAccess, resolvePath } from "./helpers";
 
 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) {

package/src/commands/sed.ts

@@ -0,0 +1,45 @@
+import type { ShellModule } from "../types/commands";
+import { getFlag, ifFlag } from "./command-helpers";
+import { resolvePath } from "./helpers";
+
+export const sedCommand: ShellModule = {
+	name: "sed",
+	description: "Stream editor for filtering and transforming text",
+	category: "text",
+	params: ["-e <expr> [file]", "s/pattern/replace/[g]"],
+	run: ({ authUser, shell, cwd, args, stdin }) => {
+		const inPlace = ifFlag(args, ["-i"]);
+		const expr = (getFlag(args, ["-e"]) as string | undefined) ?? args.find((a) => !a.startsWith("-"));
+		const fileArg = args.filter((a) => !a.startsWith("-") && a !== expr).pop();
+
+		if (!expr) return { stderr: "sed: no expression", exitCode: 1 };
+
+		let content = stdin ?? "";
+		if (fileArg) {
+			const p = resolvePath(cwd, fileArg);
+			try { content = shell.vfs.readFile(p); } catch { return { stderr: `sed: ${fileArg}: No such file or directory`, exitCode: 1 }; }
+		}
+
+		// Parse s/from/to/[g]
+		const sMatch = expr.match(/^s([^a-zA-Z0-9])(.+?)\1(.*?)\1([gi]*)$/);
+		if (!sMatch) return { stderr: `sed: unrecognized command: ${expr}`, exitCode: 1 };
+
+		const [, , from, to, flags] = sMatch;
+		const regexFlags = (flags ?? "").includes("i") ? "gi" : (flags ?? "").includes("g") ? "g" : "";
+		let regex: RegExp;
+		try { regex = new RegExp(from!, regexFlags || ""); }
+		catch (_e) { return { stderr: `sed: invalid regex: ${from}`, exitCode: 1 }; }
+
+		const result = (flags ?? "").includes("g") || regexFlags.includes("g")
+			? content.replace(regex, to ?? "")
+			: content.replace(regex, to ?? "");
+
+		if (inPlace && fileArg) {
+			const p = resolvePath(cwd, fileArg);
+			shell.writeFileAsUser(authUser, p, result);
+			return { exitCode: 0 };
+		}
+
+		return { stdout: result, exitCode: 0 };
+	},
+};

package/src/commands/set.ts

@@ -1,10 +1,8 @@
 /** 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> = {
+// Legacy global store kept for compatibility with older callers
+const _globalEnv: Record<string, string> = {
 	PATH: "/usr/local/bin:/usr/bin:/bin",
 	HOME: "/home/user",
 	SHELL: "/bin/sh",
@@ -12,62 +10,33 @@ const envVars: Record<string, string> = {
 	USER: "user",
 };
 
-export function getEnvVar(name: string): string | undefined {
-	return envVars[name];
-}
-
-export function setEnvVar(name: string, value: string): void {
-	envVars[name] = value;
-}
-
+/** @deprecated use env.vars from CommandContext */
+export function getEnvVar(name: string): string | undefined { return _globalEnv[name]; }
+/** @deprecated use env.vars from CommandContext */
+export function setEnvVar(name: string, value: string): void { _globalEnv[name] = value; }
+/** @deprecated use env.vars from CommandContext */
 export function getAllEnvVars(authUser: string): Record<string, string> {
-	envVars.USER = authUser;
-	envVars.HOME = `/home/${authUser}`;
-	return { ...envVars };
+	_globalEnv.USER = authUser;
+	_globalEnv.HOME = `/home/${authUser}`;
+	return { ..._globalEnv };
 }
 
 export const setCommand: ShellModule = {
 	name: "set",
+	description: "Display or set shell variables",
+	category: "shell",
 	params: ["[VAR=value]"],
-	run: ({ args }) => {
-		// No arguments: display all environment variables
+	run: ({ args, env }) => {
 		if (args.length === 0) {
-			const output = Object.entries(envVars)
-				.map(([key, value]) => `${key}=${value}`)
-				.sort()
-				.join("\n");
-
-			return { stdout: output, exitCode: 0 };
+			const out = Object.entries(env.vars).map(([k, v]) => `${k}=${v}`).join("\n");
+			return { stdout: out, exitCode: 0 };
 		}
-
-		// Parse VAR=value format
-		const assignments: string[] = [];
-		for (let index = 0; ; index += 1) {
-			const arg = getArg(args, index);
-			if (!arg) {
-				break;
-			}
-
+		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`);
-				}
+				const eq = arg.indexOf("=");
+				env.vars[arg.slice(0, eq)] = arg.slice(eq + 1);
 			}
 		}
-
-		return {
-			stdout: assignments.length > 0 ? assignments.join("\n") : "",
-			exitCode: 0,
-		};
+		return { exitCode: 0 };
 	},
 };