typescript-virtual-container 1.4.4 → 1.4.6

package/src/web.js

@@ -1,773 +0,0 @@
-/** 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);
-}