typescript-virtual-container 1.2.7 → 1.2.9

package/src/VirtualShell/index.ts

@@ -6,11 +6,32 @@ import type { PerfLogger } from "../utils/perfLogger";
 import { createPerfLogger } from "../utils/perfLogger";
 import VirtualFileSystem, { type VfsOptions } from "../VirtualFileSystem";
 import { VirtualUserManager } from "../VirtualUserManager";
+import { VirtualPackageManager } from "../VirtualPackageManager";
+import { bootstrapLinuxRootfs, refreshProc, syncEtcPasswd } from "../modules/linuxRootfs";
 import { startShell } from "./shell";
 
+/**
+ * Virtual machine identity strings surfaced by system-info commands
+ * (`uname`, `neofetch`, `lsb_release`, `/proc/version`, `/etc/os-release`).
+ *
+ * Pass this as the second argument to `new VirtualShell()` to customise the
+ * distro name, kernel version, and CPU architecture reported inside the shell.
+ *
+ * @example
+ * ```ts
+ * const shell = new VirtualShell("my-vm", {
+ *   kernel: "6.1.0+custom-amd64",
+ *   os:     "Acme GNU/Linux x64",
+ *   arch:   "x86_64",
+ * });
+ * ```
+ */
 export interface ShellProperties {
+	/** Kernel version string (e.g. `"1.0.0+itsrealfortune+1-amd64"`). */
 	kernel: string;
+	/** Full OS description (e.g. `"Fortune GNU/Linux x64"`). */
 	os: string;
+	/** CPU architecture label (e.g. `"x86_64"`, `"aarch64"`). */
 	arch: string;
 }
 
@@ -32,16 +53,40 @@ function resolveAutoSudoForNewUsers(): boolean {
 }
 
 /**
- * Coordinates the virtual filesystem, user manager, and command runtime.
+ * Coordinates the virtual filesystem, user manager, package manager, and
+ * command runtime for a single isolated shell environment.
+ *
+ * Each instance owns its own VFS tree, user database, package registry, and
+ * session state — multiple instances are fully independent.
+ *
+ * Instances are consumed both by the SSH/SFTP server facades and directly via
+ * the programmatic `SshClient` API.
  *
- * Instances are used both by the SSH server facade and by the programmatic
- * client API.
+ * @example
+ * ```ts
+ * const shell = new VirtualShell("my-vm");
+ * await shell.ensureInitialized();
+ * const client = new SshClient(shell, "root");
+ * const result = await client.exec("uname -a");
+ * ```
+ *
+ * @fires VirtualShell#initialized  Emitted once the VFS and users are ready.
+ * @fires VirtualShell#command       Emitted after every command execution.
+ * @fires VirtualShell#session:start Emitted when an interactive session opens.
  */
 class VirtualShell extends EventEmitter {
+	/** Backing virtual filesystem — use for direct path operations. */
 	vfs: VirtualFileSystem;
+	/** Virtual user database — use for auth, quotas, and session tracking. */
 	users: VirtualUserManager;
+	/** APT/dpkg package manager backed by the built-in package registry. */
+	packageManager: VirtualPackageManager;
+	/** Hostname shown in the shell prompt and SSH ident string. */
 	hostname: string;
+	/** Distro identity strings surfaced by `uname`, `neofetch`, etc. */
 	properties: ShellProperties;
+	/** Unix ms timestamp of shell creation — used by `uptime` and `/proc/uptime`. */
+	startTime: number;
 	private initialized: Promise<void>;
 
 	/**
@@ -60,17 +105,27 @@ class VirtualShell extends EventEmitter {
 		perf.mark("constructor");
 		this.hostname = hostname;
 		this.properties = properties || defaultShellProperties;
+		this.startTime = Date.now();
 		this.vfs = new VirtualFileSystem(vfsOptions ?? {});
 		this.users = new VirtualUserManager(this.vfs, resolveAutoSudoForNewUsers());
+		this.packageManager = new VirtualPackageManager(this.vfs, this.users);
 
 		// Store references to avoid TypeScript "used before assigned" errors
 		const vfs = this.vfs;
 		const users = this.users;
+		const pm = this.packageManager;
+		const shellProps = this.properties;
+		const shellHostname = this.hostname;
+		const startTime = this.startTime;
 
 		// Initialize both VFS mirror and users, ensuring all is ready before auth
 		this.initialized = (async () => {
 			await vfs.restoreMirror();
 			await users.initialize();
+			// Bootstrap Linux rootfs (idempotent)
+			bootstrapLinuxRootfs(vfs, users, shellHostname, shellProps, startTime);
+			// Load installed packages from dpkg status
+			pm.load();
 			this.emit("initialized");
 		})();
 	}
@@ -105,11 +160,16 @@ class VirtualShell extends EventEmitter {
 	}
 
 	/**
-	 * Executes a command line string in the context of this shell instance.
+	 * Executes a raw command line string programmatically.
+	 *
+	 * Supports the full shell operator set (`&&`, `||`, `;`, `|`, `>`, `<`,
+	 * `$(cmd)`) and alias expansion. The result is emitted via the
+	 * `"command"` event but not returned — use `SshClient.exec()` for a
+	 * result-returning wrapper.
 	 *
-	 * @param rawInput
-	 * @param authUser
-	 * @param cwd
+	 * @param rawInput Unparsed command line (e.g. `"ls -la /tmp"`).
+	 * @param authUser Username to run the command as.
+	 * @param cwd      Current working directory for path resolution.
 	 */
 	executeCommand(rawInput: string, authUser: string, cwd: string): void {
 		perf.mark("executeCommand");
@@ -118,14 +178,19 @@ class VirtualShell extends EventEmitter {
 	}
 
 	/**
-	 * Starts an interactive session with the shell.
+	 * Attaches an interactive PTY session to this shell instance.
+	 *
+	 * Called internally by `SshMimic` when a client opens a shell channel.
+	 * The session reads from `stream` (user keystrokes) and writes back ANSI
+	 * output. History, `.bashrc` sourcing, and Ctrl+W/Ctrl+U line editing are
+	 * handled automatically.
 	 *
-	 * @param stream The stream for the interactive session.
-	 * @param authUser The authenticated user for the session.
-	 * @param sessionId The ID of the session.
-	 * @param remoteAddress The address of the remote client.
+	 * @param stream        Bidirectional SSH channel stream.
+	 * @param authUser      Authenticated username bound to this session.
+	 * @param sessionId     Stable session UUID (used for `who` output), or `null`.
+	 * @param remoteAddress IP or hostname of the connecting client.
+	 * @param terminalSize  Initial terminal dimensions in columns and rows.
 	 */
-
 	startInteractiveSession(
 		stream: ShellStream,
 		authUser: string,
@@ -148,6 +213,32 @@ class VirtualShell extends EventEmitter {
 		);
 	}
 
+	/**
+	 * Refreshes the `/proc` virtual filesystem with current system state.
+	 *
+	 * Updates `/proc/uptime`, `/proc/meminfo`, `/proc/cpuinfo`,
+	 * `/proc/version`, and `/proc/loadavg` from live host data.
+	 *
+	 * Called automatically during `bootstrapLinuxRootfs`. Call again before
+	 * reading `/proc` files for up-to-date values (e.g. before `neofetch`
+	 * or `free` in long-running processes).
+	 */
+	public refreshProcFs(): void {
+		refreshProc(this.vfs, this.properties, this.hostname, this.startTime);
+	}
+
+	/**
+	 * Syncs `/etc/passwd`, `/etc/group`, and `/etc/shadow` from the current
+	 * `VirtualUserManager` state.
+	 *
+	 * Called automatically during `bootstrapLinuxRootfs`. Call again after
+	 * `users.addUser()`, `users.deleteUser()`, or `users.addSudoer()` to keep
+	 * the classic Unix credential files in sync with the user manager.
+	 */
+	public syncPasswd(): void {
+		syncEtcPasswd(this.vfs, this.users);
+	}
+
 	/**
 	 * Returns virtual filesystem instance after server started.
 	 *

package/src/VirtualUserManager/index.ts

@@ -290,10 +290,11 @@ export class VirtualUserManager extends EventEmitter {
 	}
 
 	/**
-	 * Updates password for an existing user account.
+	 * Updates the password for an existing user account.
 	 *
 	 * @param username Username to update.
-	 * @param password New plaintext password.
+	 * @param password New plaintext password (must be non-empty).
+	 * @throws When the user does not exist or the password is empty.
 	 */
 	public async setPassword(username: string, password: string): Promise<void> {
 		perf.mark("setPassword");
@@ -309,9 +310,10 @@ export class VirtualUserManager extends EventEmitter {
 	}
 
 	/**
-	 * Deletes existing non-root user account.
+	 * Deletes an existing non-root user account and revokes sudo access.
 	 *
 	 * @param username Username to remove.
+	 * @throws When `username` is `"root"` or the user does not exist.
 	 */
 	public async deleteUser(username: string): Promise<void> {
 		perf.mark("deleteUser");
@@ -343,9 +345,10 @@ export class VirtualUserManager extends EventEmitter {
 	}
 
 	/**
-	 * Grants sudo access to existing user.
+	 * Grants sudo privileges to an existing user.
 	 *
 	 * @param username Username to promote.
+	 * @throws When the user does not exist.
 	 */
 	public async addSudoer(username: string): Promise<void> {
 		perf.mark("addSudoer");
@@ -359,9 +362,10 @@ export class VirtualUserManager extends EventEmitter {
 	}
 
 	/**
-	 * Revokes sudo access from user.
+	 * Revokes sudo privileges from a user. Root cannot be demoted.
 	 *
 	 * @param username Username to demote.
+	 * @throws When `username` is `"root"`.
 	 */
 	public async removeSudoer(username: string): Promise<void> {
 		perf.mark("removeSudoer");
@@ -375,11 +379,14 @@ export class VirtualUserManager extends EventEmitter {
 	}
 
 	/**
-	 * Registers active session and allocates tty id.
+	 * Registers a new active session and allocates a virtual TTY identifier.
 	 *
-	 * @param username Session username.
-	 * @param remoteAddress Session source address.
-	 * @returns Registered session descriptor.
+	 * Called by the SSH server when a client is authenticated. The returned
+	 * descriptor is visible in `who` output and `listActiveSessions()`.
+	 *
+	 * @param username      Authenticated username bound to the session.
+	 * @param remoteAddress IP address or hostname of the connecting client.
+	 * @returns The newly created `VirtualActiveSession` descriptor.
 	 */
 	public registerSession(
 		username: string,
@@ -403,9 +410,11 @@ export class VirtualUserManager extends EventEmitter {
 	}
 
 	/**
-	 * Unregisters active session when connection closes.
+	 * Removes an active session record when the connection closes.
+	 *
+	 * Safe to call with a `null` or `undefined` session ID — it will be a no-op.
 	 *
-	 * @param sessionId Session identifier; ignored when nullish.
+	 * @param sessionId Session UUID returned by `registerSession()`, or nullish.
 	 */
 	public unregisterSession(sessionId: string | null | undefined): void {
 		perf.mark("unregisterSession");
@@ -425,11 +434,15 @@ export class VirtualUserManager extends EventEmitter {
 	}
 
 	/**
-	 * Updates username/address metadata for existing session.
+	 * Updates the username and remote address metadata for an active session.
 	 *
-	 * @param sessionId Session identifier; ignored when nullish.
-	 * @param username New username value.
-	 * @param remoteAddress New remote address value.
+	 * Called internally by `su` and `sudo` when the effective user changes
+	 * within a session. Silently ignored when the session ID is nullish or
+	 * unknown.
+	 *
+	 * @param sessionId     Session UUID to update, or nullish for no-op.
+	 * @param username      New effective username.
+	 * @param remoteAddress New remote address (usually unchanged).
 	 */
 	public updateSession(
 		sessionId: string | null | undefined,
@@ -454,9 +467,11 @@ export class VirtualUserManager extends EventEmitter {
 	}
 
 	/**
-	 * Lists active sessions sorted by start time.
+	 * Returns a snapshot of all currently active sessions, sorted by start time.
+	 *
+	 * Used by `who`, `ps`, `uptime`, and the `HoneyPot` auditor.
 	 *
-	 * @returns Snapshot of active session descriptors.
+	 * @returns Array of `VirtualActiveSession` descriptors.
 	 */
 	public listActiveSessions(): VirtualActiveSession[] {
 		perf.mark("listActiveSessions");
@@ -465,6 +480,15 @@ export class VirtualUserManager extends EventEmitter {
 		);
 	}
 
+	/**
+	 * Returns a sorted list of all registered usernames.
+	 *
+	 * @returns Array of username strings sorted alphabetically.
+	 */
+	public listUsers(): string[] {
+		return Array.from(this.users.keys()).sort();
+	}
+
 	private loadFromVfs(): void {
 		this.users.clear();
 
@@ -610,6 +634,14 @@ export class VirtualUserManager extends EventEmitter {
 		return record;
 	}
 
+	/**
+	 * Returns `true` when the user has a non-empty password set.
+	 *
+	 * A user with no password (or whose password hash matches the empty-string
+	 * hash) is allowed to authenticate without a credential check.
+	 *
+	 * @param username Target username.
+	 */
 	public hasPassword(username: string): boolean {
 		perf.mark("hasPassword");
 		if (this.getPasswordHash(username) === this.hashPassword("")) {
@@ -620,10 +652,13 @@ export class VirtualUserManager extends EventEmitter {
 	}
 
 	/**
-	 * Hashes plaintext password with per-user salt using scrypt.
+	 * Hashes a plaintext password using scrypt (or SHA-256 in fast-hash mode).
+	 *
+	 * Set `SSH_MIMIC_FAST_PASSWORD_HASH=1` to switch to SHA-256 for test
+	 * environments where scrypt latency is undesirable.
 	 *
-	 * @param password Plaintext password.
-	 * @returns Hex-encoded password hash.
+	 * @param password Plaintext password string.
+	 * @returns Hex-encoded hash string.
 	 */
 	public hashPassword(password: string): string {
 		if (VirtualUserManager.fastPasswordHash) {

package/src/commands/alias.ts

@@ -0,0 +1,60 @@
+import type { ShellModule } from "../types/commands";
+import { ifFlag } from "./command-helpers";
+
+export const aliasCommand: ShellModule = {
+	name: "alias",
+	description: "Define or display aliases",
+	category: "shell",
+	params: ["[name[=value] ...]"],
+	run: ({ args, env }) => {
+		if (!env) return { exitCode: 0 };
+
+		// Aliases stored in env.vars under prefix __alias_
+		if (args.length === 0) {
+			const aliases = Object.entries(env.vars)
+				.filter(([k]) => k.startsWith("__alias_"))
+				.map(([k, v]) => `alias ${k.slice("__alias_".length)}='${v}'`);
+			return { stdout: aliases.join("\n") || "", exitCode: 0 };
+		}
+
+		const lines: string[] = [];
+		for (const arg of args) {
+			const eq = arg.indexOf("=");
+			if (eq === -1) {
+				// Display single alias
+				const val = env.vars[`__alias_${arg}`];
+				if (val) lines.push(`alias ${arg}='${val}'`);
+				else return { stderr: `alias: ${arg}: not found`, exitCode: 1 };
+			} else {
+				// Set alias
+				const name = arg.slice(0, eq);
+				const val = arg.slice(eq + 1).replace(/^['"]|['"]$/g, "");
+				env.vars[`__alias_${name}`] = val;
+			}
+		}
+
+		return { stdout: lines.join("\n") || undefined, exitCode: 0 };
+	},
+};
+
+export const unaliasCommand: ShellModule = {
+	name: "unalias",
+	description: "Remove alias definitions",
+	category: "shell",
+	params: ["<name...> | -a"],
+	run: ({ args, env }) => {
+		if (!env) return { exitCode: 0 };
+
+		if (ifFlag(args, ["-a"])) {
+			for (const k of Object.keys(env.vars)) {
+				if (k.startsWith("__alias_")) delete env.vars[k];
+			}
+			return { exitCode: 0 };
+		}
+
+		for (const name of args) {
+			delete env.vars[`__alias_${name}`];
+		}
+		return { exitCode: 0 };
+	},
+};

package/src/commands/apt.ts

@@ -0,0 +1,198 @@
+import type { ShellModule } from "../types/commands";
+import { ifFlag, } from "./command-helpers";
+import { getPackageManager } from "./helpers";
+
+export const aptCommand: ShellModule = {
+	name: "apt",
+	aliases: ["apt-get"],
+	description: "Package manager",
+	category: "system",
+	params: ["<install|remove|update|upgrade|search|show|list> [pkg...]"],
+	run: ({ args, shell, authUser }) => {
+		const pm = getPackageManager(shell);
+		if (!pm) return { stderr: "apt: package manager not initialised", exitCode: 1 };
+
+		const sub = args[0]?.toLowerCase();
+		const rest = args.slice(1);
+
+		const quiet = ifFlag(rest, ["-q", "--quiet", "-qq"]);
+		const purge = ifFlag(rest, ["--purge"]);
+		const pkgs = rest.filter((a) => !a.startsWith("-"));
+
+		// Non-root check
+		const restricted = ["install", "remove", "purge", "upgrade", "update"];
+		if (restricted.includes(sub ?? "") && authUser !== "root") {
+			return {
+				stderr: "E: Could not open lock file /var/lib/dpkg/lock-frontend - open (13: Permission denied)\nE: Unable to acquire the dpkg frontend lock, are you root?",
+				exitCode: 100,
+			};
+		}
+
+		switch (sub) {
+			case "install": {
+				if (pkgs.length === 0)
+					return { stderr: "apt: no packages specified", exitCode: 1 };
+				const { output, exitCode } = pm.install(pkgs, { quiet });
+				return { stdout: output || undefined, exitCode };
+			}
+
+			case "remove":
+			case "purge": {
+				if (pkgs.length === 0)
+					return { stderr: "apt: no packages specified", exitCode: 1 };
+				const { output, exitCode } = pm.remove(pkgs, {
+					purge: sub === "purge" || purge,
+					quiet,
+				});
+				return { stdout: output || undefined, exitCode };
+			}
+
+			case "update": {
+				return {
+					stdout: [
+						"Hit:1 fortune://packages.fortune.local aurora InRelease",
+						"Hit:2 fortune://security.fortune.local aurora-security InRelease",
+						"Reading package lists... Done",
+						"Building dependency tree... Done",
+						"Reading state information... Done",
+						`All packages are up to date.`,
+					].join("\n"),
+					exitCode: 0,
+				};
+			}
+
+			case "upgrade": {
+				return {
+					stdout: [
+						"Reading package lists... Done",
+						"Building dependency tree... Done",
+						"Reading state information... Done",
+						"Calculating upgrade... Done",
+						"0 upgraded, 0 newly installed, 0 to remove and 0 not upgraded.",
+					].join("\n"),
+					exitCode: 0,
+				};
+			}
+
+			case "search": {
+				const term = pkgs[0];
+				if (!term)
+					return { stderr: "apt: search requires a term", exitCode: 1 };
+				const results = pm.search(term);
+				if (results.length === 0)
+					return {
+						stdout: `Sorting... Done\nFull Text Search... Done\n(no results)`,
+						exitCode: 0,
+					};
+				const lines = results.map(
+					(p) => `${p.name}/${p.section ?? "misc"} ${p.version} amd64\n  ${p.shortDesc ?? p.description}`,
+				);
+				return {
+					stdout: `Sorting... Done\nFull Text Search... Done\n${lines.join("\n")}`,
+					exitCode: 0,
+				};
+			}
+
+			case "show": {
+				const name = pkgs[0];
+				if (!name) return { stderr: "apt: show requires a package name", exitCode: 1 };
+				const info = pm.show(name);
+				if (!info)
+					return { stderr: `N: Unable to locate package ${name}`, exitCode: 100 };
+				return { stdout: info, exitCode: 0 };
+			}
+
+			case "list": {
+				const installedFlag = ifFlag(rest, ["--installed"]);
+				if (installedFlag) {
+					const pkgList = pm.listInstalled();
+					if (pkgList.length === 0)
+						return { stdout: "Listing... Done\n(no packages installed)", exitCode: 0 };
+					const lines = pkgList.map(
+						(p) => `${p.name}/${p.section} ${p.version} ${p.architecture} [installed]`,
+					);
+					return { stdout: `Listing... Done\n${lines.join("\n")}`, exitCode: 0 };
+				}
+				// all available
+				const all = pm.listAvailable();
+				const lines = all.map(
+					(p) => `${p.name}/${p.section ?? "misc"} ${p.version} amd64`,
+				);
+				return { stdout: `Listing... Done\n${lines.join("\n")}`, exitCode: 0 };
+			}
+
+			default: {
+				return {
+					stdout: [
+						"Usage: apt [options] command",
+						"",
+						"Commands:",
+						"  install <pkg...>   Install packages",
+						"  remove <pkg...>    Remove packages",
+						"  purge <pkg...>     Remove packages and config files",
+						"  update             Refresh package index",
+						"  upgrade            Upgrade all packages",
+						"  search <term>      Search in package descriptions",
+						"  show <pkg>         Show package details",
+						"  list [--installed] List packages",
+					].join("\n"),
+					exitCode: 0,
+				};
+			}
+		}
+	},
+};
+
+export const aptCacheCommand: ShellModule = {
+	name: "apt-cache",
+	description: "Query the package cache",
+	category: "system",
+	params: ["<search|show|policy> [pkg]"],
+	run: ({ args, shell }) => {
+		const pm = getPackageManager(shell);
+		if (!pm) return { stderr: "apt-cache: package manager not initialised", exitCode: 1 };
+
+		const sub = args[0]?.toLowerCase();
+		const pkgName = args[1];
+
+		switch (sub) {
+			case "search": {
+				if (!pkgName) return { stderr: "Need a search term", exitCode: 1 };
+				const results = pm.search(pkgName);
+				return {
+					stdout: results
+						.map((p) => `${p.name} - ${p.shortDesc ?? p.description}`)
+						.join("\n") || "(no results)",
+					exitCode: 0,
+				};
+			}
+			case "show": {
+				if (!pkgName) return { stderr: "Need a package name", exitCode: 1 };
+				const info = pm.show(pkgName);
+				return info
+					? { stdout: info, exitCode: 0 }
+					: { stderr: `N: Unable to locate package ${pkgName}`, exitCode: 100 };
+			}
+			case "policy": {
+				if (!pkgName) return { stderr: "Need a package name", exitCode: 1 };
+				const def = pm.findInRegistry(pkgName);
+				if (!def)
+					return { stderr: `N: Unable to locate package ${pkgName}`, exitCode: 100 };
+				const inst = pm.isInstalled(pkgName);
+				return {
+					stdout: [
+						`${pkgName}:`,
+						`  Installed: ${inst ? def.version : "(none)"}`,
+						`  Candidate: ${def.version}`,
+						`  Version table:`,
+						`     ${def.version} 500`,
+						`        500 fortune://packages.fortune.local aurora/main amd64 Packages`,
+					].join("\n"),
+					exitCode: 0,
+				};
+			}
+			default:
+				return { stderr: `apt-cache: unknown command '${sub ?? ""}'`, exitCode: 1 };
+		}
+	},
+};

package/src/commands/cat.ts

@@ -1,20 +1,44 @@
 import type { ShellModule } from "../types/commands";
-import { getArg } from "./command-helpers";
+import { ifFlag } from "./command-helpers";
 import { assertPathAccess, resolveReadablePath } from "./helpers";
 
 export const catCommand: ShellModule = {
 	name: "cat",
 	description: "Concatenate and print files",
 	category: "files",
-	params: ["<file>"],
-	run: ({ authUser, shell, cwd, args }) => {
-		const fileArg = getArg(args, 0);
-		if (!fileArg) {
+	params: ["[-n] [-b] <file...>"],
+	run: ({ authUser, shell, cwd, args, stdin }) => {
+		const numberAll    = ifFlag(args, ["-n", "--number"]);
+		const numberNonBlank = ifFlag(args, ["-b", "--number-nonblank"]);
+		const fileArgs = args.filter((a) => !a.startsWith("-"));
+
+		if (fileArgs.length === 0 && stdin !== undefined) {
+			return { stdout: stdin, exitCode: 0 };
+		}
+
+		if (fileArgs.length === 0) {
 			return { stderr: "cat: missing file operand", exitCode: 1 };
 		}
 
-		const target = resolveReadablePath(shell.vfs, cwd, fileArg);
-		assertPathAccess(authUser, target, "cat");
-		return { stdout: shell.vfs.readFile(target), exitCode: 0 };
+		const parts: string[] = [];
+		for (const fileArg of fileArgs) {
+			const target = resolveReadablePath(shell.vfs, cwd, fileArg);
+			assertPathAccess(authUser, target, "cat");
+			parts.push(shell.vfs.readFile(target));
+		}
+
+		const combined = parts.join("");
+
+		if (!numberAll && !numberNonBlank) {
+			return { stdout: combined, exitCode: 0 };
+		}
+
+		let lineNum = 1;
+		const numbered = combined.split("\n").map((line) => {
+			if (numberNonBlank && line.trim() === "") return line;
+			return `${String(lineNum++).padStart(6)}\t${line}`;
+		}).join("\n");
+
+		return { stdout: numbered, exitCode: 0 };
 	},
 };