typescript-virtual-container 1.2.4 → 1.2.5

package/src/VirtualShell/index.ts

@@ -4,7 +4,7 @@ import type { CommandContext, CommandResult } from "../types/commands";
 import type { ShellStream } from "../types/streams";
 import type { PerfLogger } from "../utils/perfLogger";
 import { createPerfLogger } from "../utils/perfLogger";
-import VirtualFileSystem from "../VirtualFileSystem";
+import VirtualFileSystem, { type VfsOptions } from "../VirtualFileSystem";
 import { VirtualUserManager } from "../VirtualUserManager";
 import { startShell } from "./shell";
 
@@ -38,7 +38,6 @@ function resolveAutoSudoForNewUsers(): boolean {
  * client API.
  */
 class VirtualShell extends EventEmitter {
-	basePath: string = ".";
 	vfs: VirtualFileSystem;
 	users: VirtualUserManager;
 	hostname: string;
@@ -50,19 +49,18 @@ class VirtualShell extends EventEmitter {
 	 *
 	 * @param hostname Virtual hostname used for prompts and idents.
 	 * @param properties Customizable properties shown in `uname -a` and similar commands.
-	 * @param basePath Optional base path for the virtual filesystem (defaults to process.cwd()).
+	 * @param vfsOptions Optional VFS persistence options (mode, snapshotPath).
 	 */
 	constructor(
 		hostname: string,
 		properties?: ShellProperties,
-		basePath?: string,
+		vfsOptions?: VfsOptions,
 	) {
 		super();
 		perf.mark("constructor");
 		this.hostname = hostname;
 		this.properties = properties || defaultShellProperties;
-		this.basePath = basePath || ".";
-		this.vfs = new VirtualFileSystem(this.basePath);
+		this.vfs = new VirtualFileSystem(vfsOptions ?? {});
 		this.users = new VirtualUserManager(this.vfs, resolveAutoSudoForNewUsers());
 
 		// Store references to avoid TypeScript "used before assigned" errors

package/src/VirtualUserManager/index.ts

@@ -648,6 +648,47 @@ export class VirtualUserManager extends EventEmitter {
 			throw new Error("invalid password");
 		}
 	}
+	private readonly authorizedKeys = new Map<
+		string,
+		Array<{ algo: string; data: Buffer }>
+	>();
+
+	/**
+	 * Adds an SSH public key for a user, enabling public-key authentication.
+	 *
+	 * @param username Target user.
+	 * @param algo Key algorithm (e.g. "ssh-rsa", "ssh-ed25519").
+	 * @param data Raw key data as a Buffer (the base64-decoded key bytes).
+	 */
+	public addAuthorizedKey(username: string, algo: string, data: Buffer): void {
+		perf.mark("addAuthorizedKey");
+		const keys = this.authorizedKeys.get(username) ?? [];
+		keys.push({ algo, data });
+		this.authorizedKeys.set(username, keys);
+		this.emit("key:add", { username, algo });
+	}
+
+	/**
+	 * Removes all authorized keys for a user.
+	 *
+	 * @param username Target user.
+	 */
+	public removeAuthorizedKeys(username: string): void {
+		this.authorizedKeys.delete(username);
+		this.emit("key:remove", { username });
+	}
+
+	/**
+	 * Returns the list of authorized keys for a user.
+	 * Returns an empty array when no keys are registered.
+	 *
+	 * @param username Target user.
+	 */
+	public getAuthorizedKeys(
+		username: string,
+	): Array<{ algo: string; data: Buffer }> {
+		return this.authorizedKeys.get(username) ?? [];
+	}
 }
 
 function normalizeVfsPath(targetPath: string): string {

package/src/commands/chmod.ts

@@ -0,0 +1,33 @@
+import type { ShellModule } from "../types/commands";
+import { assertPathAccess, resolvePath } from "./helpers";
+
+export const chmodCommand: ShellModule = {
+	name: "chmod",
+	params: ["<mode> <file>"],
+	run: ({ authUser, shell, cwd, args }) => {
+		const [modeArg, fileArg] = args;
+		if (!modeArg || !fileArg) {
+			return { stderr: "chmod: missing operand", exitCode: 1 };
+		}
+
+		const filePath = resolvePath(cwd, fileArg);
+		try {
+			assertPathAccess(authUser, filePath, "chmod");
+			if (!shell.vfs.exists(filePath)) {
+				return {
+					stderr: `chmod: ${fileArg}: No such file or directory`,
+					exitCode: 1,
+				};
+			}
+			const mode = parseInt(modeArg, 8);
+			if (Number.isNaN(mode)) {
+				return { stderr: `chmod: invalid mode: ${modeArg}`, exitCode: 1 };
+			}
+			shell.vfs.chmod(filePath, mode);
+			return { exitCode: 0 };
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			return { stderr: `chmod: ${msg}`, exitCode: 1 };
+		}
+	},
+};

package/src/commands/cp.ts

@@ -0,0 +1,76 @@
+import type { ShellModule } from "../types/commands";
+import { ifFlag } from "./command-helpers";
+import { assertPathAccess, resolvePath } from "./helpers";
+
+export const cpCommand: ShellModule = {
+	name: "cp",
+	params: ["[-r] <source> <dest>"],
+	run: ({ authUser, shell, cwd, args }) => {
+		const recursive = ifFlag(args, ["-r", "-R", "--recursive"]);
+		const positionals = args.filter((a) => !a.startsWith("-"));
+		const [srcArg, destArg] = positionals;
+
+		if (!srcArg || !destArg) {
+			return { stderr: "cp: missing operand", exitCode: 1 };
+		}
+
+		const srcPath = resolvePath(cwd, srcArg);
+		const destPath = resolvePath(cwd, destArg);
+
+		try {
+			assertPathAccess(authUser, srcPath, "cp");
+			assertPathAccess(authUser, destPath, "cp");
+
+			if (!shell.vfs.exists(srcPath)) {
+				return {
+					stderr: `cp: ${srcArg}: No such file or directory`,
+					exitCode: 1,
+				};
+			}
+
+			const srcStat = shell.vfs.stat(srcPath);
+
+			if (srcStat.type === "directory") {
+				if (!recursive) {
+					return {
+						stderr: `cp: ${srcArg}: is a directory (use -r)`,
+						exitCode: 1,
+					};
+				}
+				const copyDir = (from: string, to: string) => {
+					shell.vfs.mkdir(to, 0o755);
+					for (const entry of shell.vfs.list(from)) {
+						const fromEntry = `${from}/${entry}`;
+						const toEntry = `${to}/${entry}`;
+						const stat = shell.vfs.stat(fromEntry);
+						if (stat.type === "directory") {
+							copyDir(fromEntry, toEntry);
+						} else {
+							const content = shell.vfs.readFileRaw(fromEntry);
+							shell.writeFileAsUser(authUser, toEntry, content);
+						}
+					}
+				};
+				const finalDest =
+					shell.vfs.exists(destPath) &&
+					shell.vfs.stat(destPath).type === "directory"
+						? `${destPath}/${srcArg.split("/").pop()}`
+						: destPath;
+				copyDir(srcPath, finalDest);
+			} else {
+				const finalDest =
+					shell.vfs.exists(destPath) &&
+					shell.vfs.stat(destPath).type === "directory"
+						? `${destPath}/${srcArg.split("/").pop()}`
+						: destPath;
+				const content = shell.vfs.readFileRaw(srcPath);
+				shell.writeFileAsUser(authUser, finalDest, content);
+			}
+
+			return { exitCode: 0 };
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			return { stderr: `cp: ${msg}`, exitCode: 1 };
+		}
+	},
+};

package/src/commands/find.ts

@@ -0,0 +1,61 @@
+import type { ShellModule } from "../types/commands";
+import { getFlag } from "./command-helpers";
+import { assertPathAccess, resolvePath } from "./helpers";
+
+export const findCommand: ShellModule = {
+	name: "find",
+	params: ["[path] [-name <pattern>] [-type f|d]"],
+	run: ({ authUser, shell, cwd, args }) => {
+		const namePattern = getFlag(args, ["-name"]);
+		const typeFilter = getFlag(args, ["-type"]);
+		const positionals = args.filter(
+			(a) => !a.startsWith("-") && a !== namePattern && a !== typeFilter,
+		);
+		const rootArg = positionals[0] ?? ".";
+		const rootPath = resolvePath(cwd, rootArg);
+
+		try {
+			assertPathAccess(authUser, rootPath, "find");
+			if (!shell.vfs.exists(rootPath)) {
+				return {
+					stderr: `find: ${rootArg}: No such file or directory`,
+					exitCode: 1,
+				};
+			}
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			return { stderr: `find: ${msg}`, exitCode: 1 };
+		}
+
+		const nameRegex = namePattern
+			? new RegExp(
+					`^${(namePattern as string).replace(/\./g, "\\.").replace(/\*/g, ".*").replace(/\?/g, ".")}$`,
+				)
+			: null;
+
+		const results: string[] = [];
+		const walk = (currentPath: string, display: string) => {
+			const stat = shell.vfs.stat(currentPath);
+
+			const matchesType =
+				!typeFilter ||
+				(typeFilter === "f" && stat.type === "file") ||
+				(typeFilter === "d" && stat.type === "directory");
+			const matchesName =
+				!nameRegex || nameRegex.test(currentPath.split("/").pop() ?? "");
+
+			if (matchesType && matchesName) results.push(display);
+
+			if (stat.type === "directory") {
+				for (const entry of shell.vfs.list(currentPath)) {
+					const full = `${currentPath}/${entry}`;
+					const disp = `${display}/${entry}`;
+					walk(full, disp);
+				}
+			}
+		};
+
+		walk(rootPath, rootArg);
+		return { stdout: results.join("\n"), exitCode: 0 };
+	},
+};

package/src/commands/grep.ts

@@ -4,11 +4,15 @@ import { assertPathAccess, resolvePath } from "./helpers";
 
 export const grepCommand: ShellModule = {
 	name: "grep",
-	params: ["[-i] [-v] <pattern> [file...]"],
+	params: ["[-i] [-v] [-n] [-r] <pattern> [file...]"],
 	run: ({ authUser, shell, cwd, args, stdin }) => {
-		const { flags, positionals } = parseArgs(args, { flags: ["-i", "-v"] });
+		const { flags, positionals } = parseArgs(args, {
+			flags: ["-i", "-v", "-n", "-r"],
+		});
 		const caseInsensitive = flags.has("-i");
 		const invertMatch = flags.has("-v");
+		const showLineNumbers = flags.has("-n");
+		const recursive = flags.has("-r");
 		const pattern = positionals[0];
 		const files = positionals.slice(1);
 
@@ -18,57 +22,69 @@ export const grepCommand: ShellModule = {
 
 		let regex: RegExp;
 		try {
-			const flags = caseInsensitive ? "gmi" : "gm";
-			regex = new RegExp(pattern, flags);
+			// No "g" flag — avoids the stateful lastIndex problem with regex.test()
+			const regexFlags = caseInsensitive ? "mi" : "m";
+			regex = new RegExp(pattern, regexFlags);
 		} catch {
 			return { stderr: `grep: invalid regex: ${pattern}`, exitCode: 1 };
 		}
 
-		const results: string[] = [];
-
-		if (files.length === 0) {
-			if (!stdin) {
-				return { stdout: "", exitCode: 1 };
-			}
-
-			const lines = stdin.split("\n");
-			for (const line of lines) {
-				regex.lastIndex = 0;
+		const matchLines = (content: string, prefix = ""): string[] => {
+			const lines = content.split("\n");
+			const out: string[] = [];
+			for (let i = 0; i < lines.length; i++) {
+				const line = lines[i] ?? "";
 				const matches = regex.test(line);
 				const shouldInclude = invertMatch ? !matches : matches;
-
 				if (shouldInclude) {
-					results.push(line);
+					const lineLabel = showLineNumbers ? `${i + 1}:` : "";
+					out.push(`${prefix}${lineLabel}${line}`);
 				}
 			}
+			return out;
+		};
 
-			return {
-				stdout: results.length > 0 ? results.join("\n") : "",
-				exitCode: results.length > 0 ? 0 : 1,
+		const readPaths = (base: string): string[] => {
+			if (!shell.vfs.exists(base)) return [];
+			const stat = shell.vfs.stat(base);
+			if (stat.type === "file") return [base];
+			if (!recursive) return [];
+			const paths: string[] = [];
+			const walk = (dir: string) => {
+				for (const entry of shell.vfs.list(dir)) {
+					const full = `${dir}/${entry}`;
+					const s = shell.vfs.stat(full);
+					if (s.type === "file") paths.push(full);
+					else walk(full);
+				}
 			};
-		}
+			walk(base);
+			return paths;
+		};
 
-		for (const file of files) {
-			const target = resolvePath(cwd, file);
-			try {
-				assertPathAccess(authUser, target, "grep");
-				const content = shell.vfs.readFile(target);
-				const lines = content.split("\n");
+		const results: string[] = [];
 
-				for (const line of lines) {
-					regex.lastIndex = 0;
-					const matches = regex.test(line);
-					const shouldInclude = invertMatch ? !matches : matches;
+		if (files.length === 0) {
+			if (!stdin) return { stdout: "", exitCode: 1 };
+			results.push(...matchLines(stdin));
+		} else {
+			const resolvedPaths = files.flatMap((f) => {
+				const target = resolvePath(cwd, f);
+				return readPaths(target).map((p) => ({ file: f, path: p }));
+			});
 
-					if (shouldInclude) {
-						results.push(line);
-					}
+			for (const { file, path: filePath } of resolvedPaths) {
+				try {
+					assertPathAccess(authUser, filePath, "grep");
+					const content = shell.vfs.readFile(filePath);
+					const prefix = resolvedPaths.length > 1 ? `${file}:` : "";
+					results.push(...matchLines(content, prefix));
+				} catch {
+					return {
+						stderr: `grep: ${file}: No such file or directory`,
+						exitCode: 1,
+					};
 				}
-			} catch {
-				return {
-					stderr: `grep: ${file}: No such file or directory`,
-					exitCode: 1,
-				};
 			}
 		}
 

package/src/commands/head.ts

@@ -0,0 +1,35 @@
+import type { ShellModule } from "../types/commands";
+import { getFlag } from "./command-helpers";
+import { assertPathAccess, resolvePath } from "./helpers";
+
+export const headCommand: ShellModule = {
+	name: "head",
+	params: ["[-n <lines>] [file...]"],
+	run: ({ authUser, shell, cwd, args, stdin }) => {
+		const nArg = getFlag(args, ["-n"]);
+		const n = typeof nArg === "string" ? parseInt(nArg, 10) : 10;
+		const positionals = args.filter((a) => !a.startsWith("-") && a !== nArg);
+
+		const take = (content: string) =>
+			content.split("\n").slice(0, n).join("\n");
+
+		if (positionals.length === 0) {
+			return { stdout: take(stdin ?? ""), exitCode: 0 };
+		}
+
+		const results: string[] = [];
+		for (const file of positionals) {
+			const filePath = resolvePath(cwd, file);
+			try {
+				assertPathAccess(authUser, filePath, "head");
+				results.push(take(shell.vfs.readFile(filePath)));
+			} catch {
+				return {
+					stderr: `head: ${file}: No such file or directory`,
+					exitCode: 1,
+				};
+			}
+		}
+		return { stdout: results.join("\n"), exitCode: 0 };
+	},
+};

package/src/commands/index.ts

@@ -8,19 +8,25 @@ import type {
 import { adduserCommand } from "./adduser";
 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 { deluserCommand } from "./deluser";
 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 { headCommand } from "./head";
 import { createHelpCommand } from "./help";
 import { hostnameCommand } from "./hostname";
 import { htopCommand } from "./htop";
+import { lnCommand } from "./ln";
 import { lsCommand } from "./ls";
 import { mkdirCommand } from "./mkdir";
+import { mvCommand } from "./mv";
 import { nanoCommand } from "./nano";
 import { neofetchCommand } from "./neofetch";
 import { passwdCommand } from "./passwd";
@@ -30,9 +36,11 @@ import { setCommand } from "./set";
 import { shCommand } from "./sh";
 import { suCommand } from "./su";
 import { sudoCommand } from "./sudo";
+import { tailCommand } from "./tail";
 import { touchCommand } from "./touch";
 import { treeCommand } from "./tree";
 import { unsetCommand } from "./unset";
+import { wcCommand } from "./wc";
 import { wgetCommand } from "./wget";
 import { whoCommand } from "./who";
 import { whoamiCommand } from "./whoami";
@@ -68,6 +76,14 @@ const BASE_COMMANDS: ShellModule[] = [
 	shCommand,
 	clearCommand,
 	exitCommand,
+	cpCommand,
+	mvCommand,
+	lnCommand,
+	findCommand,
+	wcCommand,
+	headCommand,
+	tailCommand,
+	chmodCommand,
 ];
 
 const customCommands: ShellModule[] = [];
@@ -80,6 +96,7 @@ const commandRegistry = new Map<string, ShellModule>();
 let cachedCommandNames: string[] | null = null;
 
 function buildCache(): void {
+	commandRegistry.clear();
 	for (const mod of getCommandModules()) {
 		commandRegistry.set(mod.name, mod);
 		for (const alias of mod.aliases ?? []) {
@@ -90,13 +107,6 @@ function buildCache(): void {
 }
 
 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];
 }
 
@@ -114,13 +124,7 @@ export function registerCommand(module: ShellModule): void {
 		);
 	}
 
-	for (const name of names) {
-		if (commandRegistry.has(name)) {
-			throw new Error(`Command '${name}' already exists`);
-		}
-		commandRegistry.set(name, normalized);
-	}
-
+	customCommands.push(normalized);
 	buildCache();
 }
 
@@ -129,24 +133,16 @@ export function createCustomCommand(
 	params: string[],
 	run: (ctx: CommandContext) => CommandResult | Promise<CommandResult>,
 ): ShellModule {
-	return {
-		name,
-		params,
-		run,
-	};
+	return { name, params, run };
 }
 
 export function getCommandNames(): string[] {
-	if (!cachedCommandNames) {
-		buildCache();
-	}
+	if (!cachedCommandNames) buildCache();
 	return cachedCommandNames!;
 }
 
 export function resolveModule(name: string): ShellModule | undefined {
-	if (!cachedCommandNames) {
-		buildCache();
-	}
+	if (!cachedCommandNames) buildCache();
 	return commandRegistry.get(name.toLowerCase());
 }
 
@@ -166,7 +162,6 @@ function splitArgsRespectingQuotes(input: string): string[] {
 				quoteChar = ch;
 				continue;
 			}
-
 			if (ch === quoteChar) {
 				inQuotes = false;
 				quoteChar = "";
@@ -185,10 +180,7 @@ function splitArgsRespectingQuotes(input: string): string[] {
 		current += ch;
 	}
 
-	if (current.length > 0) {
-		tokens.push(current);
-	}
-
+	if (current.length > 0) tokens.push(current);
 	return tokens;
 }
 
@@ -200,8 +192,6 @@ function parseInput(rawInput: string): { commandName: string; args: string[] } {
 	};
 }
 
-// Internal async function for pipeline execution
-
 export async function runCommand(
 	rawInput: string,
 	authUser: string,
@@ -213,9 +203,7 @@ export async function runCommand(
 ): Promise<CommandResult> {
 	const trimmed = rawInput.trim();
 
-	if (trimmed.length === 0) {
-		return { exitCode: 0 };
-	}
+	if (trimmed.length === 0) return { exitCode: 0 };
 
 	if (trimmed.includes("|") || trimmed.includes(">") || trimmed.includes("<")) {
 		const { parseShellPipeline } = await import("../VirtualShell/shellParser");
@@ -223,10 +211,7 @@ export async function runCommand(
 
 		const pipeline = parseShellPipeline(trimmed);
 		if (!pipeline.isValid) {
-			return {
-				stderr: pipeline.error || "Syntax error",
-				exitCode: 1,
-			};
+			return { stderr: pipeline.error || "Syntax error", exitCode: 1 };
 		}
 
 		try {
@@ -249,10 +234,7 @@ export async function runCommand(
 	const mod = resolveModule(commandName);
 
 	if (!mod) {
-		return {
-			stderr: `Command '${trimmed}' not found`,
-			exitCode: 127,
-		};
+		return { stderr: `Command '${trimmed}' not found`, exitCode: 127 };
 	}
 
 	try {

package/src/commands/ln.ts

@@ -0,0 +1,47 @@
+import type { ShellModule } from "../types/commands";
+import { ifFlag } from "./command-helpers";
+import { assertPathAccess, resolvePath } from "./helpers";
+
+export const lnCommand: ShellModule = {
+	name: "ln",
+	params: ["[-s] <target> <link_name>"],
+	run: ({ authUser, shell, cwd, args }) => {
+		const symbolic = ifFlag(args, ["-s", "--symbolic"]);
+		const positionals = args.filter((a) => !a.startsWith("-"));
+		const [targetArg, linkArg] = positionals;
+
+		if (!targetArg || !linkArg) {
+			return { stderr: "ln: missing operand", exitCode: 1 };
+		}
+
+		const linkPath = resolvePath(cwd, linkArg);
+		const targetPath = symbolic
+			? targetArg // keep relative for symlinks
+			: resolvePath(cwd, targetArg);
+
+		try {
+			assertPathAccess(authUser, linkPath, "ln");
+
+			if (!symbolic) {
+				// Hard link — copy file contents
+				const srcPath = resolvePath(cwd, targetArg);
+				assertPathAccess(authUser, srcPath, "ln");
+				if (!shell.vfs.exists(srcPath)) {
+					return {
+						stderr: `ln: ${targetArg}: No such file or directory`,
+						exitCode: 1,
+					};
+				}
+				const content = shell.vfs.readFile(srcPath);
+				shell.writeFileAsUser(authUser, linkPath, content);
+			} else {
+				shell.vfs.symlink(targetPath, linkPath);
+			}
+
+			return { exitCode: 0 };
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			return { stderr: `ln: ${msg}`, exitCode: 1 };
+		}
+	},
+};

package/src/commands/mv.ts

@@ -0,0 +1,43 @@
+import type { ShellModule } from "../types/commands";
+import { assertPathAccess, resolvePath } from "./helpers";
+
+export const mvCommand: ShellModule = {
+	name: "mv",
+	params: ["<source> <dest>"],
+	run: ({ authUser, shell, cwd, args }) => {
+		const positionals = args.filter((a) => !a.startsWith("-"));
+		const [srcArg, destArg] = positionals;
+
+		if (!srcArg || !destArg) {
+			return { stderr: "mv: missing operand", exitCode: 1 };
+		}
+
+		const srcPath = resolvePath(cwd, srcArg);
+		const destPath = resolvePath(cwd, destArg);
+
+		try {
+			assertPathAccess(authUser, srcPath, "mv");
+			assertPathAccess(authUser, destPath, "mv");
+
+			if (!shell.vfs.exists(srcPath)) {
+				return {
+					stderr: `mv: ${srcArg}: No such file or directory`,
+					exitCode: 1,
+				};
+			}
+
+			// If dest is a directory, move into it
+			const finalDest =
+				shell.vfs.exists(destPath) &&
+				shell.vfs.stat(destPath).type === "directory"
+					? `${destPath}/${srcArg.split("/").pop()}`
+					: destPath;
+
+			shell.vfs.move(srcPath, finalDest);
+			return { exitCode: 0 };
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			return { stderr: `mv: ${msg}`, exitCode: 1 };
+		}
+	},
+};