typescript-virtual-container 1.4.4 → 1.4.6

package/src/commands/node.js

@@ -1,316 +0,0 @@
-/** 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/src/commands/npm.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"npm.d.ts","sourceRoot":"","sources":["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/src/commands/npm.js

@@ -1,109 +0,0 @@
-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/src/commands/passwd.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"passwd.d.ts","sourceRoot":"","sources":["passwd.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD;;;;;;;GAOG;AACH,eAAO,MAAM,aAAa,EAAE,WAuC3B,CAAC"}

package/src/commands/passwd.js

@@ -1,44 +0,0 @@
-/**
- * `passwd [username]` — change a virtual user's password.
- *
- * - Root can change any user's password.
- * - Non-root can only change their own password.
- * - Interactive: emits `passwordChallenge` for hidden-input prompting.
- * - Non-interactive: reads new password from stdin first line.
- */
-export const passwdCommand = {
-    name: "passwd",
-    description: "Change user password",
-    category: "users",
-    params: ["[username]"],
-    run: async ({ authUser, args, shell, stdin }) => {
-        const targetUser = args[0] ?? authUser;
-        // Permission check
-        if (authUser !== "root" && authUser !== targetUser) {
-            return { stderr: "passwd: permission denied", exitCode: 1 };
-        }
-        // Target must exist
-        if (!shell.users.listUsers().includes(targetUser)) {
-            return { stderr: `passwd: user '${targetUser}' does not exist`, exitCode: 1 };
-        }
-        // Non-interactive: read new password from stdin
-        if (stdin !== undefined && stdin.trim().length > 0) {
-            const password = stdin.trim().split("\n")[0];
-            await shell.users.setPassword(targetUser, password);
-            return {
-                stdout: `passwd: password updated successfully\n`,
-                exitCode: 0,
-            };
-        }
-        // Interactive: emit password challenge
-        return {
-            passwordChallenge: {
-                prompt: "New password: ",
-                confirmPrompt: "Retype new password: ",
-                action: "passwd",
-                targetUsername: targetUser,
-            },
-            exitCode: 0,
-        };
-    },
-};

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

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

package/src/commands/ping.js

@@ -1,28 +0,0 @@
-import { parseArgs } from "./command-helpers";
-/**
- * Send ICMP ECHO_REQUEST packets (mock implementation).
- * @category network
- * @params ["[-c <count>] <host>"]
- */
-export const pingCommand = {
-    name: "ping",
-    description: "Send ICMP ECHO_REQUEST (mock)",
-    category: "network",
-    params: ["[-c <count>] <host>"],
-    run: ({ args }) => {
-        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;
-        const lines = [`PING ${host}: 56 data bytes`];
-        for (let i = 0; i < count; i++) {
-            const ms = (Math.random() * 10 + 1).toFixed(3);
-            lines.push(`64 bytes from ${host}: icmp_seq=${i} ttl=64 time=${ms} ms`);
-        }
-        lines.push(`--- ${host} ping statistics ---`);
-        lines.push(`${count} packets transmitted, ${count} received, 0% packet loss`);
-        return { stdout: lines.join("\n"), exitCode: 0 };
-    },
-};

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

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

package/src/commands/printf.js

@@ -1,144 +0,0 @@
-/**
- * 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) {
-            let j = i + 1;
-            let leftAlign = false;
-            if (fmt[j] === "-") {
-                leftAlign = true;
-                j++;
-            }
-            let zeroPad = false;
-            if (fmt[j] === "0") {
-                zeroPad = true;
-                j++;
-            }
-            let width = 0;
-            while (j < fmt.length && /\d/.test(fmt[j])) {
-                width = width * 10 + parseInt(fmt[j], 10);
-                j++;
-            }
-            let precision = -1;
-            if (fmt[j] === ".") {
-                j++;
-                precision = 0;
-                while (j < fmt.length && /\d/.test(fmt[j])) {
-                    precision = precision * 10 + parseInt(fmt[j], 10);
-                    j++;
-                }
-            }
-            const spec = fmt[j];
-            const arg = args[argIdx++] ?? "";
-            const pad = (s, ch = " ") => {
-                if (width <= 0 || s.length >= width)
-                    return s;
-                const fill = ch.repeat(width - s.length);
-                return leftAlign ? s + fill : fill + s;
-            };
-            switch (spec) {
-                case "s": {
-                    let val = String(arg);
-                    if (precision >= 0)
-                        val = val.slice(0, precision);
-                    out += pad(val);
-                    break;
-                }
-                case "d":
-                case "i":
-                    out += pad(String(parseInt(arg, 10) || 0), zeroPad ? "0" : " ");
-                    break;
-                case "f": {
-                    const prec = precision >= 0 ? precision : 6;
-                    out += pad((parseFloat(arg) || 0).toFixed(prec));
-                    break;
-                }
-                case "o":
-                    out += pad((parseInt(arg, 10) || 0).toString(8), zeroPad ? "0" : " ");
-                    break;
-                case "x":
-                    out += pad((parseInt(arg, 10) || 0).toString(16), zeroPad ? "0" : " ");
-                    break;
-                case "X":
-                    out += pad((parseInt(arg, 10) || 0).toString(16).toUpperCase(), zeroPad ? "0" : " ");
-                    break;
-                case "%":
-                    out += "%";
-                    argIdx--;
-                    break;
-                default:
-                    out += fmt[i];
-                    i++;
-                    continue;
-            }
-            i = j + 1;
-            continue;
-        }
-        out += fmt[i];
-        i++;
-    }
-    return out;
-}
-/**
- * Format and print data to stdout.
- * @category shell
- * @params ["<format> [args...]"]
- */
-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/src/commands/ps.d.ts.map

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