typescript-virtual-container 1.0.4 → 1.0.6

package/CHANGELOG.md

@@ -6,6 +6,17 @@ The format is based on Keep a Changelog.
 
 ## [Unreleased]
 
+## [1.0.5] - 2026-04-15
+
+### Changed
+
+- Refactored commands to use shared argument/flag parsing helpers.
+- Improved maintainability and consistency of argument parsing across commands.
+
+### Fixed
+
+- Verified all refactored commands pass existing test cases without regressions.
+
 ## [1.0.4] - 2026-04-15
 
 ### Added

package/README.md

@@ -417,6 +417,56 @@ console.log(client.getUsername());  // Username from constructor
 
 ---
 
+### VirtualShell
+
+Encapsulates shell execution primitives used by the SSH runtime for command dispatch and interactive sessions.
+
+#### Constructor
+
+```typescript
+new VirtualShell(
+	vfs: VirtualFileSystem,
+	users: VirtualUserManager,
+	hostname: string,
+)
+```
+
+- **vfs**: Virtual filesystem instance used by shell commands.
+- **users**: User manager for authentication/session-aware command behavior.
+- **hostname**: Hostname injected into command context and prompt behavior.
+
+**Example:**
+
+```typescript
+const shell = new VirtualShell(vfs, users, "typescript-vm");
+```
+
+#### Methods
+
+##### `executeCommand(rawInput: string, authUser: string, cwd: string): void`
+
+Runs one command input in shell mode for a given user and working directory.
+
+```typescript
+shell.executeCommand("ls -la", "root", "/home/root");
+```
+
+##### `startInteractiveSession(stream: ShellStream, authUser: string, sessionId: string | null, remoteAddress: string, terminalSize: { cols: number; rows: number }): void`
+
+Starts an interactive shell session over a shell stream.
+
+```typescript
+shell.startInteractiveSession(
+	stream,
+	"root",
+	sessionId,
+	"127.0.0.1",
+	{ cols: 120, rows: 30 },
+);
+```
+
+---
+
 ### VirtualFileSystem
 
 In-memory filesystem with optional gzip compression and tar.gz persistence.

package/modules/neofetch.ts

@@ -0,0 +1,349 @@
+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;
+
+    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.4",
+  "version": "1.0.6",
   "license": "MIT",
   "keywords": [
     "ssh",

package/src/SSHMimic/client.ts

@@ -1,5 +1,5 @@
 import type { CommandResult } from "../types/commands";
-import { runCommand } from "./commands";
+import { runCommand } from "../VirtualShell/commands";
 import type { SshMimic } from "./index";
 
 /**

package/src/SSHMimic/exec.ts

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

package/src/SSHMimic/executor.ts

@@ -1,8 +1,8 @@
 import type { CommandMode, CommandResult } from "../types/commands";
 import type { Pipeline, PipelineCommand } from "../types/pipeline";
 import type VirtualFileSystem from "../VirtualFileSystem";
-import { runCommand as runSingleCommand } from "./commands";
-import { resolvePath } from "./commands/helpers";
+import { runCommand as runSingleCommand } from "../VirtualShell/commands";
+import { resolvePath } from "../VirtualShell/commands/helpers";
 import type { VirtualUserManager } from "./users";
 
 /**

package/src/SSHMimic/index.ts

@@ -1,9 +1,8 @@
 import { randomBytes } from "node:crypto";
 import { Server as SshServer } from "ssh2";
 import VirtualFileSystem from "../VirtualFileSystem";
-import { runExec } from "./exec";
+import { VirtualShell } from "../VirtualShell";
 import { loadOrCreateHostKey } from "./hostKey";
-import { startShell } from "./shell";
 import { VirtualUserManager } from "./users";
 
 function resolveRootPassword(): string {
@@ -35,12 +34,13 @@ function resolveAutoSudoForNewUsers(): boolean {
  * {@link SshMimic.stop} when your process exits.
  */
 class SshMimic {
-	private port: number;
-	private hostname: string;
-	private server: SshServer | null;
-	private vfs: VirtualFileSystem | null = null;
-	private users: VirtualUserManager | null = null;
-	private basePath: string = ".";
+	port: number;
+	hostname: string;
+	server: SshServer | null;
+	vfs: VirtualFileSystem | null = null;
+	users: VirtualUserManager | null = null;
+	shell: VirtualShell | null = null;
+	basePath: string = ".";
 
 	/**
 	 * Creates a new SSH mimic server instance.
@@ -80,6 +80,8 @@ class SshMimic {
 		);
 		await this.users.initialize();
 
+		this.shell = new VirtualShell(this.vfs, this.users, this.hostname);
+
 		this.server = new SshServer(
 			{
 				hostKeys: [privateKey],
@@ -148,12 +150,9 @@ class SshMimic {
 
 						session.on("shell", (acceptShell) => {
 							const stream = acceptShell();
-							startShell(
+							this.shell?.startInteractiveSession(
 								stream,
 								authUser,
-								this.vfs!,
-								this.hostname,
-								this.users!,
 								sessionId,
 								remoteAddress,
 								terminalSize,
@@ -161,14 +160,11 @@ class SshMimic {
 						});
 
 						session.on("exec", (acceptExec, _rejectExec, info) => {
-							const stream = acceptExec();
-							runExec(
-								stream,
+							const _stream = acceptExec();
+							this.shell?.executeCommand(
 								info.command.trim(),
 								authUser,
-								this.hostname,
-								this.users!,
-								this.vfs!,
+								`/home/${authUser}`,
 							);
 						});
 					});

package/src/{VirtualFileSystem.ts → VirtualFileSystem/index.ts}

@@ -5,21 +5,12 @@ import type {
 	RemoveOptions,
 	VfsNodeStats,
 	WriteFileOptions,
-} from "./types/vfs";
-import {
-	archiveExists,
-	createTarBuffer,
-	readSnapshotFromTar,
-} from "./vfs/archive";
-import type { InternalDirectoryNode, InternalNode } from "./vfs/internalTypes";
-import {
-	getNode,
-	getParentDirectory,
-	normalizePath,
-	splitPath,
-} from "./vfs/path";
-import { applySnapshot, createSnapshot } from "./vfs/snapshot";
-import { renderTree } from "./vfs/tree";
+} from "../types/vfs";
+import { archiveExists, createTarBuffer, readSnapshotFromTar } from "./archive";
+import type { InternalDirectoryNode, InternalNode } from "./internalTypes";
+import { getNode, getParentDirectory, normalizePath, splitPath } from "./path";
+import { applySnapshot, createSnapshot } from "./snapshot";
+import { renderTree } from "./tree";
 
 /**
  * In-memory virtual filesystem with tar.gz mirror persistence.

package/src/{SSHMimic → VirtualShell}/commands/cat.ts

@@ -1,11 +1,12 @@
 import type { ShellModule } from "../../types/commands";
+import { getArg } from "./command-helpers";
 import { assertPathAccess, resolveReadablePath } from "./helpers";
 
 export const catCommand: ShellModule = {
 	name: "cat",
 	params: ["<file>"],
 	run: ({ authUser, vfs, cwd, args }) => {
-		const fileArg = args[0];
+		const fileArg = getArg(args, 0);
 		if (!fileArg) {
 			return { stderr: "cat: missing file operand", exitCode: 1 };
 		}