typescript-virtual-container 1.5.3 → 1.5.4

package/src/commands/helpers.ts

@@ -1,234 +0,0 @@
-import { spawn } from "node:child_process";
-import * as path from "node:path";
-import type VirtualFileSystem from "../VirtualFileSystem";
-import type { VirtualPackageManager } from "../VirtualPackageManager";
-import type { VirtualShell } from "../VirtualShell";
-
-const PROTECTED_PREFIXES = ["/.virtual-env-js/.auth", "/etc/htpasswd"] as const;
-
-function normalizeFetchUrl(input: string): string {
-	if (/^[a-zA-Z][a-zA-Z\d+\-.]*:/.test(input)) {
-		return input;
-	}
-
-	return `http://${input}`;
-}
-
-export function normalizeTerminalOutput(text: string): string {
-	return text
-		.replace(/\r\n/g, "\n")
-		.replace(/\r/g, "\n")
-		.replace(/\t/g, "  ")
-		.split("\n")
-		.map((line) =>
-			line.replace(/^[ \u00A0]{8,}/, "  ").replace(/[ \u00A0]{3,}/g, "  "),
-		)
-		.join("\n")
-		.replace(/\n{3,}/g, "\n\n")
-		.trimEnd();
-}
-
-export function resolvePath(cwd: string, inputPath: string, homeDir?: string): string {
-	if (!inputPath || inputPath.trim() === "") {
-		return cwd;
-	}
-	if (inputPath.startsWith("~")) {
-		const home = homeDir ?? "/root";
-		return path.posix.normalize(`${home}${inputPath.slice(1)}`);
-	}
-	return inputPath.startsWith("/")
-		? path.posix.normalize(inputPath)
-		: path.posix.normalize(path.posix.join(cwd, inputPath));
-}
-
-function isProtectedPath(targetPath: string): boolean {
-	const normalized = targetPath.startsWith("/")
-		? path.posix.normalize(targetPath)
-		: path.posix.normalize(`/${targetPath}`);
-
-	return PROTECTED_PREFIXES.some(
-		(prefix) => normalized === prefix || normalized.startsWith(`${prefix}/`),
-	);
-}
-
-export function assertPathAccess(
-	authUser: string,
-	targetPath: string,
-	operation: string,
-): void {
-	if (authUser === "root") {
-		return;
-	}
-
-	if (isProtectedPath(targetPath)) {
-		throw new Error(`${operation}: permission denied: ${targetPath}`);
-	}
-}
-
-export function stripUrlFilename(url: string): string {
-	const cleaned = url.split("?")[0]?.split("#")[0] ?? url;
-	const lastPart = cleaned.split("/").filter(Boolean).pop();
-	return lastPart && lastPart.length > 0 ? lastPart : "index.html";
-}
-
-export async function fetchResource(
-	url: string,
-): Promise<{ text: string; status: number; contentType: string | null }> {
-	const response = await fetch(normalizeFetchUrl(url));
-	const contentType = response.headers.get("content-type");
-	return {
-		text: await response.text(),
-		status: response.status,
-		contentType,
-	};
-}
-
-/**
- * Run a host command like curl or wget and capture its output.
- * @param binary - The binary to execute (e.g., "curl", "wget").
- * @param args - Arguments to pass to the binary.
- * @returns Promise resolving with stdout, stderr, and exit code.
- */
-export function runHostCommand(
-	binary: string,
-	args: string[],
-): Promise<{ stdout: string; stderr: string; exitCode: number }> {
-	return new Promise((resolve) => {
-		let childProcess: ReturnType<typeof spawn>;
-
-		try {
-			childProcess = spawn(binary, args, {
-				stdio: ["ignore", "pipe", "pipe"],
-			});
-		} catch (error) {
-			resolve({
-				stdout: "",
-				stderr: `${binary}: ${error instanceof Error ? error.message : String(error)}`,
-				exitCode: 1,
-			});
-			return;
-		}
-
-		let stdout = "";
-		let stderr = "";
-		const stdoutStream = childProcess.stdout;
-		const stderrStream = childProcess.stderr;
-
-		if (!stdoutStream || !stderrStream) {
-			resolve({
-				stdout: "",
-				stderr: `${binary}: failed to capture process output`,
-				exitCode: 1,
-			});
-			return;
-		}
-
-		stdoutStream.setEncoding("utf8");
-		stderrStream.setEncoding("utf8");
-
-		stdoutStream.on("data", (chunk: string) => {
-			stdout += chunk;
-		});
-
-		stderrStream.on("data", (chunk: string) => {
-			stderr += chunk;
-		});
-
-		childProcess.on("error", (error) => {
-			const errorCode =
-				error instanceof Error && "code" in error
-					? String((error as NodeJS.ErrnoException).code ?? "")
-					: "";
-			resolve({
-				stdout: "",
-				stderr: `${binary}: ${error.message}`,
-				exitCode: errorCode === "ENOENT" ? 127 : 1,
-			});
-		});
-
-		childProcess.on("close", (code) => {
-			resolve({
-				stdout,
-				stderr,
-				exitCode: code ?? 1,
-			});
-		});
-	});
-}
-
-function levenshtein(a: string, b: string): number {
-	const dp: number[][] = Array.from({ length: a.length + 1 }, () =>
-		Array<number>(b.length + 1).fill(0),
-	);
-
-	for (let i = 0; i <= a.length; i += 1) {
-		dp[i]![0] = i;
-	}
-	for (let j = 0; j <= b.length; j += 1) {
-		dp[0]![j] = j;
-	}
-
-	for (let i = 1; i <= a.length; i += 1) {
-		for (let j = 1; j <= b.length; j += 1) {
-			const cost = a[i - 1] === b[j - 1] ? 0 : 1;
-			dp[i]![j] = Math.min(
-				dp[i - 1]![j]! + 1,
-				dp[i]![j - 1]! + 1,
-				dp[i - 1]![j - 1]! + cost,
-			);
-		}
-	}
-
-	return dp[a.length]![b.length]!;
-}
-
-export function resolveReadablePath(
-	vfs: VirtualFileSystem,
-	cwd: string,
-	inputPath: string,
-): string {
-	const exactPath = resolvePath(cwd, inputPath);
-	if (vfs.exists(exactPath)) {
-		return exactPath;
-	}
-
-	const parent = path.posix.dirname(exactPath);
-	const fileName = path.posix.basename(exactPath);
-	const siblings = vfs.list(parent);
-
-	const caseInsensitive = siblings.filter(
-		(name) => name.toLowerCase() === fileName.toLowerCase(),
-	);
-	if (caseInsensitive.length === 1) {
-		return path.posix.join(parent, caseInsensitive[0]!);
-	}
-
-	const near = siblings.filter(
-		(name) => levenshtein(name.toLowerCase(), fileName.toLowerCase()) <= 1,
-	);
-	if (near.length === 1) {
-		return path.posix.join(parent, near[0]!);
-	}
-
-	return exactPath;
-}
-
-export function joinListWithType(
-	cwd: string,
-	items: string[],
-	statAt: (p: string) => { type: "file" | "directory" },
-): string {
-	return items
-		.map((name) => {
-			const childPath = resolvePath(cwd, name);
-			const stats = statAt(childPath);
-			return stats.type === "directory" ? `${name}/` : name;
-		})
-		.join("  ");
-}
-
-export function getPackageManager(
-	shell: VirtualShell,
-): VirtualPackageManager | undefined {
-	return shell.packageManager;
-}

package/src/commands/history.ts

@@ -1,34 +0,0 @@
-import type { ShellModule } from "../types/commands";
-
-/**
- * Display persisted command history for the session (from VFS).
- * @category shell
- * @params ["[n]"]
- */
-export const historyCommand: ShellModule = {
-	name: "history",
-	description: "Display command history",
-	category: "shell",
-	params: ["[n]"],
-	run: ({ args, shell, authUser }) => {
-		// History is persisted in the VFS by the interactive shell
-		const histPath = `/home/${authUser}/.bash_history`;
-		if (!shell.vfs.exists(histPath)) {
-			return { stdout: "", exitCode: 0 };
-		}
-
-		const raw = shell.vfs.readFile(histPath);
-		const lines = raw.split("\n").filter(Boolean);
-
-		const nArg = args[0];
-		const n = nArg ? parseInt(nArg, 10) : null;
-		const slice = n && !Number.isNaN(n) ? lines.slice(-n) : lines;
-
-		const offset = lines.length - slice.length + 1;
-		const numbered = slice.map(
-			(line, i) => `${String(offset + i).padStart(5)}  ${line}`,
-		);
-
-		return { stdout: numbered.join("\n"), exitCode: 0 };
-	},
-};

package/src/commands/hostname.ts

@@ -1,14 +0,0 @@
-import type { ShellModule } from "../types/commands";
-
-/**
- * Print the configured hostname for the virtual shell.
- * @category system
- * @params []
- */
-export const hostnameCommand: ShellModule = {
-	name: "hostname",
-	description: "Print hostname",
-	category: "system",
-	params: [],
-	run: ({ hostname }) => ({ stdout: hostname, exitCode: 0 }),
-};

package/src/commands/htop.ts

@@ -1,20 +0,0 @@
-import type { ShellModule } from "../types/commands";
-
-/**
- * Interactive system monitor (requires terminal interaction).
- * @category system
- * @params []
- */
-export const htopCommand: ShellModule = {
-	name: "htop",
-	description: "System monitor",
-	category: "system",
-	params: [],
-	run: ({ mode }) => {
-		if (mode === "exec") {
-			return { stderr: "htop: interactive terminal required", exitCode: 1 };
-		}
-
-		return { openHtop: true, exitCode: 0 };
-	},
-};

package/src/commands/id.ts

@@ -1,19 +0,0 @@
-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,
-		};
-	},
-};

package/src/commands/index.ts

@@ -1,9 +0,0 @@
-export {
-	createCustomCommand,
-	getCommandModulesPublic,
-	getCommandNames,
-	registerCommand,
-	resolveModule
-} from "./registry";
-
-export { makeDefaultEnv, runCommand, runCommandDirect, userHome } from "./runtime";

package/src/commands/kill.ts

@@ -1,19 +0,0 @@
-import type { ShellModule } from "../types/commands";
-
-/**
- * Send a signal to a process by PID.
- * @category system
- * @params ["[-9] <pid>"]
- */
-export const killCommand: ShellModule = {
-	name: "kill",
-	description: "Send signal to process",
-	category: "system",
-	params: ["[-9] <pid>"],
-	run: ({ args }) => {
-		const pid = args.find((a) => !a.startsWith("-"));
-		if (!pid) return { stderr: "kill: no pid specified", exitCode: 1 };
-		// In virtual env, we just acknowledge the kill
-		return { stdout: ``, exitCode: 0 };
-	},
-};

package/src/commands/ln.ts

@@ -1,71 +0,0 @@
-import type { ShellModule } from "../types/commands";
-import { ifFlag } from "./command-helpers";
-import { assertPathAccess, resolvePath } from "./helpers";
-
-export const lnCommand: ShellModule = {
-	name: "ln",
-	description: "Create links",
-	category: "files",
-	params: ["[-s] <target> <link_name>"],
-	run: ({ authUser, shell, cwd, args }) => {
-		const symbolic = ifFlag(args, ["-s", "--symbolic"]);
-		const positionals = args.filter((a) => !a.startsWith("-"));
-		const [targetArg, linkArg] = positionals;
-
-		if (!targetArg || !linkArg) {
-			return { stderr: "ln: missing operand", exitCode: 1 };
-		}
-
-		const linkPath = resolvePath(cwd, linkArg);
-		const targetPath = symbolic
-			? targetArg // keep relative for symlinks
-			: resolvePath(cwd, targetArg);
-
-		try {
-			assertPathAccess(authUser, linkPath, "ln");
-
-			if (!symbolic) {
-				// Hard link — copy file contents
-				const srcPath = resolvePath(cwd, targetArg);
-				assertPathAccess(authUser, srcPath, "ln");
-				if (!shell.vfs.exists(srcPath)) {
-					return {
-						stderr: `ln: ${targetArg}: No such file or directory`,
-						exitCode: 1,
-					};
-				}
-				const content = shell.vfs.readFile(srcPath);
-				shell.writeFileAsUser(authUser, linkPath, content);
-			} else {
-				shell.vfs.symlink(targetPath, linkPath);
-			}
-
-			return { exitCode: 0 };
-		} catch (err) {
-			const msg = err instanceof Error ? err.message : String(err);
-			return { stderr: `ln: ${msg}`, exitCode: 1 };
-		}
-	},
-};
-
-/** Shell command: print the value of a symbolic link. */
-export const readlinkCommand: ShellModule = {
-	name: "readlink",
-	description: "Print resolved path of symbolic link",
-	category: "files",
-	params: ["[-f] <path>"],
-	run: ({ shell, cwd, args }) => {
-		const follow = args.includes("-f") || args.includes("-e");
-		const target = args.find((a) => !a.startsWith("-"));
-		if (!target) return { stderr: "readlink: missing operand\n", exitCode: 1 };
-		const p = resolvePath(cwd, target);
-		if (!shell.vfs.exists(p)) {
-			return { stderr: `readlink: ${target}: No such file or directory\n`, exitCode: 1 };
-		}
-		if (!shell.vfs.isSymlink(p)) {
-			return { stderr: `readlink: ${target}: not a symbolic link\n`, exitCode: 1 };
-		}
-		const resolved = shell.vfs.resolveSymlink(follow ? p : p);
-		return { stdout: `${resolved}\n`, exitCode: 0 };
-	},
-};

package/src/commands/ls.ts

@@ -1,243 +0,0 @@
-import type { ShellModule } from "../types/commands";
-import { getArg, ifFlag } from "./command-helpers";
-import { assertPathAccess, resolvePath } from "./helpers";
-
-// ─── ANSI color codes (matches GNU ls --color=auto / LS_COLORS defaults) ────
-
-const RESET  = "\x1b[0m";
-
-// Entry-type colors
-const C_DIR     = "\x1b[1;34m";   // bold blue         — directory
-const C_LINK    = "\x1b[1;36m";   // bold cyan         — symlink
-const C_EXEC    = "\x1b[1;32m";   // bold green        — executable file
-const C_NORMAL  = "";              // no color          — regular file
-
-// Special-mode backgrounds (GNU ls corner cases)
-const C_STICKY_WX = "\x1b[30;42m"; // black on green — dir sticky + world-writable (/tmp)
-const C_STICKY    = "\x1b[37;44m"; // white on blue  — dir sticky, NOT world-writable
-const C_OTHER_WX  = "\x1b[34;42m"; // blue on green  — dir world-writable, not sticky
-
-// ─── helpers ────────────────────────────────────────────────────────────────
-
-function colorize(name: string, color: string): string {
-	return color ? `${color}${name}${RESET}` : name;
-}
-
-function entryColor(mode: number, type: "file" | "directory", isLink: boolean): string {
-	if (isLink) return C_LINK;
-	if (type === "directory") {
-		const sticky  = !!(mode & 0o1000);
-		const worldW  = !!(mode & 0o002);
-		if (sticky && worldW) return C_STICKY_WX;
-		if (sticky)           return C_STICKY;
-		if (worldW)           return C_OTHER_WX;
-		return C_DIR;
-	}
-	if (mode & 0o111) return C_EXEC;
-	return C_NORMAL;
-}
-
-// ─── permissions string ──────────────────────────────────────────────────────
-
-function formatPermissions(mode: number, type: "file" | "directory", isLink: boolean): string {
-	let ft: string;
-	if (isLink)                    ft = "l";
-	else if (type === "directory") ft = "d";
-	else                           ft = "-";
-
-	const r = (bit: number) => (mode & bit ? "r" : "-");
-	const w = (bit: number) => (mode & bit ? "w" : "-");
-
-	const xOwner = (() => {
-		const exec = !!(mode & 0o100);
-		if (mode & 0o4000) return exec ? "s" : "S";
-		return exec ? "x" : "-";
-	})();
-	const xGroup = (() => {
-		const exec = !!(mode & 0o010);
-		if (mode & 0o2000) return exec ? "s" : "S";
-		return exec ? "x" : "-";
-	})();
-	const xOther = (() => {
-		const exec = !!(mode & 0o001);
-		if (type === "directory" && (mode & 0o1000)) return exec ? "t" : "T";
-		return exec ? "x" : "-";
-	})();
-
-	return `${ft}${r(0o400)}${w(0o200)}${xOwner}${r(0o040)}${w(0o020)}${xGroup}${r(0o004)}${w(0o002)}${xOther}`;
-}
-
-// ─── date formatting (GNU ls + French locale) ────────────────────────────────
-
-const MONTHS_EN = [
-	"Jan", "Feb", "Mar", "Apr", "May", "Jun",
-	"Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
-];
-
-function formatDate(date: Date): string {
-	const now    = new Date();
-	const sixMo  = 6 * 30 * 24 * 3600 * 1000;
-	const recent = Math.abs(now.getTime() - date.getTime()) < sixMo;
-	const day    = String(date.getDate()).padStart(2, " ");
-	const month  = MONTHS_EN[date.getMonth()] ?? "";
-	if (recent) {
-		const hh = String(date.getHours()).padStart(2, "0");
-		const mm = String(date.getMinutes()).padStart(2, "0");
-		return `${day} ${month.padEnd(3)} ${hh}:${mm}`;
-	}
-	return `${day} ${month.padEnd(3)} ${date.getFullYear()}`;
-}
-
-// ─── symlink target ──────────────────────────────────────────────────────────
-
-function readlinkTarget(vfs: { readFile: (p: string) => string }, path: string): string {
-	try { return vfs.readFile(path); } catch { return "?"; }
-}
-
-// ─── short listing ───────────────────────────────────────────────────────────
-
-function shortListing(
-	vfs: {
-		stat:      (p: string) => { mode: number; type: "file" | "directory" };
-		isSymlink: (p: string) => boolean;
-	},
-	dir: string,
-	items: string[],
-): string {
-	const base = dir === "/" ? "" : dir;
-	return items.map((name) => {
-		const childPath = `${base}/${name}`;
-		const isLink    = vfs.isSymlink(childPath);
-		let stat: { mode: number; type: "file" | "directory" };
-		try { stat = vfs.stat(childPath); } catch { return name; }
-		const color  = entryColor(stat.mode, stat.type, isLink);
-		return colorize(name, color);
-	}).join("  ");
-}
-
-// ─── long listing ────────────────────────────────────────────────────────────
-
-type VfsStat = {
-	mode:          number;
-	type:          "file" | "directory";
-	updatedAt:     Date;
-	size?:         number;
-	childrenCount?: number;
-};
-
-function longListing(
-	vfs: {
-		stat:      (p: string) => VfsStat;
-		isSymlink: (p: string) => boolean;
-		readFile:  (p: string) => string;
-	},
-	dir: string,
-	items: string[],
-): string {
-	const base = dir === "/" ? "" : dir;
-
-	type Row = { perms: string; nlink: string; size: string; date: string; label: string };
-
-	const rows: Row[] = items.map((name) => {
-		const childPath = `${base}/${name}`;
-		const isLink    = vfs.isSymlink(childPath);
-		let stat: VfsStat;
-		try { stat = vfs.stat(childPath); } catch {
-			return {
-				perms: "----------", nlink: "1", size: "0",
-				date: formatDate(new Date()), label: name,
-			};
-		}
-
-		const mode  = isLink ? 0o120777 : stat.mode;
-		const perms = formatPermissions(mode, stat.type, isLink);
-
-		// nlink: dirs = children + 2 (. and ..), files/links = 1
-		const nlink = stat.type === "directory"
-			? String((stat.childrenCount ?? 0) + 2)
-			: "1";
-
-		// size: links → target path length, files → bytes, dirs → children×4096
-		const rawSize = isLink
-			? readlinkTarget(vfs, childPath).length
-			: stat.type === "file"
-				? (stat.size ?? 0)
-				: (stat.childrenCount ?? 0) * 4096;
-		const size = String(rawSize);
-
-		const date  = formatDate(stat.updatedAt);
-		const color = entryColor(mode, stat.type, isLink);
-
-		const label = isLink
-			? `${colorize(name, color)} -> ${readlinkTarget(vfs, childPath)}`
-			: colorize(name, color);
-
-		return { perms, nlink, size, date, label };
-	});
-
-	const wNlink = Math.max(...rows.map((r) => r.nlink.length));
-	const wSize  = Math.max(...rows.map((r) => r.size.length));
-	const owner  = "root";
-	const group  = "root";
-
-	const total  = items.length * 8;
-	const lines  = rows.map((r) =>
-		`${r.perms} ${r.nlink.padStart(wNlink)} ${owner} ${group} ${r.size.padStart(wSize)} ${r.date} ${r.label}`,
-	);
-
-	return `total ${total}\n${lines.join("\n")}`;
-}
-
-// ─── command ─────────────────────────────────────────────────────────────────
-
-export const lsCommand: ShellModule = {
-	name: "ls",
-	description: "List directory contents",
-	category: "navigation",
-	params: ["[-la] [path]"],
-	run: ({ authUser, shell, cwd, args }) => {
-		const longFormat = ifFlag(args, ["-l", "--long", "-la", "-al"]);
-		const showHidden = ifFlag(args, ["-a", "--all",  "-la", "-al"]);
-
-		const targetArg = getArg(args, 0, {
-			flags: ["-l", "--long", "-a", "--all", "-la", "-al"],
-		});
-		const target = resolvePath(cwd, targetArg ?? cwd);
-		assertPathAccess(authUser, target, "ls");
-
-		// Single file or symlink
-		if (shell.vfs.exists(target)) {
-			const st     = shell.vfs.stat(target);
-			const isLink = shell.vfs.isSymlink(target);
-			if (st.type === "file" || isLink) {
-				const name  = target.split("/").pop() ?? target;
-				const color = entryColor(isLink ? 0o120777 : st.mode, st.type, isLink);
-				if (longFormat) {
-					const mode  = isLink ? 0o120777 : st.mode;
-					const size  = isLink
-						? readlinkTarget(shell.vfs, target).length
-						: (st as { size?: number }).size ?? 0;
-					const perms = formatPermissions(mode, st.type, isLink);
-					const label = isLink
-						? `${colorize(name, color)} -> ${readlinkTarget(shell.vfs, target)}`
-						: colorize(name, color);
-					return {
-						stdout: `${perms} 1 root root ${size} ${formatDate(st.updatedAt)} ${label}\n`,
-						exitCode: 0,
-					};
-				}
-				return { stdout: `${colorize(name, color)}\n`, exitCode: 0 };
-			}
-		}
-
-		const items = shell.vfs
-			.list(target)
-			.filter((name) => showHidden || !name.startsWith("."));
-
-		const rendered = longFormat
-			? longListing(shell.vfs, target, items)
-			: shortListing(shell.vfs, target, items);
-
-		return { stdout: `${rendered}\n`, exitCode: 0 };
-	},
-};