typescript-virtual-container 1.2.8 → 1.3.0

package/dist/commands/read.d.ts

@@ -0,0 +1,3 @@
+import type { ShellModule } from "../types/commands";
+export declare const readCommand: ShellModule;
+//# sourceMappingURL=read.d.ts.map

package/dist/commands/read.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read.d.ts","sourceRoot":"","sources":["../../src/commands/read.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGrD,eAAO,MAAM,WAAW,EAAE,WAqCzB,CAAC"}

package/dist/commands/read.js

@@ -0,0 +1,34 @@
+import { ifFlag } from "./command-helpers";
+export const readCommand = {
+    name: "read",
+    description: "Read a line from stdin into variables",
+    category: "shell",
+    params: ["[-r] [-p prompt] <var...>"],
+    run: ({ args, stdin, env }) => {
+        const _promptIdx = args.indexOf("-p");
+        const varNames = args.filter((a, i) => a !== "-r" && a !== "-p" && args[i - 1] !== "-p");
+        // In non-interactive context, read from stdin pipe
+        const input = (stdin ?? "").split("\n")[0] ?? "";
+        const line = ifFlag(args, ["-r"])
+            ? input
+            : input.replace(/\\(?:\r?\n|.)/g, (m) => m[1] === "\n" || m[1] === "\r" ? "" : m[1]);
+        if (!env)
+            return { exitCode: 0 };
+        if (varNames.length === 0) {
+            // No var names: store into REPLY
+            env.vars.REPLY = line;
+        }
+        else if (varNames.length === 1) {
+            env.vars[varNames[0]] = line;
+        }
+        else {
+            // Split on whitespace, last var gets remainder
+            const parts = line.split(/\s+/);
+            for (let i = 0; i < varNames.length; i++) {
+                env.vars[varNames[i]] =
+                    i < varNames.length - 1 ? (parts[i] ?? "") : parts.slice(i).join(" ");
+            }
+        }
+        return { exitCode: 0 };
+    },
+};

package/dist/commands/registry.d.ts

@@ -0,0 +1,8 @@
+/** biome-ignore-all lint/style/useNamingConvention: ENV VARIABLES */
+import type { CommandContext, CommandResult, ShellModule } from "../types/commands";
+export declare function registerCommand(module: ShellModule): void;
+export declare function createCustomCommand(name: string, params: string[], run: (ctx: CommandContext) => CommandResult | Promise<CommandResult>): ShellModule;
+export declare function getCommandNames(): string[];
+export declare function getCommandModulesPublic(): ShellModule[];
+export declare function resolveModule(name: string): ShellModule | undefined;
+//# sourceMappingURL=registry.d.ts.map

package/dist/commands/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/commands/registry.ts"],"names":[],"mappings":"AAAA,qEAAqE;AACrE,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAgNpF,wBAAgB,eAAe,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI,CAYzD;AAED,wBAAgB,mBAAmB,CAClC,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EAAE,EAChB,GAAG,EAAE,CAAC,GAAG,EAAE,cAAc,KAAK,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC,GAClE,WAAW,CAEb;AAED,wBAAgB,eAAe,IAAI,MAAM,EAAE,CAG1C;AAED,wBAAgB,uBAAuB,IAAI,WAAW,EAAE,CAEvD;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS,CAGnE"}

package/dist/commands/registry.js

@@ -0,0 +1,229 @@
+import { adduserCommand } from "./adduser";
+import { aliasCommand, unaliasCommand } from "./alias";
+import { aptCacheCommand, aptCommand } from "./apt";
+import { awkCommand } from "./awk";
+import { base64Command } from "./base64";
+import { catCommand } from "./cat";
+import { cdCommand } from "./cd";
+import { chmodCommand } from "./chmod";
+import { clearCommand } from "./clear";
+import { cpCommand } from "./cp";
+import { curlCommand } from "./curl";
+import { cutCommand } from "./cut";
+import { dateCommand } from "./date";
+import { declareCommand } from "./declare";
+import { deluserCommand } from "./deluser";
+import { dfCommand } from "./df";
+import { diffCommand } from "./diff";
+import { dpkgCommand, dpkgQueryCommand } from "./dpkg";
+import { duCommand } from "./du";
+import { echoCommand } from "./echo";
+import { envCommand } from "./env";
+import { exitCommand } from "./exit";
+import { exportCommand } from "./export";
+import { findCommand } from "./find";
+import { freeCommand } from "./free";
+import { grepCommand } from "./grep";
+import { groupsCommand } from "./groups";
+import { gunzipCommand, gzipCommand } from "./gzip";
+import { headCommand } from "./head";
+import { createHelpCommand } from "./help";
+import { historyCommand } from "./history";
+import { hostnameCommand } from "./hostname";
+import { htopCommand } from "./htop";
+import { idCommand } from "./id";
+import { killCommand } from "./kill";
+import { lnCommand } from "./ln";
+import { lsCommand } from "./ls";
+import { lsbReleaseCommand } from "./lsb-release";
+import { manCommand } from "./man";
+import { mkdirCommand } from "./mkdir";
+import { mvCommand } from "./mv";
+import { nanoCommand } from "./nano";
+import { neofetchCommand } from "./neofetch";
+import { nodeCommand } from "./node";
+import { npmCommand, npxCommand } from "./npm";
+import { passwdCommand } from "./passwd";
+import { pingCommand } from "./ping";
+import { printfCommand } from "./printf";
+import { psCommand } from "./ps";
+import { pwdCommand } from "./pwd";
+import { python3Command } from "./python";
+import { readCommand } from "./read";
+import { rmCommand } from "./rm";
+import { sedCommand } from "./sed";
+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 { suCommand } from "./su";
+import { sudoCommand } from "./sudo";
+import { tailCommand } from "./tail";
+import { tarCommand } from "./tar";
+import { teeCommand } from "./tee";
+import { testCommand } from "./test";
+import { touchCommand } from "./touch";
+import { trCommand } from "./tr";
+import { treeCommand } from "./tree";
+import { falseCommand, trueCommand } from "./true";
+import { typeCommand } from "./type";
+import { unameCommand } from "./uname";
+import { uniqCommand } from "./uniq";
+import { unsetCommand } from "./unset";
+import { uptimeCommand } from "./uptime";
+import { wcCommand } from "./wc";
+import { wgetCommand } from "./wget";
+import { whichCommand } from "./which";
+import { whoCommand } from "./who";
+import { whoamiCommand } from "./whoami";
+import { xargsCommand } from "./xargs";
+const BASE_COMMANDS = [
+    // Navigation
+    pwdCommand,
+    cdCommand,
+    lsCommand,
+    treeCommand,
+    // Files
+    catCommand,
+    touchCommand,
+    rmCommand,
+    mkdirCommand,
+    cpCommand,
+    mvCommand,
+    lnCommand,
+    chmodCommand,
+    findCommand,
+    // Text processing
+    grepCommand,
+    sedCommand,
+    awkCommand,
+    sortCommand,
+    uniqCommand,
+    wcCommand,
+    headCommand,
+    tailCommand,
+    cutCommand,
+    trCommand,
+    teeCommand,
+    xargsCommand,
+    diffCommand,
+    // Archives
+    tarCommand,
+    gzipCommand,
+    gunzipCommand,
+    base64Command,
+    // System info
+    whoamiCommand,
+    whoCommand,
+    hostnameCommand,
+    idCommand,
+    groupsCommand,
+    unameCommand,
+    psCommand,
+    killCommand,
+    dfCommand,
+    duCommand,
+    dateCommand,
+    sleepCommand,
+    pingCommand,
+    // Shell
+    echoCommand,
+    envCommand,
+    exportCommand,
+    setCommand,
+    unsetCommand,
+    shCommand,
+    clearCommand,
+    exitCommand,
+    // Editors
+    nanoCommand,
+    htopCommand,
+    // Network
+    curlCommand,
+    wgetCommand,
+    // Users
+    adduserCommand,
+    passwdCommand,
+    deluserCommand,
+    sudoCommand,
+    suCommand,
+    // Misc
+    neofetchCommand,
+    // Package management
+    aptCommand,
+    aptCacheCommand,
+    dpkgCommand,
+    dpkgQueryCommand,
+    // Shell (extended)
+    whichCommand,
+    typeCommand,
+    manCommand,
+    aliasCommand,
+    unaliasCommand,
+    testCommand,
+    sourceCommand,
+    historyCommand,
+    printfCommand,
+    readCommand,
+    declareCommand,
+    shiftCommand,
+    trapCommand,
+    returnCommand,
+    trueCommand,
+    falseCommand,
+    npmCommand,
+    npxCommand,
+    nodeCommand,
+    python3Command,
+    // System (extended)
+    uptimeCommand,
+    freeCommand,
+    lsbReleaseCommand,
+];
+const customCommands = [];
+const commandRegistry = new Map();
+let cachedCommandNames = null;
+const helpCommand = createHelpCommand(() => getCommandModules().map((cmd) => cmd.name));
+function buildCache() {
+    commandRegistry.clear();
+    for (const mod of getCommandModules()) {
+        commandRegistry.set(mod.name, mod);
+        for (const alias of mod.aliases ?? [])
+            commandRegistry.set(alias, mod);
+    }
+    cachedCommandNames = Array.from(commandRegistry.keys()).sort();
+}
+function getCommandModules() {
+    return [...BASE_COMMANDS, ...customCommands, helpCommand];
+}
+export function registerCommand(module) {
+    const normalized = {
+        ...module,
+        name: module.name.trim().toLowerCase(),
+        aliases: module.aliases?.map((a) => a.trim().toLowerCase()),
+    };
+    const names = [normalized.name, ...(normalized.aliases ?? [])];
+    if (names.some((n) => n.length === 0 || /\s/.test(n))) {
+        throw new Error("Command names must be non-empty and contain no spaces");
+    }
+    customCommands.push(normalized);
+    buildCache();
+}
+export function createCustomCommand(name, params, run) {
+    return { name, params, run };
+}
+export function getCommandNames() {
+    if (!cachedCommandNames)
+        buildCache();
+    return cachedCommandNames;
+}
+export function getCommandModulesPublic() {
+    return getCommandModules();
+}
+export function resolveModule(name) {
+    if (!cachedCommandNames)
+        buildCache();
+    return commandRegistry.get(name.toLowerCase());
+}

package/dist/commands/runtime.d.ts

@@ -0,0 +1,6 @@
+import type { VirtualShell } from "../VirtualShell";
+import type { CommandMode, CommandResult, ShellEnv } from "../types/commands";
+export declare function makeDefaultEnv(authUser: string, hostname: string): ShellEnv;
+export declare function runCommandDirect(name: string, args: string[], authUser: string, hostname: string, mode: CommandMode, cwd: string, shell: VirtualShell, stdin: string | undefined, env: ShellEnv): Promise<CommandResult>;
+export declare function runCommand(rawInput: string, authUser: string, hostname: string, mode: CommandMode, cwd: string, shell: VirtualShell, stdin?: string, env?: ShellEnv): Promise<CommandResult>;
+//# sourceMappingURL=runtime.d.ts.map

package/dist/commands/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../src/commands/runtime.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAEpD,OAAO,KAAK,EACR,WAAW,EACX,aAAa,EACb,QAAQ,EACX,MAAM,mBAAmB,CAAC;AAiE3B,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,QAAQ,CAc3E;AAyCD,wBAAsB,gBAAgB,CACrC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EAAE,EACd,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,WAAW,EACjB,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,YAAY,EACnB,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,GAAG,EAAE,QAAQ,GACX,OAAO,CAAC,aAAa,CAAC,CA4ExB;AAED,wBAAsB,UAAU,CAC/B,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,WAAW,EACjB,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,YAAY,EACnB,KAAK,CAAC,EAAE,MAAM,EACd,GAAG,CAAC,EAAE,QAAQ,GACZ,OAAO,CAAC,aAAa,CAAC,CA+HxB"}

package/dist/commands/runtime.js

@@ -0,0 +1,280 @@
+/** biome-ignore-all lint/style/useNamingConvention: ENV VARIABLES */
+import { executeStatements } from "../SSHMimic/executor";
+import { parseScript } from "../VirtualShell/shellParser";
+import { expandAsync } from "../utils/expand";
+import { resolveModule } from "./registry";
+// ── Tokenize command input respecting quotes ──────────────────────────────────
+function tokenizeCommand(input) {
+    const tokens = [];
+    let current = "";
+    let inQ = false;
+    let qChar = "";
+    let i = 0;
+    while (i < input.length) {
+        const ch = input[i];
+        const next = input[i + 1];
+        if ((ch === '"' || ch === "'") && !inQ) {
+            inQ = true;
+            qChar = ch;
+            i++;
+            continue;
+        }
+        if (inQ && ch === qChar) {
+            inQ = false;
+            qChar = "";
+            i++;
+            continue;
+        }
+        if (inQ) {
+            current += ch;
+            i++;
+            continue;
+        }
+        if (ch === " ") {
+            if (current) {
+                tokens.push(current);
+                current = "";
+            }
+            i++;
+            continue;
+        }
+        if ((ch === ">" || ch === "<") && !inQ) {
+            if (current) {
+                tokens.push(current);
+                current = "";
+            }
+            if (ch === ">" && next === ">") {
+                tokens.push(">>");
+                i += 2;
+            }
+            else {
+                tokens.push(ch);
+                i++;
+            }
+            continue;
+        }
+        current += ch;
+        i++;
+    }
+    if (current)
+        tokens.push(current);
+    return tokens;
+}
+export function makeDefaultEnv(authUser, hostname) {
+    return {
+        vars: {
+            PATH: "/usr/local/bin:/usr/bin:/bin",
+            HOME: `/home/${authUser}`,
+            USER: authUser,
+            LOGNAME: authUser,
+            SHELL: "/bin/sh",
+            TERM: "xterm-256color",
+            HOSTNAME: hostname,
+            PS1: "\\u@\\h:\\w\\$ ",
+        },
+        lastExitCode: 0,
+    };
+}
+function resolveVfsBinary(name, env, shell, authUser) {
+    if (name.startsWith("/")) {
+        if (!shell.vfs.exists(name))
+            return null;
+        try {
+            const st = shell.vfs.stat(name);
+            if (st.type !== "file")
+                return null;
+            if (!(st.mode & 0o111))
+                return null;
+            if ((name.startsWith("/sbin/") || name.startsWith("/usr/sbin/")) &&
+                authUser !== "root")
+                return null;
+            return name;
+        }
+        catch {
+            return null;
+        }
+    }
+    const pathDirs = (env.vars.PATH ?? "/usr/local/bin:/usr/bin:/bin").split(":");
+    for (const dir of pathDirs) {
+        if ((dir === "/sbin" || dir === "/usr/sbin") && authUser !== "root")
+            continue;
+        const full = `${dir}/${name}`;
+        if (!shell.vfs.exists(full))
+            continue;
+        try {
+            const st = shell.vfs.stat(full);
+            if (st.type !== "file")
+                continue;
+            if (!(st.mode & 0o111))
+                continue;
+            return full;
+        }
+        catch { }
+    }
+    return null;
+}
+export async function runCommandDirect(name, args, authUser, hostname, mode, cwd, shell, stdin, env) {
+    const aliasVal = env.vars[`__alias_${name}`];
+    if (aliasVal) {
+        return runCommand(`${aliasVal} ${args.join(" ")}`, authUser, hostname, mode, cwd, shell, stdin, env);
+    }
+    const mod = resolveModule(name);
+    if (!mod) {
+        const vfsBinary = resolveVfsBinary(name, env, shell, authUser);
+        if (vfsBinary) {
+            const stubContent = shell.vfs.readFile(vfsBinary);
+            const builtinMatch = stubContent.match(/exec\s+builtin\s+(\S+)/);
+            if (builtinMatch) {
+                const builtinMod = resolveModule(builtinMatch[1]);
+                if (builtinMod) {
+                    return await builtinMod.run({
+                        authUser,
+                        hostname,
+                        activeSessions: shell.users.listActiveSessions(),
+                        rawInput: [name, ...args].join(" "),
+                        mode,
+                        args,
+                        stdin,
+                        cwd,
+                        shell,
+                        env,
+                    });
+                }
+            }
+            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,
+                });
+            }
+        }
+        return { stderr: `${name}: command not found`, exitCode: 127 };
+    }
+    try {
+        return await mod.run({
+            authUser,
+            hostname,
+            activeSessions: shell.users.listActiveSessions(),
+            rawInput: [name, ...args].join(" "),
+            mode,
+            args,
+            stdin,
+            cwd,
+            shell,
+            env,
+        });
+    }
+    catch (error) {
+        return {
+            stderr: error instanceof Error ? error.message : "Command failed",
+            exitCode: 1,
+        };
+    }
+}
+export async function runCommand(rawInput, authUser, hostname, mode, cwd, shell, stdin, env) {
+    const trimmed = rawInput.trim();
+    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;
+    const hasOperators = /(?<![|&])[|](?![|])/.test(aliasExpanded) ||
+        aliasExpanded.includes(">") ||
+        aliasExpanded.includes("<") ||
+        aliasExpanded.includes("&&") ||
+        aliasExpanded.includes("||") ||
+        aliasExpanded.includes(";");
+    if (hasOperators) {
+        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,
+            };
+        }
+    }
+    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());
+    const commandName = parts[0]?.toLowerCase() ?? "";
+    const args = parts.slice(1);
+    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: `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,
+        };
+    }
+}

package/dist/commands/sed.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sed.d.ts","sourceRoot":"","sources":["../../src/commands/sed.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAIrD,eAAO,MAAM,UAAU,EAAE,WAwCxB,CAAC"}
+{"version":3,"file":"sed.d.ts","sourceRoot":"","sources":["../../src/commands/sed.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAIrD,eAAO,MAAM,UAAU,EAAE,WA0DxB,CAAC"}

package/dist/commands/sed.js

@@ -7,7 +7,8 @@ export const sedCommand = {
     params: ["-e <expr> [file]", "s/pattern/replace/[g]"],
     run: ({ authUser, shell, cwd, args, stdin }) => {
         const inPlace = ifFlag(args, ["-i"]);
-        const expr = getFlag(args, ["-e"]) ?? args.find((a) => !a.startsWith("-"));
+        const expr = getFlag(args, ["-e"]) ??
+            args.find((a) => !a.startsWith("-"));
         const fileArg = args.filter((a) => !a.startsWith("-") && a !== expr).pop();
         if (!expr)
             return { stderr: "sed: no expression", exitCode: 1 };
@@ -18,7 +19,10 @@ export const sedCommand = {
                 content = shell.vfs.readFile(p);
             }
             catch {
-                return { stderr: `sed: ${fileArg}: No such file or directory`, exitCode: 1 };
+                return {
+                    stderr: `sed: ${fileArg}: No such file or directory`,
+                    exitCode: 1,
+                };
             }
         }
         // Parse s/from/to/[g]
@@ -26,7 +30,11 @@ export const sedCommand = {
         if (!sMatch)
             return { stderr: `sed: unrecognized command: ${expr}`, exitCode: 1 };
         const [, , from, to, flags] = sMatch;
-        const regexFlags = (flags ?? "").includes("i") ? "gi" : (flags ?? "").includes("g") ? "g" : "";
+        const regexFlags = (flags ?? "").includes("i")
+            ? "gi"
+            : (flags ?? "").includes("g")
+                ? "g"
+                : "";
         let regex;
         try {
             regex = new RegExp(from, regexFlags || "");

package/dist/commands/set.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"set.d.ts","sourceRoot":"","sources":["../../src/commands/set.ts"],"names":[],"mappings":"AAAA,qEAAqE;AACrE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAWrD,mDAAmD;AACnD,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAA6B;AACxF,mDAAmD;AACnD,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAA8B;AAC1F,mDAAmD;AACnD,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAItE;AAED,eAAO,MAAM,UAAU,EAAE,WAkBxB,CAAC"}
+{"version":3,"file":"set.d.ts","sourceRoot":"","sources":["../../src/commands/set.ts"],"names":[],"mappings":"AAAA,qEAAqE;AACrE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAWrD,mDAAmD;AACnD,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAE1D;AACD,mDAAmD;AACnD,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAE3D;AACD,mDAAmD;AACnD,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAItE;AAED,eAAO,MAAM,UAAU,EAAE,WAoBxB,CAAC"}

package/dist/commands/set.js

@@ -7,9 +7,13 @@ const _globalEnv = {
     USER: "user",
 };
 /** @deprecated use env.vars from CommandContext */
-export function getEnvVar(name) { return _globalEnv[name]; }
+export function getEnvVar(name) {
+    return _globalEnv[name];
+}
 /** @deprecated use env.vars from CommandContext */
-export function setEnvVar(name, value) { _globalEnv[name] = value; }
+export function setEnvVar(name, value) {
+    _globalEnv[name] = value;
+}
 /** @deprecated use env.vars from CommandContext */
 export function getAllEnvVars(authUser) {
     _globalEnv.USER = authUser;
@@ -23,7 +27,9 @@ export const setCommand = {
     params: ["[VAR=value]"],
     run: ({ args, env }) => {
         if (args.length === 0) {
-            const out = Object.entries(env.vars).map(([k, v]) => `${k}=${v}`).join("\n");
+            const out = Object.entries(env.vars)
+                .map(([k, v]) => `${k}=${v}`)
+                .join("\n");
             return { stdout: out, exitCode: 0 };
         }
         for (const arg of args) {

package/dist/commands/sh.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sh.d.ts","sourceRoot":"","sources":["../../src/commands/sh.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAiC,WAAW,EAAE,MAAM,mBAAmB,CAAC;AA+KpF,eAAO,MAAM,SAAS,EAAE,WA+BvB,CAAC"}
+{"version":3,"file":"sh.d.ts","sourceRoot":"","sources":["../../src/commands/sh.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGR,WAAW,EACd,MAAM,mBAAmB,CAAC;AA4R3B,eAAO,MAAM,SAAS,EAAE,WA4CvB,CAAC"}