typescript-virtual-container 1.4.1 → 1.4.3

package/src/VirtualFileSystem/index.ts

@@ -75,6 +75,11 @@ class VirtualFileSystem extends EventEmitter {
 	private root: InternalDirectoryNode;
 	private readonly mode: VfsPersistenceMode;
 	private readonly snapshotFile: string | null;
+	/** Active host-directory mounts: vPath → { hostPath, readOnly } */
+	private readonly mounts = new Map<string, { hostPath: string; readOnly: boolean }>();
+	/** True when running in a browser environment (no host FS access). */
+	private static readonly isBrowser =
+		typeof process === "undefined" || typeof (process as NodeJS.Process).versions?.node === "undefined";
 
 	constructor(options: VfsOptions = {}) {
 		super();
@@ -219,7 +224,97 @@ class VirtualFileSystem extends EventEmitter {
 	// ── Public filesystem API ─────────────────────────────────────────────────
 
 	/** Creates a directory (and any missing parents). */
-	public mkdir(targetPath: string, mode: number = 0o755): void {
+
+	// ── Mount API ─────────────────────────────────────────────────────────────
+
+	/**
+	 * Mount a host directory into the VFS at `vPath`.
+	 *
+	 * Files inside `vPath` are read directly from the host filesystem via
+	 * `node:fs`. All standard VFS operations (`readFile`, `writeFile`,
+	 * `exists`, `stat`, `list`) are transparently delegated.
+	 *
+	 * In browser environments the mount is silently ignored — `vPath` remains
+	 * an empty in-memory directory.
+	 *
+	 * @param vPath     Absolute path inside the VM (e.g. `"/app"`).
+	 * @param hostPath  Path on the host filesystem — relative paths are
+	 *                  resolved from `process.cwd()`.
+	 * @param readOnly  When `true` (default), write operations inside the
+	 *                  mount throw `EROFS: read-only file system`.
+	 *
+	 * @example
+	 * ```ts
+	 * shell.vfs.mount("/app", "./src", { readOnly: true });
+	 * // cat /app/index.ts  — reads ./src/index.ts from host
+	 * ```
+	 */
+	public mount(
+		vPath: string,
+		hostPath: string,
+		{ readOnly = true }: { readOnly?: boolean } = {},
+	): void {
+		if (VirtualFileSystem.isBrowser) return; // silently degrade in browser
+		const normalized = normalizePath(vPath);
+		const resolved   = path.resolve(hostPath);
+		if (!fsSync.existsSync(resolved)) {
+			throw new Error(`VirtualFileSystem.mount: host path does not exist: "${resolved}"`);
+		}
+		if (!fsSync.statSync(resolved).isDirectory()) {
+			throw new Error(`VirtualFileSystem.mount: host path is not a directory: "${resolved}"`);
+		}
+		// Ensure the mount point exists in the VFS tree
+		this.mkdir(normalized);
+		this.mounts.set(normalized, { hostPath: resolved, readOnly });
+		this.emit("mount", { vPath: normalized, hostPath: resolved, readOnly });
+	}
+
+	/**
+	 * Unmount a previously mounted host directory.
+	 * The in-memory VFS directory at `vPath` is preserved but the host
+	 * delegation is removed.
+	 */
+	public unmount(vPath: string): void {
+		const normalized = normalizePath(vPath);
+		if (this.mounts.delete(normalized)) {
+			this.emit("unmount", { vPath: normalized });
+		}
+	}
+
+	/** List all active mounts. */
+	public getMounts(): Array<{ vPath: string; hostPath: string; readOnly: boolean }> {
+		return [...this.mounts.entries()].map(([vPath, opts]) => ({
+			vPath, ...opts,
+		}));
+	}
+
+	/**
+	 * If `targetPath` is inside a mount, return `{ hostPath, readOnly, relPath }`.
+	 * `relPath` is the path relative to the mount's host directory.
+	 * Returns `null` if the path is not under any mount.
+	 */
+	private resolveMount(targetPath: string): {
+		hostPath: string;
+		readOnly: boolean;
+		relPath:  string;
+		fullHostPath: string;
+	} | null {
+		const normalized = normalizePath(targetPath);
+		// Iterate mounts from most specific to least specific
+		const sorted = [...this.mounts.entries()].sort(
+			([a], [b]) => b.length - a.length,
+		);
+		for (const [vBase, opts] of sorted) {
+			if (normalized === vBase || normalized.startsWith(`${vBase}/`)) {
+				const relPath      = normalized.slice(vBase.length).replace(/^\//, "");
+				const fullHostPath = relPath ? path.join(opts.hostPath, relPath) : opts.hostPath;
+				return { hostPath: opts.hostPath, readOnly: opts.readOnly, relPath, fullHostPath };
+			}
+		}
+		return null;
+	}
+
+		public mkdir(targetPath: string, mode: number = 0o755): void {
 		const normalized = normalizePath(targetPath);
 		const existing = (() => {
 			try {
@@ -245,6 +340,15 @@ class VirtualFileSystem extends EventEmitter {
 		content: string | Buffer,
 		options: WriteFileOptions = {},
 	): void {
+		// Delegate to host FS if inside a mount
+		const m = this.resolveMount(targetPath);
+		if (m) {
+			if (m.readOnly) throw new Error(`EROFS: read-only file system, open '${m.fullHostPath}'`);
+			const dir = path.dirname(m.fullHostPath);
+			if (!fsSync.existsSync(dir)) fsSync.mkdirSync(dir, { recursive: true });
+			fsSync.writeFileSync(m.fullHostPath, Buffer.isBuffer(content) ? content : Buffer.from(content, "utf8"));
+			return;
+		}
 		const normalized = normalizePath(targetPath);
 		const { parent, name } = getParentDirectory(
 			this.root,
@@ -288,6 +392,11 @@ class VirtualFileSystem extends EventEmitter {
 	 * Gzip-compressed files are transparently decompressed.
 	 */
 	public readFile(targetPath: string): string {
+		const m = this.resolveMount(targetPath);
+		if (m) {
+			if (!fsSync.existsSync(m.fullHostPath)) throw new Error(`ENOENT: no such file or directory, open '${m.fullHostPath}'`);
+			return fsSync.readFileSync(m.fullHostPath, "utf8");
+		}
 		const normalized = normalizePath(targetPath);
 		const node = getNode(this.root, normalized);
 		if (node.type !== "file") {
@@ -301,6 +410,11 @@ class VirtualFileSystem extends EventEmitter {
 
 	/** Reads file content as a Buffer (decompresses if needed). */
 	public readFileRaw(targetPath: string): Buffer {
+		const m = this.resolveMount(targetPath);
+		if (m) {
+			if (!fsSync.existsSync(m.fullHostPath)) throw new Error(`ENOENT: no such file or directory, open '${m.fullHostPath}'`);
+			return fsSync.readFileSync(m.fullHostPath);
+		}
 		const normalized = normalizePath(targetPath);
 		const node = getNode(this.root, normalized);
 		if (node.type !== "file") {
@@ -314,6 +428,8 @@ class VirtualFileSystem extends EventEmitter {
 
 	/** Returns true when a file or directory exists at path. */
 	public exists(targetPath: string): boolean {
+		const m = this.resolveMount(targetPath);
+		if (m) return fsSync.existsSync(m.fullHostPath);
 		try {
 			getNode(this.root, normalizePath(targetPath));
 			return true;
@@ -329,6 +445,34 @@ class VirtualFileSystem extends EventEmitter {
 
 	/** Returns metadata for a file or directory. */
 	public stat(targetPath: string): VfsNodeStats {
+		const m = this.resolveMount(targetPath);
+		if (m) {
+			if (!fsSync.existsSync(m.fullHostPath)) throw new Error(`ENOENT: stat '${m.fullHostPath}'`);
+			const hst = fsSync.statSync(m.fullHostPath);
+			const name = m.relPath.split("/").pop() ?? m.fullHostPath.split("/").pop() ?? "";
+			const now = hst.mtime;
+			if (hst.isDirectory()) {
+				return {
+					type: "directory",
+					name,
+					path: normalizePath(targetPath),
+					mode: 0o755,
+					createdAt: hst.birthtime,
+					updatedAt: now,
+					childrenCount: fsSync.readdirSync(m.fullHostPath).length,
+				} satisfies import("../types/vfs").VfsDirectoryNode;
+			}
+			return {
+				type: "file",
+				name,
+				path: normalizePath(targetPath),
+				mode: m.readOnly ? 0o444 : 0o644,
+				createdAt: hst.birthtime,
+				updatedAt: now,
+				compressed: false,
+				size: hst.size,
+			} satisfies import("../types/vfs").VfsFileNode;
+		}
 		const normalized = normalizePath(targetPath);
 		const node = getNode(this.root, normalized);
 		const name = normalized === "/" ? "" : path.posix.basename(normalized);
@@ -359,6 +503,13 @@ class VirtualFileSystem extends EventEmitter {
 
 	/** Lists direct children names of a directory (sorted). */
 	public list(dirPath: string = "/"): string[] {
+		const m = this.resolveMount(dirPath);
+		if (m) {
+			if (!fsSync.existsSync(m.fullHostPath)) return [];
+			try {
+				return fsSync.readdirSync(m.fullHostPath).sort();
+			} catch { return []; }
+		}
 		const normalized = normalizePath(dirPath);
 		const node = getNode(this.root, normalized);
 		if (node.type !== "directory") {
@@ -508,6 +659,18 @@ class VirtualFileSystem extends EventEmitter {
 
 	/** Removes a file or directory node. */
 	public remove(targetPath: string, options: RemoveOptions = {}): void {
+		const m = this.resolveMount(targetPath);
+		if (m) {
+			if (m.readOnly) throw new Error(`EROFS: read-only file system, unlink '${m.fullHostPath}'`);
+			if (!fsSync.existsSync(m.fullHostPath)) throw new Error(`ENOENT: no such file or directory, unlink '${m.fullHostPath}'`);
+			const hst = fsSync.statSync(m.fullHostPath);
+			if (hst.isDirectory()) {
+				fsSync.rmSync(m.fullHostPath, { recursive: options.recursive ?? false });
+			} else {
+				fsSync.unlinkSync(m.fullHostPath);
+			}
+			return;
+		}
 		const normalized = normalizePath(targetPath);
 		if (normalized === "/") throw new Error("Cannot remove root directory.");
 		const node = getNode(this.root, normalized);

package/src/VirtualShell/index.ts

@@ -298,6 +298,42 @@ class VirtualShell extends EventEmitter {
 		);
 	}
 
+	/**
+	 * Mount a host directory into the VFS at `vPath`.
+	 *
+	 * Delegates file operations inside `vPath` to the host filesystem via
+	 * `node:fs`. Silently ignored in browser environments.
+	 *
+	 * @param vPath    Absolute path inside the VM (e.g. `"/app"`).
+	 * @param hostPath Path on the host — relative paths are resolved from `process.cwd()`.
+	 * @param options  `{ readOnly?: boolean }` — default `true`.
+	 *
+	 * @example
+	 * ```ts
+	 * const shell = new VirtualShell("dev-vm");
+	 * await shell.ensureInitialized();
+	 * shell.mount("/workspace", "./my-project");
+	 * // shell commands can now read ./my-project files via /workspace
+	 * ```
+	 */
+	public mount(
+		vPath: string,
+		hostPath: string,
+		options: { readOnly?: boolean } = {},
+	): void {
+		this.vfs.mount(vPath, hostPath, options);
+	}
+
+	/** Remove a previously mounted host directory. */
+	public unmount(vPath: string): void {
+		this.vfs.unmount(vPath);
+	}
+
+	/** List all active mounts. */
+	public getMounts(): Array<{ vPath: string; hostPath: string; readOnly: boolean }> {
+		return this.vfs.getMounts();
+	}
+
 	/**
 	 * Updates only the session-dependent `/proc` entries (`/proc/<pid>`,
 	 * `/proc/self`). Cheaper than a full `refreshProcFs()` — call this

package/src/VirtualShell/shell.ts

@@ -52,7 +52,7 @@ export function startShell(
 ): void {
 	let lineBuffer = "";
 	let cursorPos = 0;
-	let history = loadHistory(shell.vfs);
+	let history = loadHistory(shell.vfs, authUser);
 	let historyIndex: number | null = null;
 	let historyDraft = "";
 	let cwd = `/home/${authUser}`;
@@ -388,11 +388,11 @@ export function startShell(
 		}
 
 		const data = history.length > 0 ? `${history.join("\n")}\n` : "";
-		shell.vfs.writeFile("/virtual-env-js/.bash_history", data);
+		shell.vfs.writeFile(`/home/${authUser}/.bash_history`, data);
 	}
 
 	function readLastLogin(): { at: string; from: string } | null {
-		const lastlogPath = `/virtual-env-js/.lastlog/${authUser}.json`;
+		const lastlogPath = `/home/${authUser}/.lastlog.json`;
 		if (!shell.vfs.exists(lastlogPath)) {
 			return null;
 		}
@@ -408,12 +408,7 @@ export function startShell(
 	}
 
 	function writeLastLogin(nowIso: string): void {
-		const dir = "/virtual-env-js/.lastlog";
-		if (!shell.vfs.exists(dir)) {
-			shell.vfs.mkdir(dir, 0o700);
-		}
-
-		const lastlogPath = `${dir}/${authUser}.json`;
+		const lastlogPath = `/home/${authUser}/.lastlog`;
 		shell.vfs.writeFile(
 			lastlogPath,
 			JSON.stringify({ at: nowIso, from: remoteAddress }),
@@ -690,8 +685,8 @@ export function startShell(
 	});
 }
 
-function loadHistory(vfs: VirtualFileSystem): string[] {
-	const historyPath = "/virtual-env-js/.bash_history";
+function loadHistory(vfs: VirtualFileSystem, authUser: string): string[] {
+	const historyPath = `/home/${authUser}/.bash_history`;
 	if (!vfs.exists(historyPath)) {
 		vfs.writeFile(historyPath, "");
 		return [];

package/src/VirtualShell/shellParser.ts

@@ -225,6 +225,10 @@ function parseCommandWithRedirections(token: string): PipelineCommand {
 	let appendOutput = false;
 	let i = 0;
 
+	let stderrFile: string | undefined;
+	let stderrAppend = false;
+	let stderrToStdout = false;
+
 	while (i < parts.length) {
 		const part = parts[i]!;
 		if (part === "<") {
@@ -247,6 +251,23 @@ function parseCommandWithRedirections(token: string): PipelineCommand {
 			outputFile = parts[i];
 			appendOutput = false;
 			i++;
+		} else if (part === "2>&1") {
+			stderrToStdout = true;
+			i++;
+		} else if (part === "2>>") {
+			i++;
+			if (i >= parts.length)
+				throw new Error("Syntax error: expected filename after 2>>");
+			stderrFile = parts[i];
+			stderrAppend = true;
+			i++;
+		} else if (part === "2>") {
+			i++;
+			if (i >= parts.length)
+				throw new Error("Syntax error: expected filename after 2>");
+			stderrFile = parts[i];
+			stderrAppend = false;
+			i++;
 		} else {
 			cmdParts.push(part);
 			i++;
@@ -254,6 +275,10 @@ function parseCommandWithRedirections(token: string): PipelineCommand {
 	}
 
 	const name = (cmdParts[0] ?? "").toLowerCase();
-	return { name, args: cmdParts.slice(1), inputFile, outputFile, appendOutput };
+	return {
+		name, args: cmdParts.slice(1),
+		inputFile, outputFile, appendOutput,
+		stderrFile, stderrAppend, stderrToStdout,
+	};
 }
 

package/src/VirtualUserManager/index.ts

@@ -47,10 +47,10 @@ const perf: PerfLogger = createPerfLogger("VirtualUserManager");
 export class VirtualUserManager extends EventEmitter {
 	private static readonly recordCache = new Map<string, VirtualUserRecord>();
 	private static readonly fastPasswordHash = resolveFastPasswordHash();
-	private readonly usersPath = "/virtual-env-js/.auth/htpasswd";
-	private readonly sudoersPath = "/virtual-env-js/.auth/sudoers";
-	private readonly quotasPath = "/virtual-env-js/.auth/quotas";
-	private readonly authDirPath = "/virtual-env-js/.auth";
+	private readonly usersPath = "/etc/htpasswd";
+	private readonly sudoersPath = "/etc/sudoers";
+	private readonly quotasPath = "/etc/quotas";
+	private readonly authDirPath = "/.virtual-env-js/.auth";
 	private readonly users = new Map<string, VirtualUserRecord>();
 	private readonly sudoers = new Set<string>();
 	private readonly quotas = new Map<string, number>();

package/src/commands/export.ts

@@ -11,13 +11,15 @@ export const exportCommand: ShellModule = {
 	category: "shell",
 	params: ["[VAR=value]"],
 	run: ({ args, env }) => {
-		if (args.length === 0) {
+		// export -p or export with no args — list all exported vars
+		if (args.length === 0 || (args.length === 1 && args[0] === "-p")) {
 			const out = Object.entries(env.vars)
+				.filter(([k]) => k && /^[A-Za-z_][A-Za-z0-9_]*$/.test(k))
 				.map(([k, v]) => `declare -x ${k}="${v}"`)
 				.join("\n");
-			return { stdout: out, exitCode: 0 };
+			return { stdout: out ? `${out}\n` : "", exitCode: 0 };
 		}
-		for (const arg of args) {
+		for (const arg of args.filter((a) => a !== "-p")) {
 			if (arg.includes("=")) {
 				const eq = arg.indexOf("=");
 				const name = arg.slice(0, eq);

package/src/commands/helpers.ts

@@ -4,7 +4,7 @@ import type VirtualFileSystem from "../VirtualFileSystem";
 import type { VirtualPackageManager } from "../VirtualPackageManager";
 import type { VirtualShell } from "../VirtualShell";
 
-const PROTECTED_PREFIXES = ["/virtual-env-js/.auth"] as const;
+const PROTECTED_PREFIXES = ["/.virtual-env-js/.auth", "/etc/htpasswd"] as const;
 
 function normalizeFetchUrl(input: string): string {
 	if (/^[a-zA-Z][a-zA-Z\d+\-.]*:/.test(input)) {

package/src/commands/history.ts

@@ -10,9 +10,9 @@ export const historyCommand: ShellModule = {
 	description: "Display command history",
 	category: "shell",
 	params: ["[n]"],
-	run: ({ args, shell }) => {
+	run: ({ args, shell, authUser }) => {
 		// History is persisted in the VFS by the interactive shell
-		const histPath = "/virtual-env-js/.bash_history";
+		const histPath = `/home/${authUser}/.bash_history`;
 		if (!shell.vfs.exists(histPath)) {
 			return { stdout: "", exitCode: 0 };
 		}

package/src/commands/registry.ts

@@ -36,6 +36,7 @@ import { htopCommand } from "./htop";
 import { idCommand } from "./id";
 import { killCommand } from "./kill";
 import { lnCommand, readlinkCommand } from "./ln";
+import { seqCommand } from "./seq";
 import { statCommand } from "./stat";
 import { lsCommand } from "./ls";
 import { lsbReleaseCommand } from "./lsb-release";
@@ -99,6 +100,7 @@ const BASE_COMMANDS: ShellModule[] = [
 	lnCommand,
 	readlinkCommand,
 	chmodCommand,
+	seqCommand,
 	statCommand,
 	findCommand,
 	// Text processing

package/src/commands/runtime.ts

@@ -7,7 +7,7 @@ import type {
     CommandResult,
     ShellEnv,
 } from "../types/commands";
-import { expandAsync } from "../utils/expand";
+import { expandAsync, expandBraces } from "../utils/expand";
 import { tokenizeCommand } from "../utils/tokenize";
 import { resolveModule } from "./registry";
 
@@ -176,6 +176,15 @@ export async function runCommand(
 		? trimmed.replace(rawFirstWord, aliasVal)
 		: trimmed;
 
+	// Detect sh-syntax constructs that must be handled by the sh interpreter
+	const isShScript =
+		/\bfor\s+\w+\s+in\b/.test(aliasExpanded) ||
+		/\bwhile\s+/.test(aliasExpanded) ||
+		/\bif\s+/.test(aliasExpanded) ||
+		/\w+\s*\(\s*\)\s*\{/.test(aliasExpanded) ||
+		/\bfunction\s+\w+/.test(aliasExpanded) ||
+		/\(\(\s*.+\s*\)\)/.test(aliasExpanded);
+
 	const hasOperators =
 		/(?<![|&])[|](?![|])/.test(aliasExpanded) ||
 		aliasExpanded.includes(">") ||
@@ -184,7 +193,24 @@ export async function runCommand(
 		aliasExpanded.includes("||") ||
 		aliasExpanded.includes(";");
 
-	if (hasOperators) {
+	if ((isShScript && rawFirstWord !== "sh" && rawFirstWord !== "bash") || hasOperators) {
+		// sh-syntax: route through sh interpreter to handle for/while/functions
+		if (isShScript && rawFirstWord !== "sh" && rawFirstWord !== "bash") {
+			const shMod = resolveModule("sh");
+			if (shMod) {
+				return await shMod.run({
+					authUser, hostname,
+					activeSessions: shell.users.listActiveSessions(),
+					rawInput: aliasExpanded,
+					mode,
+					args: ["-c", aliasExpanded],
+					stdin: undefined,
+					cwd,
+					shell,
+					env: shellEnv,
+				});
+			}
+		}
 		const script = parseScript(aliasExpanded);
 		if (!script.isValid)
 			return { stderr: script.error || "Syntax error", exitCode: 1 };
@@ -225,7 +251,8 @@ export async function runCommand(
 
 	const parts = tokenizeCommand(expanded.trim());
 	const commandName = parts[0]?.toLowerCase() ?? "";
-	const args = parts.slice(1);
+	// Apply brace expansion to each arg token
+	const args = parts.slice(1).flatMap(expandBraces);
 	const mod = resolveModule(commandName);
 
 	if (!mod) {

package/src/commands/seq.ts

@@ -0,0 +1,43 @@
+import type { ShellModule } from "../types/commands";
+
+/** Generate sequences of numbers. seq LAST / seq FIRST LAST / seq FIRST INCREMENT LAST */
+export const seqCommand: ShellModule = {
+	name: "seq",
+	description: "Print a sequence of numbers",
+	category: "text",
+	params: ["[FIRST [INCREMENT]] LAST"],
+	run: ({ args }) => {
+		const nums = args.filter((a) => !a.startsWith("-") || /^-[\d.]/.test(a)).map(Number);
+		const sep = (() => { const i = args.indexOf("-s"); return i !== -1 ? (args[i + 1] ?? "\n") : "\n"; })();
+		const fmt = (() => { const i = args.indexOf("-f"); return i !== -1 ? (args[i + 1] ?? "%g") : null; })();
+		const width = args.includes("-w");
+
+		let first = 1, inc = 1, last: number;
+		if (nums.length === 1)      { last = nums[0]!; }
+		else if (nums.length === 2) { first = nums[0]!; last = nums[1]!; }
+		else                        { first = nums[0]!; inc = nums[1]!; last = nums[2]!; }
+
+		if (inc === 0) return { stderr: "seq: zero increment\n", exitCode: 1 };
+		if ((inc > 0 && first > last) || (inc < 0 && first < last)) return { stdout: "", exitCode: 0 };
+
+		const results: string[] = [];
+		const maxSteps = 100000;
+		let steps = 0;
+		for (let n = first; inc > 0 ? n <= last : n >= last; n = Math.round((n + inc) * 1e10) / 1e10) {
+			if (++steps > maxSteps) break;
+			let s: string;
+			if (fmt) {
+				s = fmt.replace("%g", String(n)).replace("%f", n.toFixed(6)).replace("%d", String(Math.trunc(n)));
+			} else {
+				s = Number.isInteger(n) ? String(n) : n.toPrecision(12).replace(/\.?0+$/, "");
+			}
+			if (width) {
+				const maxLen = String(Math.trunc(last)).length;
+				s = s.padStart(maxLen, "0");
+			}
+			results.push(s);
+		}
+
+		return { stdout: `${results.join(sep)}\n`, exitCode: 0 };
+	},
+};