typescript-virtual-container 1.3.1 → 1.3.3

package/dist/web.js

@@ -0,0 +1,773 @@
+/** biome-ignore-all lint/style/useNamingConvention: env vars */
+import { parseScript } from "./VirtualShell/shellParser";
+import { expandAsync, expandSync } from "./utils/expand";
+const textEncoder = new TextEncoder();
+const textDecoder = new TextDecoder();
+function encodeBase64(bytes) {
+    let binary = "";
+    for (const byte of bytes)
+        binary += String.fromCharCode(byte);
+    return btoa(binary);
+}
+function decodeBase64(base64) {
+    const binary = atob(base64);
+    const bytes = new Uint8Array(binary.length);
+    for (let index = 0; index < binary.length; index += 1) {
+        bytes[index] = binary.charCodeAt(index);
+    }
+    return bytes;
+}
+function normalizePath(inputPath, cwd = "/") {
+    const raw = inputPath.startsWith("/") ? inputPath : `${cwd}/${inputPath}`;
+    const parts = raw.split("/");
+    const stack = [];
+    for (const part of parts) {
+        if (!part || part === ".")
+            continue;
+        if (part === "..") {
+            stack.pop();
+            continue;
+        }
+        stack.push(part);
+    }
+    return `/${stack.join("/")}` || "/";
+}
+function dirname(inputPath) {
+    const normalized = normalizePath(inputPath);
+    if (normalized === "/")
+        return "/";
+    const parts = normalized.split("/").filter(Boolean);
+    parts.pop();
+    return parts.length > 0 ? `/${parts.join("/")}` : "/";
+}
+function basename(inputPath) {
+    const normalized = normalizePath(inputPath);
+    if (normalized === "/")
+        return "/";
+    const parts = normalized.split("/").filter(Boolean);
+    return parts.at(-1) ?? "/";
+}
+function cloneNode(node) {
+    if (node.type === "file") {
+        return {
+            ...node,
+            contentBase64: node.contentBase64,
+        };
+    }
+    return {
+        ...node,
+        children: node.children.map((child) => cloneNode(child)),
+    };
+}
+function makeDirectory(name, mode) {
+    const now = new Date().toISOString();
+    return {
+        type: "directory",
+        name,
+        mode,
+        createdAt: now,
+        updatedAt: now,
+        children: [],
+    };
+}
+function makeFile(name, content, mode) {
+    const now = new Date().toISOString();
+    return {
+        type: "file",
+        name,
+        mode,
+        createdAt: now,
+        updatedAt: now,
+        contentBase64: encodeBase64(content),
+    };
+}
+function findChild(directory, name) {
+    return directory.children.find((child) => child.name === name);
+}
+function setChild(directory, node) {
+    const index = directory.children.findIndex((child) => child.name === node.name);
+    if (index === -1) {
+        directory.children.push(node);
+        return;
+    }
+    directory.children[index] = node;
+}
+function removeChild(directory, name) {
+    directory.children = directory.children.filter((child) => child.name !== name);
+}
+function splitPath(pathValue) {
+    return normalizePath(pathValue).split("/").filter(Boolean);
+}
+const webGlobal = globalThis;
+function promisifyRequest(request) {
+    return new Promise((resolve, reject) => {
+        request.addEventListener("success", () => resolve(request.result));
+        request.addEventListener("error", () => reject(request.error));
+    });
+}
+class IndexedDbMirrorVfs {
+    databaseName;
+    storeName;
+    key;
+    root;
+    constructor(options = {}) {
+        this.databaseName = options.databaseName ?? "typescript-virtual-container-web";
+        this.storeName = options.storeName ?? "snapshots";
+        this.key = options.key ?? "current";
+        this.root = makeDirectory("", 0o755);
+    }
+    async openDatabase() {
+        return new Promise((resolve, reject) => {
+            const indexedDbFactory = webGlobal.indexedDB;
+            if (!indexedDbFactory) {
+                reject(new Error("IndexedDB is not available in this environment"));
+                return;
+            }
+            const request = indexedDbFactory.open(this.databaseName, 1);
+            request.addEventListener("upgradeneeded", () => {
+                const database = request.result;
+                if (!database.objectStoreNames.contains(this.storeName)) {
+                    database.createObjectStore(this.storeName);
+                }
+            });
+            request.addEventListener("success", () => resolve(request.result));
+            request.addEventListener("error", () => reject(request.error));
+        });
+    }
+    async readSnapshot() {
+        const database = await this.openDatabase();
+        try {
+            const transaction = database.transaction(this.storeName, "readonly");
+            const store = transaction.objectStore(this.storeName);
+            const request = store.get(this.key);
+            const result = (await promisifyRequest(request));
+            if (!result)
+                return null;
+            return JSON.parse(result);
+        }
+        finally {
+            database.close();
+        }
+    }
+    async writeSnapshot(snapshot) {
+        const database = await this.openDatabase();
+        try {
+            const transaction = database.transaction(this.storeName, "readwrite");
+            const store = transaction.objectStore(this.storeName);
+            await promisifyRequest(store.put(JSON.stringify(snapshot), this.key));
+            await new Promise((resolve, reject) => {
+                transaction.addEventListener("complete", () => resolve());
+                transaction.addEventListener("error", () => reject(transaction.error));
+                transaction.addEventListener("abort", () => reject(transaction.error));
+            });
+        }
+        finally {
+            database.close();
+        }
+    }
+    serializeNode(node) {
+        if (node.type === "file")
+            return { ...node };
+        return {
+            ...node,
+            children: node.children.map((child) => this.serializeNode(child)),
+        };
+    }
+    deserializeNode(node) {
+        if (node.type === "file")
+            return { ...node };
+        return {
+            ...node,
+            children: node.children.map((child) => this.deserializeNode(child)),
+        };
+    }
+    getNode(targetPath) {
+        const normalized = normalizePath(targetPath);
+        if (normalized === "/")
+            return this.root;
+        const parts = splitPath(normalized);
+        let current = this.root;
+        for (const part of parts) {
+            if (current.type !== "directory") {
+                throw new Error(`Not a directory: ${normalized}`);
+            }
+            const child = findChild(current, part);
+            if (!child)
+                throw new Error(`No such file or directory: ${normalized}`);
+            current = child;
+        }
+        return current;
+    }
+    ensureDirectory(targetPath, mode) {
+        const normalized = normalizePath(targetPath);
+        if (normalized === "/")
+            return this.root;
+        const parts = splitPath(normalized);
+        let current = this.root;
+        for (const part of parts) {
+            const existing = findChild(current, part);
+            if (!existing) {
+                const created = makeDirectory(part, mode);
+                setChild(current, created);
+                current = created;
+                continue;
+            }
+            if (existing.type !== "directory") {
+                throw new Error(`Cannot create directory '${normalized}': path is a file.`);
+            }
+            current = existing;
+        }
+        return current;
+    }
+    removeNode(targetPath, recursive) {
+        const normalized = normalizePath(targetPath);
+        if (normalized === "/")
+            throw new Error("Cannot remove root directory");
+        const parent = this.getNode(dirname(normalized));
+        if (parent.type !== "directory")
+            throw new Error(`Not a directory: ${dirname(normalized)}`);
+        const name = basename(normalized);
+        const node = findChild(parent, name);
+        if (!node)
+            throw new Error(`No such file or directory: ${normalized}`);
+        if (node.type === "directory" && node.children.length > 0 && !recursive) {
+            throw new Error(`Cannot remove '${normalized}': directory not empty.`);
+        }
+        removeChild(parent, name);
+    }
+    copyNode(node) {
+        if (node.type === "file") {
+            return {
+                ...node,
+                contentBase64: node.contentBase64,
+            };
+        }
+        return {
+            ...node,
+            children: node.children.map((child) => this.copyNode(child)),
+        };
+    }
+    async restoreMirror() {
+        const snapshot = await this.readSnapshot();
+        if (!snapshot)
+            return;
+        this.root = this.deserializeNode(snapshot.root);
+    }
+    async flushMirror() {
+        await this.writeSnapshot({ root: this.serializeNode(this.root) });
+    }
+    exists(targetPath) {
+        try {
+            this.getNode(targetPath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    list(targetPath) {
+        const node = this.getNode(targetPath);
+        if (node.type !== "directory")
+            throw new Error(`Not a directory: ${targetPath}`);
+        return node.children.map((child) => child.name).sort((a, b) => a.localeCompare(b));
+    }
+    stat(targetPath) {
+        const node = this.getNode(targetPath);
+        if (node.type === "file") {
+            return {
+                type: "file",
+                mode: node.mode,
+                size: decodeBase64(node.contentBase64).byteLength,
+                name: node.name,
+            };
+        }
+        return { type: "directory", mode: node.mode, size: 0, name: node.name };
+    }
+    readFile(targetPath) {
+        const node = this.getNode(targetPath);
+        if (node.type !== "file")
+            throw new Error(`Is a directory: ${targetPath}`);
+        return textDecoder.decode(decodeBase64(node.contentBase64));
+    }
+    writeFile(targetPath, content, mode = 0o644) {
+        const normalized = normalizePath(targetPath);
+        const parent = this.ensureDirectory(dirname(normalized), 0o755);
+        const bytes = typeof content === "string" ? textEncoder.encode(content) : content;
+        const file = makeFile(basename(normalized), bytes, mode);
+        setChild(parent, file);
+    }
+    mkdir(targetPath, mode = 0o755) {
+        this.ensureDirectory(targetPath, mode);
+    }
+    touch(targetPath) {
+        if (this.exists(targetPath))
+            return;
+        this.writeFile(targetPath, "");
+    }
+    move(fromPath, toPath) {
+        const source = this.getNode(fromPath);
+        const sourceParent = this.getNode(dirname(fromPath));
+        const destinationParent = this.ensureDirectory(dirname(toPath), 0o755);
+        if (sourceParent.type !== "directory")
+            throw new Error(`Not a directory: ${dirname(fromPath)}`);
+        removeChild(sourceParent, basename(fromPath));
+        const clone = cloneNode(source);
+        clone.name = basename(toPath);
+        setChild(destinationParent, clone);
+    }
+    copy(fromPath, toPath) {
+        const source = this.getNode(fromPath);
+        const destinationParent = this.ensureDirectory(dirname(toPath), 0o755);
+        const clone = this.copyNode(source);
+        clone.name = basename(toPath);
+        setChild(destinationParent, clone);
+    }
+    remove(targetPath, options = {}) {
+        this.removeNode(targetPath, options.recursive ?? false);
+    }
+    exportSnapshot() {
+        return { root: this.serializeNode(this.root) };
+    }
+    importSnapshot(snapshot) {
+        this.root = this.deserializeNode(snapshot.root);
+    }
+}
+class WebShell {
+    hostname;
+    vfs;
+    env;
+    cwd;
+    commands = new Map();
+    initialized = false;
+    constructor(hostname, options = {}) {
+        this.hostname = hostname;
+        this.cwd = options.cwd ?? "/home/root";
+        this.env = {
+            vars: {
+                PATH: "/usr/bin:/bin",
+                HOME: "/home/root",
+                USER: "root",
+                LOGNAME: "root",
+                SHELL: "/bin/sh",
+                HOSTNAME: hostname,
+                PWD: this.cwd,
+            },
+            lastExitCode: 0,
+        };
+        this.vfs = new IndexedDbMirrorVfs(options.vfs);
+        this.registerBuiltins();
+    }
+    register(command) {
+        this.commands.set(command.name.toLowerCase(), command);
+        for (const alias of command.aliases ?? []) {
+            this.commands.set(alias.toLowerCase(), command);
+        }
+    }
+    registerBuiltins() {
+        this.register({
+            name: "help",
+            description: "List available web commands",
+            params: [],
+            run: () => ({ stdout: `${this.listCommands().join("\n")}\n`, exitCode: 0 }),
+        });
+        this.register({
+            name: "pwd",
+            description: "Print current directory",
+            params: [],
+            run: () => ({ stdout: `${this.cwd}\n`, exitCode: 0 }),
+        });
+        this.register({
+            name: "cd",
+            description: "Change current directory",
+            params: ["[dir]"],
+            run: ({ args }) => {
+                const target = args[0] ? normalizePath(args[0], this.cwd) : "/home/root";
+                if (!this.vfs.exists(target) || this.vfs.stat(target).type !== "directory") {
+                    return { stderr: `cd: no such file or directory: ${target}`, exitCode: 1 };
+                }
+                this.cwd = target;
+                this.env.vars.PWD = target;
+                return { exitCode: 0, nextCwd: target };
+            },
+        });
+        this.register({
+            name: "echo",
+            description: "Display text",
+            params: ["[-n] [-e] [text...]"],
+            run: ({ args, stdin }) => {
+                const noNewline = args.includes("-n");
+                const raw = args.filter((arg) => arg !== "-n" && arg !== "-e" && arg !== "-E");
+                const text = raw.length > 0 ? raw.join(" ") : (stdin ?? "");
+                const expanded = expandSync(text, this.env.vars, this.env.lastExitCode, this.env.vars.HOME);
+                return { stdout: noNewline ? expanded : `${expanded}\n`, exitCode: 0 };
+            },
+        });
+        this.register({
+            name: "env",
+            description: "Print environment variables",
+            params: [],
+            run: () => ({ stdout: `${Object.entries(this.env.vars).map(([key, value]) => `${key}=${value}`).join("\n")}\n`, exitCode: 0 }),
+        });
+        this.register({
+            name: "export",
+            description: "Set environment variables",
+            params: ["KEY=VALUE..."],
+            run: ({ args }) => {
+                for (const arg of args) {
+                    const eq = arg.indexOf("=");
+                    if (eq === -1)
+                        continue;
+                    const key = arg.slice(0, eq).trim();
+                    const value = arg.slice(eq + 1);
+                    if (key)
+                        this.env.vars[key] = value;
+                }
+                return { exitCode: 0 };
+            },
+        });
+        this.register({
+            name: "unset",
+            description: "Unset environment variables",
+            params: ["NAME..."],
+            run: ({ args }) => {
+                for (const name of args)
+                    delete this.env.vars[name];
+                return { exitCode: 0 };
+            },
+        });
+        this.register({
+            name: "mkdir",
+            description: "Create directories",
+            params: ["[-p] dir..."],
+            run: async ({ args }) => {
+                const paths = args.filter((arg) => arg !== "-p");
+                for (const target of paths) {
+                    this.vfs.mkdir(normalizePath(target, this.cwd));
+                }
+                await this.vfs.flushMirror();
+                return { exitCode: 0 };
+            },
+        });
+        this.register({
+            name: "touch",
+            description: "Create files",
+            params: ["file..."],
+            run: async ({ args }) => {
+                for (const target of args) {
+                    this.vfs.touch(normalizePath(target, this.cwd));
+                }
+                await this.vfs.flushMirror();
+                return { exitCode: 0 };
+            },
+        });
+        this.register({
+            name: "rm",
+            description: "Remove files or directories",
+            params: ["[-r] [-f] path..."],
+            run: async ({ args }) => {
+                const recursive = args.includes("-r");
+                const targets = args.filter((arg) => arg !== "-r" && arg !== "-f");
+                for (const target of targets) {
+                    this.vfs.remove(normalizePath(target, this.cwd), { recursive });
+                }
+                await this.vfs.flushMirror();
+                return { exitCode: 0 };
+            },
+        });
+        this.register({
+            name: "cp",
+            description: "Copy files or directories",
+            params: ["[-r] source destination"],
+            run: async ({ args }) => {
+                const recursive = args.includes("-r");
+                const items = args.filter((arg) => arg !== "-r");
+                if (items.length < 2)
+                    return { stderr: "cp: missing destination file operand", exitCode: 1 };
+                const dest = normalizePath(items.at(-1), this.cwd);
+                for (const source of items.slice(0, -1)) {
+                    const sourcePath = normalizePath(source, this.cwd);
+                    if (!recursive && this.vfs.stat(sourcePath).type === "directory") {
+                        return { stderr: `cp: -r not specified; omitting directory '${sourcePath}'`, exitCode: 1 };
+                    }
+                    this.vfs.copy(sourcePath, dest);
+                }
+                await this.vfs.flushMirror();
+                return { exitCode: 0 };
+            },
+        });
+        this.register({
+            name: "mv",
+            description: "Move or rename files",
+            params: ["source destination"],
+            run: async ({ args }) => {
+                if (args.length < 2)
+                    return { stderr: "mv: missing destination file operand", exitCode: 1 };
+                const source = normalizePath(args[0], this.cwd);
+                const destination = normalizePath(args[1], this.cwd);
+                this.vfs.move(source, destination);
+                await this.vfs.flushMirror();
+                return { exitCode: 0 };
+            },
+        });
+        this.register({
+            name: "cat",
+            description: "Concatenate files",
+            params: ["[file...]"],
+            run: ({ args, stdin }) => {
+                if (args.length === 0)
+                    return { stdout: stdin ?? "", exitCode: 0 };
+                let output = "";
+                for (const source of args) {
+                    output += this.vfs.readFile(normalizePath(source, this.cwd));
+                }
+                return { stdout: output, exitCode: 0 };
+            },
+        });
+        this.register({
+            name: "ls",
+            description: "List files",
+            params: ["[path]"],
+            run: ({ args }) => {
+                const target = normalizePath(args[0] ?? ".", this.cwd);
+                const entries = this.vfs.list(target);
+                return { stdout: `${entries.join("  ")}\n`, exitCode: 0 };
+            },
+        });
+        this.register({
+            name: "tee",
+            description: "Read from stdin and write to files",
+            params: ["[-a] file..."],
+            run: async ({ args, stdin }) => {
+                const append = args.includes("-a");
+                const targets = args.filter((arg) => arg !== "-a");
+                const content = stdin ?? "";
+                for (const target of targets) {
+                    const normalized = normalizePath(target, this.cwd);
+                    if (append && this.vfs.exists(normalized)) {
+                        const current = this.vfs.readFile(normalized);
+                        this.vfs.writeFile(normalized, `${current}${content}`);
+                    }
+                    else {
+                        this.vfs.writeFile(normalized, content);
+                    }
+                }
+                await this.vfs.flushMirror();
+                return { stdout: content, exitCode: 0 };
+            },
+        });
+        this.register({
+            name: "curl",
+            description: "Fetch a URL and optionally write to a file",
+            params: ["[-o file] URL"],
+            run: async ({ args }) => {
+                const outputIndex = args.indexOf("-o");
+                const outputTarget = outputIndex !== -1 ? args[outputIndex + 1] : undefined;
+                const filtered = args.filter((arg, index) => arg !== "-o" && index !== outputIndex + 1);
+                const url = filtered.at(-1);
+                if (!url)
+                    return { stderr: "curl: missing URL", exitCode: 2 };
+                const response = await fetch(url);
+                const body = await response.text();
+                if (outputTarget) {
+                    this.vfs.writeFile(normalizePath(outputTarget, this.cwd), body);
+                    await this.vfs.flushMirror();
+                    return { exitCode: response.ok ? 0 : 1 };
+                }
+                return { stdout: body, exitCode: response.ok ? 0 : 1 };
+            },
+        });
+        this.register({
+            name: "wget",
+            description: "Fetch a URL and optionally write to a file",
+            params: ["[-O file] URL"],
+            run: async ({ args }) => {
+                const outputIndex = args.indexOf("-O");
+                const outputTarget = outputIndex !== -1 ? args[outputIndex + 1] : undefined;
+                const filtered = args.filter((arg, index) => arg !== "-O" && index !== outputIndex + 1);
+                const url = filtered.at(-1);
+                if (!url)
+                    return { stderr: "wget: missing URL", exitCode: 2 };
+                const response = await fetch(url);
+                const body = await response.text();
+                const filename = outputTarget ?? basename(new URL(url).pathname || "index.html");
+                this.vfs.writeFile(normalizePath(filename, this.cwd), body);
+                await this.vfs.flushMirror();
+                return { exitCode: response.ok ? 0 : 1 };
+            },
+        });
+        this.register({
+            name: "true",
+            description: "Return success",
+            params: [],
+            run: () => ({ exitCode: 0 }),
+        });
+        this.register({
+            name: "false",
+            description: "Return failure",
+            params: [],
+            run: () => ({ exitCode: 1 }),
+        });
+    }
+    listCommands() {
+        const unique = new Map();
+        for (const command of this.commands.values())
+            unique.set(command.name, command);
+        return Array.from(unique.values())
+            .sort((a, b) => a.name.localeCompare(b.name))
+            .map((command) => `${command.name}${command.params.length > 0 ? ` ${command.params.join(" ")}` : ""}`);
+    }
+    resolveCommand(name) {
+        return this.commands.get(name.toLowerCase());
+    }
+    async ensureInitialized() {
+        if (this.initialized)
+            return;
+        await this.vfs.restoreMirror();
+        if (!this.vfs.exists("/home"))
+            this.vfs.mkdir("/home");
+        if (!this.vfs.exists("/home/root")) {
+            this.vfs.mkdir("/home/root");
+            this.vfs.writeFile("/home/root/README.txt", `Welcome to ${this.hostname}\n`);
+        }
+        if (!this.vfs.exists("/tmp"))
+            this.vfs.mkdir("/tmp");
+        if (!this.vfs.exists("/etc"))
+            this.vfs.mkdir("/etc");
+        if (!this.vfs.exists("/etc/hostname"))
+            this.vfs.writeFile("/etc/hostname", `${this.hostname}\n`);
+        if (!this.vfs.exists("/etc/hosts")) {
+            this.vfs.writeFile("/etc/hosts", "127.0.0.1 localhost\n::1 localhost\n");
+        }
+        this.initialized = true;
+    }
+    getCurrentWorkingDirectory() {
+        return this.cwd;
+    }
+    async executeCommandLine(rawInput, persist = true) {
+        await this.ensureInitialized();
+        const trimmed = rawInput.trim();
+        if (!trimmed)
+            return { exitCode: 0 };
+        const expanded = await expandAsync(trimmed, this.env.vars, this.env.lastExitCode, (subcommand) => this.executeCommandLine(subcommand, false).then((r) => r.stdout ?? ""));
+        const script = parseScript(expanded);
+        const result = await this.executeStatements(script.statements);
+        this.env.lastExitCode = result.exitCode ?? 0;
+        if (persist)
+            await this.vfs.flushMirror();
+        return result;
+    }
+    async executeStatements(statements) {
+        let last = { exitCode: 0 };
+        let index = 0;
+        while (index < statements.length) {
+            const stmt = statements[index];
+            last = await this.executePipeline(stmt.pipeline.commands);
+            this.env.lastExitCode = last.exitCode ?? 0;
+            if (last.closeSession || last.switchUser)
+                return last;
+            const op = stmt.op;
+            if (!op || op === ";") {
+                // continue
+            }
+            else if (op === "&&") {
+                if ((last.exitCode ?? 0) !== 0) {
+                    while (index < statements.length && statements[index]?.op === "&&")
+                        index += 1;
+                }
+            }
+            else if (op === "||") {
+                if ((last.exitCode ?? 0) === 0) {
+                    while (index < statements.length && statements[index]?.op === "||")
+                        index += 1;
+                }
+            }
+            index += 1;
+        }
+        return last;
+    }
+    async executePipeline(commands) {
+        if (commands.length === 0)
+            return { exitCode: 0 };
+        if (commands.length === 1) {
+            return this.executeSingleCommandWithRedirections(commands[0]);
+        }
+        return this.executePipelineChain(commands);
+    }
+    async executeSingleCommandWithRedirections(command) {
+        let stdin;
+        if (command.inputFile) {
+            const inputPath = normalizePath(command.inputFile, this.cwd);
+            try {
+                stdin = this.vfs.readFile(inputPath);
+            }
+            catch {
+                return { stderr: `${command.inputFile}: No such file or directory`, exitCode: 1 };
+            }
+        }
+        const result = await this.executeCommand(command.name, command.args, stdin);
+        if (command.outputFile) {
+            const outputPath = normalizePath(command.outputFile, this.cwd);
+            const output = result.stdout ?? "";
+            if (command.appendOutput && this.vfs.exists(outputPath)) {
+                const existing = this.vfs.readFile(outputPath);
+                this.vfs.writeFile(outputPath, `${existing}${output}`);
+            }
+            else {
+                this.vfs.writeFile(outputPath, output);
+            }
+            return { ...result, stdout: "" };
+        }
+        return result;
+    }
+    async executePipelineChain(commands) {
+        let currentOutput = "";
+        let exitCode = 0;
+        for (let index = 0; index < commands.length; index += 1) {
+            const command = commands[index];
+            if (index === 0 && command.inputFile) {
+                const inputPath = normalizePath(command.inputFile, this.cwd);
+                try {
+                    currentOutput = this.vfs.readFile(inputPath);
+                }
+                catch {
+                    return { stderr: `${command.inputFile}: No such file or directory`, exitCode: 1 };
+                }
+            }
+            const result = await this.executeCommand(command.name, command.args, currentOutput);
+            currentOutput = result.stdout ?? "";
+            exitCode = result.exitCode ?? 0;
+        }
+        return { stdout: currentOutput, exitCode };
+    }
+    async executeCommand(name, args, stdin) {
+        const command = this.resolveCommand(name);
+        if (!command) {
+            return { stderr: `${name}: command not found`, exitCode: 127 };
+        }
+        const expandedArgs = args.map((arg) => expandSync(arg, this.env.vars, this.env.lastExitCode, this.env.vars.HOME));
+        const context = {
+            args: expandedArgs,
+            stdin,
+            cwd: this.cwd,
+            env: this.env,
+            rawInput: `${name} ${args.join(" ")}`.trim(),
+            shell: this,
+        };
+        try {
+            const result = await command.run(context);
+            if (result.nextCwd) {
+                this.cwd = result.nextCwd;
+                this.env.vars.PWD = result.nextCwd;
+            }
+            return result;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return { stderr: message, exitCode: 1 };
+        }
+    }
+}
+export { IndexedDbMirrorVfs, WebShell };
+export function createWebShell(hostname = "typescript-vm", options = {}) {
+    return new WebShell(hostname, options);
+}