typescript-virtual-container 1.1.1-b → 1.1.1-c

package/dist/commands/index.js

@@ -0,0 +1,212 @@
+import { adduserCommand } from "./adduser";
+import { catCommand } from "./cat";
+import { cdCommand } from "./cd";
+import { clearCommand } from "./clear";
+import { curlCommand } from "./curl";
+import { deluserCommand } from "./deluser";
+import { echoCommand } from "./echo";
+import { envCommand } from "./env";
+import { exitCommand } from "./exit";
+import { exportCommand } from "./export";
+import { grepCommand } from "./grep";
+import { createHelpCommand } from "./help";
+import { hostnameCommand } from "./hostname";
+import { htopCommand } from "./htop";
+import { lsCommand } from "./ls";
+import { mkdirCommand } from "./mkdir";
+import { nanoCommand } from "./nano";
+import { neofetchCommand } from "./neofetch";
+import { pwdCommand } from "./pwd";
+import { rmCommand } from "./rm";
+import { setCommand } from "./set";
+import { shCommand } from "./sh";
+import { suCommand } from "./su";
+import { sudoCommand } from "./sudo";
+import { touchCommand } from "./touch";
+import { treeCommand } from "./tree";
+import { unsetCommand } from "./unset";
+import { wgetCommand } from "./wget";
+import { whoCommand } from "./who";
+import { whoamiCommand } from "./whoami";
+const BASE_COMMANDS = [
+    pwdCommand,
+    whoamiCommand,
+    whoCommand,
+    hostnameCommand,
+    lsCommand,
+    cdCommand,
+    catCommand,
+    echoCommand,
+    mkdirCommand,
+    touchCommand,
+    rmCommand,
+    treeCommand,
+    nanoCommand,
+    neofetchCommand,
+    htopCommand,
+    adduserCommand,
+    deluserCommand,
+    sudoCommand,
+    suCommand,
+    curlCommand,
+    envCommand,
+    wgetCommand,
+    grepCommand,
+    exportCommand,
+    setCommand,
+    unsetCommand,
+    shCommand,
+    clearCommand,
+    exitCommand,
+];
+const customCommands = [];
+const helpCommand = createHelpCommand(() => getCommandModules().map((cmd) => cmd.name));
+const commandRegistry = new Map();
+let cachedCommandNames = null;
+function buildCache() {
+    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() {
+    // console.log("Loading command modules...");
+    // console.log(
+    // 	`Base commands: ${BASE_COMMANDS.map((cmd) => cmd.name).join(", ")}`,
+    // );
+    // console.log(
+    // 	`Custom commands: ${customCommands.map((cmd) => cmd.name).join(", ")}`,
+    // );
+    return [...BASE_COMMANDS, ...customCommands, helpCommand];
+}
+export function registerCommand(module) {
+    const normalized = {
+        ...module,
+        name: module.name.trim().toLowerCase(),
+        aliases: module.aliases?.map((alias) => alias.trim().toLowerCase()),
+    };
+    const names = [normalized.name, ...(normalized.aliases ?? [])];
+    if (names.some((name) => name.length === 0 || /\s/.test(name))) {
+        throw new Error("Command names and aliases must be non-empty and contain no spaces");
+    }
+    for (const name of names) {
+        if (commandRegistry.has(name)) {
+            throw new Error(`Command '${name}' already exists`);
+        }
+        commandRegistry.set(name, normalized);
+    }
+    buildCache();
+}
+export function createCustomCommand(name, params, run) {
+    return {
+        name,
+        params,
+        run,
+    };
+}
+export function getCommandNames() {
+    if (!cachedCommandNames) {
+        buildCache();
+    }
+    return cachedCommandNames;
+}
+export function resolveModule(name) {
+    if (!cachedCommandNames) {
+        buildCache();
+    }
+    return commandRegistry.get(name.toLowerCase());
+}
+function splitArgsRespectingQuotes(input) {
+    const tokens = [];
+    let current = "";
+    let inQuotes = false;
+    let quoteChar = "";
+    for (let i = 0; i < input.length; i += 1) {
+        const ch = input[i] || "";
+        const prev = i > 0 ? input[i - 1] : "";
+        if ((ch === '"' || ch === "'") && prev !== "\\") {
+            if (!inQuotes) {
+                inQuotes = true;
+                quoteChar = ch;
+                continue;
+            }
+            if (ch === quoteChar) {
+                inQuotes = false;
+                quoteChar = "";
+                continue;
+            }
+        }
+        if (/\s/.test(ch) && !inQuotes) {
+            if (current.length > 0) {
+                tokens.push(current);
+                current = "";
+            }
+            continue;
+        }
+        current += ch;
+    }
+    if (current.length > 0) {
+        tokens.push(current);
+    }
+    return tokens;
+}
+function parseInput(rawInput) {
+    const parts = splitArgsRespectingQuotes(rawInput.trim());
+    return {
+        commandName: parts[0]?.toLowerCase() ?? "",
+        args: parts.slice(1),
+    };
+}
+// Internal async function for pipeline execution
+export async function runCommand(rawInput, authUser, hostname, mode, cwd, shell, stdin) {
+    const trimmed = rawInput.trim();
+    if (trimmed.length === 0) {
+        return { exitCode: 0 };
+    }
+    if (trimmed.includes("|") || trimmed.includes(">") || trimmed.includes("<")) {
+        const { parseShellPipeline } = await import("../VirtualShell/shellParser");
+        const { executePipeline } = await import("../SSHMimic/executor");
+        const pipeline = parseShellPipeline(trimmed);
+        if (!pipeline.isValid) {
+            return {
+                stderr: pipeline.error || "Syntax error",
+                exitCode: 1,
+            };
+        }
+        try {
+            return await executePipeline(pipeline, authUser, hostname, mode, cwd, shell);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "Pipeline execution failed";
+            return { stderr: message, exitCode: 1 };
+        }
+    }
+    const { commandName, args } = parseInput(trimmed);
+    const mod = resolveModule(commandName);
+    if (!mod) {
+        return {
+            stderr: `Command '${trimmed}' not found`,
+            exitCode: 127,
+        };
+    }
+    try {
+        return await mod.run({
+            authUser,
+            hostname,
+            activeSessions: shell.users.listActiveSessions(),
+            rawInput: trimmed,
+            mode,
+            args,
+            stdin,
+            cwd,
+            shell,
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Command failed";
+        return { stderr: message, exitCode: 1 };
+    }
+}

package/dist/commands/ls.d.ts

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

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

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

package/dist/commands/ls.js

@@ -0,0 +1,47 @@
+import { getArg, ifFlag } from "./command-helpers";
+import { assertPathAccess, joinListWithType, resolvePath } from "./helpers";
+function formatPermissions(mode, isDirectory) {
+    const fileType = isDirectory ? "d" : "-";
+    const permissionBits = [
+        [0o400, "r"],
+        [0o200, "w"],
+        [0o100, "x"],
+        [0o040, "r"],
+        [0o020, "w"],
+        [0o010, "x"],
+        [0o004, "r"],
+        [0o002, "w"],
+        [0o001, "x"],
+    ];
+    const permissions = permissionBits
+        .map(([bit, symbol]) => (mode & bit ? symbol : "-"))
+        .join("");
+    return `${fileType}${permissions}`;
+}
+function formatDate(date) {
+    return date.toISOString().replace("T", " ").slice(0, 16);
+}
+export const lsCommand = {
+    name: "ls",
+    params: ["[path]"],
+    run: ({ authUser, shell, cwd, args }) => {
+        const longFormat = ifFlag(args, ["-l", "--long"]);
+        const targetArg = getArg(args, 0, { flags: ["-l", "--long"] });
+        const target = resolvePath(cwd, targetArg ?? cwd);
+        assertPathAccess(authUser, target, "ls");
+        const items = shell.vfs
+            .list(target)
+            .filter((name) => !name.startsWith("."));
+        const rendered = longFormat
+            ? items
+                .map((name) => {
+                const childPath = resolvePath(target, name);
+                const stat = shell.vfs.stat(childPath);
+                const size = stat.type === "file" ? stat.size : stat.childrenCount;
+                return `${formatPermissions(stat.mode, stat.type === "directory")} 1 ${size} ${formatDate(stat.updatedAt)} ${name}${stat.type === "directory" ? "/" : ""}`;
+            })
+                .join("\n")
+            : joinListWithType(target, items, (p) => shell.vfs.stat(p));
+        return { stdout: rendered, exitCode: 0 };
+    },
+};

package/dist/commands/mkdir.d.ts

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

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

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

package/dist/commands/mkdir.js

@@ -0,0 +1,21 @@
+import { getArg } from "./command-helpers";
+import { assertPathAccess, resolvePath } from "./helpers";
+export const mkdirCommand = {
+    name: "mkdir",
+    params: ["<dir>"],
+    run: ({ authUser, shell, cwd, args }) => {
+        if (args.length === 0) {
+            return { stderr: "mkdir: missing operand", exitCode: 1 };
+        }
+        for (let index = 0; index < args.length; index++) {
+            const dir = getArg(args, index);
+            if (!dir) {
+                return { stderr: "mkdir: missing operand", exitCode: 1 };
+            }
+            const target = resolvePath(cwd, dir);
+            assertPathAccess(authUser, target, "mkdir");
+            shell.vfs.mkdir(target);
+        }
+        return { exitCode: 0 };
+    },
+};

package/dist/commands/nano.d.ts

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

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

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

package/dist/commands/nano.js

@@ -0,0 +1,27 @@
+import * as path from "node:path";
+import { assertPathAccess, resolvePath } from "./helpers";
+export const nanoCommand = {
+    name: "nano",
+    params: ["<file>"],
+    run: ({ authUser, shell, cwd, args }) => {
+        const fileArg = args[0];
+        if (!fileArg) {
+            return { stderr: "nano: missing file operand", exitCode: 1 };
+        }
+        const targetPath = resolvePath(cwd, fileArg);
+        assertPathAccess(authUser, targetPath, "nano");
+        const initialContent = shell.vfs.exists(targetPath)
+            ? shell.vfs.readFile(targetPath)
+            : "";
+        const safeName = path.posix.basename(targetPath) || "buffer";
+        const tempPath = `/tmp/sshmimic-nano-${Date.now()}-${safeName}.tmp`;
+        return {
+            openEditor: {
+                targetPath,
+                tempPath,
+                initialContent,
+            },
+            exitCode: 0,
+        };
+    },
+};

package/dist/commands/neofetch.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"neofetch.d.ts","sourceRoot":"","sources":["../../src/commands/neofetch.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAIrD,eAAO,MAAM,eAAe,EAAE,WA+B7B,CAAC"}

package/dist/commands/neofetch.js

@@ -0,0 +1,32 @@
+import { buildNeofetchOutput } from "../modules/neofetch";
+import { ifFlag } from "./command-helpers";
+import { getAllEnvVars } from "./set";
+export const neofetchCommand = {
+    name: "neofetch",
+    params: ["[--off]"],
+    run: ({ args, authUser, hostname, shell }) => {
+        const env = getAllEnvVars(authUser);
+        if (ifFlag(args, "--help")) {
+            return {
+                stdout: "Usage: neofetch [--off]",
+                exitCode: 0,
+            };
+        }
+        if (ifFlag(args, "--off")) {
+            return {
+                stdout: `${authUser}@${hostname}`,
+                exitCode: 0,
+            };
+        }
+        return {
+            stdout: buildNeofetchOutput({
+                user: authUser,
+                host: hostname,
+                shell: env.SHELL,
+                shellProps: shell.properties,
+                terminal: env.TERM,
+            }),
+            exitCode: 0,
+        };
+    },
+};

package/dist/commands/pwd.d.ts

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

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

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

package/dist/commands/pwd.js

@@ -0,0 +1,5 @@
+export const pwdCommand = {
+    name: "pwd",
+    params: [],
+    run: ({ cwd }) => ({ stdout: cwd, exitCode: 0 }),
+};

package/dist/commands/rm.d.ts

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

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

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

package/dist/commands/rm.js

@@ -0,0 +1,29 @@
+import { getArg, ifFlag } from "./command-helpers";
+import { assertPathAccess, resolvePath } from "./helpers";
+export const rmCommand = {
+    name: "rm",
+    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/dist/commands/set.d.ts

@@ -0,0 +1,7 @@
+/** biome-ignore-all lint/style/useNamingConvention: env variables */
+import type { ShellModule } from "../types/commands";
+export declare function getEnvVar(name: string): string | undefined;
+export declare function setEnvVar(name: string, value: string): void;
+export declare function getAllEnvVars(authUser: string): Record<string, string>;
+export declare const setCommand: ShellModule;
+//# sourceMappingURL=set.d.ts.map

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

@@ -0,0 +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;AAarD,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAE1D;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAE3D;AAED,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAItE;AAED,eAAO,MAAM,UAAU,EAAE,WA4CxB,CAAC"}

package/dist/commands/set.js

@@ -0,0 +1,64 @@
+import { getArg } from "./command-helpers";
+// Simple in-memory environment variables store
+// In a real implementation, this would be per-session/per-user
+const envVars = {
+    PATH: "/usr/local/bin:/usr/bin:/bin",
+    HOME: "/home/user",
+    SHELL: "/bin/sh",
+    TERM: "xterm-256color",
+    USER: "user",
+};
+export function getEnvVar(name) {
+    return envVars[name];
+}
+export function setEnvVar(name, value) {
+    envVars[name] = value;
+}
+export function getAllEnvVars(authUser) {
+    envVars.USER = authUser;
+    envVars.HOME = `/home/${authUser}`;
+    return { ...envVars };
+}
+export const setCommand = {
+    name: "set",
+    params: ["[VAR=value]"],
+    run: ({ args }) => {
+        // No arguments: display all environment variables
+        if (args.length === 0) {
+            const output = Object.entries(envVars)
+                .map(([key, value]) => `${key}=${value}`)
+                .sort()
+                .join("\n");
+            return { stdout: output, exitCode: 0 };
+        }
+        // Parse VAR=value format
+        const assignments = [];
+        for (let index = 0;; index += 1) {
+            const arg = getArg(args, index);
+            if (!arg) {
+                break;
+            }
+            if (arg.includes("=")) {
+                const [varName, varValue] = arg.split("=", 2);
+                if (varName && varValue !== undefined) {
+                    setEnvVar(varName, varValue);
+                    assignments.push(arg);
+                }
+            }
+            else {
+                // If no '=' present, display that specific variable
+                const value = getEnvVar(arg);
+                if (value !== undefined) {
+                    assignments.push(`${arg}=${value}`);
+                }
+                else {
+                    assignments.push(`${arg}: not set`);
+                }
+            }
+        }
+        return {
+            stdout: assignments.length > 0 ? assignments.join("\n") : "",
+            exitCode: 0,
+        };
+    },
+};

package/dist/commands/sh.d.ts

@@ -0,0 +1,4 @@
+import type { ShellModule } from "../types/commands";
+/** Simple shell script executor with basic variable support */
+export declare const shCommand: ShellModule;
+//# sourceMappingURL=sh.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sh.d.ts","sourceRoot":"","sources":["../../src/commands/sh.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAkB,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAIrE,+DAA+D;AAC/D,eAAO,MAAM,SAAS,EAAE,WAmDvB,CAAC"}

package/dist/commands/sh.js

@@ -0,0 +1,45 @@
+import { getArg, getFlag } from "./command-helpers";
+import { runCommand } from "./index";
+/** Simple shell script executor with basic variable support */
+export const shCommand = {
+    name: "sh",
+    params: ["-c <script>", "[<file>]"],
+    aliases: ["bash"],
+    run: async (ctx) => {
+        const { args, authUser, hostname, mode, cwd } = ctx;
+        // Handle -c option: sh -c "command"
+        if (getFlag(args, "-c") && args.length >= 2) {
+            const script = getArg(args, 1) ?? "";
+            if (!script) {
+                return { stderr: "sh: -c requires a script", exitCode: 1 };
+            }
+            const scriptArgs = args.slice(2);
+            // Split by semicolon and newline
+            const lines = script
+                .split(/[;\n]/)
+                .map((line) => line.trim())
+                .filter((line) => line && !line.startsWith("#"));
+            let output = "";
+            const exitCode = 0;
+            for (const line of lines) {
+                // Simple variable substitution
+                let command = line;
+                for (let i = 0; i < scriptArgs.length; i++) {
+                    const arg = scriptArgs[i] ?? "";
+                    command = command.replaceAll(`$${i}`, arg);
+                }
+                command = command.replaceAll("$@", scriptArgs.join(" "));
+                // Execute the command
+                const result = await Promise.resolve(runCommand(command, authUser, hostname, mode, cwd, ctx.shell));
+                if (result.stdout) {
+                    output += `${result.stdout}\n`;
+                }
+                if (result.stderr) {
+                    return { stderr: result.stderr, exitCode: result.exitCode ?? 1 };
+                }
+            }
+            return { stdout: output.trim(), exitCode };
+        }
+        return { stderr: "sh: invalid usage", exitCode: 1 };
+    },
+};

package/dist/commands/su.d.ts

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

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

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

package/dist/commands/su.js

@@ -0,0 +1,24 @@
+import { getArg } from "./command-helpers";
+export const suCommand = {
+    name: "su",
+    params: ["- <username>"],
+    run: ({ authUser, shell, args }) => {
+        const users = shell.users;
+        const targetUser = getArg(args, 0, { flags: ["-"] });
+        if (!targetUser) {
+            return { stderr: "su: missing username", exitCode: 1 };
+        }
+        if (!users.isSudoer(authUser) && authUser !== "root") {
+            return { stderr: "su: permission denied", exitCode: 1 };
+        }
+        if (!users.verifyPassword(targetUser, getArg(args, 1) ?? "") &&
+            authUser !== "root") {
+            return { stderr: "su: authentication failure", exitCode: 1 };
+        }
+        return {
+            switchUser: targetUser,
+            nextCwd: `/home/${targetUser}`,
+            exitCode: 0,
+        };
+    },
+};

package/dist/commands/sudo.d.ts

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

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

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

package/dist/commands/sudo.js

@@ -0,0 +1,47 @@
+import { parseArgs } from "./command-helpers";
+import { runCommand } from "./index";
+function parseSudoArgs(args) {
+    const { flags, flagsWithValues, positionals } = parseArgs(args, {
+        flags: ["-i", "-S"],
+        flagsWithValue: ["-u", "--user"],
+    });
+    const loginShell = flags.has("-i");
+    const targetUser = flagsWithValues.get("-u") || flagsWithValues.get("--user") || "root";
+    const commandLine = positionals.length > 0 ? positionals.join(" ") : null;
+    return { targetUser, loginShell, commandLine };
+}
+export const sudoCommand = {
+    name: "sudo",
+    params: ["<command...>"],
+    run: async ({ authUser, hostname, mode, cwd, shell, args }) => {
+        const { targetUser, loginShell, commandLine } = parseSudoArgs(args);
+        if (authUser !== "root" && !shell.users.isSudoer(authUser)) {
+            return { stderr: "sudo: permission denied", exitCode: 1 };
+        }
+        const effectiveUser = targetUser || "root";
+        const prompt = `[sudo] password for ${authUser}: `;
+        if (authUser === "root") {
+            if (!commandLine && loginShell) {
+                return {
+                    switchUser: effectiveUser,
+                    nextCwd: `/home/${effectiveUser}`,
+                    exitCode: 0,
+                };
+            }
+            if (!commandLine) {
+                return { stderr: "sudo: missing command", exitCode: 1 };
+            }
+            return runCommand(commandLine, effectiveUser, hostname, mode, loginShell ? `/home/${effectiveUser}` : cwd, shell);
+        }
+        return {
+            sudoChallenge: {
+                username: authUser,
+                targetUser: effectiveUser,
+                commandLine,
+                loginShell,
+                prompt,
+            },
+            exitCode: 0,
+        };
+    },
+};

package/dist/commands/touch.d.ts

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

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

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