typescript-virtual-container 1.2.9 → 1.3.0

package/dist/utils/vfsDiff.d.ts

@@ -0,0 +1,90 @@
+/**
+ * vfsDiff.ts
+ *
+ * Snapshot diff tooling for `VirtualFileSystem`.
+ *
+ * Compares two VFS snapshots and returns structured diff results suitable
+ * for test assertions, audit logging, and deployment verification.
+ *
+ * @example
+ * ```ts
+ * import { diffSnapshots, formatDiff } from "typescript-virtual-container/utils/vfsDiff";
+ *
+ * const before = shell.vfs.toSnapshot();
+ * await client.exec("npm install && mkdir -p /app");
+ * const after = shell.vfs.toSnapshot();
+ *
+ * const diff = diffSnapshots(before, after);
+ * console.log(formatDiff(diff));
+ *
+ * // Test assertions
+ * expect(diff.added).toContain("/app");
+ * expect(diff.modified).toContain("/etc/hosts");
+ * expect(diff.removed).not.toContain("/tmp/needed-file");
+ * ```
+ */
+import type { VfsSnapshot } from "../types/vfs";
+/** A single changed file entry in a diff result. */
+export interface VfsDiffEntry {
+    /** Absolute VFS path of the changed node. */
+    path: string;
+    /** Node type — `"file"` or `"directory"`. */
+    type: "file" | "directory";
+}
+/** A modified file entry — includes before/after content for files. */
+export interface VfsDiffModified extends VfsDiffEntry {
+    type: "file";
+    /** Content before the change (decoded from base64). */
+    before: string;
+    /** Content after the change (decoded from base64). */
+    after: string;
+}
+/** Full result of a snapshot diff operation. */
+export interface VfsDiff {
+    /** Paths present in `after` but not in `before`. */
+    added: VfsDiffEntry[];
+    /** Paths present in `before` but not in `after`. */
+    removed: VfsDiffEntry[];
+    /** Files whose content or mode changed between snapshots. */
+    modified: VfsDiffModified[];
+    /** True when there are no differences. */
+    clean: boolean;
+}
+/**
+ * Compute the diff between two VFS snapshots.
+ *
+ * @param before  Snapshot taken before the operation.
+ * @param after   Snapshot taken after the operation.
+ * @param options Optional filtering options.
+ * @returns A structured `VfsDiff` result.
+ */
+export declare function diffSnapshots(before: VfsSnapshot, after: VfsSnapshot, options?: {
+    /** Glob-style path prefixes to ignore (e.g. `["/proc", "/var/log"]`). */
+    ignore?: string[];
+}): VfsDiff;
+/**
+ * Format a `VfsDiff` as a human-readable string similar to `git diff --stat`.
+ *
+ * @param diff    Result from `diffSnapshots`.
+ * @param options Formatting options.
+ */
+export declare function formatDiff(diff: VfsDiff, options?: {
+    /** Show file content changes inline. Default: false. */
+    showContent?: boolean;
+    /** Max chars of content to show per change. Default: 120. */
+    maxContentChars?: number;
+}): string;
+/**
+ * Assert that a diff contains specific paths, throwing on mismatch.
+ * Designed for use in test suites.
+ *
+ * @param diff    Result from `diffSnapshots`.
+ * @param expect  Expected paths in each category.
+ * @throws When any expectation is not met.
+ */
+export declare function assertDiff(diff: VfsDiff, expect: {
+    added?: string[];
+    removed?: string[];
+    modified?: string[];
+}): void;
+//# sourceMappingURL=vfsDiff.d.ts.map

package/dist/utils/vfsDiff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vfsDiff.d.ts","sourceRoot":"","sources":["../../src/utils/vfsDiff.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,KAAK,EACX,WAAW,EAIX,MAAM,cAAc,CAAC;AAItB,oDAAoD;AACpD,MAAM,WAAW,YAAY;IAC5B,6CAA6C;IAC7C,IAAI,EAAE,MAAM,CAAC;IACb,6CAA6C;IAC7C,IAAI,EAAE,MAAM,GAAG,WAAW,CAAC;CAC3B;AAED,uEAAuE;AACvE,MAAM,WAAW,eAAgB,SAAQ,YAAY;IACpD,IAAI,EAAE,MAAM,CAAC;IACb,uDAAuD;IACvD,MAAM,EAAE,MAAM,CAAC;IACf,sDAAsD;IACtD,KAAK,EAAE,MAAM,CAAC;CACd;AAED,gDAAgD;AAChD,MAAM,WAAW,OAAO;IACvB,oDAAoD;IACpD,KAAK,EAAE,YAAY,EAAE,CAAC;IACtB,oDAAoD;IACpD,OAAO,EAAE,YAAY,EAAE,CAAC;IACxB,6DAA6D;IAC7D,QAAQ,EAAE,eAAe,EAAE,CAAC;IAC5B,0CAA0C;IAC1C,KAAK,EAAE,OAAO,CAAC;CACf;AA4BD;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAC5B,MAAM,EAAE,WAAW,EACnB,KAAK,EAAE,WAAW,EAClB,OAAO,GAAE;IACR,yEAAyE;IACzE,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;CACb,GACJ,OAAO,CAsET;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CACzB,IAAI,EAAE,OAAO,EACb,OAAO,GAAE;IACR,wDAAwD;IACxD,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,6DAA6D;IAC7D,eAAe,CAAC,EAAE,MAAM,CAAC;CACpB,GACJ,MAAM,CAsCR;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CACzB,IAAI,EAAE,OAAO,EACb,MAAM,EAAE;IACP,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;CACpB,GACC,IAAI,CA4BN"}

package/dist/utils/vfsDiff.js

@@ -0,0 +1,177 @@
+/**
+ * vfsDiff.ts
+ *
+ * Snapshot diff tooling for `VirtualFileSystem`.
+ *
+ * Compares two VFS snapshots and returns structured diff results suitable
+ * for test assertions, audit logging, and deployment verification.
+ *
+ * @example
+ * ```ts
+ * import { diffSnapshots, formatDiff } from "typescript-virtual-container/utils/vfsDiff";
+ *
+ * const before = shell.vfs.toSnapshot();
+ * await client.exec("npm install && mkdir -p /app");
+ * const after = shell.vfs.toSnapshot();
+ *
+ * const diff = diffSnapshots(before, after);
+ * console.log(formatDiff(diff));
+ *
+ * // Test assertions
+ * expect(diff.added).toContain("/app");
+ * expect(diff.modified).toContain("/etc/hosts");
+ * expect(diff.removed).not.toContain("/tmp/needed-file");
+ * ```
+ */
+// ─── internal helpers ─────────────────────────────────────────────────────────
+function flattenSnapshot(node, prefix, out) {
+    const path = prefix === "" ? "/" : prefix;
+    out.set(path, node);
+    if (node.type === "directory") {
+        for (const child of node.children ?? []) {
+            flattenSnapshot(child, `${prefix}/${child.name}`, out);
+        }
+    }
+}
+function decodeContent(node) {
+    try {
+        return Buffer.from(node.contentBase64, "base64").toString("utf8");
+    }
+    catch {
+        return node.contentBase64;
+    }
+}
+// ─── public API ───────────────────────────────────────────────────────────────
+/**
+ * Compute the diff between two VFS snapshots.
+ *
+ * @param before  Snapshot taken before the operation.
+ * @param after   Snapshot taken after the operation.
+ * @param options Optional filtering options.
+ * @returns A structured `VfsDiff` result.
+ */
+export function diffSnapshots(before, after, options = {}) {
+    const ignorePrefixes = options.ignore ?? [];
+    const shouldIgnore = (path) => ignorePrefixes.some((prefix) => path === prefix || path.startsWith(`${prefix}/`));
+    const beforeMap = new Map();
+    const afterMap = new Map();
+    flattenSnapshot(before.root, "", beforeMap);
+    flattenSnapshot(after.root, "", afterMap);
+    const added = [];
+    const removed = [];
+    const modified = [];
+    // Added — in after, not in before
+    for (const [path, node] of afterMap) {
+        if (shouldIgnore(path))
+            continue;
+        if (!beforeMap.has(path)) {
+            added.push({ path, type: node.type });
+        }
+    }
+    // Removed — in before, not in after
+    for (const [path, node] of beforeMap) {
+        if (shouldIgnore(path))
+            continue;
+        if (!afterMap.has(path)) {
+            removed.push({ path, type: node.type });
+        }
+    }
+    // Modified — in both, but content or mode changed
+    for (const [path, afterNode] of afterMap) {
+        if (shouldIgnore(path))
+            continue;
+        const beforeNode = beforeMap.get(path);
+        if (!beforeNode)
+            continue; // already in added
+        if (afterNode.type !== beforeNode.type)
+            continue; // type change = add+remove
+        if (afterNode.type === "file" && beforeNode.type === "file") {
+            const beforeContent = decodeContent(beforeNode);
+            const afterContent = decodeContent(afterNode);
+            const modeChanged = afterNode.mode !== beforeNode.mode;
+            if (beforeContent !== afterContent || modeChanged) {
+                modified.push({
+                    path,
+                    type: "file",
+                    before: beforeContent,
+                    after: afterContent,
+                });
+            }
+        }
+    }
+    // Sort all arrays for determinism
+    const sortByPath = (a, b) => a.path.localeCompare(b.path);
+    added.sort(sortByPath);
+    removed.sort(sortByPath);
+    modified.sort(sortByPath);
+    return {
+        added,
+        removed,
+        modified,
+        clean: added.length === 0 && removed.length === 0 && modified.length === 0,
+    };
+}
+/**
+ * Format a `VfsDiff` as a human-readable string similar to `git diff --stat`.
+ *
+ * @param diff    Result from `diffSnapshots`.
+ * @param options Formatting options.
+ */
+export function formatDiff(diff, options = {}) {
+    if (diff.clean)
+        return "(no changes)";
+    const { showContent = false, maxContentChars = 120 } = options;
+    const lines = [];
+    for (const entry of diff.added) {
+        lines.push(`+ ${entry.path}  [${entry.type}]`);
+    }
+    for (const entry of diff.removed) {
+        lines.push(`- ${entry.path}  [${entry.type}]`);
+    }
+    for (const entry of diff.modified) {
+        lines.push(`~ ${entry.path}  [modified]`);
+        if (showContent) {
+            const before = entry.before.slice(0, maxContentChars);
+            const after = entry.after.slice(0, maxContentChars);
+            lines.push(`  before: ${JSON.stringify(before)}${entry.before.length > maxContentChars ? "…" : ""}`);
+            lines.push(`  after:  ${JSON.stringify(after)}${entry.after.length > maxContentChars ? "…" : ""}`);
+        }
+    }
+    const summary = [
+        diff.added.length > 0 ? `${diff.added.length} added` : "",
+        diff.removed.length > 0 ? `${diff.removed.length} removed` : "",
+        diff.modified.length > 0 ? `${diff.modified.length} modified` : "",
+    ]
+        .filter(Boolean)
+        .join(", ");
+    lines.push(`\n${summary}`);
+    return lines.join("\n");
+}
+/**
+ * Assert that a diff contains specific paths, throwing on mismatch.
+ * Designed for use in test suites.
+ *
+ * @param diff    Result from `diffSnapshots`.
+ * @param expect  Expected paths in each category.
+ * @throws When any expectation is not met.
+ */
+export function assertDiff(diff, expect) {
+    const addedPaths = diff.added.map((e) => e.path);
+    const removedPaths = diff.removed.map((e) => e.path);
+    const modifiedPaths = diff.modified.map((e) => e.path);
+    for (const path of expect.added ?? []) {
+        if (!addedPaths.includes(path)) {
+            throw new Error(`assertDiff: expected "${path}" to be added, but it was not.\nAdded: ${JSON.stringify(addedPaths)}`);
+        }
+    }
+    for (const path of expect.removed ?? []) {
+        if (!removedPaths.includes(path)) {
+            throw new Error(`assertDiff: expected "${path}" to be removed, but it was not.\nRemoved: ${JSON.stringify(removedPaths)}`);
+        }
+    }
+    for (const path of expect.modified ?? []) {
+        if (!modifiedPaths.includes(path)) {
+            throw new Error(`assertDiff: expected "${path}" to be modified, but it was not.\nModified: ${JSON.stringify(modifiedPaths)}`);
+        }
+    }
+}

package/package.json

@@ -4,7 +4,7 @@
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
-  "version": "1.2.9",
+  "version": "1.3.0",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -29,6 +29,7 @@
     "build": "tsc --project tsconfig.json",
     "deploy:npm": "npm publish --access public",
     "bench": "rm -rf .benchmark-shells/ && bun benchmark-virtualshell.ts",
+    "standalone-build:wo-sftp": "bunx esbuild src/standalone-wo-sftp.ts --bundle --platform=node --target=node18 --outfile=standalone-wo-sftp.js --tree-shaking=true --minify --sourcemap",
     "publish-package": "bash ./scripts/publish-package.sh",
     "standalone-build": "bunx esbuild src/standalone.ts --bundle --platform=node --target=node18 --outfile=standalone.js --tree-shaking=true --minify --sourcemap"
   },

package/src/SSHMimic/exec.ts

@@ -17,7 +17,16 @@ export function runExec(
 	shell: VirtualShell,
 ): void {
 	Promise.resolve(
-		runCommand(cmd, authUser, hostname, "exec", `/home/${authUser}`, shell, undefined, makeDefaultEnv(authUser, hostname)),
+		runCommand(
+			cmd,
+			authUser,
+			hostname,
+			"exec",
+			`/home/${authUser}`,
+			shell,
+			undefined,
+			makeDefaultEnv(authUser, hostname),
+		),
 	)
 		.then((result) => {
 			if (result.stdout) {

package/src/SSHMimic/executor.ts

@@ -1,7 +1,12 @@
 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,25 +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 result = await runCommandDirect(cmd.name, cmd.args, 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,
+			};
 		}
 	}
 
@@ -155,11 +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 result = await runCommandDirect(cmd.name, cmd.args, 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) {
@@ -167,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);
@@ -180,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 };
-