typescript-virtual-container 1.0.8 → 1.1.1-b

package/src/{VirtualShell/commands → commands}/nano.ts

@@ -1,11 +1,11 @@
 import * as path from "node:path";
-import type { ShellModule } from "../../types/commands";
+import type { ShellModule } from "../types/commands";
 import { assertPathAccess, resolvePath } from "./helpers";
 
 export const nanoCommand: ShellModule = {
 	name: "nano",
 	params: ["<file>"],
-	run: ({ authUser, vfs, cwd, args }) => {
+	run: ({ authUser, shell, cwd, args }) => {
 		const fileArg = args[0];
 		if (!fileArg) {
 			return { stderr: "nano: missing file operand", exitCode: 1 };
@@ -13,8 +13,8 @@ export const nanoCommand: ShellModule = {
 
 		const targetPath = resolvePath(cwd, fileArg);
 		assertPathAccess(authUser, targetPath, "nano");
-		const initialContent = vfs.exists(targetPath)
-			? vfs.readFile(targetPath)
+		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`;

package/src/{VirtualShell/commands → commands}/neofetch.ts

@@ -1,12 +1,12 @@
-import { buildNeofetchOutput } from "../../../modules/neofetch";
-import type { ShellModule } from "../../types/commands";
+import { buildNeofetchOutput } from "../../modules/neofetch";
+import type { ShellModule } from "../types/commands";
 import { ifFlag } from "./command-helpers";
 import { getAllEnvVars } from "./set";
 
 export const neofetchCommand: ShellModule = {
 	name: "neofetch",
 	params: ["[--off]"],
-	run: ({ args, authUser, hostname, shellProps }) => {
+	run: ({ args, authUser, hostname, shell }) => {
 		const env = getAllEnvVars(authUser);
 
 		if (ifFlag(args, "--help")) {
@@ -28,7 +28,7 @@ export const neofetchCommand: ShellModule = {
 				user: authUser,
 				host: hostname,
 				shell: env.SHELL,
-				shellProps: shellProps,
+				shellProps: shell.properties,
 				terminal: env.TERM,
 			}),
 			exitCode: 0,

package/src/{VirtualShell/commands → commands}/pwd.ts

@@ -1,4 +1,4 @@
-import type { ShellModule } from "../../types/commands";
+import type { ShellModule } from "../types/commands";
 
 export const pwdCommand: ShellModule = {
 	name: "pwd",

package/src/{VirtualShell/commands → commands}/rm.ts

@@ -1,11 +1,11 @@
-import type { ShellModule } from "../../types/commands";
+import type { ShellModule } from "../types/commands";
 import { getArg, ifFlag } from "./command-helpers";
 import { assertPathAccess, resolvePath } from "./helpers";
 
 export const rmCommand: ShellModule = {
 	name: "rm",
 	params: ["[-r|-rf] <path>"],
-	run: ({ authUser, vfs, cwd, args }) => {
+	run: ({ authUser, shell, cwd, args }) => {
 		if (args.length === 0) {
 			return { stderr: "rm: missing operand", exitCode: 1 };
 		}
@@ -27,7 +27,7 @@ export const rmCommand: ShellModule = {
 		for (const target of targets) {
 			const resolvedTarget = resolvePath(cwd, target);
 			assertPathAccess(authUser, resolvedTarget, "rm");
-			vfs.remove(resolvedTarget, { recursive });
+			shell.vfs.remove(resolvedTarget, { recursive });
 		}
 
 		return { exitCode: 0 };

package/src/{VirtualShell/commands → commands}/set.ts

@@ -1,5 +1,5 @@
 /** biome-ignore-all lint/style/useNamingConvention: env variables */
-import type { ShellModule } from "../../types/commands";
+import type { ShellModule } from "../types/commands";
 import { getArg } from "./command-helpers";
 
 // Simple in-memory environment variables store

package/src/{VirtualShell/commands → commands}/sh.ts

@@ -1,5 +1,4 @@
-import { defaultShellProperties } from "..";
-import type { CommandContext, ShellModule } from "../../types/commands";
+import type { CommandContext, ShellModule } from "../types/commands";
 import { getArg, getFlag } from "./command-helpers";
 import { runCommand } from "./index";
 
@@ -9,8 +8,7 @@ export const shCommand: ShellModule = {
 	params: ["-c <script>", "[<file>]"],
 	aliases: ["bash"],
 	run: async (ctx: CommandContext) => {
-		const { vfs, args, authUser, hostname, users, mode, cwd } = 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) ?? "";
@@ -39,16 +37,7 @@ export const shCommand: ShellModule = {
 
 				// Execute the command
 				const result = await Promise.resolve(
-					runCommand(
-						command,
-						authUser,
-						hostname,
-						users,
-						mode,
-						cwd,
-						defaultShellProperties,
-						vfs,
-					),
+					runCommand(command, authUser, hostname, mode, cwd, ctx.shell),
 				);
 
 				if (result.stdout) {

package/src/{VirtualShell/commands → commands}/su.ts

@@ -1,10 +1,11 @@
-import type { ShellModule } from "../../types/commands";
+import type { ShellModule } from "../types/commands";
 import { getArg } from "./command-helpers";
 
 export const suCommand: ShellModule = {
 	name: "su",
 	params: ["- <username>"],
-	run: ({ authUser, users, args }) => {
+	run: ({ authUser, shell, args }) => {
+		const users = shell.users!;
 		const targetUser = getArg(args, 0, { flags: ["-"] });
 
 		if (!targetUser) {

package/src/{VirtualShell/commands → commands}/sudo.ts

@@ -1,5 +1,4 @@
-import { defaultShellProperties } from "..";
-import type { ShellModule } from "../../types/commands";
+import type { ShellModule } from "../types/commands";
 import { parseArgs } from "./command-helpers";
 import { runCommand } from "./index";
 
@@ -23,10 +22,10 @@ function parseSudoArgs(args: string[]): {
 export const sudoCommand: ShellModule = {
 	name: "sudo",
 	params: ["<command...>"],
-	run: async ({ authUser, hostname, users, mode, cwd, vfs, args }) => {
+	run: async ({ authUser, hostname, mode, cwd, shell, args }) => {
 		const { targetUser, loginShell, commandLine } = parseSudoArgs(args);
 
-		if (authUser !== "root" && !users.isSudoer(authUser)) {
+		if (authUser !== "root" && !shell.users.isSudoer(authUser)) {
 			return { stderr: "sudo: permission denied", exitCode: 1 };
 		}
 
@@ -50,11 +49,9 @@ export const sudoCommand: ShellModule = {
 				commandLine,
 				effectiveUser,
 				hostname,
-				users,
 				mode,
 				loginShell ? `/home/${effectiveUser}` : cwd,
-				defaultShellProperties,
-				vfs,
+				shell,
 			);
 		}
 

package/src/{VirtualShell/commands → commands}/touch.ts

@@ -1,10 +1,10 @@
-import type { ShellModule } from "../../types/commands";
+import type { ShellModule } from "../types/commands";
 import { assertPathAccess, resolvePath } from "./helpers";
 
 export const touchCommand: ShellModule = {
 	name: "touch",
 	params: ["<file>"],
-	run: ({ authUser, vfs, cwd, args }) => {
+	run: ({ authUser, shell, cwd, args }) => {
 		if (args.length === 0) {
 			return { stderr: "touch: missing file operand", exitCode: 1 };
 		}
@@ -12,8 +12,8 @@ export const touchCommand: ShellModule = {
 		for (const file of args) {
 			const target = resolvePath(cwd, file);
 			assertPathAccess(authUser, target, "touch");
-			if (!vfs.exists(target)) {
-				vfs.writeFile(target, "");
+			if (!shell.vfs.exists(target)) {
+				shell.writeFileAsUser(authUser, target, "");
 			}
 		}
 		return { exitCode: 0 };

package/src/{VirtualShell/commands → commands}/tree.ts

@@ -1,13 +1,13 @@
-import type { ShellModule } from "../../types/commands";
+import type { ShellModule } from "../types/commands";
 import { getArg } from "./command-helpers";
 import { assertPathAccess, resolvePath } from "./helpers";
 
 export const treeCommand: ShellModule = {
 	name: "tree",
 	params: ["[path]"],
-	run: ({ authUser, vfs, cwd, args }) => {
+	run: ({ authUser, shell, cwd, args }) => {
 		const target = resolvePath(cwd, getArg(args, 0) ?? cwd);
 		assertPathAccess(authUser, target, "tree");
-		return { stdout: vfs.tree(target), exitCode: 0 };
+		return { stdout: shell.vfs.tree(target), exitCode: 0 };
 	},
 };

package/src/{VirtualShell/commands → commands}/unset.ts

@@ -1,4 +1,4 @@
-import type { ShellModule } from "../../types/commands";
+import type { ShellModule } from "../types/commands";
 import { setEnvVar } from "./set";
 
 export const unsetCommand: ShellModule = {

package/src/{VirtualShell/commands → commands}/wget.ts

@@ -2,7 +2,7 @@ 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 type { ShellModule } from "../../types/commands";
+import type { ShellModule } from "../types/commands";
 import { ifFlag, parseArgs } from "./command-helpers";
 import {
 	assertPathAccess,
@@ -83,7 +83,7 @@ function runHostWget(args: string[]): Promise<{
 export const wgetCommand: ShellModule = {
 	name: "wget",
 	params: ["[url]"],
-	run: async ({ authUser, vfs, cwd, args }) => {
+	run: async ({ authUser, cwd, args, shell }) => {
 		const { flagsWithValues, positionals } = parseArgs(args, {
 			flagsWithValue: ["-o", "-O", "--output", "--output-document"],
 		});
@@ -131,7 +131,7 @@ export const wgetCommand: ShellModule = {
 			const content = await readFile(tempFile, "utf8");
 			const target = resolvePath(cwd, outputPath || stripUrlFilename(url));
 			assertPathAccess(authUser, target, "wget");
-			vfs.writeFile(target, content);
+			shell.writeFileAsUser(authUser, target, content);
 
 			return {
 				stdout: `saved ${target}`,

package/src/{VirtualShell/commands → commands}/who.ts

@@ -1,11 +1,11 @@
-import { formatLoginDate } from "../../SSHMimic/loginFormat";
-import type { ShellModule } from "../../types/commands";
+import { formatLoginDate } from "../SSHMimic/loginFormat";
+import type { ShellModule } from "../types/commands";
 
 export const whoCommand: ShellModule = {
 	name: "who",
 	params: [],
-	run: ({ users }) => {
-		const lines = users.listActiveSessions().map((session) => {
+	run: ({ shell }) => {
+		const lines = shell.users.listActiveSessions().map((session) => {
 			const loginAt = new Date(session.startedAt);
 			const displayDate = Number.isNaN(loginAt.getTime())
 				? session.startedAt

package/src/{VirtualShell/commands → commands}/whoami.ts

@@ -1,4 +1,4 @@
-import type { ShellModule } from "../../types/commands";
+import type { ShellModule } from "../types/commands";
 
 export const whoamiCommand: ShellModule = {
 	name: "whoami",

package/src/index.ts

@@ -1,8 +1,8 @@
-import { SshClient } from "./SSHMimic/client";
+import { SshClient } from "./SSHClient";
 import { SshMimic } from "./SSHMimic/index";
-import { VirtualUserManager } from "./SSHMimic/users";
 import VirtualFileSystem from "./VirtualFileSystem";
-import type { VirtualShell } from "./VirtualShell";
+import { VirtualShell } from "./VirtualShell";
+import { VirtualUserManager } from "./VirtualUserManager";
 
 export type {
 	CommandContext,
@@ -32,13 +32,13 @@ export type {
 export {
 	SshClient,
 	VirtualFileSystem,
-	SshMimic as VirtualMachine,
+	VirtualShell,
+	SshMimic as VirtualSshServer,
 	VirtualUserManager,
-	type VirtualShell,
 };
 
 export {
 	getArg,
 	getFlag,
 	ifFlag,
-} from "./VirtualShell/commands/command-helpers";
+} from "./commands/command-helpers";

package/src/standalone.ts

@@ -1,21 +1,26 @@
-import { VirtualMachine } from ".";
+import { VirtualShell, VirtualSshServer } from ".";
 
-const sshHostname = process.env.SSH_MIMIC_HOSTNAME ?? "typescript-vm";
-const sshMimic = new VirtualMachine({ port: 2222, hostname: sshHostname });
+const hostname = process.env.SSH_MIMIC_HOSTNAME ?? "typescript-vm";
+const virtualShell = new VirtualShell(hostname);
 
-sshMimic
+virtualShell.addCommand("demo", [], () => {
+	return {
+		stdout: "This is a demo command. It does nothing useful.",
+		exitCode: 0,
+	};
+});
+
+new VirtualSshServer({
+	port: 2222,
+	hostname,
+	shell: virtualShell,
+})
 	.start()
 	.then((port: number) => {
-		if (!sshMimic.shell) console.error("Failed to initialize SSH Mimic shell.");
-		else {
-			console.log(`SSH Mimic initialized. Listening on port ${port}.`);
-			sshMimic.shell.addCommand("demo", [], () => {
-				return {
-					stdout: "This is a demo command. It does nothing useful.",
-					exitCode: 0,
-				};
-			});
-		}
+		// if (!sshMimic) console.error("Failed to initialize SSH Mimic shell.");
+		// else {
+		console.log(`SSH Mimic initialized. Listening on port ${port}.`);
+		// }
 	})
 	.catch((error: unknown) => {
 		console.error("Failed to start SSH Mimic:", error);

package/src/types/commands.ts

@@ -1,12 +1,8 @@
 /** Command invocation mode used by shell runtime. */
 export type CommandMode = "shell" | "exec";
 
-import type {
-	VirtualActiveSession,
-	VirtualUserManager,
-} from "../SSHMimic/users";
-import type VirtualFileSystem from "../VirtualFileSystem";
-import type { ShellProperties } from "../VirtualShell";
+import type { VirtualShell } from "../VirtualShell";
+import type { VirtualActiveSession } from "../VirtualUserManager";
 
 /**
  * Normalized command execution output.
@@ -67,8 +63,6 @@ export interface CommandContext {
 	authUser: string;
 	/** Virtual hostname shown in prompt and banners. */
 	hostname: string;
-	/** User and session manager instance. */
-	users: VirtualUserManager;
 	/** Snapshot of currently active user sessions. */
 	activeSessions: VirtualActiveSession[];
 	/** Original unparsed command line input. */
@@ -78,13 +72,11 @@ export interface CommandContext {
 	/** Tokenized arguments excluding command name. */
 	args: string[];
 	/** Virtual shell instance. */
-	shellProps: ShellProperties;
+	shell: VirtualShell;
 	/** Optional stdin payload (used by pipes/redirections). */
 	stdin?: string;
 	/** Current working directory for command execution. */
 	cwd: string;
-	/** Virtual filesystem instance for IO operations. */
-	vfs: VirtualFileSystem;
 }
 
 /** Contract implemented by each shell command module. */

package/tests/command-helpers.test.ts

@@ -3,7 +3,7 @@ import {
     getArg,
     getFlag,
     ifFlag,
-} from "../src/VirtualShell/commands/command-helpers";
+} from "../src/commands/command-helpers";
 
 describe("command-helpers", () => {
 	test("ifFlag detects plain and inline flag forms", () => {

package/tests/helpers.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import { assertPathAccess } from "../src/VirtualShell/commands/helpers";
+import { assertPathAccess } from "../src/commands/helpers";
 
 describe("assertPathAccess", () => {
 	test("blocks non-root access to auth store", () => {

package/tests/parser-executor.test.ts

@@ -1,7 +1,6 @@
 import { describe, expect, test } from "bun:test";
+import { VirtualShell } from "../src";
 import { executePipeline } from "../src/SSHMimic/executor";
-import { VirtualUserManager } from "../src/SSHMimic/users";
-import VirtualFileSystem from "../src/VirtualFileSystem";
 import { parseShellPipeline } from "../src/VirtualShell/shellParser";
 
 describe("Pipeline parser and executor", () => {
@@ -20,18 +19,16 @@ describe("Pipeline parser and executor", () => {
   });
 
   test("executes simple pipeline", async () => {
-    const vfs = new VirtualFileSystem("/tmp");
-    const users = new VirtualUserManager(vfs, "root-pass");
+    const shell = new VirtualShell("localhost");
     const pipeline = parseShellPipeline("echo hello | grep h");
 
     const result = await executePipeline(
       pipeline,
       "root",
       "localhost",
-      users,
       "shell",
       "/",
-      vfs,
+      shell
     );
 
     expect(result.exitCode).toBe(0);

package/tests/users.test.ts

@@ -2,8 +2,8 @@ import { describe, expect, test } from "bun:test";
 import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { VirtualUserManager } from "../src/SSHMimic/users";
 import VirtualFileSystem from "../src/VirtualFileSystem";
+import { VirtualUserManager } from "../src/VirtualUserManager";
 
 async function withTempVfs(
 	run: (vfs: VirtualFileSystem) => Promise<void>,
@@ -39,3 +39,63 @@ describe("VirtualUserManager auto sudo", () => {
 		});
 	});
 });
+
+describe("VirtualUserManager quotas", () => {
+	test("enforces quota for writes inside user home", async () => {
+		await withTempVfs(async (vfs) => {
+			const users = new VirtualUserManager(vfs, "root-pass");
+			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 () => {
+		await withTempVfs(async (vfs) => {
+			const users = new VirtualUserManager(vfs, "root-pass");
+			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 () => {
+		await withTempVfs(async (vfs) => {
+			const users = new VirtualUserManager(vfs, "root-pass");
+			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();
+		});
+	});
+});