typescript-virtual-container 1.0.4 → 1.0.5

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

@@ -1,4 +1,5 @@
 import type { ShellModule } from "../../types/commands";
+import { getArg } from "./command-helpers";
 import { assertPathAccess, resolvePath } from "./helpers";
 
 export const mkdirCommand: ShellModule = {
@@ -9,7 +10,11 @@ export const mkdirCommand: ShellModule = {
 			return { stderr: "mkdir: missing operand", exitCode: 1 };
 		}
 
-		for (const dir of args) {
+		for (let index = 0; index < args.length; index++) {
+			const dir = getArg(args, index);
+			if (!dir) {
+				return { stderr: "mkdir: missing operand", exitCode: 1 };
+			}
 			const target = resolvePath(cwd, dir);
 			assertPathAccess(authUser, target, "mkdir");
 			vfs.mkdir(target);

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

@@ -1,4 +1,5 @@
 import type { ShellModule } from "../../types/commands";
+import { getArg, ifFlag } from "./command-helpers";
 import { assertPathAccess, resolvePath } from "./helpers";
 
 export const rmCommand: ShellModule = {
@@ -9,9 +10,15 @@ export const rmCommand: ShellModule = {
 			return { stderr: "rm: missing operand", exitCode: 1 };
 		}
 
-		const recursive =
-			args.includes("-r") || args.includes("-rf") || args.includes("-fr");
-		const targets = args.filter((arg) => !arg.startsWith("-"));
+		const recursive = ifFlag(args, ["-r", "-rf", "-fr"]);
+		const targets: string[] = [];
+		for (let index = 0; ; index += 1) {
+			const target = getArg(args, index, { flags: ["-r", "-rf", "-fr"] });
+			if (!target) {
+				break;
+			}
+			targets.push(target);
+		}
 
 		if (targets.length === 0) {
 			return { stderr: "rm: missing operand", exitCode: 1 };

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

@@ -1,5 +1,6 @@
 /** 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
@@ -41,7 +42,12 @@ export const setCommand: ShellModule = {
 
 		// Parse VAR=value format
 		const assignments: string[] = [];
-		for (const arg of args) {
+		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) {

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/{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/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/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 };
-	},
-};