typescript-virtual-container 1.5.7 → 1.5.9

package/dist/modules/webTermRenderer.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Minimal VT100 screen buffer for browser-side rendering.
+ * Handles the subset of escape sequences emitted by NanoEditor:
+ *   - CSI H / CSI row;colH  (cursor position)
+ *   - CSI K                  (erase to end of line)
+ *   - CSI 2J                 (erase display)
+ *   - CSI ?25l / ?25h        (cursor hide/show)
+ *   - CSI <n> m              (SGR — bold, reverse, fg, bg, reset)
+ */
+export interface Cell {
+    ch: string;
+    bold: boolean;
+    reverse: boolean;
+    fg: string | null;
+    bg: string | null;
+}
+export declare class WebTermRenderer {
+    private rows;
+    private cols;
+    private screen;
+    private scrollback;
+    private curRow;
+    private curCol;
+    private cursorVisible;
+    private _cleared;
+    private bold;
+    private reverse;
+    private fg;
+    private bg;
+    private buf;
+    constructor(rows: number, cols: number);
+    resize(rows: number, cols: number): void;
+    write(data: string): void;
+    private flush;
+    private handleCsi;
+    private handleSgr;
+    private scrollUp;
+    private putChar;
+    private makeScreen;
+    /** Render current screen state to an HTML string for a <pre> element. */
+    renderHtml(): string;
+    get cursorRow(): number;
+    get cursorCol(): number;
+    get isCursorVisible(): boolean;
+    /** Returns true (once) if CSI 2J was received since last call. */
+    consumeCleared(): boolean;
+    get scrollbackLength(): number;
+    clearScrollback(): void;
+    renderScrollbackHtml(): string;
+}

package/dist/modules/webTermRenderer.js

@@ -0,0 +1,425 @@
+/**
+ * Minimal VT100 screen buffer for browser-side rendering.
+ * Handles the subset of escape sequences emitted by NanoEditor:
+ *   - CSI H / CSI row;colH  (cursor position)
+ *   - CSI K                  (erase to end of line)
+ *   - CSI 2J                 (erase display)
+ *   - CSI ?25l / ?25h        (cursor hide/show)
+ *   - CSI <n> m              (SGR — bold, reverse, fg, bg, reset)
+ */
+const DEFAULT_CELL = { ch: " ", bold: false, reverse: false, fg: null, bg: null };
+function makeCell(partial) {
+    return { ...DEFAULT_CELL, ...partial };
+}
+export class WebTermRenderer {
+    rows;
+    cols;
+    screen;
+    scrollback = [];
+    curRow = 0;
+    curCol = 0;
+    cursorVisible = true;
+    _cleared = false;
+    // Current SGR state
+    bold = false;
+    reverse = false;
+    fg = null;
+    bg = null;
+    buf = "";
+    constructor(rows, cols) {
+        this.rows = rows;
+        this.cols = cols;
+        this.screen = this.makeScreen();
+    }
+    resize(rows, cols) {
+        const newScreen = this.makeScreen(rows, cols);
+        for (let r = 0; r < Math.min(rows, this.rows); r++) {
+            for (let c = 0; c < Math.min(cols, this.cols); c++) {
+                newScreen[r][c] = this.screen[r]?.[c] ?? makeCell();
+            }
+        }
+        this.rows = rows;
+        this.cols = cols;
+        this.screen = newScreen;
+        this.curRow = Math.min(this.curRow, rows - 1);
+        this.curCol = Math.min(this.curCol, cols - 1);
+    }
+    write(data) {
+        this.buf += data;
+        this.flush();
+    }
+    flush() {
+        let i = 0;
+        while (i < this.buf.length) {
+            const ch = this.buf[i];
+            if (ch === "\x1b") {
+                if (i + 1 >= this.buf.length)
+                    break; // wait for more data
+                const next = this.buf[i + 1];
+                if (next === "[") {
+                    // CSI — find terminator
+                    let j = i + 2;
+                    while (j < this.buf.length && (this.buf[j] < "@" || this.buf[j] > "~"))
+                        j++;
+                    if (j >= this.buf.length)
+                        break; // incomplete
+                    const seq = this.buf.slice(i + 2, j);
+                    const cmd = this.buf[j];
+                    this.handleCsi(seq, cmd);
+                    i = j + 1;
+                }
+                else if (next === "]") {
+                    // OSC (Operating System Command) — terminator is BEL (\x07) or ST (ESC \)
+                    // Must consume fully or the payload prints as raw text and corrupts SGR state.
+                    let j = i + 2;
+                    while (j < this.buf.length) {
+                        if (this.buf[j] === "\x07") {
+                            j++;
+                            break;
+                        }
+                        if (this.buf[j] === "\x1b" && this.buf[j + 1] === "\\") {
+                            j += 2;
+                            break;
+                        }
+                        j++;
+                    }
+                    // If terminator not yet received, wait for more data
+                    if (j >= this.buf.length && this.buf[j - 1] !== "\x07")
+                        break;
+                    i = j;
+                }
+                else if (next === "O") {
+                    // SS3 — single extra byte (F1-F4, cursor keys in application mode)
+                    if (i + 2 >= this.buf.length)
+                        break; // wait for more data
+                    i += 3; // ESC O <cmd>
+                }
+                else {
+                    i += 2; // skip unknown 2-char ESC sequence
+                }
+            }
+            else if (ch === "\r") {
+                this.curCol = 0;
+                i++;
+            }
+            else if (ch === "\n") {
+                if (this.curRow < this.rows - 1) {
+                    this.curRow++;
+                }
+                else {
+                    this.scrollUp();
+                }
+                i++;
+            }
+            else if (ch.charCodeAt(0) >= 32) {
+                this.putChar(ch);
+                i++;
+            }
+            else {
+                i++; // skip other control chars
+            }
+        }
+        this.buf = this.buf.slice(i);
+    }
+    handleCsi(seq, cmd) {
+        if (cmd === "H" || cmd === "f") {
+            // Cursor position: row;col (1-based)
+            const parts = seq.split(";").map((n) => Number.parseInt(n || "1", 10));
+            this.curRow = Math.max(0, Math.min((parts[0] ?? 1) - 1, this.rows - 1));
+            this.curCol = Math.max(0, Math.min((parts[1] ?? 1) - 1, this.cols - 1));
+            return;
+        }
+        if (cmd === "K") {
+            // Erase line from cursor to end
+            const mode = seq === "" ? 0 : Number.parseInt(seq, 10);
+            if (mode === 0) {
+                for (let c = this.curCol; c < this.cols; c++) {
+                    this.screen[this.curRow][c] = makeCell();
+                }
+            }
+            else if (mode === 1) {
+                for (let c = 0; c <= this.curCol; c++) {
+                    this.screen[this.curRow][c] = makeCell();
+                }
+            }
+            else if (mode === 2) {
+                for (let c = 0; c < this.cols; c++) {
+                    this.screen[this.curRow][c] = makeCell();
+                }
+            }
+            return;
+        }
+        if (cmd === "m") {
+            this.handleSgr(seq);
+            return;
+        }
+        if (cmd === "l" && seq === "?25") {
+            this.cursorVisible = false;
+            return;
+        }
+        if (cmd === "h" && seq === "?25") {
+            this.cursorVisible = true;
+            return;
+        }
+        // Cursor movement (relative)
+        if (cmd === "A") {
+            const n = Number.parseInt(seq || "1", 10) || 1;
+            this.curRow = Math.max(0, this.curRow - n);
+            return;
+        }
+        if (cmd === "B") {
+            const n = Number.parseInt(seq || "1", 10) || 1;
+            this.curRow = Math.min(this.rows - 1, this.curRow + n);
+            return;
+        }
+        if (cmd === "C") {
+            const n = Number.parseInt(seq || "1", 10) || 1;
+            this.curCol = Math.min(this.cols - 1, this.curCol + n);
+            return;
+        }
+        if (cmd === "D") {
+            const n = Number.parseInt(seq || "1", 10) || 1;
+            this.curCol = Math.max(0, this.curCol - n);
+            return;
+        }
+        // Cursor column absolute
+        if (cmd === "G") {
+            const n = Number.parseInt(seq || "1", 10) || 1;
+            this.curCol = Math.max(0, Math.min(n - 1, this.cols - 1));
+            return;
+        }
+        // Erase display modes 0/1
+        if (cmd === "J") {
+            const mode = seq === "" ? 0 : Number.parseInt(seq, 10);
+            if (mode === 0) {
+                for (let c = this.curCol; c < this.cols; c++)
+                    this.screen[this.curRow][c] = makeCell();
+                for (let r = this.curRow + 1; r < this.rows; r++)
+                    this.screen[r] = Array.from({ length: this.cols }, () => makeCell());
+            }
+            else if (mode === 1) {
+                for (let r = 0; r < this.curRow; r++)
+                    this.screen[r] = Array.from({ length: this.cols }, () => makeCell());
+                for (let c = 0; c <= this.curCol; c++)
+                    this.screen[this.curRow][c] = makeCell();
+            }
+            else if (mode === 2) {
+                this.screen = this.makeScreen();
+                this.scrollback = [];
+                this.curRow = 0;
+                this.curCol = 0;
+                this._cleared = true;
+            }
+            return;
+        }
+    }
+    handleSgr(seq) {
+        const codes = seq === "" ? [0] : seq.split(";").map((n) => Number.parseInt(n || "0", 10));
+        let i = 0;
+        while (i < codes.length) {
+            const code = codes[i];
+            if (code === 0) {
+                this.bold = false;
+                this.reverse = false;
+                this.fg = null;
+                this.bg = null;
+            }
+            else if (code === 1) {
+                this.bold = true;
+            }
+            else if (code === 7) {
+                this.reverse = true;
+            }
+            else if (code === 22) {
+                this.bold = false;
+            }
+            else if (code === 27) {
+                this.reverse = false;
+            }
+            else if (code >= 30 && code <= 37) {
+                this.fg = ANSI_COLORS[code - 30];
+            }
+            else if (code === 38) {
+                if (codes[i + 1] === 5 && codes[i + 2] !== undefined) {
+                    this.fg = xterm256(codes[i + 2]);
+                    i += 2;
+                }
+                else if (codes[i + 1] === 2 && codes[i + 4] !== undefined) {
+                    this.fg = `rgb(${codes[i + 2]},${codes[i + 3]},${codes[i + 4]})`;
+                    i += 4;
+                }
+            }
+            else if (code === 39) {
+                this.fg = null;
+            }
+            else if (code >= 40 && code <= 47) {
+                this.bg = ANSI_COLORS[code - 40];
+            }
+            else if (code === 48) {
+                if (codes[i + 1] === 5 && codes[i + 2] !== undefined) {
+                    this.bg = xterm256(codes[i + 2]);
+                    i += 2;
+                }
+                else if (codes[i + 1] === 2 && codes[i + 4] !== undefined) {
+                    this.bg = `rgb(${codes[i + 2]},${codes[i + 3]},${codes[i + 4]})`;
+                    i += 4;
+                }
+            }
+            else if (code === 49) {
+                this.bg = null;
+            }
+            else if (code >= 90 && code <= 97) {
+                this.fg = ANSI_COLORS_BRIGHT[code - 90];
+            }
+            else if (code >= 100 && code <= 107) {
+                this.bg = ANSI_COLORS_BRIGHT[code - 100];
+            }
+            i++;
+        }
+    }
+    scrollUp() {
+        const line = this.screen.shift();
+        this.scrollback.push(line);
+        if (this.scrollback.length > 1000)
+            this.scrollback.shift();
+        this.screen.push(Array.from({ length: this.cols }, () => makeCell()));
+        // curRow stays at rows-1 (bottom)
+    }
+    putChar(ch) {
+        if (this.curCol >= this.cols) {
+            this.curCol = 0;
+            if (this.curRow < this.rows - 1) {
+                this.curRow++;
+            }
+            else {
+                this.scrollUp();
+            }
+        }
+        this.screen[this.curRow][this.curCol] = makeCell({
+            ch,
+            bold: this.bold,
+            reverse: this.reverse,
+            fg: this.fg,
+            bg: this.bg,
+        });
+        this.curCol++;
+    }
+    makeScreen(rows = this.rows, cols = this.cols) {
+        return Array.from({ length: rows }, () => Array.from({ length: cols }, () => makeCell()));
+    }
+    /** Render current screen state to an HTML string for a <pre> element. */
+    renderHtml() {
+        let html = "";
+        for (let r = 0; r < this.rows; r++) {
+            const row = this.screen[r];
+            let spanOpen = false;
+            let lastStyle = "";
+            for (let c = 0; c < this.cols; c++) {
+                const cell = row[c];
+                const isCursor = this.cursorVisible && r === this.curRow && c === this.curCol;
+                let fg = cell.fg ?? "#ccc";
+                let bg = cell.bg ?? "transparent";
+                if (cell.reverse) {
+                    [fg, bg] = [bg === "transparent" ? "#000" : bg, fg === "transparent" ? "#000" : fg];
+                }
+                if (isCursor) {
+                    // Isoler le curseur dans son propre span pour éviter que sa couleur
+                    // inversée ne déborde sur les cellules vides adjacentes.
+                    if (spanOpen) {
+                        html += "</span>";
+                        spanOpen = false;
+                        lastStyle = "";
+                    }
+                    const curFg = bg === "transparent" ? "#000" : bg;
+                    const boldPart = cell.bold ? "font-weight:bold;" : "";
+                    html += `<span style="color:${curFg};background:#ccc;${boldPart}">${escHtml(cell.ch)}</span>`;
+                }
+                else {
+                    const style = `color:${fg};background:${bg};${cell.bold ? "font-weight:bold;" : ""}`;
+                    if (style !== lastStyle) {
+                        if (spanOpen)
+                            html += "</span>";
+                        html += `<span style="${style}">`;
+                        spanOpen = true;
+                        lastStyle = style;
+                    }
+                    html += escHtml(cell.ch);
+                }
+            }
+            if (spanOpen)
+                html += "</span>";
+            if (r < this.rows - 1)
+                html += "\n";
+        }
+        return html;
+    }
+    get cursorRow() { return this.curRow; }
+    get cursorCol() { return this.curCol; }
+    get isCursorVisible() { return this.cursorVisible; }
+    /** Returns true (once) if CSI 2J was received since last call. */
+    consumeCleared() {
+        const v = this._cleared;
+        this._cleared = false;
+        return v;
+    }
+    get scrollbackLength() { return this.scrollback.length; }
+    clearScrollback() { this.scrollback = []; }
+    renderScrollbackHtml() {
+        let html = "";
+        for (const row of this.scrollback) {
+            let spanOpen = false;
+            let lastStyle = "";
+            for (const cell of row) {
+                let fg = cell.fg ?? "#ccc";
+                let bg = cell.bg ?? "transparent";
+                if (cell.reverse) {
+                    [fg, bg] = [bg === "transparent" ? "#000" : bg, fg === "transparent" ? "#000" : fg];
+                }
+                const style = `color:${fg};background:${bg};${cell.bold ? "font-weight:bold;" : ""}`;
+                if (style !== lastStyle) {
+                    if (spanOpen)
+                        html += "</span>";
+                    html += `<span style="${style}">`;
+                    spanOpen = true;
+                    lastStyle = style;
+                }
+                html += escHtml(cell.ch);
+            }
+            if (spanOpen)
+                html += "</span>";
+            html += "\n";
+        }
+        return html;
+    }
+}
+// const ANSI_NORMAL_TO_BRIGHT: Record<string, string> = {
+// 	"#000": "#555", "#c00": "#f55", "#0c0": "#5f5", "#cc0": "#ff5",
+// 	"#00c": "#55f", "#c0c": "#f5f", "#0cc": "#5ff", "#ccc": "#fff",
+// };
+// function boldBright(fg: string): string {
+// 	return ANSI_NORMAL_TO_BRIGHT[fg] ?? fg;
+// }
+function escHtml(ch) {
+    if (ch === "&")
+        return "&amp;";
+    if (ch === "<")
+        return "&lt;";
+    if (ch === ">")
+        return "&gt;";
+    return ch;
+}
+const ANSI_COLORS = ["#000", "#c00", "#0c0", "#cc0", "#00c", "#c0c", "#0cc", "#ccc"];
+const ANSI_COLORS_BRIGHT = ["#555", "#f55", "#5f5", "#ff5", "#55f", "#f5f", "#5ff", "#fff"];
+function xterm256(n) {
+    if (n < 16)
+        return (n < 8 ? ANSI_COLORS : ANSI_COLORS_BRIGHT)[n < 8 ? n : n - 8];
+    if (n < 232) {
+        const i = n - 16;
+        const r = Math.floor(i / 36) * 51;
+        const g = Math.floor((i % 36) / 6) * 51;
+        const b = (i % 6) * 51;
+        return `rgb(${r},${g},${b})`;
+    }
+    const v = (n - 232) * 10 + 8;
+    return `rgb(${v},${v},${v})`;
+}

package/dist/types/commands.d.ts

@@ -27,6 +27,8 @@ export interface CommandResult {
     openEditor?: NanoEditorSession;
     /** Request opening built-in htop-like screen. */
     openHtop?: boolean;
+    /** Request opening built-in Pac-Man game. */
+    openPacman?: boolean;
     /** Request sudo password challenge flow. */
     sudoChallenge?: SudoChallenge;
     /** Request a generic password challenge (adduser, passwd). */

package/dist/types/pipeline.d.ts

@@ -36,6 +36,8 @@ export interface Statement {
     op?: LogicalOp;
     /** Optional next statement in sequence. */
     next?: Statement;
+    /** Run in background (trailing &). */
+    background?: boolean;
 }
 /** Top-level parse result for a script. */
 export interface Script {

package/dist/utils/shellSession.d.ts

@@ -0,0 +1,10 @@
+import type VirtualFileSystem from "../VirtualFileSystem";
+export declare function loadHistory(vfs: VirtualFileSystem, authUser: string): string[];
+export declare function saveHistory(vfs: VirtualFileSystem, authUser: string, history: string[]): void;
+export interface LastLogin {
+    at: string;
+    from: string;
+}
+export declare function readLastLogin(vfs: VirtualFileSystem, authUser: string): LastLogin | null;
+export declare function writeLastLogin(vfs: VirtualFileSystem, authUser: string, from: string): void;
+export declare function listPathCompletions(vfs: VirtualFileSystem, cwd: string, prefix: string): string[];

package/dist/utils/shellSession.js

@@ -0,0 +1,56 @@
+import * as path from "node:path";
+import { resolvePath } from "../commands/helpers";
+import { userHome } from "../commands/runtime";
+// ── History ───────────────────────────────────────────────────────────────────
+export function loadHistory(vfs, authUser) {
+    const historyPath = `${userHome(authUser)}/.bash_history`;
+    if (!vfs.exists(historyPath)) {
+        vfs.writeFile(historyPath, "");
+        return [];
+    }
+    return vfs.readFile(historyPath)
+        .split("\n")
+        .map((l) => l.trim())
+        .filter((l) => l.length > 0);
+}
+export function saveHistory(vfs, authUser, history) {
+    const data = history.length > 0 ? `${history.join("\n")}\n` : "";
+    vfs.writeFile(`${userHome(authUser)}/.bash_history`, data);
+}
+export function readLastLogin(vfs, authUser) {
+    const p = authUser === "root" ? "/root/.lastlog.json" : `/home/${authUser}/.lastlog`;
+    if (!vfs.exists(p))
+        return null;
+    try {
+        return JSON.parse(vfs.readFile(p));
+    }
+    catch {
+        return null;
+    }
+}
+export function writeLastLogin(vfs, authUser, from) {
+    const p = authUser === "root" ? "/root/.lastlog.json" : `/home/${authUser}/.lastlog`;
+    vfs.writeFile(p, JSON.stringify({ at: new Date().toISOString(), from }));
+}
+// ── Path completion ───────────────────────────────────────────────────────────
+export function listPathCompletions(vfs, cwd, 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 vfs
+            .list(basePath)
+            .filter((e) => e.startsWith(namePart))
+            .filter((e) => namePart.startsWith(".") || !e.startsWith("."))
+            .map((e) => {
+            const fullPath = path.posix.join(basePath, e);
+            const st = vfs.stat(fullPath);
+            return `${dirPart}${e}${st.type === "directory" ? "/" : ""}`;
+        })
+            .sort();
+    }
+    catch {
+        return [];
+    }
+}

package/package.json

@@ -4,7 +4,7 @@
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
-  "version": "1.5.7",
+  "version": "1.5.9",
   "files": [
     "dist/",
     "README.md",
@@ -37,7 +37,7 @@
     "deploy:npm": "bun publish --access public",
     "bench": "rm -rf .benchmark-shells/ && bun benchmark-virtualshell.ts",
     "benchmark": "bun benchmark-virtualshell.ts > benchmark-results.txt",
-"web-build": "bunx esbuild src/web.ts --bundle --platform=browser --format=esm --target=es2020 --outfile=builds/web.min.js --tree-shaking=true --minify",
+    "web-build": "bunx esbuild src/web.ts --bundle --platform=browser --format=esm --target=es2020 --outfile=builds/web.min.js --tree-shaking=true --minify",
     "web-build-iife": "bunx esbuild src/web.ts --bundle --platform=browser --format=iife --target=es2020 --outfile=builds/web-iife.min.js --tree-shaking=true --minify --global-name=WebShellLib",
     "example-build": "bun run web-build && cp builds/web.min.js examples/web.min.js",
     "example-serve": "cd examples && bun server.js",