typescript-virtual-container 1.5.2 → 1.5.4

package/src/commands/mkdir.ts

@@ -1,31 +0,0 @@
-import type { ShellModule } from "../types/commands";
-import { getArg } from "./command-helpers";
-import { assertPathAccess, resolvePath } from "./helpers";
-
-/**
- * Create one or more directories.
- * @category files
- * @params ["<dir>"]
- */
-export const mkdirCommand: ShellModule = {
-	name: "mkdir",
-	description: "Make directories",
-	category: "files",
-	params: ["<dir>"],
-	run: ({ authUser, shell, cwd, args }) => {
-		if (args.length === 0) {
-			return { stderr: "mkdir: missing operand", exitCode: 1 };
-		}
-
-		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");
-			shell.vfs.mkdir(target);
-		}
-		return { exitCode: 0 };
-	},
-};

package/src/commands/mv.ts

@@ -1,50 +0,0 @@
-import type { ShellModule } from "../types/commands";
-import { assertPathAccess, resolvePath } from "./helpers";
-
-/**
- * Move or rename files and directories.
- * @category files
- * @params ["<source> <dest>"]
- */
-export const mvCommand: ShellModule = {
-	name: "mv",
-	description: "Move or rename files",
-	category: "files",
-	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/nano.ts

@@ -1,38 +0,0 @@
-import * as path from "node:path";
-import type { ShellModule } from "../types/commands";
-import { assertPathAccess, resolvePath } from "./helpers";
-
-/**
- * Simple text editor for editing files.
- * @category files
- * @params ["<file>"]
- */
-export const nanoCommand: ShellModule = {
-	name: "nano",
-	description: "Text editor",
-	category: "files",
-	params: ["<file>"],
-	run: ({ authUser, shell, cwd, args }) => {
-		const fileArg = args[0];
-		if (!fileArg) {
-			return { stderr: "nano: missing file operand", exitCode: 1 };
-		}
-
-		const targetPath = resolvePath(cwd, fileArg);
-		assertPathAccess(authUser, targetPath, "nano");
-		const initialContent = shell.vfs.exists(targetPath)
-			? shell.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/commands/neofetch.ts

@@ -1,53 +0,0 @@
-import { buildNeofetchOutput } from "../modules/neofetch";
-import type { ShellModule } from "../types/commands";
-import { ifFlag } from "./command-helpers";
-
-/**
- * Display system information in a decorative format.
- * @category system
- * @params ["[--off]"]
- */
-export const neofetchCommand: ShellModule = {
-	name: "neofetch",
-	description: "System info display",
-	category: "system",
-	params: ["[--off]"],
-	run: ({ args, authUser, hostname, shell, env }) => {
-		if (!shell.packageManager.isInstalled("neofetch")) {
-			return {
-				stderr:
-					"bash: neofetch: command not found\nHint: install it with: apt install neofetch\n",
-				exitCode: 127,
-			};
-		}
-		if (ifFlag(args, "--help")) {
-			return {
-				stdout: "Usage: neofetch [--off]",
-				exitCode: 0,
-			};
-		}
-
-		if (ifFlag(args, "--off")) {
-			return {
-				stdout: `${authUser}@${hostname}`,
-				exitCode: 0,
-			};
-		}
-
-		return {
-			stdout: buildNeofetchOutput({
-				user: authUser,
-				host: hostname,
-				shell: env.vars.SHELL,
-				shellProps: shell.properties,
-				terminal: env.vars.TERM,
-				uptimeSeconds: Math.floor((Date.now() - shell.startTime) / 1000),
-				packages: (() => {
-					const count = shell.packageManager?.installedCount() ?? 0;
-					return `${count} (dpkg)`;
-				})(),
-			}),
-			exitCode: 0,
-		};
-	},
-};

package/src/commands/node.ts

@@ -1,341 +0,0 @@
-/** biome-ignore-all lint/style/useNamingConvention: node globals and ENV VAR KEYS */
-/**
- * node.ts — Virtual Node.js runtime.
- *
- * Uses `node:vm` for sandboxed evaluation with a controlled context that
- * intercepts `process`, `require`, `console`, and all standard globals.
- * No host filesystem access, no network, no child processes.
- */
-import vm from "node:vm";
-import type { ShellModule } from "../types/commands";
-import { ifFlag } from "./command-helpers";
-import { resolvePath } from "./helpers";
-
-const VIRTUAL_VERSION = "v18.19.0";
-const VIRTUAL_VERSIONS = {
-	node: VIRTUAL_VERSION,
-	npm: "9.2.0",
-	v8: "10.2.154.26-node.22",
-};
-
-// ─── sandbox context ──────────────────────────────────────────────────────────
-
-function makeContext(outputLines: string[], stderrLines: string[]) {
-	const fakeProcess = {
-		version: VIRTUAL_VERSION,
-		versions: VIRTUAL_VERSIONS,
-		platform: "linux",
-		arch: "x64",
-		env: {
-			NODE_ENV: "production",
-			HOME: "/root",
-			PATH: "/usr/local/bin:/usr/bin:/bin",
-		},
-		argv: ["node"],
-		stdout: {
-			write: (s: string) => {
-				outputLines.push(s);
-				return true;
-			},
-		},
-		stderr: {
-			write: (s: string) => {
-				stderrLines.push(s);
-				return true;
-			},
-		},
-		exit: (code = 0) => {
-			throw new ExitSignal(code);
-		},
-		cwd: () => "/root",
-		hrtime: () => [0, 0],
-	};
-
-	const fakeConsole = {
-		log: (...a: unknown[]) => outputLines.push(a.map(formatValue).join(" ")),
-		error: (...a: unknown[]) => stderrLines.push(a.map(formatValue).join(" ")),
-		warn: (...a: unknown[]) => stderrLines.push(a.map(formatValue).join(" ")),
-		info: (...a: unknown[]) => outputLines.push(a.map(formatValue).join(" ")),
-		dir: (v: unknown) => outputLines.push(formatValue(v)),
-	};
-
-	const fakeRequire = (mod: string): unknown => {
-		// Provide stubs for common modules
-		switch (mod) {
-			case "path":
-				return {
-					join: (...parts: string[]) => parts.join("/").replace(/\/+/g, "/"),
-					resolve: (...parts: string[]) =>
-						`/${parts.join("/").replace(/^\/+/, "")}`,
-					dirname: (p: string) => p.split("/").slice(0, -1).join("/") || "/",
-					basename: (p: string) => p.split("/").pop() ?? "",
-					extname: (p: string) => {
-						const b = p.split("/").pop() ?? "";
-						const d = b.lastIndexOf(".");
-						return d > 0 ? b.slice(d) : "";
-					},
-					sep: "/",
-					delimiter: ":",
-				};
-			case "os":
-				return {
-					platform: () => "linux",
-					arch: () => "x64",
-					type: () => "Linux",
-					hostname: () => "fortune-vm",
-					homedir: () => "/root",
-					tmpdir: () => "/tmp",
-					EOL: "\n",
-				};
-			case "util":
-				return {
-					format: (...a: unknown[]) => a.map(formatValue).join(" "),
-					inspect: (v: unknown) => formatValue(v),
-				};
-			case "fs":
-			case "fs/promises":
-				throw new Error(
-					`Cannot require '${mod}': filesystem access not available in virtual runtime`,
-				);
-			case "child_process":
-			case "net":
-			case "http":
-			case "https":
-				throw new Error(
-					`Cannot require '${mod}': not available in virtual runtime`,
-				);
-			default:
-				throw new Error(`Cannot find module '${mod}'`);
-		}
-	};
-	fakeRequire.resolve = (id: string) => {
-		throw new Error(`Cannot resolve '${id}'`);
-	};
-	fakeRequire.cache = {};
-	fakeRequire.extensions = {};
-
-	return vm.createContext({
-		// Core globals
-		console: fakeConsole,
-		process: fakeProcess,
-		require: fakeRequire,
-
-		// JS built-ins
-		Math,
-		JSON,
-		Object,
-		Array,
-		String,
-		Number,
-		Boolean,
-		Symbol,
-		Date,
-		RegExp,
-		Error,
-		TypeError,
-		RangeError,
-		SyntaxError,
-		Promise,
-		Map,
-		Set,
-		WeakMap,
-		WeakSet,
-		parseInt,
-		parseFloat,
-		isNaN,
-		isFinite,
-		encodeURIComponent,
-		decodeURIComponent,
-		encodeURI,
-		decodeURI,
-		setTimeout: () => {},
-		clearTimeout: () => {},
-		setInterval: () => {},
-		clearInterval: () => {},
-		queueMicrotask: () => {},
-		globalThis: undefined as unknown, // set below
-		undefined,
-		Infinity,
-		NaN,
-	});
-}
-
-class ExitSignal {
-	constructor(public readonly code: number) {}
-}
-
-function formatValue(v: unknown): string {
-	if (v === null) return "null";
-	if (v === undefined) return "undefined";
-	if (typeof v === "string") return v;
-	if (typeof v === "function") return `[Function: ${v.name || "(anonymous)"}]`;
-	if (Array.isArray(v)) return `[ ${v.map(formatValue).join(", ")} ]`;
-	if (v instanceof Error) return `${v.name}: ${v.message}`;
-	if (typeof v === "object") {
-		try {
-			const entries = Object.entries(v as Record<string, unknown>)
-				.map(([k, val]) => `${k}: ${formatValue(val)}`)
-				.join(", ");
-			return `{ ${entries} }`;
-		} catch {
-			return "[Object]";
-		}
-	}
-	return String(v);
-}
-
-// ─── execution ────────────────────────────────────────────────────────────────
-
-function runJs(code: string): {
-	stdout: string;
-	stderr: string;
-	exitCode: number;
-} {
-	const outputLines: string[] = [];
-	const stderrLines: string[] = [];
-	const ctx = makeContext(outputLines, stderrLines);
-
-	let exitCode = 0;
-
-	try {
-		const result = vm.runInContext(code, ctx, { timeout: 5000 });
-		// If the expression returned a value and nothing was console.log'd, print it
-		if (result !== undefined && outputLines.length === 0) {
-			outputLines.push(formatValue(result));
-		}
-	} catch (err) {
-		if (err instanceof ExitSignal) {
-			exitCode = err.code;
-		} else if (err instanceof Error) {
-			stderrLines.push(`${err.name}: ${err.message}`);
-			exitCode = 1;
-		} else {
-			stderrLines.push(String(err));
-			exitCode = 1;
-		}
-	}
-
-	return {
-		stdout: outputLines.length ? `${outputLines.join("\n")}\n` : "",
-		stderr: stderrLines.length ? `${stderrLines.join("\n")}\n` : "",
-		exitCode,
-	};
-}
-
-function runJsFile(code: string): {
-	stdout: string;
-	stderr: string;
-	exitCode: number;
-} {
-	// If the code is a single expression (no semicolons, no newlines, no statements),
-	// wrap it to capture the return value like a REPL would
-	const trimmed = code.trim();
-	const isExpression =
-		!trimmed.includes("\n") &&
-		!trimmed.startsWith("const ") &&
-		!trimmed.startsWith("let ") &&
-		!trimmed.startsWith("var ") &&
-		!trimmed.startsWith("function ") &&
-		!trimmed.startsWith("class ") &&
-		!trimmed.startsWith("if ") &&
-		!trimmed.startsWith("for ") &&
-		!trimmed.startsWith("while ") &&
-		!trimmed.startsWith("import ") &&
-		!trimmed.startsWith("//");
-
-	if (isExpression) return runJs(trimmed);
-
-	// Multi-line: wrap in IIFE
-	return runJs(`(async () => { ${code} })()`);
-}
-
-// ─── command ──────────────────────────────────────────────────────────────────
-/**
- * `node` virtual runtime command. Executes JS in a safe sandbox with
- * limited globals and no host FS/child process access.
- * @category system
- * @params []
- */
-export const nodeCommand: ShellModule = {
-	name: "node",
-	description: "JavaScript runtime (virtual)",
-	category: "system",
-	params: ["[--version] [-e <expr>] [-p <expr>] [file]"],
-	run: ({ args, shell, cwd }) => {
-		// Require explicit installation via `apt install nodejs`
-		if (!shell.packageManager.isInstalled("nodejs")) {
-			return {
-				stderr:
-					"bash: node: command not found\nHint: install it with: apt install nodejs\n",
-				exitCode: 127,
-			};
-		}
-		if (ifFlag(args, ["--version", "-v"])) {
-			return { stdout: `${VIRTUAL_VERSION}\n`, exitCode: 0 };
-		}
-
-		if (ifFlag(args, ["--versions"])) {
-			return {
-				stdout: `${JSON.stringify(VIRTUAL_VERSIONS, null, 2)}\n`,
-				exitCode: 0,
-			};
-		}
-
-		// -e 'expr'
-		const eIdx = args.findIndex((a) => a === "-e" || a === "--eval");
-		if (eIdx !== -1) {
-			const expr = args[eIdx + 1];
-			if (!expr)
-				return { stderr: "node: -e requires an argument\n", exitCode: 1 };
-			const { stdout, stderr, exitCode } = runJs(expr);
-			return {
-				stdout: stdout || undefined,
-				stderr: stderr || undefined,
-				exitCode,
-			};
-		}
-
-		// -p 'expr' — print mode
-		const pIdx = args.findIndex((a) => a === "-p" || a === "--print");
-		if (pIdx !== -1) {
-			const expr = args[pIdx + 1];
-			if (!expr)
-				return { stderr: "node: -p requires an argument\n", exitCode: 1 };
-			const { stdout, stderr, exitCode } = runJs(expr);
-			return {
-				stdout: stdout || (exitCode === 0 ? "\n" : undefined),
-				stderr: stderr || undefined,
-				exitCode,
-			};
-		}
-
-		// node <file>
-		const file = args.find((a) => !a.startsWith("-"));
-		if (file) {
-			const filePath = resolvePath(cwd, file);
-			if (!shell.vfs.exists(filePath)) {
-				return {
-					stderr: `node: cannot open file '${file}': No such file or directory\n`,
-					exitCode: 1,
-				};
-			}
-			const code = shell.vfs.readFile(filePath);
-			const { stdout, stderr, exitCode } = runJsFile(code);
-			return {
-				stdout: stdout || undefined,
-				stderr: stderr || undefined,
-				exitCode,
-			};
-		}
-
-		// No args — REPL hint
-		return {
-			stdout: [
-				`Welcome to Node.js ${VIRTUAL_VERSION}.`,
-				`Type ".exit" to exit the REPL.`,
-				`> `,
-			].join("\n"),
-			exitCode: 0,
-		};
-	},
-};

package/src/commands/npm.ts

@@ -1,132 +0,0 @@
-/**
- * npm.ts — Virtual npm command.
- * Gated behind `apt install npm`. Provides version info and informative
- * stubs for common subcommands.
- */
-import type { ShellModule } from "../types/commands";
-import { ifFlag } from "./command-helpers";
-
-const NPM_VERSION = "9.2.0";
-const NODE_VERSION = "18.19.0";
-
-/**
- * `npm` virtual CLI. Requires `apt install npm` in the virtual package manager.
- * @category system
- * @params ["<command> [args]"]
- */
-export const npmCommand: ShellModule = {
-	name: "npm",
-	description: "Node.js package manager (virtual)",
-	category: "system",
-	params: ["<command> [args]"],
-	run: ({ args, shell }) => {
-		// Require explicit installation
-		if (!shell.packageManager.isInstalled("npm")) {
-			return {
-				stderr:
-					"bash: npm: command not found\nHint: install it with: apt install npm\n",
-				exitCode: 127,
-			};
-		}
-
-		if (ifFlag(args, ["--version", "-v"])) {
-			return { stdout: `${NPM_VERSION}\n`, exitCode: 0 };
-		}
-
-		const sub = args[0]?.toLowerCase();
-
-		switch (sub) {
-			case "version":
-			case "-version":
-				return {
-					stdout: `{ npm: '${NPM_VERSION}', node: '${NODE_VERSION}', v8: '10.2.154.26' }\n`,
-					exitCode: 0,
-				};
-
-			case "install":
-			case "i":
-			case "add":
-				return {
-					stderr:
-						"npm warn: package installation is not available in the virtual runtime.\nnpm warn: This environment simulates npm CLI behaviour only.\n",
-					exitCode: 1,
-				};
-
-			case "run":
-			case "exec":
-			case "x":
-				return {
-					stderr: `npm error: script execution is not available in the virtual runtime.\n`,
-					exitCode: 1,
-				};
-
-			case "init":
-				return {
-					stdout: "Wrote to /home/user/package.json\n",
-					exitCode: 0,
-				};
-
-			case "list":
-			case "ls":
-				return {
-					stdout: `${sub === "ls" || sub === "list" ? "virtual-env@1.0.0" : ""}\n└── (empty)\n`,
-					exitCode: 0,
-				};
-
-			case "help":
-			case undefined:
-				return {
-					stdout: `${[
-						`npm ${NPM_VERSION}`,
-						"",
-						"Usage: npm <command>",
-						"",
-						"Commands:",
-						"  install       (not available in virtual runtime)",
-						"  run           (not available in virtual runtime)",
-						"  exec          (not available in virtual runtime)",
-						"  list          List installed packages",
-						"  version       Print versions",
-						"  --version     Print npm version",
-					].join("\n")}\n`,
-					exitCode: 0,
-				};
-
-			default:
-				return {
-					stderr: `npm error: unknown command: ${sub}\n`,
-					exitCode: 1,
-				};
-		}
-	},
-};
-
-/**
- * `npx` virtual runner. Requires `apt install npm` in the virtual package manager.
- * @category system
- * @params ["<package> [args]"]
- */
-export const npxCommand: ShellModule = {
-	name: "npx",
-	description: "Node.js package runner (virtual)",
-	category: "system",
-	params: ["<package> [args]"],
-	run: ({ args, shell }) => {
-		if (!shell.packageManager.isInstalled("npm")) {
-			return {
-				stderr:
-					"bash: npx: command not found\nHint: install it with: apt install npm\n",
-				exitCode: 127,
-			};
-		}
-
-		if (ifFlag(args, ["--version"])) {
-			return { stdout: `${NPM_VERSION}\n`, exitCode: 0 };
-		}
-
-		return {
-			stderr: `npx: package execution is not available in the virtual runtime.\n`,
-			exitCode: 1,
-		};
-	},
-};

package/src/commands/passwd.ts

@@ -1,50 +0,0 @@
-import type { ShellModule } from "../types/commands";
-
-/**
- * `passwd [username]` — change a virtual user's password.
- *
- * - Root can change any user's password.
- * - Non-root can only change their own password.
- * - Interactive: emits `passwordChallenge` for hidden-input prompting.
- * - Non-interactive: reads new password from stdin first line.
- */
-export const passwdCommand: ShellModule = {
-	name: "passwd",
-	description: "Change user password",
-	category: "users",
-	params: ["[username]"],
-	run: async ({ authUser, args, shell, stdin }) => {
-		const targetUser = args[0] ?? authUser;
-
-		// Permission check
-		if (authUser !== "root" && authUser !== targetUser) {
-			return { stderr: "passwd: permission denied", exitCode: 1 };
-		}
-
-		// Target must exist
-		if (!shell.users.listUsers().includes(targetUser)) {
-			return { stderr: `passwd: user '${targetUser}' does not exist`, exitCode: 1 };
-		}
-
-		// Non-interactive: read new password from stdin
-		if (stdin !== undefined && stdin.trim().length > 0) {
-			const password = stdin.trim().split("\n")[0]!;
-			await shell.users.setPassword(targetUser, password);
-			return {
-				stdout: `passwd: password updated successfully\n`,
-				exitCode: 0,
-			};
-		}
-
-		// Interactive: emit password challenge
-		return {
-			passwordChallenge: {
-				prompt: "New password: ",
-				confirmPrompt: "Retype new password: ",
-				action: "passwd" as const,
-				targetUsername: targetUser,
-			},
-			exitCode: 0,
-		};
-	},
-};