typescript-virtual-container 1.2.4 → 1.2.6

package/src/VirtualShell/index.ts

@@ -4,7 +4,7 @@ import type { CommandContext, CommandResult } from "../types/commands";
 import type { ShellStream } from "../types/streams";
 import type { PerfLogger } from "../utils/perfLogger";
 import { createPerfLogger } from "../utils/perfLogger";
-import VirtualFileSystem from "../VirtualFileSystem";
+import VirtualFileSystem, { type VfsOptions } from "../VirtualFileSystem";
 import { VirtualUserManager } from "../VirtualUserManager";
 import { startShell } from "./shell";
 
@@ -38,7 +38,6 @@ function resolveAutoSudoForNewUsers(): boolean {
  * client API.
  */
 class VirtualShell extends EventEmitter {
-	basePath: string = ".";
 	vfs: VirtualFileSystem;
 	users: VirtualUserManager;
 	hostname: string;
@@ -50,19 +49,18 @@ class VirtualShell extends EventEmitter {
 	 *
 	 * @param hostname Virtual hostname used for prompts and idents.
 	 * @param properties Customizable properties shown in `uname -a` and similar commands.
-	 * @param basePath Optional base path for the virtual filesystem (defaults to process.cwd()).
+	 * @param vfsOptions Optional VFS persistence options (mode, snapshotPath).
 	 */
 	constructor(
 		hostname: string,
 		properties?: ShellProperties,
-		basePath?: string,
+		vfsOptions?: VfsOptions,
 	) {
 		super();
 		perf.mark("constructor");
 		this.hostname = hostname;
 		this.properties = properties || defaultShellProperties;
-		this.basePath = basePath || ".";
-		this.vfs = new VirtualFileSystem(this.basePath);
+		this.vfs = new VirtualFileSystem(vfsOptions ?? {});
 		this.users = new VirtualUserManager(this.vfs, resolveAutoSudoForNewUsers());
 
 		// Store references to avoid TypeScript "used before assigned" errors

package/src/VirtualShell/shell.ts

@@ -2,7 +2,8 @@ import type { ChildProcessWithoutNullStreams } from "node:child_process";
 import { readFile, unlink, writeFile } from "node:fs/promises";
 import * as path from "node:path";
 import type { ShellProperties, VirtualShell } from ".";
-import { getCommandNames, runCommand } from "../commands";
+import { getCommandNames, makeDefaultEnv, runCommand } from "../commands";
+import type { ShellEnv } from "../types/commands";
 import {
 	spawnHtopProcess,
 	spawnNanoEditorProcess,
@@ -50,6 +51,7 @@ export function startShell(
 	let historyIndex: number | null = null;
 	let historyDraft = "";
 	let cwd = `/home/${authUser}`;
+	const shellEnv: ShellEnv = makeDefaultEnv(authUser, hostname);
 	let nanoSession: NanoSession | null = null;
 	let pendingSudo: PendingSudo | null = null;
 	const buildCurrentPrompt = (): string => {
@@ -62,6 +64,21 @@ export function startShell(
 		`[${sessionId}] Shell started for user '${authUser}' at ${remoteAddress}`,
 	);
 
+	// Load .bashrc if it exists
+	void (async () => {
+		const bashrcPath = `/home/${authUser}/.bashrc`;
+		if (shell.vfs.exists(bashrcPath)) {
+			try {
+				const bashrc = shell.vfs.readFile(bashrcPath);
+				for (const line of bashrc.split("\n")) {
+					const l = line.trim();
+					if (!l || l.startsWith("#")) continue;
+					await runCommand(l, authUser, hostname, "shell", cwd, shell, undefined, shellEnv);
+				}
+			} catch { /* ignore bashrc errors */ }
+		}
+	})();
+
 	function renderLine(): void {
 		const prompt = buildCurrentPrompt();
 		stream.write(`\r${prompt}${lineBuffer}\u001b[K`);
@@ -568,7 +585,7 @@ export function startShell(
 
 				if (line.length > 0) {
 					const result = await Promise.resolve(
-						runCommand(line, authUser, hostname, "shell", cwd, shell),
+						runCommand(line, authUser, hostname, "shell", cwd, shell, undefined, shellEnv),
 					);
 
 					pushHistory(line);

package/src/VirtualShell/shellParser.ts

@@ -1,228 +1,262 @@
-import type { Pipeline, PipelineCommand } from "../types/pipeline";
+import type { Pipeline, PipelineCommand, Script, Statement, LogicalOp } from "../types/pipeline";
 
-/** Parse a shell command line into a structured pipeline */
-export function parseShellPipeline(rawInput: string): Pipeline {
+// ── Public API ───────────────────────────────────────────────────────────────
+
+/**
+ * Parse a shell input line into a Script (sequence of statements connected
+ * by && / || / ;).  Each statement contains one Pipeline (commands connected
+ * by |).
+ */
+export function parseScript(rawInput: string): Script {
 	const trimmed = rawInput.trim();
+	if (!trimmed) return { statements: [], isValid: true };
 
-	if (!trimmed) {
-		return { commands: [], isValid: true };
+	try {
+		const statements = parseStatements(trimmed);
+		return { statements, isValid: true };
+	} catch (e) {
+		return { statements: [], isValid: false, error: (e as Error).message };
 	}
+}
 
-	const commands: PipelineCommand[] = [];
-	const tokenized = tokenizePipeline(trimmed);
-	if (tokenized.error) {
-		return {
-			commands: [],
-			isValid: false,
-			error: tokenized.error,
-		};
+/** Legacy compat: parse a single pipeline (no &&/||/;) */
+export function parseShellPipeline(rawInput: string): Pipeline {
+	const trimmed = rawInput.trim();
+	if (!trimmed) return { commands: [], isValid: true };
+	try {
+		const commands = parsePipeline(trimmed);
+		return { commands, isValid: true };
+	} catch (e) {
+		return { commands: [], isValid: false, error: (e as Error).message };
 	}
+}
 
-	const pipeTokens = tokenized.tokens;
+// ── Variable & tilde expansion ────────────────────────────────────────────────
 
-	for (const token of pipeTokens) {
-		const cmd = parseCommandWithRedirections(token);
-		if (!cmd.isValid) {
-			return {
-				commands: [],
-				isValid: false,
-				error: cmd.error,
-			};
-		}
-		if (cmd.command) {
-			commands.push(cmd.command);
-		}
+/**
+ * Expand ~ and $VAR / ${VAR} / ${VAR:-default} / $(cmd placeholder) in a
+ * token, given the current env vars and home path.
+ * Command substitution $(…) is NOT executed here — it's left as a marker so
+ * the executor can handle it.
+ */
+export function expandToken(
+	token: string,
+	env: Record<string, string>,
+	authUser: string,
+	lastExitCode = 0,
+): string {
+	// tilde expansion
+	token = token.replace(/^~(\/|$)/, `/home/${authUser}$1`);
+
+	// $? special var
+	token = token.replace(/\$\?/g, String(lastExitCode));
+	// $$ PID (mock)
+	token = token.replace(/\$\$/g, "1");
+	// $# argc (0 for interactive)
+	token = token.replace(/\$#/g, "0");
+
+	// ${VAR:-default} and ${VAR:+value}
+	token = token.replace(/\$\{([^}:]+):-([^}]*)\}/g, (_, name, def) =>
+		env[name] ?? def,
+	);
+	token = token.replace(/\$\{([^}:]+):\+([^}]*)\}/g, (_, name, val) =>
+		env[name] ? val : "",
+	);
+
+	// ${VAR}
+	token = token.replace(/\$\{([^}]+)\}/g, (_, name) => env[name] ?? "");
+
+	// $VAR (greedy: match longest valid identifier)
+	token = token.replace(/\$([A-Za-z_][A-Za-z0-9_]*)/g, (_, name) =>
+		env[name] ?? "",
+	);
+
+	return token;
+}
+
+/**
+ * Expand glob patterns (*, ?, [abc]) against a list of entries.
+ * Returns the original pattern if no match.
+ */
+export function expandGlob(pattern: string, entries: string[]): string[] {
+	if (!/[*?[]/.test(pattern)) return [pattern];
+	const regex = globToRegex(pattern);
+	const matches = entries.filter((e) => regex.test(e));
+	return matches.length > 0 ? matches.sort() : [pattern];
+}
+
+function globToRegex(pattern: string): RegExp {
+	let re = "^";
+	for (let i = 0; i < pattern.length; i++) {
+		const c = pattern[i]!;
+		if (c === "*") re += ".*";
+		else if (c === "?") re += ".";
+		else if (c === "[") {
+			const close = pattern.indexOf("]", i + 1);
+			if (close === -1) re += "\\[";
+			else {
+				re += `[${pattern.slice(i + 1, close)}]`;
+				i = close;
+			}
+		} else re += c.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+	}
+	return new RegExp(`${re}$`);
+}
+
+// ── Internal parser ───────────────────────────────────────────────────────────
+
+function parseStatements(input: string): Statement[] {
+	// Split by ;, &&, || — respecting quotes and parens
+	const segments = splitByLogicalOps(input);
+	const statements: Statement[] = [];
+
+	for (const seg of segments) {
+		const commands = parsePipeline(seg.text.trim());
+		const stmt: Statement = { pipeline: { commands, isValid: true } };
+		if (seg.op) stmt.op = seg.op;
+		statements.push(stmt);
 	}
 
-	return { commands, isValid: true };
+	return statements;
 }
 
-/** Tokenize input by pipes, respecting quoted strings */
-function tokenizePipeline(input: string): { tokens: string[]; error?: string } {
-	const tokens: string[] = [];
+interface Segment { text: string; op?: LogicalOp }
+
+function splitByLogicalOps(input: string): Segment[] {
+	const segments: Segment[] = [];
 	let current = "";
-	let inQuotes = false;
-	let quoteChar = "";
+	let depth = 0; // parens/subshell depth
+	let inQ = false;
+	let qChar = "";
 	let i = 0;
 
+	const flush = (op?: LogicalOp) => {
+		if (current.trim()) segments.push({ text: current, op });
+		current = "";
+	};
+
 	while (i < input.length) {
-		const ch = input[i];
-
-		if ((ch === '"' || ch === "'") && (i === 0 || input[i - 1] !== "\\")) {
-			if (!inQuotes) {
-				inQuotes = true;
-				quoteChar = ch;
-			} else if (ch === quoteChar) {
-				inQuotes = false;
-			}
-			current += ch;
-			i++;
-		} else if (ch === "|" && !inQuotes) {
-			if (!current.trim()) {
-				return {
-					tokens: [],
-					error: "Syntax error near unexpected token '|'",
-				};
-			}
-			tokens.push(current.trim());
-			current = "";
-			i++;
-		} else {
-			current += ch;
-			i++;
-		}
-	}
+		const ch = input[i]!;
+		const ch2 = input.slice(i, i + 2);
 
-	if (inQuotes) {
-		return {
-			tokens: [],
-			error: "Syntax error: unterminated quote",
-		};
-	}
+		if ((ch === '"' || ch === "'") && !inQ) { inQ = true; qChar = ch; current += ch; i++; continue; }
+		if (inQ && ch === qChar) { inQ = false; current += ch; i++; continue; }
+		if (inQ) { current += ch; i++; continue; }
 
-	if (!current.trim()) {
-		return {
-			tokens: [],
-			error: "Syntax error near unexpected token '|'",
-		};
-	}
+		if (ch === "(") { depth++; current += ch; i++; continue; }
+		if (ch === ")") { depth--; current += ch; i++; continue; }
+		if (depth > 0) { current += ch; i++; continue; }
 
-	tokens.push(current.trim());
+		if (ch2 === "&&") { flush("&&"); i += 2; continue; }
+		if (ch2 === "||") { flush("||"); i += 2; continue; }
+		if (ch === ";") { flush(";"); i++; continue; }
 
-	return { tokens };
+		current += ch; i++;
+	}
+	flush();
+	return segments;
 }
 
-interface ParseResult {
-	command?: PipelineCommand;
-	isValid: boolean;
-	error?: string;
+function parsePipeline(input: string): PipelineCommand[] {
+	const pipeTokens = splitByPipe(input);
+	return pipeTokens.map(parseCommandWithRedirections);
 }
 
-/** Parse a single command with its redirections (>, >>, <) */
-function parseCommandWithRedirections(token: string): ParseResult {
-	const parts = tokenizeCommand(token);
+function splitByPipe(input: string): string[] {
+	const tokens: string[] = [];
+	let current = "";
+	let inQ = false;
+	let qChar = "";
 
-	if (parts.length === 0) {
-		return { isValid: true };
+	for (let i = 0; i < input.length; i++) {
+		const ch = input[i]!;
+		if ((ch === '"' || ch === "'") && !inQ) { inQ = true; qChar = ch; current += ch; continue; }
+		if (inQ && ch === qChar) { inQ = false; current += ch; continue; }
+		if (inQ) { current += ch; continue; }
+
+		// || was already consumed at statement level, bare | is pipe
+		if (ch === "|" && input[i + 1] !== "|") {
+			if (!current.trim()) throw new Error("Syntax error near unexpected token '|'");
+			tokens.push(current.trim());
+			current = "";
+		} else {
+			current += ch;
+		}
 	}
 
+	const tail = current.trim();
+	if (!tail && tokens.length > 0) throw new Error("Syntax error near unexpected token '|'");
+	if (tail) tokens.push(tail);
+	return tokens;
+}
+
+function parseCommandWithRedirections(token: string): PipelineCommand {
+	const parts = tokenizeCommand(token);
+	if (parts.length === 0) return { name: "", args: [] };
+
 	const cmdParts: string[] = [];
 	let inputFile: string | undefined;
 	let outputFile: string | undefined;
 	let appendOutput = false;
-
 	let i = 0;
-	while (i < parts.length) {
-		const part = parts[i] as string;
 
+	while (i < parts.length) {
+		const part = parts[i]!;
 		if (part === "<") {
 			i++;
-			if (i >= parts.length) {
-				return {
-					isValid: false,
-					error: "Syntax error: expected filename after <",
-				};
-			}
+			if (i >= parts.length) throw new Error("Syntax error: expected filename after <");
 			inputFile = parts[i];
 			i++;
 		} else if (part === ">>") {
 			i++;
-			if (i >= parts.length) {
-				return {
-					isValid: false,
-					error: "Syntax error: expected filename after >>",
-				};
-			}
-			outputFile = parts[i];
-			appendOutput = true;
-			i++;
+			if (i >= parts.length) throw new Error("Syntax error: expected filename after >>");
+			outputFile = parts[i]; appendOutput = true; i++;
 		} else if (part === ">") {
 			i++;
-			if (i >= parts.length) {
-				return {
-					isValid: false,
-					error: "Syntax error: expected filename after >",
-				};
-			}
-			outputFile = parts[i];
-			appendOutput = false;
-			i++;
+			if (i >= parts.length) throw new Error("Syntax error: expected filename after >");
+			outputFile = parts[i]; appendOutput = false; i++;
 		} else {
-			cmdParts.push(part);
-			i++;
+			cmdParts.push(part); i++;
 		}
 	}
 
-	if (cmdParts.length === 0) {
-		return { isValid: true };
-	}
-
-	const name = (cmdParts[0] as string).toLowerCase();
-	const args = cmdParts.slice(1);
-
-	return {
-		command: {
-			name,
-			args,
-			inputFile,
-			outputFile,
-			appendOutput,
-		},
-		isValid: true,
-	};
+	const name = (cmdParts[0] ?? "").toLowerCase();
+	return { name, args: cmdParts.slice(1), inputFile, outputFile, appendOutput };
 }
 
-/** Tokenize a command, respecting quotes and handling >> vs > */
 function tokenizeCommand(input: string): string[] {
 	const tokens: string[] = [];
 	let current = "";
-	let inQuotes = false;
-	let quoteChar = "";
+	let inQ = false;
+	let qChar = "";
 	let i = 0;
 
 	while (i < input.length) {
-		const ch = input[i];
+		const ch = input[i]!;
 		const next = input[i + 1];
 
-		// Handle quotes
-		if ((ch === '"' || ch === "'") && (i === 0 || input[i - 1] !== "\\")) {
-			if (!inQuotes) {
-				inQuotes = true;
-				quoteChar = ch;
-			} else if (ch === quoteChar) {
-				inQuotes = false;
-				quoteChar = "";
-			} else {
-				current += ch;
-			}
-			i++;
-		} else if (ch === " " && !inQuotes) {
-			if (current) {
-				tokens.push(current);
-				current = "";
-			}
-			i++;
-		} else if ((ch === ">" || ch === "<") && !inQuotes) {
-			if (current) {
-				tokens.push(current);
-				current = "";
-			}
-			if (ch === ">" && next === ">") {
-				tokens.push(">>");
-				i += 2;
-			} else {
-				tokens.push(ch);
-				i++;
-			}
-		} else {
-			current += ch;
-			i++;
+		if ((ch === '"' || ch === "'") && !inQ) {
+			inQ = true; qChar = ch; i++; continue;
 		}
-	}
+		if (inQ && ch === qChar) {
+			inQ = false; qChar = ""; i++; continue;
+		}
+		if (inQ) { current += ch; i++; continue; }
 
-	if (current) {
-		tokens.push(current);
-	}
+		if (ch === " ") {
+			if (current) { tokens.push(current); current = ""; }
+			i++; continue;
+		}
 
+		if ((ch === ">" || ch === "<") && !inQ) {
+			if (current) { tokens.push(current); current = ""; }
+			if (ch === ">" && next === ">") { tokens.push(">>"); i += 2; }
+			else { tokens.push(ch); i++; }
+			continue;
+		}
+
+		current += ch; i++;
+	}
+	if (current) tokens.push(current);
 	return tokens;
 }

package/src/VirtualUserManager/index.ts

@@ -648,6 +648,42 @@ export class VirtualUserManager extends EventEmitter {
 			throw new Error("invalid password");
 		}
 	}
+	private readonly authorizedKeys = new Map<string, Array<{ algo: string; data: Buffer }>>();
+
+	/**
+	 * Adds an SSH public key for a user, enabling public-key authentication.
+	 *
+	 * @param username Target user.
+	 * @param algo Key algorithm (e.g. "ssh-rsa", "ssh-ed25519").
+	 * @param data Raw key data as a Buffer (the base64-decoded key bytes).
+	 */
+	public addAuthorizedKey(username: string, algo: string, data: Buffer): void {
+		perf.mark("addAuthorizedKey");
+		const keys = this.authorizedKeys.get(username) ?? [];
+		keys.push({ algo, data });
+		this.authorizedKeys.set(username, keys);
+		this.emit("key:add", { username, algo });
+	}
+
+	/**
+	 * Removes all authorized keys for a user.
+	 *
+	 * @param username Target user.
+	 */
+	public removeAuthorizedKeys(username: string): void {
+		this.authorizedKeys.delete(username);
+		this.emit("key:remove", { username });
+	}
+
+	/**
+	 * Returns the list of authorized keys for a user.
+	 * Returns an empty array when no keys are registered.
+	 *
+	 * @param username Target user.
+	 */
+	public getAuthorizedKeys(username: string): Array<{ algo: string; data: Buffer }> {
+		return this.authorizedKeys.get(username) ?? [];
+	}
 }
 
 function normalizeVfsPath(targetPath: string): string {

package/src/commands/adduser.ts

@@ -2,6 +2,8 @@ import type { ShellModule } from "../types/commands";
 
 export const adduserCommand: ShellModule = {
 	name: "adduser",
+	description: "Add a new user",
+	category: "users",
 	params: ["<username> <password>"],
 	run: async ({ authUser, shell, args }) => {
 		if (authUser !== "root") {

package/src/commands/awk.ts

@@ -0,0 +1,30 @@
+import type { ShellModule } from "../types/commands";
+import { getFlag } from "./command-helpers";
+
+export const awkCommand: ShellModule = {
+	name: "awk",
+	description: "Pattern scanning and processing language (minimal)",
+	category: "text",
+	params: ["[-F <sep>] '<program>' [file]"],
+	run: ({ args, stdin }) => {
+		const sep = (getFlag(args, ["-F"]) as string | undefined) ?? " ";
+		const prog = args.find((a) => !a.startsWith("-") && a !== sep);
+		if (!prog) return { stderr: "awk: no program", exitCode: 1 };
+
+		// Only support print $N and {print $N} patterns
+		const printMatch = prog.match(/^\{?\s*print\s+([^}]+)\s*\}?$/);
+		if (!printMatch) return { stderr: `awk: unsupported program: ${prog}`, exitCode: 1 };
+
+		const fields = printMatch[1]!.split(/\s*,\s*/).map((f) => f.trim());
+		const lines = (stdin ?? "").split("\n").filter(Boolean);
+		const out = lines.map((line) => {
+			const parts = line.split(sep === " " ? /\s+/ : sep);
+			return fields.map((f) => {
+				if (f === "$0") return line;
+				const n = parseInt(f.replace("$", ""), 10);
+				return Number.isNaN(n) ? f.replace(/"/g, "") : (parts[n - 1] ?? "");
+			}).join(sep === " " ? "\t" : sep);
+		});
+		return { stdout: out.join("\n"), exitCode: 0 };
+	},
+};

package/src/commands/base64.ts

@@ -0,0 +1,18 @@
+import type { ShellModule } from "../types/commands";
+import { ifFlag } from "./command-helpers";
+
+export const base64Command: ShellModule = {
+	name: "base64",
+	description: "Encode/decode base64",
+	category: "text",
+	params: ["[-d] [file]"],
+	run: ({ args, stdin }) => {
+		const decode = ifFlag(args, ["-d", "--decode"]);
+		const input = stdin ?? "";
+		if (decode) {
+			try { return { stdout: Buffer.from(input.trim(), "base64").toString("utf8"), exitCode: 0 }; }
+			catch { return { stderr: "base64: invalid input", exitCode: 1 }; }
+		}
+		return { stdout: Buffer.from(input).toString("base64"), exitCode: 0 };
+	},
+};

package/src/commands/cat.ts

@@ -4,6 +4,8 @@ import { assertPathAccess, resolveReadablePath } from "./helpers";
 
 export const catCommand: ShellModule = {
 	name: "cat",
+	description: "Concatenate and print files",
+	category: "files",
 	params: ["<file>"],
 	run: ({ authUser, shell, cwd, args }) => {
 		const fileArg = getArg(args, 0);

package/src/commands/cd.ts

@@ -3,6 +3,8 @@ import { assertPathAccess, resolvePath } from "./helpers";
 
 export const cdCommand: ShellModule = {
 	name: "cd",
+	description: "Change directory",
+	category: "navigation",
 	params: ["[path]"],
 	run: ({ authUser, shell, cwd, args, mode }) => {
 		const target = resolvePath(cwd, args[0] ?? "/virtual-env-js");

package/src/commands/chmod.ts

@@ -0,0 +1,35 @@
+import type { ShellModule } from "../types/commands";
+import { assertPathAccess, resolvePath } from "./helpers";
+
+export const chmodCommand: ShellModule = {
+	name: "chmod",
+	description: "Change file permissions",
+	category: "files",
+	params: ["<mode> <file>"],
+	run: ({ authUser, shell, cwd, args }) => {
+		const [modeArg, fileArg] = args;
+		if (!modeArg || !fileArg) {
+			return { stderr: "chmod: missing operand", exitCode: 1 };
+		}
+
+		const filePath = resolvePath(cwd, fileArg);
+		try {
+			assertPathAccess(authUser, filePath, "chmod");
+			if (!shell.vfs.exists(filePath)) {
+				return {
+					stderr: `chmod: ${fileArg}: No such file or directory`,
+					exitCode: 1,
+				};
+			}
+			const mode = parseInt(modeArg, 8);
+			if (Number.isNaN(mode)) {
+				return { stderr: `chmod: invalid mode: ${modeArg}`, exitCode: 1 };
+			}
+			shell.vfs.chmod(filePath, mode);
+			return { exitCode: 0 };
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			return { stderr: `chmod: ${msg}`, exitCode: 1 };
+		}
+	},
+};