typescript-virtual-container 1.4.3 → 1.4.4

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

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

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

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

package/tests/parser-executor.test.js

@@ -0,0 +1,25 @@
+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

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

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

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

package/tests/sftp.test.js

@@ -0,0 +1,246 @@
+/// <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

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

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

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

package/tests/ssh-exec.test.js

@@ -0,0 +1,39 @@
+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

@@ -0,0 +1,56 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,71 @@
+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/test-helper.ts

@@ -0,0 +1,79 @@
+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: InstanceType<typeof SshClient>, cmd: string) {
+	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: InstanceType<typeof SshClient>, cmd: string) {
+	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: VirtualShell, path: string, content: string) {
+	shell.vfs.writeFile(path, content);
+}
+
+/**
+ * Helper: create a test directory
+ * @param shell VirtualShell instance
+ * @param path Directory path
+ */
+export function createTestDir(shell: VirtualShell, path: string) {
+	shell.vfs.mkdir(path);
+}
+
+/**
+ * Helper: read file from shell
+ * @param shell VirtualShell instance
+ * @param path File path
+ * @returns File content
+ */
+export function readTestFile(shell: VirtualShell, path: string): string {
+	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: VirtualShell, path: string): boolean {
+	return shell.vfs.exists(path);
+}
+
+/**
+ * Helper: cleanup test environment
+ * @param shell VirtualShell instance
+ */
+export function cleanupTestEnv(shell: VirtualShell) {
+	// No cleanup needed for now, VirtualShell is ephemeral
+}

package/tests/users.test.d.ts

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

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

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

package/tests/users.test.js

@@ -0,0 +1,71 @@
+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

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

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

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