typescript-virtual-container 1.2.8 → 1.3.0

package/src/commands/free.ts

@@ -0,0 +1,47 @@
+import * as os from "node:os";
+import type { ShellModule } from "../types/commands";
+import { ifFlag } from "./command-helpers";
+
+/**
+ * Display memory usage information (human / MB / GB options).
+ * @category system
+ * @params ["[-h] [-m] [-g]"]
+ */
+export const freeCommand: ShellModule = {
+	name: "free",
+	description: "Display amount of free and used memory",
+	category: "system",
+	params: ["[-h] [-m] [-g]"],
+	run: ({ args }) => {
+		const human = ifFlag(args, ["-h", "--human"]);
+		const mb = ifFlag(args, ["-m"]);
+		const gb = ifFlag(args, ["-g"]);
+
+		const osTotalB = os.totalmem();
+		const osFreeB = os.freemem();
+		const usedB = osTotalB - osFreeB;
+		const sharedB = Math.floor(osTotalB * 0.02);
+		const buffersB = Math.floor(osTotalB * 0.05);
+		const availableB = Math.floor(osFreeB * 0.95);
+		const swapB = Math.floor(osTotalB * 0.5);
+
+		const fmt = (bytes: number): string => {
+			if (human) {
+				if (bytes >= 1024 * 1024 * 1024)
+					return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)}G`;
+				if (bytes >= 1024 * 1024)
+					return `${(bytes / (1024 * 1024)).toFixed(1)}M`;
+				return `${(bytes / 1024).toFixed(1)}K`;
+			}
+			if (gb) return String(Math.floor(bytes / (1024 * 1024 * 1024)));
+			if (mb) return String(Math.floor(bytes / (1024 * 1024)));
+			return String(Math.floor(bytes / 1024));
+		};
+
+		const header = `               total        used        free      shared  buff/cache   available`;
+		const memRow = `Mem:  ${fmt(osTotalB).padStart(12)} ${fmt(usedB).padStart(11)} ${fmt(osFreeB).padStart(11)} ${fmt(sharedB).padStart(11)} ${fmt(buffersB).padStart(11)} ${fmt(availableB).padStart(11)}`;
+		const swapRow = `Swap: ${fmt(swapB).padStart(12)} ${fmt(0).padStart(11)} ${fmt(swapB).padStart(11)}`;
+
+		return { stdout: [header, memRow, swapRow].join("\n"), exitCode: 0 };
+	},
+};

package/src/commands/grep.ts

@@ -2,13 +2,20 @@ import type { ShellModule } from "../types/commands";
 import { parseArgs } from "./command-helpers";
 import { assertPathAccess, resolvePath } from "./helpers";
 
+/**
+ * Search for a regex pattern in files or stdin with common flags.
+ * @category text
+ * @params ["[-i] [-v] [-n] [-r] <pattern> [file...]"]
+ */
 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,7 +87,10 @@ 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/gzip.ts

@@ -1,6 +1,11 @@
 import type { ShellModule } from "../types/commands";
 import { resolvePath } from "./helpers";
 
+/**
+ * Compress files using gzip (stores in VFS as compressed content).
+ * @category archive
+ * @params ["<file>"]
+ */
 export const gzipCommand: ShellModule = {
 	name: "gzip",
 	description: "Compress files",
@@ -10,12 +15,24 @@ export const gzipCommand: ShellModule = {
 		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 }; }
+		try {
+			shell.vfs.compressFile(p);
+			return { exitCode: 0 };
+		} catch {
+			return {
+				stderr: `gzip: ${file}: No such file or directory`,
+				exitCode: 1,
+			};
+		}
 	},
 };
 
 export const gunzipCommand: ShellModule = {
+	/**
+	 * Decompress gzip files (or zcat alias).
+	 * @category archive
+	 * @params ["<file>"]
+	 */
 	name: "gunzip",
 	description: "Decompress files",
 	category: "archive",
@@ -25,7 +42,14 @@ export const gunzipCommand: ShellModule = {
 		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 }; }
+		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

@@ -2,6 +2,11 @@ import type { ShellModule } from "../types/commands";
 import { getFlag } from "./command-helpers";
 import { assertPathAccess, resolvePath } from "./helpers";
 
+/**
+ * Output the first part of files or stdin (head).
+ * @category text
+ * @params ["[-n <lines>] [file...]"]
+ */
 export const headCommand: ShellModule = {
 	name: "head",
 	description: "Output first lines",

package/src/commands/help.ts

@@ -1,78 +1,152 @@
 import type { ShellModule } from "../types/commands";
-import { getCommandModulesPublic } from "./index";
+import { getCommandModulesPublic } from "./registry";
+
+// ─── category config ──────────────────────────────────────────────────────────
+
+const CATEGORY_ORDER = [
+	"navigation",
+	"files",
+	"text",
+	"archive",
+	"system",
+	"package",
+	"network",
+	"shell",
+	"users",
+	"misc",
+];
 
-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",
+	package: "Package Management",
 	network: "Network",
-	shell: "Shell",
+	shell: "Shell & Scripting",
 	users: "Users & Permissions",
 	misc: "Miscellaneous",
 };
 
-function padRight(s: string, n: number): string {
+// ─── formatting helpers ───────────────────────────────────────────────────────
+
+const BOLD = "\x1b[1m";
+const RESET = "\x1b[0m";
+const CYAN = "\x1b[36m";
+const YLW = "\x1b[33m";
+const DIM = "\x1b[2m";
+const GREEN = "\x1b[32m";
+
+function pad(s: string, n: number): string {
 	return s.length >= n ? s : s + " ".repeat(n - s.length);
 }
 
+function formatCmdLine(mod: ShellModule): string {
+	const aliases = mod.aliases?.length
+		? ` ${DIM}(${mod.aliases.join(", ")})${RESET}`
+		: "";
+	return `  ${CYAN}${pad(mod.name, 16)}${RESET}${aliases}${pad("", mod.aliases?.length ? 0 : 0)} ${mod.description ?? ""}`;
+}
+
+// ─── full grouped listing ─────────────────────────────────────────────────────
+
+function renderFull(modules: ShellModule[]): string {
+	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[] = [
+		`${BOLD}Available commands${RESET}`,
+		`${DIM}Type 'help <command>' for detailed usage.${RESET}`,
+		"",
+	];
+
+	const cats = [
+		...CATEGORY_ORDER.filter((c) => grouped[c]),
+		...Object.keys(grouped)
+			.filter((c) => !CATEGORY_ORDER.includes(c))
+			.sort(),
+	];
+
+	for (const cat of cats) {
+		const mods = grouped[cat];
+		if (!mods?.length) continue;
+
+		lines.push(`${YLW}${CATEGORY_LABELS[cat] ?? cat}${RESET}`);
+		const sorted = [...mods].sort((a, b) => a.name.localeCompare(b.name));
+		for (const mod of sorted) {
+			lines.push(formatCmdLine(mod));
+		}
+		lines.push("");
+	}
+
+	const total = modules.length;
+	lines.push(`${DIM}${total} commands available.${RESET}`);
+
+	return lines.join("\n");
+}
+
+// ─── single-command detail ────────────────────────────────────────────────────
+
+function renderDetail(mod: ShellModule): string {
+	const lines: string[] = [];
+
+	lines.push(
+		`${BOLD}${mod.name}${RESET} — ${mod.description ?? "no description"}`,
+	);
+
+	if (mod.aliases?.length) {
+		lines.push(`${DIM}Aliases: ${mod.aliases.join(", ")}${RESET}`);
+	}
+
+	lines.push("");
+	lines.push(`${GREEN}Usage:${RESET}`);
+	if (mod.params.length) {
+		for (const p of mod.params) {
+			lines.push(`  ${mod.name} ${p}`);
+		}
+	} else {
+		lines.push(`  ${mod.name}`);
+	}
+
+	const catLabel =
+		CATEGORY_LABELS[mod.category ?? "misc"] ?? mod.category ?? "misc";
+	lines.push("");
+	lines.push(`${DIM}Category: ${catLabel}${RESET}`);
+
+	return lines.join("\n");
+}
+
+// ─── export ───────────────────────────────────────────────────────────────────
+
 export function createHelpCommand(_getNames: () => string[]): ShellModule {
 	return {
 		name: "help",
-		description: "Display this help message",
+		description: "List all commands, or show usage for a specific command",
 		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`);
-
-				const sorted = [...mods].sort((a, b) => a.name.localeCompare(b.name));
-				for (const mod of sorted) {
-					lines.push(`  \x1b[36m${padRight(mod.name, 14)}\x1b[0m ${mod.description ?? ""}`);
+				const target = args[0].toLowerCase();
+				const mod = modules.find(
+					(m) => m.name === target || m.aliases?.includes(target),
+				);
+				if (!mod) {
+					return {
+						stderr: `help: no help entry for '${args[0]}'`,
+						exitCode: 1,
+					};
 				}
+				return { stdout: renderDetail(mod), exitCode: 0 };
 			}
 
-		return { stdout: lines.join("\n"), exitCode: 0 };
+			return { stdout: renderFull(modules), exitCode: 0 };
 		},
 	};
 }

package/src/commands/helpers.ts

@@ -1,6 +1,8 @@
 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"] as const;
 
@@ -220,3 +222,9 @@ export function joinListWithType(
 		})
 		.join("  ");
 }
+
+export function getPackageManager(
+	shell: VirtualShell,
+): VirtualPackageManager | undefined {
+	return shell.packageManager;
+}

package/src/commands/history.ts

@@ -0,0 +1,34 @@
+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 }) => {
+		// History is persisted in the VFS by the interactive shell
+		const histPath = "/virtual-env-js/.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,5 +1,10 @@
 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",

package/src/commands/id.ts

@@ -11,6 +11,9 @@ export const idCommand: ShellModule = {
 		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 };
+		return {
+			stdout: `uid=${uid}(${target}) gid=${gid}(${target}) groups=${groups}`,
+			exitCode: 0,
+		};
 	},
 };

package/src/commands/index.ts

@@ -1,255 +1,9 @@
-/** biome-ignore-all lint/style/useNamingConvention: ENV VARIABLES */
-import type { VirtualShell } from "../VirtualShell";
-import type {
-	CommandContext,
-	CommandMode,
-	CommandResult,
-	ShellEnv,
-	ShellModule,
-} from "../types/commands";
-import { adduserCommand } from "./adduser";
-import { awkCommand } from "./awk";
-import { base64Command } from "./base64";
-import { catCommand } from "./cat";
-import { cdCommand } from "./cd";
-import { chmodCommand } from "./chmod";
-import { clearCommand } from "./clear";
-import { cpCommand } from "./cp";
-import { curlCommand } from "./curl";
-import { cutCommand } from "./cut";
-import { dateCommand } from "./date";
-import { deluserCommand } from "./deluser";
-import { dfCommand } from "./df";
-import { diffCommand } from "./diff";
-import { duCommand } from "./du";
-import { echoCommand } from "./echo";
-import { envCommand } from "./env";
-import { exitCommand } from "./exit";
-import { exportCommand } from "./export";
-import { findCommand } from "./find";
-import { grepCommand } from "./grep";
-import { groupsCommand } from "./groups";
-import { gunzipCommand, gzipCommand } from "./gzip";
-import { headCommand } from "./head";
-import { createHelpCommand } from "./help";
-import { hostnameCommand } from "./hostname";
-import { htopCommand } from "./htop";
-import { idCommand } from "./id";
-import { killCommand } from "./kill";
-import { lnCommand } from "./ln";
-import { lsCommand } from "./ls";
-import { mkdirCommand } from "./mkdir";
-import { mvCommand } from "./mv";
-import { nanoCommand } from "./nano";
-import { neofetchCommand } from "./neofetch";
-import { passwdCommand } from "./passwd";
-import { pingCommand } from "./ping";
-import { psCommand } from "./ps";
-import { pwdCommand } from "./pwd";
-import { rmCommand } from "./rm";
-import { sedCommand } from "./sed";
-import { setCommand } from "./set";
-import { shCommand } from "./sh";
-import { sleepCommand } from "./sleep";
-import { sortCommand } from "./sort";
-import { suCommand } from "./su";
-import { sudoCommand } from "./sudo";
-import { tailCommand } from "./tail";
-import { tarCommand } from "./tar";
-import { teeCommand } from "./tee";
-import { touchCommand } from "./touch";
-import { trCommand } from "./tr";
-import { treeCommand } from "./tree";
-import { unameCommand } from "./uname";
-import { uniqCommand } from "./uniq";
-import { unsetCommand } from "./unset";
-import { wcCommand } from "./wc";
-import { wgetCommand } from "./wget";
-import { whoCommand } from "./who";
-import { whoamiCommand } from "./whoami";
-import { xargsCommand } from "./xargs";
-
-const BASE_COMMANDS: ShellModule[] = [
-	// Navigation
-	pwdCommand, cdCommand, lsCommand, treeCommand,
-	// Files
-	catCommand, touchCommand, rmCommand, mkdirCommand, cpCommand, mvCommand, lnCommand,
-	chmodCommand, findCommand,
-	// Text processing
-	grepCommand, sedCommand, awkCommand, sortCommand, uniqCommand, wcCommand,
-	headCommand, tailCommand, cutCommand, trCommand, teeCommand, xargsCommand,
-	diffCommand,
-	// Archives
-	tarCommand, gzipCommand, gunzipCommand, base64Command,
-	// System info
-	whoamiCommand, whoCommand, hostnameCommand, idCommand, groupsCommand, unameCommand,
-	psCommand, killCommand, dfCommand, duCommand, dateCommand, sleepCommand, pingCommand,
-	// Shell
-	echoCommand, envCommand, exportCommand, setCommand, unsetCommand, shCommand,
-	clearCommand, exitCommand,
-	// Editors
-	nanoCommand, htopCommand,
-	// Network
-	curlCommand, wgetCommand,
-	// Users
-	adduserCommand, passwdCommand, deluserCommand, sudoCommand, suCommand,
-	// Misc
-	neofetchCommand,
-];
-
-const customCommands: ShellModule[] = [];
-const commandRegistry = new Map<string, ShellModule>();
-let cachedCommandNames: string[] | null = null;
-
-const helpCommand = createHelpCommand(() => getCommandModules().map((cmd) => cmd.name));
-
-function buildCache(): void {
-	commandRegistry.clear();
-	for (const mod of getCommandModules()) {
-		commandRegistry.set(mod.name, mod);
-		for (const alias of mod.aliases ?? []) commandRegistry.set(alias, mod);
-	}
-	cachedCommandNames = Array.from(commandRegistry.keys()).sort();
-}
-
-function getCommandModules(): ShellModule[] {
-	return [...BASE_COMMANDS, ...customCommands, helpCommand];
-}
-
-export function registerCommand(module: ShellModule): void {
-	const normalized: ShellModule = {
-		...module,
-		name: module.name.trim().toLowerCase(),
-		aliases: module.aliases?.map((a) => a.trim().toLowerCase()),
-	};
-	const names = [normalized.name, ...(normalized.aliases ?? [])];
-	if (names.some((n) => n.length === 0 || /\s/.test(n))) {
-		throw new Error("Command names must be non-empty and contain no spaces");
-	}
-	customCommands.push(normalized);
-	buildCache();
-}
-
-export function createCustomCommand(
-	name: string,
-	params: string[],
-	run: (ctx: CommandContext) => CommandResult | Promise<CommandResult>,
-): ShellModule {
-	return { name, params, run };
-}
-
-export function getCommandNames(): string[] {
-	if (!cachedCommandNames) buildCache();
-	return cachedCommandNames!;
-}
-
-export function getCommandModulesPublic(): ShellModule[] {
-	return getCommandModules();
-}
-
-export function resolveModule(name: string): ShellModule | undefined {
-	if (!cachedCommandNames) buildCache();
-	return commandRegistry.get(name.toLowerCase());
-}
-
-function splitArgsRespectingQuotes(input: string): string[] {
-	const tokens: string[] = [];
-	let current = "";
-	let inQuotes = false;
-	let quoteChar = "";
-
-	for (let i = 0; i < input.length; i++) {
-		const ch = input[i] || "";
-		const prev = i > 0 ? input[i - 1] : "";
-		if ((ch === '"' || ch === "'") && prev !== "\\") {
-			if (!inQuotes) { inQuotes = true; quoteChar = ch; continue; }
-			if (ch === quoteChar) { inQuotes = false; quoteChar = ""; continue; }
-		}
-		if (/\s/.test(ch) && !inQuotes) {
-			if (current.length > 0) { tokens.push(current); current = ""; }
-			continue;
-		}
-		current += ch;
-	}
-	if (current.length > 0) tokens.push(current);
-	return tokens;
-}
-
-function parseInput(rawInput: string): { commandName: string; args: string[] } {
-	const parts = splitArgsRespectingQuotes(rawInput.trim());
-	return { commandName: parts[0]?.toLowerCase() ?? "", args: parts.slice(1) };
-}
-
-export function makeDefaultEnv(authUser: string, hostname: string): ShellEnv {
-	return {
-		vars: {
-			PATH: "/usr/local/bin:/usr/bin:/bin",
-			HOME: `/home/${authUser}`,
-			USER: authUser,
-			LOGNAME: authUser,
-			SHELL: "/bin/sh",
-			TERM: "xterm-256color",
-			HOSTNAME: hostname,
-			PS1: "\\u@\\h:\\w\\$ ",
-		},
-		lastExitCode: 0,
-	};
-}
-
-export async function runCommand(
-	rawInput: string,
-	authUser: string,
-	hostname: string,
-	mode: CommandMode,
-	cwd: string,
-	shell: VirtualShell,
-	stdin?: string,
-	env?: ShellEnv,
-): Promise<CommandResult> {
-	const trimmed = rawInput.trim();
-	if (trimmed.length === 0) return { exitCode: 0 };
-
-	const shellEnv: ShellEnv = env ?? makeDefaultEnv(authUser, hostname);
-
-	// Detect shell operators
-	if (
-		/(?<![|&])[|](?![|])/.test(trimmed) ||
-		trimmed.includes(">") ||
-		trimmed.includes("<") ||
-		trimmed.includes("&&") ||
-		trimmed.includes("||") ||
-		trimmed.includes(";")
-	) {
-		const { parseScript } = await import("../VirtualShell/shellParser");
-		const { executeStatements } = await import("../SSHMimic/executor");
-		const script = parseScript(trimmed);
-		if (!script.isValid) return { stderr: script.error || "Syntax error", exitCode: 1 };
-		try {
-			return await executeStatements(script.statements, authUser, hostname, mode, cwd, shell, shellEnv);
-		} catch (error: unknown) {
-			return { stderr: error instanceof Error ? error.message : "Execution failed", exitCode: 1 };
-		}
-	}
-
-	const { commandName, args } = parseInput(trimmed);
-	const mod = resolveModule(commandName);
-
-	if (!mod) return { stderr: `${commandName}: command not found`, exitCode: 127 };
-
-	try {
-		return await mod.run({
-			authUser,
-			hostname,
-			activeSessions: shell.users.listActiveSessions(),
-			rawInput: trimmed,
-			mode,
-			args,
-			stdin,
-			cwd,
-			shell,
-			env: shellEnv,
-		});
-	} catch (error: unknown) {
-		return { stderr: error instanceof Error ? error.message : "Command failed", exitCode: 1 };
-	}
-}
+export {
+	createCustomCommand,
+	getCommandModulesPublic,
+	getCommandNames,
+	registerCommand,
+	resolveModule
+} from "./registry";
+
+export { makeDefaultEnv, runCommand, runCommandDirect } from "./runtime";