typescript-virtual-container 0.1.0

package/src/SSHMimic/commands/helpers.ts

@@ -0,0 +1,137 @@
+import * as path from "node:path";
+import type VirtualFileSystem from "../../VirtualFileSystem";
+
+export function resolvePath(cwd: string, inputPath: string): string {
+	if (!inputPath || inputPath.trim() === "") {
+		return cwd;
+	}
+	return inputPath.startsWith("/")
+		? path.posix.normalize(inputPath)
+		: path.posix.normalize(path.posix.join(cwd, inputPath));
+}
+
+export function parseOutputPath(args: string[]): {
+	outputPath: string | null;
+	inputArgs: string[];
+} {
+	const filtered: string[] = [];
+	let outputPath: string | null = null;
+
+	for (let index = 0; index < args.length; index += 1) {
+		const arg = args[index]!;
+
+		if (
+			arg === "-o" ||
+			arg === "-O" ||
+			arg === "--output" ||
+			arg === "--output-document"
+		) {
+			outputPath = args[index + 1] ?? null;
+			index += 1;
+			continue;
+		}
+
+		if (arg.startsWith("-o=")) {
+			outputPath = arg.slice(3);
+			continue;
+		}
+
+		if (arg.startsWith("-O=")) {
+			outputPath = arg.slice(3);
+			continue;
+		}
+
+		filtered.push(arg);
+	}
+
+	return { outputPath, inputArgs: filtered };
+}
+
+export function stripUrlFilename(url: string): string {
+	const cleaned = url.split("?")[0]?.split("#")[0] ?? url;
+	const lastPart = cleaned.split("/").filter(Boolean).pop();
+	return lastPart && lastPart.length > 0 ? lastPart : "index.html";
+}
+
+export async function fetchResource(
+	url: string,
+): Promise<{ text: string; status: number; contentType: string | null }> {
+	const response = await fetch(url);
+	const contentType = response.headers.get("content-type");
+	return {
+		text: await response.text(),
+		status: response.status,
+		contentType,
+	};
+}
+
+function levenshtein(a: string, b: string): number {
+	const dp: number[][] = Array.from({ length: a.length + 1 }, () =>
+		Array<number>(b.length + 1).fill(0),
+	);
+
+	for (let i = 0; i <= a.length; i += 1) {
+		dp[i]![0] = i;
+	}
+	for (let j = 0; j <= b.length; j += 1) {
+		dp[0]![j] = j;
+	}
+
+	for (let i = 1; i <= a.length; i += 1) {
+		for (let j = 1; j <= b.length; j += 1) {
+			const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+			dp[i]![j] = Math.min(
+				dp[i - 1]![j]! + 1,
+				dp[i]![j - 1]! + 1,
+				dp[i - 1]![j - 1]! + cost,
+			);
+		}
+	}
+
+	return dp[a.length]![b.length]!;
+}
+
+export function resolveReadablePath(
+	vfs: VirtualFileSystem,
+	cwd: string,
+	inputPath: string,
+): string {
+	const exactPath = resolvePath(cwd, inputPath);
+	if (vfs.exists(exactPath)) {
+		return exactPath;
+	}
+
+	const parent = path.posix.dirname(exactPath);
+	const fileName = path.posix.basename(exactPath);
+	const siblings = vfs.list(parent);
+
+	const caseInsensitive = siblings.filter(
+		(name) => name.toLowerCase() === fileName.toLowerCase(),
+	);
+	if (caseInsensitive.length === 1) {
+		return path.posix.join(parent, caseInsensitive[0]!);
+	}
+
+	const near = siblings.filter(
+		(name) => levenshtein(name.toLowerCase(), fileName.toLowerCase()) <= 1,
+	);
+	if (near.length === 1) {
+		return path.posix.join(parent, near[0]!);
+	}
+
+	return exactPath;
+}
+
+export function joinListWithType(
+	cwd: string,
+	items: string[],
+	statAt: (p: string) => { type: "file" | "directory" },
+): string {
+	return items
+		.map((name) => {
+			const childPath = resolvePath(cwd, name);
+			const stats = statAt(childPath);
+			return stats.type === "directory" ? `${name}/` : name;
+		})
+		.join("  ");
+}

package/src/SSHMimic/commands/hostname.ts

@@ -0,0 +1,7 @@
+import type { ShellModule } from "../../types/commands";
+
+export const hostnameCommand: ShellModule = {
+	name: "hostname",
+	params: [],
+	run: ({ hostname }) => ({ stdout: hostname, exitCode: 0 }),
+};

package/src/SSHMimic/commands/htop.ts

@@ -0,0 +1,13 @@
+import type { ShellModule } from "../../types/commands";
+
+export const htopCommand: ShellModule = {
+	name: "htop",
+	params: [],
+	run: ({ mode }) => {
+		if (mode === "exec") {
+			return { stderr: "htop: interactive terminal required", exitCode: 1 };
+		}
+
+		return { openHtop: true, exitCode: 0 };
+	},
+};

package/src/SSHMimic/commands/index.ts

@@ -0,0 +1,120 @@
+import type {
+	CommandMode,
+	CommandOutcome,
+	ShellModule,
+} from "../../types/commands";
+import type VirtualFileSystem from "../../VirtualFileSystem";
+import type { VirtualUserManager } from "../users";
+import { adduserCommand } from "./adduser";
+import { catCommand } from "./cat";
+import { cdCommand } from "./cd";
+import { clearCommand } from "./clear";
+import { curlCommand } from "./curl";
+import { deluserCommand } from "./deluser";
+import { exitCommand } from "./exit";
+import { createHelpCommand } from "./help";
+import { hostnameCommand } from "./hostname";
+import { htopCommand } from "./htop";
+import { lsCommand } from "./ls";
+import { mkdirCommand } from "./mkdir";
+import { nanoCommand } from "./nano";
+import { pwdCommand } from "./pwd";
+import { rmCommand } from "./rm";
+import { suCommand } from "./su";
+import { sudoCommand } from "./sudo";
+import { touchCommand } from "./touch";
+import { treeCommand } from "./tree";
+import { wgetCommand } from "./wget";
+import { whoCommand } from "./who";
+import { whoamiCommand } from "./whoami";
+
+const BASE_COMMANDS: ShellModule[] = [
+	pwdCommand,
+	whoamiCommand,
+	whoCommand,
+	hostnameCommand,
+	lsCommand,
+	cdCommand,
+	catCommand,
+	mkdirCommand,
+	touchCommand,
+	rmCommand,
+	treeCommand,
+	nanoCommand,
+	htopCommand,
+	adduserCommand,
+	deluserCommand,
+	sudoCommand,
+	suCommand,
+	curlCommand,
+	wgetCommand,
+	clearCommand,
+	exitCommand,
+];
+
+const COMMANDS: ShellModule[] = [
+	...BASE_COMMANDS,
+	createHelpCommand(() => COMMANDS.map((cmd) => cmd.name)),
+];
+
+export function getCommandNames(): string[] {
+	return COMMANDS.flatMap((cmd) => [cmd.name, ...(cmd.aliases ?? [])]);
+}
+
+function resolveModule(name: string): ShellModule | undefined {
+	const lowered = name.toLowerCase();
+	return COMMANDS.find(
+		(cmd) => cmd.name === lowered || cmd.aliases?.includes(lowered),
+	);
+}
+
+function parseInput(rawInput: string): { commandName: string; args: string[] } {
+	const parts = rawInput.trim().split(/\s+/).filter(Boolean);
+	return {
+		commandName: parts[0]?.toLowerCase() ?? "",
+		args: parts.slice(1),
+	};
+}
+
+export function runCommand(
+	rawInput: string,
+	authUser: string,
+	hostname: string,
+	users: VirtualUserManager,
+	mode: CommandMode,
+	cwd: string,
+	vfs: VirtualFileSystem,
+): CommandOutcome {
+	const trimmed = rawInput.trim();
+
+	if (trimmed.length === 0) {
+		return { exitCode: 0 };
+	}
+
+	const { commandName, args } = parseInput(trimmed);
+	const mod = resolveModule(commandName);
+
+	if (!mod) {
+		return {
+			stderr: `Command '${trimmed}' not found`,
+			exitCode: 127,
+		};
+	}
+
+	try {
+		return mod.run({
+			authUser,
+			hostname,
+			users,
+			activeSessions: users.listActiveSessions(),
+			rawInput: trimmed,
+			mode,
+			args,
+			cwd,
+			vfs,
+		});
+	} catch (error: unknown) {
+		const message = error instanceof Error ? error.message : "Command failed";
+		return { stderr: message, exitCode: 1 };
+	}
+}

package/src/SSHMimic/commands/ls.ts

@@ -0,0 +1,14 @@
+import type { ShellModule } from "../../types/commands";
+import { joinListWithType, resolvePath } from "./helpers";
+
+export const lsCommand: ShellModule = {
+	name: "ls",
+	params: ["[path]"],
+	run: ({ vfs, cwd, args }) => {
+		const targetArg = args.find((arg) => !arg.startsWith("-"));
+		const target = resolvePath(cwd, targetArg ?? cwd);
+		const items = vfs.list(target).filter((name) => !name.startsWith("."));
+		const rendered = joinListWithType(target, items, (p) => vfs.stat(p));
+		return { stdout: rendered, exitCode: 0 };
+	},
+};

package/src/SSHMimic/commands/mkdir.ts

@@ -0,0 +1,17 @@
+import type { ShellModule } from "../../types/commands";
+import { resolvePath } from "./helpers";
+
+export const mkdirCommand: ShellModule = {
+	name: "mkdir",
+	params: ["<dir>"],
+	run: ({ vfs, cwd, args }) => {
+		if (args.length === 0) {
+			return { stderr: "mkdir: missing operand", exitCode: 1 };
+		}
+
+		for (const dir of args) {
+			vfs.mkdir(resolvePath(cwd, dir));
+		}
+		return { exitCode: 0 };
+	},
+};

package/src/SSHMimic/commands/nano.ts

@@ -0,0 +1,30 @@
+import * as path from "node:path";
+import type { ShellModule } from "../../types/commands";
+import { resolvePath } from "./helpers";
+
+export const nanoCommand: ShellModule = {
+	name: "nano",
+	params: ["<file>"],
+	run: ({ vfs, cwd, args }) => {
+		const fileArg = args[0];
+		if (!fileArg) {
+			return { stderr: "nano: missing file operand", exitCode: 1 };
+		}
+
+		const targetPath = resolvePath(cwd, fileArg);
+		const initialContent = vfs.exists(targetPath)
+			? vfs.readFile(targetPath)
+			: "";
+		const safeName = path.posix.basename(targetPath) || "buffer";
+		const tempPath = `/tmp/sshmimic-nano-${Date.now()}-${safeName}.tmp`;
+
+		return {
+			openEditor: {
+				targetPath,
+				tempPath,
+				initialContent,
+			},
+			exitCode: 0,
+		};
+	},
+};

package/src/SSHMimic/commands/pwd.ts

@@ -0,0 +1,7 @@
+import type { ShellModule } from "../../types/commands";
+
+export const pwdCommand: ShellModule = {
+	name: "pwd",
+	params: [],
+	run: ({ cwd }) => ({ stdout: cwd, exitCode: 0 }),
+};

package/src/SSHMimic/commands/rm.ts

@@ -0,0 +1,26 @@
+import type { ShellModule } from "../../types/commands";
+import { resolvePath } from "./helpers";
+
+export const rmCommand: ShellModule = {
+	name: "rm",
+	params: ["[-r|-rf] <path>"],
+	run: ({ vfs, cwd, args }) => {
+		if (args.length === 0) {
+			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("-"));
+
+		if (targets.length === 0) {
+			return { stderr: "rm: missing operand", exitCode: 1 };
+		}
+
+		for (const target of targets) {
+			vfs.remove(resolvePath(cwd, target), { recursive });
+		}
+
+		return { exitCode: 0 };
+	},
+};

package/src/SSHMimic/commands/su.ts

@@ -0,0 +1,31 @@
+import type { ShellModule } from "../../types/commands";
+
+export const suCommand: ShellModule = {
+	name: "su",
+	params: ["- <username>"],
+	run: ({ authUser, users, args }) => {
+		const filtered = args.filter((arg) => arg !== "-");
+		const targetUser = filtered[0];
+
+		if (!targetUser) {
+			return { stderr: "su: missing username", exitCode: 1 };
+		}
+
+		if (!users.isSudoer(authUser) && authUser !== "root") {
+			return { stderr: "su: permission denied", exitCode: 1 };
+		}
+
+		if (
+			!users.verifyPassword(targetUser, filtered[1] ?? "") &&
+			authUser !== "root"
+		) {
+			return { stderr: "su: authentication failure", exitCode: 1 };
+		}
+
+		return {
+			switchUser: targetUser,
+			nextCwd: `/home/${targetUser}`,
+			exitCode: 0,
+		};
+	},
+};

package/src/SSHMimic/commands/sudo.ts

@@ -0,0 +1,90 @@
+import type { ShellModule } from "../../types/commands";
+import { runCommand } from "./index";
+
+function parseSudoArgs(args: string[]): {
+	targetUser: 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;
+		}
+
+		if (arg.startsWith("-u=")) {
+			targetUser = arg.slice(3) || "root";
+			continue;
+		}
+
+		commandParts.push(arg);
+	}
+
+	const commandLine = commandParts.length > 0 ? commandParts.join(" ") : null;
+	return { targetUser, loginShell, commandLine };
+}
+export const sudoCommand: ShellModule = {
+	name: "sudo",
+	params: ["<command...>"],
+	run: async ({ authUser, hostname, users, mode, cwd, vfs, args }) => {
+		const { targetUser, loginShell, commandLine } = parseSudoArgs(args);
+
+		if (authUser !== "root" && !users.isSudoer(authUser)) {
+			return { stderr: "sudo: permission denied", exitCode: 1 };
+		}
+
+		const effectiveUser = targetUser || "root";
+		const prompt = `[sudo] password for ${authUser}: `;
+
+		if (authUser === "root") {
+			if (!commandLine && loginShell) {
+				return {
+					switchUser: effectiveUser,
+					nextCwd: `/home/${effectiveUser}`,
+					exitCode: 0,
+				};
+			}
+
+			if (!commandLine) {
+				return { stderr: "sudo: missing command", exitCode: 1 };
+			}
+
+			return runCommand(
+				commandLine,
+				effectiveUser,
+				hostname,
+				users,
+				mode,
+				loginShell ? `/home/${effectiveUser}` : cwd,
+				vfs,
+			);
+		}
+
+		return {
+			sudoChallenge: {
+				username: authUser,
+				targetUser: effectiveUser,
+				commandLine,
+				loginShell,
+				prompt,
+			},
+			exitCode: 0,
+		};
+	},
+};

package/src/SSHMimic/commands/touch.ts

@@ -0,0 +1,20 @@
+import type { ShellModule } from "../../types/commands";
+import { resolvePath } from "./helpers";
+
+export const touchCommand: ShellModule = {
+	name: "touch",
+	params: ["<file>"],
+	run: ({ vfs, cwd, args }) => {
+		if (args.length === 0) {
+			return { stderr: "touch: missing file operand", exitCode: 1 };
+		}
+
+		for (const file of args) {
+			const target = resolvePath(cwd, file);
+			if (!vfs.exists(target)) {
+				vfs.writeFile(target, "");
+			}
+		}
+		return { exitCode: 0 };
+	},
+};

package/src/SSHMimic/commands/tree.ts

@@ -0,0 +1,11 @@
+import type { ShellModule } from "../../types/commands";
+import { resolvePath } from "./helpers";
+
+export const treeCommand: ShellModule = {
+	name: "tree",
+	params: ["[path]"],
+	run: ({ vfs, cwd, args }) => {
+		const target = resolvePath(cwd, args[0] ?? cwd);
+		return { stdout: vfs.tree(target), exitCode: 0 };
+	},
+};

package/src/SSHMimic/commands/wget.ts

@@ -0,0 +1,33 @@
+import type { ShellModule } from "../../types/commands";
+import {
+	fetchResource,
+	parseOutputPath,
+	resolvePath,
+	stripUrlFilename,
+} from "./helpers";
+
+export const wgetCommand: ShellModule = {
+	name: "wget",
+	params: ["[url]"],
+	run: async ({ vfs, cwd, args }) => {
+		const { outputPath, inputArgs } = parseOutputPath(args);
+		const url = inputArgs[0];
+
+		if (!url) {
+			return { stderr: "wget: missing URL", exitCode: 1 };
+		}
+
+		const result = await fetchResource(url);
+		if (result.status >= 400) {
+			return { stderr: `wget: HTTP ${result.status}`, exitCode: 8 };
+		}
+
+		const target = resolvePath(cwd, outputPath ?? stripUrlFilename(url));
+		vfs.writeFile(target, result.text);
+
+		return {
+			stdout: `saved ${target}`,
+			exitCode: 0,
+		};
+	},
+};

package/src/SSHMimic/commands/who.ts

@@ -0,0 +1,18 @@
+import type { ShellModule } from "../../types/commands";
+import { formatLoginDate } from "../loginFormat";
+
+export const whoCommand: ShellModule = {
+	name: "who",
+	params: [],
+	run: ({ users }) => {
+		const lines = users.listActiveSessions().map((session) => {
+			const loginAt = new Date(session.startedAt);
+			const displayDate = Number.isNaN(loginAt.getTime())
+				? session.startedAt
+				: formatLoginDate(loginAt);
+			return `${session.username} ${session.tty} ${displayDate} (${session.remoteAddress || "unknown"})`;
+		});
+
+		return { stdout: lines.join("\n"), exitCode: 0 };
+	},
+};

package/src/SSHMimic/commands/whoami.ts

@@ -0,0 +1,7 @@
+import type { ShellModule } from "../../types/commands";
+
+export const whoamiCommand: ShellModule = {
+	name: "whoami",
+	params: [],
+	run: ({ authUser }) => ({ stdout: authUser, exitCode: 0 }),
+};

package/src/SSHMimic/exec.ts

@@ -0,0 +1,37 @@
+import type { ExecStream } from "../types/streams";
+import type VirtualFileSystem from "../VirtualFileSystem";
+import { runCommand } from "./commands";
+import type { VirtualUserManager } from "./users";
+
+export function runExec(
+	stream: ExecStream,
+	cmd: string,
+	authUser: string,
+	hostname: string,
+	users: VirtualUserManager,
+	vfs: VirtualFileSystem,
+): void {
+	Promise.resolve(
+		runCommand(
+			cmd,
+			authUser,
+			hostname,
+			users,
+			"exec",
+			`/home/${authUser}`,
+			vfs,
+		),
+	).then((result) => {
+		if (result.stdout) {
+			stream.write(`${result.stdout}\n`);
+		}
+
+		if (result.stderr) {
+			stream.stderr.write(`${result.stderr}\n`);
+		}
+
+		stream.exit(result.exitCode ?? 0);
+		void vfs.flushMirror();
+		stream.end();
+	});
+}

package/src/SSHMimic/hostKey.ts

@@ -0,0 +1,21 @@
+import { generateKeyPairSync } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+
+export function loadOrCreateHostKey(baseDir: string = process.cwd()): string {
+	const hostKeyPath = resolve(baseDir, ".ssh-mimic", "host_rsa");
+
+	if (existsSync(hostKeyPath)) {
+		return readFileSync(hostKeyPath, "utf8");
+	}
+
+	const privateKey = generateKeyPairSync("rsa", {
+		modulusLength: 2048,
+		privateKeyEncoding: { type: "pkcs1", format: "pem" },
+		publicKeyEncoding: { type: "pkcs1", format: "pem" },
+	}).privateKey;
+
+	mkdirSync(dirname(hostKeyPath), { recursive: true });
+	writeFileSync(hostKeyPath, privateKey, { mode: 0o600 });
+	return privateKey;
+}