typescript-virtual-container 1.4.4 → 1.4.5

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

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

package/src/commands/read.js

@@ -1,39 +0,0 @@
-import { ifFlag } from "./command-helpers";
-/**
- * Read a line from stdin into one or more variables.
- * @category shell
- * @params ["[-r] [-p prompt] <var...>"]
- */
-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/src/commands/registry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["registry.ts"],"names":[],"mappings":"AAAA,qEAAqE;AACrE,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAqNpF,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/src/commands/registry.js

@@ -1,234 +0,0 @@
-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, readlinkCommand } from "./ln";
-import { seqCommand } from "./seq";
-import { statCommand } from "./stat";
-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,
-    readlinkCommand,
-    chmodCommand,
-    seqCommand,
-    statCommand,
-    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/src/commands/rm.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"rm.d.ts","sourceRoot":"","sources":["rm.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAIrD;;;;GAIG;AACH,eAAO,MAAM,SAAS,EAAE,WAgCvB,CAAC"}

package/src/commands/rm.js

@@ -1,36 +0,0 @@
-import { getArg, ifFlag } from "./command-helpers";
-import { assertPathAccess, resolvePath } from "./helpers";
-/**
- * Remove files or directories from the filesystem.
- * @category files
- * @params ["[-r|-rf] <path>"]
- */
-export const rmCommand = {
-    name: "rm",
-    description: "Remove files or directories",
-    category: "files",
-    params: ["[-r|-rf] <path>"],
-    run: ({ authUser, shell, cwd, args }) => {
-        if (args.length === 0) {
-            return { stderr: "rm: missing operand", exitCode: 1 };
-        }
-        const recursive = ifFlag(args, ["-r", "-rf", "-fr"]);
-        const targets = [];
-        for (let index = 0;; index += 1) {
-            const target = getArg(args, index, { flags: ["-r", "-rf", "-fr"] });
-            if (!target) {
-                break;
-            }
-            targets.push(target);
-        }
-        if (targets.length === 0) {
-            return { stderr: "rm: missing operand", exitCode: 1 };
-        }
-        for (const target of targets) {
-            const resolvedTarget = resolvePath(cwd, target);
-            assertPathAccess(authUser, resolvedTarget, "rm");
-            shell.vfs.remove(resolvedTarget, { recursive });
-        }
-        return { exitCode: 0 };
-    },
-};

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

@@ -1 +0,0 @@
-{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["runtime.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAEpD,OAAO,KAAK,EACX,WAAW,EACX,aAAa,EACb,QAAQ,EACR,MAAM,mBAAmB,CAAC;AAK3B,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,CAkHxB;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,CAyKxB"}

package/src/commands/runtime.js

@@ -1,285 +0,0 @@
-/** 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 { tokenizeCommand } from "../utils/tokenize";
-import { resolveModule } from "./registry";
-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 assignRe = /^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/;
-    const invocation = [name, ...args];
-    let assignCount = 0;
-    while (assignCount < invocation.length && assignRe.test(invocation[assignCount])) {
-        assignCount += 1;
-    }
-    if (assignCount > 0) {
-        const assignments = invocation.slice(0, assignCount).map((token) => token.match(assignRe));
-        const remaining = invocation.slice(assignCount);
-        const restored = [];
-        for (const [, key, value] of assignments) {
-            restored.push([key, env.vars[key]]);
-            env.vars[key] = value;
-        }
-        if (remaining.length === 0) {
-            return { exitCode: 0 };
-        }
-        try {
-            const result = await runCommandDirect(remaining[0], remaining.slice(1), authUser, hostname, mode, cwd, shell, stdin, env);
-            return result;
-        }
-        finally {
-            for (const [key, value] of restored) {
-                if (value === undefined)
-                    delete env.vars[key];
-                else
-                    env.vars[key] = value;
-            }
-        }
-    }
-    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;
-    // 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,
-            };
-        }
-    }
-    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({
-                        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/src/commands/sed.d.ts.map

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

package/src/commands/sed.js

@@ -1,60 +0,0 @@
-import { getFlag, ifFlag } from "./command-helpers";
-import { resolvePath } from "./helpers";
-/**
- * Stream editor for filtering and transforming text lines.
- * @category text
- * @params ["-e <expr> [file]", "s/pattern/replace/[g]"]
- */
-export const sedCommand = {
-    name: "sed",
-    description: "Stream editor for filtering and transforming text",
-    category: "text",
-    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 fileArg = args.filter((a) => !a.startsWith("-") && a !== expr).pop();
-        if (!expr)
-            return { stderr: "sed: no expression", exitCode: 1 };
-        let content = stdin ?? "";
-        if (fileArg) {
-            const p = resolvePath(cwd, fileArg);
-            try {
-                content = shell.vfs.readFile(p);
-            }
-            catch {
-                return {
-                    stderr: `sed: ${fileArg}: No such file or directory`,
-                    exitCode: 1,
-                };
-            }
-        }
-        // Parse s/from/to/[g]
-        const sMatch = expr.match(/^s([^a-zA-Z0-9])(.+?)\1(.*?)\1([gi]*)$/);
-        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"
-                : "";
-        let regex;
-        try {
-            regex = new RegExp(from, regexFlags || "");
-        }
-        catch (_e) {
-            return { stderr: `sed: invalid regex: ${from}`, exitCode: 1 };
-        }
-        const result = (flags ?? "").includes("g") || regexFlags.includes("g")
-            ? content.replace(regex, to ?? "")
-            : content.replace(regex, to ?? "");
-        if (inPlace && fileArg) {
-            const p = resolvePath(cwd, fileArg);
-            shell.writeFileAsUser(authUser, p, result);
-            return { exitCode: 0 };
-        }
-        return { stdout: result, exitCode: 0 };
-    },
-};

package/src/commands/seq.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"seq.d.ts","sourceRoot":"","sources":["seq.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD,0FAA0F;AAC1F,eAAO,MAAM,UAAU,EAAE,WAuCxB,CAAC"}