typescript-virtual-container 1.4.2 → 1.4.3

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

package/src/commands/sh.ts

@@ -45,6 +45,8 @@ type Block =
 	  }
 	| { type: "for"; var: string; list: string; body: string[] }
 	| { type: "while"; cond: string; body: string[] }
+	| { type: "func"; name: string; body: string[] }
+	| { type: "arith"; expr: string }
 	| { type: "cmd"; line: string };
 
 /** Very small shell interpreter: supports if/elif/else/fi, for/do/done, while/do/done */
@@ -58,6 +60,41 @@ function parseBlocks(lines: string[]): Block[] {
 			continue;
 		}
 
+		// Function definition: name() { or function name { or name() { body }
+		const funcMatchInline = line.match(/^(?:function\s+)?(\w+)\s*\(\s*\)\s*\{(.+)\}\s*$/);
+		const funcMatch = funcMatchInline ?? (
+			line.match(/^(?:function\s+)?(\w+)\s*\(\s*\)\s*\{?\s*$/) ||
+			line.match(/^function\s+(\w+)\s*\{?\s*$/)
+		);
+		if (funcMatch) {
+			const funcName = funcMatch[1]!;
+			const body: string[] = [];
+			// Inline: name() { cmd; } — single-line form
+			if (funcMatchInline) {
+				body.push(...funcMatchInline[2]!.split(";").map((s: string) => s.trim()).filter(Boolean));
+				blocks.push({ type: "func", name: funcName, body });
+				i++;
+				continue;
+			}
+			i++;
+			while (i < lines.length && lines[i]?.trim() !== "}" && i < lines.length + 1) {
+				const l = lines[i]!.trim().replace(/^do\s+/, "");
+				if (l && l !== "{") body.push(l);
+				i++;
+			}
+			i++; // skip closing }
+			blocks.push({ type: "func", name: funcName, body });
+			continue;
+		}
+
+		// (( expr )) arithmetic statement
+		const arithMatch = line.match(/^\(\(\s*(.+?)\s*\)\)$/);
+		if (arithMatch) {
+			blocks.push({ type: "arith", expr: arithMatch[1]! });
+			i++;
+			continue;
+		}
+
 		if (line.startsWith("if ") || line === "if") {
 			const cond = line
 				.replace(/^if\s+/, "")
@@ -225,16 +262,34 @@ async function runBlocks(
 				}
 			}
 
-			const r = await runCommand(
-				expanded,
-				ctx.authUser,
-				ctx.hostname,
-				ctx.mode,
-				ctx.cwd,
-				ctx.shell,
-				undefined,
-				ctx.env,
-			);
+			const r = await (async () => {
+				// Check if expanded matches a registered function
+				const cmdName = expanded.trim().split(/\s+/)[0] ?? "";
+				const funcBody = ctx.env.vars[`__func_${cmdName}`];
+				if (funcBody) {
+					// Set positional params $1 $2 ... from remaining args
+					const funcArgs = expanded.trim().split(/\s+/).slice(1);
+					const savedVars = { ...ctx.env.vars };
+					funcArgs.forEach((a, i) => { ctx.env.vars[String(i + 1)] = a; });
+					ctx.env.vars["0"] = cmdName;
+					const funcLines = funcBody.split("\n");
+					const funcResult = await runBlocks(parseBlocks(funcLines), ctx);
+					// Restore positional params
+					for (let pi = 1; pi <= funcArgs.length; pi++) delete ctx.env.vars[String(pi)];
+					Object.assign(ctx.env.vars, { ...savedVars, ...ctx.env.vars });
+					return funcResult;
+				}
+				return runCommand(
+					expanded,
+					ctx.authUser,
+					ctx.hostname,
+					ctx.mode,
+					ctx.cwd,
+					ctx.shell,
+					undefined,
+					ctx.env,
+				);
+			})();
 			ctx.env.lastExitCode = r.exitCode ?? 0;
 			if (r.stdout) output += `${r.stdout}\n`;
 			if (r.stderr) return { ...r, stdout: output.trim() };
@@ -259,6 +314,27 @@ async function runBlocks(
 					if (sub.stdout) output += `${sub.stdout}\n`;
 				}
 			}
+		} else if (block.type === "func") {
+			// Register function in env vars as __func_<name>=<body>
+			ctx.env.vars[`__func_${block.name}`] = block.body.join("\n");
+		} else if (block.type === "arith") {
+			// (( expr )) — evaluate arithmetic, update vars
+			const { expandSync } = await import("../utils/expand");
+			const expr = expandSync(block.expr, ctx.env.vars, ctx.env.lastExitCode);
+			// Handle i++ / i-- / i+=N / i-=N
+			const incMatch = expr.match(/^(\w+)\s*(\+\+|--)$/);
+			if (incMatch) {
+				const val = parseInt(ctx.env.vars[incMatch[1]!] ?? "0", 10);
+				ctx.env.vars[incMatch[1]!] = String(incMatch[2] === "++" ? val + 1 : val - 1);
+			} else {
+				const assignMatch = expr.match(/^(\w+)\s*([+\-*/])=\s*(.+)$/);
+				if (assignMatch) {
+					const lhs = parseInt(ctx.env.vars[assignMatch[1]!] ?? "0", 10);
+					const rhs = parseInt(assignMatch[3]!, 10);
+					const ops: Record<string, number> = { "+": lhs + rhs, "-": lhs - rhs, "*": lhs * rhs, "/": Math.floor(lhs / rhs) };
+					ctx.env.vars[assignMatch[1]!] = String(ops[assignMatch[2]!] ?? lhs);
+				}
+			}
 		} else if (block.type === "for") {
 			const listExpanded = await expandVars(
 				block.list,
@@ -266,7 +342,9 @@ async function runBlocks(
 				ctx.env.lastExitCode,
 				ctx,
 			);
-			const items = listExpanded.trim().split(/\s+/);
+			// Apply brace expansion to each token in the list
+			const { expandBraces } = await import("../utils/expand");
+			const items = listExpanded.trim().split(/\s+/).flatMap(expandBraces);
 			for (const item of items) {
 				ctx.env.vars[block.var] = item;
 				const sub = await runBlocks(parseBlocks(block.body), ctx);
@@ -292,6 +370,59 @@ async function runBlocks(
  * @category shell
  * @params ["-c <script>", "[<file>]"]
  */
+
+/**
+ * Split a sh script into logical lines, respecting:
+ * - `{...}` braces (function bodies)
+ * - Newlines and semicolons at depth 0 only
+ */
+function splitShScript(script: string): string[] {
+	const lines: string[] = [];
+	let current = "";
+	let depth = 0;
+	let inSingleQ = false;
+	let inDoubleQ = false;
+	let i = 0;
+	while (i < script.length) {
+		const ch = script[i]!;
+		if (!inSingleQ && !inDoubleQ) {
+			if (ch === "'") { inSingleQ = true; current += ch; i++; continue; }
+			if (ch === '"') { inDoubleQ = true; current += ch; i++; continue; }
+			if (ch === "{") { depth++; current += ch; i++; continue; }
+			if (ch === "}") {
+				depth--;
+				current += ch;
+				i++;
+				// At depth 0, closing } ends the function body line
+				if (depth === 0) {
+					const t = current.trim();
+					if (t) lines.push(t);
+					current = "";
+					// Skip trailing ; or whitespace
+					while (i < script.length && (script[i] === ";" || script[i] === " ")) i++;
+				}
+				continue;
+			}
+			if (depth === 0 && (ch === ";" || ch === "\n")) {
+				const t = current.trim();
+				if (t && !t.startsWith("#")) lines.push(t);
+				current = "";
+				i++;
+				continue;
+			}
+		} else if (inSingleQ && ch === "'") {
+			inSingleQ = false;
+		} else if (inDoubleQ && ch === '"') {
+			inDoubleQ = false;
+		}
+		current += ch;
+		i++;
+	}
+	const t = current.trim();
+	if (t && !t.startsWith("#")) lines.push(t);
+	return lines;
+}
+
 export const shCommand: ShellModule = {
 	name: "sh",
 	aliases: ["bash"],
@@ -305,10 +436,7 @@ export const shCommand: ShellModule = {
 		if (ifFlag(args, "-c")) {
 			const script = args[args.indexOf("-c") + 1] ?? "";
 			if (!script) return { stderr: "sh: -c requires a script", exitCode: 1 };
-			const lines = script
-				.split(/[;\n]/)
-				.map((l) => l.trim())
-				.filter((l) => l && !l.startsWith("#"));
+			const lines = splitShScript(script);
 			const blocks = parseBlocks(lines);
 			return runBlocks(blocks, ctx);
 		}
@@ -323,10 +451,7 @@ export const shCommand: ShellModule = {
 					exitCode: 1,
 				};
 			const content = shell.vfs.readFile(p);
-			const lines = content
-				.split("\n")
-				.map((l) => l.trim())
-				.filter((l) => l && !l.startsWith("#"));
+			const lines = splitShScript(content);
 			const blocks = parseBlocks(lines);
 			return runBlocks(blocks, ctx);
 		}

package/src/types/pipeline.ts

@@ -10,6 +10,12 @@ export interface PipelineCommand {
 	outputFile?: string;
 	/** Append to output file (>> file) */
 	appendOutput?: boolean;
+	/** Stderr redirection file path (2> file) */
+	stderrFile?: string;
+	/** Append stderr to file (2>> file) */
+	stderrAppend?: boolean;
+	/** Redirect stderr to stdout (2>&1) */
+	stderrToStdout?: boolean;
 }
 
 /** Logical operator connecting two statement groups. */

package/src/types/vfs.ts

@@ -79,3 +79,20 @@ export type VfsSnapshotNode = VfsSnapshotFileNode | VfsSnapshotDirectoryNode;
 export interface VfsSnapshot {
 	root: VfsSnapshotDirectoryNode;
 }
+
+/** Options for mounting a host directory into the VFS. */
+export interface MountOptions {
+	/** Absolute path inside the VM (e.g. `"/app"`). */
+	vPath: string;
+	/** Path on the host filesystem. Relative paths resolved from `process.cwd()`. */
+	hostPath: string;
+	/** When `true` (default), write operations inside the mount throw `EROFS`. */
+	readOnly?: boolean;
+}
+
+/** Describes an active mount point. */
+export interface MountPoint {
+	vPath:    string;
+	hostPath: string;
+	readOnly: boolean;
+}

package/src/utils/expand.ts

@@ -95,6 +95,79 @@ function outsideSingleQuotes(
  * @param lastExit  Last command exit code (for `$?`).
  * @param home      Home directory path (for `~`).
  */
+
+/**
+ * Expand brace expressions in a single token.
+ * - `{a,b,c}` → `["a", "b", "c"]`
+ * - `{1..5}` → `["1", "2", "3", "4", "5"]`
+ * - `{a..e}` → `["a", "b", "c", "d", "e"]`
+ * - `prefix{a,b}suffix` → `["prefixasuffix", "prefixbsuffix"]`
+ * Returns a single-element array when no brace expansion applies.
+ */
+export function expandBraces(token: string): string[] {
+	// Find the first { not preceded by $
+	let depth = 0;
+	let start = -1;
+	for (let i = 0; i < token.length; i++) {
+		const ch = token[i]!;
+		if (ch === "{" && token[i - 1] !== "$") {
+			if (depth === 0) start = i;
+			depth++;
+		} else if (ch === "}") {
+			depth--;
+			if (depth === 0 && start !== -1) {
+				const prefix  = token.slice(0, start);
+				const inner   = token.slice(start + 1, i);
+				const suffix  = token.slice(i + 1);
+
+				// Range: {1..5} or {a..e}
+				const rangeMatch = inner.match(/^(-?\d+)\.\.(-?\d+)(?:\.\.-?(\d+))?$/) ||
+				                   inner.match(/^([a-z])\.\.([a-z])$/);
+				if (rangeMatch) {
+					const items: string[] = [];
+					if (/\d/.test(rangeMatch[1]!)) {
+						const from = parseInt(rangeMatch[1]!, 10);
+						const to   = parseInt(rangeMatch[2]!, 10);
+						const step = rangeMatch[3] ? parseInt(rangeMatch[3], 10) : 1;
+						const inc  = from <= to ? step : -step;
+						for (let n = from; from <= to ? n <= to : n >= to; n += inc) {
+							items.push(String(n));
+						}
+					} else {
+						const from = rangeMatch[1]!.charCodeAt(0);
+						const to   = rangeMatch[2]!.charCodeAt(0);
+						const inc  = from <= to ? 1 : -1;
+						for (let c = from; from <= to ? c <= to : c >= to; c += inc) {
+							items.push(String.fromCharCode(c));
+						}
+					}
+					const expanded = items.map((v) => `${prefix}${v}${suffix}`);
+					return expanded.flatMap(expandBraces);
+				}
+
+				// Comma list: {a,b,c} — split respecting nested braces
+				const parts: string[] = [];
+				let cur = "";
+				let d2 = 0;
+				for (const ch2 of inner) {
+					if (ch2 === "{") { d2++; cur += ch2; }
+					else if (ch2 === "}") { d2--; cur += ch2; }
+					else if (ch2 === "," && d2 === 0) { parts.push(cur); cur = ""; }
+					else { cur += ch2; }
+				}
+				parts.push(cur);
+
+				if (parts.length > 1) {
+					const expanded = parts.map((p) => `${prefix}${p}${suffix}`);
+					return expanded.flatMap(expandBraces);
+				}
+				break;
+			}
+		}
+	}
+	return [token];
+}
+
 export function expandSync(
 	input: string,
 	env: Record<string, string>,
@@ -155,8 +228,8 @@ export function expandSync(
 			(_, name) => env[name] ?? "",
 		);
 
-		// $VAR
-		s = s.replace(/\$([A-Za-z_][A-Za-z0-9_]*)/g, (_, name) => env[name] ?? "");
+		// $VAR and positional params $1 $2 ...
+		s = s.replace(/\$([A-Za-z_][A-Za-z0-9_]*|\d+)/g, (_, name) => env[name] ?? "");
 
 		return s;
 	});

package/src/utils/tokenize.ts

@@ -55,6 +55,26 @@ export function tokenizeCommand(input: string): string[] {
 			continue;
 		}
 
+		// Handle 2>&1, 2>>, 2>, >&, >>
+		if (!inQ && ch === "2" && (next === ">" )) {
+			const rest = input.slice(i + 1);
+			if (rest.startsWith(">>&1") || rest.startsWith(">> &1")) {
+				if (current) { tokens.push(current); current = ""; }
+				tokens.push("2>>&1"); i += 5; continue;
+			}
+			if (rest.startsWith(">&1")) {
+				if (current) { tokens.push(current); current = ""; }
+				tokens.push("2>&1"); i += 4; continue;
+			}
+			if (rest.startsWith(">>")) {
+				if (current) { tokens.push(current); current = ""; }
+				tokens.push("2>>"); i += 3; continue;
+			}
+			if (rest.startsWith(">")) {
+				if (current) { tokens.push(current); current = ""; }
+				tokens.push("2>"); i += 2; continue;
+			}
+		}
 		if ((ch === ">" || ch === "<") && !inQ) {
 			if (current) {
 				tokens.push(current);