typescript-virtual-container 1.5.6 → 1.5.8

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;
@@ -14,42 +15,48 @@ export function startShell(properties, stream, authUser, hostname, sessionId, re
     let cwd = userHome(authUser);
     let pendingHeredoc = null;
     const shellEnv = makeDefaultEnv(authUser, hostname);
+    const sessionStack = [];
     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();
@@ -87,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;
@@ -112,9 +120,11 @@ export function startShell(properties, stream, authUser, hostname, sessionId, re
             stream.write(`${toTtyLines(result.stderr)}\r\n`);
         }
         if (result.switchUser) {
+            sessionStack.push({ authUser, cwd });
             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;
@@ -122,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();
@@ -172,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;
@@ -205,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);
@@ -237,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;
@@ -255,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) {
@@ -396,13 +354,24 @@ export function startShell(properties, stream, authUser, hostname, sessionId, re
                 cursorPos = 0;
                 historyIndex = null;
                 historyDraft = "";
-                stream.write("bye\r\n");
-                pushHistory("bye");
-                // WAL: checkpoint handled by auto-flush timer
                 stream.write("logout\r\n");
-                stream.exit(0);
-                stream.end();
-                return;
+                if (sessionStack.length > 0) {
+                    const prev = sessionStack.pop();
+                    authUser = prev.authUser;
+                    cwd = prev.cwd;
+                    shellEnv.vars.USER = authUser;
+                    shellEnv.vars.LOGNAME = authUser;
+                    shellEnv.vars.HOME = userHome(authUser);
+                    shellEnv.vars.PWD = cwd;
+                    shell.users.updateSession(sessionId, authUser, remoteAddress);
+                    renderLine();
+                }
+                else {
+                    stream.exit(0);
+                    stream.end();
+                    return;
+                }
+                continue;
             }
             if (ch === "\t") {
                 handleTabCompletion();
@@ -598,17 +567,32 @@ export function startShell(properties, stream, authUser, hostname, sessionId, re
                     }
                     if (result.closeSession) {
                         stream.write("logout\r\n");
-                        stream.exit(result.exitCode ?? 0);
-                        stream.end();
-                        return;
+                        if (sessionStack.length > 0) {
+                            const prev = sessionStack.pop();
+                            authUser = prev.authUser;
+                            cwd = prev.cwd;
+                            shellEnv.vars.USER = authUser;
+                            shellEnv.vars.LOGNAME = authUser;
+                            shellEnv.vars.HOME = userHome(authUser);
+                            shellEnv.vars.PWD = cwd;
+                            shell.users.updateSession(sessionId, authUser, remoteAddress);
+                        }
+                        else {
+                            stream.exit(result.exitCode ?? 0);
+                            stream.end();
+                            return;
+                        }
                     }
-                    if (result.nextCwd) {
+                    if (result.nextCwd && !result.closeSession) {
                         cwd = result.nextCwd;
                     }
                     if (result.switchUser) {
+                        sessionStack.push({ authUser, cwd });
                         authUser = result.switchUser;
                         cwd = result.nextCwd ?? userHome(authUser);
+                        shellEnv.vars.PWD = cwd;
                         shell.users.updateSession(sessionId, authUser, remoteAddress);
+                        await applyUserSwitch(authUser, hostname, cwd, shellEnv, shell);
                         lineBuffer = "";
                         cursorPos = 0;
                     }
@@ -630,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/VirtualShell/shellParser.js

@@ -1,3 +1,4 @@
+import { globToRegex } from "../utils/glob";
 import { tokenizeCommand } from "../utils/tokenize";
 // ── Public API ───────────────────────────────────────────────────────────────
 /**
@@ -42,28 +43,6 @@ export function expandGlob(pattern, entries) {
     const matches = entries.filter((e) => regex.test(e));
     return matches.length > 0 ? matches.sort() : [pattern];
 }
-function globToRegex(pattern) {
-    let re = "^";
-    for (let i = 0; i < pattern.length; i++) {
-        const c = pattern[i];
-        if (c === "*")
-            re += ".*";
-        else if (c === "?")
-            re += ".";
-        else if (c === "[") {
-            const close = pattern.indexOf("]", i + 1);
-            if (close === -1)
-                re += "\\[";
-            else {
-                re += `[${pattern.slice(i + 1, close)}]`;
-                i = close;
-            }
-        }
-        else
-            re += c.replace(/[.+^${}()|[\]\\]/g, "\\$&");
-    }
-    return new RegExp(`${re}$`);
-}
 // ── Internal parser ───────────────────────────────────────────────────────────
 function parseStatements(input) {
     // Split by ;, &&, || — respecting quotes and parens

package/dist/commands/exit.js

@@ -5,7 +5,7 @@
  */
 export const exitCommand = {
     name: "exit",
-    aliases: ["bye"],
+    aliases: ["bye", "logout"],
     description: "Exit the shell session",
     category: "shell",
     params: ["[code]"],

package/dist/commands/find.js

@@ -1,3 +1,4 @@
+import { globToRegex } from "../utils/glob";
 import { assertPathAccess, resolvePath } from "./helpers";
 import { runCommand } from "./runtime";
 /**
@@ -109,10 +110,6 @@ export const findCommand = {
             return [{ type: "true" }, pos + 1];
         }
         const pred = exprArgs.length > 0 ? parseExpr(exprArgs, 0)[0] : { type: "true" };
-        function globToRegex(pat, flags = "") {
-            const esc = pat.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
-            return new RegExp(`^${esc}$`, flags);
-        }
         function matchPred(p, fullPath, depth) {
             switch (p.type) {
                 case "true": return true;

package/dist/commands/helpers.d.ts

@@ -1,28 +1,8 @@
 import type VirtualFileSystem from "../VirtualFileSystem";
 import type { VirtualPackageManager } from "../VirtualPackageManager";
 import type { VirtualShell } from "../VirtualShell";
-export declare function normalizeTerminalOutput(text: string): string;
 export declare function resolvePath(cwd: string, inputPath: string, homeDir?: string): string;
 export declare function assertPathAccess(authUser: string, targetPath: string, operation: string): void;
 export declare function stripUrlFilename(url: string): string;
-export declare function fetchResource(url: string): Promise<{
-    text: string;
-    status: number;
-    contentType: string | null;
-}>;
-/**
- * Run a host command like curl or wget and capture its output.
- * @param binary - The binary to execute (e.g., "curl", "wget").
- * @param args - Arguments to pass to the binary.
- * @returns Promise resolving with stdout, stderr, and exit code.
- */
-export declare function runHostCommand(binary: string, args: string[]): Promise<{
-    stdout: string;
-    stderr: string;
-    exitCode: number;
-}>;
 export declare function resolveReadablePath(vfs: VirtualFileSystem, cwd: string, inputPath: string): string;
-export declare function joinListWithType(cwd: string, items: string[], statAt: (p: string) => {
-    type: "file" | "directory";
-}): string;
 export declare function getPackageManager(shell: VirtualShell): VirtualPackageManager | undefined;

package/dist/commands/helpers.js

@@ -1,23 +1,5 @@
-import { spawn } from "node:child_process";
 import * as path from "node:path";
 const PROTECTED_PREFIXES = ["/.virtual-env-js/.auth", "/etc/htpasswd"];
-function normalizeFetchUrl(input) {
-    if (/^[a-zA-Z][a-zA-Z\d+\-.]*:/.test(input)) {
-        return input;
-    }
-    return `http://${input}`;
-}
-export function normalizeTerminalOutput(text) {
-    return text
-        .replace(/\r\n/g, "\n")
-        .replace(/\r/g, "\n")
-        .replace(/\t/g, "  ")
-        .split("\n")
-        .map((line) => line.replace(/^[ \u00A0]{8,}/, "  ").replace(/[ \u00A0]{3,}/g, "  "))
-        .join("\n")
-        .replace(/\n{3,}/g, "\n\n")
-        .trimEnd();
-}
 export function resolvePath(cwd, inputPath, homeDir) {
     if (!inputPath || inputPath.trim() === "") {
         return cwd;
@@ -49,76 +31,6 @@ export function stripUrlFilename(url) {
     const lastPart = cleaned.split("/").filter(Boolean).pop();
     return lastPart && lastPart.length > 0 ? lastPart : "index.html";
 }
-export async function fetchResource(url) {
-    const response = await fetch(normalizeFetchUrl(url));
-    const contentType = response.headers.get("content-type");
-    return {
-        text: await response.text(),
-        status: response.status,
-        contentType,
-    };
-}
-/**
- * Run a host command like curl or wget and capture its output.
- * @param binary - The binary to execute (e.g., "curl", "wget").
- * @param args - Arguments to pass to the binary.
- * @returns Promise resolving with stdout, stderr, and exit code.
- */
-export function runHostCommand(binary, args) {
-    return new Promise((resolve) => {
-        let childProcess;
-        try {
-            childProcess = spawn(binary, args, {
-                stdio: ["ignore", "pipe", "pipe"],
-            });
-        }
-        catch (error) {
-            resolve({
-                stdout: "",
-                stderr: `${binary}: ${error instanceof Error ? error.message : String(error)}`,
-                exitCode: 1,
-            });
-            return;
-        }
-        let stdout = "";
-        let stderr = "";
-        const stdoutStream = childProcess.stdout;
-        const stderrStream = childProcess.stderr;
-        if (!stdoutStream || !stderrStream) {
-            resolve({
-                stdout: "",
-                stderr: `${binary}: failed to capture process output`,
-                exitCode: 1,
-            });
-            return;
-        }
-        stdoutStream.setEncoding("utf8");
-        stderrStream.setEncoding("utf8");
-        stdoutStream.on("data", (chunk) => {
-            stdout += chunk;
-        });
-        stderrStream.on("data", (chunk) => {
-            stderr += chunk;
-        });
-        childProcess.on("error", (error) => {
-            const errorCode = error instanceof Error && "code" in error
-                ? String(error.code ?? "")
-                : "";
-            resolve({
-                stdout: "",
-                stderr: `${binary}: ${error.message}`,
-                exitCode: errorCode === "ENOENT" ? 127 : 1,
-            });
-        });
-        childProcess.on("close", (code) => {
-            resolve({
-                stdout,
-                stderr,
-                exitCode: code ?? 1,
-            });
-        });
-    });
-}
 function levenshtein(a, b) {
     const dp = Array.from({ length: a.length + 1 }, () => Array(b.length + 1).fill(0));
     for (let i = 0; i <= a.length; i += 1) {
@@ -153,15 +65,6 @@ export function resolveReadablePath(vfs, cwd, inputPath) {
     }
     return exactPath;
 }
-export function joinListWithType(cwd, items, statAt) {
-    return items
-        .map((name) => {
-        const childPath = resolvePath(cwd, name);
-        const stats = statAt(childPath);
-        return stats.type === "directory" ? `${name}/` : name;
-    })
-        .join("  ");
-}
 export function getPackageManager(shell) {
     return shell.packageManager;
 }

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/perl.js

@@ -25,7 +25,7 @@ export const perlCommand = {
             for (let li = 0; li < lines.length; li++) {
                 let line = lines[li];
                 // $_ = line, $. = line number
-                let processed = code
+                const processed = code
                     .replace(/\$_/g, JSON.stringify(line))
                     .replace(/\$\./g, String(li + 1));
                 // s/pat/rep/[g] substitution on $_

package/dist/commands/python.js

@@ -694,8 +694,11 @@ class Interpreter {
                     return left.repeat(right);
                 if (Array.isArray(left) && typeof right === "number") {
                     const arr = [];
-                    for (let i = 0; i < right; i++)
-                        arr.push(...left);
+                    const n = right | 0;
+                    for (let i = 0; i < n; i++) {
+                        for (let j = 0; j < left.length; j++)
+                            arr.push(left[j]);
+                    }
                     return arr;
                 }
                 return left * right;