typescript-virtual-container 1.0.5 → 1.0.7

package/modules/neofetch.ts

@@ -0,0 +1,354 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import type { ShellProperties } from "../src/VirtualShell";
+
+function formatUptime(seconds: number): string {
+	const totalMinutes = Math.max(1, Math.floor(seconds / 60));
+	const days = Math.floor(totalMinutes / (24 * 60));
+	const hours = Math.floor((totalMinutes % (24 * 60)) / 60);
+	const minutes = totalMinutes % 60;
+
+	const parts: string[] = [];
+	if (days > 0) {
+		parts.push(`${days} day${days > 1 ? "s" : ""}`);
+	}
+	if (hours > 0) {
+		parts.push(`${hours} hour${hours > 1 ? "s" : ""}`);
+	}
+	if (minutes > 0 || parts.length === 0) {
+		parts.push(`${minutes} min${minutes > 1 ? "s" : ""}`);
+	}
+
+	return parts.join(", ");
+}
+
+function colorBlock(code: number): string {
+	return `\u001b[${code}m   \u001b[0m`;
+}
+
+function buildColorBars(): string[] {
+	const normal = [40, 41, 42, 43, 44, 45, 46, 47].map(colorBlock).join("");
+	const bright = [100, 101, 102, 103, 104, 105, 106, 107]
+		.map(colorBlock)
+		.join("");
+	return [normal, bright];
+}
+
+function colorizeLogoLine(line: string, index: number, total: number): string {
+	if (line.trim().length === 0) {
+		return line;
+	}
+
+	const start = { r: 255, g: 255, b: 255 };
+	const end = { r: 168, g: 85, b: 247 };
+	const ratio = total <= 1 ? 0 : index / (total - 1);
+
+	const r = Math.round(start.r + (end.r - start.r) * ratio);
+	const g = Math.round(start.g + (end.g - start.g) * ratio);
+	const b = Math.round(start.b + (end.b - start.b) * ratio);
+
+	return `\u001b[38;2;${r};${g};${b}m${line}\u001b[0m`;
+}
+
+function colorizeDetailLine(line: string): string {
+	if (line.trim().length === 0) {
+		return line;
+	}
+
+	const colonIndex = line.indexOf(':');
+
+	if (colonIndex === -1) {
+		// Pas de ':', chercher '@' pour identifier user@host
+		if (line.includes('@')) {
+			// C'est user@host, appliquer dégradé horizontal
+			return applyHorizontalGradient(line);
+		}
+		// Sinon c'est un separator ou autre, laisser tel quel
+		return line;
+	}
+
+	// Il y a un ':', c'est titre: valeur
+	const title = line.substring(0, colonIndex + 1);
+	const value = line.substring(colonIndex + 1);
+
+	// Appliquer le dégradé seulement au titre
+	const colorized = applyHorizontalGradient(title);
+	return colorized + value;
+}
+
+function applyHorizontalGradient(text: string): string {
+	// Nettoyer les codes ANSI existants
+	const ansiRegex = new RegExp(`${String.fromCharCode(27)}\\[[\\d;]*m`, 'g');
+	const cleaned = text.replace(ansiRegex, '');
+
+	if (cleaned.trim().length === 0) {
+		return text;
+	}
+
+	const start = { r: 255, g: 255, b: 255 };
+	const end = { r: 168, g: 85, b: 247 };
+	let result = '';
+
+	for (let i = 0; i < cleaned.length; i += 1) {
+		const ratio = cleaned.length <= 1 ? 0 : i / (cleaned.length - 1);
+
+		const r = Math.round(start.r + (end.r - start.r) * ratio);
+		const g = Math.round(start.g + (end.g - start.g) * ratio);
+		const b = Math.round(start.b + (end.b - start.b) * ratio);
+
+		result += `\u001b[38;2;${r};${g};${b}m${cleaned[i]}\u001b[0m`;
+	}
+
+	return result;
+}
+
+export interface NeofetchInfo {
+	user: string;
+	host: string;
+	osName?: string;
+	kernel?: string;
+	uptimeSeconds?: number;
+	packages?: string;
+	shell?: string;
+    shellProps?: ShellProperties;
+	resolution?: string;
+	terminal?: string;
+	cpu?: string;
+	gpu?: string;
+	memoryUsedMiB?: number;
+	memoryTotalMiB?: number;
+}
+
+function toMiB(bytes: number): number {
+	return Math.max(0, Math.round(bytes / (1024 * 1024)));
+}
+
+function readOsPrettyName(): string | undefined {
+	try {
+		const data = readFileSync("/etc/os-release", "utf8");
+		for (const line of data.split("\n")) {
+			if (!line.startsWith("PRETTY_NAME=")) {
+				continue;
+			}
+
+			const value = line.slice("PRETTY_NAME=".length).trim();
+			return value.replace(/^"|"$/g, "");
+		}
+	} catch {
+		return undefined;
+	}
+
+	return undefined;
+}
+
+function readFirstLine(filePath: string): string | undefined {
+	try {
+		const data = readFileSync(filePath, "utf8").split("\n")[0]?.trim();
+		if (!data || data.length === 0) {
+			return undefined;
+		}
+		return data;
+	} catch {
+		return undefined;
+	}
+}
+
+function resolveHostLabel(fallback: string): string {
+	const vendor = readFirstLine("/sys/devices/virtual/dmi/id/sys_vendor");
+	const product = readFirstLine("/sys/devices/virtual/dmi/id/product_name");
+
+	if (vendor && product) {
+		return `${vendor} ${product}`;
+	}
+	if (product) {
+		return product;
+	}
+
+	return fallback;
+}
+
+function countDpkgPackages(): number | undefined {
+	const candidates = ["/var/lib/dpkg/status", "/usr/local/var/lib/dpkg/status"];
+
+	for (const filePath of candidates) {
+		if (!existsSync(filePath)) {
+			continue;
+		}
+
+		try {
+			const data = readFileSync(filePath, "utf8");
+			const matches = data.match(/^Package:\s+/gm);
+			return matches?.length ?? 0;
+		} catch {
+		}
+	}
+
+	return undefined;
+}
+
+function countSnapPackages(): number | undefined {
+	const candidates = ["/snap", "/var/lib/snapd/snaps"];
+
+	for (const dirPath of candidates) {
+		if (!existsSync(dirPath)) {
+			continue;
+		}
+
+		try {
+			const entries = readdirSync(dirPath, { withFileTypes: true });
+			const count = entries.filter((entry) => entry.isDirectory()).length;
+			return count;
+		} catch {
+		}
+	}
+
+	return undefined;
+}
+
+function resolvePackagesLabel(): string {
+	const dpkgCount = countDpkgPackages();
+	const snapCount = countSnapPackages();
+
+	if (dpkgCount !== undefined && snapCount !== undefined) {
+		return `${dpkgCount} (dpkg), ${snapCount} (snap)`;
+	}
+	if (dpkgCount !== undefined) {
+		return `${dpkgCount} (dpkg)`;
+	}
+	if (snapCount !== undefined) {
+		return `${snapCount} (snap)`;
+	}
+
+	return "n/a";
+}
+
+function resolveCpuLabel(): string {
+	const cpus = os.cpus();
+	if (cpus.length === 0) {
+		return "unknown";
+	}
+
+	const first = cpus[0];
+	if (!first) {
+		return "unknown";
+	}
+
+	const ghz = (first.speed / 1000).toFixed(2);
+	return `${first.model} (${cpus.length}) @ ${ghz}GHz`;
+}
+
+function resolveShellLabel(shell?: string): string {
+	if (!shell || shell.trim().length === 0) {
+		return "unknown";
+	}
+
+	return path.posix.basename(shell.trim());
+}
+
+function resolveDefaults(info: NeofetchInfo): Required<NeofetchInfo> {
+	const totalMem = os.totalmem();
+	const freeMem = os.freemem();
+	const usedMem = Math.max(0, totalMem - freeMem);
+    const shellProps = info.shellProps;
+
+    const processUptime = process.uptime();
+    if (info.uptimeSeconds === undefined) {
+        info.uptimeSeconds = Math.round(processUptime);
+    }
+
+    console.log("Resolving neofetch info with shellProps:", shellProps);
+
+	return {
+		user: info.user,
+		host: info.host,
+		osName: shellProps?.os ?? info.osName ?? `${readOsPrettyName() ?? os.type()} ${os.arch()}`,
+		kernel: shellProps?.kernel ?? info.kernel ?? os.release(),
+		uptimeSeconds: info.uptimeSeconds ?? os.uptime(),
+		packages: info.packages ?? resolvePackagesLabel(),
+		shell: resolveShellLabel(info.shell),
+		shellProps: info.shellProps as ShellProperties ?? {
+            kernel: info.kernel ?? os.release(),
+            os: info.osName ?? `${readOsPrettyName() ?? os.type()} ${os.arch()}`,
+            arch: os.arch(),
+        },
+		resolution: info.resolution ?? "n/a (ssh)",
+		terminal: info.terminal ?? "unknown",
+		cpu: info.cpu ?? resolveCpuLabel(),
+		gpu: info.gpu ?? "n/a",
+		memoryUsedMiB: info.memoryUsedMiB ?? toMiB(usedMem),
+		memoryTotalMiB: info.memoryTotalMiB ?? toMiB(totalMem),
+	};
+}
+
+export function buildNeofetchOutput(info: NeofetchInfo): string {
+	const fields = resolveDefaults(info);
+	const uptime = formatUptime(fields.uptimeSeconds);
+	const colorBars = buildColorBars();
+
+	const distroLogo = [
+        "                               .. .:.    ",
+        " .::..                       ..     ..   ",
+        ".    ....                  ...       ..  ",
+        ":       ....             .:.          .. ",
+        ":           .:.:........:.            .. ",
+        ":                                     .. ",
+        ".                                      : ",
+        ".                                      : ",
+        "..                                     : ",
+        " :.                                   .. ",
+        " ..                                   .. ",
+        " :-.                                  :: ",
+        "  .:.                                 :. ",
+        "   ..:                               ... ",
+        "   ..:                               :.. ",
+        "  :...                              :....",
+        "   ..                                ....",
+        "   .                                  .. ",
+        "  .:.                                 .: ",
+        "  :.                                  .. ",
+        " ::.                                 ..  ",
+        ".....                          ..:...    ",
+        "...:.                         ..         ",
+        ".:...:.       ::.           ..           ",
+        "  ... ..:::::..  ..:::::::..             ",
+    ]
+
+	const details = [
+		`${fields.user}@${fields.host}`,
+		"-------------------------",
+		`OS: ${fields.osName}`,
+		`Host: ${resolveHostLabel(fields.host)}`,
+		`Kernel: ${fields.kernel}`,
+		`Uptime: ${uptime}`,
+		// `Packages: ${fields.packages}`,
+		`Shell: ${fields.shell}`,
+		// `Shell Props: ${fields.shellProps}`,
+		`Resolution: ${fields.resolution}`,
+		`Terminal: ${fields.terminal}`,
+		`CPU: ${fields.cpu}`,
+		`GPU: ${fields.gpu}`,
+		`Memory: ${fields.memoryUsedMiB}MiB / ${fields.memoryTotalMiB}MiB`,
+		"",
+		colorBars[0],
+		colorBars[1],
+	];
+
+	const width = Math.max(distroLogo.length, details.length);
+	const lines: string[] = [];
+
+	for (let i = 0; i < width; i += 1) {
+		const rawLeft = distroLogo[i] ?? "";
+		const right = details[i] ?? "";
+		if (right.length > 0) {
+			const left = colorizeLogoLine(rawLeft.padEnd(31, " "), i, distroLogo.length);
+			const coloredRight = colorizeDetailLine(right);
+			lines.push(`${left}  ${coloredRight}`);
+			continue;
+		}
+
+		lines.push(colorizeLogoLine(rawLeft, i, distroLogo.length));
+	}
+
+	return lines.join("\n");
+}

package/package.json

@@ -3,7 +3,7 @@
   "description": "In-memory SSH server with virtual filesystem and typed programmatic API",
   "module": "src/index.ts",
   "type": "module",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "license": "MIT",
   "keywords": [
     "ssh",

package/src/SSHMimic/exec.ts

@@ -1,5 +1,6 @@
 import type { ExecStream } from "../types/streams";
 import type VirtualFileSystem from "../VirtualFileSystem";
+import { defaultShellProperties } from "../VirtualShell";
 import { runCommand } from "../VirtualShell/commands";
 import type { VirtualUserManager } from "./users";
 
@@ -26,6 +27,7 @@ export function runExec(
 			users,
 			"exec",
 			`/home/${authUser}`,
+			defaultShellProperties,
 			vfs,
 		),
 	).then((result) => {

package/src/SSHMimic/executor.ts

@@ -1,6 +1,7 @@
 import type { CommandMode, CommandResult } from "../types/commands";
 import type { Pipeline, PipelineCommand } from "../types/pipeline";
 import type VirtualFileSystem from "../VirtualFileSystem";
+import { defaultShellProperties } from "../VirtualShell";
 import { runCommand as runSingleCommand } from "../VirtualShell/commands";
 import { resolvePath } from "../VirtualShell/commands/helpers";
 import type { VirtualUserManager } from "./users";
@@ -84,6 +85,7 @@ async function executeSingleCommandWithRedirections(
 		users,
 		mode,
 		cwd,
+		defaultShellProperties,
 		vfs,
 		stdin,
 	);
@@ -159,6 +161,7 @@ async function executePipelineChain(
 			users,
 			mode,
 			cwd,
+			defaultShellProperties,
 			vfs,
 			currentOutput,
 		);

package/src/VirtualShell/commands/index.ts

@@ -1,3 +1,4 @@
+import type { ShellProperties } from "..";
 import type { VirtualUserManager } from "../../SSHMimic/users";
 import type {
 	CommandContext,
@@ -24,6 +25,7 @@ import { htopCommand } from "./htop";
 import { lsCommand } from "./ls";
 import { mkdirCommand } from "./mkdir";
 import { nanoCommand } from "./nano";
+import { neofetchCommand } from "./neofetch";
 import { pwdCommand } from "./pwd";
 import { rmCommand } from "./rm";
 import { setCommand } from "./set";
@@ -51,6 +53,7 @@ const BASE_COMMANDS: ShellModule[] = [
 	rmCommand,
 	treeCommand,
 	nanoCommand,
+	neofetchCommand,
 	htopCommand,
 	adduserCommand,
 	deluserCommand,
@@ -196,6 +199,7 @@ async function runCommandInternal(
 	users: VirtualUserManager,
 	mode: CommandMode,
 	cwd: string,
+	shellProps: ShellProperties,
 	vfs: VirtualFileSystem,
 	stdin?: string,
 ): Promise<CommandResult> {
@@ -254,6 +258,7 @@ async function runCommandInternal(
 			rawInput,
 			mode,
 			args,
+			shellProps,
 			stdin,
 			cwd,
 			vfs,
@@ -273,6 +278,7 @@ export function runCommand(
 	users: VirtualUserManager,
 	mode: CommandMode,
 	cwd: string,
+	shellProps: ShellProperties,
 	vfs: VirtualFileSystem,
 	stdin?: string,
 ): CommandOutcome {
@@ -291,6 +297,7 @@ export function runCommand(
 			users,
 			mode,
 			cwd,
+			shellProps,
 			vfs,
 			stdin,
 		);
@@ -319,6 +326,7 @@ export function runCommand(
 			stdin,
 			cwd,
 			vfs,
+			shellProps,
 		});
 	} catch (error: unknown) {
 		const message = error instanceof Error ? error.message : "Command failed";

package/src/VirtualShell/commands/neofetch.ts

@@ -0,0 +1,37 @@
+import { buildNeofetchOutput } from "../../../modules/neofetch";
+import type { ShellModule } from "../../types/commands";
+import { ifFlag } from "./command-helpers";
+import { getAllEnvVars } from "./set";
+
+export const neofetchCommand: ShellModule = {
+	name: "neofetch",
+	params: ["[--off]"],
+	run: ({ args, authUser, hostname, shellProps }) => {
+		const env = getAllEnvVars(authUser);
+
+		if (ifFlag(args, "--help")) {
+			return {
+				stdout: "Usage: neofetch [--off]",
+				exitCode: 0,
+			};
+		}
+
+		if (ifFlag(args, "--off")) {
+			return {
+				stdout: `${authUser}@${hostname}`,
+				exitCode: 0,
+			};
+		}
+
+		return {
+			stdout: buildNeofetchOutput({
+				user: authUser,
+				host: hostname,
+				shell: env.SHELL,
+				shellProps: shellProps,
+				terminal: env.TERM,
+			}),
+			exitCode: 0,
+		};
+	},
+};

package/src/VirtualShell/commands/sh.ts

@@ -1,3 +1,4 @@
+import { defaultShellProperties } from "..";
 import type { CommandContext, ShellModule } from "../../types/commands";
 import { getArg, getFlag } from "./command-helpers";
 import { runCommand } from "./index";
@@ -38,7 +39,16 @@ export const shCommand: ShellModule = {
 
 				// Execute the command
 				const result = await Promise.resolve(
-					runCommand(command, authUser, hostname, users, mode, cwd, vfs),
+					runCommand(
+						command,
+						authUser,
+						hostname,
+						users,
+						mode,
+						cwd,
+						defaultShellProperties,
+						vfs,
+					),
 				);
 
 				if (result.stdout) {

package/src/VirtualShell/commands/sudo.ts

@@ -1,3 +1,4 @@
+import { defaultShellProperties } from "..";
 import type { ShellModule } from "../../types/commands";
 import { getArg, getFlag, ifFlag } from "./command-helpers";
 import { runCommand } from "./index";
@@ -62,6 +63,7 @@ export const sudoCommand: ShellModule = {
 				users,
 				mode,
 				loginShell ? `/home/${effectiveUser}` : cwd,
+				defaultShellProperties,
 				vfs,
 			);
 		}

package/src/VirtualShell/index.ts

@@ -5,19 +5,34 @@ import type VirtualFileSystem from "../VirtualFileSystem";
 import { createCustomCommand, registerCommand, runCommand } from "./commands";
 import { startShell } from "./shell";
 
+export interface ShellProperties {
+	kernel: string;
+	os: "Fortune GNU/Linux x64";
+	arch: "x86_64";
+}
+
+export const defaultShellProperties: ShellProperties = {
+	kernel: "1.0.0+itsrealfortune+1-amd64",
+	os: "Fortune GNU/Linux x64",
+	arch: "x86_64",
+};
+
 class VirtualShell {
 	private vfs: VirtualFileSystem;
 	private users: VirtualUserManager;
 	private hostname: string;
+	public properties: ShellProperties;
 
 	constructor(
 		vfs: VirtualFileSystem,
 		users: VirtualUserManager,
 		hostname: string,
+		properties?: ShellProperties,
 	) {
 		this.vfs = vfs;
 		this.users = users;
 		this.hostname = hostname;
+		this.properties = properties || defaultShellProperties;
 	}
 
 	addCommand(
@@ -41,6 +56,7 @@ class VirtualShell {
 			this.users,
 			"shell",
 			cwd,
+			this.properties,
 			this.vfs,
 		);
 	}
@@ -54,6 +70,7 @@ class VirtualShell {
 	): void {
 		// Interactive shell logic
 		startShell(
+			this.properties,
 			stream,
 			authUser,
 			this.vfs!,

package/src/VirtualShell/shell.ts

@@ -1,6 +1,7 @@
 import { type ChildProcessWithoutNullStreams, spawn } from "node:child_process";
 import { readFile, unlink, writeFile } from "node:fs/promises";
 import * as path from "node:path";
+import { defaultShellProperties, type ShellProperties } from ".";
 import { formatLoginDate } from "../SSHMimic/loginFormat";
 import { buildPrompt } from "../SSHMimic/prompt";
 import type { VirtualUserManager } from "../SSHMimic/users";
@@ -41,6 +42,7 @@ function toTtyLines(text: string): string {
 }
 
 export function startShell(
+	properties: ShellProperties,
 	stream: ShellStream,
 	authUser: string,
 	vfs: VirtualFileSystem,
@@ -180,6 +182,7 @@ export function startShell(
 				users,
 				"shell",
 				runCwd,
+				defaultShellProperties,
 				vfs,
 			),
 		);
@@ -467,20 +470,15 @@ export function startShell(
 	}
 
 	function renderLoginBanner(): void {
-		// const kernel = os.release();
-		// const arch = os.arch();
-
-		// Our own kernel and arch strings to avoid leaking host info and to provide a more "Linux-like" feel
-		const kernel = "5.15.0-1051-azure";
-		const arch = "x86_64";
-
 		const last = readLastLogin();
 		const nowIso = new Date().toISOString();
 
-		stream.write(`Linux ${hostname} ${kernel} ${arch}\r\n`);
+		stream.write(
+			`Linux ${hostname} ${properties.kernel} ${properties.arch}\r\n`,
+		);
 		stream.write("\r\n");
 		stream.write(
-			"The programs included with the Debian GNU/Linux system are free software;\r\n",
+			"The programs included with the Fortune GNU/Linux system are free software;\r\n",
 		);
 		stream.write(
 			"the exact distribution terms for each program are described in the\r\n",
@@ -488,7 +486,7 @@ export function startShell(
 		stream.write("individual files in /usr/share/doc/*/copyright.\r\n");
 		stream.write("\r\n");
 		stream.write(
-			"Debian GNU/Linux comes with ABSOLUTELY NO WARRANTY, to the extent\r\n",
+			"Fortune GNU/Linux comes with ABSOLUTELY NO WARRANTY, to the extent\r\n",
 		);
 		stream.write("permitted by applicable law.\r\n");
 
@@ -649,7 +647,16 @@ export function startShell(
 
 				if (line.length > 0) {
 					const result = await Promise.resolve(
-						runCommand(line, authUser, hostname, users, "shell", cwd, vfs),
+						runCommand(
+							line,
+							authUser,
+							hostname,
+							users,
+							"shell",
+							cwd,
+							defaultShellProperties,
+							vfs,
+						),
 					);
 
 					pushHistory(line);

package/src/types/commands.ts

@@ -6,6 +6,7 @@ import type {
 	VirtualUserManager,
 } from "../SSHMimic/users";
 import type VirtualFileSystem from "../VirtualFileSystem";
+import type { ShellProperties } from "../VirtualShell";
 
 /**
  * Normalized command execution output.
@@ -76,6 +77,8 @@ export interface CommandContext {
 	mode: CommandMode;
 	/** Tokenized arguments excluding command name. */
 	args: string[];
+	/** Virtual shell instance. */
+	shellProps: ShellProperties;
 	/** Optional stdin payload (used by pipes/redirections). */
 	stdin?: string;
 	/** Current working directory for command execution. */