typescript-virtual-container 1.5.5 → 1.5.7

package/dist/VirtualFileSystem/index.js

@@ -5,7 +5,7 @@ import * as path from "node:path";
 import { gunzipSync, gzipSync } from "node:zlib";
 import { decodeVfs, encodeVfs, isBinarySnapshot } from "./binaryPack";
 import { appendJournalEntry, JournalOp, readJournal, truncateJournal } from "./journal";
-import { getNode, getParentDirectory, normalizePath } from "./path";
+import { getNodeNormalized, getParentDirectory, normalizePath } from "./path";
 // ── VirtualFileSystem ─────────────────────────────────────────────────────────
 /**
  * In-memory virtual filesystem with optional JSON-snapshot persistence.
@@ -48,6 +48,8 @@ class VirtualFileSystem extends EventEmitter {
     _dirty = false;
     /** Active host-directory mounts: vPath → { hostPath, readOnly } */
     mounts = new Map();
+    /** Sorted mounts cache (longest-path-first). Rebuilt lazily on mount/unmount. */
+    _sortedMounts = null;
     /** True when running in a browser environment (no host FS access). */
     static isBrowser = typeof process === "undefined" || typeof process.versions?.node === "undefined";
     constructor(options = {}) {
@@ -93,6 +95,7 @@ class VirtualFileSystem extends EventEmitter {
             updatedAt: now,
             children: Object.create(null),
             _childCount: 0,
+            _sortedKeys: null,
         };
     }
     makeFile(name, content, mode, compressed) {
@@ -127,8 +130,10 @@ class VirtualFileSystem extends EventEmitter {
         // Don't overwrite a real file or an already-promoted node
         if (existing?.type === "file")
             return;
-        if (!existing)
+        if (!existing) {
             parent._childCount++;
+            parent._sortedKeys = null;
+        }
         parent.children[name] = this.makeStub(name, content, mode);
     }
     mkdirRecursive(targetPath, mode) {
@@ -145,6 +150,7 @@ class VirtualFileSystem extends EventEmitter {
                 child = this.makeDir(part, mode);
                 current.children[part] = child;
                 current._childCount++;
+                current._sortedKeys = null;
                 this.emit("dir:create", { path: builtPath, mode });
                 this._journal({ op: JournalOp.MKDIR, path: builtPath, mode });
             }
@@ -316,21 +322,19 @@ class VirtualFileSystem extends EventEmitter {
             const existing = live.children[name];
             if (node.type === "directory") {
                 if (!existing) {
-                    // Dir doesn't exist yet — add it
                     live.children[name] = node;
                     live._childCount++;
+                    live._sortedKeys = null;
                 }
                 else if (existing.type === "directory") {
-                    // Both dirs — recurse
                     this._mergeDir(existing, node);
                 }
-                // existing is a file where dir expected — leave user file alone
             }
             else {
-                // File or stub — only add if not already present
                 if (!existing) {
                     live.children[name] = node;
                     live._childCount++;
+                    live._sortedKeys = null;
                 }
             }
         }
@@ -495,6 +499,7 @@ class VirtualFileSystem extends EventEmitter {
         // Ensure the mount point exists in the VFS tree
         this.mkdir(normalized);
         this.mounts.set(normalized, { hostPath: resolved, readOnly });
+        this._sortedMounts = null;
         this.emit("mount", { vPath: normalized, hostPath: resolved, readOnly });
     }
     /**
@@ -505,6 +510,7 @@ class VirtualFileSystem extends EventEmitter {
     unmount(vPath) {
         const normalized = normalizePath(vPath);
         if (this.mounts.delete(normalized)) {
+            this._sortedMounts = null;
             this.emit("unmount", { vPath: normalized });
         }
     }
@@ -521,9 +527,11 @@ class VirtualFileSystem extends EventEmitter {
      */
     resolveMount(targetPath) {
         const normalized = normalizePath(targetPath);
-        // Iterate mounts from most specific to least specific
-        const sorted = [...this.mounts.entries()].sort(([a], [b]) => b.length - a.length);
-        for (const [vBase, opts] of sorted) {
+        // Iterate mounts from most specific to least specific (cached, rebuilt on mount/unmount)
+        if (!this._sortedMounts) {
+            this._sortedMounts = [...this.mounts.entries()].sort(([a], [b]) => b.length - a.length);
+        }
+        for (const [vBase, opts] of this._sortedMounts) {
             if (normalized === vBase || normalized.startsWith(`${vBase}/`)) {
                 const relPath = normalized.slice(vBase.length).replace(/^\//, "");
                 const fullHostPath = relPath ? path.join(opts.hostPath, relPath) : opts.hostPath;
@@ -536,7 +544,7 @@ class VirtualFileSystem extends EventEmitter {
         const normalized = normalizePath(targetPath);
         const existing = (() => {
             try {
-                return getNode(this.root, normalized);
+                return getNodeNormalized(this.root, normalized);
             }
             catch {
                 return null;
@@ -585,8 +593,10 @@ class VirtualFileSystem extends EventEmitter {
         }
         else {
             // Create new real file — also promotes stubs (no _childCount change for stubs)
-            if (!existing)
+            if (!existing) {
                 parent._childCount++;
+                parent._sortedKeys = null;
+            }
             parent.children[name] = this.makeFile(name, storedContent, mode, shouldCompress);
         }
         this.emit("file:write", { path: normalized, size: storedContent.length });
@@ -604,7 +614,7 @@ class VirtualFileSystem extends EventEmitter {
             return fsSync.readFileSync(m.fullHostPath, "utf8");
         }
         const normalized = normalizePath(targetPath);
-        const node = getNode(this.root, normalized);
+        const node = getNodeNormalized(this.root, normalized);
         if (node.type === "stub") {
             this.emit("file:read", { path: normalized, size: node.stubContent.length });
             return node.stubContent;
@@ -628,7 +638,7 @@ class VirtualFileSystem extends EventEmitter {
             return fsSync.readFileSync(m.fullHostPath);
         }
         const normalized = normalizePath(targetPath);
-        const node = getNode(this.root, normalized);
+        const node = getNodeNormalized(this.root, normalized);
         if (node.type === "stub") {
             const buf = Buffer.from(node.stubContent, "utf8");
             this.emit("file:read", { path: normalized, size: buf.length });
@@ -650,7 +660,7 @@ class VirtualFileSystem extends EventEmitter {
         if (m)
             return fsSync.existsSync(m.fullHostPath);
         try {
-            getNode(this.root, normalizePath(targetPath));
+            getNodeNormalized(this.root, normalizePath(targetPath));
             return true;
         }
         catch {
@@ -660,7 +670,7 @@ class VirtualFileSystem extends EventEmitter {
     /** Updates mode bits on a node. */
     chmod(targetPath, mode) {
         const normalized = normalizePath(targetPath);
-        getNode(this.root, normalized).mode = mode;
+        getNodeNormalized(this.root, normalized).mode = mode;
         this._journal({ op: JournalOp.CHMOD, path: normalized, mode });
     }
     /** Returns metadata for a file or directory. */
@@ -695,7 +705,7 @@ class VirtualFileSystem extends EventEmitter {
             };
         }
         const normalized = normalizePath(targetPath);
-        const node = getNode(this.root, normalized);
+        const node = getNodeNormalized(this.root, normalized);
         const name = normalized === "/" ? "" : path.posix.basename(normalized);
         if (node.type === "stub") {
             const s = node;
@@ -734,6 +744,26 @@ class VirtualFileSystem extends EventEmitter {
             childrenCount: d._childCount,
         };
     }
+    /**
+     * Fast type-only check — no Date/string allocation.
+     * Use instead of `stat().type` when that's all you need.
+     */
+    statType(targetPath) {
+        try {
+            const m = this.resolveMount(targetPath);
+            if (m) {
+                const s = fsSync.statSync(m.fullHostPath, { throwIfNoEntry: false });
+                if (!s)
+                    return null;
+                return s.isDirectory() ? "directory" : "file";
+            }
+            const node = getNodeNormalized(this.root, normalizePath(targetPath));
+            return node.type === "directory" ? "directory" : "file";
+        }
+        catch {
+            return null;
+        }
+    }
     /** Lists direct children names of a directory (sorted). */
     list(dirPath = "/") {
         const m = this.resolveMount(dirPath);
@@ -748,16 +778,19 @@ class VirtualFileSystem extends EventEmitter {
             }
         }
         const normalized = normalizePath(dirPath);
-        const node = getNode(this.root, normalized);
+        const node = getNodeNormalized(this.root, normalized);
         if (node.type !== "directory") {
             throw new Error(`Cannot list '${dirPath}': not a directory.`);
         }
-        return Object.keys(node.children).sort();
+        const dir = node;
+        if (!dir._sortedKeys)
+            dir._sortedKeys = Object.keys(dir.children).sort();
+        return dir._sortedKeys;
     }
     /** Renders ASCII tree view of a directory hierarchy. */
     tree(dirPath = "/") {
         const normalized = normalizePath(dirPath);
-        const node = getNode(this.root, normalized);
+        const node = getNodeNormalized(this.root, normalized);
         if (node.type !== "directory") {
             throw new Error(`Cannot render tree for '${dirPath}': not a directory.`);
         }
@@ -766,7 +799,9 @@ class VirtualFileSystem extends EventEmitter {
     }
     renderTreeLines(dir, label) {
         const lines = [label];
-        const entries = Object.keys(dir.children).sort();
+        if (!dir._sortedKeys)
+            dir._sortedKeys = Object.keys(dir.children).sort();
+        const entries = dir._sortedKeys;
         for (let i = 0; i < entries.length; i++) {
             const name = entries[i];
             const child = dir.children[name];
@@ -786,7 +821,7 @@ class VirtualFileSystem extends EventEmitter {
     }
     /** Computes total stored bytes under a path. */
     getUsageBytes(targetPath = "/") {
-        return this.computeUsage(getNode(this.root, normalizePath(targetPath)));
+        return this.computeUsage(getNodeNormalized(this.root, normalizePath(targetPath)));
     }
     computeUsage(node) {
         if (node.type === "file")
@@ -801,7 +836,7 @@ class VirtualFileSystem extends EventEmitter {
     }
     /** Compresses a file's content with gzip in place. */
     compressFile(targetPath) {
-        const node = getNode(this.root, normalizePath(targetPath));
+        const node = getNodeNormalized(this.root, normalizePath(targetPath));
         if (node.type !== "file")
             throw new Error(`Cannot compress '${targetPath}': not a file.`);
         const f = node;
@@ -813,7 +848,7 @@ class VirtualFileSystem extends EventEmitter {
     }
     /** Decompresses a gzip-compressed file in place. */
     decompressFile(targetPath) {
-        const node = getNode(this.root, normalizePath(targetPath));
+        const node = getNodeNormalized(this.root, normalizePath(targetPath));
         if (node.type !== "file")
             throw new Error(`Cannot decompress '${targetPath}': not a file.`);
         const f = node;
@@ -844,6 +879,7 @@ class VirtualFileSystem extends EventEmitter {
         };
         parent.children[name] = symNode;
         parent._childCount++;
+        parent._sortedKeys = null;
         // Journal before emit
         this._journal({ op: JournalOp.SYMLINK, path: normalizedLink, dest: normalizedTarget });
         this.emit("symlink:create", {
@@ -854,7 +890,7 @@ class VirtualFileSystem extends EventEmitter {
     /** Returns true when the path is a symbolic link node. */
     isSymlink(targetPath) {
         try {
-            const node = getNode(this.root, normalizePath(targetPath));
+            const node = getNodeNormalized(this.root, normalizePath(targetPath));
             return node.type === "file" && node.mode === 0o120777;
         }
         catch {
@@ -869,7 +905,7 @@ class VirtualFileSystem extends EventEmitter {
         let current = normalizePath(linkPath);
         for (let depth = 0; depth < maxDepth; depth++) {
             try {
-                const node = getNode(this.root, current);
+                const node = getNodeNormalized(this.root, current);
                 if (node.type === "file" && node.mode === 0o120777) {
                     const target = node.content.toString("utf8");
                     current = target.startsWith("/")
@@ -905,7 +941,7 @@ class VirtualFileSystem extends EventEmitter {
         const normalized = normalizePath(targetPath);
         if (normalized === "/")
             throw new Error("Cannot remove root directory.");
-        const node = getNode(this.root, normalized);
+        const node = getNodeNormalized(this.root, normalized);
         if (node.type === "directory") {
             const dir = node;
             if (!options.recursive && dir._childCount > 0) {
@@ -915,6 +951,7 @@ class VirtualFileSystem extends EventEmitter {
         const { parent, name } = getParentDirectory(this.root, normalized, false, () => { });
         delete parent.children[name];
         parent._childCount--;
+        parent._sortedKeys = null;
         this.emit("node:remove", { path: normalized });
         this._journal({ op: JournalOp.REMOVE, path: normalized });
     }
@@ -925,7 +962,7 @@ class VirtualFileSystem extends EventEmitter {
         if (fromNormalized === "/" || toNormalized === "/") {
             throw new Error("Cannot move root directory.");
         }
-        const node = getNode(this.root, fromNormalized);
+        const node = getNodeNormalized(this.root, fromNormalized);
         if (this.exists(toNormalized)) {
             throw new Error(`Destination '${toNormalized}' already exists.`);
         }
@@ -934,9 +971,11 @@ class VirtualFileSystem extends EventEmitter {
         const { parent: srcParent, name: srcName } = getParentDirectory(this.root, fromNormalized, false, () => { });
         delete srcParent.children[srcName];
         srcParent._childCount--;
+        srcParent._sortedKeys = null;
         node.name = destName;
         destParent.children[destName] = node;
         destParent._childCount++;
+        destParent._sortedKeys = null;
         this._journal({ op: JournalOp.MOVE, path: fromNormalized, dest: toNormalized });
     }
     // ── Snapshot serialisation ─────────────────────────────────────────────────
@@ -1026,6 +1065,7 @@ class VirtualFileSystem extends EventEmitter {
             updatedAt: Date.parse(snap.updatedAt),
             children: Object.create(null),
             _childCount: 0,
+            _sortedKeys: null,
         };
         for (const child of snap.children) {
             if (child.type === "file") {

package/dist/VirtualFileSystem/internalTypes.d.ts

@@ -36,5 +36,7 @@ export interface InternalDirectoryNode extends InternalBaseNode {
     children: Record<string, InternalNode>;
     /** Cached child count — avoids O(n) Object.keys() on hot paths. */
     _childCount: number;
+    /** Cached sorted child names — null means stale, rebuilt lazily by list(). */
+    _sortedKeys: string[] | null;
 }
 export {};

package/dist/VirtualFileSystem/path.d.ts

@@ -2,6 +2,11 @@ import type { InternalDirectoryNode, InternalNode } from "./internalTypes";
 export declare function normalizePath(rawPath: string): string;
 export declare function splitPath(normalizedPath: string): string[];
 export declare function getNode(root: InternalDirectoryNode, targetPath: string): InternalNode;
+/**
+ * Like getNode but skips normalization — caller must pass an already-normalized path.
+ * Avoids double normalizePath() when the caller has already normalized.
+ */
+export declare function getNodeNormalized(root: InternalDirectoryNode, normalized: string): InternalNode;
 export declare function getParentDirectory(root: InternalDirectoryNode, targetPath: string, createIfMissing: boolean, createPath: (pathToCreate: string) => void): {
     parent: InternalDirectoryNode;
     name: string;

package/dist/VirtualFileSystem/path.js

@@ -11,20 +11,33 @@ export function splitPath(normalizedPath) {
 }
 export function getNode(root, targetPath) {
     const normalized = normalizePath(targetPath);
-    if (normalized === "/") {
+    return getNodeNormalized(root, normalized);
+}
+/**
+ * Like getNode but skips normalization — caller must pass an already-normalized path.
+ * Avoids double normalizePath() when the caller has already normalized.
+ */
+export function getNodeNormalized(root, normalized) {
+    if (normalized === "/")
         return root;
-    }
-    const parts = splitPath(normalized);
     let current = root;
-    for (const part of parts) {
-        if (current.type !== "directory") {
-            throw new Error(`Path '${normalized}' does not exist.`);
-        }
-        const next = current.children[part];
-        if (!next) {
-            throw new Error(`Path '${normalized}' does not exist.`);
+    let i = 1; // skip leading "/"
+    while (i <= normalized.length) {
+        const slash = normalized.indexOf("/", i);
+        const end = slash === -1 ? normalized.length : slash;
+        const part = normalized.slice(i, end);
+        if (part) {
+            if (current.type !== "directory") {
+                throw new Error(`Path '${normalized}' does not exist.`);
+            }
+            const next = current.children[part];
+            if (!next)
+                throw new Error(`Path '${normalized}' does not exist.`);
+            current = next;
         }
-        current = next;
+        if (slash === -1)
+            break;
+        i = slash + 1;
     }
     return current;
 }

package/dist/VirtualPackageManager/index.d.ts

@@ -94,18 +94,20 @@ export declare class VirtualPackageManager {
     private readonly registryPath;
     private readonly logPath;
     private readonly aptLogPath;
+    private _loaded;
     /**
      * @param vfs   Backing virtual filesystem for file I/O and dpkg status persistence.
      * @param users User manager reference passed to `onInstall` hooks.
      */
     constructor(vfs: VirtualFileSystem, users: VirtualUserManager);
+    /** Ensure dpkg/status is parsed. Called lazily on first package operation. */
+    private _ensureLoaded;
     /**
      * Loads installed package state from `/var/lib/dpkg/status` in the VFS.
-     *
-     * Called automatically by `VirtualShell` after `bootstrapLinuxRootfs`.
      * Safe to call again to reload state after a snapshot restore.
      */
     load(): void;
+    private _parseStatus;
     /** Persist installed state to /var/lib/dpkg/status. */
     private persist;
     private parseFields;

package/dist/VirtualPackageManager/index.js

@@ -502,6 +502,10 @@ const PACKAGE_REGISTRY = [
         ],
     }
 ];
+// O(1) name lookup — built once at module load, avoids O(n) linear scan per command
+const _REGISTRY_MAP = new Map(PACKAGE_REGISTRY.map((p) => [p.name.toLowerCase(), p]));
+// Pre-sorted for listAvailable() — avoids O(n log n) sort on every apt list/search
+const _REGISTRY_SORTED = PACKAGE_REGISTRY.slice().sort((a, b) => a.name.localeCompare(b.name));
 /**
  * Pure-TypeScript APT/dpkg package manager backed by a built-in registry.
  *
@@ -526,6 +530,7 @@ export class VirtualPackageManager {
     registryPath = "/var/lib/dpkg/status";
     logPath = "/var/log/dpkg.log";
     aptLogPath = "/var/log/apt/history.log";
+    _loaded = false;
     /**
      * @param vfs   Backing virtual filesystem for file I/O and dpkg status persistence.
      * @param users User manager reference passed to `onInstall` hooks.
@@ -534,13 +539,22 @@ export class VirtualPackageManager {
         this.vfs = vfs;
         this.users = users;
     }
+    /** Ensure dpkg/status is parsed. Called lazily on first package operation. */
+    _ensureLoaded() {
+        if (this._loaded)
+            return;
+        this._loaded = true;
+        this._parseStatus();
+    }
     /**
      * Loads installed package state from `/var/lib/dpkg/status` in the VFS.
-     *
-     * Called automatically by `VirtualShell` after `bootstrapLinuxRootfs`.
      * Safe to call again to reload state after a snapshot restore.
      */
     load() {
+        this._loaded = false;
+        this._ensureLoaded();
+    }
+    _parseStatus() {
         if (!this.vfs.exists(this.registryPath))
             return;
         const status = this.vfs.readFile(this.registryPath);
@@ -626,7 +640,7 @@ export class VirtualPackageManager {
      * @returns The matching `PackageDefinition`, or `undefined` if not found.
      */
     findInRegistry(name) {
-        return PACKAGE_REGISTRY.find((p) => p.name.toLowerCase() === name.toLowerCase());
+        return _REGISTRY_MAP.get(name.toLowerCase());
     }
     /**
      * Returns all packages in the built-in registry, sorted alphabetically.
@@ -634,7 +648,7 @@ export class VirtualPackageManager {
      * @returns Array of `PackageDefinition` entries.
      */
     listAvailable() {
-        return [...PACKAGE_REGISTRY].sort((a, b) => a.name.localeCompare(b.name));
+        return _REGISTRY_SORTED;
     }
     /**
      * Returns all currently installed packages, sorted alphabetically.
@@ -642,6 +656,7 @@ export class VirtualPackageManager {
      * @returns Array of `InstalledPackage` records.
      */
     listInstalled() {
+        this._ensureLoaded();
         return [...this.installed.values()].sort((a, b) => a.name.localeCompare(b.name));
     }
     /**
@@ -650,6 +665,7 @@ export class VirtualPackageManager {
      * @param name Package name (case-insensitive).
      */
     isInstalled(name) {
+        this._ensureLoaded();
         return this.installed.has(name.toLowerCase());
     }
     /**
@@ -658,6 +674,7 @@ export class VirtualPackageManager {
      * Used by `neofetch` to populate the `Packages:` field.
      */
     installedCount() {
+        this._ensureLoaded();
         return this.installed.size;
     }
     /**
@@ -675,6 +692,7 @@ export class VirtualPackageManager {
      *          (`0` on success, `100` when a package is not found).
      */
     install(names, opts = {}) {
+        this._ensureLoaded();
         const lines = [];
         const toInstall = [];
         const notFound = [];
@@ -770,6 +788,7 @@ export class VirtualPackageManager {
      * @returns Terminal-style `output` string and exit code (`0` on success).
      */
     remove(names, opts = {}) {
+        this._ensureLoaded();
         const lines = [];
         const toRemove = [];
         for (const name of names) {
@@ -833,6 +852,7 @@ export class VirtualPackageManager {
      * @returns Multi-line metadata string, or `null` if not in the registry.
      */
     show(name) {
+        this._ensureLoaded();
         const def = this.findInRegistry(name);
         if (!def)
             return null;

package/dist/VirtualShell/index.d.ts

@@ -29,6 +29,10 @@ export interface ShellProperties {
     os: string;
     /** CPU architecture label (e.g. `"x86_64"`, `"aarch64"`). */
     arch: string;
+    /** Display resolution (e.g. `"1920x1080"`). */
+    resolution?: string;
+    /** GPU label (e.g. `"WebGL Renderer"`). */
+    gpu?: string;
 }
 /**
  * Minimal VFS interface accepted by {@link VirtualShell} as a drop-in replacement

package/dist/VirtualShell/index.js

@@ -27,10 +27,7 @@ function isVirtualShellVfsLike(value) {
         typeof candidate.exists === "function" &&
         typeof candidate.stat === "function" &&
         typeof candidate.list === "function" &&
-        typeof candidate.remove === "function" &&
-        typeof candidate.copy === "function" &&
-        typeof candidate.move === "function" &&
-        typeof candidate.touch === "function");
+        typeof candidate.remove === "function");
 }
 const defaultShellProperties = {
     kernel: "1.0.0+itsrealfortune+1-amd64",
@@ -110,7 +107,6 @@ class VirtualShell extends EventEmitter {
         // 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;
@@ -120,8 +116,6 @@ class VirtualShell extends EventEmitter {
             await users.initialize();
             // Bootstrap Linux rootfs (idempotent)
             bootstrapLinuxRootfs(vfs, users, shellHostname, shellProps, startTime);
-            // Load installed packages from dpkg status
-            pm.load();
             this.emit("initialized");
         })();
     }

package/dist/VirtualShell/shell.js

@@ -14,6 +14,7 @@ export function startShell(properties, stream, authUser, hostname, sessionId, re
     let cwd = userHome(authUser);
     let pendingHeredoc = null;
     const shellEnv = makeDefaultEnv(authUser, hostname);
+    const sessionStack = [];
     let nanoSession = null;
     let pendingSudo = null;
     const buildCurrentPrompt = () => {
@@ -112,6 +113,7 @@ export function startShell(properties, stream, authUser, hostname, sessionId, re
             stream.write(`${toTtyLines(result.stderr)}\r\n`);
         }
         if (result.switchUser) {
+            sessionStack.push({ authUser, cwd });
             authUser = result.switchUser;
             cwd = result.nextCwd ?? userHome(authUser);
             shell.users.updateSession(sessionId, authUser, remoteAddress);
@@ -396,13 +398,24 @@ export function startShell(properties, stream, authUser, hostname, sessionId, re
                 cursorPos = 0;
                 historyIndex = null;
                 historyDraft = "";
-                stream.write("bye\r\n");
-                pushHistory("bye");
-                // WAL: checkpoint handled by auto-flush timer
                 stream.write("logout\r\n");
-                stream.exit(0);
-                stream.end();
-                return;
+                if (sessionStack.length > 0) {
+                    const prev = sessionStack.pop();
+                    authUser = prev.authUser;
+                    cwd = prev.cwd;
+                    shellEnv.vars.USER = authUser;
+                    shellEnv.vars.LOGNAME = authUser;
+                    shellEnv.vars.HOME = userHome(authUser);
+                    shellEnv.vars.PWD = cwd;
+                    shell.users.updateSession(sessionId, authUser, remoteAddress);
+                    renderLine();
+                }
+                else {
+                    stream.exit(0);
+                    stream.end();
+                    return;
+                }
+                continue;
             }
             if (ch === "\t") {
                 handleTabCompletion();
@@ -598,16 +611,33 @@ export function startShell(properties, stream, authUser, hostname, sessionId, re
                     }
                     if (result.closeSession) {
                         stream.write("logout\r\n");
-                        stream.exit(result.exitCode ?? 0);
-                        stream.end();
-                        return;
+                        if (sessionStack.length > 0) {
+                            const prev = sessionStack.pop();
+                            authUser = prev.authUser;
+                            cwd = prev.cwd;
+                            shellEnv.vars.USER = authUser;
+                            shellEnv.vars.LOGNAME = authUser;
+                            shellEnv.vars.HOME = userHome(authUser);
+                            shellEnv.vars.PWD = cwd;
+                            shell.users.updateSession(sessionId, authUser, remoteAddress);
+                        }
+                        else {
+                            stream.exit(result.exitCode ?? 0);
+                            stream.end();
+                            return;
+                        }
                     }
-                    if (result.nextCwd) {
+                    if (result.nextCwd && !result.closeSession) {
                         cwd = result.nextCwd;
                     }
                     if (result.switchUser) {
+                        sessionStack.push({ authUser, cwd });
                         authUser = result.switchUser;
                         cwd = result.nextCwd ?? userHome(authUser);
+                        shellEnv.vars.USER = authUser;
+                        shellEnv.vars.LOGNAME = authUser;
+                        shellEnv.vars.HOME = userHome(authUser);
+                        shellEnv.vars.PWD = cwd;
                         shell.users.updateSession(sessionId, authUser, remoteAddress);
                         lineBuffer = "";
                         cursorPos = 0;