typescript-virtual-container 1.5.5 → 1.5.7

package/dist/self-standalone.js

@@ -1,444 +0,0 @@
-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, userHome } 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 ──────────────────────────────────────────────────────────────────
-console.clear();
-function readUserArg() {
-    for (let index = 0; index < argv.length; index += 1) {
-        const current = argv[index];
-        if (current === "--user") {
-            const next = argv[index + 1];
-            if (!next || next.startsWith("--")) {
-                throw new Error("self-standalone: --user requires a value");
-            }
-            return next;
-        }
-        if (current?.startsWith("--user=")) {
-            return current.slice("--user=".length) || "root";
-        }
-    }
-    return "root";
-}
-const initialUser = readUserArg();
-const virtualShell = new VirtualShell(hostname, undefined, {
-    mode: "fs",
-    snapshotPath: ".vfs",
-});
-// ── VFS helpers ───────────────────────────────────────────────────────────────
-function readLastLogin(username) {
-    const lastlogPath = `/home/${username}/.lastlog`;
-    if (!virtualShell.vfs.exists(lastlogPath))
-        return null;
-    try {
-        return JSON.parse(virtualShell.vfs.readFile(lastlogPath));
-    }
-    catch {
-        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.stopAutoFlush();
-}
-function loadHistory(authUser) {
-    const historyPath = `${userHome(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(`${userHome(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) {
-            rl.question(promptText, resolve);
-            return;
-        }
-        const wasRawMode = Boolean(stdin.isRaw);
-        let buffer = "";
-        const cleanup = () => {
-            stdin.off("data", onData);
-            if (!wasRawMode)
-                stdin.setRawMode(false);
-        };
-        const finish = (value) => {
-            cleanup();
-            stdout.write("\n");
-            resolve(value);
-        };
-        const onData = (chunk) => {
-            const input = chunk.toString("utf8");
-            for (let i = 0; i < input.length; i += 1) {
-                const ch = input[i];
-                if (ch === "\r" || ch === "\n") {
-                    finish(buffer);
-                    return;
-                }
-                if (ch === "\u007f" || ch === "\b") {
-                    buffer = buffer.slice(0, -1);
-                    continue;
-                }
-                if (ch >= " ")
-                    buffer += ch;
-            }
-        };
-        // Pause readline so it doesn't eat our raw keystrokes
-        rl.pause();
-        stdout.write(promptText);
-        if (!wasRawMode)
-            stdin.setRawMode(true);
-        stdin.resume();
-        stdin.on("data", onData);
-    });
-}
-// ── Session state helper ──────────────────────────────────────────────────────
-function applySessionState(authUserState, cwdState, result, shellEnvState) {
-    let authUser = authUserState;
-    let cwd = cwdState;
-    if (result.switchUser) {
-        authUser = result.switchUser;
-        cwd = result.nextCwd ?? userHome(authUser);
-        shellEnvState.vars.USER = authUser;
-        shellEnvState.vars.LOGNAME = authUser;
-        shellEnvState.vars.HOME = userHome(authUser);
-        shellEnvState.vars.PWD = cwd;
-    }
-    else if (result.nextCwd) {
-        cwd = result.nextCwd;
-        shellEnvState.vars.PWD = cwd;
-    }
-    return { authUser, cwd };
-}
-// ── Demo command ──────────────────────────────────────────────────────────────
-virtualShell.addCommand("demo", [], () => ({
-    stdout: "This is a demo command. It does nothing useful.",
-    exitCode: 0,
-}));
-// ── Main shell ────────────────────────────────────────────────────────────────
-async function runReadlineShell() {
-    await virtualShell.ensureInitialized();
-    const selectedUser = initialUser.trim() || "root";
-    if (virtualShell.users.getPasswordHash(selectedUser) === null) {
-        process.stderr.write(`self-standalone: user '${selectedUser}' does not exist\n`);
-        process.exit(1);
-    }
-    // Ensure home dir and README.txt exist (mirrors SSHMimic/VirtualUserManager behaviour)
-    const homePath = selectedUser === "root" ? "/root" : userHome(selectedUser);
-    if (!virtualShell.vfs.exists(homePath)) {
-        virtualShell.vfs.mkdir(homePath, selectedUser === "root" ? 0o700 : 0o755);
-    }
-    const readmePath = `${homePath}/README.txt`;
-    if (!virtualShell.vfs.exists(readmePath)) {
-        virtualShell.vfs.writeFile(readmePath, `Welcome to ${hostname}\n`);
-        await virtualShell.vfs.stopAutoFlush();
-    }
-    const shellEnv = makeDefaultEnv(selectedUser, hostname);
-    let authUser = selectedUser;
-    let cwd = userHome(authUser);
-    shellEnv.vars.PWD = cwd;
-    const remoteAddress = "localhost";
-    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");
-        }
-        rl.pause();
-        const editor = spawnNanoEditorProcess(tempPath, terminalSize, {
-            write: stdout.write.bind(stdout),
-            exit: () => undefined,
-            end: () => undefined,
-        });
-        const wasRawMode = Boolean(stdin.isRaw);
-        const forwardInput = (chunk) => { editor.stdin.write(chunk); };
-        stdin.resume();
-        if (!wasRawMode)
-            stdin.setRawMode(true);
-        stdin.on("data", forwardInput);
-        await new Promise((resolve) => {
-            const cleanup = () => {
-                stdin.off("data", forwardInput);
-                if (!wasRawMode)
-                    stdin.setRawMode(false);
-                rl.resume();
-            };
-            editor.on("error", (error) => {
-                cleanup();
-                stdout.write(`nano: ${error.message}\r\n`);
-                resolve();
-            });
-            editor.on("close", async () => {
-                cleanup();
-                rl.write("", { ctrl: true, name: "u" });
-                try {
-                    const updatedContent = await readFile(tempPath, "utf8");
-                    virtualShell.writeFileAsUser(authUser, targetPath, updatedContent);
-                    await flushVfs();
-                }
-                catch {
-                    // save skipped or temp file missing
-                }
-                await unlink(tempPath).catch(() => undefined);
-                stdout.write("\r\n");
-                resolve();
-            });
-        });
-    }
-    // ── challenge handlers ─────────────────────────────────────────────────────
-    async function handleSudoChallenge(challenge) {
-        if (challenge.onPassword) {
-            let promptText = challenge.prompt;
-            while (true) {
-                const typed = await askHiddenQuestion(rl, promptText);
-                const step = await challenge.onPassword(typed, virtualShell);
-                if (step.result === null) {
-                    promptText = step.nextPrompt ?? promptText;
-                    continue;
-                }
-                await handleCommandResult(step.result);
-                return;
-            }
-        }
-        const password = await askHiddenQuestion(rl, challenge.prompt);
-        if (!virtualShell.users.verifyPassword(challenge.username, password)) {
-            process.stderr.write("Sorry, try again.\n");
-            return;
-        }
-        if (!challenge.commandLine) {
-            authUser = challenge.targetUser;
-            cwd = userHome(authUser);
-            shellEnv.vars.USER = authUser;
-            shellEnv.vars.LOGNAME = authUser;
-            shellEnv.vars.HOME = userHome(authUser);
-            shellEnv.vars.PWD = cwd;
-            return;
-        }
-        const runCwd = challenge.loginShell ? userHome(challenge.targetUser) : cwd;
-        const nestedResult = await runCommand(challenge.commandLine, challenge.targetUser, hostname, "shell", runCwd, virtualShell, undefined, shellEnv);
-        await handleCommandResult(nestedResult);
-    }
-    async function handlePasswordChallenge(challenge) {
-        const first = await askHiddenQuestion(rl, challenge.prompt);
-        if (challenge.confirmPrompt) {
-            const second = await askHiddenQuestion(rl, challenge.confirmPrompt);
-            if (second !== first) {
-                process.stderr.write("passwords do not match\n");
-                return;
-            }
-        }
-        switch (challenge.action) {
-            case "passwd":
-                await virtualShell.users.setPassword(challenge.targetUsername, first);
-                stdout.write("passwd: password updated successfully\n");
-                break;
-            case "adduser":
-                if (!challenge.newUsername) {
-                    process.stderr.write("adduser: missing username\n");
-                    return;
-                }
-                await virtualShell.users.addUser(challenge.newUsername, first);
-                stdout.write(`adduser: user '${challenge.newUsername}' created\n`);
-                break;
-            case "deluser":
-                await virtualShell.users.deleteUser(challenge.targetUsername);
-                stdout.write(`Removing user '${challenge.targetUsername}' ...\ndeluser: done.\n`);
-                break;
-            case "su":
-                authUser = challenge.targetUsername;
-                cwd = userHome(authUser);
-                shellEnv.vars.USER = authUser;
-                shellEnv.vars.LOGNAME = authUser;
-                shellEnv.vars.HOME = userHome(authUser);
-                shellEnv.vars.PWD = cwd;
-                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);
-            return;
-        }
-        if (result.sudoChallenge) {
-            await handleSudoChallenge(result.sudoChallenge);
-            return;
-        }
-        if (result.passwordChallenge) {
-            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`);
-        }
-        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);
-        }
-    }
-    // ── Prompt helper ──────────────────────────────────────────────────────────
-    const renderPrompt = () => {
-        const cwdLabel = cwd === userHome(authUser) ? "~" : basename(cwd) || "/";
-        return buildPrompt(authUser, hostname, cwdLabel);
-    };
-    const prompt = () => {
-        rl.setPrompt(renderPrompt());
-        rl.prompt();
-    };
-    // ── 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();
-    // ── 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();
-        const trimmed = inputLine.trim();
-        if (trimmed.length > 0) {
-            history.push(inputLine);
-            if (history.length > 500)
-                history = history.slice(history.length - 500);
-            saveHistory(history, authUser);
-            rlWithHistory.history = [...history].reverse();
-        }
-        const result = await runCommand(inputLine, authUser, hostname, "shell", cwd, virtualShell, undefined, shellEnv);
-        await handleCommandResult(result);
-        await flushVfs();
-        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);
-});
-// ── Graceful shutdown (process-level) ────────────────────────────────────────
-let _shuttingDown = false;
-async function _gracefulShutdown(signal) {
-    if (_shuttingDown)
-        return;
-    _shuttingDown = true;
-    process.stdout.write(`\n[${signal}] Saving VFS...\n`);
-    try {
-        await virtualShell.vfs.stopAutoFlush();
-    }
-    catch { }
-    process.exit(0);
-}
-process.on("SIGTERM", () => { void _gracefulShutdown("SIGTERM"); });
-process.on("beforeExit", () => { void virtualShell.vfs.stopAutoFlush(); });
-process.on("uncaughtException", (error) => {
-    console.error("Uncaught exception:", error);
-});
-process.on("unhandledRejection", (error, promise) => {
-    console.error("Unhandled rejection at:", promise, "error:", error);
-});

package/dist/standalone-wo-sftp.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/standalone-wo-sftp.js

@@ -1,30 +0,0 @@
-import { SshMimic } from "./SSHMimic/index";
-import { VirtualShell } from "./VirtualShell";
-const hostname = process.env.SSH_MIMIC_HOSTNAME ?? "typescript-vm";
-const virtualShell = new VirtualShell(hostname, undefined, {
-    mode: "fs",
-    snapshotPath: ".vfs",
-});
-virtualShell.addCommand("demo", [], () => {
-    return {
-        stdout: "This is a demo command. It does nothing useful.",
-        exitCode: 0,
-    };
-});
-new SshMimic({
-    port: 2222,
-    hostname,
-    shell: virtualShell,
-})
-    .start()
-    .catch((error) => {
-    console.error("Failed to start SSH Mimic:", error);
-    process.exit(1);
-});
-process.on("uncaughtException", (error) => {
-    console.log("Oh my god, something terrible happened: ", 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);
-});

package/dist/standalone.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/standalone.js

@@ -1,61 +0,0 @@
-import { VirtualSftpServer, VirtualShell, VirtualSshServer } from ".";
-const hostname = process.env.SSH_MIMIC_HOSTNAME ?? "typescript-vm";
-const virtualShell = new VirtualShell(hostname, undefined, {
-    mode: "fs",
-    snapshotPath: ".vfs",
-});
-virtualShell.addCommand("demo", [], () => {
-    return {
-        stdout: "This is a demo command. It does nothing useful.",
-        exitCode: 0,
-    };
-});
-new VirtualSshServer({
-    port: 2222,
-    hostname,
-    shell: virtualShell,
-})
-    .start()
-    .catch((error) => {
-    console.error("Failed to start SSH Mimic:", error);
-    process.exit(1);
-});
-new VirtualSftpServer({ port: 2223, hostname, shell: virtualShell })
-    .start()
-    .catch((error) => {
-    console.error("Failed to start SFTP Mimic:", error);
-    process.exit(1);
-});
-// ── Graceful shutdown ─────────────────────────────────────────────────────────
-// On SIGINT / SIGTERM: flush the WAL journal to a full checkpoint before exit.
-// A kill -9 or OOM crash is unrecoverable here, but the WAL journal on disk
-// guarantees all writes since the last checkpoint are replayed on next start.
-let isShuttingDown = false;
-async function gracefulShutdown(signal) {
-    if (isShuttingDown)
-        return;
-    isShuttingDown = true;
-    console.log(`\n[${signal}] Flushing VFS checkpoint before exit...`);
-    try {
-        await virtualShell.vfs.stopAutoFlush();
-        console.log("[shutdown] Checkpoint written. Goodbye.");
-    }
-    catch (err) {
-        console.error("[shutdown] Flush failed:", err);
-    }
-    process.exit(0);
-}
-process.on("SIGINT", () => { void gracefulShutdown("SIGINT"); });
-process.on("SIGTERM", () => { void gracefulShutdown("SIGTERM"); });
-process.on("beforeExit", () => { void virtualShell.vfs.stopAutoFlush(); });
-process.on("uncaughtException", (error) => {
-    console.debug("Oh my god, something terrible happened: ", error);
-});
-process.on("unhandledRejection", (error, promise) => {
-    console.debug(" Oh Lord! We forgot to handle a promise rejection here: ", promise);
-    console.debug(" The error was: ", error);
-});
-setInterval(() => {
-    const rss = process.memoryUsage().rss; // Just keep the event loop alive and prevent exit
-    console.debug(`Current memory usage: ${Math.round(rss / 1024 / 1024)} MB`);
-}, 1000);