typescript-virtual-container 1.2.4 → 1.2.6

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

@@ -0,0 +1,78 @@
+import type { ShellModule } from "../types/commands";
+import { ifFlag } from "./command-helpers";
+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"]);
+		const positionals = args.filter((a) => !a.startsWith("-"));
+		const [srcArg, destArg] = positionals;
+
+		if (!srcArg || !destArg) {
+			return { stderr: "cp: missing operand", exitCode: 1 };
+		}
+
+		const srcPath = resolvePath(cwd, srcArg);
+		const destPath = resolvePath(cwd, destArg);
+
+		try {
+			assertPathAccess(authUser, srcPath, "cp");
+			assertPathAccess(authUser, destPath, "cp");
+
+			if (!shell.vfs.exists(srcPath)) {
+				return {
+					stderr: `cp: ${srcArg}: No such file or directory`,
+					exitCode: 1,
+				};
+			}
+
+			const srcStat = shell.vfs.stat(srcPath);
+
+			if (srcStat.type === "directory") {
+				if (!recursive) {
+					return {
+						stderr: `cp: ${srcArg}: is a directory (use -r)`,
+						exitCode: 1,
+					};
+				}
+				const copyDir = (from: string, to: string) => {
+					shell.vfs.mkdir(to, 0o755);
+					for (const entry of shell.vfs.list(from)) {
+						const fromEntry = `${from}/${entry}`;
+						const toEntry = `${to}/${entry}`;
+						const stat = shell.vfs.stat(fromEntry);
+						if (stat.type === "directory") {
+							copyDir(fromEntry, toEntry);
+						} else {
+							const content = shell.vfs.readFileRaw(fromEntry);
+							shell.writeFileAsUser(authUser, toEntry, content);
+						}
+					}
+				};
+				const finalDest =
+					shell.vfs.exists(destPath) &&
+					shell.vfs.stat(destPath).type === "directory"
+						? `${destPath}/${srcArg.split("/").pop()}`
+						: destPath;
+				copyDir(srcPath, finalDest);
+			} else {
+				const finalDest =
+					shell.vfs.exists(destPath) &&
+					shell.vfs.stat(destPath).type === "directory"
+						? `${destPath}/${srcArg.split("/").pop()}`
+						: destPath;
+				const content = shell.vfs.readFileRaw(srcPath);
+				shell.writeFileAsUser(authUser, finalDest, content);
+			}
+
+			return { exitCode: 0 };
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			return { stderr: `cp: ${msg}`, exitCode: 1 };
+		}
+	},
+};

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

package/src/commands/diff.ts

@@ -0,0 +1,29 @@
+import type { ShellModule } from "../types/commands";
+import { resolvePath } from "./helpers";
+
+export const diffCommand: ShellModule = {
+	name: "diff",
+	description: "Compare files line by line",
+	category: "text",
+	params: ["<file1> <file2>"],
+	run: ({ shell, cwd, args }) => {
+		const [f1, f2] = args;
+		if (!f1 || !f2) return { stderr: "diff: missing operand", exitCode: 1 };
+		const p1 = resolvePath(cwd, f1);
+		const p2 = resolvePath(cwd, f2);
+		let a: string[], b: string[];
+		try { a = shell.vfs.readFile(p1).split("\n"); } catch { return { stderr: `diff: ${f1}: No such file or directory`, exitCode: 2 }; }
+		try { b = shell.vfs.readFile(p2).split("\n"); } catch { return { stderr: `diff: ${f2}: No such file or directory`, exitCode: 2 }; }
+
+		const out: string[] = [];
+		const max = Math.max(a.length, b.length);
+		for (let i = 0; i < max; i++) {
+			const la = a[i]; const lb = b[i];
+			if (la !== lb) {
+				if (la !== undefined) out.push(`< ${la}`);
+				if (lb !== undefined) out.push(`> ${lb}`);
+			}
+		}
+		return { stdout: out.join("\n"), exitCode: out.length > 0 ? 1 : 0 };
+	},
+};

package/src/commands/du.ts

@@ -0,0 +1,39 @@
+import type { ShellModule } from "../types/commands";
+import { ifFlag } from "./command-helpers";
+import { resolvePath } from "./helpers";
+
+export const duCommand: ShellModule = {
+	name: "du",
+	description: "Estimate file space usage",
+	category: "system",
+	params: ["[-h] [-s] [path]"],
+	run: ({ shell, cwd, args }) => {
+		const human = ifFlag(args, ["-h"]);
+		const summary = ifFlag(args, ["-s"]);
+		const target = args.find((a) => !a.startsWith("-")) ?? ".";
+		const p = resolvePath(cwd, target);
+
+		const fmt = (b: number) => human ? `${(b / 1024).toFixed(1)}K` : String(Math.ceil(b / 1024));
+
+		if (!shell.vfs.exists(p)) return { stderr: `du: ${target}: No such file or directory`, exitCode: 1 };
+
+		if (summary || shell.vfs.stat(p).type === "file") {
+			return { stdout: `${fmt(shell.vfs.getUsageBytes(p))}\t${target}`, exitCode: 0 };
+		}
+
+		const lines: string[] = [];
+		const walk = (dir: string, rel: string) => {
+			let total = 0;
+			for (const e of shell.vfs.list(dir)) {
+				const full = `${dir}/${e}`, r = `${rel}/${e}`;
+				const st = shell.vfs.stat(full);
+				if (st.type === "directory") total += walk(full, r);
+				else { total += st.size; if (!summary) lines.push(`${fmt(st.size)}\t${r}`); }
+			}
+			lines.push(`${fmt(total)}\t${rel}`);
+			return total;
+		};
+		walk(p, target);
+		return { stdout: lines.join("\n"), exitCode: 0 };
+	},
+};

package/src/commands/echo.ts

@@ -10,6 +10,8 @@ function expandEnvVars(input: string, env: Record<string, string>): string {
 
 export const echoCommand: ShellModule = {
 	name: "echo",
+	description: "Display text",
+	category: "shell",
 	params: ["[options] [text...]"],
 	run: ({ args, authUser, stdin }) => {
 		const { flags, positionals } = parseArgs(args, { flags: ["-n"] });

package/src/commands/env.ts

@@ -1,22 +1,12 @@
 import type { ShellModule } from "../types/commands";
-import { getAllEnvVars } from "./set";
 
 export const envCommand: ShellModule = {
 	name: "env",
-	params: ["[VAR=value...] [command]"],
-	run: ({ authUser }) => {
-		// For now, just display all environment variables
-		// In a full implementation, this would also handle running commands with modified env
-
-		const allVars = getAllEnvVars(authUser);
-		const envVarsOutput = Object.entries(allVars)
-			.map(([key, value]) => `${key}=${value}`)
-			.sort()
-			.join("\n");
-
-		return {
-			stdout: envVarsOutput,
-			exitCode: 0,
-		};
+	description: "Print environment variables",
+	category: "shell",
+	params: [],
+	run: ({ env, authUser }) => {
+		const vars = { ...env.vars, USER: authUser, HOME: `/home/${authUser}` };
+		return { stdout: Object.entries(vars).map(([k, v]) => `${k}=${v}`).join("\n"), exitCode: 0 };
 	},
 };

package/src/commands/export.ts

@@ -1,38 +1,25 @@
 import type { ShellModule } from "../types/commands";
-import { getArg } from "./command-helpers";
-import { getEnvVar, setEnvVar } from "./set";
 
 export const exportCommand: ShellModule = {
 	name: "export",
+	description: "Set shell environment variable",
+	category: "shell",
 	params: ["[VAR=value]"],
-	run: ({ args }) => {
-		// export VAR=value or export VAR (to make it available to child processes)
+	run: ({ args, env }) => {
 		if (args.length === 0) {
-			// List all exported variables
-			return {
-				stdout: "# export command - sets variables for child processes",
-				exitCode: 0,
-			};
+			const out = Object.entries(env.vars).map(([k, v]) => `declare -x ${k}="${v}"`).join("\n");
+			return { stdout: out, exitCode: 0 };
 		}
-
-		// Parse VAR=value format
-		for (let index = 0; ; index += 1) {
-			const arg = getArg(args, index);
-			if (!arg) {
-				break;
-			}
-
+		for (const arg of args) {
 			if (arg.includes("=")) {
-				const [varName, varValue] = arg.split("=", 2);
-				if (varName && varValue !== undefined) {
-					setEnvVar(varName, varValue);
-				}
+				const eq = arg.indexOf("=");
+				const name = arg.slice(0, eq);
+				const value = arg.slice(eq + 1);
+				env.vars[name] = value;
 			} else {
-				// export VAR_NAME makes it available but we just set it
-				setEnvVar(arg, getEnvVar(arg) || "");
+				// mark existing as exported (already is)
 			}
 		}
-
 		return { exitCode: 0 };
 	},
 };

package/src/commands/find.ts

@@ -0,0 +1,63 @@
+import type { ShellModule } from "../types/commands";
+import { getFlag } from "./command-helpers";
+import { assertPathAccess, resolvePath } from "./helpers";
+
+export const findCommand: ShellModule = {
+	name: "find",
+	description: "Search for files",
+	category: "files",
+	params: ["[path] [-name <pattern>] [-type f|d]"],
+	run: ({ authUser, shell, cwd, args }) => {
+		const namePattern = getFlag(args, ["-name"]);
+		const typeFilter = getFlag(args, ["-type"]);
+		const positionals = args.filter(
+			(a) => !a.startsWith("-") && a !== namePattern && a !== typeFilter,
+		);
+		const rootArg = positionals[0] ?? ".";
+		const rootPath = resolvePath(cwd, rootArg);
+
+		try {
+			assertPathAccess(authUser, rootPath, "find");
+			if (!shell.vfs.exists(rootPath)) {
+				return {
+					stderr: `find: ${rootArg}: No such file or directory`,
+					exitCode: 1,
+				};
+			}
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			return { stderr: `find: ${msg}`, exitCode: 1 };
+		}
+
+		const nameRegex = namePattern
+			? new RegExp(
+					`^${(namePattern as string).replace(/\./g, "\\.").replace(/\*/g, ".*").replace(/\?/g, ".")}$`,
+				)
+			: null;
+
+		const results: string[] = [];
+		const walk = (currentPath: string, display: string) => {
+			const stat = shell.vfs.stat(currentPath);
+
+			const matchesType =
+				!typeFilter ||
+				(typeFilter === "f" && stat.type === "file") ||
+				(typeFilter === "d" && stat.type === "directory");
+			const matchesName =
+				!nameRegex || nameRegex.test(currentPath.split("/").pop() ?? "");
+
+			if (matchesType && matchesName) results.push(display);
+
+			if (stat.type === "directory") {
+				for (const entry of shell.vfs.list(currentPath)) {
+					const full = `${currentPath}/${entry}`;
+					const disp = `${display}/${entry}`;
+					walk(full, disp);
+				}
+			}
+		};
+
+		walk(rootPath, rootArg);
+		return { stdout: results.join("\n"), exitCode: 0 };
+	},
+};

package/src/commands/grep.ts

@@ -4,11 +4,15 @@ import { assertPathAccess, resolvePath } from "./helpers";
 
 export const grepCommand: ShellModule = {
 	name: "grep",
-	params: ["[-i] [-v] <pattern> [file...]"],
+	description: "Search text patterns",
+	category: "text",
+	params: ["[-i] [-v] [-n] [-r] <pattern> [file...]"],
 	run: ({ authUser, shell, cwd, args, stdin }) => {
-		const { flags, positionals } = parseArgs(args, { flags: ["-i", "-v"] });
+		const { flags, positionals } = parseArgs(args, { flags: ["-i", "-v", "-n", "-r"] });
 		const caseInsensitive = flags.has("-i");
 		const invertMatch = flags.has("-v");
+		const showLineNumbers = flags.has("-n");
+		const recursive = flags.has("-r");
 		const pattern = positionals[0];
 		const files = positionals.slice(1);
 
@@ -18,57 +22,66 @@ export const grepCommand: ShellModule = {
 
 		let regex: RegExp;
 		try {
-			const flags = caseInsensitive ? "gmi" : "gm";
-			regex = new RegExp(pattern, flags);
+			// No "g" flag — avoids the stateful lastIndex problem with regex.test()
+			const regexFlags = caseInsensitive ? "mi" : "m";
+			regex = new RegExp(pattern, regexFlags);
 		} catch {
 			return { stderr: `grep: invalid regex: ${pattern}`, exitCode: 1 };
 		}
 
-		const results: string[] = [];
-
-		if (files.length === 0) {
-			if (!stdin) {
-				return { stdout: "", exitCode: 1 };
-			}
-
-			const lines = stdin.split("\n");
-			for (const line of lines) {
-				regex.lastIndex = 0;
+		const matchLines = (content: string, prefix = ""): string[] => {
+			const lines = content.split("\n");
+			const out: string[] = [];
+			for (let i = 0; i < lines.length; i++) {
+				const line = lines[i] ?? "";
 				const matches = regex.test(line);
 				const shouldInclude = invertMatch ? !matches : matches;
-
 				if (shouldInclude) {
-					results.push(line);
+					const lineLabel = showLineNumbers ? `${i + 1}:` : "";
+					out.push(`${prefix}${lineLabel}${line}`);
 				}
 			}
+			return out;
+		};
 
-			return {
-				stdout: results.length > 0 ? results.join("\n") : "",
-				exitCode: results.length > 0 ? 0 : 1,
+		const readPaths = (base: string): string[] => {
+			if (!shell.vfs.exists(base)) return [];
+			const stat = shell.vfs.stat(base);
+			if (stat.type === "file") return [base];
+			if (!recursive) return [];
+			const paths: string[] = [];
+			const walk = (dir: string) => {
+				for (const entry of shell.vfs.list(dir)) {
+					const full = `${dir}/${entry}`;
+					const s = shell.vfs.stat(full);
+					if (s.type === "file") paths.push(full);
+					else walk(full);
+				}
 			};
-		}
+			walk(base);
+			return paths;
+		};
 
-		for (const file of files) {
-			const target = resolvePath(cwd, file);
-			try {
-				assertPathAccess(authUser, target, "grep");
-				const content = shell.vfs.readFile(target);
-				const lines = content.split("\n");
+		const results: string[] = [];
 
-				for (const line of lines) {
-					regex.lastIndex = 0;
-					const matches = regex.test(line);
-					const shouldInclude = invertMatch ? !matches : matches;
+		if (files.length === 0) {
+			if (!stdin) return { stdout: "", exitCode: 1 };
+			results.push(...matchLines(stdin));
+		} else {
+			const resolvedPaths = files.flatMap((f) => {
+				const target = resolvePath(cwd, f);
+				return readPaths(target).map((p) => ({ file: f, path: p }));
+			});
 
-					if (shouldInclude) {
-						results.push(line);
-					}
+			for (const { file, path: filePath } of resolvedPaths) {
+				try {
+					assertPathAccess(authUser, filePath, "grep");
+					const content = shell.vfs.readFile(filePath);
+					const prefix = resolvedPaths.length > 1 ? `${file}:` : "";
+					results.push(...matchLines(content, prefix));
+				} catch {
+					return { stderr: `grep: ${file}: No such file or directory`, exitCode: 1 };
 				}
-			} catch {
-				return {
-					stderr: `grep: ${file}: No such file or directory`,
-					exitCode: 1,
-				};
 			}
 		}
 

package/src/commands/groups.ts

@@ -0,0 +1,14 @@
+import type { ShellModule } from "../types/commands";
+
+export const groupsCommand: ShellModule = {
+	name: "groups",
+	description: "Print group memberships",
+	category: "system",
+	params: ["[user]"],
+	run: ({ authUser, shell, args }) => {
+		const target = args[0] ?? authUser;
+		const isSudo = shell.users.isSudoer(target);
+		const grps = isSudo ? `${target} sudo root` : target;
+		return { stdout: grps, exitCode: 0 };
+	},
+};

package/src/commands/gzip.ts

@@ -0,0 +1,31 @@
+import type { ShellModule } from "../types/commands";
+import { resolvePath } from "./helpers";
+
+export const gzipCommand: ShellModule = {
+	name: "gzip",
+	description: "Compress files",
+	category: "archive",
+	params: ["<file>"],
+	run: ({ shell, cwd, args }) => {
+		const file = args[0];
+		if (!file) return { stderr: "gzip: no file specified", exitCode: 1 };
+		const p = resolvePath(cwd, file);
+		try { shell.vfs.compressFile(p); return { exitCode: 0 }; }
+		catch { return { stderr: `gzip: ${file}: No such file or directory`, exitCode: 1 }; }
+	},
+};
+
+export const gunzipCommand: ShellModule = {
+	name: "gunzip",
+	description: "Decompress files",
+	category: "archive",
+	params: ["<file>"],
+	aliases: ["zcat"],
+	run: ({ shell, cwd, args }) => {
+		const file = args[0];
+		if (!file) return { stderr: "gunzip: no file specified", exitCode: 1 };
+		const p = resolvePath(cwd, file);
+		try { shell.vfs.decompressFile(p); return { exitCode: 0 }; }
+		catch { return { stderr: `gunzip: ${file}: No such file or directory`, exitCode: 1 }; }
+	},
+};

package/src/commands/head.ts

@@ -0,0 +1,37 @@
+import type { ShellModule } from "../types/commands";
+import { getFlag } from "./command-helpers";
+import { assertPathAccess, resolvePath } from "./helpers";
+
+export const headCommand: ShellModule = {
+	name: "head",
+	description: "Output first lines",
+	category: "text",
+	params: ["[-n <lines>] [file...]"],
+	run: ({ authUser, shell, cwd, args, stdin }) => {
+		const nArg = getFlag(args, ["-n"]);
+		const n = typeof nArg === "string" ? parseInt(nArg, 10) : 10;
+		const positionals = args.filter((a) => !a.startsWith("-") && a !== nArg);
+
+		const take = (content: string) =>
+			content.split("\n").slice(0, n).join("\n");
+
+		if (positionals.length === 0) {
+			return { stdout: take(stdin ?? ""), exitCode: 0 };
+		}
+
+		const results: string[] = [];
+		for (const file of positionals) {
+			const filePath = resolvePath(cwd, file);
+			try {
+				assertPathAccess(authUser, filePath, "head");
+				results.push(take(shell.vfs.readFile(filePath)));
+			} catch {
+				return {
+					stderr: `head: ${file}: No such file or directory`,
+					exitCode: 1,
+				};
+			}
+		}
+		return { stdout: results.join("\n"), exitCode: 0 };
+	},
+};