typescript-virtual-container 1.2.7 → 1.2.9

package/dist/commands/source.js

@@ -0,0 +1,31 @@
+import { resolvePath } from "./helpers";
+import { runCommand } from ".";
+export const sourceCommand = {
+    name: "source",
+    aliases: ["."],
+    description: "Execute commands from a file in the current shell environment",
+    category: "shell",
+    params: ["<file> [args...]"],
+    run: async ({ args, authUser, hostname, cwd, shell, env }) => {
+        const fileArg = args[0];
+        if (!fileArg) {
+            return { stderr: "source: missing filename", exitCode: 1 };
+        }
+        const filePath = resolvePath(cwd, fileArg);
+        if (!shell.vfs.exists(filePath)) {
+            return { stderr: `source: ${fileArg}: No such file or directory`, exitCode: 1 };
+        }
+        const content = shell.vfs.readFile(filePath);
+        let lastExitCode = 0;
+        for (const line of content.split("\n")) {
+            const l = line.trim();
+            if (!l || l.startsWith("#"))
+                continue;
+            const result = await runCommand(l, authUser, hostname, "shell", cwd, shell, undefined, env);
+            lastExitCode = result.exitCode ?? 0;
+            if (result.closeSession || result.switchUser)
+                return result;
+        }
+        return { exitCode: lastExitCode };
+    },
+};

package/dist/commands/test.d.ts

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

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

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

package/dist/commands/test.js

@@ -0,0 +1,92 @@
+/**
+ * Evaluate a POSIX test expression.
+ * Supports: -f, -d, -e, -r, -w, -x, -s, -z, -n,
+ *           string =, !=, numeric -eq -ne -lt -le -gt -ge,
+ *           ! (negate), -a (and), -o (or).
+ */
+function evalTest(tokens, shell, cwd) {
+    // When called via [ command, ] is the last arg — strip it
+    // When called via test command, no brackets present
+    if (tokens[tokens.length - 1] === "]") {
+        tokens = tokens.slice(0, -1);
+    }
+    // Also strip leading [ if present (shouldn't normally happen but be safe)
+    if (tokens[0] === "[") {
+        tokens = tokens.slice(1);
+    }
+    if (tokens.length === 0)
+        return false;
+    // Negation
+    if (tokens[0] === "!")
+        return !evalTest(tokens.slice(1), shell, cwd);
+    // Boolean -a / -o (simple left-right, no precedence)
+    const andIdx = tokens.indexOf("-a");
+    if (andIdx !== -1) {
+        return evalTest(tokens.slice(0, andIdx), shell, cwd) &&
+            evalTest(tokens.slice(andIdx + 1), shell, cwd);
+    }
+    const orIdx = tokens.indexOf("-o");
+    if (orIdx !== -1) {
+        return evalTest(tokens.slice(0, orIdx), shell, cwd) ||
+            evalTest(tokens.slice(orIdx + 1), shell, cwd);
+    }
+    // Unary file tests
+    if (tokens.length === 2) {
+        const [flag, operand = ""] = tokens;
+        const resolvePath = (p) => p.startsWith("/") ? p : `${cwd}/${p}`.replace(/\/+/g, "/");
+        const path = resolvePath(operand);
+        switch (flag) {
+            case "-e": return shell.vfs.exists(path);
+            case "-f": return shell.vfs.exists(path) && shell.vfs.stat(path).type === "file";
+            case "-d": return shell.vfs.exists(path) && shell.vfs.stat(path).type === "directory";
+            case "-r": return shell.vfs.exists(path); // all readable in virtual env
+            case "-w": return shell.vfs.exists(path);
+            case "-x": return shell.vfs.exists(path) && !!(shell.vfs.stat(path).mode & 0o111);
+            case "-s": return shell.vfs.exists(path) && shell.vfs.stat(path).type === "file" && shell.vfs.stat(path).size > 0;
+            case "-z": return operand.length === 0;
+            case "-n": return operand.length > 0;
+            case "-L": return shell.vfs.isSymlink(path);
+        }
+    }
+    // Binary comparisons
+    if (tokens.length === 3) {
+        const [left = "", op, right = ""] = tokens;
+        const leftN = Number(left);
+        const rightN = Number(right);
+        switch (op) {
+            // String
+            case "=":
+            case "==": return left === right;
+            case "!=": return left !== right;
+            case "<": return left < right;
+            case ">": return left > right;
+            // Numeric
+            case "-eq": return leftN === rightN;
+            case "-ne": return leftN !== rightN;
+            case "-lt": return leftN < rightN;
+            case "-le": return leftN <= rightN;
+            case "-gt": return leftN > rightN;
+            case "-ge": return leftN >= rightN;
+        }
+    }
+    // Single string (truthy if non-empty)
+    if (tokens.length === 1)
+        return (tokens[0] ?? "").length > 0;
+    return false;
+}
+export const testCommand = {
+    name: "test",
+    aliases: ["["],
+    description: "Evaluate conditional expression",
+    category: "shell",
+    params: ["<expression>"],
+    run: ({ args, shell, cwd }) => {
+        try {
+            const result = evalTest([...args], shell, cwd);
+            return { exitCode: result ? 0 : 1 };
+        }
+        catch {
+            return { stderr: "test: malformed expression", exitCode: 2 };
+        }
+    },
+};

package/dist/commands/type.d.ts

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

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

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

package/dist/commands/type.js

@@ -0,0 +1,34 @@
+import { resolveModule } from ".";
+export const typeCommand = {
+    name: "type",
+    description: "Describe how a command would be interpreted",
+    category: "shell",
+    params: ["<command...>"],
+    run: ({ args, shell, env }) => {
+        if (args.length === 0)
+            return { stderr: "type: missing argument", exitCode: 1 };
+        const pathDirs = (env?.vars?.PATH ?? "/usr/local/bin:/usr/bin:/bin").split(":");
+        const lines = [];
+        let exitCode = 0;
+        for (const name of args) {
+            if (resolveModule(name)) {
+                lines.push(`${name} is a shell builtin`);
+                continue;
+            }
+            let found = false;
+            for (const dir of pathDirs) {
+                const full = `${dir}/${name}`;
+                if (shell.vfs.exists(full)) {
+                    lines.push(`${name} is ${full}`);
+                    found = true;
+                    break;
+                }
+            }
+            if (!found) {
+                lines.push(`${name}: not found`);
+                exitCode = 1;
+            }
+        }
+        return { stdout: lines.join("\n"), exitCode };
+    },
+};

package/dist/commands/uptime.d.ts

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

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

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

package/dist/commands/uptime.js

@@ -0,0 +1,40 @@
+import { ifFlag } from "./command-helpers";
+export const uptimeCommand = {
+    name: "uptime",
+    description: "Tell how long the system has been running",
+    category: "system",
+    params: ["[-p] [-s]"],
+    run: ({ args, shell }) => {
+        const pretty = ifFlag(args, ["-p"]);
+        const since = ifFlag(args, ["-s"]);
+        const uptimeSec = Math.floor((Date.now() - shell.startTime) / 1000);
+        const days = Math.floor(uptimeSec / 86400);
+        const hours = Math.floor((uptimeSec % 86400) / 3600);
+        const mins = Math.floor((uptimeSec % 3600) / 60);
+        if (since) {
+            return {
+                stdout: new Date(shell.startTime).toISOString().slice(0, 19).replace("T", " "),
+                exitCode: 0,
+            };
+        }
+        if (pretty) {
+            const parts = [];
+            if (days > 0)
+                parts.push(`${days} day${days > 1 ? "s" : ""}`);
+            if (hours > 0)
+                parts.push(`${hours} hour${hours > 1 ? "s" : ""}`);
+            parts.push(`${mins} minute${mins !== 1 ? "s" : ""}`);
+            return { stdout: `up ${parts.join(", ")}`, exitCode: 0 };
+        }
+        const timeStr = new Date().toTimeString().slice(0, 8);
+        const uptimeStr = days > 0
+            ? `${days} day${days > 1 ? "s" : ""}, ${String(hours).padStart(2)}:${String(mins).padStart(2, "0")}`
+            : `${String(hours).padStart(2)}:${String(mins).padStart(2, "0")}`;
+        const sessions = shell.users.listActiveSessions().length;
+        const load = (Math.random() * 0.5).toFixed(2);
+        return {
+            stdout: ` ${timeStr} up ${uptimeStr},  ${sessions} user${sessions !== 1 ? "s" : ""},  load average: ${load}, ${load}, ${load}`,
+            exitCode: 0,
+        };
+    },
+};

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

@@ -1 +1 @@
-{"version":3,"file":"wget.d.ts","sourceRoot":"","sources":["../../src/commands/wget.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AA8ErD,eAAO,MAAM,WAAW,EAAE,WA+DzB,CAAC"}
+{"version":3,"file":"wget.d.ts","sourceRoot":"","sources":["../../src/commands/wget.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAIrD,eAAO,MAAM,WAAW,EAAE,WAwFzB,CAAC"}

package/dist/commands/wget.js

@@ -1,115 +1,86 @@
-import { spawn } from "node:child_process";
-import { mkdtemp, readFile, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
 import { ifFlag, parseArgs } from "./command-helpers";
-import { assertPathAccess, normalizeTerminalOutput, resolvePath, runHostCommand, stripUrlFilename, } from "./helpers";
-function runHostWget(args) {
-    return new Promise((resolve) => {
-        let childProcess;
-        try {
-            childProcess = spawn("wget", args, {
-                stdio: ["ignore", "pipe", "pipe"],
-            });
-        }
-        catch (error) {
-            resolve({
-                stdout: "",
-                stderr: `wget: ${error instanceof Error ? error.message : String(error)}`,
-                exitCode: 1,
-            });
-            return;
-        }
-        let stdout = "";
-        let stderr = "";
-        const stdoutStream = childProcess.stdout;
-        const stderrStream = childProcess.stderr;
-        if (!stdoutStream || !stderrStream) {
-            resolve({
-                stdout: "",
-                stderr: "wget: failed to capture process output",
-                exitCode: 1,
-            });
-            return;
-        }
-        stdoutStream.setEncoding("utf8");
-        stderrStream.setEncoding("utf8");
-        stdoutStream.on("data", (chunk) => {
-            stdout += chunk;
-        });
-        stderrStream.on("data", (chunk) => {
-            stderr += chunk;
-        });
-        childProcess.on("error", (error) => {
-            const errorCode = error instanceof Error && "code" in error
-                ? String(error.code ?? "")
-                : "";
-            resolve({
-                stdout: "",
-                stderr: `wget: ${error.message}`,
-                exitCode: errorCode === "ENOENT" ? 127 : 1,
-            });
-        });
-        childProcess.on("close", (code) => {
-            resolve({
-                stdout,
-                stderr,
-                exitCode: code ?? 1,
-            });
-        });
-    });
-}
+import { assertPathAccess, resolvePath, stripUrlFilename } from "./helpers";
 export const wgetCommand = {
     name: "wget",
-    description: "File downloader",
+    description: "File downloader (pure fetch)",
     category: "network",
-    params: ["[url]"],
+    params: ["[options] <url>"],
     run: async ({ authUser, cwd, args, shell }) => {
         const { flagsWithValues, positionals } = parseArgs(args, {
-            flagsWithValue: ["-o", "-O", "--output", "--output-document"],
+            flagsWithValue: ["-O", "--output-document", "-o", "--output-file", "-P", "--directory-prefix", "--tries", "--timeout"],
         });
-        const outputPath = flagsWithValues.get("-o") ||
-            flagsWithValues.get("-O") ||
-            flagsWithValues.get("--output") ||
-            flagsWithValues.get("--output-document") ||
-            null;
-        const url = positionals[0];
-        if (!url) {
-            return { stderr: "wget: missing URL", exitCode: 1 };
-        }
-        const isHelpLike = ifFlag(args, ["-h", "--help", "-V", "--version"]);
-        if (isHelpLike) {
-            const result = await runHostWget(args);
+        if (ifFlag(args, ["-h", "--help"])) {
             return {
-                stdout: normalizeTerminalOutput(result.stdout),
-                stderr: result.stderr
-                    ? normalizeTerminalOutput(result.stderr)
-                    : undefined,
-                exitCode: result.exitCode,
+                stdout: [
+                    "Usage: wget [option]... [URL]...",
+                    "  -O, --output-document=FILE  Write to FILE ('-' for stdout)",
+                    "  -P, --directory-prefix=DIR  Save files in DIR",
+                    "  -q, --quiet                 Quiet mode",
+                    "  -v, --verbose               Verbose output (default)",
+                    "  -c, --continue              Continue partial download",
+                    "  --tries=N                   Retry N times",
+                    "  --timeout=N                 Timeout in seconds",
+                ].join("\n"),
+                exitCode: 0,
             };
         }
-        const tempDir = await mkdtemp(join(tmpdir(), "virtual-env-js-wget-"));
-        const tempFile = join(tempDir, "download");
+        if (ifFlag(args, ["-V", "--version"])) {
+            return { stdout: "GNU Wget 1.21.3 (virtual) built on Fortune GNU/Linux.", exitCode: 0 };
+        }
+        const url = positionals[0];
+        if (!url)
+            return { stderr: "wget: missing URL\nUsage: wget [OPTION]... [URL]...", exitCode: 1 };
+        const outputArg = flagsWithValues.get("-O") ?? flagsWithValues.get("--output-document") ?? null;
+        const dirPrefix = flagsWithValues.get("-P") ?? flagsWithValues.get("--directory-prefix") ?? null;
+        const quiet = ifFlag(args, ["-q", "--quiet"]);
+        // Derive target filename
+        const filename = outputArg === "-" ? null : (outputArg ?? stripUrlFilename(url));
+        const targetPath = filename
+            ? resolvePath(cwd, dirPrefix ? `${dirPrefix}/${filename}` : filename)
+            : null;
+        if (targetPath)
+            assertPathAccess(authUser, targetPath, "wget");
+        const stderrLines = [];
+        if (!quiet) {
+            stderrLines.push(`--${new Date().toISOString()}--  ${url}`);
+            stderrLines.push(`Resolving ${new URL(url).host}...`);
+            stderrLines.push(`Connecting to ${new URL(url).host}...`);
+        }
+        let response;
         try {
-            const hostArgs = [...positionals, "-O", tempFile];
-            const result = await runHostCommand("wget", hostArgs);
-            if (result.exitCode !== 0) {
-                return {
-                    stderr: normalizeTerminalOutput(result.stderr || `wget: exited with code ${result.exitCode}`),
-                    exitCode: result.exitCode,
-                };
-            }
-            const content = await readFile(tempFile, "utf8");
-            const target = resolvePath(cwd, outputPath || stripUrlFilename(url));
-            assertPathAccess(authUser, target, "wget");
-            shell.writeFileAsUser(authUser, target, content);
-            return {
-                stdout: `saved ${target}`,
-                exitCode: 0,
-            };
+            response = await fetch(url, { headers: { "User-Agent": "Wget/1.21.3 (Fortune GNU/Linux)" } });
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            stderrLines.push(`wget: unable to resolve host: ${msg}`);
+            return { stderr: stderrLines.join("\n"), exitCode: 4 };
+        }
+        if (!response.ok) {
+            stderrLines.push(`ERROR ${response.status}: ${response.statusText}`);
+            return { stderr: stderrLines.join("\n"), exitCode: 8 };
+        }
+        let body;
+        try {
+            body = await response.text();
+        }
+        catch {
+            return { stderr: "wget: failed to read response", exitCode: 1 };
+        }
+        if (!quiet) {
+            const ct = response.headers.get("content-type") ?? "application/octet-stream";
+            stderrLines.push(`HTTP request sent, awaiting response... ${response.status} ${response.statusText}`);
+            stderrLines.push(`Length: ${body.length} [${ct}]`);
+        }
+        // Output to stdout (pipe) or file
+        if (outputArg === "-") {
+            return { stdout: body, stderr: stderrLines.join("\n") || undefined, exitCode: 0 };
         }
-        finally {
-            await rm(tempDir, { recursive: true, force: true });
+        if (targetPath) {
+            shell.writeFileAsUser(authUser, targetPath, body);
+            if (!quiet)
+                stderrLines.push(`Saving to: '${targetPath}'\n${targetPath}            100%[==================>]  ${body.length} B`);
+            return { stderr: stderrLines.join("\n") || undefined, exitCode: 0 };
         }
+        return { stdout: body, exitCode: 0 };
     },
 };

package/dist/commands/which.d.ts

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

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

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

package/dist/commands/which.js

@@ -0,0 +1,32 @@
+export const whichCommand = {
+    name: "which",
+    description: "Locate a command in PATH",
+    category: "shell",
+    params: ["<command...>"],
+    run: ({ args, shell, env }) => {
+        if (args.length === 0)
+            return { stderr: "which: missing argument", exitCode: 1 };
+        const pathDirs = (env?.vars?.PATH ?? "/usr/local/bin:/usr/bin:/bin").split(":");
+        const lines = [];
+        let anyMissing = false;
+        for (const name of args) {
+            let found = false;
+            for (const dir of pathDirs) {
+                const full = `${dir}/${name}`;
+                if (shell.vfs.exists(full)) {
+                    const st = shell.vfs.stat(full);
+                    if (st.type === "file") {
+                        lines.push(full);
+                        found = true;
+                        break;
+                    }
+                }
+            }
+            if (!found)
+                anyMissing = true;
+        }
+        if (lines.length === 0)
+            return { exitCode: 1 };
+        return { stdout: lines.join("\n"), exitCode: anyMissing ? 1 : 0 };
+    },
+};

package/dist/index.d.ts

@@ -4,11 +4,14 @@ import { SftpMimic, SshMimic } from "./SSHMimic/index";
 import VirtualFileSystem from "./VirtualFileSystem/index";
 import { VirtualShell } from "./VirtualShell/index";
 import { VirtualUserManager } from "./VirtualUserManager/index";
+import { VirtualPackageManager } from "./VirtualPackageManager/index";
 export type { AuditLogEntry, HoneyPotStats, } from "./Honeypot/index";
-export type { CommandContext, CommandMode, CommandOutcome, CommandResult, NanoEditorSession, ShellModule, SudoChallenge, } from "./types/commands";
+export type { CommandContext, CommandMode, CommandOutcome, CommandResult, NanoEditorSession, ShellEnv, ShellModule, SudoChallenge, } from "./types/commands";
+export type { ShellProperties } from "./VirtualShell/index";
 export type { ExecStream, ShellStream } from "./types/streams";
 export type { RemoveOptions, VfsBaseNode, VfsDirectoryNode, VfsFileNode, VfsNodeStats, VfsNodeType, VfsSnapshot, VfsSnapshotBaseNode, VfsSnapshotDirectoryNode, VfsSnapshotFileNode, VfsSnapshotNode, WriteFileOptions, } from "./types/vfs";
 export type { VfsOptions, VfsPersistenceMode } from "./VirtualFileSystem/index";
-export { HoneyPot, SshClient, VirtualFileSystem, SftpMimic as VirtualSftpServer, VirtualShell, SshMimic as VirtualSshServer, VirtualUserManager, };
+export type { PackageDefinition, PackageFile, InstalledPackage, } from "./VirtualPackageManager/index";
+export { HoneyPot, SshClient, VirtualFileSystem, SftpMimic as VirtualSftpServer, VirtualShell, SshMimic as VirtualSshServer, VirtualUserManager, VirtualPackageManager, };
 export { getArg, getFlag, ifFlag, } from "./commands/command-helpers";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAC5C,OAAO,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAC9C,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,iBAAiB,MAAM,2BAA2B,CAAC;AAC1D,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACpD,OAAO,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAEhE,YAAY,EACX,aAAa,EACb,aAAa,GACb,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EACX,cAAc,EACd,WAAW,EACX,cAAc,EACd,aAAa,EACb,iBAAiB,EACjB,WAAW,EACX,aAAa,GACb,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAC/D,YAAY,EACX,aAAa,EACb,WAAW,EACX,gBAAgB,EAChB,WAAW,EACX,YAAY,EACZ,WAAW,EACX,WAAW,EACX,mBAAmB,EACnB,wBAAwB,EACxB,mBAAmB,EACnB,eAAe,EACf,gBAAgB,GAChB,MAAM,aAAa,CAAC;AACrB,YAAY,EAAE,UAAU,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAEhF,OAAO,EACN,QAAQ,EACR,SAAS,EACT,iBAAiB,EACjB,SAAS,IAAI,iBAAiB,EAC9B,YAAY,EACZ,QAAQ,IAAI,gBAAgB,EAC5B,kBAAkB,GAClB,CAAC;AAEF,OAAO,EACN,MAAM,EACN,OAAO,EACP,MAAM,GACN,MAAM,4BAA4B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAC5C,OAAO,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAC9C,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,iBAAiB,MAAM,2BAA2B,CAAC;AAC1D,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACpD,OAAO,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AAEtE,YAAY,EACX,aAAa,EACb,aAAa,GACb,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EACX,cAAc,EACd,WAAW,EACX,cAAc,EACd,aAAa,EACb,iBAAiB,EACjB,QAAQ,EACR,WAAW,EACX,aAAa,GACb,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC5D,YAAY,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAC/D,YAAY,EACX,aAAa,EACb,WAAW,EACX,gBAAgB,EAChB,WAAW,EACX,YAAY,EACZ,WAAW,EACX,WAAW,EACX,mBAAmB,EACnB,wBAAwB,EACxB,mBAAmB,EACnB,eAAe,EACf,gBAAgB,GAChB,MAAM,aAAa,CAAC;AACrB,YAAY,EAAE,UAAU,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAEhF,YAAY,EACX,iBAAiB,EACjB,WAAW,EACX,gBAAgB,GAChB,MAAM,+BAA+B,CAAC;AAEvC,OAAO,EACN,QAAQ,EACR,SAAS,EACT,iBAAiB,EACjB,SAAS,IAAI,iBAAiB,EAC9B,YAAY,EACZ,QAAQ,IAAI,gBAAgB,EAC5B,kBAAkB,EAClB,qBAAqB,GACrB,CAAC;AAEF,OAAO,EACN,MAAM,EACN,OAAO,EACP,MAAM,GACN,MAAM,4BAA4B,CAAC"}

package/dist/index.js

@@ -4,5 +4,6 @@ import { SftpMimic, SshMimic } from "./SSHMimic/index";
 import VirtualFileSystem from "./VirtualFileSystem/index";
 import { VirtualShell } from "./VirtualShell/index";
 import { VirtualUserManager } from "./VirtualUserManager/index";
-export { HoneyPot, SshClient, VirtualFileSystem, SftpMimic as VirtualSftpServer, VirtualShell, SshMimic as VirtualSshServer, VirtualUserManager, };
+import { VirtualPackageManager } from "./VirtualPackageManager/index";
+export { HoneyPot, SshClient, VirtualFileSystem, SftpMimic as VirtualSftpServer, VirtualShell, SshMimic as VirtualSshServer, VirtualUserManager, VirtualPackageManager, };
 export { getArg, getFlag, ifFlag, } from "./commands/command-helpers";

package/dist/modules/linuxRootfs.d.ts

@@ -0,0 +1,24 @@
+/**
+ * linuxRootfs.ts
+ *
+ * Bootstraps a realistic Linux directory hierarchy in the VFS.
+ * Called once during VirtualShell initialization. Idempotent — skips
+ * paths that already exist so FS-mode snapshots survive restarts.
+ */
+import type { ShellProperties } from "../VirtualShell";
+import type VirtualFileSystem from "../VirtualFileSystem";
+import type { VirtualUserManager } from "../VirtualUserManager";
+export declare function syncEtcPasswd(vfs: VirtualFileSystem, users: VirtualUserManager): void;
+export declare function refreshProc(vfs: VirtualFileSystem, props: ShellProperties, hostname: string, shellStartTime: number): void;
+/**
+ * Bootstraps the full Linux rootfs hierarchy in the VFS.
+ * Safe to call multiple times — idempotent.
+ *
+ * @param vfs Target virtual filesystem.
+ * @param users User manager (for /etc/passwd sync).
+ * @param hostname Virtual hostname.
+ * @param props Shell properties (kernel, os, arch).
+ * @param shellStartTime Unix ms of shell creation (for uptime).
+ */
+export declare function bootstrapLinuxRootfs(vfs: VirtualFileSystem, users: VirtualUserManager, hostname: string, props: ShellProperties, shellStartTime: number): void;
+//# sourceMappingURL=linuxRootfs.d.ts.map

package/dist/modules/linuxRootfs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"linuxRootfs.d.ts","sourceRoot":"","sources":["../../src/modules/linuxRootfs.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,KAAK,iBAAiB,MAAM,sBAAsB,CAAC;AAC1D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAyHhE,wBAAgB,aAAa,CAC5B,GAAG,EAAE,iBAAiB,EACtB,KAAK,EAAE,kBAAkB,GACvB,IAAI,CAsCN;AAID,wBAAgB,WAAW,CAC1B,GAAG,EAAE,iBAAiB,EACtB,KAAK,EAAE,eAAe,EACtB,QAAQ,EAAE,MAAM,EAChB,cAAc,EAAE,MAAM,GACpB,IAAI,CA6DN;AAuKD;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CACnC,GAAG,EAAE,iBAAiB,EACtB,KAAK,EAAE,kBAAkB,EACzB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,eAAe,EACtB,cAAc,EAAE,MAAM,GACpB,IAAI,CAYN"}