typescript-virtual-container 1.4.4 → 1.4.5

package/tests/parser-executor.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=parser-executor.test.d.ts.map

package/tests/parser-executor.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"parser-executor.test.d.ts","sourceRoot":"","sources":["parser-executor.test.ts"],"names":[],"mappings":""}

package/tests/parser-executor.test.js

@@ -1,25 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { VirtualShell } from "../src";
-import { executePipeline } from "../src/SSHMimic/executor";
-import { parseShellPipeline } from "../src/VirtualShell/shellParser";
-describe("Pipeline parser and executor", () => {
-    test("parses simple pipeline", () => {
-        const pipeline = parseShellPipeline("echo hello | grep h");
-        expect(pipeline.isValid).toBe(true);
-        expect(pipeline.commands).toHaveLength(2);
-        expect(pipeline.commands[0]?.name).toBe("echo");
-        expect(pipeline.commands[1]?.name).toBe("grep");
-    });
-    test("handles invalid syntax", () => {
-        const pipeline = parseShellPipeline("echo hello |");
-        expect(pipeline.isValid).toBe(false);
-        expect(pipeline.error).toBeDefined();
-    });
-    test("executes simple pipeline", async () => {
-        const shell = new VirtualShell("localhost");
-        const pipeline = parseShellPipeline("echo hello | grep h");
-        const result = await executePipeline(pipeline, "root", "localhost", "shell", "/", shell);
-        expect(result.exitCode).toBe(0);
-        expect(result.stdout).toContain("hello");
-    });
-});

package/tests/sftp.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=sftp.test.d.ts.map

package/tests/sftp.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sftp.test.d.ts","sourceRoot":"","sources":["sftp.test.ts"],"names":[],"mappings":""}

package/tests/sftp.test.js

@@ -1,246 +0,0 @@
-/// <reference types="bun" />
-import { describe, expect, test } from "bun:test";
-import { Client } from "ssh2";
-import { SftpMimic } from "../src/SSHMimic/sftp";
-import VirtualFileSystem from "../src/VirtualFileSystem";
-import { VirtualUserManager } from "../src/VirtualUserManager";
-// VirtualFileSystem is now pure in-memory — no temp dir or cleanup needed.
-function connectSftp(port) {
-    return new Promise((resolve, reject) => {
-        const client = new Client();
-        client.on("ready", () => {
-            client.sftp((err, sftp) => {
-                if (err) {
-                    client.end();
-                    reject(err);
-                    return;
-                }
-                resolve({ client, sftp });
-            });
-        });
-        client.on("error", reject);
-        client.connect({
-            host: "127.0.0.1",
-            port,
-            username: "root",
-            password: "", // root has no password — any value or empty is accepted
-            hostVerifier: () => true,
-        });
-    });
-}
-function connectSftpWithUser(port, username, password) {
-    return new Promise((resolve, reject) => {
-        const client = new Client();
-        client.on("ready", () => {
-            client.sftp((err, sftp) => {
-                if (err) {
-                    client.end();
-                    reject(err);
-                    return;
-                }
-                resolve({ client, sftp });
-            });
-        });
-        client.on("error", reject);
-        client.connect({
-            host: "127.0.0.1",
-            port,
-            username,
-            password,
-            hostVerifier: () => true,
-        });
-    });
-}
-describe("SftpMimic", () => {
-    test("authenticates with VirtualUserManager and serves files from the VirtualFileSystem", async () => {
-        const vfs = new VirtualFileSystem();
-        const users = new VirtualUserManager(vfs);
-        await users.initialize();
-        const rootPath = "/home/root";
-        if (!vfs.exists(rootPath)) {
-            vfs.mkdir(rootPath, 0o755);
-        }
-        vfs.writeFile(`${rootPath}/TEST.txt`, "hello world");
-        const server = new SftpMimic({
-            port: 0,
-            hostname: "test-sftp",
-            vfs,
-            users,
-        });
-        const port = await server.start();
-        try {
-            const { client, sftp } = await connectSftp(port);
-            const list = await new Promise((resolve, reject) => {
-                sftp.readdir("/home/root", (err, list) => {
-                    if (err) {
-                        reject(err);
-                        return;
-                    }
-                    resolve(list || []);
-                });
-            });
-            expect(list.map((entry) => entry.filename)).toContain("TEST.txt");
-            const content = await new Promise((resolve, reject) => {
-                sftp.readFile("/home/root/TEST.txt", "utf8", (err, data) => {
-                    if (err) {
-                        reject(err);
-                        return;
-                    }
-                    resolve((data || Buffer.alloc(0)).toString("utf8"));
-                });
-            });
-            expect(content).toBe("hello world");
-            client.end();
-        }
-        finally {
-            server.stop();
-        }
-    });
-    test("blocks path traversal attempts outside home directory", async () => {
-        const vfs = new VirtualFileSystem();
-        const users = new VirtualUserManager(vfs);
-        await users.initialize();
-        const rootPath = "/home/root";
-        if (!vfs.exists(rootPath)) {
-            vfs.mkdir(rootPath, 0o755);
-        }
-        const server = new SftpMimic({
-            port: 0,
-            hostname: "test-sftp",
-            vfs,
-            users,
-        });
-        const port = await server.start();
-        try {
-            const { client, sftp } = await connectSftp(port);
-            // /etc/passwd is outside /home/root — should be rejected
-            const traversalAttempt = await new Promise((resolve) => {
-                sftp.stat("/etc/passwd", (err) => {
-                    resolve(err ?? null);
-                });
-            });
-            expect(traversalAttempt).not.toBeNull();
-            expect(traversalAttempt?.message).toContain("Permission denied");
-            // /home/root itself should work
-            const homeAccess = await new Promise((resolve, reject) => {
-                sftp.readdir("/home/root", (err, list) => {
-                    if (err) {
-                        reject(err);
-                        return;
-                    }
-                    resolve(list || []);
-                });
-            });
-            expect(homeAccess).toBeDefined();
-            // Path traversal via ../.. should also be rejected
-            const upTraversalAttempt = await new Promise((resolve) => {
-                sftp.readdir("/home/root/../../etc", (err) => {
-                    resolve(err ?? null);
-                });
-            });
-            expect(upTraversalAttempt).not.toBeNull();
-            client.end();
-        }
-        finally {
-            server.stop();
-        }
-    });
-    test("allows a user with a password to authenticate", async () => {
-        const vfs = new VirtualFileSystem();
-        const users = new VirtualUserManager(vfs);
-        await users.initialize();
-        await users.addUser("alice", "alice-pass");
-        // Ensure alice's home exists (addUser should create it, but let's be explicit)
-        if (!vfs.exists("/home/alice")) {
-            vfs.mkdir("/home/alice", 0o755);
-        }
-        vfs.writeFile("/home/alice/hello.txt", "hi alice");
-        const server = new SftpMimic({
-            port: 0,
-            hostname: "test-sftp",
-            vfs,
-            users,
-        });
-        const port = await server.start();
-        try {
-            const { client, sftp } = await connectSftpWithUser(port, "alice", "alice-pass");
-            const list = await new Promise((resolve, reject) => {
-                sftp.readdir("/home/alice", (err, list) => {
-                    if (err) {
-                        reject(err);
-                        return;
-                    }
-                    resolve(list || []);
-                });
-            });
-            expect(list.map((e) => e.filename)).toContain("hello.txt");
-            client.end();
-        }
-        finally {
-            server.stop();
-        }
-    });
-    test("rejects a user with a wrong password", async () => {
-        const vfs = new VirtualFileSystem();
-        const users = new VirtualUserManager(vfs);
-        await users.initialize();
-        await users.addUser("bob", "correct-pass");
-        const server = new SftpMimic({
-            port: 0,
-            hostname: "test-sftp",
-            vfs,
-            users,
-        });
-        const port = await server.start();
-        try {
-            const connectPromise = connectSftpWithUser(port, "bob", "wrong-pass");
-            await expect(connectPromise).rejects.toThrow();
-        }
-        finally {
-            server.stop();
-        }
-    });
-    test("allows writing and reading back a file over SFTP", async () => {
-        const vfs = new VirtualFileSystem();
-        const users = new VirtualUserManager(vfs);
-        await users.initialize();
-        if (!vfs.exists("/home/root")) {
-            vfs.mkdir("/home/root", 0o755);
-        }
-        const server = new SftpMimic({
-            port: 0,
-            hostname: "test-sftp",
-            vfs,
-            users,
-        });
-        const port = await server.start();
-        try {
-            const { client, sftp } = await connectSftp(port);
-            await new Promise((resolve, reject) => {
-                sftp.writeFile("/home/root/written.txt", Buffer.from("written via sftp"), (err) => {
-                    if (err) {
-                        reject(err);
-                        return;
-                    }
-                    resolve();
-                });
-            });
-            const content = await new Promise((resolve, reject) => {
-                sftp.readFile("/home/root/written.txt", "utf8", (err, data) => {
-                    if (err) {
-                        reject(err);
-                        return;
-                    }
-                    resolve((data || Buffer.alloc(0)).toString("utf8"));
-                });
-            });
-            expect(content).toBe("written via sftp");
-            // Also verify it landed in the in-memory VFS
-            expect(vfs.readFile("/home/root/written.txt")).toBe("written via sftp");
-            client.end();
-        }
-        finally {
-            server.stop();
-        }
-    });
-});

package/tests/ssh-exec.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=ssh-exec.test.d.ts.map

package/tests/ssh-exec.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ssh-exec.test.d.ts","sourceRoot":"","sources":["ssh-exec.test.ts"],"names":[],"mappings":""}

package/tests/ssh-exec.test.js

@@ -1,39 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { VirtualShell } from "../src";
-import { runExec } from "../src/SSHMimic/exec";
-describe("SSH exec inline commands", () => {
-    test("runExec sends stdout, stderr, and exit code for inline commands", async () => {
-        const shell = new VirtualShell("localhost");
-        const stdout = [];
-        const stderr = [];
-        let exitCode = -1;
-        const stream = {
-            write(data) {
-                stdout.push(data);
-            },
-            stderr: {
-                write(data) {
-                    stderr.push(data);
-                },
-            },
-            exit(code) {
-                exitCode = code;
-            },
-            end() {
-                return undefined;
-            },
-        };
-        await shell.ensureInitialized();
-        const endPromise = new Promise((resolve) => {
-            stream.end = () => {
-                resolve();
-                return;
-            };
-        });
-        runExec(stream, "echo hello", "root", "localhost", shell);
-        await endPromise;
-        expect(stdout.join("")).toContain("hello");
-        expect(stderr.join("")).toBe("");
-        expect(exitCode).toBe(0);
-    });
-});

package/tests/test-helper.d.ts

@@ -1,56 +0,0 @@
-import { VirtualShell } from "../src";
-import { SshClient } from "../src/SSHClient";
-/**
- * Test helper: creates a fresh shell & client for each test
- */
-export declare function createTestEnv(vmName?: string): Promise<{
-    shell: VirtualShell;
-    client: SshClient;
-}>;
-/**
- * Helper: run a single command via SshClient
- * @param client SshClient instance
- * @param cmd Command string (e.g., "ls /tmp")
- * @returns { exitCode, stdout, stderr }
- */
-export declare function runCmd(client: InstanceType<typeof SshClient>, cmd: string): Promise<import("../src").CommandResult>;
-/**
- * Helper: run a piped command
- * @param client SshClient instance
- * @param cmd Command with pipes (e.g., "echo hello | grep h")
- * @returns { exitCode, stdout, stderr }
- */
-export declare function runPipedCmd(client: InstanceType<typeof SshClient>, cmd: string): Promise<import("../src").CommandResult>;
-/**
- * Helper: create a test file in the shell
- * @param shell VirtualShell instance
- * @param path File path
- * @param content File content
- */
-export declare function createTestFile(shell: VirtualShell, path: string, content: string): void;
-/**
- * Helper: create a test directory
- * @param shell VirtualShell instance
- * @param path Directory path
- */
-export declare function createTestDir(shell: VirtualShell, path: string): void;
-/**
- * Helper: read file from shell
- * @param shell VirtualShell instance
- * @param path File path
- * @returns File content
- */
-export declare function readTestFile(shell: VirtualShell, path: string): string;
-/**
- * Helper: check if path exists
- * @param shell VirtualShell instance
- * @param path Path to check
- * @returns true if exists
- */
-export declare function pathExists(shell: VirtualShell, path: string): boolean;
-/**
- * Helper: cleanup test environment
- * @param shell VirtualShell instance
- */
-export declare function cleanupTestEnv(shell: VirtualShell): void;
-//# sourceMappingURL=test-helper.d.ts.map

package/tests/test-helper.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"test-helper.d.ts","sourceRoot":"","sources":["test-helper.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AACtC,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAE7C;;GAEG;AACH,wBAAsB,aAAa,CAAC,MAAM,SAAe;;;GAKxD;AAED;;;;;GAKG;AACH,wBAAsB,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,OAAO,SAAS,CAAC,EAAE,GAAG,EAAE,MAAM,2CAE/E;AAED;;;;;GAKG;AACH,wBAAsB,WAAW,CAAC,MAAM,EAAE,YAAY,CAAC,OAAO,SAAS,CAAC,EAAE,GAAG,EAAE,MAAM,2CAEpF;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,QAEhF;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,QAE9D;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAEtE;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAErE;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,YAAY,QAEjD"}

package/tests/test-helper.js

@@ -1,71 +0,0 @@
-import { VirtualShell } from "../src";
-import { SshClient } from "../src/SSHClient";
-/**
- * Test helper: creates a fresh shell & client for each test
- */
-export async function createTestEnv(vmName = "test-shell") {
-    const shell = new VirtualShell(vmName);
-    await shell.ensureInitialized();
-    const client = new SshClient(shell, "root");
-    return { shell, client };
-}
-/**
- * Helper: run a single command via SshClient
- * @param client SshClient instance
- * @param cmd Command string (e.g., "ls /tmp")
- * @returns { exitCode, stdout, stderr }
- */
-export async function runCmd(client, cmd) {
-    return client.exec(cmd);
-}
-/**
- * Helper: run a piped command
- * @param client SshClient instance
- * @param cmd Command with pipes (e.g., "echo hello | grep h")
- * @returns { exitCode, stdout, stderr }
- */
-export async function runPipedCmd(client, cmd) {
-    return client.exec(cmd);
-}
-/**
- * Helper: create a test file in the shell
- * @param shell VirtualShell instance
- * @param path File path
- * @param content File content
- */
-export function createTestFile(shell, path, content) {
-    shell.vfs.writeFile(path, content);
-}
-/**
- * Helper: create a test directory
- * @param shell VirtualShell instance
- * @param path Directory path
- */
-export function createTestDir(shell, path) {
-    shell.vfs.mkdir(path);
-}
-/**
- * Helper: read file from shell
- * @param shell VirtualShell instance
- * @param path File path
- * @returns File content
- */
-export function readTestFile(shell, path) {
-    return shell.vfs.readFile(path);
-}
-/**
- * Helper: check if path exists
- * @param shell VirtualShell instance
- * @param path Path to check
- * @returns true if exists
- */
-export function pathExists(shell, path) {
-    return shell.vfs.exists(path);
-}
-/**
- * Helper: cleanup test environment
- * @param shell VirtualShell instance
- */
-export function cleanupTestEnv(shell) {
-    // No cleanup needed for now, VirtualShell is ephemeral
-}

package/tests/users.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=users.test.d.ts.map

package/tests/users.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"users.test.d.ts","sourceRoot":"","sources":["users.test.ts"],"names":[],"mappings":""}

package/tests/users.test.js

@@ -1,71 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import VirtualFileSystem from "../src/VirtualFileSystem";
-import { VirtualUserManager } from "../src/VirtualUserManager";
-function makeVfs() {
-    return new VirtualFileSystem();
-}
-describe("VirtualUserManager auto sudo", () => {
-    test("adds new users to sudoers by default", async () => {
-        const vfs = makeVfs();
-        const users = new VirtualUserManager(vfs);
-        await users.initialize();
-        await users.addUser("alice", "alice-pass");
-        expect(users.isSudoer("alice")).toBe(true);
-    });
-    test("does not auto-add sudoers when disabled", async () => {
-        const vfs = makeVfs();
-        const users = new VirtualUserManager(vfs, false);
-        await users.initialize();
-        await users.addUser("bob", "bob-pass");
-        expect(users.isSudoer("bob")).toBe(false);
-    });
-    test("updates password for existing user", async () => {
-        const vfs = makeVfs();
-        const users = new VirtualUserManager(vfs);
-        await users.initialize();
-        await users.addUser("alice", "alice-pass");
-        await users.setPassword("alice", "new-pass");
-        expect(users.verifyPassword("alice", "new-pass")).toBe(true);
-        expect(users.verifyPassword("alice", "alice-pass")).toBe(false);
-    });
-});
-describe("VirtualUserManager quotas", () => {
-    test("enforces quota for writes inside user home", async () => {
-        const vfs = makeVfs();
-        const users = new VirtualUserManager(vfs);
-        await users.initialize();
-        await users.addUser("alice", "alice-pass");
-        const startingUsage = users.getUsageBytes("alice");
-        await users.setQuotaBytes("alice", startingUsage + 5);
-        expect(() => {
-            users.assertWriteWithinQuota("alice", "/home/alice/note.txt", "hello");
-        }).not.toThrow();
-        vfs.writeFile("/home/alice/note.txt", "hello");
-        expect(() => {
-            users.assertWriteWithinQuota("alice", "/home/alice/note.txt", "this exceeds the configured quota");
-        }).toThrow("quota exceeded for 'alice'");
-    });
-    test("does not enforce home quota outside user home", async () => {
-        const vfs = makeVfs();
-        const users = new VirtualUserManager(vfs);
-        await users.initialize();
-        await users.addUser("bob", "bob-pass");
-        await users.setQuotaBytes("bob", 1);
-        expect(() => {
-            users.assertWriteWithinQuota("bob", "/tmp/shared.txt", "large-content");
-        }).not.toThrow();
-    });
-    test("clearQuota removes enforced limit", async () => {
-        const vfs = makeVfs();
-        const users = new VirtualUserManager(vfs);
-        await users.initialize();
-        await users.addUser("charlie", "charlie-pass");
-        await users.setQuotaBytes("charlie", 2);
-        expect(users.getQuotaBytes("charlie")).toBe(2);
-        await users.clearQuota("charlie");
-        expect(users.getQuotaBytes("charlie")).toBeNull();
-        expect(() => {
-            users.assertWriteWithinQuota("charlie", "/home/charlie/file.txt", "long-content");
-        }).not.toThrow();
-    });
-});

package/tests/web.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=web.test.d.ts.map

package/tests/web.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"web.test.d.ts","sourceRoot":"","sources":["web.test.ts"],"names":[],"mappings":""}