typescript-virtual-container 1.5.7 → 1.5.9

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,
@@ -156,6 +180,41 @@ async function _runCommandDirectInner(name, args, authUser, hostname, mode, cwd,
             }
         }
     }
+    // Shell function defined via sh.ts (stored as __func_<name>)
+    const funcBody = env.vars[`__func_${name}`];
+    if (funcBody) {
+        const shMod = resolveModule("sh");
+        if (!shMod)
+            return { stderr: `${name}: sh not available`, exitCode: 127 };
+        const savedPositional = {};
+        args.forEach((a, i) => {
+            savedPositional[String(i + 1)] = env.vars[String(i + 1)];
+            env.vars[String(i + 1)] = a;
+        });
+        savedPositional["0"] = env.vars["0"];
+        env.vars["0"] = name;
+        try {
+            return await shMod.run({
+                authUser, hostname,
+                activeSessions: shell.users.listActiveSessions(),
+                rawInput: funcBody,
+                mode,
+                args: ["-c", funcBody],
+                stdin,
+                cwd,
+                shell,
+                env,
+            });
+        }
+        finally {
+            for (const [k, v] of Object.entries(savedPositional)) {
+                if (v === undefined)
+                    delete env.vars[k];
+                else
+                    env.vars[k] = v;
+            }
+        }
+    }
     const aliasVal = env.vars[`__alias_${name}`];
     if (aliasVal) {
         return runCommand(`${aliasVal} ${args.join(" ")}`, authUser, hostname, mode, cwd, shell, stdin, env);

package/dist/commands/sh.js

@@ -20,9 +20,11 @@ function parseBlocks(lines) {
             continue;
         }
         // Function definition: name() { or function name { or name() { body }
-        const funcMatchInline = line.match(/^(?:function\s+)?(\w+)\s*\(\s*\)\s*\{(.+)\}\s*$/);
-        const funcMatch = funcMatchInline ?? (line.match(/^(?:function\s+)?(\w+)\s*\(\s*\)\s*\{?\s*$/) ||
-            line.match(/^function\s+(\w+)\s*\{?\s*$/));
+        // Shell allows any non-whitespace identifier as function name (incl. ':')
+        const funcNamePat = "[^\\s(){}]+";
+        const funcMatchInline = line.match(new RegExp(`^(?:function\\s+)?(${funcNamePat})\\s*\\(\\s*\\)\\s*\\{(.+)\\}\\s*$`));
+        const funcMatch = funcMatchInline ?? (line.match(new RegExp(`^(?:function\\s+)?(${funcNamePat})\\s*\\(\\s*\\)\\s*\\{?\\s*$`)) ||
+            line.match(new RegExp(`^function\\s+(${funcNamePat})\\s*\\{?\\s*$`)));
         if (funcMatch) {
             const funcName = funcMatch[1];
             const body = [];

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[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[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.9)
 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[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 { ShellStream } from "../types/streams";
+import type { TerminalSize } from "./shellRuntime";
+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;
+}