typescript-virtual-container 1.0.4 → 1.0.6

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,6 @@
+import { defaultShellProperties } from "..";
 import type { ShellModule } from "../../types/commands";
+import { getArg, getFlag, ifFlag } from "./command-helpers";
 import { runCommand } from "./index";
 
 function parseSudoArgs(args: string[]): {
@@ -6,34 +8,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;
@@ -72,6 +63,7 @@ export const sudoCommand: ShellModule = {
 				users,
 				mode,
 				loginShell ? `/home/${effectiveUser}` : cwd,
+				defaultShellProperties,
 				vfs,
 			);
 		}

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/{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,86 @@
+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";
+
+export interface ShellProperties {
+	kernel: string;
+	os: "Fortune GNU/Linux x64";
+	arch: "x86_64";
+}
+
+export const defaultShellProperties: ShellProperties = {
+	kernel: "1.0.0+itsrealfortune+1-amd64",
+	os: "Fortune GNU/Linux x64",
+	arch: "x86_64",
+};
+
+class VirtualShell {
+	private vfs: VirtualFileSystem;
+	private users: VirtualUserManager;
+	private hostname: string;
+	public properties: ShellProperties;
+
+	constructor(
+		vfs: VirtualFileSystem,
+		users: VirtualUserManager,
+		hostname: string,
+		properties?: ShellProperties,
+	) {
+		this.vfs = vfs;
+		this.users = users;
+		this.hostname = hostname;
+		this.properties = properties || defaultShellProperties;
+	}
+
+	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.properties,
+			this.vfs,
+		);
+	}
+
+	startInteractiveSession(
+		stream: ShellStream,
+		authUser: string,
+		sessionId: string | null,
+		remoteAddress: string,
+		terminalSize: { cols: number; rows: number },
+	): void {
+		// Interactive shell logic
+		startShell(
+			this.properties,
+			stream,
+			authUser,
+			this.vfs!,
+			this.hostname,
+			this.users!,
+			sessionId,
+			remoteAddress,
+			terminalSize,
+		);
+	}
+}
+
+export { VirtualShell };

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

@@ -1,12 +1,13 @@
 import { type ChildProcessWithoutNullStreams, spawn } from "node:child_process";
 import { readFile, unlink, writeFile } from "node:fs/promises";
 import * as path from "node:path";
+import { defaultShellProperties, type ShellProperties } from ".";
+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";
@@ -41,6 +42,7 @@ function toTtyLines(text: string): string {
 }
 
 export function startShell(
+	properties: ShellProperties,
 	stream: ShellStream,
 	authUser: string,
 	vfs: VirtualFileSystem,
@@ -180,6 +182,7 @@ export function startShell(
 				users,
 				"shell",
 				runCwd,
+				defaultShellProperties,
 				vfs,
 			),
 		);
@@ -467,20 +470,15 @@ export function startShell(
 	}
 
 	function renderLoginBanner(): void {
-		// const kernel = os.release();
-		// const arch = os.arch();
-
-		// Our own kernel and arch strings to avoid leaking host info and to provide a more "Linux-like" feel
-		const kernel = "5.15.0-1051-azure";
-		const arch = "x86_64";
-
 		const last = readLastLogin();
 		const nowIso = new Date().toISOString();
 
-		stream.write(`Linux ${hostname} ${kernel} ${arch}\r\n`);
+		stream.write(
+			`Linux ${hostname} ${properties.kernel} ${properties.arch}\r\n`,
+		);
 		stream.write("\r\n");
 		stream.write(
-			"The programs included with the Debian GNU/Linux system are free software;\r\n",
+			"The programs included with the Fortune GNU/Linux system are free software;\r\n",
 		);
 		stream.write(
 			"the exact distribution terms for each program are described in the\r\n",
@@ -488,7 +486,7 @@ export function startShell(
 		stream.write("individual files in /usr/share/doc/*/copyright.\r\n");
 		stream.write("\r\n");
 		stream.write(
-			"Debian GNU/Linux comes with ABSOLUTELY NO WARRANTY, to the extent\r\n",
+			"Fortune GNU/Linux comes with ABSOLUTELY NO WARRANTY, to the extent\r\n",
 		);
 		stream.write("permitted by applicable law.\r\n");
 
@@ -649,7 +647,16 @@ export function startShell(
 
 				if (line.length > 0) {
 					const result = await Promise.resolve(
-						runCommand(line, authUser, hostname, users, "shell", cwd, vfs),
+						runCommand(
+							line,
+							authUser,
+							hostname,
+							users,
+							"shell",
+							cwd,
+							defaultShellProperties,
+							vfs,
+						),
 					);
 
 					pushHistory(line);

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

@@ -6,6 +6,7 @@ import type {
 	VirtualUserManager,
 } from "../SSHMimic/users";
 import type VirtualFileSystem from "../VirtualFileSystem";
+import type { ShellProperties } from "../VirtualShell";
 
 /**
  * Normalized command execution output.
@@ -76,6 +77,8 @@ export interface CommandContext {
 	mode: CommandMode;
 	/** Tokenized arguments excluding command name. */
 	args: string[];
+	/** Virtual shell instance. */
+	shellProps: ShellProperties;
 	/** Optional stdin payload (used by pipes/redirections). */
 	stdin?: string;
 	/** Current working directory for command execution. */

package/tests/command-helpers.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, test } from "bun:test";
+import {
+    getArg,
+    getFlag,
+    ifFlag,
+} from "../src/VirtualShell/commands/command-helpers";
+
+describe("command-helpers", () => {
+	test("ifFlag detects plain and inline flag forms", () => {
+		expect(ifFlag(["-l", "docs"], ["-l", "--long"])).toBe(true);
+		expect(ifFlag(["--user=root", "whoami"], "--user")).toBe(true);
+		expect(ifFlag(["docs"], ["-l", "--long"])).toBe(false);
+	});
+
+	test("getFlag returns value for adjacent and inline forms", () => {
+		expect(getFlag(["-u", "root", "id"], ["-u", "--user"])).toBe("root");
+		expect(getFlag(["--user=alice", "id"], ["-u", "--user"])).toBe("alice");
+		expect(getFlag(["-i", "whoami"], "-i")).toBe("whoami");
+		expect(getFlag(["-o"], "-o")).toBe(true);
+		expect(getFlag(["pwd"], ["-u", "--user"])).toBeUndefined();
+	});
+
+	test("getArg skips bool and value flags", () => {
+		const args = ["-i", "-u", "root", "sh", "-c", "whoami"];
+		const options = { flags: ["-i"], flagsWithValue: ["-u"] };
+
+		expect(getArg(args, 0, options)).toBe("sh");
+		expect(getArg(args, 1, options)).toBe("-c");
+		expect(getArg(args, 2, options)).toBe("whoami");
+		expect(getArg(args, 3, options)).toBeUndefined();
+	});
+
+	test("getArg keeps tokens after -- as positional", () => {
+		const args = ["-n", "--", "-n", "hello"];
+		const options = { flags: ["-n"] };
+
+		expect(getArg(args, 0, options)).toBe("-n");
+		expect(getArg(args, 1, options)).toBe("hello");
+	});
+});

package/tests/helpers.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import { assertPathAccess } from "../src/SSHMimic/commands/helpers";
+import { assertPathAccess } from "../src/VirtualShell/commands/helpers";
 
 describe("assertPathAccess", () => {
 	test("blocks non-root access to auth store", () => {

package/src/SSHMimic/commands/sh.ts

@@ -1,121 +0,0 @@
-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 };
-	},
-};