typescript-virtual-container 1.0.8 → 1.1.1

package/.vscode/settings.json

@@ -0,0 +1,18 @@
+{
+    "files.exclude": {
+        "**/.git": true,
+        "**/.hg": true,
+        "**/.svn": true,
+        "**/.DS_Store": true,
+        "**/Thumbs.db": true,
+        "**/node_modules": true,
+
+        ".ssh-mimic": true,
+        ".vfs": true,
+        
+        "LICENSE": true,
+        "*.md": true,
+        "biome.json": true,
+        "tsconfig.tsbuildinfo": true
+    }
+}

package/README.md

@@ -10,6 +10,7 @@
 ## Table of Contents
 
 - [Overview](#overview)
+- [What This Is / What This Is Not](#what-this-is--what-this-is-not)
 - [Why This Package](#why-this-package)
 - [Installation](#installation)
 - [Compatibility](#compatibility)
@@ -42,6 +43,22 @@
 - **Built-in Commands**: `ls`, `cd`, `pwd`, `cat`, `mkdir`, `touch`, `rm`, `tree`, `whoami`, `hostname`, `who`, `sudo`, `su`, `adduser`, `deluser`, `nano` (text editor), `curl`, `wget`, and a growing set of additional commands. Not everything is implemented yet, and shell compatibility is still being expanded.
 - **Full TypeScript Support**: Complete JSDoc coverage, exported types, and first-class async/await for all operations.
 
+## What This Is / What This Is Not
+
+### What This Is
+
+- A virtual shell runtime written in TypeScript.
+- An in-memory environment with its own virtual filesystem, user management, and command runtime.
+- A practical tool for deterministic testing, automation pipelines, and SSH-like workflows without running real containers.
+
+### What This Is Not
+
+- Not a fully isolated container runtime.
+- Not a security sandbox.
+- Not a kernel-level isolation boundary (unlike Docker/VM-based isolation).
+
+This project emulates shell behavior for developer workflows. It is designed for realism and productivity, not hard security isolation.
+
 ## Why This Package
 
 This package is designed for teams that need a realistic SSH-like runtime without spinning up real containers or VMs.
@@ -87,10 +104,10 @@ The virtual filesystem and shell behavior are intentionally portable and do not
 ### Running an SSH Server
 
 ```typescript
-import { VirtualMachine } from "typescript-virtual-container";
+import { VirtualSshServer } from "typescript-virtual-container";
 
 // Create server on port 2222
-const ssh = new VirtualMachine({ 
+const ssh = new VirtualSshServer({ 
 	port: 2222, 
 	hostname: "my-container" 
 });
@@ -112,13 +129,14 @@ process.on("SIGTERM", () => {
 ### Using the Programmatic Client API
 
 ```typescript
-import { VirtualMachine, SshClient } from "typescript-virtual-container";
+import { VirtualSshServer, SshClient, VirtualShell } from "typescript-virtual-container";
 
-const ssh = new VirtualMachine({ port: 2222 });
+const shell = new VirtualShell("typescript-vm");
+const ssh = new VirtualSshServer({ port: 2222, shell });
 await ssh.start();
 
 // Create authenticated client for specific user
-const client = new SshClient(ssh, "root");
+const client = new SshClient(shell, "root");
 
 // Execute commands programmatically
 const list = await client.ls("/home");
@@ -178,7 +196,7 @@ ssh.stop();
 
 ### SshMimic (SSH Server)
 
-Main SSH server class. Manages virtual filesystem, user authentication, and session handlers.
+Main SSH server class, exported as `VirtualSshServer` in the package entrypoint. It wires the virtual shell runtime into ssh2 sessions and manages authentication/session handlers.
 
 #### Constructor
 
@@ -186,17 +204,25 @@ Main SSH server class. Manages virtual filesystem, user authentication, and sess
 new SshMimic(options: {
 	port: number;           // TCP port to bind on localhost
 	hostname?: string;      // Virtual hostname (default: "typescript-vm")
-	basePath?: string;      // Base directory for VFS snapshot storage (default: ".")
+	shell?: VirtualShell;   // Optional preconfigured shell instance
 })
 ```
 
+- `hostname` controls the SSH ident label and the default hostname used by a generated shell.
+- If `shell` is omitted, the server creates `new VirtualShell(hostname)` for you.
+
 **Example:**
 
 ```typescript
+const virtualShell = new VirtualShell("my-lab", {
+	kernel: "1.0.0+itsrealfortune+1-amd64",
+	os: "Fortune GNU/Linux x64",
+	arch: "x86_64",
+}, "./data");
 const ssh = new SshMimic({
 	port: 2222,
 	hostname: "my-lab",
-	basePath: "./data"  // Snapshots stored in ./data/.vfs/mirror.tar.gz
+	shell: virtualShell
 });
 ```
 
@@ -254,21 +280,22 @@ console.log(`Server name: ${ssh.getHostname()}`);
 
 ### SshClient (Programmatic Shell API)
 
-Execute shell commands as a specific user without SSH overhead. Maintains connection state (current working directory) across calls.
+Execute shell commands against a `VirtualShell` instance without SSH overhead. Maintains connection state (current working directory) across calls.
 
 #### Constructor
 
 ```typescript
-new SshClient(ssh: SshMimic, username: string)
+new SshClient(shell: VirtualShell, username: string)
 ```
 
-- **ssh**: Parent SSH server instance (must be started)
+- **shell**: Parent virtual shell instance
 - **username**: User to authenticate as (no password required)
 
 **Example:**
 
 ```typescript
-const client = new SshClient(ssh, "alice");
+const shell = new VirtualShell("typescript-vm");
+const client = new SshClient(shell, "alice");
 ```
 
 #### Methods
@@ -419,30 +446,57 @@ console.log(client.getUsername());  // Username from constructor
 
 ### VirtualShell
 
-Encapsulates shell execution primitives used by the SSH runtime for command dispatch and interactive sessions.
+Encapsulates shell execution primitives used by the SSH runtime for command dispatch, interactive sessions, and the programmatic client.
+
+#### ShellProperties
+
+```typescript
+interface ShellProperties {
+	kernel: string;
+	os: "Fortune GNU/Linux x64";
+	arch: "x86_64";
+}
+
+const defaultShellProperties: ShellProperties;
+```
+
+- `kernel` is displayed in shell/system information output.
+- `os` and `arch` are fixed labels used by the shell runtime.
 
 #### Constructor
 
 ```typescript
 new VirtualShell(
-	vfs: VirtualFileSystem,
-	users: VirtualUserManager,
 	hostname: string,
+	properties?: ShellProperties,
+	basePath?: string,
 )
 ```
 
-- **vfs**: Virtual filesystem instance used by shell commands.
-- **users**: User manager for authentication/session-aware command behavior.
 - **hostname**: Hostname injected into command context and prompt behavior.
+- **properties**: Optional shell metadata. Defaults to `defaultShellProperties`.
+- **basePath**: Optional directory used to resolve `.vfs/mirror.tar.gz` (defaults to `.`).
 
 **Example:**
 
 ```typescript
-const shell = new VirtualShell(vfs, users, "typescript-vm");
+const shell = new VirtualShell("typescript-vm", {
+	kernel: "1.0.0+itsrealfortune+1-amd64",
+	os: "Fortune GNU/Linux x64",
+	arch: "x86_64",
+}, "./data");
 ```
 
 #### Methods
 
+##### `addCommand(name: string, params: string[], callback: (ctx: CommandContext) => CommandResult | Promise<CommandResult>): void`
+
+Registers a custom command at runtime.
+
+```typescript
+shell.addCommand("hello", [], () => ({ stdout: "hello", exitCode: 0 }));
+```
+
 ##### `executeCommand(rawInput: string, authUser: string, cwd: string): void`
 
 Runs one command input in shell mode for a given user and working directory.
@@ -617,11 +671,12 @@ User authentication, password hashing (scrypt), sudo privilege management, and s
 #### Constructor
 
 ```typescript
-new VirtualUserManager(vfs: VirtualFileSystem, defaultRootPassword?: string)
+new VirtualUserManager(vfs: VirtualFileSystem, defaultRootPassword?: string, autoSudoForNewUsers?: boolean)
 ```
 
 - **vfs**: Virtual filesystem (for auth data persistence)
-- **defaultRootPassword**: Root password if creating new user (default: "root")
+- **defaultRootPassword**: Root password used when root is created (default: "root")
+- **autoSudoForNewUsers**: When true, new users are added to sudoers automatically (default: `true` unless `SSH_MIMIC_AUTO_SUDO_NEW_USERS` disables it)
 
 ```typescript
 const users = new VirtualUserManager(vfs, "SecureRootPass123");
@@ -690,6 +745,46 @@ Revokes sudo privileges. Cannot remove root.
 await users.removeSudoer("charlie");
 ```
 
+##### `async setQuotaBytes(username: string, maxBytes: number): Promise<void>`
+
+Sets an optional per-user quota (bytes) for writes under `/home/<username>`.
+
+```typescript
+await users.setQuotaBytes("alice", 5 * 1024 * 1024); // 5 MB
+```
+
+##### `async clearQuota(username: string): Promise<void>`
+
+Removes quota limit for a user.
+
+```typescript
+await users.clearQuota("alice");
+```
+
+##### `getQuotaBytes(username: string): number | null`
+
+Returns configured quota in bytes, or `null` if unlimited.
+
+```typescript
+console.log(users.getQuotaBytes("alice"));
+```
+
+##### `getUsageBytes(username: string): number`
+
+Returns current stored usage in bytes under `/home/<username>`.
+
+```typescript
+console.log(users.getUsageBytes("alice"));
+```
+
+##### `assertWriteWithinQuota(username: string, targetPath: string, nextContent: string | Buffer): void`
+
+Validates a write operation against quota rules; throws when projected usage exceeds quota.
+
+```typescript
+users.assertWriteWithinQuota("alice", "/home/alice/data.txt", "payload");
+```
+
 ##### `registerSession(username: string, remoteAddress: string): VirtualActiveSession`
 
 Creates active session (called on SSH auth). Returns session descriptor with UUID, tty, start time.
@@ -801,9 +896,9 @@ interface VirtualActiveSession {
 Minimal server startup that accepts SSH connections:
 
 ```typescript
-import { VirtualMachine } from "typescript-virtual-container";
+import { VirtualSshServer } from "typescript-virtual-container";
 
-const ssh = new VirtualMachine({
+const ssh = new VirtualSshServer({
 	port: 2222,
 	hostname: "lab-environment"
 });
@@ -835,12 +930,13 @@ ssh root@localhost -p 2222
 Create, read, modify files without SSH:
 
 ```typescript
-import { VirtualMachine, SshClient } from "typescript-virtual-container";
+import { VirtualSshServer, SshClient, VirtualShell } from "typescript-virtual-container";
 
-const ssh = new VirtualMachine({ port: 2222 });
+const shell = new VirtualShell("typescript-vm");
+const ssh = new VirtualSshServer({ port: 2222, shell });
 await ssh.start();
 
-const client = new SshClient(ssh, "root");
+const client = new SshClient(shell, "root");
 
 // Create structure
 await client.mkdir("/app/config", true);
@@ -874,9 +970,10 @@ ssh.stop();
 Create users, manage permissions, session tracking:
 
 ```typescript
-import { VirtualMachine, SshClient } from "typescript-virtual-container";
+import { VirtualSshServer, SshClient, VirtualShell } from "typescript-virtual-container";
 
-const ssh = new VirtualMachine({ port: 2222 });
+const shell = new VirtualShell("typescript-vm");
+const ssh = new VirtualSshServer({ port: 2222, shell });
 await ssh.start();
 
 const users = ssh.getUsers()!;
@@ -891,11 +988,11 @@ await users.removeSudoer("bob");
 await users.addSudoer("alice");
 
 // Alice: High privilege
-const alice = new SshClient(ssh, "alice");
+const alice = new SshClient(shell, "alice");
 await alice.writeFile("/etc/important.conf", "secret=yes");
 
 // Bob: Regular user
-const bob = new SshClient(ssh, "bob");
+const bob = new SshClient(shell, "bob");
 const result = await bob.cat("/etc/important.conf");
 console.log("Bob read file:", result.stderr);
 
@@ -909,12 +1006,13 @@ ssh.stop();
 Save filesystem state between runs:
 
 ```typescript
-import { VirtualMachine } from "typescript-virtual-container";
+import { VirtualSshServer, VirtualShell } from "typescript-virtual-container";
 
 // First run: Initialize
-const ssh1 = new VirtualMachine({ 
+const shell1 = new VirtualShell("typescript-vm", undefined, "./container");
+const ssh1 = new VirtualSshServer({ 
 	port: 2222,
-	basePath: "./container" 
+	shell: shell1 
 });
 await ssh1.start();
 const vfs1 = ssh1.getVfs()!;
@@ -927,9 +1025,10 @@ ssh1.stop();
 console.log("State saved to ./container/.vfs/mirror.tar.gz");
 
 // Later: Reload and continue
-const ssh2 = new VirtualMachine({ 
+const shell2 = new VirtualShell("typescript-vm", undefined, "./container");
+const ssh2 = new VirtualSshServer({ 
 	port: 2223,
-	basePath: "./container" 
+	shell: shell2 
 });
 await ssh2.start();
 const vfs2 = ssh2.getVfs()!;
@@ -948,13 +1047,14 @@ ssh2.stop();
 Simulate filesystem changes and verify outcomes:
 
 ```typescript
-import { VirtualMachine, SshClient } from "typescript-virtual-container";
+import { VirtualSshServer, SshClient, VirtualShell } from "typescript-virtual-container";
 
 async function testDeployment() {
-	const ssh = new VirtualMachine({ port: 2222 });
+	const shell = new VirtualShell("typescript-vm");
+	const ssh = new VirtualSshServer({ port: 2222, shell });
 	await ssh.start();
 
-	const client = new SshClient(ssh, "root");
+	const client = new SshClient(shell, "root");
 
 	// Pre-deployment: Set up base structure
 	await client.mkdir("/srv/app", true);
@@ -984,12 +1084,13 @@ testDeployment().catch(console.error);
 Simulate shell workflows:
 
 ```typescript
-import { VirtualMachine, SshClient } from "typescript-virtual-container";
+import { VirtualSshServer, SshClient, VirtualShell } from "typescript-virtual-container";
 
-const ssh = new VirtualMachine({ port: 2222 });
+const shell = new VirtualShell("typescript-vm");
+const ssh = new VirtualSshServer({ port: 2222, shell });
 await ssh.start();
 
-const client = new SshClient(ssh, "root");
+const client = new SshClient(shell, "root");
 
 // Create nested structure
 await client.mkdir("/home/user/projects/myapp/src", true);
@@ -1026,12 +1127,13 @@ ssh.stop();
 Graceful error handling in programmatic workflows:
 
 ```typescript
-import { VirtualMachine, SshClient } from "typescript-virtual-container";
+import { VirtualSshServer, SshClient, VirtualShell } from "typescript-virtual-container";
 
-const ssh = new VirtualMachine({ port: 2222 });
+const shell = new VirtualShell("typescript-vm");
+const ssh = new VirtualSshServer({ port: 2222, shell });
 await ssh.start();
 
-const client = new SshClient(ssh, "root");
+const client = new SshClient(shell, "root");
 
 // Try read non-existent file
 const result = await client.readFile("/etc/nonexistent.conf");
@@ -1056,32 +1158,42 @@ ssh.stop();
 
 ## Built-in Commands
 
-The following commands are available in both SSH shell mode and via `SshClient.exec()`. This list is intentionally incomplete: some commands, flags, and edge cases are still missing or only partially compatible with real shells, and that will continue to be worked on.
+The following commands are currently registered and available in both SSH shell mode and via `SshClient.exec()`. Some flags and edge-case behavior are still being expanded for shell compatibility.
 
 | Command | Purpose | Notes |
 |---------|---------|-------|
-| `pwd` | Print working directory | No args |
+| `adduser <name> <pass>` | Create user | Root only |
+| `cat <path>` | Read file | Displays content |
 | `cd <path>` | Change directory | Updates client cwd |
+| `clear` | Clear screen | No args |
+| `curl <url>` | Fetch URL | Mock implementation |
+| `deluser <name>` | Delete user | Root only, not root |
+| `echo <text...>` | Print text | Supports shell-like argument output |
+| `env` | List environment variables | Shell environment view |
+| `exit [code]` | Close session | Optional exit code |
+| `export NAME=VALUE` | Set/export environment variable | Persists in shell env |
+| `grep <pattern> [path]` | Search for text | Simplified grep behavior |
+| `help` | List commands | No args |
+| `hostname` | Server hostname | No args |
+| `htop` | System monitor | Mock display |
+| `pwd` | Print working directory | No args |
 | `ls [path]` | List directory | Defaults to `.` |
 | `mkdir [-p] <path>` | Create directory | `-p` for parents |
+| `nano <path>` | Text editor | Interactive mode |
+| `neofetch` | Show system summary | Mock display |
 | `touch <path>` | Create empty file | Updates timestamps |
-| `cat <path>` | Read file | Displays content |
 | `rm [-r] <path>` | Remove file/dir | `-r` for recursive |
-| `tree [path]` | ASCII tree view | Defaults to `.` |
-| `whoami` | Current user | No args |
-| `hostname` | Server hostname | No args |
-| `who` | Active sessions | No args |
-| `sudo [-i] <cmd>` | Elevation | Requires sudoer status |
+| `set` | Show shell options/variables | Simplified behavior |
+| `sh <script>` | Run shell script | Simplified execution model |
 | `su <user>` | Switch user | Requires password/sudo |
-| `adduser <name> <pass>` | Create user | Root only |
-| `deluser <name>` | Delete user | Root only, not root |
-| `curl <url>` | Fetch URL | Mock implementation |
+| `sudo [-i] <cmd>` | Elevation | Requires sudoer status |
+| `tree [path]` | ASCII tree view | Defaults to `.` |
+| `unset <name>` | Remove environment variable | Shell environment update |
 | `wget <url>` | Download | Mock implementation |
-| `nano <path>` | Text editor | Interactive mode |
-| `htop` | System monitor | Mock display |
-| `clear` | Clear screen | No args |
-| `exit [code]` | Close session | Optional exit code |
-| `help` | List commands | No args |
+| `who` | Active sessions | No args |
+| `whoami` | Current user | No args |
+
+Commands can be added via the VirtualShell addCommand() method for custom behavior.
 
 ---
 
@@ -1105,10 +1217,11 @@ npm run start
 ### Runtime Options
 
 ```typescript
-const ssh = new VirtualMachine({
+const shell = new VirtualShell("my-container", undefined, "./data");
+const ssh = new VirtualSshServer({
 	port: 2222,                    // Required
 	hostname: "my-container",      // Optional
-	basePath: "./data"             // Optional, default: "."
+	shell                          // Optional, prebuilt shell instance
 });
 ```
 
@@ -1131,8 +1244,9 @@ const ssh = new VirtualMachine({
 **Example:**
 
 ```typescript
-const client1 = new SshClient(ssh, "alice");
-const client2 = new SshClient(ssh, "bob");
+const shell = new VirtualShell("typescript-vm");
+const client1 = new SshClient(shell, "alice");
+const client2 = new SshClient(shell, "bob");
 
 const [result1, result2] = await Promise.all([
 	client1.writeFile("/tmp/alice.txt", "..."),
@@ -1202,7 +1316,7 @@ Error: listen EADDRINUSE :::2222
 **Solution**: Use a different port
 
 ```typescript
-const ssh = new VirtualMachine({ port: 3333 });
+const ssh = new VirtualSshServer({ port: 3333 });
 ```
 
 ### SSH Authentication Failed
@@ -1239,29 +1353,6 @@ await ssh.getVfs().flushMirror();
 
 ---
 
-## Migration Guide
-
-### From v0.0.x to v1.x
-
-Old API:
-
-```typescript
-const ssh = new SshMimic(2222, "hostname");
-```
-
-New API:
-
-```typescript
-const ssh = new VirtualMachine({ port: 2222, hostname: "hostname" });
-```
-
-**Changes**:
-- Object-based constructor
-- Optional `basePath` parameter
-- Exports renamed: `SshMimic` → `VirtualMachine` from main entry
-
----
-
 ## Contributing
 
 1. Fork repository
@@ -1307,9 +1398,9 @@ MIT License. See LICENSE file for details.
 
 ## Roadmap
 
-- [ ] Custom command plugin API
-- [ ] Optional per-user quotas for virtual filesystem usage
-- [ ] Improved shell compatibility for complex piping and redirection
+- [x] Custom command plugin API
+- [x] Optional per-user quotas for virtual filesystem usage
+- [x] Improved shell compatibility for complex piping and redirection
 - [ ] Snapshot diff tooling for test assertions
-- [ ] Structured event hooks (session open/close, file write, sudo challenge)
+- [x] Structured event hooks (session open/close, file write, sudo challenge)
 - [ ] WebSocket-based remote shell client (experimental)

package/modules/shellInteractive.ts

@@ -0,0 +1,45 @@
+import { type ChildProcessWithoutNullStreams, spawn } from "node:child_process";
+import type { ShellStream } from "../src/types/streams";
+import { shellQuote, type TerminalSize, withTerminalSize } from "./shellRuntime";
+
+function spawnScriptProcess(
+	command: string,
+	terminalSize: TerminalSize,
+	stream: ShellStream,
+): ChildProcessWithoutNullStreams {
+	const formatted = withTerminalSize(command, terminalSize);
+	const proc = spawn("script", ["-qfec", formatted, "/dev/null"], {
+		stdio: ["pipe", "pipe", "pipe"],
+		env: {
+			...process.env,
+			// biome-ignore lint/style/useNamingConvention: env variable should be uppercase
+			TERM: process.env.TERM ?? "xterm-256color",
+		},
+	});
+
+	proc.stdout.on("data", (data: Buffer) => {
+		stream.write(data.toString("utf8"));
+	});
+
+	proc.stderr.on("data", (data: Buffer) => {
+		stream.write(data.toString("utf8"));
+	});
+
+	return proc;
+}
+
+export function spawnNanoEditorProcess(
+	tempPath: string,
+	terminalSize: TerminalSize,
+	stream: ShellStream,
+): ChildProcessWithoutNullStreams {
+	return spawnScriptProcess(`nano -- ${shellQuote(tempPath)}`, terminalSize, stream);
+}
+
+export function spawnHtopProcess(
+	pidList: string,
+	terminalSize: TerminalSize,
+	stream: ShellStream,
+): ChildProcessWithoutNullStreams {
+	return spawnScriptProcess(`htop -p ${shellQuote(pidList)}`, terminalSize, stream);
+}

package/modules/shellRuntime.ts

@@ -0,0 +1,76 @@
+import { readFile } from "node:fs/promises";
+import * as path from "node:path";
+
+export interface TerminalSize {
+	cols: number;
+	rows: number;
+}
+
+export function shellQuote(value: string): string {
+	return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+
+export function toTtyLines(text: string): string {
+	return text
+		.replace(/\r\n/g, "\n")
+		.replace(/\r/g, "\n")
+		.replace(/\n/g, "\r\n");
+}
+
+export function withTerminalSize(
+	command: string,
+	terminalSize: TerminalSize,
+): string {
+	const cols =
+		Number.isFinite(terminalSize.cols) && terminalSize.cols > 0
+			? Math.floor(terminalSize.cols)
+			: 80;
+	const rows =
+		Number.isFinite(terminalSize.rows) && terminalSize.rows > 0
+			? Math.floor(terminalSize.rows)
+			: 24;
+	return `stty cols ${cols} rows ${rows} 2>/dev/null; ${command}`;
+}
+
+export function resolvePath(base: string, inputPath: string): string {
+	if (!inputPath || inputPath.trim() === "" || inputPath === ".") {
+		return base;
+	}
+	return inputPath.startsWith("/")
+		? path.posix.normalize(inputPath)
+		: path.posix.normalize(path.posix.join(base, inputPath));
+}
+
+export async function collectChildPids(parentPid: number): Promise<number[]> {
+	try {
+		const childrenRaw = await readFile(
+			`/proc/${parentPid}/task/${parentPid}/children`,
+			"utf8",
+		);
+		const directChildren = childrenRaw
+			.trim()
+			.split(/\s+/)
+			.filter(Boolean)
+			.map((value) => Number.parseInt(value, 10))
+			.filter((pid) => Number.isInteger(pid) && pid > 0);
+
+		const nested = await Promise.all(
+			directChildren.map((pid) => collectChildPids(pid)),
+		);
+		return [...directChildren, ...nested.flat()];
+	} catch {
+		return [];
+	}
+}
+
+export async function getVisibleHtopPidList(
+	rootPid = process.pid,
+): Promise<string | null> {
+	const descendants = await collectChildPids(rootPid);
+	const unique = Array.from(new Set(descendants)).sort((a, b) => a - b);
+	if (unique.length === 0) {
+		return null;
+	}
+
+	return unique.join(",");
+}

package/package.json

@@ -3,7 +3,7 @@
   "description": "In-memory SSH server with virtual filesystem and typed programmatic API",
   "module": "src/index.ts",
   "type": "module",
-  "version": "1.0.8",
+  "version": "1.1.1",
   "license": "MIT",
   "keywords": [
     "ssh",