typescript-virtual-container 1.5.2 → 1.5.4

package/dist/commands/registry.js

@@ -3,6 +3,7 @@ import { aliasCommand, unaliasCommand } from "./alias";
 import { aptCacheCommand, aptCommand } from "./apt";
 import { awkCommand } from "./awk";
 import { base64Command } from "./base64";
+import { basenameCommand, dirnameCommand } from "./basename";
 import { catCommand } from "./cat";
 import { cdCommand } from "./cd";
 import { chmodCommand } from "./chmod";
@@ -21,8 +22,10 @@ import { echoCommand } from "./echo";
 import { envCommand } from "./env";
 import { exitCommand } from "./exit";
 import { exportCommand } from "./export";
+import { fileCommand } from "./file";
 import { findCommand } from "./find";
 import { freeCommand } from "./free";
+import { cmatrixCommand, cowsayCommand, cowthinkCommand, fortuneCommand, slCommand, yesCommand } from "./fun";
 import { grepCommand } from "./grep";
 import { groupsCommand } from "./groups";
 import { gunzipCommand, gzipCommand } from "./gzip";
@@ -32,10 +35,10 @@ import { historyCommand } from "./history";
 import { hostnameCommand } from "./hostname";
 import { htopCommand } from "./htop";
 import { idCommand } from "./id";
+import { ifconfigCommand } from "./ifconfig";
 import { killCommand } from "./kill";
+import { dmesgCommand, lastCommand } from "./last";
 import { lnCommand, readlinkCommand } from "./ln";
-import { seqCommand } from "./seq";
-import { statCommand } from "./stat";
 import { lsCommand } from "./ls";
 import { lsbReleaseCommand } from "./lsb-release";
 import { manCommand } from "./man";
@@ -54,12 +57,14 @@ import { python3Command } from "./python";
 import { readCommand } from "./read";
 import { rmCommand } from "./rm";
 import { sedCommand } from "./sed";
+import { seqCommand } from "./seq";
 import { setCommand } from "./set";
 import { shCommand } from "./sh";
 import { returnCommand, shiftCommand, trapCommand } from "./shift";
 import { sleepCommand } from "./sleep";
 import { sortCommand } from "./sort";
 import { sourceCommand } from "./source";
+import { statCommand } from "./stat";
 import { suCommand } from "./su";
 import { sudoCommand } from "./sudo";
 import { tailCommand } from "./tail";
@@ -67,6 +72,7 @@ import { tarCommand } from "./tar";
 import { teeCommand } from "./tee";
 import { testCommand } from "./test";
 import { touchCommand } from "./touch";
+import { sttyCommand, tputCommand } from "./tput";
 import { trCommand } from "./tr";
 import { treeCommand } from "./tree";
 import { falseCommand, trueCommand } from "./true";
@@ -81,6 +87,7 @@ import { whichCommand } from "./which";
 import { whoCommand } from "./who";
 import { whoamiCommand } from "./whoami";
 import { xargsCommand } from "./xargs";
+import { wCommand } from "./w";
 const BASE_COMMANDS = [
     // Navigation
     pwdCommand,
@@ -144,6 +151,21 @@ const BASE_COMMANDS = [
     exitCommand,
     // Editors
     nanoCommand,
+    wCommand,
+    basenameCommand,
+    dirnameCommand,
+    fileCommand,
+    tputCommand,
+    sttyCommand,
+    lastCommand,
+    dmesgCommand,
+    ifconfigCommand,
+    yesCommand,
+    fortuneCommand,
+    cowsayCommand,
+    cowthinkCommand,
+    cmatrixCommand,
+    slCommand,
     htopCommand,
     // Network
     curlCommand,

package/dist/commands/runtime.js

@@ -1,7 +1,7 @@
 /** biome-ignore-all lint/style/useNamingConvention: ENV VARIABLES */
 import { executeStatements } from "../SSHMimic/executor";
 import { parseScript } from "../VirtualShell/shellParser";
-import { expandAsync, expandBraces } from "../utils/expand";
+import { expandAsync, expandBraces, expandGlob } from "../utils/expand";
 import { tokenizeCommand } from "../utils/tokenize";
 import { resolveModule } from "./registry";
 /** Returns the home directory path for a given user. Root lives at /root. */
@@ -61,7 +61,25 @@ function resolveVfsBinary(name, env, shell, authUser) {
     }
     return null;
 }
+const MAX_CALL_DEPTH = 8;
+let _callDepth = 0;
 export async function runCommandDirect(name, args, authUser, hostname, mode, cwd, shell, stdin, env) {
+    // Anti-loop guard: track call depth via env to avoid infinite recursion
+    _callDepth++;
+    // console.debug(`[depth=${_callDepth}] runCommandDirect: ${name}`);
+    if (_callDepth > MAX_CALL_DEPTH) {
+        _callDepth--;
+        // console.debug(`[LOOP DETECTED] runCommandDirect blocked: ${name}`);
+        return { stderr: `${name}: maximum call depth (${MAX_CALL_DEPTH}) exceeded`, exitCode: 126 };
+    }
+    try {
+        return await _runCommandDirectInner(name, args, authUser, hostname, mode, cwd, shell, stdin, env);
+    }
+    finally {
+        _callDepth--;
+    }
+}
+async function _runCommandDirectInner(name, args, authUser, hostname, mode, cwd, shell, stdin, env) {
     const assignRe = /^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/;
     const invocation = [name, ...args];
     let assignCount = 0;
@@ -118,6 +136,8 @@ export async function runCommandDirect(name, args, authUser, hostname, mode, cwd
                         env,
                     });
                 }
+                // builtin not found — stop here, don't fall through to sh -c (avoids infinite loop)
+                return { stderr: `${name}: exec builtin '${builtinMatch[1]}' not found`, exitCode: 127 };
             }
             const shMod = resolveModule("sh");
             if (shMod) {
@@ -163,84 +183,129 @@ export async function runCommand(rawInput, authUser, hostname, mode, cwd, shell,
     if (trimmed.length === 0)
         return { exitCode: 0 };
     const shellEnv = env ?? makeDefaultEnv(authUser, hostname);
-    const rawTokens = tokenizeCommand(trimmed);
-    const rawFirstWord = rawTokens[0]?.toLowerCase() ?? "";
-    const aliasVal = shellEnv.vars[`__alias_${rawFirstWord}`];
-    const aliasExpanded = aliasVal
-        ? trimmed.replace(rawFirstWord, aliasVal)
-        : trimmed;
-    // Detect sh-syntax constructs that must be handled by the sh interpreter
-    const isShScript = /\bfor\s+\w+\s+in\b/.test(aliasExpanded) ||
-        /\bwhile\s+/.test(aliasExpanded) ||
-        /\bif\s+/.test(aliasExpanded) ||
-        /\w+\s*\(\s*\)\s*\{/.test(aliasExpanded) ||
-        /\bfunction\s+\w+/.test(aliasExpanded) ||
-        /\(\(\s*.+\s*\)\)/.test(aliasExpanded);
-    const hasOperators = /(?<![|&])[|](?![|])/.test(aliasExpanded) ||
-        aliasExpanded.includes(">") ||
-        aliasExpanded.includes("<") ||
-        aliasExpanded.includes("&&") ||
-        aliasExpanded.includes("||") ||
-        aliasExpanded.includes(";");
-    if ((isShScript && rawFirstWord !== "sh" && rawFirstWord !== "bash") || hasOperators) {
-        // sh-syntax: route through sh interpreter to handle for/while/functions
-        if (isShScript && rawFirstWord !== "sh" && rawFirstWord !== "bash") {
-            const shMod = resolveModule("sh");
-            if (shMod) {
-                return await shMod.run({
-                    authUser, hostname,
-                    activeSessions: shell.users.listActiveSessions(),
-                    rawInput: aliasExpanded,
-                    mode,
-                    args: ["-c", aliasExpanded],
-                    stdin: undefined,
-                    cwd,
-                    shell,
-                    env: shellEnv,
-                });
+    // Anti-loop guard: check depth here too — catches sh -c recursive calls
+    _callDepth++;
+    // console.debug(`[depth=${_callDepth}] runCommand: ${trimmed.slice(0, 60)}`);
+    if (_callDepth > MAX_CALL_DEPTH) {
+        _callDepth--;
+        // console.debug(`[LOOP DETECTED] runCommand blocked: ${trimmed.slice(0, 60)}`);
+        return { stderr: `${trimmed.split(" ")[0]}: maximum call depth (${MAX_CALL_DEPTH}) exceeded`, exitCode: 126 };
+    }
+    try {
+        // History expansion: !! and !n
+        if (trimmed === '!!' || /^!-?\d+$/.test(trimmed) || trimmed.startsWith('!! ')) {
+            const histPath = `${shellEnv.vars.HOME ?? `/home/${authUser}`}/.bash_history`;
+            if (shell.vfs.exists(histPath)) {
+                const lines = shell.vfs.readFile(histPath).split('\n').filter(Boolean);
+                let cmd;
+                if (trimmed === '!!' || trimmed.startsWith('!! ')) {
+                    cmd = lines[lines.length - 1];
+                }
+                else {
+                    const n = parseInt(trimmed.slice(1), 10);
+                    cmd = n > 0 ? lines[n - 1] : lines[lines.length + n];
+                }
+                if (cmd) {
+                    const suffix = trimmed.startsWith('!! ') ? trimmed.slice(3) : '';
+                    return runCommand(`${cmd}${suffix ? ` ${suffix}` : ''}`, authUser, hostname, mode, cwd, shell, stdin, shellEnv);
+                }
             }
+            return { stderr: `${trimmed}: event not found`, exitCode: 1 };
         }
-        const script = parseScript(aliasExpanded);
-        if (!script.isValid)
-            return { stderr: script.error || "Syntax error", exitCode: 1 };
-        try {
-            return await executeStatements(script.statements, authUser, hostname, mode, cwd, shell, shellEnv);
+        const rawTokens = tokenizeCommand(trimmed);
+        const rawFirstWord = rawTokens[0]?.toLowerCase() ?? "";
+        const aliasVal = shellEnv.vars[`__alias_${rawFirstWord}`];
+        const aliasExpanded = aliasVal
+            ? trimmed.replace(rawFirstWord, aliasVal)
+            : trimmed;
+        // Detect sh-syntax constructs that must be handled by the sh interpreter
+        const isShScript = /\bfor\s+\w+\s+in\b/.test(aliasExpanded) ||
+            /\bwhile\s+/.test(aliasExpanded) ||
+            /\bif\s+/.test(aliasExpanded) ||
+            /\w+\s*\(\s*\)\s*\{/.test(aliasExpanded) ||
+            /\bfunction\s+\w+/.test(aliasExpanded) ||
+            /\(\(\s*.+\s*\)\)/.test(aliasExpanded);
+        const hasOperators = /(?<![|&])[|](?![|])/.test(aliasExpanded) ||
+            aliasExpanded.includes(">") ||
+            aliasExpanded.includes("<") ||
+            aliasExpanded.includes("&&") ||
+            aliasExpanded.includes("||") ||
+            aliasExpanded.includes(";");
+        if ((isShScript && rawFirstWord !== "sh" && rawFirstWord !== "bash") || hasOperators) {
+            // sh-syntax: route through sh interpreter to handle for/while/functions
+            if (isShScript && rawFirstWord !== "sh" && rawFirstWord !== "bash") {
+                const shMod = resolveModule("sh");
+                if (shMod) {
+                    return await shMod.run({
+                        authUser, hostname,
+                        activeSessions: shell.users.listActiveSessions(),
+                        rawInput: aliasExpanded,
+                        mode,
+                        args: ["-c", aliasExpanded],
+                        stdin: undefined,
+                        cwd,
+                        shell,
+                        env: shellEnv,
+                    });
+                }
+            }
+            const script = parseScript(aliasExpanded);
+            if (!script.isValid)
+                return { stderr: script.error || "Syntax error", exitCode: 1 };
+            try {
+                return await executeStatements(script.statements, authUser, hostname, mode, cwd, shell, shellEnv);
+            }
+            catch (error) {
+                return {
+                    stderr: error instanceof Error ? error.message : "Execution failed",
+                    exitCode: 1,
+                };
+            }
         }
-        catch (error) {
-            return {
-                stderr: error instanceof Error ? error.message : "Execution failed",
-                exitCode: 1,
-            };
+        const expanded = await expandAsync(aliasExpanded, shellEnv.vars, shellEnv.lastExitCode, (sub) => runCommand(sub, authUser, hostname, mode, cwd, shell, undefined, shellEnv).then((r) => r.stdout ?? ""));
+        const parts = tokenizeCommand(expanded.trim());
+        if (parts.length === 0)
+            return { exitCode: 0 };
+        const assignRe = /^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/;
+        if (assignRe.test(parts[0])) {
+            return runCommandDirect(parts[0], parts.slice(1), authUser, hostname, mode, cwd, shell, stdin, shellEnv);
         }
-    }
-    const expanded = await expandAsync(aliasExpanded, shellEnv.vars, shellEnv.lastExitCode, (sub) => runCommand(sub, authUser, hostname, mode, cwd, shell, undefined, shellEnv).then((r) => r.stdout ?? ""));
-    const parts = tokenizeCommand(expanded.trim());
-    if (parts.length === 0)
-        return { exitCode: 0 };
-    const assignRe = /^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/;
-    if (assignRe.test(parts[0])) {
-        return runCommandDirect(parts[0], parts.slice(1), authUser, hostname, mode, cwd, shell, stdin, shellEnv);
-    }
-    const commandName = parts[0]?.toLowerCase() ?? "";
-    // Apply brace expansion to each arg token
-    const args = parts.slice(1).flatMap(expandBraces);
-    const mod = resolveModule(commandName);
-    if (!mod) {
-        const vfsBinary = resolveVfsBinary(commandName, shellEnv, shell, authUser);
-        if (vfsBinary) {
-            const stubContent = shell.vfs.readFile(vfsBinary);
-            const builtinMatch = stubContent.match(/exec\s+builtin\s+(\S+)/);
-            if (builtinMatch) {
-                const builtinName = builtinMatch[1];
-                const builtinMod = resolveModule(builtinName);
-                if (builtinMod) {
-                    return await builtinMod.run({
+        const commandName = parts[0]?.toLowerCase() ?? "";
+        // Apply brace expansion to each arg token
+        const args = parts.slice(1).flatMap(expandBraces).flatMap(token => expandGlob(token, cwd, shell.vfs));
+        const mod = resolveModule(commandName);
+        if (!mod) {
+            const vfsBinary = resolveVfsBinary(commandName, shellEnv, shell, authUser);
+            if (vfsBinary) {
+                const stubContent = shell.vfs.readFile(vfsBinary);
+                const builtinMatch = stubContent.match(/exec\s+builtin\s+(\S+)/);
+                if (builtinMatch) {
+                    const builtinName = builtinMatch[1];
+                    const builtinMod = resolveModule(builtinName);
+                    if (builtinMod) {
+                        return await builtinMod.run({
+                            authUser,
+                            hostname,
+                            activeSessions: shell.users.listActiveSessions(),
+                            rawInput: [commandName, ...args].join(" "),
+                            mode,
+                            args,
+                            stdin,
+                            cwd,
+                            shell,
+                            env: shellEnv,
+                        });
+                    }
+                }
+                const shMod = resolveModule("sh");
+                if (shMod) {
+                    return await shMod.run({
                         authUser,
                         hostname,
                         activeSessions: shell.users.listActiveSessions(),
-                        rawInput: [commandName, ...args].join(" "),
+                        rawInput: `sh -c ${JSON.stringify(stubContent)}`,
                         mode,
-                        args,
+                        args: ["-c", stubContent, "--", ...args],
                         stdin,
                         cwd,
                         shell,
@@ -248,42 +313,30 @@ export async function runCommand(rawInput, authUser, hostname, mode, cwd, shell,
                     });
                 }
             }
-            const shMod = resolveModule("sh");
-            if (shMod) {
-                return await shMod.run({
-                    authUser,
-                    hostname,
-                    activeSessions: shell.users.listActiveSessions(),
-                    rawInput: `sh -c ${JSON.stringify(stubContent)}`,
-                    mode,
-                    args: ["-c", stubContent, "--", ...args],
-                    stdin,
-                    cwd,
-                    shell,
-                    env: shellEnv,
-                });
-            }
+            return { stderr: `${commandName}: command not found`, exitCode: 127 };
+        }
+        try {
+            return await mod.run({
+                authUser,
+                hostname,
+                activeSessions: shell.users.listActiveSessions(),
+                rawInput: expanded,
+                mode,
+                args,
+                stdin,
+                cwd,
+                shell,
+                env: shellEnv,
+            });
+        }
+        catch (error) {
+            return {
+                stderr: error instanceof Error ? error.message : "Command failed",
+                exitCode: 1,
+            };
         }
-        return { stderr: `${commandName}: command not found`, exitCode: 127 };
-    }
-    try {
-        return await mod.run({
-            authUser,
-            hostname,
-            activeSessions: shell.users.listActiveSessions(),
-            rawInput: expanded,
-            mode,
-            args,
-            stdin,
-            cwd,
-            shell,
-            env: shellEnv,
-        });
     }
-    catch (error) {
-        return {
-            stderr: error instanceof Error ? error.message : "Command failed",
-            exitCode: 1,
-        };
+    finally {
+        _callDepth--;
     }
 }

package/dist/commands/sh.js

@@ -369,6 +369,11 @@ function splitShScript(script) {
                 }
                 continue;
             }
+            // Backslash-newline continuation: join lines
+            if (!inSingleQ && ch === '\\' && i + 1 < script.length && script[i + 1] === '\n') {
+                i += 2; // skip \ and \n
+                continue;
+            }
             if (depth === 0 && (ch === ";" || ch === "\n")) {
                 const t = current.trim();
                 if (t && !t.startsWith("#"))

package/dist/commands/tput.d.ts

@@ -0,0 +1,13 @@
+import type { ShellModule } from "../types/commands";
+/**
+ * Terminal control.
+ * @category shell
+ * @params ["<cap> [args...]"]
+ */
+export declare const tputCommand: ShellModule;
+/**
+ * Print or set terminal line settings.
+ * @category shell
+ * @params ["[args...]"]
+ */
+export declare const sttyCommand: ShellModule;

package/dist/commands/tput.js

@@ -0,0 +1,76 @@
+const CAPS = {
+    cols: 220, lines: 50, colors: 256,
+    bold: "\x1b[1m", dim: "\x1b[2m", smul: "\x1b[4m", rmul: "\x1b[24m",
+    rev: "\x1b[7m", smso: "\x1b[7m", rmso: "\x1b[27m",
+    sgr0: "\x1b[0m", el: "\x1b[K", ed: "\x1b[J",
+    clear: "\x1b[2J\x1b[H", cup: "", setaf: "", setab: "",
+};
+const ANSI_COLORS = [
+    "30", "31", "32", "33", "34", "35", "36", "37",
+    "90", "91", "92", "93", "94", "95", "96", "97",
+];
+/**
+ * Terminal control.
+ * @category shell
+ * @params ["<cap> [args...]"]
+ */
+export const tputCommand = {
+    name: "tput",
+    description: "Query terminfo database",
+    category: "shell",
+    params: ["<cap> [args...]"],
+    run: ({ args }) => {
+        const cap = args[0];
+        if (!cap)
+            return { stderr: "tput: missing capability", exitCode: 1 };
+        if (cap === "setaf" && args[1] !== undefined) {
+            const n = parseInt(args[1], 10);
+            const code = ANSI_COLORS[n] ?? "39";
+            return { stdout: `\x1b[${code}m`, exitCode: 0 };
+        }
+        if (cap === "setab" && args[1] !== undefined) {
+            const n = parseInt(args[1], 10);
+            const code = ANSI_COLORS[n]?.replace(/3/, "4").replace(/9/, "10") ?? "49";
+            return { stdout: `\x1b[${code}m`, exitCode: 0 };
+        }
+        if (cap === "cup" && args[1] !== undefined && args[2] !== undefined) {
+            return { stdout: `\x1b[${parseInt(args[1], 10) + 1};${parseInt(args[2], 10) + 1}H`, exitCode: 0 };
+        }
+        const val = CAPS[cap];
+        if (val === undefined)
+            return { stderr: `tput: unknown terminal capability '${cap}'`, exitCode: 1 };
+        return { stdout: String(val), exitCode: 0 };
+    },
+};
+/**
+ * Print or set terminal line settings.
+ * @category shell
+ * @params ["[args...]"]
+ */
+export const sttyCommand = {
+    name: "stty",
+    description: "Change and print terminal line settings",
+    category: "shell",
+    params: ["[args...]"],
+    run: ({ args }) => {
+        if (args.includes("-a") || args.includes("--all")) {
+            return {
+                stdout: [
+                    "speed 38400 baud; rows 50; columns 220; line = 0;",
+                    "intr = ^C; quit = ^\\; erase = ^?; kill = ^U; eof = ^D;",
+                    "eol = M-^?; eol2 = M-^?; swtch = <undef>; start = ^Q; stop = ^S;",
+                    "-parenb -parodd -cmspar cs8 -hupcl -cstopb cread -clocal -crtscts",
+                    "brkint -icrnl ixon -ixoff -iuclc ixany imaxbel -iutf8",
+                    "opost -olcuc -ocrnl onlcr -onocr -onlret -ofill -ofdel nl0 cr0 tab0 bs0 vt0 ff0",
+                    "isig icanon iexten echo echoe echok -echonl -noflsh -xcase -tostop -echoprt echoctl echoke",
+                ].join("\n"),
+                exitCode: 0,
+            };
+        }
+        if (args.includes("size")) {
+            return { stdout: "50 220", exitCode: 0 };
+        }
+        // silently accept set operations
+        return { exitCode: 0 };
+    },
+};

package/dist/commands/w.d.ts

@@ -0,0 +1,7 @@
+import type { ShellModule } from "../types/commands";
+/**
+ * Show who is logged on and what they are doing.
+ * @category system
+ * @params ["[user]"]
+ */
+export declare const wCommand: ShellModule;

package/dist/commands/w.js

@@ -0,0 +1,38 @@
+import { userHome } from "./runtime";
+/**
+ * Show who is logged on and what they are doing.
+ * @category system
+ * @params ["[user]"]
+ */
+export const wCommand = {
+    name: "w",
+    description: "Show who is logged on and what they are doing",
+    category: "system",
+    params: ["[user]"],
+    run: ({ shell, authUser }) => {
+        const now = new Date();
+        const upSecs = Math.floor(performance.now() / 1000);
+        const upMins = Math.floor(upSecs / 60);
+        const upHours = Math.floor(upMins / 60);
+        const uptimeStr = upHours > 0
+            ? `${upHours}:${String(upMins % 60).padStart(2, "0")}`
+            : `${upMins} min`;
+        const timeStr = now.toTimeString().slice(0, 5);
+        // Read active sessions
+        shell.users.listActiveSessions?.();
+        const logPath = `${userHome(authUser)}/.lastlog`;
+        let loginTime = timeStr;
+        if (shell.vfs.exists(logPath)) {
+            try {
+                const log = JSON.parse(shell.vfs.readFile(logPath));
+                loginTime = new Date(log.at).toTimeString().slice(0, 5);
+            }
+            catch { }
+        }
+        const header = ` ${timeStr} up ${uptimeStr},  1 user,  load average: 0.${Math.floor(Math.random() * 30).toString().padStart(2, "0")}, 0.${Math.floor(Math.random() * 15).toString().padStart(2, "0")}, 0.${Math.floor(Math.random() * 10).toString().padStart(2, "0")}`;
+        const colHeader = "USER     TTY      FROM             LOGIN@   IDLE JCPU   PCPU WHAT";
+        const idle = "0.00s";
+        const row = `${authUser.padEnd(8)} pts/0    browser          ${loginTime}   ${idle}  0.01s  0.00s -bash`;
+        return { stdout: [header, colHeader, row].join("\n"), exitCode: 0 };
+    },
+};

package/dist/utils/expand.d.ts

@@ -56,3 +56,15 @@ export declare function expandSync(input: string, env: Record<string, string>, l
  * @param runCmd    Async callback to execute a command and return its stdout.
  */
 export declare function expandAsync(input: string, env: Record<string, string>, lastExit: number, runCmd: (cmd: string) => Promise<string>): Promise<string>;
+/**
+ * Expand a glob pattern against a VirtualShell VFS.
+ * Supports * (any chars in segment) and ** (any path).
+ * Returns the original pattern if no matches found (bash behavior).
+ */
+export declare function expandGlob(pattern: string, cwd: string, vfs: {
+    list: (p: string) => string[];
+    exists: (p: string) => boolean;
+    stat: (p: string) => {
+        type: string;
+    };
+}): string[];

package/dist/utils/expand.js

@@ -474,3 +474,87 @@ export async function expandAsync(input, env, lastExit, runCmd) {
             env[depthKey] = String(currentDepth);
     }
 }
+// ─── Glob expansion ──────────────────────────────────────────────────────────
+/**
+ * Expand a glob pattern against a VirtualShell VFS.
+ * Supports * (any chars in segment) and ** (any path).
+ * Returns the original pattern if no matches found (bash behavior).
+ */
+export function expandGlob(pattern, cwd, vfs) {
+    // No glob chars → return as-is
+    if (!pattern.includes('*') && !pattern.includes('?'))
+        return [pattern];
+    const isAbsolute = pattern.startsWith('/');
+    const base = isAbsolute ? '/' : cwd;
+    const relPattern = isAbsolute ? pattern.slice(1) : pattern;
+    const results = matchGlob(base, relPattern.split('/'), vfs);
+    if (results.length === 0)
+        return [pattern]; // no match → literal
+    return results.sort();
+}
+function matchGlob(dir, segments, vfs) {
+    if (segments.length === 0)
+        return [dir];
+    const [seg, ...rest] = segments;
+    if (!seg)
+        return [dir];
+    // ** matches zero or more path segments
+    if (seg === '**') {
+        const all = walkAll(dir, vfs);
+        return rest.length === 0 ? all : all.flatMap(d => {
+            try {
+                if (vfs.stat(d).type === 'directory')
+                    return matchGlob(d, rest, vfs);
+            }
+            catch { }
+            return [];
+        });
+    }
+    let entries = [];
+    try {
+        entries = vfs.list(dir);
+    }
+    catch {
+        return [];
+    }
+    const re = globToRegex(seg);
+    return entries
+        .filter(e => !e.startsWith('.') || seg.startsWith('.'))
+        .filter(e => re.test(e))
+        .flatMap(e => {
+        const full = dir === '/' ? `/${e}` : `${dir}/${e}`;
+        if (rest.length === 0)
+            return [full];
+        try {
+            if (vfs.stat(full).type === 'directory')
+                return matchGlob(full, rest, vfs);
+        }
+        catch { }
+        return [];
+    });
+}
+function walkAll(dir, vfs) {
+    const results = [dir];
+    let entries = [];
+    try {
+        entries = vfs.list(dir);
+    }
+    catch {
+        return results;
+    }
+    for (const e of entries) {
+        const full = dir === '/' ? `/${e}` : `${dir}/${e}`;
+        try {
+            if (vfs.stat(full).type === 'directory')
+                results.push(...walkAll(full, vfs));
+        }
+        catch { }
+    }
+    return results;
+}
+function globToRegex(pattern) {
+    const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, '\\$&')
+        .replace(/\*/g, '.*')
+        .replace(/\?/g, '.');
+    return new RegExp(`^${escaped}$`);
+}