typescript-virtual-container 1.2.3 → 1.2.5

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 };
+		}
+	},
+};

package/src/commands/tail.ts

@@ -0,0 +1,37 @@
+import type { ShellModule } from "../types/commands";
+import { getFlag } from "./command-helpers";
+import { assertPathAccess, resolvePath } from "./helpers";
+
+export const tailCommand: ShellModule = {
+	name: "tail",
+	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) => {
+			const lines = content.split("\n");
+			return lines.slice(Math.max(0, lines.length - 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, "tail");
+				results.push(take(shell.vfs.readFile(filePath)));
+			} catch {
+				return {
+					stderr: `tail: ${file}: No such file or directory`,
+					exitCode: 1,
+				};
+			}
+		}
+		return { stdout: results.join("\n"), exitCode: 0 };
+	},
+};

package/src/commands/wc.ts

@@ -0,0 +1,48 @@
+import type { ShellModule } from "../types/commands";
+import { ifFlag } from "./command-helpers";
+import { assertPathAccess, resolvePath } from "./helpers";
+
+export const wcCommand: ShellModule = {
+	name: "wc",
+	params: ["[-l] [-w] [-c] [file...]"],
+	run: ({ authUser, shell, cwd, args, stdin }) => {
+		const lines = ifFlag(args, ["-l"]);
+		const words = ifFlag(args, ["-w"]);
+		const bytes = ifFlag(args, ["-c"]);
+		const showAll = !lines && !words && !bytes;
+		const positionals = args.filter((a) => !a.startsWith("-"));
+
+		const count = (content: string, label: string): string => {
+			const l = content.split("\n").length - (content.endsWith("\n") ? 1 : 0);
+			const w = content.trim().split(/\s+/).filter(Boolean).length;
+			const c = Buffer.byteLength(content, "utf8");
+			const parts: string[] = [];
+			if (showAll || lines) parts.push(String(l).padStart(7));
+			if (showAll || words) parts.push(String(w).padStart(7));
+			if (showAll || bytes) parts.push(String(c).padStart(7));
+			if (label) parts.push(` ${label}`);
+			return parts.join("");
+		};
+
+		if (positionals.length === 0) {
+			const content = stdin ?? "";
+			return { stdout: count(content, ""), exitCode: 0 };
+		}
+
+		const results: string[] = [];
+		for (const file of positionals) {
+			const filePath = resolvePath(cwd, file);
+			try {
+				assertPathAccess(authUser, filePath, "wc");
+				const content = shell.vfs.readFile(filePath);
+				results.push(count(content, file));
+			} catch {
+				return {
+					stderr: `wc: ${file}: No such file or directory`,
+					exitCode: 1,
+				};
+			}
+		}
+		return { stdout: results.join("\n"), exitCode: 0 };
+	},
+};

package/src/index.ts

@@ -33,6 +33,7 @@ export type {
 	VfsSnapshotNode,
 	WriteFileOptions,
 } from "./types/vfs";
+export type { VfsOptions, VfsPersistenceMode } from "./VirtualFileSystem/index";
 
 export {
 	HoneyPot,

package/src/standalone.ts

@@ -16,12 +16,6 @@ new VirtualSshServer({
 	shell: virtualShell,
 })
 	.start()
-	.then((port: number) => {
-		// if (!sshMimic) console.error("Failed to initialize SSH Mimic shell.");
-		// else {
-		console.log(`SSH Mimic initialized. Listening on port ${port}.`);
-		// }
-	})
 	.catch((error: unknown) => {
 		console.error("Failed to start SSH Mimic:", error);
 		process.exit(1);
@@ -29,10 +23,19 @@ new VirtualSshServer({
 
 new VirtualSftpServer({ port: 2223, hostname, shell: virtualShell })
 	.start()
-	.then((port: number) => {
-		console.log(`SFTP Mimic initialized. Listening on port ${port}.`);
-	})
 	.catch((error: unknown) => {
 		console.error("Failed to start SFTP Mimic:", error);
 		process.exit(1);
 	});
+
+process.on("uncaughtException", (error) => {
+	console.log("Oh my god, something terrible happened: ", error);
+});
+
+process.on("unhandledRejection", (error, promise) => {
+	console.log(
+		" Oh Lord! We forgot to handle a promise rejection here: ",
+		promise,
+	);
+	console.log(" The error was: ", error);
+});