typescript-virtual-container 1.2.9 → 1.3.1

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/history.ts

@@ -1,5 +1,10 @@
 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",
@@ -20,8 +25,8 @@ export const historyCommand: ShellModule = {
 		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}`
+		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,360 +1,9 @@
-/** biome-ignore-all lint/style/useNamingConvention: ENV VARIABLES */
-import { executeStatements } from "../SSHMimic/executor";
-import type { VirtualShell } from "../VirtualShell";
-import { parseScript } from "../VirtualShell/shellParser";
-import type {
-	CommandContext,
-	CommandMode,
-	CommandResult,
-	ShellEnv,
-	ShellModule,
-} from "../types/commands";
-import { adduserCommand } from "./adduser";
-import { aliasCommand, unaliasCommand } from "./alias";
-import { testCommand } from "./test";
-import { sourceCommand } from "./source";
-import { historyCommand } from "./history";
-import { aptCacheCommand, aptCommand } from "./apt";
-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 { dpkgCommand, dpkgQueryCommand } from "./dpkg";
-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 { freeCommand } from "./free";
-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 { lsbReleaseCommand } from "./lsb-release";
-import { manCommand } from "./man";
-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 { typeCommand } from "./type";
-import { unameCommand } from "./uname";
-import { uniqCommand } from "./uniq";
-import { unsetCommand } from "./unset";
-import { uptimeCommand } from "./uptime";
-import { wcCommand } from "./wc";
-import { wgetCommand } from "./wget";
-import { whichCommand } from "./which";
-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,
-	// Package management
-	aptCommand, aptCacheCommand, dpkgCommand, dpkgQueryCommand,
-	// Shell (extended)
-	whichCommand, typeCommand, manCommand, aliasCommand, unaliasCommand,
-	testCommand, sourceCommand, historyCommand,
-	// System (extended)
-	uptimeCommand, freeCommand, lsbReleaseCommand,
-];
-
-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,
-	};
-}
-
-/**
- * Execute a pre-parsed command directly by name and argument list.
- *
- * Unlike `runCommand`, this function does NOT re-join name+args into a string
- * and re-parse — so arguments that contain special characters (`;`, `|`, `>`,
- * quotes) are passed through verbatim. Use this from the pipeline executor.
- */
-export async function runCommandDirect(
-	name: string,
-	args: string[],
-	authUser: string,
-	hostname: string,
-	mode: CommandMode,
-	cwd: string,
-	shell: VirtualShell,
-	stdin: string | undefined,
-	env: ShellEnv,
-): Promise<CommandResult> {
-	// Alias expansion on the command name
-	const aliasVal = env.vars[`__alias_${name}`];
-	if (aliasVal) {
-		// Alias may expand to a multi-word command — re-route through runCommand
-		return runCommand(`${aliasVal} ${args.join(" ")}`, authUser, hostname, mode, cwd, shell, stdin, env);
-	}
-
-	const mod = resolveModule(name);
-	if (!mod) return { stderr: `${name}: command not found`, exitCode: 127 };
-
-	try {
-		return await mod.run({
-			authUser,
-			hostname,
-			activeSessions: shell.users.listActiveSessions(),
-			rawInput: [name, ...args].join(" "),
-			mode,
-			args,
-			stdin,
-			cwd,
-			shell,
-			env,
-		});
-	} catch (error: unknown) {
-		return { stderr: error instanceof Error ? error.message : "Command failed", exitCode: 1 };
-	}
-}
-
-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);
-
-	// ── $(cmd) command substitution ──────────────────────────────────────────
-	let expanded = trimmed;
-	if (expanded.includes("$(")) {
-		// Only substitute $(…) that are NOT inside single quotes
-		// Strategy: walk char by char, track single-quote state
-		let result = "";
-		let inSingle = false;
-		let i = 0;
-		while (i < expanded.length) {
-			const ch = expanded[i]!;
-			if (ch === "'" && !inSingle) { inSingle = true; result += ch; i++; continue; }
-			if (ch === "'" && inSingle)  { inSingle = false; result += ch; i++; continue; }
-			if (!inSingle && ch === "$" && expanded[i + 1] === "(") {
-				// Find matching closing )
-				let depth = 0;
-				let j = i + 1;
-				while (j < expanded.length) {
-					if (expanded[j] === "(") depth++;
-					else if (expanded[j] === ")") { depth--; if (depth === 0) break; }
-					j++;
-				}
-				const sub = expanded.slice(i + 2, j).trim();
-				const subResult = await runCommand(sub, authUser, hostname, mode, cwd, shell, undefined, shellEnv);
-				const subOut = (subResult.stdout ?? "").replace(/\n$/, "");
-				result += subOut;
-				i = j + 1;
-				continue;
-			}
-			result += ch; i++;
-		}
-		expanded = result;
-	}
-
-	// ── alias expansion ───────────────────────────────────────────────────────
-	const firstWord = expanded.split(/\s+/)[0] ?? "";
-	const aliasVal = shellEnv.vars[`__alias_${firstWord}`];
-	if (aliasVal) {
-		expanded = expanded.replace(firstWord, aliasVal);
-	}
-
-	// Detect shell operators
-	if (
-		/(?<![|&])[|](?![|])/.test(expanded) ||
-		expanded.includes(">") ||
-		expanded.includes("<") ||
-		expanded.includes("&&") ||
-		expanded.includes("||") ||
-		expanded.includes(";")
-	) {
-		const script = parseScript(expanded);
-		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(expanded);
-	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: expanded,
-			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";

package/src/commands/ls.ts

@@ -32,9 +32,11 @@ export const lsCommand: ShellModule = {
 	category: "navigation",
 	params: ["[-la] [path]"],
 	run: ({ authUser, shell, cwd, args }) => {
-		const longFormat  = ifFlag(args, ["-l", "--long"]);
-		const showHidden  = ifFlag(args, ["-a", "--all"]);
-		const targetArg   = getArg(args, 0, { flags: ["-l", "--long", "-a", "--all", "-la", "-al"] });
+		const longFormat = ifFlag(args, ["-l", "--long"]);
+		const showHidden = ifFlag(args, ["-a", "--all"]);
+		const targetArg = getArg(args, 0, {
+			flags: ["-l", "--long", "-a", "--all", "-la", "-al"],
+		});
 		const target = resolvePath(cwd, targetArg ?? cwd);
 		assertPathAccess(authUser, target, "ls");
 		const items = shell.vfs

package/src/commands/lsb-release.ts

@@ -15,11 +15,17 @@ export const lsbReleaseCommand: ShellModule = {
 			const content = shell.vfs.readFile("/etc/os-release");
 			for (const line of content.split("\n")) {
 				if (line.startsWith("PRETTY_NAME="))
-					osName = line.slice("PRETTY_NAME=".length).replace(/^"|"$/g, "").trim();
+					osName = line
+						.slice("PRETTY_NAME=".length)
+						.replace(/^"|"$/g, "")
+						.trim();
 				if (line.startsWith("VERSION_CODENAME="))
 					codename = line.slice("VERSION_CODENAME=".length).trim();
 				if (line.startsWith("VERSION_ID="))
-					version = line.slice("VERSION_ID=".length).replace(/^"|"$/g, "").trim();
+					version = line
+						.slice("VERSION_ID=".length)
+						.replace(/^"|"$/g, "")
+						.trim();
 			}
 		} catch {}
 

package/src/commands/nano.ts

@@ -5,7 +5,7 @@ import { assertPathAccess, resolvePath } from "./helpers";
 export const nanoCommand: ShellModule = {
 	name: "nano",
 	description: "Text editor",
-	category: "shell",
+	category: "files",
 	params: ["<file>"],
 	run: ({ authUser, shell, cwd, args }) => {
 		const fileArg = args[0];

package/src/commands/neofetch.ts

@@ -6,7 +6,7 @@ import { getAllEnvVars } from "./set";
 export const neofetchCommand: ShellModule = {
 	name: "neofetch",
 	description: "System info display",
-	category: "misc",
+	category: "system",
 	params: ["[--off]"],
 	run: ({ args, authUser, hostname, shell }) => {
 		const env = getAllEnvVars(authUser);