typescript-virtual-container 1.2.8 → 1.3.0

package/src/SSHMimic/executor.ts

@@ -1,7 +1,12 @@
-import { runCommand as runSingleCommand } from "../commands";
+import { runCommandDirect } from "../commands";
 import { resolvePath } from "../commands/helpers";
 import type { CommandMode, CommandResult, ShellEnv } from "../types/commands";
-import type { Pipeline, PipelineCommand, Script, Statement } from "../types/pipeline";
+import type {
+	Pipeline,
+	PipelineCommand,
+	Script,
+	Statement,
+} from "../types/pipeline";
 import type { VirtualShell } from "../VirtualShell";
 
 // ── Script executor (handles &&/||/;) ────────────────────────────────────────
@@ -15,17 +20,30 @@ export async function executeScript(
 	shell: VirtualShell,
 	env: ShellEnv,
 ): Promise<CommandResult> {
-	if (!script.isValid) return { stderr: script.error || "Syntax error", exitCode: 1 };
+	if (!script.isValid)
+		return { stderr: script.error || "Syntax error", exitCode: 1 };
 
 	let lastResult: CommandResult = { exitCode: 0 };
 
 	for (const stmt of script.statements) {
 		// Decide whether to run this statement based on previous op
-		lastResult = await executePipeline(stmt.pipeline, authUser, hostname, mode, cwd, shell, env);
+		lastResult = await executePipeline(
+			stmt.pipeline,
+			authUser,
+			hostname,
+			mode,
+			cwd,
+			shell,
+			env,
+		);
 		env.lastExitCode = lastResult.exitCode ?? 0;
 
 		// Propagate session-control signals
-		if (lastResult.closeSession || lastResult.switchUser || lastResult.nextCwd) {
+		if (
+			lastResult.closeSession ||
+			lastResult.switchUser ||
+			lastResult.nextCwd
+		) {
 			break;
 		}
 	}
@@ -48,7 +66,15 @@ export async function executeStatements(
 
 	while (i < statements.length) {
 		const stmt = statements[i]!;
-		last = await executePipeline(stmt.pipeline, authUser, hostname, mode, cwd, shell, env);
+		last = await executePipeline(
+			stmt.pipeline,
+			authUser,
+			hostname,
+			mode,
+			cwd,
+			shell,
+			env,
+		);
 		env.lastExitCode = last.exitCode ?? 0;
 
 		if (last.closeSession || last.switchUser) return last;
@@ -83,7 +109,8 @@ export async function executePipeline(
 	shell: VirtualShell,
 	env?: ShellEnv,
 ): Promise<CommandResult> {
-	if (!pipeline.isValid) return { stderr: pipeline.error || "Syntax error", exitCode: 1 };
+	if (!pipeline.isValid)
+		return { stderr: pipeline.error || "Syntax error", exitCode: 1 };
 	if (pipeline.commands.length === 0) return { exitCode: 0 };
 
 	const shellEnv: ShellEnv = env ?? { vars: {}, lastExitCode: 0 };
@@ -91,13 +118,23 @@ export async function executePipeline(
 	if (pipeline.commands.length === 1) {
 		return executeSingleCommandWithRedirections(
 			pipeline.commands[0] as PipelineCommand,
-			authUser, hostname, mode, cwd, shell, shellEnv,
+			authUser,
+			hostname,
+			mode,
+			cwd,
+			shell,
+			shellEnv,
 		);
 	}
 
 	return executePipelineChain(
 		pipeline.commands as PipelineCommand[],
-		authUser, hostname, mode, cwd, shell, shellEnv,
+		authUser,
+		hostname,
+		mode,
+		cwd,
+		shell,
+		shellEnv,
 	);
 }
 
@@ -113,26 +150,51 @@ async function executeSingleCommandWithRedirections(
 	let stdin: string | undefined;
 	if (cmd.inputFile) {
 		const inputPath = resolvePath(cwd, cmd.inputFile);
-		try { stdin = shell.vfs.readFile(inputPath); }
-		catch { return { stderr: `${cmd.inputFile}: No such file or directory`, exitCode: 1 }; }
+		try {
+			stdin = shell.vfs.readFile(inputPath);
+		} catch {
+			return {
+				stderr: `${cmd.inputFile}: No such file or directory`,
+				exitCode: 1,
+			};
+		}
 	}
 
-	const rawInput = [cmd.name, ...cmd.args].join(" ");
-	const result = await runSingleCommand(rawInput, authUser, hostname, mode, cwd, shell, stdin, env);
+	const result = await runCommandDirect(
+		cmd.name,
+		cmd.args,
+		authUser,
+		hostname,
+		mode,
+		cwd,
+		shell,
+		stdin,
+		env,
+	);
 
 	if (cmd.outputFile) {
 		const outputPath = resolvePath(cwd, cmd.outputFile);
 		const output = result.stdout || "";
 		try {
 			if (cmd.appendOutput) {
-				const existing = (() => { try { return shell.vfs.readFile(outputPath); } catch { return ""; } })();
+				const existing = (() => {
+					try {
+						return shell.vfs.readFile(outputPath);
+					} catch {
+						return "";
+					}
+				})();
 				shell.writeFileAsUser(authUser, outputPath, existing + output);
 			} else {
 				shell.writeFileAsUser(authUser, outputPath, output);
 			}
 			return { ...result, stdout: "" };
 		} catch {
-			return { ...result, stderr: `Failed to write to ${cmd.outputFile}`, exitCode: 1 };
+			return {
+				...result,
+				stderr: `Failed to write to ${cmd.outputFile}`,
+				exitCode: 1,
+			};
 		}
 	}
 
@@ -156,12 +218,27 @@ async function executePipelineChain(
 
 		if (i === 0 && cmd.inputFile) {
 			const inputPath = resolvePath(cwd, cmd.inputFile);
-			try { currentOutput = shell.vfs.readFile(inputPath); }
-			catch { return { stderr: `${cmd.inputFile}: No such file or directory`, exitCode: 1 }; }
+			try {
+				currentOutput = shell.vfs.readFile(inputPath);
+			} catch {
+				return {
+					stderr: `${cmd.inputFile}: No such file or directory`,
+					exitCode: 1,
+				};
+			}
 		}
 
-		const rawInput = [cmd.name, ...cmd.args].join(" ");
-		const result = await runSingleCommand(rawInput, authUser, hostname, mode, cwd, shell, currentOutput, env);
+		const result = await runCommandDirect(
+			cmd.name,
+			cmd.args,
+			authUser,
+			hostname,
+			mode,
+			cwd,
+			shell,
+			currentOutput,
+			env,
+		);
 		exitCode = result.exitCode ?? 0;
 
 		if (i === commands.length - 1 && cmd.outputFile) {
@@ -169,7 +246,13 @@ async function executePipelineChain(
 			const output = result.stdout || "";
 			try {
 				if (cmd.appendOutput) {
-					const existing = (() => { try { return shell.vfs.readFile(outputPath); } catch { return ""; } })();
+					const existing = (() => {
+						try {
+							return shell.vfs.readFile(outputPath);
+						} catch {
+							return "";
+						}
+					})();
 					shell.writeFileAsUser(authUser, outputPath, existing + output);
 				} else {
 					shell.writeFileAsUser(authUser, outputPath, output);
@@ -182,7 +265,8 @@ async function executePipelineChain(
 			currentOutput = result.stdout || "";
 		}
 
-		if (result.stderr && exitCode !== 0) return { stderr: result.stderr, exitCode };
+		if (result.stderr && exitCode !== 0)
+			return { stderr: result.stderr, exitCode };
 		if (result.closeSession || result.switchUser) return result;
 	}
 

package/src/SSHMimic/index.ts

@@ -140,7 +140,11 @@ class SshMimic extends EventEmitter {
 
 					// Rate-limit check
 					if (this.isLockedOut(remoteAddress)) {
-						this.emit("auth:failure", { username: candidateUser, remoteAddress, reason: "lockout" });
+						this.emit("auth:failure", {
+							username: candidateUser,
+							remoteAddress,
+							reason: "lockout",
+						});
 						ctx.reject();
 						return;
 					}
@@ -152,7 +156,10 @@ class SshMimic extends EventEmitter {
 								`User ${candidateUser} has no password set, allowing login without verification`,
 							);
 							authUser = candidateUser;
-							sessionId = shell.users.registerSession(authUser, remoteAddress).id;
+							sessionId = shell.users.registerSession(
+								authUser,
+								remoteAddress,
+							).id;
 							this.recordSuccess(remoteAddress);
 							this.emit("auth:success", { username: authUser, remoteAddress });
 							this.ensureHomeDir(authUser);
@@ -166,7 +173,10 @@ class SshMimic extends EventEmitter {
 							!shell.users.verifyPassword(candidateUser, ctx.password)
 						) {
 							this.recordFailure(remoteAddress);
-							this.emit("auth:failure", { username: candidateUser, remoteAddress });
+							this.emit("auth:failure", {
+								username: candidateUser,
+								remoteAddress,
+							});
 							ctx.reject();
 							return;
 						}
@@ -192,13 +202,16 @@ class SshMimic extends EventEmitter {
 						const incomingKey = ctx.key;
 						const keyMatches = authorizedKeys.some(
 							(k) =>
-								k.algo === incomingKey.algo &&
-								k.data.equals(incomingKey.data),
+								k.algo === incomingKey.algo && k.data.equals(incomingKey.data),
 						);
 
 						if (!keyMatches) {
 							this.recordFailure(remoteAddress);
-							this.emit("auth:failure", { username: candidateUser, remoteAddress, method: "publickey" });
+							this.emit("auth:failure", {
+								username: candidateUser,
+								remoteAddress,
+								method: "publickey",
+							});
 							ctx.reject();
 							return;
 						}
@@ -206,9 +219,16 @@ class SshMimic extends EventEmitter {
 						// Key matched — if this is a signature check step, accept
 						if (ctx.signature) {
 							authUser = candidateUser;
-							sessionId = shell.users.registerSession(authUser, remoteAddress).id;
+							sessionId = shell.users.registerSession(
+								authUser,
+								remoteAddress,
+							).id;
 							this.recordSuccess(remoteAddress);
-							this.emit("auth:success", { username: authUser, remoteAddress, method: "publickey" });
+							this.emit("auth:success", {
+								username: authUser,
+								remoteAddress,
+								method: "publickey",
+							});
 							this.ensureHomeDir(authUser);
 							ctx.accept();
 						} else {
@@ -238,20 +258,35 @@ class SshMimic extends EventEmitter {
 							acceptPty();
 						});
 
-						session.on("window-change", (_acceptChange, _rejectChange, info) => {
-							terminalSize.cols = info?.cols ?? terminalSize.cols;
-							terminalSize.rows = info?.rows ?? terminalSize.rows;
-						});
+						session.on(
+							"window-change",
+							(_acceptChange, _rejectChange, info) => {
+								terminalSize.cols = info?.cols ?? terminalSize.cols;
+								terminalSize.rows = info?.rows ?? terminalSize.rows;
+							},
+						);
 
 						session.on("shell", (acceptShell) => {
 							const stream = acceptShell();
-							shell?.startInteractiveSession(stream, authUser, sessionId, remoteAddress, terminalSize);
+							shell?.startInteractiveSession(
+								stream,
+								authUser,
+								sessionId,
+								remoteAddress,
+								terminalSize,
+							);
 						});
 
 						session.on("exec", (acceptExec, _rejectExec, info) => {
 							const stream = acceptExec();
 							if (stream) {
-								runExec(stream, info.command.trim(), authUser, shell.hostname, shell);
+								runExec(
+									stream,
+									info.command.trim(),
+									authUser,
+									shell.hostname,
+									shell,
+								);
 							}
 						});
 					});
@@ -293,4 +328,3 @@ class SshMimic extends EventEmitter {
 
 export { SftpMimic } from "./sftp";
 export { SshMimic };
-

package/src/VirtualFileSystem/binaryPack.ts

@@ -31,19 +31,25 @@
  *   Binary pack :  ~1.00 MB + ~40 bytes/node header  → ~27% smaller, no string parsing
  */
 
-import type { InternalDirectoryNode, InternalFileNode, InternalNode } from "./internalTypes";
+import type {
+	InternalDirectoryNode,
+	InternalFileNode,
+	InternalNode,
+} from "./internalTypes";
 
 const MAGIC = Buffer.from([0x56, 0x46, 0x53, 0x21]); // "VFS!"
 const VERSION = 0x01;
 const TYPE_FILE = 0x01;
-const TYPE_DIR  = 0x02;
+const TYPE_DIR = 0x02;
 
 // ── Encoder ───────────────────────────────────────────────────────────────────
 
 class Encoder {
 	private chunks: Buffer[] = [];
 
-	write(buf: Buffer): void { this.chunks.push(buf); }
+	write(buf: Buffer): void {
+		this.chunks.push(buf);
+	}
 
 	writeUint8(n: number): void {
 		const b = Buffer.allocUnsafe(1);
@@ -80,7 +86,9 @@ class Encoder {
 		this.chunks.push(bytes);
 	}
 
-	toBuffer(): Buffer { return Buffer.concat(this.chunks); }
+	toBuffer(): Buffer {
+		return Buffer.concat(this.chunks);
+	}
 }
 
 function encodeNode(enc: Encoder, node: InternalNode): void {
@@ -124,7 +132,9 @@ class Decoder {
 	private pos = 0;
 	constructor(private readonly buf: Buffer) {}
 
-	readUint8(): number { return this.buf.readUInt8(this.pos++); }
+	readUint8(): number {
+		return this.buf.readUInt8(this.pos++);
+	}
 
 	readUint16(): number {
 		const v = this.buf.readUInt16LE(this.pos);
@@ -158,7 +168,9 @@ class Decoder {
 		return b;
 	}
 
-	remaining(): number { return this.buf.length - this.pos; }
+	remaining(): number {
+		return this.buf.length - this.pos;
+	}
 }
 
 function decodeNode(dec: Decoder): InternalNode {
@@ -171,7 +183,15 @@ function decodeNode(dec: Decoder): InternalNode {
 	if (type === TYPE_FILE) {
 		const compressed = dec.readUint8() === 0x01;
 		const content = dec.readBytes();
-		return { type: "file", name, mode, createdAt, updatedAt, compressed, content } satisfies InternalFileNode;
+		return {
+			type: "file",
+			name,
+			mode,
+			createdAt,
+			updatedAt,
+			compressed,
+			content,
+		} satisfies InternalFileNode;
 	}
 
 	if (type === TYPE_DIR) {
@@ -181,7 +201,14 @@ function decodeNode(dec: Decoder): InternalNode {
 			const child = decodeNode(dec);
 			children.set(child.name, child);
 		}
-		return { type: "directory", name, mode, createdAt, updatedAt, children } satisfies InternalDirectoryNode;
+		return {
+			type: "directory",
+			name,
+			mode,
+			createdAt,
+			updatedAt,
+			children,
+		} satisfies InternalDirectoryNode;
 	}
 
 	throw new Error(`[VFS binary] Unknown node type: 0x${type.toString(16)}`);

package/src/VirtualFileSystem/index.ts

@@ -172,7 +172,9 @@ class VirtualFileSystem extends EventEmitter {
 				// Legacy JSON fallback — auto-migrates on next flushMirror()
 				const snapshot: VfsSnapshot = JSON.parse(raw.toString("utf8"));
 				this.root = this.deserializeDir(snapshot.root, "");
-				console.info("[VirtualFileSystem] Migrating legacy JSON snapshot to binary format.");
+				console.info(
+					"[VirtualFileSystem] Migrating legacy JSON snapshot to binary format.",
+				);
 			}
 			this.emit("snapshot:restore", { path: this.snapshotFile });
 		} catch (err) {
@@ -220,7 +222,11 @@ class VirtualFileSystem extends EventEmitter {
 	public mkdir(targetPath: string, mode: number = 0o755): void {
 		const normalized = normalizePath(targetPath);
 		const existing = (() => {
-			try { return getNode(this.root, normalized); } catch { return null; }
+			try {
+				return getNode(this.root, normalized);
+			} catch {
+				return null;
+			}
 		})();
 		if (existing && existing.type !== "directory") {
 			throw new Error(
@@ -311,7 +317,9 @@ class VirtualFileSystem extends EventEmitter {
 		try {
 			getNode(this.root, normalizePath(targetPath));
 			return true;
-		} catch { return false; }
+		} catch {
+			return false;
+		}
 	}
 
 	/** Updates mode bits on a node. */
@@ -327,15 +335,24 @@ class VirtualFileSystem extends EventEmitter {
 		if (node.type === "file") {
 			const f = node as InternalFileNode;
 			return {
-				type: "file", name, path: normalized, mode: f.mode,
-				createdAt: f.createdAt, updatedAt: f.updatedAt,
-				compressed: f.compressed, size: f.content.length,
+				type: "file",
+				name,
+				path: normalized,
+				mode: f.mode,
+				createdAt: f.createdAt,
+				updatedAt: f.updatedAt,
+				compressed: f.compressed,
+				size: f.content.length,
 			};
 		}
 		const d = node as InternalDirectoryNode;
 		return {
-			type: "directory", name, path: normalized, mode: d.mode,
-			createdAt: d.createdAt, updatedAt: d.updatedAt,
+			type: "directory",
+			name,
+			path: normalized,
+			mode: d.mode,
+			createdAt: d.createdAt,
+			updatedAt: d.updatedAt,
 			childrenCount: d.children.size,
 		};
 	}
@@ -355,9 +372,7 @@ class VirtualFileSystem extends EventEmitter {
 		const normalized = normalizePath(dirPath);
 		const node = getNode(this.root, normalized);
 		if (node.type !== "directory") {
-			throw new Error(
-				`Cannot render tree for '${dirPath}': not a directory.`,
-			);
+			throw new Error(`Cannot render tree for '${dirPath}': not a directory.`);
 		}
 		const label = dirPath === "/" ? "/" : path.posix.basename(normalized);
 		return this.renderTreeLines(node as InternalDirectoryNode, label);
@@ -375,7 +390,8 @@ class VirtualFileSystem extends EventEmitter {
 			lines.push(`${connector}${name}`);
 			if (child.type === "directory") {
 				const sub = this.renderTreeLines(child as InternalDirectoryNode, "")
-					.split("\n").slice(1)
+					.split("\n")
+					.slice(1)
 					.map((l) => `${nextPrefix}${l}`);
 				lines.push(...sub);
 			}
@@ -400,7 +416,8 @@ class VirtualFileSystem extends EventEmitter {
 	/** Compresses a file's content with gzip in place. */
 	public compressFile(targetPath: string): void {
 		const node = getNode(this.root, normalizePath(targetPath));
-		if (node.type !== "file") throw new Error(`Cannot compress '${targetPath}': not a file.`);
+		if (node.type !== "file")
+			throw new Error(`Cannot compress '${targetPath}': not a file.`);
 		const f = node as InternalFileNode;
 		if (!f.compressed) {
 			f.content = gzipSync(f.content);
@@ -412,7 +429,8 @@ class VirtualFileSystem extends EventEmitter {
 	/** Decompresses a gzip-compressed file in place. */
 	public decompressFile(targetPath: string): void {
 		const node = getNode(this.root, normalizePath(targetPath));
-		if (node.type !== "file") throw new Error(`Cannot decompress '${targetPath}': not a file.`);
+		if (node.type !== "file")
+			throw new Error(`Cannot decompress '${targetPath}': not a file.`);
 		const f = node as InternalFileNode;
 		if (f.compressed) {
 			f.content = gunzipSync(f.content);
@@ -431,18 +449,25 @@ class VirtualFileSystem extends EventEmitter {
 			? normalizePath(targetPath)
 			: targetPath;
 		const { parent, name } = getParentDirectory(
-			this.root, normalizedLink, true,
+			this.root,
+			normalizedLink,
+			true,
 			(p) => this.mkdirRecursive(p, 0o755),
 		);
 		const symNode: InternalFileNode = {
-			type: "file", name,
+			type: "file",
+			name,
 			content: Buffer.from(normalizedTarget, "utf8"),
 			mode: 0o120777,
 			compressed: false,
-			createdAt: new Date(), updatedAt: new Date(),
+			createdAt: new Date(),
+			updatedAt: new Date(),
 		};
 		parent.children.set(name, symNode);
-		this.emit("symlink:create", { link: normalizedLink, target: normalizedTarget });
+		this.emit("symlink:create", {
+			link: normalizedLink,
+			target: normalizedTarget,
+		});
 	}
 
 	/** Returns true when the path is a symbolic link node. */
@@ -450,7 +475,9 @@ class VirtualFileSystem extends EventEmitter {
 		try {
 			const node = getNode(this.root, normalizePath(targetPath));
 			return node.type === "file" && node.mode === 0o120777;
-		} catch { return false; }
+		} catch {
+			return false;
+		}
 	}
 
 	/**
@@ -466,10 +493,14 @@ class VirtualFileSystem extends EventEmitter {
 					const target = (node as InternalFileNode).content.toString("utf8");
 					current = target.startsWith("/")
 						? target
-						: normalizePath(path.posix.join(path.posix.dirname(current), target));
+						: normalizePath(
+								path.posix.join(path.posix.dirname(current), target),
+							);
 					continue;
 				}
-			} catch { break; }
+			} catch {
+				break;
+			}
 			return current;
 		}
 		throw new Error(`Too many levels of symbolic links: ${linkPath}`);
@@ -488,7 +519,12 @@ class VirtualFileSystem extends EventEmitter {
 				);
 			}
 		}
-		const { parent, name } = getParentDirectory(this.root, normalized, false, () => {});
+		const { parent, name } = getParentDirectory(
+			this.root,
+			normalized,
+			false,
+			() => {},
+		);
 		parent.children.delete(name);
 		this.emit("node:remove", { path: normalized });
 	}
@@ -506,10 +542,16 @@ class VirtualFileSystem extends EventEmitter {
 		}
 		this.mkdirRecursive(path.posix.dirname(toNormalized), 0o755);
 		const { parent: destParent, name: destName } = getParentDirectory(
-			this.root, toNormalized, false, () => {},
+			this.root,
+			toNormalized,
+			false,
+			() => {},
 		);
 		const { parent: srcParent, name: srcName } = getParentDirectory(
-			this.root, fromNormalized, false, () => {},
+			this.root,
+			fromNormalized,
+			false,
+			() => {},
 		);
 		srcParent.children.delete(srcName);
 		node.name = destName;
@@ -538,7 +580,9 @@ class VirtualFileSystem extends EventEmitter {
 			);
 		}
 		return {
-			type: "directory", name: dir.name, mode: dir.mode,
+			type: "directory",
+			name: dir.name,
+			mode: dir.mode,
 			createdAt: dir.createdAt.toISOString(),
 			updatedAt: dir.updatedAt.toISOString(),
 			children,
@@ -547,7 +591,9 @@ class VirtualFileSystem extends EventEmitter {
 
 	private serializeFile(file: InternalFileNode): VfsSnapshotFileNode {
 		return {
-			type: "file", name: file.name, mode: file.mode,
+			type: "file",
+			name: file.name,
+			mode: file.mode,
 			createdAt: file.createdAt.toISOString(),
 			updatedAt: file.updatedAt.toISOString(),
 			compressed: file.compressed,
@@ -588,7 +634,9 @@ class VirtualFileSystem extends EventEmitter {
 		name: string,
 	): InternalDirectoryNode {
 		const dir: InternalDirectoryNode = {
-			type: "directory", name, mode: snap.mode,
+			type: "directory",
+			name,
+			mode: snap.mode,
 			createdAt: new Date(snap.createdAt),
 			updatedAt: new Date(snap.updatedAt),
 			children: new Map(),
@@ -597,7 +645,9 @@ class VirtualFileSystem extends EventEmitter {
 			if (child.type === "file") {
 				const f = child as VfsSnapshotFileNode;
 				dir.children.set(f.name, {
-					type: "file", name: f.name, mode: f.mode,
+					type: "file",
+					name: f.name,
+					mode: f.mode,
 					createdAt: new Date(f.createdAt),
 					updatedAt: new Date(f.updatedAt),
 					compressed: f.compressed,