typescript-virtual-container 1.4.0 → 1.4.2

package/dist/self-standalone.js

@@ -1,14 +1,18 @@
 import { readFile, unlink, writeFile } from "node:fs/promises";
+import * as path from "node:path";
 import { basename } from "node:path";
 import { stdin, stdout } from "node:process";
 import { createInterface } from "node:readline";
+import { getCommandNames } from "./commands/registry";
 import { makeDefaultEnv, runCommand } from "./commands/runtime";
 import { spawnNanoEditorProcess } from "./modules/shellInteractive";
+import { resolvePath } from "./modules/shellRuntime";
 import { buildLoginBanner } from "./SSHMimic/loginBanner";
 import { buildPrompt } from "./SSHMimic/prompt";
 import { VirtualShell } from "./VirtualShell";
 const hostname = process.env.SSH_MIMIC_HOSTNAME ?? "typescript-vm";
 const argv = process.argv.slice(2);
+// ── CLI args ──────────────────────────────────────────────────────────────────
 function readUserArg() {
     for (let index = 0; index < argv.length; index += 1) {
         const current = argv[index];
@@ -30,11 +34,11 @@ const virtualShell = new VirtualShell(hostname, undefined, {
     mode: "fs",
     snapshotPath: ".vfs",
 });
+// ── VFS helpers ───────────────────────────────────────────────────────────────
 function readLastLogin(username) {
-    const lastlogPath = `/virtual-env-js/.lastlog/${username}.json`;
-    if (!virtualShell.vfs.exists(lastlogPath)) {
+    const lastlogPath = `/home/${username}/.lastlog`;
+    if (!virtualShell.vfs.exists(lastlogPath))
         return null;
-    }
     try {
         return JSON.parse(virtualShell.vfs.readFile(lastlogPath));
     }
@@ -42,6 +46,63 @@ function readLastLogin(username) {
         return null;
     }
 }
+function writeLastLogin(username, from) {
+    virtualShell.vfs.writeFile(`/home/${username}/.lastlog`, JSON.stringify({ at: new Date().toISOString(), from }));
+}
+async function flushVfs() {
+    await virtualShell.vfs.flushMirror();
+}
+function loadHistory(authUser) {
+    const historyPath = `/home/${authUser}/.bash_history`;
+    if (!virtualShell.vfs.exists(historyPath)) {
+        virtualShell.vfs.writeFile(historyPath, "");
+        return [];
+    }
+    return virtualShell.vfs
+        .readFile(historyPath)
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+}
+function saveHistory(history, authUser) {
+    const data = history.length > 0 ? `${history.join("\n")}\n` : "";
+    virtualShell.vfs.writeFile(`/home/${authUser}/.bash_history`, data);
+}
+// ── Tab completion ────────────────────────────────────────────────────────────
+function listPathCompletions(vfs, cwd, prefix) {
+    const slashIndex = prefix.lastIndexOf("/");
+    const dirPart = slashIndex >= 0 ? prefix.slice(0, slashIndex + 1) : "";
+    const namePart = slashIndex >= 0 ? prefix.slice(slashIndex + 1) : prefix;
+    const basePath = resolvePath(cwd, dirPart || ".");
+    try {
+        return vfs
+            .list(basePath)
+            .filter((e) => !e.startsWith(".") && e.startsWith(namePart))
+            .map((e) => {
+            const fullPath = path.posix.join(basePath, e);
+            const st = vfs.stat(fullPath);
+            return `${dirPart}${e}${st.type === "directory" ? "/" : ""}`;
+        })
+            .sort();
+    }
+    catch {
+        return [];
+    }
+}
+function makeCompleter(getState) {
+    const commandNames = Array.from(new Set(getCommandNames())).sort();
+    return (line, cb) => {
+        const { cwd } = getState();
+        // Extract the token under/before cursor (last whitespace-separated word)
+        const token = line.split(/\s+/).at(-1) ?? "";
+        const isFirstToken = line.trimStart() === token;
+        const cmdHits = isFirstToken ? commandNames.filter((n) => n.startsWith(token)) : [];
+        const pathHits = listPathCompletions(virtualShell.vfs, cwd, token);
+        const hits = Array.from(new Set([...cmdHits, ...pathHits])).sort();
+        cb(null, [hits, token]);
+    };
+}
+// ── Hidden password input ─────────────────────────────────────────────────────
 function askHiddenQuestion(rl, promptText) {
     return new Promise((resolve) => {
         if (!stdin.isTTY || !stdout.isTTY) {
@@ -52,10 +113,8 @@ function askHiddenQuestion(rl, promptText) {
         let buffer = "";
         const cleanup = () => {
             stdin.off("data", onData);
-            if (!wasRawMode) {
+            if (!wasRawMode)
                 stdin.setRawMode(false);
-            }
-            rl.resume();
         };
         const finish = (value) => {
             cleanup();
@@ -64,8 +123,8 @@ function askHiddenQuestion(rl, promptText) {
         };
         const onData = (chunk) => {
             const input = chunk.toString("utf8");
-            for (let index = 0; index < input.length; index += 1) {
-                const ch = input[index];
+            for (let i = 0; i < input.length; i += 1) {
+                const ch = input[i];
                 if (ch === "\r" || ch === "\n") {
                     finish(buffer);
                     return;
@@ -74,46 +133,20 @@ function askHiddenQuestion(rl, promptText) {
                     buffer = buffer.slice(0, -1);
                     continue;
                 }
-                if (ch >= " ") {
+                if (ch >= " ")
                     buffer += ch;
-                }
             }
         };
+        // Pause readline so it doesn't eat our raw keystrokes
         rl.pause();
         stdout.write(promptText);
-        if (!wasRawMode) {
+        if (!wasRawMode)
             stdin.setRawMode(true);
-        }
         stdin.resume();
         stdin.on("data", onData);
     });
 }
-function writeLastLogin(username, from) {
-    const dir = "/virtual-env-js/.lastlog";
-    if (!virtualShell.vfs.exists(dir)) {
-        virtualShell.vfs.mkdir(dir, 0o700);
-    }
-    virtualShell.vfs.writeFile(`/virtual-env-js/.lastlog/${username}.json`, JSON.stringify({ at: new Date().toISOString(), from }));
-}
-async function flushVfs() {
-    await virtualShell.vfs.flushMirror();
-}
-function loadHistory() {
-    const historyPath = "/virtual-env-js/.bash_history";
-    if (!virtualShell.vfs.exists(historyPath)) {
-        virtualShell.vfs.writeFile(historyPath, "");
-        return [];
-    }
-    return virtualShell.vfs
-        .readFile(historyPath)
-        .split("\n")
-        .map((line) => line.trim())
-        .filter((line) => line.length > 0);
-}
-function saveHistory(history) {
-    const data = history.length > 0 ? `${history.join("\n")}\n` : "";
-    virtualShell.vfs.writeFile("/virtual-env-js/.bash_history", data);
-}
+// ── Session state helper ──────────────────────────────────────────────────────
 function applySessionState(authUserState, cwdState, result, shellEnvState) {
     let authUser = authUserState;
     let cwd = cwdState;
@@ -131,21 +164,16 @@ function applySessionState(authUserState, cwdState, result, shellEnvState) {
     }
     return { authUser, cwd };
 }
-virtualShell.addCommand("demo", [], () => {
-    return {
-        stdout: "This is a demo command. It does nothing useful.",
-        exitCode: 0,
-    };
-});
+// ── Demo command ──────────────────────────────────────────────────────────────
+virtualShell.addCommand("demo", [], () => ({
+    stdout: "This is a demo command. It does nothing useful.",
+    exitCode: 0,
+}));
+// ── Main shell ────────────────────────────────────────────────────────────────
 async function runReadlineShell() {
-    const rl = createInterface({ input: stdin, output: stdout, terminal: true });
     await virtualShell.ensureInitialized();
-    let history = loadHistory();
-    const rlWithHistory = rl;
-    rlWithHistory.history = [...history].reverse();
     const selectedUser = initialUser.trim() || "root";
-    const userExists = virtualShell.users.getPasswordHash(selectedUser) !== null;
-    if (!userExists) {
+    if (virtualShell.users.getPasswordHash(selectedUser) === null) {
         process.stderr.write(`self-standalone: user '${selectedUser}' does not exist\n`);
         process.exit(1);
     }
@@ -154,10 +182,19 @@ async function runReadlineShell() {
     let cwd = `/home/${authUser}`;
     shellEnv.vars.PWD = cwd;
     const remoteAddress = "localhost";
-    const terminalSize = {
-        cols: stdout.columns ?? 80,
-        rows: stdout.rows ?? 24,
-    };
+    const terminalSize = { cols: stdout.columns ?? 80, rows: stdout.rows ?? 24 };
+    let history = loadHistory(authUser);
+    // completer reads cwd via closure — always current
+    const rl = createInterface({
+        input: stdin,
+        output: stdout,
+        terminal: true,
+        completer: makeCompleter(() => ({ cwd })),
+    });
+    // Sync readline's internal history with our VFS history
+    const rlWithHistory = rl;
+    rlWithHistory.history = [...history].reverse();
+    // ── nano editor ────────────────────────────────────────────────────────────
     async function startNanoEditor(targetPath, initialContent, tempPath) {
         if (virtualShell.vfs.exists(targetPath)) {
             await writeFile(tempPath, initialContent, "utf8");
@@ -169,20 +206,16 @@ async function runReadlineShell() {
             end: () => undefined,
         });
         const wasRawMode = Boolean(stdin.isRaw);
-        const forwardInput = (chunk) => {
-            editor.stdin.write(chunk);
-        };
+        const forwardInput = (chunk) => { editor.stdin.write(chunk); };
         stdin.resume();
-        if (!wasRawMode) {
+        if (!wasRawMode)
             stdin.setRawMode(true);
-        }
         stdin.on("data", forwardInput);
         await new Promise((resolve) => {
             const cleanup = () => {
                 stdin.off("data", forwardInput);
-                if (!wasRawMode) {
+                if (!wasRawMode)
                     stdin.setRawMode(false);
-                }
                 rl.resume();
             };
             editor.on("error", (error) => {
@@ -199,7 +232,7 @@ async function runReadlineShell() {
                     await flushVfs();
                 }
                 catch {
-                    // Save skipped or temp file missing.
+                    // save skipped or temp file missing
                 }
                 await unlink(tempPath).catch(() => undefined);
                 stdout.write("\r\n");
@@ -207,6 +240,7 @@ async function runReadlineShell() {
             });
         });
     }
+    // ── challenge handlers ─────────────────────────────────────────────────────
     async function handleSudoChallenge(challenge) {
         if (challenge.onPassword) {
             let promptText = challenge.prompt;
@@ -275,6 +309,7 @@ async function runReadlineShell() {
                 break;
         }
     }
+    // handleCommandResult must be declared before the "line" handler
     async function handleCommandResult(result) {
         if (result.openEditor) {
             await startNanoEditor(result.openEditor.targetPath, result.openEditor.initialContent, result.openEditor.tempPath);
@@ -288,32 +323,26 @@ async function runReadlineShell() {
             await handlePasswordChallenge(result.passwordChallenge);
             return;
         }
+        if (result.clearScreen) {
+            stdout.write("\u001b[2J\u001b[H");
+            console.clear();
+        }
         if (result.stdout) {
             stdout.write(result.stdout.endsWith("\n") ? result.stdout : `${result.stdout}\n`);
         }
         if (result.stderr) {
             process.stderr.write(result.stderr.endsWith("\n") ? result.stderr : `${result.stderr}\n`);
         }
-        if (result.clearScreen) {
-            stdout.write("\u001b[2J\u001b[H");
-            console.clear();
-        }
-        const updatedState = applySessionState(authUser, cwd, result, shellEnv);
-        authUser = updatedState.authUser;
-        cwd = updatedState.cwd;
+        const updated = applySessionState(authUser, cwd, result, shellEnv);
+        authUser = updated.authUser;
+        cwd = updated.cwd;
         if (result.closeSession) {
             await flushVfs();
             rl.close();
             process.exit(result.exitCode ?? 0);
         }
     }
-    if (process.env.USER !== "root" && virtualShell.users.hasPassword(authUser)) {
-        const password = await askHiddenQuestion(rl, `Password for ${authUser}: `);
-        if (!virtualShell.users.verifyPassword(authUser, password)) {
-            process.stderr.write("self-standalone: authentication failed\n");
-            process.exit(1);
-        }
-    }
+    // ── Prompt helper ──────────────────────────────────────────────────────────
     const renderPrompt = () => {
         const cwdLabel = cwd === `/home/${authUser}` ? "~" : basename(cwd) || "/";
         return buildPrompt(authUser, hostname, cwdLabel);
@@ -322,50 +351,68 @@ async function runReadlineShell() {
         rl.setPrompt(renderPrompt());
         rl.prompt();
     };
-    rl.on("SIGINT", () => {
-        stdout.write("^C\n");
-        rl.write("", { ctrl: true, name: "u" });
-        prompt();
-    });
-    rl.on("close", () => {
-        void (async () => {
-            await flushVfs();
-            console.log("");
-            process.exit(0);
-        })();
-    });
+    // ── Auth (password gate) ───────────────────────────────────────────────────
+    if (process.env.USER !== "root" && virtualShell.users.hasPassword(authUser)) {
+        const password = await askHiddenQuestion(rl, `Password for ${authUser}: `);
+        if (!virtualShell.users.verifyPassword(authUser, password)) {
+            process.stderr.write("self-standalone: authentication failed\n");
+            process.exit(1);
+        }
+    }
+    // ── Login banner ───────────────────────────────────────────────────────────
     stdout.write(buildLoginBanner(hostname, virtualShell.properties, readLastLogin(authUser)));
     writeLastLogin(authUser, remoteAddress);
     await flushVfs();
-    prompt();
-    while (true) {
-        const inputLine = await new Promise((resolve) => {
-            rl.once("line", (line) => resolve(line));
-        });
+    // ── Event-driven line handler (enables completer) ──────────────────────────
+    //
+    // Key insight: readline's completer only fires when readline itself owns
+    // stdin (i.e. rl is not paused). We use the event-driven "line" pattern
+    // instead of a while(true)+rl.once("line") loop so readline stays active
+    // between commands. We pause only while awaiting async work, then resume
+    // immediately before re-prompting so the next Tab press is caught.
+    let busy = false;
+    rl.on("line", async (inputLine) => {
+        if (busy)
+            return; // shouldn't happen but guard re-entrancy
+        busy = true;
         rl.pause();
-        if (inputLine.trim().length > 0) {
+        const trimmed = inputLine.trim();
+        if (trimmed.length > 0) {
             history.push(inputLine);
-            if (history.length > 500) {
+            if (history.length > 500)
                 history = history.slice(history.length - 500);
-            }
-            saveHistory(history);
+            saveHistory(history, authUser);
             rlWithHistory.history = [...history].reverse();
         }
         const result = await runCommand(inputLine, authUser, hostname, "shell", cwd, virtualShell, undefined, shellEnv);
         await handleCommandResult(result);
         await flushVfs();
-        prompt();
+        busy = false;
+        // Resume before prompt so readline can handle Tab on the next input
         rl.resume();
-    }
+        prompt();
+    });
+    rl.on("SIGINT", () => {
+        stdout.write("^C\n");
+        rl.write("", { ctrl: true, name: "u" });
+        prompt();
+    });
+    rl.on("close", () => {
+        void flushVfs().then(() => {
+            console.log("");
+            process.exit(0);
+        });
+    });
+    // Initial prompt — readline is already active, completer live from first keystroke
+    prompt();
 }
 runReadlineShell().catch((error) => {
     console.error("Failed to start readline SSH emulation:", error);
     process.exit(1);
 });
 process.on("uncaughtException", (error) => {
-    console.log("Oh my god, something terrible happened: ", error);
+    console.error("Uncaught exception:", error);
 });
 process.on("unhandledRejection", (error, promise) => {
-    console.log(" Oh Lord! We forgot to handle a promise rejection here: ", promise);
-    console.log(" The error was: ", error);
+    console.error("Unhandled rejection at:", promise, "error:", error);
 });

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "typescript-virtual-container",
-  "description": "In-memory SSH server with virtual filesystem and typed programmatic API",
+  "description": "Scalable Linux emulator with included SSH/SFTP server, virtual filesystem and typed programmatic API for testing, automation, and interactive shell scripting in TypeScript/JavaScript.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
-  "version": "1.4.0",
+  "version": "1.4.2",
   "license": "MIT",
   "repository": {
     "type": "git",

package/src/VirtualPackageManager/index.ts

@@ -556,7 +556,35 @@ const PACKAGE_REGISTRY: PackageDefinition[] = [
 				mode: 0o755,
 			},
 		],
-	},
+	},{
+		name: "gzip",
+		version: "1.12-2",
+		section: "utils",
+		description: "GNU compression utility",
+		shortDesc: "compression utility",
+		installedSizeKb: 128,
+		files: [
+			{
+				path: "/usr/bin/gzip",
+				content: "#!/bin/sh\necho 'gzip: virtual stub'\n",
+				mode: 0o755,
+			},
+		]
+	}, {
+		name: "neofetch",
+		version: "7.1.0-1",
+		section: "utils",
+		description: "A command-line system information tool written in bash 3.2+",
+		shortDesc: "command-line system information tool",
+		installedSizeKb: 256,
+		files: [
+			{
+				path: "/usr/bin/neofetch",
+				content: "#!/bin/sh\necho 'neofetch: virtual stub'\n",
+				mode: 0o755,
+			},
+		],
+	}
 ];
 
 /**

package/src/VirtualShell/shell.ts

@@ -52,7 +52,7 @@ export function startShell(
 ): void {
 	let lineBuffer = "";
 	let cursorPos = 0;
-	let history = loadHistory(shell.vfs);
+	let history = loadHistory(shell.vfs, authUser);
 	let historyIndex: number | null = null;
 	let historyDraft = "";
 	let cwd = `/home/${authUser}`;
@@ -388,11 +388,11 @@ export function startShell(
 		}
 
 		const data = history.length > 0 ? `${history.join("\n")}\n` : "";
-		shell.vfs.writeFile("/virtual-env-js/.bash_history", data);
+		shell.vfs.writeFile(`/home/${authUser}/.bash_history`, data);
 	}
 
 	function readLastLogin(): { at: string; from: string } | null {
-		const lastlogPath = `/virtual-env-js/.lastlog/${authUser}.json`;
+		const lastlogPath = `/home/${authUser}/.lastlog.json`;
 		if (!shell.vfs.exists(lastlogPath)) {
 			return null;
 		}
@@ -408,12 +408,7 @@ export function startShell(
 	}
 
 	function writeLastLogin(nowIso: string): void {
-		const dir = "/virtual-env-js/.lastlog";
-		if (!shell.vfs.exists(dir)) {
-			shell.vfs.mkdir(dir, 0o700);
-		}
-
-		const lastlogPath = `${dir}/${authUser}.json`;
+		const lastlogPath = `/home/${authUser}/.lastlog`;
 		shell.vfs.writeFile(
 			lastlogPath,
 			JSON.stringify({ at: nowIso, from: remoteAddress }),
@@ -690,8 +685,8 @@ export function startShell(
 	});
 }
 
-function loadHistory(vfs: VirtualFileSystem): string[] {
-	const historyPath = "/virtual-env-js/.bash_history";
+function loadHistory(vfs: VirtualFileSystem, authUser: string): string[] {
+	const historyPath = `/home/${authUser}/.bash_history`;
 	if (!vfs.exists(historyPath)) {
 		vfs.writeFile(historyPath, "");
 		return [];

package/src/VirtualUserManager/index.ts

@@ -47,10 +47,10 @@ const perf: PerfLogger = createPerfLogger("VirtualUserManager");
 export class VirtualUserManager extends EventEmitter {
 	private static readonly recordCache = new Map<string, VirtualUserRecord>();
 	private static readonly fastPasswordHash = resolveFastPasswordHash();
-	private readonly usersPath = "/virtual-env-js/.auth/htpasswd";
-	private readonly sudoersPath = "/virtual-env-js/.auth/sudoers";
-	private readonly quotasPath = "/virtual-env-js/.auth/quotas";
-	private readonly authDirPath = "/virtual-env-js/.auth";
+	private readonly usersPath = "/etc/htpasswd";
+	private readonly sudoersPath = "/etc/sudoers";
+	private readonly quotasPath = "/etc/quotas";
+	private readonly authDirPath = "/.virtual-env-js/.auth";
 	private readonly users = new Map<string, VirtualUserRecord>();
 	private readonly sudoers = new Set<string>();
 	private readonly quotas = new Map<string, number>();

package/src/commands/curl.ts

@@ -97,7 +97,8 @@ export const curlCommand: ShellModule = {
 
 		let response: Response;
 		try {
-			response = await fetch(url, fetchOpts);
+			const urlWithHttp = url.startsWith("http://") || url.startsWith("https://") ? url : `http://${url}`;
+			response = await fetch(urlWithHttp, fetchOpts);
 		} catch (err) {
 			const msg = err instanceof Error ? err.message : String(err);
 			return {

package/src/commands/gzip.ts

@@ -11,6 +11,13 @@ export const gzipCommand: ShellModule = {
 	category: "archive",
 	params: ["[-k] [-d] <file>"],
 	run: ({ shell, cwd, args }) => {
+		if (!shell.packageManager.isInstalled("gzip")) {
+			return {
+				stderr:
+					"bash: gzip: command not found\nHint: install it with: apt install gzip\n",
+				exitCode: 127,
+			};
+		}
 		const keepOrig = args.includes("-k") || args.includes("--keep");
 		const decompress = args.includes("-d");
 		const file = args.find((a) => !a.startsWith("-"));

package/src/commands/helpers.ts

@@ -4,7 +4,7 @@ import type VirtualFileSystem from "../VirtualFileSystem";
 import type { VirtualPackageManager } from "../VirtualPackageManager";
 import type { VirtualShell } from "../VirtualShell";
 
-const PROTECTED_PREFIXES = ["/virtual-env-js/.auth"] as const;
+const PROTECTED_PREFIXES = ["/.virtual-env-js/.auth", "/etc/htpasswd"] as const;
 
 function normalizeFetchUrl(input: string): string {
 	if (/^[a-zA-Z][a-zA-Z\d+\-.]*:/.test(input)) {

package/src/commands/history.ts

@@ -10,9 +10,9 @@ export const historyCommand: ShellModule = {
 	description: "Display command history",
 	category: "shell",
 	params: ["[n]"],
-	run: ({ args, shell }) => {
+	run: ({ args, shell, authUser }) => {
 		// History is persisted in the VFS by the interactive shell
-		const histPath = "/virtual-env-js/.bash_history";
+		const histPath = `/home/${authUser}/.bash_history`;
 		if (!shell.vfs.exists(histPath)) {
 			return { stdout: "", exitCode: 0 };
 		}