typescript-virtual-container 1.5.7 → 1.5.8

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,11 @@
-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 { 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,39 +19,44 @@ 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();
@@ -88,6 +94,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;
@@ -117,6 +124,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 +132,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 +170,12 @@ 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 applyHistoryLine(nextLine) {
         lineBuffer = nextLine;
@@ -207,28 +198,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 +208,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 +226,30 @@ 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 {
+                nanoSession.process.stdin.write(chunk);
+            }
             return;
         }
         if (pendingHeredoc) {
@@ -634,11 +590,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 +614,10 @@ 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");
+            }
             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/commands/id.js

@@ -4,11 +4,18 @@ export const idCommand = {
     category: "system",
     params: ["[user]"],
     run: ({ authUser, shell, args }) => {
-        const target = args[0] ?? authUser;
+        const flagU = args.includes("-u");
+        const flagG = args.includes("-g");
+        const flagN = args.includes("-n");
+        const target = args.find(a => !a.startsWith("-")) ?? authUser;
         const uid = target === "root" ? 0 : 1000;
         const gid = uid;
         const isSudo = shell.users.isSudoer(target);
         const groups = isSudo ? `${gid}(${target}),0(root)` : `${gid}(${target})`;
+        if (flagU)
+            return { stdout: flagN ? target : String(uid), exitCode: 0 };
+        if (flagG)
+            return { stdout: flagN ? target : String(gid), exitCode: 0 };
         return {
             stdout: `uid=${uid}(${target}) gid=${gid}(${target}) groups=${groups}`,
             exitCode: 0,

package/dist/commands/index.d.ts

@@ -1,2 +1,2 @@
 export { createCustomCommand, getCommandModulesPublic, getCommandNames, registerCommand, resolveModule } from "./registry";
-export { makeDefaultEnv, runCommand, runCommandDirect, userHome } from "./runtime";
+export { applyUserSwitch, makeDefaultEnv, runCommand, runCommandDirect, userHome } from "./runtime";

package/dist/commands/index.js

@@ -1,2 +1,2 @@
 export { createCustomCommand, getCommandModulesPublic, getCommandNames, registerCommand, resolveModule } from "./registry";
-export { makeDefaultEnv, runCommand, runCommandDirect, userHome } from "./runtime";
+export { applyUserSwitch, makeDefaultEnv, runCommand, runCommandDirect, userHome } from "./runtime";

package/dist/commands/manuals-bundle.js

@@ -993,7 +993,16 @@ SYNOPSIS
        rm [OPTION]... FILE...
 
 OPTIONS
-       -r     remove directories and their contents recursively`,
+       -r, -R remove directories and their contents recursively
+
+       -f, --force
+              skip confirmation prompt, never prompt
+
+       -rf, -fr
+              recursive and force combined
+
+       Without -f, rm prompts for confirmation before removing each target.
+       Answer y or yes to confirm, anything else cancels.`,
     "sed": `SED(1)                   User Commands                      SED(1)
 
 NAME

package/dist/commands/rm.d.ts

@@ -2,6 +2,6 @@ import type { ShellModule } from "../types/commands";
 /**
  * Remove files or directories from the filesystem.
  * @category files
- * @params ["[-r|-rf] <path>"]
+ * @params ["[-r|-rf|-f] <path>"]
  */
 export declare const rmCommand: ShellModule;

package/dist/commands/rm.js

@@ -1,36 +1,73 @@
 import { getArg, ifFlag } from "./command-helpers";
 import { assertPathAccess, resolvePath } from "./helpers";
+const FLAG_RECURSIVE = ["-r", "-R", "-rf", "-fr", "-rF", "-Fr"];
+const FLAG_FORCE = ["-f", "-rf", "-fr", "-rF", "-Fr", "--force"];
 /**
  * Remove files or directories from the filesystem.
  * @category files
- * @params ["[-r|-rf] <path>"]
+ * @params ["[-r|-rf|-f] <path>"]
  */
 export const rmCommand = {
     name: "rm",
     description: "Remove files or directories",
     category: "files",
-    params: ["[-r|-rf] <path>"],
+    params: ["[-r|-rf|-f] <path>"],
     run: ({ authUser, shell, cwd, args }) => {
         if (args.length === 0) {
             return { stderr: "rm: missing operand", exitCode: 1 };
         }
-        const recursive = ifFlag(args, ["-r", "-rf", "-fr"]);
+        const recursive = ifFlag(args, FLAG_RECURSIVE);
+        const force = ifFlag(args, FLAG_FORCE);
+        const allFlags = [...FLAG_RECURSIVE, ...FLAG_FORCE, "--force"];
         const targets = [];
         for (let index = 0;; index += 1) {
-            const target = getArg(args, index, { flags: ["-r", "-rf", "-fr"] });
-            if (!target) {
+            const target = getArg(args, index, { flags: allFlags });
+            if (!target)
                 break;
-            }
             targets.push(target);
         }
         if (targets.length === 0) {
             return { stderr: "rm: missing operand", exitCode: 1 };
         }
-        for (const target of targets) {
-            const resolvedTarget = resolvePath(cwd, target);
-            assertPathAccess(authUser, resolvedTarget, "rm");
-            shell.vfs.remove(resolvedTarget, { recursive });
+        const resolved = targets.map((t) => resolvePath(cwd, t));
+        for (const r of resolved)
+            assertPathAccess(authUser, r, "rm");
+        for (const r of resolved) {
+            if (!shell.vfs.exists(r)) {
+                if (force)
+                    continue;
+                return { stderr: `rm: cannot remove '${r}': No such file or directory`, exitCode: 1 };
+            }
         }
-        return { exitCode: 0 };
+        const doRemove = (sh) => {
+            for (const r of resolved)
+                if (sh.vfs.exists(r))
+                    sh.vfs.remove(r, { recursive });
+            return { exitCode: 0 };
+        };
+        if (force)
+            return doRemove(shell);
+        const label = targets.length === 1 ? `'${targets[0]}'` : `${targets.length} items`;
+        const prompt = recursive
+            ? `rm: remove ${label} recursively? [y/N] `
+            : `rm: remove ${label}? [y/N] `;
+        return {
+            sudoChallenge: {
+                username: authUser,
+                targetUser: authUser,
+                commandLine: null,
+                loginShell: false,
+                prompt,
+                mode: "confirm",
+                onPassword: async (input, sh) => {
+                    const answer = input.trim().toLowerCase();
+                    if (answer !== "y" && answer !== "yes") {
+                        return { result: { stdout: "rm: cancelled\n", exitCode: 1 } };
+                    }
+                    return { result: doRemove(sh) };
+                },
+            },
+            exitCode: 0,
+        };
     },
 };

package/dist/commands/runtime.d.ts

@@ -2,6 +2,11 @@ import type { VirtualShell } from "../VirtualShell";
 import type { CommandMode, CommandResult, ShellEnv } from "../types/commands";
 /** Returns the home directory path for a given user. Root lives at /root. */
 export declare function userHome(authUser: string): string;
+/**
+ * Apply a user switch: reset PS1/USER/HOME/LOGNAME in shellEnv and re-source
+ * the new user's .bashrc. Call this after setting authUser = newUser.
+ */
+export declare function applyUserSwitch(newUser: string, hostname: string, cwd: string, shellEnv: ShellEnv, shell: VirtualShell): Promise<void>;
 export declare function makeDefaultEnv(authUser: string, hostname: string): ShellEnv;
 export declare function runCommandDirect(name: string, args: string[], authUser: string, hostname: string, mode: CommandMode, cwd: string, shell: VirtualShell, stdin: string | undefined, env: ShellEnv): Promise<CommandResult>;
 export declare function runCommand(rawInput: string, authUser: string, hostname: string, mode: CommandMode, cwd: string, shell: VirtualShell, stdin?: string, env?: ShellEnv): Promise<CommandResult>;

package/dist/commands/runtime.js

@@ -18,6 +18,28 @@ const RE_OPERATORS = /[><;&]|\|\|/;
 export function userHome(authUser) {
     return authUser === "root" ? "/root" : `/home/${authUser}`;
 }
+/**
+ * Apply a user switch: reset PS1/USER/HOME/LOGNAME in shellEnv and re-source
+ * the new user's .bashrc. Call this after setting authUser = newUser.
+ */
+export async function applyUserSwitch(newUser, hostname, cwd, shellEnv, shell) {
+    shellEnv.vars.USER = newUser;
+    shellEnv.vars.LOGNAME = newUser;
+    shellEnv.vars.HOME = userHome(newUser);
+    shellEnv.vars.PS1 = makeDefaultEnv(newUser, hostname).vars.PS1 ?? "";
+    const rcPath = `${userHome(newUser)}/.bashrc`;
+    if (!shell.vfs.exists(rcPath))
+        return;
+    for (const raw of shell.vfs.readFile(rcPath).split("\n")) {
+        const l = raw.trim();
+        if (!l || l.startsWith("#"))
+            continue;
+        try {
+            await runCommand(l, newUser, hostname, "shell", cwd, shell, undefined, shellEnv);
+        }
+        catch { /* ignore */ }
+    }
+}
 export function makeDefaultEnv(authUser, hostname) {
     return {
         vars: {
@@ -28,7 +50,9 @@ export function makeDefaultEnv(authUser, hostname) {
             SHELL: "/bin/bash",
             TERM: "xterm-256color",
             HOSTNAME: hostname,
-            PS1: "\\u@\\h:\\w\\$ ",
+            PS1: authUser === "root"
+                ? "\\[\\e[37;1m\\][\\[\\e[31;1m\\]\\u\\[\\e[37;1m\\]@\\[\\e[34;1m\\]\\h\\[\\e[0m\\] \\w\\[\\e[37;1m\\]]\\[\\e[31;1m\\]\\$\\[\\e[0m\\] "
+                : "\\[\\e[37;1m\\][\\[\\e[35;1m\\]\\u\\[\\e[37;1m\\]@\\[\\e[34;1m\\]\\h\\[\\e[0m\\] \\w\\[\\e[37;1m\\]]\\[\\e[0m\\]\\$ ",
             "0": "/bin/bash",
         },
         lastExitCode: 0,

package/dist/modules/linuxRootfs.js

@@ -59,7 +59,11 @@ function bootstrapEtc(vfs, hostname, props) {
     ensureFile(vfs, "/etc/shells", "/bin/sh\n/bin/bash\n/usr/bin/bash\n/bin/dash\n/usr/bin/dash\n");
     ensureFile(vfs, "/etc/profile", `${[
         "export PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
-        "export PS1='\\u@\\h:\\w\\$ '",
+        "if [ \"$(id -u)\" -eq 0 ]; then",
+        "  export PS1='\\[\\e[37;1m\\][\\[\\e[31;1m\\]\\u\\[\\e[37;1m\\]@\\[\\e[34;1m\\]\\h\\[\\e[0m\\] \\w\\[\\e[37;1m\\]]\\[\\e[31;1m\\]\\$\\[\\e[0m\\] '",
+        "else",
+        "  export PS1='\\[\\e[37;1m\\][\\[\\e[35;1m\\]\\u\\[\\e[37;1m\\]@\\[\\e[34;1m\\]\\h\\[\\e[0m\\] \\w\\[\\e[37;1m\\]]\\[\\e[0m\\]\\$ '",
+        "fi",
     ].join("\n")}\n`);
     ensureFile(vfs, "/etc/issue", "Fortune GNU/Linux 24.04 LTS \\n \\l\n");
     ensureFile(vfs, "/etc/issue.net", "Fortune GNU/Linux 24.04 LTS\n");
@@ -1281,7 +1285,7 @@ Installed-Size: 6800
 Maintainer: Fortune Package Team <dpkg@fortune.local>
 Architecture: amd64
 Version: 1.22.6nyx1
-Depends: libc6 (>= 2.17), libzstd1 (>= 1.5.7)
+Depends: libc6 (>= 2.17), libzstd1 (>= 1.5.8)
 Description: Fortune package management system
  This package provides the low-level infrastructure for handling the
  installation and removal of Fortune software packages.
@@ -1449,7 +1453,7 @@ function bootstrapRoot(vfs) {
     ensureDir(vfs, "/root/.local/share", 0o755);
     ensureFile(vfs, "/root/.bashrc", `${[
         "# root .bashrc",
-        "export PS1='\\[\\033[0;31m\\]\\u@\\h\\[\\033[0m\\]:\\[\\033[0;34m\\]\\w\\[\\033[0m\\]# '",
+        "export PS1='\\[\\e[37;1m\\][\\[\\e[31;1m\\]\\u\\[\\e[37;1m\\]@\\[\\e[34;1m\\]\\h\\[\\e[0m\\] \\w\\[\\e[37;1m\\]]\\[\\e[31;1m\\]\\$\\[\\e[0m\\] '",
         "export PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
         "export LANG=en_US.UTF-8",
         "alias ll='ls -la'",

package/dist/modules/nanoEditor.d.ts

@@ -0,0 +1,92 @@
+import type { TerminalSize } from "./shellRuntime";
+import type { ShellStream } from "../types/streams";
+export type NanoExitReason = "saved" | "aborted";
+export interface NanoEditorOptions {
+    stream: ShellStream;
+    terminalSize: TerminalSize;
+    content: string;
+    filename: string;
+    onExit: (reason: NanoExitReason, content: string) => void;
+    /** Called on ^S / silent save — save without closing nano. Optional. */
+    onSave?: (content: string) => void;
+}
+export declare class NanoEditor {
+    private lines;
+    private cursorRow;
+    private cursorCol;
+    private scrollTop;
+    private modified;
+    private filename;
+    private mode;
+    private inputBuffer;
+    private searchState;
+    private clipboard;
+    private undoStack;
+    private redoStack;
+    private markActive;
+    private readonly stream;
+    private terminalSize;
+    private readonly onExit;
+    private readonly onSave;
+    constructor(opts: NanoEditorOptions);
+    start(): void;
+    resize(size: TerminalSize): void;
+    handleInput(chunk: Buffer): void;
+    private consumeSequence;
+    private handleEscape;
+    private handleAlt;
+    private handleChar;
+    private handleControl;
+    private dispatch;
+    private handlePromptChar;
+    private moveCursor;
+    private moveCursorLeft;
+    private moveCursorRight;
+    private moveCursorHome;
+    private moveCursorEnd;
+    private movePage;
+    private moveWordRight;
+    private moveWordLeft;
+    private pushUndo;
+    private doInsertChar;
+    private doEnter;
+    private doBackspace;
+    private doDelete;
+    private doCutLine;
+    private doUncut;
+    private doUndo;
+    private doRedo;
+    private enterSearch;
+    private doSearch;
+    private doSearchNext;
+    private doSearchReplace;
+    private toggleMark;
+    private doExit;
+    private doSave;
+    private enterWriteout;
+    private showCursorPos;
+    private enterGotoLine;
+    private enterHelp;
+    private get cols();
+    private get rows();
+    private editAreaRows;
+    private editAreaStart;
+    private currentLine;
+    private clampScroll;
+    private getCurrentContent;
+    private pad;
+    fullRedraw(): void;
+    private renderTitleBar;
+    private renderEditArea;
+    private renderLine;
+    private renderCursor;
+    private renderStatusLine;
+    private renderStatusBar;
+    private buildTitleBar;
+    private buildEditArea;
+    private renderLineText;
+    private buildHelpBar;
+    private buildShortcutRow;
+    private buildCursorPosition;
+    private renderHelp;
+}