typescript-virtual-container 1.2.9 → 1.3.1

package/dist/commands/node.js

@@ -0,0 +1,316 @@
+/** biome-ignore-all lint/style/useNamingConvention: node globals and ENV VAR KEYS */
+/**
+ * node.ts — Virtual Node.js runtime.
+ *
+ * Uses `node:vm` for sandboxed evaluation with a controlled context that
+ * intercepts `process`, `require`, `console`, and all standard globals.
+ * No host filesystem access, no network, no child processes.
+ */
+import vm from "node:vm";
+import { ifFlag } from "./command-helpers";
+import { resolvePath } from "./helpers";
+const VIRTUAL_VERSION = "v18.19.0";
+const VIRTUAL_VERSIONS = {
+    node: VIRTUAL_VERSION,
+    npm: "9.2.0",
+    v8: "10.2.154.26-node.22",
+};
+// ─── sandbox context ──────────────────────────────────────────────────────────
+function makeContext(outputLines, stderrLines) {
+    const fakeProcess = {
+        version: VIRTUAL_VERSION,
+        versions: VIRTUAL_VERSIONS,
+        platform: "linux",
+        arch: "x64",
+        env: {
+            NODE_ENV: "production",
+            HOME: "/root",
+            PATH: "/usr/local/bin:/usr/bin:/bin",
+        },
+        argv: ["node"],
+        stdout: {
+            write: (s) => {
+                outputLines.push(s);
+                return true;
+            },
+        },
+        stderr: {
+            write: (s) => {
+                stderrLines.push(s);
+                return true;
+            },
+        },
+        exit: (code = 0) => {
+            throw new ExitSignal(code);
+        },
+        cwd: () => "/root",
+        hrtime: () => [0, 0],
+    };
+    const fakeConsole = {
+        log: (...a) => outputLines.push(a.map(formatValue).join(" ")),
+        error: (...a) => stderrLines.push(a.map(formatValue).join(" ")),
+        warn: (...a) => stderrLines.push(a.map(formatValue).join(" ")),
+        info: (...a) => outputLines.push(a.map(formatValue).join(" ")),
+        dir: (v) => outputLines.push(formatValue(v)),
+    };
+    const fakeRequire = (mod) => {
+        // Provide stubs for common modules
+        switch (mod) {
+            case "path":
+                return {
+                    join: (...parts) => parts.join("/").replace(/\/+/g, "/"),
+                    resolve: (...parts) => `/${parts.join("/").replace(/^\/+/, "")}`,
+                    dirname: (p) => p.split("/").slice(0, -1).join("/") || "/",
+                    basename: (p) => p.split("/").pop() ?? "",
+                    extname: (p) => {
+                        const b = p.split("/").pop() ?? "";
+                        const d = b.lastIndexOf(".");
+                        return d > 0 ? b.slice(d) : "";
+                    },
+                    sep: "/",
+                    delimiter: ":",
+                };
+            case "os":
+                return {
+                    platform: () => "linux",
+                    arch: () => "x64",
+                    type: () => "Linux",
+                    hostname: () => "fortune-vm",
+                    homedir: () => "/root",
+                    tmpdir: () => "/tmp",
+                    EOL: "\n",
+                };
+            case "util":
+                return {
+                    format: (...a) => a.map(formatValue).join(" "),
+                    inspect: (v) => formatValue(v),
+                };
+            case "fs":
+            case "fs/promises":
+                throw new Error(`Cannot require '${mod}': filesystem access not available in virtual runtime`);
+            case "child_process":
+            case "net":
+            case "http":
+            case "https":
+                throw new Error(`Cannot require '${mod}': not available in virtual runtime`);
+            default:
+                throw new Error(`Cannot find module '${mod}'`);
+        }
+    };
+    fakeRequire.resolve = (id) => {
+        throw new Error(`Cannot resolve '${id}'`);
+    };
+    fakeRequire.cache = {};
+    fakeRequire.extensions = {};
+    return vm.createContext({
+        // Core globals
+        console: fakeConsole,
+        process: fakeProcess,
+        require: fakeRequire,
+        // JS built-ins
+        Math,
+        JSON,
+        Object,
+        Array,
+        String,
+        Number,
+        Boolean,
+        Symbol,
+        Date,
+        RegExp,
+        Error,
+        TypeError,
+        RangeError,
+        SyntaxError,
+        Promise,
+        Map,
+        Set,
+        WeakMap,
+        WeakSet,
+        parseInt,
+        parseFloat,
+        isNaN,
+        isFinite,
+        encodeURIComponent,
+        decodeURIComponent,
+        encodeURI,
+        decodeURI,
+        setTimeout: () => { },
+        clearTimeout: () => { },
+        setInterval: () => { },
+        clearInterval: () => { },
+        queueMicrotask: () => { },
+        globalThis: undefined, // set below
+        undefined,
+        Infinity,
+        NaN,
+    });
+}
+class ExitSignal {
+    code;
+    constructor(code) {
+        this.code = code;
+    }
+}
+function formatValue(v) {
+    if (v === null)
+        return "null";
+    if (v === undefined)
+        return "undefined";
+    if (typeof v === "string")
+        return v;
+    if (typeof v === "function")
+        return `[Function: ${v.name || "(anonymous)"}]`;
+    if (Array.isArray(v))
+        return `[ ${v.map(formatValue).join(", ")} ]`;
+    if (v instanceof Error)
+        return `${v.name}: ${v.message}`;
+    if (typeof v === "object") {
+        try {
+            const entries = Object.entries(v)
+                .map(([k, val]) => `${k}: ${formatValue(val)}`)
+                .join(", ");
+            return `{ ${entries} }`;
+        }
+        catch {
+            return "[Object]";
+        }
+    }
+    return String(v);
+}
+// ─── execution ────────────────────────────────────────────────────────────────
+function runJs(code) {
+    const outputLines = [];
+    const stderrLines = [];
+    const ctx = makeContext(outputLines, stderrLines);
+    let exitCode = 0;
+    try {
+        const result = vm.runInContext(code, ctx, { timeout: 5000 });
+        // If the expression returned a value and nothing was console.log'd, print it
+        if (result !== undefined && outputLines.length === 0) {
+            outputLines.push(formatValue(result));
+        }
+    }
+    catch (err) {
+        if (err instanceof ExitSignal) {
+            exitCode = err.code;
+        }
+        else if (err instanceof Error) {
+            stderrLines.push(`${err.name}: ${err.message}`);
+            exitCode = 1;
+        }
+        else {
+            stderrLines.push(String(err));
+            exitCode = 1;
+        }
+    }
+    return {
+        stdout: outputLines.length ? `${outputLines.join("\n")}\n` : "",
+        stderr: stderrLines.length ? `${stderrLines.join("\n")}\n` : "",
+        exitCode,
+    };
+}
+function runJsFile(code) {
+    // If the code is a single expression (no semicolons, no newlines, no statements),
+    // wrap it to capture the return value like a REPL would
+    const trimmed = code.trim();
+    const isExpression = !trimmed.includes("\n") &&
+        !trimmed.startsWith("const ") &&
+        !trimmed.startsWith("let ") &&
+        !trimmed.startsWith("var ") &&
+        !trimmed.startsWith("function ") &&
+        !trimmed.startsWith("class ") &&
+        !trimmed.startsWith("if ") &&
+        !trimmed.startsWith("for ") &&
+        !trimmed.startsWith("while ") &&
+        !trimmed.startsWith("import ") &&
+        !trimmed.startsWith("//");
+    if (isExpression)
+        return runJs(trimmed);
+    // Multi-line: wrap in IIFE
+    return runJs(`(async () => { ${code} })()`);
+}
+// ─── command ──────────────────────────────────────────────────────────────────
+/**
+ * `node` virtual runtime command. Executes JS in a safe sandbox with
+ * limited globals and no host FS/child process access.
+ * @category system
+ * @params []
+ */
+export const nodeCommand = {
+    name: "node",
+    description: "JavaScript runtime (virtual)",
+    category: "system",
+    params: ["[--version] [-e <expr>] [-p <expr>] [file]"],
+    run: ({ args, shell, cwd }) => {
+        // Require explicit installation via `apt install nodejs`
+        if (!shell.packageManager.isInstalled("nodejs")) {
+            return {
+                stderr: "bash: node: command not found\nHint: install it with: apt install nodejs\n",
+                exitCode: 127,
+            };
+        }
+        if (ifFlag(args, ["--version", "-v"])) {
+            return { stdout: `${VIRTUAL_VERSION}\n`, exitCode: 0 };
+        }
+        if (ifFlag(args, ["--versions"])) {
+            return {
+                stdout: `${JSON.stringify(VIRTUAL_VERSIONS, null, 2)}\n`,
+                exitCode: 0,
+            };
+        }
+        // -e 'expr'
+        const eIdx = args.findIndex((a) => a === "-e" || a === "--eval");
+        if (eIdx !== -1) {
+            const expr = args[eIdx + 1];
+            if (!expr)
+                return { stderr: "node: -e requires an argument\n", exitCode: 1 };
+            const { stdout, stderr, exitCode } = runJs(expr);
+            return {
+                stdout: stdout || undefined,
+                stderr: stderr || undefined,
+                exitCode,
+            };
+        }
+        // -p 'expr' — print mode
+        const pIdx = args.findIndex((a) => a === "-p" || a === "--print");
+        if (pIdx !== -1) {
+            const expr = args[pIdx + 1];
+            if (!expr)
+                return { stderr: "node: -p requires an argument\n", exitCode: 1 };
+            const { stdout, stderr, exitCode } = runJs(expr);
+            return {
+                stdout: stdout || (exitCode === 0 ? "\n" : undefined),
+                stderr: stderr || undefined,
+                exitCode,
+            };
+        }
+        // node <file>
+        const file = args.find((a) => !a.startsWith("-"));
+        if (file) {
+            const filePath = resolvePath(cwd, file);
+            if (!shell.vfs.exists(filePath)) {
+                return {
+                    stderr: `node: cannot open file '${file}': No such file or directory\n`,
+                    exitCode: 1,
+                };
+            }
+            const code = shell.vfs.readFile(filePath);
+            const { stdout, stderr, exitCode } = runJsFile(code);
+            return {
+                stdout: stdout || undefined,
+                stderr: stderr || undefined,
+                exitCode,
+            };
+        }
+        // No args — REPL hint
+        return {
+            stdout: [
+                `Welcome to Node.js ${VIRTUAL_VERSION}.`,
+                `Type ".exit" to exit the REPL.`,
+                `> `,
+            ].join("\n"),
+            exitCode: 0,
+        };
+    },
+};

package/dist/commands/npm.d.ts

@@ -0,0 +1,19 @@
+/**
+ * npm.ts — Virtual npm command.
+ * Gated behind `apt install npm`. Provides version info and informative
+ * stubs for common subcommands.
+ */
+import type { ShellModule } from "../types/commands";
+/**
+ * `npm` virtual CLI. Requires `apt install npm` in the virtual package manager.
+ * @category system
+ * @params ["<command> [args]"]
+ */
+export declare const npmCommand: ShellModule;
+/**
+ * `npx` virtual runner. Requires `apt install npm` in the virtual package manager.
+ * @category system
+ * @params ["<package> [args]"]
+ */
+export declare const npxCommand: ShellModule;
+//# sourceMappingURL=npm.d.ts.map

package/dist/commands/npm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"npm.d.ts","sourceRoot":"","sources":["../../src/commands/npm.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAMrD;;;;GAIG;AACH,eAAO,MAAM,UAAU,EAAE,WAqFxB,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,UAAU,EAAE,WAuBxB,CAAC"}

package/dist/commands/npm.js

@@ -0,0 +1,109 @@
+import { ifFlag } from "./command-helpers";
+const NPM_VERSION = "9.2.0";
+const NODE_VERSION = "18.19.0";
+/**
+ * `npm` virtual CLI. Requires `apt install npm` in the virtual package manager.
+ * @category system
+ * @params ["<command> [args]"]
+ */
+export const npmCommand = {
+    name: "npm",
+    description: "Node.js package manager (virtual)",
+    category: "system",
+    params: ["<command> [args]"],
+    run: ({ args, shell }) => {
+        // Require explicit installation
+        if (!shell.packageManager.isInstalled("npm")) {
+            return {
+                stderr: "bash: npm: command not found\nHint: install it with: apt install npm\n",
+                exitCode: 127,
+            };
+        }
+        if (ifFlag(args, ["--version", "-v"])) {
+            return { stdout: `${NPM_VERSION}\n`, exitCode: 0 };
+        }
+        const sub = args[0]?.toLowerCase();
+        switch (sub) {
+            case "version":
+            case "-version":
+                return {
+                    stdout: `{ npm: '${NPM_VERSION}', node: '${NODE_VERSION}', v8: '10.2.154.26' }\n`,
+                    exitCode: 0,
+                };
+            case "install":
+            case "i":
+            case "add":
+                return {
+                    stderr: "npm warn: package installation is not available in the virtual runtime.\nnpm warn: This environment simulates npm CLI behaviour only.\n",
+                    exitCode: 1,
+                };
+            case "run":
+            case "exec":
+            case "x":
+                return {
+                    stderr: `npm error: script execution is not available in the virtual runtime.\n`,
+                    exitCode: 1,
+                };
+            case "init":
+                return {
+                    stdout: "Wrote to /home/user/package.json\n",
+                    exitCode: 0,
+                };
+            case "list":
+            case "ls":
+                return {
+                    stdout: `${sub === "ls" || sub === "list" ? "virtual-env@1.0.0" : ""}\n└── (empty)\n`,
+                    exitCode: 0,
+                };
+            case "help":
+            case undefined:
+                return {
+                    stdout: `${[
+                        `npm ${NPM_VERSION}`,
+                        "",
+                        "Usage: npm <command>",
+                        "",
+                        "Commands:",
+                        "  install       (not available in virtual runtime)",
+                        "  run           (not available in virtual runtime)",
+                        "  exec          (not available in virtual runtime)",
+                        "  list          List installed packages",
+                        "  version       Print versions",
+                        "  --version     Print npm version",
+                    ].join("\n")}\n`,
+                    exitCode: 0,
+                };
+            default:
+                return {
+                    stderr: `npm error: unknown command: ${sub}\n`,
+                    exitCode: 1,
+                };
+        }
+    },
+};
+/**
+ * `npx` virtual runner. Requires `apt install npm` in the virtual package manager.
+ * @category system
+ * @params ["<package> [args]"]
+ */
+export const npxCommand = {
+    name: "npx",
+    description: "Node.js package runner (virtual)",
+    category: "system",
+    params: ["<package> [args]"],
+    run: ({ args, shell }) => {
+        if (!shell.packageManager.isInstalled("npm")) {
+            return {
+                stderr: "bash: npx: command not found\nHint: install it with: apt install npm\n",
+                exitCode: 127,
+            };
+        }
+        if (ifFlag(args, ["--version"])) {
+            return { stdout: `${NPM_VERSION}\n`, exitCode: 0 };
+        }
+        return {
+            stderr: `npx: package execution is not available in the virtual runtime.\n`,
+            exitCode: 1,
+        };
+    },
+};

package/dist/commands/ping.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ping.d.ts","sourceRoot":"","sources":["../../src/commands/ping.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGrD,eAAO,MAAM,WAAW,EAAE,WAmBzB,CAAC"}
+{"version":3,"file":"ping.d.ts","sourceRoot":"","sources":["../../src/commands/ping.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGrD,eAAO,MAAM,WAAW,EAAE,WAuBzB,CAAC"}

package/dist/commands/ping.js

@@ -5,7 +5,9 @@ export const pingCommand = {
     category: "network",
     params: ["[-c <count>] <host>"],
     run: ({ args }) => {
-        const { flagsWithValues, positionals } = parseArgs(args, { flagsWithValue: ["-c", "-i", "-W"] });
+        const { flagsWithValues, positionals } = parseArgs(args, {
+            flagsWithValue: ["-c", "-i", "-W"],
+        });
         const host = positionals[0] ?? "localhost";
         const countArg = flagsWithValues.get("-c");
         const count = countArg ? Math.max(1, parseInt(countArg, 10) || 4) : 4;

package/dist/commands/printf.d.ts

@@ -0,0 +1,3 @@
+import type { ShellModule } from "../types/commands";
+export declare const printfCommand: ShellModule;
+//# sourceMappingURL=printf.d.ts.map

package/dist/commands/printf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"printf.d.ts","sourceRoot":"","sources":["../../src/commands/printf.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAoGrD,eAAO,MAAM,aAAa,EAAE,WAW3B,CAAC"}

package/dist/commands/printf.js

@@ -0,0 +1,113 @@
+/**
+ * Render a printf format string with given arguments.
+ * Supports: %s %d %i %f %o %x %X %% \n \t \r \\
+ */
+function renderPrintf(fmt, args) {
+    let argIdx = 0;
+    let out = "";
+    let i = 0;
+    while (i < fmt.length) {
+        if (fmt[i] === "\\" && i + 1 < fmt.length) {
+            switch (fmt[i + 1]) {
+                case "n":
+                    out += "\n";
+                    i += 2;
+                    continue;
+                case "t":
+                    out += "\t";
+                    i += 2;
+                    continue;
+                case "r":
+                    out += "\r";
+                    i += 2;
+                    continue;
+                case "\\":
+                    out += "\\";
+                    i += 2;
+                    continue;
+                case "a":
+                    out += "\x07";
+                    i += 2;
+                    continue;
+                case "b":
+                    out += "\x08";
+                    i += 2;
+                    continue;
+                case "f":
+                    out += "\x0C";
+                    i += 2;
+                    continue;
+                case "v":
+                    out += "\x0B";
+                    i += 2;
+                    continue;
+                default:
+                    out += fmt[i];
+                    i++;
+                    continue;
+            }
+        }
+        if (fmt[i] === "%" && i + 1 < fmt.length) {
+            // Optional width/precision: %[-][width][.prec]spec
+            let j = i + 1;
+            if (fmt[j] === "-")
+                j++;
+            while (j < fmt.length && /\d/.test(fmt[j]))
+                j++;
+            if (fmt[j] === ".") {
+                j++;
+                while (j < fmt.length && /\d/.test(fmt[j]))
+                    j++;
+            }
+            const spec = fmt[j];
+            const arg = args[argIdx++] ?? "";
+            switch (spec) {
+                case "s":
+                    out += arg;
+                    break;
+                case "d":
+                case "i":
+                    out += String(parseInt(arg, 10) || 0);
+                    break;
+                case "f":
+                    out += String(parseFloat(arg) || 0);
+                    break;
+                case "o":
+                    out += (parseInt(arg, 10) || 0).toString(8);
+                    break;
+                case "x":
+                    out += (parseInt(arg, 10) || 0).toString(16);
+                    break;
+                case "X":
+                    out += (parseInt(arg, 10) || 0).toString(16).toUpperCase();
+                    break;
+                case "%":
+                    out += "%";
+                    argIdx--;
+                    break;
+                default:
+                    out += fmt[i];
+                    i++;
+                    continue;
+            }
+            i = j + 1;
+            continue;
+        }
+        out += fmt[i];
+        i++;
+    }
+    return out;
+}
+export const printfCommand = {
+    name: "printf",
+    description: "Format and print data",
+    category: "shell",
+    params: ["<format> [args...]"],
+    run: ({ args }) => {
+        const fmt = args[0];
+        if (!fmt)
+            return { stderr: "printf: missing format string", exitCode: 1 };
+        const output = renderPrintf(fmt, args.slice(1));
+        return { stdout: output, exitCode: 0 };
+    },
+};

package/dist/commands/ps.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ps.d.ts","sourceRoot":"","sources":["../../src/commands/ps.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGrD,eAAO,MAAM,SAAS,EAAE,WAqCvB,CAAC"}
+{"version":3,"file":"ps.d.ts","sourceRoot":"","sources":["../../src/commands/ps.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGrD,eAAO,MAAM,SAAS,EAAE,WAiDvB,CAAC"}

package/dist/commands/ps.js

@@ -6,7 +6,10 @@ export const psCommand = {
     params: ["[-a] [-u] [-x] [aux]"],
     run: ({ authUser, shell, args }) => {
         const sessions = shell.users.listActiveSessions();
-        const showUser = ifFlag(args, ["-u"]) || args.includes("u") || args.includes("aux") || args.includes("au");
+        const showUser = ifFlag(args, ["-u"]) ||
+            args.includes("u") ||
+            args.includes("aux") ||
+            args.includes("au");
         const showAll = ifFlag(args, ["-a", "-x"]) || args.includes("a") || args.includes("aux");
         if (showUser) {
             const header = "USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND";

package/dist/commands/python.d.ts

@@ -0,0 +1,30 @@
+/** biome-ignore-all lint/suspicious/useIterableCallbackReturn: intentional side-effect forEach */
+/**
+ * python.ts — Virtual Python 3 interpreter.
+ *
+ * Implements a genuine mini-interpreter capable of:
+ *   - print(), len(), type(), range(), list(), str(), int(), float(), bool()
+ *   - max(), min(), abs(), sum(), sorted(), reversed(), enumerate(), zip()
+ *   - str methods: upper(), lower(), strip(), split(), join(), replace(),
+ *                  startswith(), endswith(), format(), count(), find()
+ *   - list methods: append(), extend(), pop(), sort(), reverse(), index()
+ *   - dict: keys(), values(), items(), get()
+ *   - import os, sys, math, json, re (stubs)
+ *   - f-strings, multi-line scripts, assignments, for/while loops, if/elif/else
+ *   - functions (def), return, class basics
+ */
+import type { ShellModule } from "../types/commands";
+declare global {
+    interface Map<K, V> {
+        also?: ((fn: (m: Map<K, V>) => void) => Map<K, V>) | undefined;
+    }
+}
+/**
+ * Virtual Python 3 interpreter command. Implements a small Python subset
+ * for scripts and `-c` invocations. Requires `apt install python3` in the
+ * virtual package manager to be available.
+ * @category system
+ * @params ["[--version] [-c <code>] [-V] [file]"]
+ */
+export declare const python3Command: ShellModule;
+//# sourceMappingURL=python.d.ts.map

package/dist/commands/python.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"python.d.ts","sourceRoot":"","sources":["../../src/commands/python.ts"],"names":[],"mappings":"AAAA,kGAAkG;AAClG;;;;;;;;;;;;;GAaG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAqlErD,OAAO,CAAC,MAAM,CAAC;IACd,UAAU,GAAG,CAAC,CAAC,EAAE,CAAC;QACjB,IAAI,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,IAAI,KAAK,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;KAC/D;CACD;AAID;;;;;;GAMG;AACH,eAAO,MAAM,cAAc,EAAE,WAiE5B,CAAC"}