typescript-virtual-container 1.5.7 → 1.5.9

package/dist/VirtualShell/index.d.ts

@@ -78,9 +78,8 @@ export interface VirtualShellVfsOptions {
  * const result = await client.exec("uname -a");
  * ```
  *
- * @fires VirtualShell#initialized  Emitted once the VFS and users are ready.
- * @fires VirtualShell#command       Emitted after every command execution.
- * @fires VirtualShell#session:start Emitted when an interactive session opens.
+ * **Events:** `initialized` (VFS and users ready), `command` (after each execution),
+ * `session:start` (interactive session opened).
  */
 declare class VirtualShell extends EventEmitter {
     /** Backing virtual filesystem — use for direct path operations. */

package/dist/VirtualShell/index.js

@@ -60,9 +60,8 @@ function resolveAutoSudoForNewUsers() {
  * const result = await client.exec("uname -a");
  * ```
  *
- * @fires VirtualShell#initialized  Emitted once the VFS and users are ready.
- * @fires VirtualShell#command       Emitted after every command execution.
- * @fires VirtualShell#session:start Emitted when an interactive session opens.
+ * **Events:** `initialized` (VFS and users ready), `command` (after each execution),
+ * `session:start` (interactive session opened).
  */
 class VirtualShell extends EventEmitter {
     /** Backing virtual filesystem — use for direct path operations. */

package/dist/VirtualShell/shell.js

@@ -1,10 +1,12 @@
-import { readFile, unlink, writeFile } from "node:fs/promises";
 import * as path from "node:path";
-import { getCommandNames, makeDefaultEnv, runCommand, userHome } from "../commands";
-import { spawnHtopProcess, spawnNanoEditorProcess, } from "../modules/shellInteractive";
-import { getVisibleHtopPidList, resolvePath, toTtyLines, } from "../modules/shellRuntime";
+import { applyUserSwitch, getCommandNames, makeDefaultEnv, runCommand, userHome } from "../commands";
+import { NanoEditor } from "../modules/nanoEditor";
+import { PacmanGame } from "../modules/pacmanGame";
+import { spawnHtopProcess, } from "../modules/shellInteractive";
+import { getVisibleHtopPidList, toTtyLines, } from "../modules/shellRuntime";
 import { buildLoginBanner } from "../SSHMimic/loginBanner";
 import { buildPrompt } from "../SSHMimic/prompt";
+import { listPathCompletions, loadHistory, readLastLogin, saveHistory, writeLastLogin } from "../utils/shellSession";
 export function startShell(properties, stream, authUser, hostname, sessionId, remoteAddress = "unknown", terminalSize = { cols: 80, rows: 24 }, shell) {
     let lineBuffer = "";
     let cursorPos = 0;
@@ -18,43 +20,48 @@ export function startShell(properties, stream, authUser, hostname, sessionId, re
     let nanoSession = null;
     let pendingSudo = null;
     const buildCurrentPrompt = () => {
+        if (shellEnv.vars.PS1)
+            return buildPrompt(authUser, hostname, "", shellEnv.vars.PS1, cwd);
         const homePath = userHome(authUser);
         const cwdLabel = cwd === homePath ? "~" : path.posix.basename(cwd) || "/";
         return buildPrompt(authUser, hostname, cwdLabel);
     };
     const commandNames = Array.from(new Set(getCommandNames())).sort();
     console.log(`[${sessionId}] Shell started for user '${authUser}' at ${remoteAddress}`);
-    // Source login/rc files at startup
-    void (async () => {
-        const sourceFile = async (filePath, isEnvFile = false) => {
-            if (!shell.vfs.exists(filePath))
-                return;
-            try {
-                const content = shell.vfs.readFile(filePath);
-                for (const line of content.split("\n")) {
-                    const l = line.trim();
-                    if (!l || l.startsWith("#"))
-                        continue;
-                    if (isEnvFile) {
-                        // /etc/environment: KEY=VALUE pairs only, no shell syntax
-                        const m = l.match(/^([A-Za-z_][A-Za-z0-9_]*)=["']?(.+?)["']?\s*$/);
-                        if (m)
-                            shellEnv.vars[m[1]] = m[2];
-                    }
-                    else {
-                        await runCommand(l, authUser, hostname, "shell", cwd, shell, undefined, shellEnv);
-                    }
+    // Source login/rc files before first prompt.
+    let loginReady = false;
+    const sourceFile = async (filePath, isEnvFile = false) => {
+        if (!shell.vfs.exists(filePath))
+            return;
+        try {
+            const content = shell.vfs.readFile(filePath);
+            for (const line of content.split("\n")) {
+                const l = line.trim();
+                if (!l || l.startsWith("#"))
+                    continue;
+                if (isEnvFile) {
+                    const m = l.match(/^([A-Za-z_][A-Za-z0-9_]*)=["']?(.+?)["']?\s*$/);
+                    if (m)
+                        shellEnv.vars[m[1]] = m[2];
+                }
+                else {
+                    const r = await runCommand(l, authUser, hostname, "shell", cwd, shell, undefined, shellEnv);
+                    if (r.stdout)
+                        stream.write(r.stdout.replace(/\n/g, "\r\n"));
                 }
             }
-            catch { /* ignore */ }
-        };
+        }
+        catch { /* ignore */ }
+    };
+    const loginPromise = (async () => {
         await sourceFile("/etc/environment", true);
         await sourceFile(`${userHome(authUser)}/.profile`);
         await sourceFile(`${userHome(authUser)}/.bashrc`);
+        loginReady = true;
     })();
     function renderLine() {
         const prompt = buildCurrentPrompt();
-        stream.write(`\r${prompt}${lineBuffer}\u001b[K`);
+        stream.write(`\r\x1b[0m${prompt}${lineBuffer}\u001b[K`);
         const moveLeft = lineBuffer.length - cursorPos;
         if (moveLeft > 0) {
             stream.write(`\u001b[${moveLeft}D`);
@@ -88,6 +95,7 @@ export function startShell(properties, stream, authUser, hostname, sessionId, re
                 cwd = userHome(authUser);
             }
             shell.users.updateSession(sessionId, authUser, remoteAddress);
+            await applyUserSwitch(authUser, hostname, cwd, shellEnv, shell);
             stream.write("\r\n");
             renderLine();
             return;
@@ -103,6 +111,10 @@ export function startShell(properties, stream, authUser, hostname, sessionId, re
             await startHtop();
             return;
         }
+        if (result.openPacman) {
+            startPacman();
+            return;
+        }
         if (result.clearScreen) {
             stream.write("\u001b[2J\u001b[H");
         }
@@ -117,6 +129,7 @@ export function startShell(properties, stream, authUser, hostname, sessionId, re
             authUser = result.switchUser;
             cwd = result.nextCwd ?? userHome(authUser);
             shell.users.updateSession(sessionId, authUser, remoteAddress);
+            await applyUserSwitch(authUser, hostname, cwd, shellEnv, shell);
         }
         else if (result.nextCwd) {
             cwd = result.nextCwd;
@@ -124,46 +137,34 @@ export function startShell(properties, stream, authUser, hostname, sessionId, re
         // WAL: checkpoint handled by auto-flush timer
         renderLine();
     }
-    async function finishNanoEditor() {
-        if (!nanoSession) {
-            return;
-        }
-        const activeSession = nanoSession;
-        if (activeSession.kind === "nano") {
-            try {
-                const updatedContent = await readFile(activeSession.tempPath, "utf8");
-                shell.writeFileAsUser(authUser, activeSession.targetPath, updatedContent);
-                // WAL: checkpoint handled by auto-flush timer
-            }
-            catch {
-                // If temp file does not exist, nano exited without writing.
-            }
-            await unlink(activeSession.tempPath).catch(() => undefined);
+    function finishInteractiveSession(savedContent, targetPath) {
+        if (savedContent !== undefined && targetPath) {
+            shell.writeFileAsUser(authUser, targetPath, savedContent);
         }
         nanoSession = null;
         lineBuffer = "";
         cursorPos = 0;
-        stream.write("\r\n");
+        // Clear screen + reset SGR so nano residue is gone before next prompt
+        stream.write("\x1b[2J\x1b[H\x1b[0m");
         renderLine();
     }
-    async function startNanoEditor(targetPath, initialContent, tempPath) {
-        if (shell.vfs.exists(targetPath)) {
-            await writeFile(tempPath, initialContent, "utf8");
-        }
-        const editor = spawnNanoEditorProcess(tempPath, terminalSize, stream);
-        editor.on("error", (error) => {
-            stream.write(`nano: ${error.message}\r\n`);
-            void finishNanoEditor();
-        });
-        editor.on("close", () => {
-            void finishNanoEditor();
+    function startNanoEditor(targetPath, initialContent, _tempPath) {
+        const editor = new NanoEditor({
+            stream,
+            terminalSize,
+            content: initialContent,
+            filename: path.posix.basename(targetPath),
+            onExit: (reason, content) => {
+                if (reason === "saved") {
+                    finishInteractiveSession(content, targetPath);
+                }
+                else {
+                    finishInteractiveSession();
+                }
+            },
         });
-        nanoSession = {
-            kind: "nano",
-            targetPath,
-            tempPath,
-            process: editor,
-        };
+        nanoSession = { kind: "nano", targetPath, editor };
+        editor.start();
     }
     async function startHtop() {
         const pidList = await getVisibleHtopPidList();
@@ -174,17 +175,27 @@ export function startShell(properties, stream, authUser, hostname, sessionId, re
         const monitor = spawnHtopProcess(pidList, terminalSize, stream);
         monitor.on("error", (error) => {
             stream.write(`htop: ${error.message}\r\n`);
-            void finishNanoEditor();
+            finishInteractiveSession();
         });
         monitor.on("close", () => {
-            void finishNanoEditor();
+            finishInteractiveSession();
         });
-        nanoSession = {
-            kind: "htop",
-            targetPath: "",
-            tempPath: "",
-            process: monitor,
-        };
+        nanoSession = { kind: "htop", process: monitor };
+    }
+    function startPacman() {
+        const game = new PacmanGame({
+            stream,
+            terminalSize,
+            onExit: () => {
+                nanoSession = null;
+                lineBuffer = "";
+                cursorPos = 0;
+                stream.write("\x1b[2J\x1b[H\x1b[0m");
+                renderLine();
+            },
+        });
+        nanoSession = { kind: "pacman", game };
+        game.start();
     }
     function applyHistoryLine(nextLine) {
         lineBuffer = nextLine;
@@ -207,28 +218,6 @@ export function startShell(properties, stream, authUser, hostname, sessionId, re
         }
         return { start, end };
     }
-    function listPathCompletions(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 shell.vfs
-                .list(basePath)
-                .filter((entry) => !entry.startsWith("."))
-                .filter((entry) => entry.startsWith(namePart))
-                .map((entry) => {
-                const fullPath = path.posix.join(basePath, entry);
-                const st = shell.vfs.stat(fullPath);
-                const suffix = st.type === "directory" ? "/" : "";
-                return `${dirPart}${entry}${suffix}`;
-            })
-                .sort();
-        }
-        catch {
-            return [];
-        }
-    }
     function handleTabCompletion() {
         const { start, end } = getTokenRange(lineBuffer, cursorPos);
         const token = lineBuffer.slice(start, cursorPos);
@@ -239,7 +228,7 @@ export function startShell(properties, stream, authUser, hostname, sessionId, re
         const commandCandidates = firstToken
             ? commandNames.filter((name) => name.startsWith(token))
             : [];
-        const pathCandidates = listPathCompletions(token);
+        const pathCandidates = listPathCompletions(shell.vfs, cwd, token);
         const candidates = Array.from(new Set([...commandCandidates, ...pathCandidates])).sort();
         if (candidates.length === 0) {
             return;
@@ -257,43 +246,33 @@ export function startShell(properties, stream, authUser, hostname, sessionId, re
         renderLine();
     }
     function pushHistory(cmd) {
-        if (cmd.length === 0) {
+        if (cmd.length === 0)
             return;
-        }
         history.push(cmd);
-        if (history.length > 500) {
+        if (history.length > 500)
             history = history.slice(history.length - 500);
-        }
-        const data = history.length > 0 ? `${history.join("\n")}\n` : "";
-        shell.vfs.writeFile(`${userHome(authUser)}/.bash_history`, data);
-    }
-    function readLastLogin() {
-        const lastlogPath = `${userHome(authUser)}/.lastlog.json`;
-        if (!shell.vfs.exists(lastlogPath)) {
-            return null;
-        }
-        try {
-            return JSON.parse(shell.vfs.readFile(lastlogPath));
-        }
-        catch {
-            return null;
-        }
-    }
-    function writeLastLogin(nowIso) {
-        const lastlogPath = `${userHome(authUser)}/.lastlog`;
-        shell.vfs.writeFile(lastlogPath, JSON.stringify({ at: nowIso, from: remoteAddress }));
+        saveHistory(shell.vfs, authUser, history);
     }
     function renderLoginBanner() {
-        const last = readLastLogin();
-        const nowIso = new Date().toISOString();
+        const last = readLastLogin(shell.vfs, authUser);
         stream.write(buildLoginBanner(hostname, properties, last));
-        writeLastLogin(nowIso);
+        writeLastLogin(shell.vfs, authUser, remoteAddress);
     }
     renderLoginBanner();
-    renderLine();
+    void loginPromise.then(() => renderLine());
     stream.on("data", async (chunk) => {
+        if (!loginReady)
+            return;
         if (nanoSession) {
-            nanoSession.process.stdin.write(chunk);
+            if (nanoSession.kind === "nano") {
+                nanoSession.editor.handleInput(chunk);
+            }
+            else if (nanoSession.kind === "pacman") {
+                nanoSession.game.handleInput(chunk);
+            }
+            else {
+                nanoSession.process.stdin.write(chunk);
+            }
             return;
         }
         if (pendingHeredoc) {
@@ -596,6 +575,10 @@ export function startShell(properties, stream, authUser, hostname, sessionId, re
                         await startHtop();
                         return;
                     }
+                    if (result.openPacman) {
+                        startPacman();
+                        return;
+                    }
                     if (result.sudoChallenge) {
                         startSudoPrompt(result.sudoChallenge);
                         return;
@@ -634,11 +617,9 @@ export function startShell(properties, stream, authUser, hostname, sessionId, re
                         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);
+                        await applyUserSwitch(authUser, hostname, cwd, shellEnv, shell);
                         lineBuffer = "";
                         cursorPos = 0;
                     }
@@ -660,20 +641,13 @@ export function startShell(properties, stream, authUser, hostname, sessionId, re
     });
     stream.on("close", () => {
         if (nanoSession) {
-            nanoSession.process.kill("SIGTERM");
+            if (nanoSession.kind === "htop") {
+                nanoSession.process.kill("SIGTERM");
+            }
+            else if (nanoSession.kind === "pacman") {
+                nanoSession.game.stop();
+            }
             nanoSession = null;
         }
     });
 }
-function loadHistory(vfs, authUser) {
-    const historyPath = `${userHome(authUser)}/.bash_history`;
-    if (!vfs.exists(historyPath)) {
-        vfs.writeFile(historyPath, "");
-        return [];
-    }
-    const raw = vfs.readFile(historyPath);
-    return raw
-        .split("\n")
-        .map((line) => line.trim())
-        .filter((line) => line.length > 0);
-}

package/dist/VirtualShell/shellParser.js

@@ -45,7 +45,7 @@ export function expandGlob(pattern, entries) {
 }
 // ── Internal parser ───────────────────────────────────────────────────────────
 function parseStatements(input) {
-    // Split by ;, &&, || — respecting quotes and parens
+    // Split by ;, &&, ||, & — respecting quotes and parens
     const segments = splitByLogicalOps(input);
     const statements = [];
     for (const seg of segments) {
@@ -53,6 +53,8 @@ function parseStatements(input) {
         const stmt = { pipeline: { commands, isValid: true } };
         if (seg.op)
             stmt.op = seg.op;
+        if (seg.background)
+            stmt.background = true;
         statements.push(stmt);
     }
     return statements;
@@ -64,9 +66,9 @@ function splitByLogicalOps(input) {
     let inQ = false;
     let qChar = "";
     let i = 0;
-    const flush = (op) => {
+    const flush = (op, background) => {
         if (current.trim())
-            segments.push({ text: current, op });
+            segments.push({ text: current, op, background });
         current = "";
     };
     while (i < input.length) {
@@ -117,6 +119,25 @@ function splitByLogicalOps(input) {
             i += 2;
             continue;
         }
+        if (ch === "&" && input[i + 1] !== "&") {
+            // &> redirect (stdout+stderr) — keep in current segment, not a background op
+            if (input[i + 1] === ">") {
+                current += ch;
+                i++;
+                continue;
+            }
+            // 2>&1 — the & is part of a redirection target, not a background op
+            const trimmed = current.trimEnd();
+            if (trimmed.endsWith(">") || trimmed.endsWith("2>") || trimmed.endsWith(">>")) {
+                current += ch;
+                i++;
+                continue;
+            }
+            // trailing & → background job; treat like ; for sequencing
+            flush(";", true);
+            i++;
+            continue;
+        }
         if (ch === ";") {
             flush(";");
             i++;
@@ -209,6 +230,17 @@ function parseCommandWithRedirections(token) {
             appendOutput = false;
             i++;
         }
+        else if (part === "&>" || part === "&>>") {
+            // &> file — redirect both stdout and stderr to file
+            const append = part === "&>>";
+            i++;
+            if (i >= parts.length)
+                throw new Error(`Syntax error: expected filename after ${part}`);
+            outputFile = parts[i];
+            appendOutput = append;
+            stderrToStdout = true;
+            i++;
+        }
         else if (part === "2>&1") {
             stderrToStdout = true;
             i++;

package/dist/commands/coreutils.d.ts

@@ -0,0 +1,55 @@
+import type { ShellModule } from "../types/commands";
+/**
+ * timeout — run command with time limit (simulated: just runs the command)
+ * @category shell
+ * @params ["<duration> <command> [args...]"]
+ */
+export declare const timeoutCommand: ShellModule;
+/**
+ * mktemp — create a temporary file or directory
+ * @category shell
+ * @params ["[TEMPLATE]"]
+ */
+export declare const mktempCommand: ShellModule;
+/**
+ * nproc — print number of processing units
+ * @category system
+ * @params ["[--all]"]
+ */
+export declare const nprocCommand: ShellModule;
+/**
+ * wait — wait for background jobs (no-op: background jobs are fire-and-forget)
+ * @category shell
+ * @params ["[job_id...]"]
+ */
+export declare const waitCommand: ShellModule;
+/**
+ * shuf — shuffle lines of input
+ * @category text
+ * @params ["[-n count] [-i lo-hi] [file]"]
+ */
+export declare const shufCommand: ShellModule;
+/**
+ * paste — merge lines of files side by side
+ * @category text
+ * @params ["[-d delimiter] file..."]
+ */
+export declare const pasteCommand: ShellModule;
+/**
+ * tac — concatenate files in reverse (line order)
+ * @category text
+ * @params ["[file...]"]
+ */
+export declare const tacCommand: ShellModule;
+/**
+ * nl — number lines of files
+ * @category text
+ * @params ["[file]"]
+ */
+export declare const nlCommand: ShellModule;
+/**
+ * column — columnate lists
+ * @category text
+ * @params ["[-t] [-s sep] [file]"]
+ */
+export declare const columnCommand: ShellModule;