typescript-virtual-container 1.2.5 → 1.2.6

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

@@ -4,6 +4,8 @@ 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"]);

package/src/commands/grep.ts

@@ -4,11 +4,11 @@ import { assertPathAccess, resolvePath } from "./helpers";
 
 export const grepCommand: ShellModule = {
 	name: "grep",
+	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", "-n", "-r"],
-		});
+		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");
@@ -80,10 +80,7 @@ export const grepCommand: ShellModule = {
 					const prefix = resolvedPaths.length > 1 ? `${file}:` : "";
 					results.push(...matchLines(content, prefix));
 				} catch {
-					return {
-						stderr: `grep: ${file}: No such file or directory`,
-						exitCode: 1,
-					};
+					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

@@ -4,6 +4,8 @@ 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"]);

package/src/commands/help.ts

@@ -1,9 +1,87 @@
 import type { ShellModule } from "../types/commands";
+import { getCommandModulesPublic } from "./index";
 
-export function createHelpCommand(getNames: () => string[]): ShellModule {
+const CATEGORY_ORDER = ["navigation", "files", "text", "archive", "system", "network", "shell", "users", "misc"];
+const CATEGORY_LABELS: Record<string, string> = {
+	navigation: "Navigation",
+	files: "Files & Filesystem",
+	text: "Text Processing",
+	archive: "Archive & Compression",
+	system: "System",
+	network: "Network",
+	shell: "Shell",
+	users: "Users & Permissions",
+	misc: "Miscellaneous",
+};
+
+function padRight(s: string, n: number): string {
+	return s.length >= n ? s : s + " ".repeat(n - s.length);
+}
+
+export function createHelpCommand(_getNames: () => string[]): ShellModule {
 	return {
 		name: "help",
-		params: [],
-		run: () => ({ stdout: `Builtins: ${getNames().join(" ")}`, exitCode: 0 }),
+		description: "Display this help message",
+		category: "shell",
+		params: ["[command]"],
+		run: ({ args }) => {
+			const modules = getCommandModulesPublic();
+
+			// help <command>
+			if (args[0]) {
+				const mod = modules.find((m) => m.name === args[0] || m.aliases?.includes(args[0]!));
+				if (!mod) return { stderr: `help: no help for '${args[0]}'`, exitCode: 1 };
+				const aliases = mod.aliases?.length ? `  aliases: ${mod.aliases.join(", ")}\n` : "";
+				const params = mod.params.map((p) => `  ${mod.name} ${p}`).join("\n");
+				return {
+					stdout: [
+						`\x1b[1m${mod.name}\x1b[0m — ${mod.description ?? "no description"}`,
+						aliases,
+						"Usage:",
+						params || `  ${mod.name}`,
+					].filter(Boolean).join("\n"),
+					exitCode: 0,
+				};
+			}
+
+			// Full help — grouped by category
+			const grouped: Record<string, ShellModule[]> = {};
+			for (const mod of modules) {
+				const cat = mod.category ?? "misc";
+				if (!grouped[cat]) grouped[cat] = [];
+				grouped[cat]!.push(mod);
+			}
+
+			const lines: string[] = [];
+			lines.push("\x1b[1mAvailable commands\x1b[0m");
+			lines.push("");
+
+			const cats = [
+				...CATEGORY_ORDER.filter((c) => grouped[c]),
+				...Object.keys(grouped).filter((c) => !CATEGORY_ORDER.includes(c)),
+			];
+
+			for (const cat of cats) {
+				const mods = grouped[cat];
+				if (!mods || mods.length === 0) continue;
+				lines.push(`\x1b[33m${CATEGORY_LABELS[cat] ?? cat}\x1b[0m`);
+
+				// Two-column layout
+				const sorted = [...mods].sort((a, b) => a.name.localeCompare(b.name));
+				for (let i = 0; i < sorted.length; i += 2) {
+					const left = sorted[i]!;
+					const right = sorted[i + 1];
+					const leftStr = `  \x1b[36m${padRight(left.name, 14)}\x1b[0m ${left.description ?? ""}`;
+					const rightStr = right
+						? `  \x1b[36m${padRight(right.name, 14)}\x1b[0m ${right.description ?? ""}`
+						: "";
+					lines.push(rightStr ? `${leftStr.padEnd(44)}${rightStr}` : leftStr);
+				}
+				lines.push("");
+			}
+
+			lines.push("Type \x1b[1mhelp <command>\x1b[0m for usage details.");
+			return { stdout: lines.join("\n"), exitCode: 0 };
+		},
 	};
 }

package/src/commands/hostname.ts

@@ -2,6 +2,8 @@ import type { ShellModule } from "../types/commands";
 
 export const hostnameCommand: ShellModule = {
 	name: "hostname",
+	description: "Print hostname",
+	category: "system",
 	params: [],
 	run: ({ hostname }) => ({ stdout: hostname, exitCode: 0 }),
 };

package/src/commands/htop.ts

@@ -2,6 +2,8 @@ import type { ShellModule } from "../types/commands";
 
 export const htopCommand: ShellModule = {
 	name: "htop",
+	description: "System monitor",
+	category: "system",
 	params: [],
 	run: ({ mode }) => {
 		if (mode === "exec") {

package/src/commands/id.ts

@@ -0,0 +1,16 @@
+import type { ShellModule } from "../types/commands";
+
+export const idCommand: ShellModule = {
+	name: "id",
+	description: "Print user identity",
+	category: "system",
+	params: ["[user]"],
+	run: ({ authUser, shell, args }) => {
+		const target = args[0] ?? authUser;
+		const uid = target === "root" ? 0 : 1000;
+		const gid = uid;
+		const isSudo = shell.users.isSudoer(target);
+		const groups = isSudo ? `${gid}(${target}),0(root)` : `${gid}(${target})`;
+		return { stdout: `uid=${uid}(${target}) gid=${gid}(${target}) groups=${groups}`, exitCode: 0 };
+	},
+};