typescript-virtual-container 1.5.4 → 1.5.5

package/dist/VirtualShell/shell.js

@@ -12,6 +12,7 @@ export function startShell(properties, stream, authUser, hostname, sessionId, re
     let historyIndex = null;
     let historyDraft = "";
     let cwd = userHome(authUser);
+    let pendingHeredoc = null;
     const shellEnv = makeDefaultEnv(authUser, hostname);
     let nanoSession = null;
     let pendingSudo = null;
@@ -22,23 +23,33 @@ export function startShell(properties, stream, authUser, hostname, sessionId, re
     };
     const commandNames = Array.from(new Set(getCommandNames())).sort();
     console.log(`[${sessionId}] Shell started for user '${authUser}' at ${remoteAddress}`);
-    // Load .bashrc if it exists
+    // Source login/rc files at startup
     void (async () => {
-        const bashrcPath = `${userHome(authUser)}/.bashrc`;
-        if (shell.vfs.exists(bashrcPath)) {
+        const sourceFile = async (filePath, isEnvFile = false) => {
+            if (!shell.vfs.exists(filePath))
+                return;
             try {
-                const bashrc = shell.vfs.readFile(bashrcPath);
-                for (const line of bashrc.split("\n")) {
+                const content = shell.vfs.readFile(filePath);
+                for (const line of content.split("\n")) {
                     const l = line.trim();
                     if (!l || l.startsWith("#"))
                         continue;
-                    await runCommand(l, authUser, hostname, "shell", cwd, shell, undefined, shellEnv);
+                    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);
+                    }
                 }
             }
-            catch {
-                /* ignore bashrc errors */
-            }
-        }
+            catch { /* ignore */ }
+        };
+        await sourceFile("/etc/environment", true);
+        await sourceFile(`${userHome(authUser)}/.profile`);
+        await sourceFile(`${userHome(authUser)}/.bashrc`);
     })();
     function renderLine() {
         const prompt = buildCurrentPrompt();
@@ -283,6 +294,53 @@ export function startShell(properties, stream, authUser, hostname, sessionId, re
             nanoSession.process.stdin.write(chunk);
             return;
         }
+        if (pendingHeredoc) {
+            const hd = pendingHeredoc;
+            const input = chunk.toString("utf8");
+            for (let i = 0; i < input.length; i++) {
+                const ch = input[i];
+                if (ch === "") {
+                    pendingHeredoc = null;
+                    stream.write("^C\r\n");
+                    renderLine();
+                    return;
+                }
+                if (ch === "" || ch === "\b") {
+                    lineBuffer = lineBuffer.slice(0, -1);
+                    renderLine();
+                    continue;
+                }
+                if (ch === "\r" || ch === "\n") {
+                    const typedLine = lineBuffer;
+                    lineBuffer = "";
+                    cursorPos = 0;
+                    stream.write("\r\n");
+                    if (typedLine === hd.delimiter) {
+                        const stdin = hd.lines.join("\n");
+                        const cmd = hd.cmdBefore;
+                        pendingHeredoc = null;
+                        pushHistory(`${cmd} << ${hd.delimiter}`);
+                        const result = await Promise.resolve(runCommand(cmd, authUser, hostname, "shell", cwd, shell, stdin, shellEnv));
+                        if (result.stdout)
+                            stream.write(`${toTtyLines(result.stdout)}\r\n`);
+                        if (result.stderr)
+                            stream.write(`${toTtyLines(result.stderr)}\r\n`);
+                        if (result.nextCwd)
+                            cwd = result.nextCwd;
+                        renderLine();
+                        return;
+                    }
+                    hd.lines.push(typedLine);
+                    stream.write("> ");
+                    continue;
+                }
+                if (ch >= " " || ch === "\t") {
+                    lineBuffer += ch;
+                    stream.write(ch);
+                }
+            }
+            return;
+        }
         if (pendingSudo) {
             const input = chunk.toString("utf8");
             for (let i = 0; i < input.length; i += 1) {
@@ -407,6 +465,47 @@ export function startShell(properties, stream, authUser, hostname, sessionId, re
                         }
                         continue;
                     }
+                    // Home: \x1b[1~ or \x1b[H
+                    if (third === "1" && fourth === "~") {
+                        i += 3;
+                        cursorPos = 0;
+                        renderLine();
+                        continue;
+                    }
+                    if (third === "H") {
+                        i += 2;
+                        cursorPos = 0;
+                        renderLine();
+                        continue;
+                    }
+                    // End: \x1b[4~ or \x1b[F
+                    if (third === "4" && fourth === "~") {
+                        i += 3;
+                        cursorPos = lineBuffer.length;
+                        renderLine();
+                        continue;
+                    }
+                    if (third === "F") {
+                        i += 2;
+                        cursorPos = lineBuffer.length;
+                        renderLine();
+                        continue;
+                    }
+                }
+                // Home/End via \x1bO sequences (some terminals)
+                if (next === "O" && third) {
+                    if (third === "H") {
+                        i += 2;
+                        cursorPos = 0;
+                        renderLine();
+                        continue;
+                    }
+                    if (third === "F") {
+                        i += 2;
+                        cursorPos = lineBuffer.length;
+                        renderLine();
+                        continue;
+                    }
                 }
             }
             if (ch === "\u0003") {
@@ -418,13 +517,61 @@ export function startShell(properties, stream, authUser, hostname, sessionId, re
                 renderLine();
                 continue;
             }
+            if (ch === "\u0001") {
+                cursorPos = 0;
+                renderLine();
+                continue;
+            } // Ctrl+A
+            if (ch === "\u0005") {
+                cursorPos = lineBuffer.length;
+                renderLine();
+                continue;
+            } // Ctrl+E
+            if (ch === "\u000b") {
+                lineBuffer = lineBuffer.slice(0, cursorPos);
+                renderLine();
+                continue;
+            } // Ctrl+K
+            if (ch === "\u0015") {
+                lineBuffer = lineBuffer.slice(cursorPos);
+                cursorPos = 0;
+                renderLine();
+                continue;
+            } // Ctrl+U
+            if (ch === "\u0017") { // Ctrl+W — kill word backward
+                let wStart = cursorPos;
+                while (wStart > 0 && lineBuffer[wStart - 1] === " ")
+                    wStart--;
+                while (wStart > 0 && lineBuffer[wStart - 1] !== " ")
+                    wStart--;
+                lineBuffer = lineBuffer.slice(0, wStart) + lineBuffer.slice(cursorPos);
+                cursorPos = wStart;
+                renderLine();
+                continue;
+            }
             if (ch === "\r" || ch === "\n") {
-                const line = lineBuffer.trim();
+                let line = lineBuffer.trim();
                 lineBuffer = "";
                 cursorPos = 0;
                 historyIndex = null;
                 historyDraft = "";
                 stream.write("\r\n");
+                // !! history expansion
+                if (line === "!!" || line.startsWith("!! ") || /\s!!$/.test(line) || / !! /.test(line)) {
+                    const lastCmd = history.length > 0 ? history[history.length - 1] : "";
+                    line = line === "!!" ? lastCmd : line.replace(/!!/g, lastCmd);
+                }
+                else if (/(?:^|\s)!!/.test(line)) {
+                    const lastCmd = history.length > 0 ? history[history.length - 1] : "";
+                    line = line.replace(/!!/g, lastCmd);
+                }
+                // Heredoc detection: cmd << DELIM
+                const heredocMatch = line.match(/^(.*?)\s*<<-?\s*['"`]?([A-Za-z_][A-Za-z0-9_]*)['"`]?\s*$/);
+                if (heredocMatch && line.length > 0) {
+                    pendingHeredoc = { delimiter: heredocMatch[2], lines: [], cmdBefore: heredocMatch[1].trim() || "cat" };
+                    stream.write("> ");
+                    continue;
+                }
                 if (line.length > 0) {
                     const result = await Promise.resolve(runCommand(line, authUser, hostname, "shell", cwd, shell, undefined, shellEnv));
                     pushHistory(line);

package/dist/commands/bc.d.ts

@@ -0,0 +1,2 @@
+import type { ShellModule } from "../types/commands";
+export declare const bcCommand: ShellModule;

package/dist/commands/bc.js

@@ -0,0 +1,28 @@
+import { evalArith } from "../utils/expand";
+export const bcCommand = {
+    name: "bc",
+    description: "Arbitrary precision calculator language",
+    category: "system",
+    params: ["[expression]"],
+    run: ({ args, stdin }) => {
+        const input = (stdin ?? args.join(" ")).trim();
+        if (!input)
+            return { stdout: "", exitCode: 0 };
+        const results = [];
+        for (const line of input.split("\n")) {
+            const expr = line.trim();
+            if (!expr || expr.startsWith("#"))
+                continue;
+            // Strip trailing semicolons
+            const cleaned = expr.replace(/;+$/, "").trim();
+            const val = evalArith(cleaned, {});
+            if (!Number.isNaN(val)) {
+                results.push(String(val));
+            }
+            else {
+                return { stderr: `bc: syntax error on line: ${expr}`, exitCode: 1 };
+            }
+        }
+        return { stdout: results.join("\n"), exitCode: 0 };
+    },
+};

package/dist/commands/{ifconfig.d.ts → ip.d.ts}

@@ -4,4 +4,4 @@ import type { ShellModule } from "../types/commands";
  * @category network
  * @params ["<object> <command>"]
  */
-export declare const ifconfigCommand: ShellModule;
+export declare const ipCommand: ShellModule;

package/dist/commands/{ifconfig.js → ip.js}

@@ -21,8 +21,8 @@ const LINK_OUTPUT = `1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state
  * @category network
  * @params ["<object> <command>"]
  */
-export const ifconfigCommand = {
-    name: "ifconfig",
+export const ipCommand = {
+    name: "ip",
     description: "Show/manipulate routing, network devices, interfaces",
     category: "network",
     params: ["<object> <command>"],
@@ -30,7 +30,7 @@ export const ifconfigCommand = {
         const obj = args[0]?.toLowerCase();
         const cmd = args[1]?.toLowerCase() ?? "show";
         if (!obj) {
-            return { stderr: "Usage: ifconfig [interface]", exitCode: 1 };
+            return { stderr: "Usage: ip [ OPTIONS ] OBJECT { COMMAND | help }\nOBJECT := { link | addr | route | neigh }", exitCode: 1 };
         }
         if (obj === "addr" || obj === "address" || obj === "a") {
             return { stdout: ADDR_OUTPUT, exitCode: 0 };

package/dist/commands/jobs.d.ts

@@ -0,0 +1,4 @@
+import type { ShellModule } from "../types/commands";
+export declare const jobsCommand: ShellModule;
+export declare const bgCommand: ShellModule;
+export declare const fgCommand: ShellModule;

package/dist/commands/jobs.js

@@ -0,0 +1,27 @@
+export const jobsCommand = {
+    name: "jobs",
+    description: "List active jobs",
+    category: "shell",
+    params: [],
+    run: () => ({ stdout: "", exitCode: 0 }),
+};
+export const bgCommand = {
+    name: "bg",
+    description: "Resume a suspended job in the background",
+    category: "shell",
+    params: ["[%jobspec]"],
+    run: ({ args }) => ({
+        stderr: `bg: ${args[0] ?? "%1"}: no such job`,
+        exitCode: 1,
+    }),
+};
+export const fgCommand = {
+    name: "fg",
+    description: "Resume a suspended job in the foreground",
+    category: "shell",
+    params: ["[%jobspec]"],
+    run: ({ args }) => ({
+        stderr: `fg: ${args[0] ?? "%1"}: no such job`,
+        exitCode: 1,
+    }),
+};

package/dist/commands/registry.js

@@ -4,6 +4,7 @@ import { aptCacheCommand, aptCommand } from "./apt";
 import { awkCommand } from "./awk";
 import { base64Command } from "./base64";
 import { basenameCommand, dirnameCommand } from "./basename";
+import { bcCommand } from "./bc";
 import { catCommand } from "./cat";
 import { cdCommand } from "./cd";
 import { chmodCommand } from "./chmod";
@@ -35,7 +36,8 @@ import { historyCommand } from "./history";
 import { hostnameCommand } from "./hostname";
 import { htopCommand } from "./htop";
 import { idCommand } from "./id";
-import { ifconfigCommand } from "./ifconfig";
+import { ipCommand } from "./ip";
+import { bgCommand, fgCommand, jobsCommand } from "./jobs";
 import { killCommand } from "./kill";
 import { dmesgCommand, lastCommand } from "./last";
 import { lnCommand, readlinkCommand } from "./ln";
@@ -81,13 +83,13 @@ import { unameCommand } from "./uname";
 import { uniqCommand } from "./uniq";
 import { unsetCommand } from "./unset";
 import { uptimeCommand } from "./uptime";
+import { wCommand } from "./w";
 import { wcCommand } from "./wc";
 import { wgetCommand } from "./wget";
 import { whichCommand } from "./which";
 import { whoCommand } from "./who";
 import { whoamiCommand } from "./whoami";
 import { xargsCommand } from "./xargs";
-import { wCommand } from "./w";
 const BASE_COMMANDS = [
     // Navigation
     pwdCommand,
@@ -159,7 +161,7 @@ const BASE_COMMANDS = [
     sttyCommand,
     lastCommand,
     dmesgCommand,
-    ifconfigCommand,
+    ipCommand,
     yesCommand,
     fortuneCommand,
     cowsayCommand,
@@ -184,6 +186,10 @@ const BASE_COMMANDS = [
     dpkgCommand,
     dpkgQueryCommand,
     // Shell (extended)
+    jobsCommand,
+    bgCommand,
+    fgCommand,
+    bcCommand,
     whichCommand,
     typeCommand,
     manCommand,

package/dist/commands/runtime.js

@@ -15,10 +15,11 @@ export function makeDefaultEnv(authUser, hostname) {
             HOME: userHome(authUser),
             USER: authUser,
             LOGNAME: authUser,
-            SHELL: "/bin/sh",
+            SHELL: "/bin/bash",
             TERM: "xterm-256color",
             HOSTNAME: hostname,
             PS1: "\\u@\\h:\\w\\$ ",
+            "0": "/bin/bash",
         },
         lastExitCode: 0,
     };

package/dist/commands/set.js

@@ -11,11 +11,31 @@ export const setCommand = {
     run: ({ args, env }) => {
         if (args.length === 0) {
             const out = Object.entries(env.vars)
+                .filter(([k]) => !k.startsWith("__"))
                 .map(([k, v]) => `${k}=${v}`)
                 .join("\n");
             return { stdout: out, exitCode: 0 };
         }
         for (const arg of args) {
+            const flagMatch = arg.match(/^([+-])([a-zA-Z]+)$/);
+            if (flagMatch) {
+                const on = flagMatch[1] === "-";
+                for (const flag of flagMatch[2]) {
+                    if (flag === "e") {
+                        if (on)
+                            env.vars.__errexit = "1";
+                        else
+                            delete env.vars.__errexit;
+                    }
+                    if (flag === "x") {
+                        if (on)
+                            env.vars.__xtrace = "1";
+                        else
+                            delete env.vars.__xtrace;
+                    }
+                }
+                continue;
+            }
             if (arg.includes("=")) {
                 const eq = arg.indexOf("=");
                 env.vars[arg.slice(0, eq)] = arg.slice(eq + 1);

package/dist/commands/sh.js

@@ -125,6 +125,43 @@ function parseBlocks(lines) {
             }
             blocks.push({ type: "while", cond, body });
         }
+        else if (line.startsWith("case ") && line.endsWith(" in") || line.match(/^case\s+.+\s+in$/)) {
+            const caseExpr = line.replace(/^case\s+/, "").replace(/\s+in$/, "").trim();
+            const patterns = [];
+            i++;
+            while (i < lines.length && lines[i]?.trim() !== "esac") {
+                const pl = lines[i].trim();
+                if (!pl || pl === "esac") {
+                    i++;
+                    continue;
+                }
+                // pattern) or pattern1|pattern2)
+                const patMatch = pl.match(/^(.+?)\)\s*(.*)$/);
+                if (patMatch) {
+                    const pat = patMatch[1].trim();
+                    const body = [];
+                    if (patMatch[2]?.trim() && patMatch[2].trim() !== ";;") {
+                        body.push(patMatch[2].trim());
+                    }
+                    i++;
+                    while (i < lines.length) {
+                        const bl = lines[i].trim();
+                        if (bl === ";;" || bl === "esac")
+                            break;
+                        if (bl)
+                            body.push(bl);
+                        i++;
+                    }
+                    if (lines[i]?.trim() === ";;")
+                        i++; // skip ;;
+                    patterns.push({ pattern: pat, body });
+                }
+                else {
+                    i++;
+                }
+            }
+            blocks.push({ type: "case", expr: caseExpr, patterns });
+        }
         else {
             blocks.push({ type: "cmd", line });
         }
@@ -189,9 +226,12 @@ async function evalCondition(cond, ctx) {
 async function runBlocks(blocks, ctx) {
     let lastResult = { exitCode: 0 };
     let output = "";
+    let traceOutput = "";
     for (const block of blocks) {
         if (block.type === "cmd") {
             const expanded = await expandVars(block.line, ctx.env.vars, ctx.env.lastExitCode, ctx);
+            if (ctx.env.vars.__xtrace)
+                traceOutput += `+ ${expanded}\n`;
             // Bare VAR=val assignment(s) — handle before dispatching to runCommand
             const assignRe = /^([A-Za-z_][A-Za-z0-9_]*)=(.*)/;
             const tokens = expanded.trim().split(/\s+/);
@@ -231,6 +271,8 @@ async function runBlocks(blocks, ctx) {
                 output += `${r.stdout}\n`;
             if (r.stderr)
                 return { ...r, stdout: output.trim() };
+            if (ctx.env.vars.__errexit && (r.exitCode ?? 0) !== 0)
+                return { ...r, stdout: output.trim() };
             lastResult = r;
         }
         else if (block.type === "if") {
@@ -311,8 +353,34 @@ async function runBlocks(blocks, ctx) {
                 iterations++;
             }
         }
+        else if (block.type === "case") {
+            const expanded = await expandVars(block.expr, ctx.env.vars, ctx.env.lastExitCode, ctx);
+            for (const pat of block.patterns) {
+                const alts = pat.pattern.split("|").map((p) => p.trim());
+                const matched = alts.some((p) => {
+                    if (p === "*")
+                        return true;
+                    if (p.includes("*") || p.includes("?")) {
+                        const re = new RegExp(`^${p.replace(/\./g, "\\.").replace(/\*/g, ".*").replace(/\?/g, ".")}$`);
+                        return re.test(expanded);
+                    }
+                    return p === expanded;
+                });
+                if (matched) {
+                    const sub = await runBlocks(parseBlocks(pat.body), ctx);
+                    if (sub.stdout)
+                        output += `${sub.stdout}\n`;
+                    break;
+                }
+            }
+        }
+    }
+    const finalStdout = output.trim() || lastResult.stdout;
+    if (traceOutput) {
+        const traceStderr = (lastResult.stderr ? `${lastResult.stderr}\n` : "") + traceOutput.trim();
+        return { ...lastResult, stdout: finalStdout, stderr: traceStderr || lastResult.stderr };
     }
-    return { ...lastResult, stdout: output.trim() || lastResult.stdout };
+    return { ...lastResult, stdout: finalStdout };
 }
 /**
  * Execute shell scripts or commands with a minimal shell interpreter.

package/dist/utils/expand.js

@@ -369,10 +369,12 @@ export function expandSync(input, env, lastExit = 0, home) {
         let s = chunk;
         // Tilde expansion — only at start of token or after `:` or whitespace
         s = s.replace(/(^|[\s:])~(\/|$)/g, (_, pre, post) => `${pre}${homePath}${post}`);
-        // $? $$ $#
+        // $? $$ $# $RANDOM $LINENO
         s = s.replace(/\$\?/g, String(lastExit));
         s = s.replace(/\$\$/g, "1");
         s = s.replace(/\$#/g, "0");
+        s = s.replace(/\$RANDOM\b/g, () => String(Math.floor(Math.random() * 32768)));
+        s = s.replace(/\$LINENO\b/g, "1");
         // $(( arithmetic )) — must come before ${ and $VAR to avoid conflicts
         s = expandArithmeticChunks(s, env);
         // ${#VAR} — string length

package/package.json

@@ -4,7 +4,7 @@
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
-  "version": "1.5.4",
+  "version": "1.5.5",
   "files": [
     "dist/",
     "README.md",