typescript-virtual-container 1.5.3 → 1.5.4

package/tests/parser-executor.test.ts

@@ -1,37 +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.ts

@@ -1,323 +0,0 @@
-/// <reference types="bun" />
-import { describe, expect, test } from "bun:test";
-import type { FileEntryWithStats, SFTPWrapper } from "ssh2";
-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: number,
-): Promise<{ client: Client; sftp: SFTPWrapper }> {
-	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: number,
-	username: string,
-	password: string,
-): Promise<{ client: Client; sftp: SFTPWrapper }> {
-	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 = "/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<FileEntryWithStats[]>(
-				(resolve, reject) => {
-					sftp.readdir(
-						"/root",
-						(err?: Error | null, list?: FileEntryWithStats[]) => {
-							if (err) {
-								reject(err);
-								return;
-							}
-							resolve(list || []);
-						},
-					);
-				},
-			);
-
-			expect(list.map((entry) => entry.filename)).toContain("TEST.txt");
-
-			const content = await new Promise<string>((resolve, reject) => {
-				sftp.readFile(
-					"/root/TEST.txt",
-					"utf8",
-					(err?: Error | null, data?: Buffer) => {
-						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 = "/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 /root — should be rejected
-			const traversalAttempt = await new Promise<Error | null>((resolve) => {
-				sftp.stat("/etc/passwd", (err?: Error | null) => {
-					resolve(err ?? null);
-				});
-			});
-
-			expect(traversalAttempt).not.toBeNull();
-			expect(traversalAttempt?.message).toContain("Permission denied");
-
-			// /root itself should work
-			const homeAccess = await new Promise<FileEntryWithStats[]>(
-				(resolve, reject) => {
-					sftp.readdir(
-						"/root",
-						(err?: Error | null, list?: FileEntryWithStats[]) => {
-							if (err) {
-								reject(err);
-								return;
-							}
-							resolve(list || []);
-						},
-					);
-				},
-			);
-			expect(homeAccess).toBeDefined();
-
-			// Path traversal via ../.. should also be rejected
-			const upTraversalAttempt = await new Promise<Error | null>((resolve) => {
-				sftp.readdir("/root/../../etc", (err?: Error | null) => {
-					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<FileEntryWithStats[]>(
-				(resolve, reject) => {
-					sftp.readdir(
-						"/home/alice",
-						(err?: Error | null, list?: FileEntryWithStats[]) => {
-							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("/root")) {
-			vfs.mkdir("/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<void>((resolve, reject) => {
-				sftp.writeFile(
-					"/root/written.txt",
-					Buffer.from("written via sftp"),
-					(err?: Error | null) => {
-						if (err) {
-							reject(err);
-							return;
-						}
-						resolve();
-					},
-				);
-			});
-
-			const content = await new Promise<string>((resolve, reject) => {
-				sftp.readFile(
-					"/root/written.txt",
-					"utf8",
-					(err?: Error | null, data?: Buffer) => {
-						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("/root/written.txt")).toBe("written via sftp");
-
-			client.end();
-		} finally {
-			server.stop();
-		}
-	});
-});

package/tests/ssh-exec.test.ts

@@ -1,45 +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: string[] = [];
-		const stderr: string[] = [];
-		let exitCode: number = -1;
-
-		const stream = {
-			write(data: string) {
-				stdout.push(data);
-			},
-			stderr: {
-				write(data: string) {
-					stderr.push(data);
-				},
-			},
-			exit(code: number) {
-				exitCode = code;
-			},
-			end() {
-				return undefined;
-			},
-		};
-
-		await shell.ensureInitialized();
-
-		const endPromise = new Promise<void>((resolve) => {
-			stream.end = () => {
-				resolve();
-				return;
-			};
-		});
-
-		runExec(stream as never, "echo hello", "root", "localhost", shell);
-		await endPromise;
-
-		expect(stdout.join("")).toContain("hello");
-		expect(stderr.join("")).toBe("");
-		expect(exitCode).toBe(0);
-	});
-});

package/tests/test-helper.ts

@@ -1,79 +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: 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.ts

@@ -1,86 +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/tsconfig.json

@@ -1,49 +0,0 @@
-{
-  "compilerOptions": {
-    // Environment setup & latest features
-    "lib": [
-      "ESNext",
-      "DOM",
-      "DOM.Iterable"
-    ],
-    "target": "ESNext",
-    "module": "Preserve",
-    "moduleDetection": "force",
-    "jsx": "react-jsx",
-    "allowJs": true,
-    
-    // Bundler mode
-    "moduleResolution": "bundler",
-    "verbatimModuleSyntax": true,
-    "noEmit": false,
-    "rewriteRelativeImportExtensions": true,
-    
-    // Best practices
-    "strict": true,
-    "skipLibCheck": true,
-    "noFallthroughCasesInSwitch": true,
-    "noUncheckedIndexedAccess": true,
-    "noImplicitOverride": true,
-
-    // Some stricter flags (disabled by default)
-    "noUnusedLocals": false,
-    "noUnusedParameters": false,
-    "noPropertyAccessFromIndexSignature": false,
-    "types": [
-      "node",
-      "bun"
-    ],
-
-    "esModuleInterop": true,
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true,
-    "declaration": true,
-    "declarationMap": false,
-    "rootDir": "src",
-    "outDir": "dist",
-    "sourceMap": false,
-    "composite": true,
-    "tsBuildInfoFile": "dist/.tsbuildinfo"
-  },    
-  "include": ["src/**/*"]
-}

package/typedoc.json

@@ -1,47 +0,0 @@
-{
-  "entryPoints": [
-    "src/index.ts"
-  ],
-  "out": "docs",
-  "name": "typescript-virtual-container",
-  "includeVersion": true,
-  "readme": "README.md",
-  "blockTags": [
-    "@abstract",
-    "@alpha",
-    "@async",
-    "@beta",
-    "@decorator",
-    "@deprecated",
-    "@eventProperty",
-    "@example",
-    "@experimental",
-    "@fires",
-    "@ignore",
-    "@inheritDoc",
-    "@internal",
-    "@label",
-    "@link",
-    "@module",
-    "@namespace",
-    "@override",
-    "@packageDocumentation",
-    "@param",
-    "@privateRemarks",
-    "@property",
-    "@public",
-    "@readonly",
-    "@remarks",
-    "@returns",
-    "@satisfies",
-    "@sealed",
-    "@since",
-    "@throws",
-    "@typeParam",
-    "@virtual"
-  ],
-  "excludePrivate": true,
-  "excludeInternal": true,
-  "treatWarningsAsErrors": false,
-  "skipErrorChecking": false
-}