typescript-virtual-container 1.2.5 → 1.2.6

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,10 +648,7 @@ export class VirtualUserManager extends EventEmitter {
 			throw new Error("invalid password");
 		}
 	}
-	private readonly authorizedKeys = new Map<
-		string,
-		Array<{ algo: string; data: Buffer }>
-	>();
+	private readonly authorizedKeys = new Map<string, Array<{ algo: string; data: Buffer }>>();
 
 	/**
 	 * Adds an SSH public key for a user, enabling public-key authentication.
@@ -684,9 +681,7 @@ export class VirtualUserManager extends EventEmitter {
 	 *
 	 * @param username Target user.
 	 */
-	public getAuthorizedKeys(
-		username: string,
-	): Array<{ algo: string; data: Buffer }> {
+	public getAuthorizedKeys(username: string): Array<{ algo: string; data: Buffer }> {
 		return this.authorizedKeys.get(username) ?? [];
 	}
 }

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

@@ -3,6 +3,8 @@ 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;

package/src/commands/clear.ts

@@ -2,6 +2,9 @@ import type { ShellModule } from "../types/commands";
 
 export const clearCommand: ShellModule = {
 	name: "clear",
+	description: "Clear the terminal screen",
+	category: "shell",
 	params: [],
-	run: () => ({ clearScreen: true, exitCode: 0 }),
+	// clearScreen flag triggers \x1b[2J\x1b[H in the shell layer
+	run: () => ({ clearScreen: true, stdout: "", exitCode: 0 }),
 };

package/src/commands/cp.ts

@@ -4,6 +4,8 @@ import { assertPathAccess, resolvePath } from "./helpers";
 
 export const cpCommand: ShellModule = {
 	name: "cp",
+	description: "Copy files or directories",
+	category: "files",
 	params: ["[-r] <source> <dest>"],
 	run: ({ authUser, shell, cwd, args }) => {
 		const recursive = ifFlag(args, ["-r", "-R", "--recursive"]);

package/src/commands/curl.ts

@@ -9,6 +9,8 @@ import {
 
 export const curlCommand: ShellModule = {
 	name: "curl",
+	description: "HTTP client",
+	category: "network",
 	params: ["[-o file] <url>"],
 	run: async ({ authUser, cwd, args, shell }) => {
 		const { flagsWithValues, positionals } = parseArgs(args, {

package/src/commands/cut.ts

@@ -0,0 +1,29 @@
+import type { ShellModule } from "../types/commands";
+import { getFlag } from "./command-helpers";
+
+export const cutCommand: ShellModule = {
+	name: "cut",
+	description: "Remove sections from lines",
+	category: "text",
+	params: ["-d <delim> -f <fields> [file]"],
+	run: ({ args, stdin }) => {
+		const delim = (getFlag(args, ["-d"]) as string | undefined) ?? "\t";
+		const fields = (getFlag(args, ["-f"]) as string | undefined) ?? "1";
+		const cols = fields.split(",").map((f) => {
+			const [a, b] = f.split("-").map(Number);
+			return b !== undefined ? { from: (a ?? 1) - 1, to: b - 1 } : { from: (a ?? 1) - 1, to: (a ?? 1) - 1 };
+		});
+		const lines = (stdin ?? "").split("\n");
+		const out = lines.map((line) => {
+			const parts = line.split(delim);
+			const selected: string[] = [];
+			for (const col of cols) {
+				for (let i = col.from; i <= Math.min(col.to, parts.length - 1); i++) {
+					selected.push(parts[i] ?? "");
+				}
+			}
+			return selected.join(delim);
+		});
+		return { stdout: out.join("\n"), exitCode: 0 };
+	},
+};

package/src/commands/date.ts

@@ -0,0 +1,24 @@
+import type { ShellModule } from "../types/commands";
+
+export const dateCommand: ShellModule = {
+	name: "date",
+	description: "Print current date and time",
+	category: "system",
+	params: ["[+format]"],
+	run: ({ args }) => {
+		const now = new Date();
+		const fmt = args[0];
+		if (fmt?.startsWith("+")) {
+			const f = fmt.slice(1)
+				.replace("%Y", String(now.getFullYear()))
+				.replace("%m", String(now.getMonth() + 1).padStart(2, "0"))
+				.replace("%d", String(now.getDate()).padStart(2, "0"))
+				.replace("%H", String(now.getHours()).padStart(2, "0"))
+				.replace("%M", String(now.getMinutes()).padStart(2, "0"))
+				.replace("%S", String(now.getSeconds()).padStart(2, "0"))
+				.replace("%s", String(Math.floor(now.getTime() / 1000)));
+			return { stdout: f, exitCode: 0 };
+		}
+		return { stdout: now.toString(), exitCode: 0 };
+	},
+};

package/src/commands/deluser.ts

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

package/src/commands/df.ts

@@ -0,0 +1,18 @@
+import type { ShellModule } from "../types/commands";
+
+export const dfCommand: ShellModule = {
+	name: "df",
+	description: "Report filesystem disk space usage",
+	category: "system",
+	params: ["[-h]"],
+	run: ({ shell }) => {
+		const bytes = shell.vfs.getUsageBytes();
+		const used = (bytes / 1024).toFixed(0);
+		const total = "1048576"; // 1GB virtual
+		const avail = String(Number(total) - Number(used));
+		const pct = Math.round((Number(used) / Number(total)) * 100);
+		const hdr = "Filesystem     1K-blocks    Used Available Use% Mounted on";
+		const row = `virtual-fs     ${total.padStart(9)} ${used.padStart(7)} ${avail.padStart(9)} ${pct}% /`;
+		return { stdout: `${hdr}\n${row}`, exitCode: 0 };
+	},
+};