typescript-virtual-container 1.5.5 → 1.5.7

package/dist/commands/bzip2.js

@@ -0,0 +1,91 @@
+import { gunzipSync, gzipSync } from "fflate";
+import { resolvePath } from "./helpers";
+// BZ2 magic bytes: "BZh" — we store gzip data after this marker so our tools
+// can round-trip. Real bzip2 files won't be decompressable this way, but files
+// created and extracted within this VM will work correctly.
+const BZ2_MAGIC = Buffer.from("BZhVFS\0");
+function vfsBzip2(data) {
+    const gz = Buffer.from(gzipSync(data));
+    return Buffer.concat([BZ2_MAGIC, gz]);
+}
+function vfsBunzip2(data) {
+    if (!data.subarray(0, BZ2_MAGIC.length).equals(BZ2_MAGIC))
+        return null;
+    try {
+        return Buffer.from(gunzipSync(data.subarray(BZ2_MAGIC.length)));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Compress files using bzip2 (VFS-internal gzip with BZ2 marker — round-trips within VM).
+ * @category archive
+ */
+export const bzip2Command = {
+    name: "bzip2",
+    description: "Compress files using Burrows-Wheeler algorithm",
+    category: "archive",
+    params: ["[-k] [-d] <file>"],
+    run: ({ authUser, shell, cwd, args }) => {
+        const keepOrig = args.includes("-k") || args.includes("--keep");
+        const decompress = args.includes("-d") || args.includes("--decompress");
+        const file = args.find((a) => !a.startsWith("-"));
+        if (!file)
+            return { stderr: "bzip2: no file specified", exitCode: 1 };
+        const p = resolvePath(cwd, file);
+        if (!shell.vfs.exists(p))
+            return { stderr: `bzip2: ${file}: No such file or directory`, exitCode: 1 };
+        if (decompress) {
+            if (!file.endsWith(".bz2"))
+                return { stderr: `bzip2: ${file}: unknown suffix -- ignored`, exitCode: 1 };
+            const raw = shell.vfs.readFileRaw(p);
+            const result = vfsBunzip2(raw);
+            if (!result)
+                return { stderr: `bzip2: ${file}: data integrity error`, exitCode: 2 };
+            const dest = p.slice(0, -4);
+            shell.writeFileAsUser(authUser, dest, result);
+            if (!keepOrig)
+                shell.vfs.remove(p);
+            return { exitCode: 0 };
+        }
+        if (file.endsWith(".bz2"))
+            return { stderr: `bzip2: ${file}: already has .bz2 suffix -- unchanged`, exitCode: 1 };
+        const raw = shell.vfs.readFileRaw(p);
+        shell.vfs.writeFile(`${p}.bz2`, vfsBzip2(raw));
+        if (!keepOrig)
+            shell.vfs.remove(p);
+        return { exitCode: 0 };
+    },
+};
+/**
+ * Decompress bzip2 files (VFS-internal format).
+ * @category archive
+ */
+export const bunzip2Command = {
+    name: "bunzip2",
+    description: "Decompress bzip2 files",
+    category: "archive",
+    aliases: ["bzcat"],
+    params: ["[-k] <file>"],
+    run: ({ authUser, shell, cwd, args }) => {
+        const keepOrig = args.includes("-k") || args.includes("--keep");
+        const file = args.find((a) => !a.startsWith("-"));
+        if (!file)
+            return { stderr: "bunzip2: no file specified", exitCode: 1 };
+        const p = resolvePath(cwd, file);
+        if (!shell.vfs.exists(p))
+            return { stderr: `bunzip2: ${file}: No such file or directory`, exitCode: 1 };
+        if (!file.endsWith(".bz2"))
+            return { stderr: `bunzip2: ${file}: unknown suffix -- ignored`, exitCode: 1 };
+        const raw = shell.vfs.readFileRaw(p);
+        const result = vfsBunzip2(raw);
+        if (!result)
+            return { stderr: `bunzip2: ${file}: data integrity error`, exitCode: 2 };
+        const dest = p.slice(0, -4);
+        shell.writeFileAsUser(authUser, dest, result);
+        if (!keepOrig)
+            shell.vfs.remove(p);
+        return { exitCode: 0 };
+    },
+};

package/dist/commands/exit.js

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

package/dist/commands/find.d.ts

@@ -1,7 +1,7 @@
 import type { ShellModule } from "../types/commands";
 /**
- * Find files and directories by name and type with minimal pattern support.
+ * Find files and directories with filtering, -exec, -maxdepth, -not, -o, -a.
  * @category files
- * @params ["[path] [-name <pattern>] [-type f|d]"]
+ * @params ["[path] [expression...]"]
  */
 export declare const findCommand: ShellModule;

package/dist/commands/find.js

@@ -1,55 +1,227 @@
-import { getFlag } from "./command-helpers";
+import { globToRegex } from "../utils/glob";
 import { assertPathAccess, resolvePath } from "./helpers";
+import { runCommand } from "./runtime";
 /**
- * Find files and directories by name and type with minimal pattern support.
+ * Find files and directories with filtering, -exec, -maxdepth, -not, -o, -a.
  * @category files
- * @params ["[path] [-name <pattern>] [-type f|d]"]
+ * @params ["[path] [expression...]"]
  */
 export const findCommand = {
     name: "find",
     description: "Search for files",
     category: "files",
-    params: ["[path] [-name <pattern>] [-type f|d]"],
-    run: ({ authUser, shell, cwd, args }) => {
-        const namePattern = getFlag(args, ["-name"]);
-        const typeFilter = getFlag(args, ["-type"]);
-        const positionals = args.filter((a) => !a.startsWith("-") && a !== namePattern && a !== typeFilter);
-        const rootArg = positionals[0] ?? ".";
-        const rootPath = resolvePath(cwd, rootArg);
-        try {
-            assertPathAccess(authUser, rootPath, "find");
-            if (!shell.vfs.exists(rootPath)) {
-                return {
-                    stderr: `find: ${rootArg}: No such file or directory`,
-                    exitCode: 1,
-                };
+    params: ["[path] [expression...]"],
+    run: async ({ authUser, shell, cwd, args, env, hostname, mode }) => {
+        // Collect root paths (positional args before first - option)
+        const roots = [];
+        let i = 0;
+        while (i < args.length && !args[i].startsWith("-") && args[i] !== "!" && args[i] !== "(") {
+            roots.push(args[i]);
+            i++;
+        }
+        if (roots.length === 0)
+            roots.push(".");
+        const exprArgs = args.slice(i);
+        let maxDepth = Infinity;
+        let minDepth = 0;
+        const execCmds = [];
+        function parseExpr(tokens, pos) {
+            return parseOr(tokens, pos);
+        }
+        function parseOr(tokens, pos) {
+            let [left, p] = parseAnd(tokens, pos);
+            while (tokens[p] === "-o" || tokens[p] === "-or") {
+                p++;
+                const [right, np] = parseAnd(tokens, p);
+                left = { type: "or", left, right };
+                p = np;
+            }
+            return [left, p];
+        }
+        function parseAnd(tokens, pos) {
+            let [left, p] = parseNot(tokens, pos);
+            while (p < tokens.length && tokens[p] !== "-o" && tokens[p] !== "-or" && tokens[p] !== ")") {
+                if (tokens[p] === "-a" || tokens[p] === "-and")
+                    p++;
+                if (p >= tokens.length || tokens[p] === "-o" || tokens[p] === ")")
+                    break;
+                const [right, np] = parseNot(tokens, p);
+                left = { type: "and", left, right };
+                p = np;
+            }
+            return [left, p];
+        }
+        function parseNot(tokens, pos) {
+            if (tokens[pos] === "!" || tokens[pos] === "-not") {
+                const [pred, np] = parsePrimary(tokens, pos + 1);
+                return [{ type: "not", pred }, np];
+            }
+            return parsePrimary(tokens, pos);
+        }
+        function parsePrimary(tokens, pos) {
+            const tok = tokens[pos];
+            if (!tok)
+                return [{ type: "true" }, pos];
+            if (tok === "(") {
+                const [pred, np] = parseExpr(tokens, pos + 1);
+                const closePos = tokens[np] === ")" ? np + 1 : np;
+                return [pred, closePos];
+            }
+            if (tok === "-name")
+                return [{ type: "name", pat: tokens[pos + 1] ?? "*", ignoreCase: false }, pos + 2];
+            if (tok === "-iname")
+                return [{ type: "name", pat: tokens[pos + 1] ?? "*", ignoreCase: true }, pos + 2];
+            if (tok === "-type")
+                return [{ type: "type", t: tokens[pos + 1] ?? "f" }, pos + 2];
+            if (tok === "-maxdepth") {
+                maxDepth = parseInt(tokens[pos + 1] ?? "0", 10);
+                return [{ type: "true" }, pos + 2];
+            }
+            if (tok === "-mindepth") {
+                minDepth = parseInt(tokens[pos + 1] ?? "0", 10);
+                return [{ type: "true" }, pos + 2];
+            }
+            if (tok === "-empty")
+                return [{ type: "empty" }, pos + 1];
+            if (tok === "-print" || tok === "-print0")
+                return [{ type: "print" }, pos + 1];
+            if (tok === "-true")
+                return [{ type: "true" }, pos + 1];
+            if (tok === "-false")
+                return [{ type: "false" }, pos + 1];
+            if (tok === "-size") {
+                const raw = tokens[pos + 1] ?? "0";
+                const unit = raw.slice(-1);
+                const n = parseInt(raw, 10);
+                return [{ type: "size", n, unit }, pos + 2];
             }
+            if (tok === "-exec" || tok === "-execdir") {
+                const useDir = tok === "-execdir";
+                const cmd = [];
+                let j = pos + 1;
+                while (j < tokens.length && tokens[j] !== ";") {
+                    cmd.push(tokens[j]);
+                    j++;
+                }
+                execCmds.push({ cmd, useDir });
+                return [{ type: "exec", cmd, useDir }, j + 1];
+            }
+            // Unknown predicate — skip
+            return [{ type: "true" }, pos + 1];
         }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            return { stderr: `find: ${msg}`, exitCode: 1 };
+        const pred = exprArgs.length > 0 ? parseExpr(exprArgs, 0)[0] : { type: "true" };
+        function matchPred(p, fullPath, depth) {
+            switch (p.type) {
+                case "true": return true;
+                case "false": return false;
+                case "not": return !matchPred(p.pred, fullPath, depth);
+                case "and": return matchPred(p.left, fullPath, depth) && matchPred(p.right, fullPath, depth);
+                case "or": return matchPred(p.left, fullPath, depth) || matchPred(p.right, fullPath, depth);
+                case "name": {
+                    const base = fullPath.split("/").pop() ?? "";
+                    return globToRegex(p.pat, p.ignoreCase ? "i" : "").test(base);
+                }
+                case "type": {
+                    try {
+                        const st = shell.vfs.stat(fullPath);
+                        if (p.t === "f")
+                            return st.type === "file";
+                        if (p.t === "d")
+                            return st.type === "directory";
+                        if (p.t === "l")
+                            return false; // VFS has no symlink type
+                    }
+                    catch {
+                        return false;
+                    }
+                    return false;
+                }
+                case "empty": {
+                    try {
+                        const st = shell.vfs.stat(fullPath);
+                        if (st.type === "directory")
+                            return shell.vfs.list(fullPath).length === 0;
+                        return shell.vfs.readFile(fullPath).length === 0;
+                    }
+                    catch {
+                        return false;
+                    }
+                }
+                case "size": {
+                    try {
+                        const content = shell.vfs.readFile(fullPath);
+                        const bytes = content.length;
+                        const unit = p.unit;
+                        let fileSize = bytes;
+                        if (unit === "k" || unit === "K")
+                            fileSize = Math.ceil(bytes / 1024);
+                        else if (unit === "M")
+                            fileSize = Math.ceil(bytes / (1024 * 1024));
+                        else if (unit === "c")
+                            fileSize = bytes;
+                        return fileSize === p.n;
+                    }
+                    catch {
+                        return false;
+                    }
+                }
+                case "print": return true;
+                case "exec": return true; // handled separately
+                default: return true;
+            }
         }
-        const nameRegex = namePattern
-            ? new RegExp(`^${namePattern.replace(/\./g, "\\.").replace(/\*/g, ".*").replace(/\?/g, ".")}$`)
-            : null;
         const results = [];
-        const walk = (currentPath, display) => {
-            const stat = shell.vfs.stat(currentPath);
-            const matchesType = !typeFilter ||
-                (typeFilter === "f" && stat.type === "file") ||
-                (typeFilter === "d" && stat.type === "directory");
-            const matchesName = !nameRegex || nameRegex.test(currentPath.split("/").pop() ?? "");
-            if (matchesType && matchesName)
+        function walk(currentPath, display, depth) {
+            if (depth > maxDepth)
+                return;
+            try {
+                assertPathAccess(authUser, currentPath, "find");
+            }
+            catch {
+                return;
+            }
+            if (depth >= minDepth && matchPred(pred, currentPath, depth)) {
                 results.push(display);
-            if (stat.type === "directory") {
+            }
+            let stat;
+            try {
+                stat = shell.vfs.stat(currentPath);
+            }
+            catch {
+                return;
+            }
+            if (stat.type === "directory" && depth < maxDepth) {
                 for (const entry of shell.vfs.list(currentPath)) {
-                    const full = `${currentPath}/${entry}`;
-                    const disp = `${display}/${entry}`;
-                    walk(full, disp);
+                    walk(`${currentPath}/${entry}`, `${display}/${entry}`, depth + 1);
                 }
             }
-        };
-        walk(rootPath, rootArg);
-        return { stdout: results.join("\n"), exitCode: 0 };
+        }
+        for (const root of roots) {
+            const rootPath = resolvePath(cwd, root);
+            if (!shell.vfs.exists(rootPath)) {
+                return { stderr: `find: '${root}': No such file or directory`, exitCode: 1 };
+            }
+            walk(rootPath, root === "." ? "." : root, 0);
+        }
+        // Execute -exec commands
+        if (execCmds.length > 0 && results.length > 0) {
+            const execOutputs = [];
+            for (const { cmd } of execCmds) {
+                for (const filePath of results) {
+                    const expanded = cmd.map((t) => t === "{}" ? filePath : t);
+                    const cmdStr = expanded.map((t) => (t.includes(" ") ? `"${t}"` : t)).join(" ");
+                    const r = await runCommand(cmdStr, authUser, hostname, mode, cwd, shell, undefined, env);
+                    if (r.stdout)
+                        execOutputs.push(r.stdout.replace(/\n$/, ""));
+                    if (r.stderr)
+                        execOutputs.push(r.stderr.replace(/\n$/, ""));
+                }
+            }
+            if (execOutputs.length > 0) {
+                return { stdout: `${execOutputs.join("\n")}\n`, exitCode: 0 };
+            }
+            return { exitCode: 0 };
+        }
+        return { stdout: results.join("\n") + (results.length > 0 ? "\n" : ""), exitCode: 0 };
     },
 };

package/dist/commands/helpers.d.ts

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

package/dist/commands/helpers.js

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

package/dist/commands/lsof.d.ts

@@ -0,0 +1,6 @@
+import type { ShellModule } from "../types/commands";
+/**
+ * List open files (stub — returns simulated process file descriptors).
+ * @category system
+ */
+export declare const lsofCommand: ShellModule;

package/dist/commands/lsof.js

@@ -0,0 +1,30 @@
+/**
+ * List open files (stub — returns simulated process file descriptors).
+ * @category system
+ */
+export const lsofCommand = {
+    name: "lsof",
+    description: "List open files",
+    category: "system",
+    params: ["[-p <pid>] [-u <user>] [-i [addr]]"],
+    run: ({ authUser, args }) => {
+        const iNet = args.includes("-i");
+        if (iNet) {
+            const header = "COMMAND    PID     USER   FD   TYPE DEVICE SIZE/OFF NODE NAME";
+            const rows = [
+                `sshd       1234     root    3u  IPv4  12345      0t0  TCP *:22 (LISTEN)`,
+                `nginx       567     root    6u  IPv4  23456      0t0  TCP *:80 (LISTEN)`,
+            ];
+            return { stdout: `${header}\n${rows.join("\n")}`, exitCode: 0 };
+        }
+        const header = "COMMAND    PID     USER   FD   TYPE DEVICE SIZE/OFF NODE NAME";
+        const rows = [
+            `bash      1001 ${authUser}  cwd    DIR    8,1     4096    2 /home/${authUser}`,
+            `bash      1001 ${authUser}  txt    REG    8,1  1183448   23 /bin/bash`,
+            `bash      1001 ${authUser}    0u   CHR  136,0      0t0    3 /dev/pts/0`,
+            `bash      1001 ${authUser}    1u   CHR  136,0      0t0    3 /dev/pts/0`,
+            `bash      1001 ${authUser}    2u   CHR  136,0      0t0    3 /dev/pts/0`,
+        ];
+        return { stdout: `${header}\n${rows.join("\n")}`, exitCode: 0 };
+    },
+};

package/dist/commands/perl.d.ts

@@ -0,0 +1,6 @@
+import type { ShellModule } from "../types/commands";
+/**
+ * Perl interpreter stub — supports -e one-liners with print, say, basic regex, and -p/-n/-i.
+ * @category scripting
+ */
+export declare const perlCommand: ShellModule;

package/dist/commands/perl.js

@@ -0,0 +1,76 @@
+/**
+ * Perl interpreter stub — supports -e one-liners with print, say, basic regex, and -p/-n/-i.
+ * @category scripting
+ */
+export const perlCommand = {
+    name: "perl",
+    description: "Practical Extraction and Report Language",
+    category: "scripting",
+    params: ["[-e <expr>] [-p] [-n] [-i] [file]"],
+    run: ({ args, stdin }) => {
+        const eIdx = args.indexOf("-e");
+        const code = eIdx !== -1 ? args[eIdx + 1] : undefined;
+        const printLoop = args.includes("-p");
+        const noAutoprint = args.includes("-n");
+        const hasLoop = printLoop || noAutoprint;
+        if (!code) {
+            return { stderr: "perl: no code specified (only -e one-liners supported)", exitCode: 1 };
+        }
+        const input = stdin ?? "";
+        const lines = input.split("\n");
+        if (lines[lines.length - 1] === "")
+            lines.pop();
+        const out = [];
+        if (hasLoop) {
+            for (let li = 0; li < lines.length; li++) {
+                let line = lines[li];
+                // $_ = line, $. = line number
+                const processed = code
+                    .replace(/\$_/g, JSON.stringify(line))
+                    .replace(/\$\./g, String(li + 1));
+                // s/pat/rep/[g] substitution on $_
+                const sMatch = processed.match(/^s([^a-zA-Z0-9])(.*?)\1(.*?)\1([gi]*)$/);
+                if (sMatch) {
+                    const flags = sMatch[4] ?? "";
+                    try {
+                        const re = new RegExp(sMatch[2], flags.includes("i") ? (flags.includes("g") ? "gi" : "i") : flags.includes("g") ? "g" : "");
+                        line = line.replace(re, sMatch[3]);
+                    }
+                    catch { /* ignore */ }
+                    if (printLoop)
+                        out.push(line);
+                    continue;
+                }
+                // print / say
+                const printM = processed.match(/^(?:print|say)\s+(?:STDOUT\s+)?(?:"([^"]*)"|'([^']*)'|(.+))(?:\s*;)?$/);
+                if (printM) {
+                    const val = (printM[1] ?? printM[2] ?? printM[3] ?? "")
+                        .replace(/\\n/g, "\n").replace(/\\t/g, "\t");
+                    out.push(code.startsWith("say") ? val : val.replace(/\n$/, ""));
+                    if (printLoop)
+                        out.push(line);
+                    continue;
+                }
+                if (printLoop)
+                    out.push(line);
+            }
+        }
+        else {
+            // Single expression
+            const printM = code.match(/^(?:print|say)\s+(?:STDOUT\s+)?(?:"([^"]*)"|'([^']*)'|(.*))(?:\s*;)?$/);
+            if (printM) {
+                const val = (printM[1] ?? printM[2] ?? printM[3] ?? "")
+                    .replace(/\\n/g, "\n").replace(/\\t/g, "\t");
+                out.push(val);
+            }
+            else {
+                // Version string
+                if (code.trim() === 'print $]' || code.includes("version")) {
+                    out.push("5.036001");
+                }
+            }
+        }
+        const result = out.join("\n");
+        return { stdout: result + (result && !result.endsWith("\n") ? "\n" : ""), exitCode: 0 };
+    },
+};

package/dist/commands/python.js

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