typescript-virtual-container 1.3.1 → 1.3.3

package/src/VirtualShell/index.ts

@@ -8,6 +8,7 @@ import {
 } from "../modules/linuxRootfs";
 import type { CommandContext, CommandResult } from "../types/commands";
 import type { ShellStream } from "../types/streams";
+import type { VfsNodeStats } from "../types/vfs";
 import type { PerfLogger } from "../utils/perfLogger";
 import { createPerfLogger } from "../utils/perfLogger";
 import VirtualFileSystem, { type VfsOptions } from "../VirtualFileSystem";
@@ -40,6 +41,56 @@ export interface ShellProperties {
 	arch: string;
 }
 
+export interface VirtualShellVfsLike {
+	restoreMirror(): Promise<void>;
+	flushMirror(): Promise<void>;
+	writeFile(targetPath: string, content: string | Uint8Array): void;
+	readFile(targetPath: string): string;
+	mkdir(targetPath: string, mode?: number): void;
+	exists(targetPath: string): boolean;
+	stat(targetPath: string): VfsNodeStats;
+	list(targetPath: string): string[];
+	remove(targetPath: string, options?: { recursive?: boolean }): void;
+	chmod?(targetPath: string, mode: number): void;
+	symlink?(targetPath: string, linkPath: string): void;
+	getUsageBytes?(targetPath?: string): number;
+}
+
+export interface VirtualShellVfsOptions {
+	vfsInstance?: VirtualShellVfsLike;
+}
+
+function hasVfsInstance(obj: unknown): obj is { vfsInstance: VirtualShellVfsLike } {
+	return (
+		typeof obj === "object" &&
+		obj !== null &&
+		"vfsInstance" in obj &&
+		isVirtualShellVfsLike((obj as Record<string, unknown>).vfsInstance)
+	);
+}
+
+function isVirtualShellVfsLike(value: unknown): value is VirtualShellVfsLike {
+	if (typeof value !== "object" || value === null) {
+		return false;
+	}
+
+	const candidate = value as Record<string, unknown>;
+	return (
+		typeof candidate.restoreMirror === "function" &&
+		typeof candidate.flushMirror === "function" &&
+		typeof candidate.writeFile === "function" &&
+		typeof candidate.readFile === "function" &&
+		typeof candidate.mkdir === "function" &&
+		typeof candidate.exists === "function" &&
+		typeof candidate.stat === "function" &&
+		typeof candidate.list === "function" &&
+		typeof candidate.remove === "function" &&
+		typeof candidate.copy === "function" &&
+		typeof candidate.move === "function" &&
+		typeof candidate.touch === "function"
+	);
+}
+
 const defaultShellProperties: ShellProperties = {
 	kernel: "1.0.0+itsrealfortune+1-amd64",
 	os: "Fortune GNU/Linux x64",
@@ -104,14 +155,21 @@ class VirtualShell extends EventEmitter {
 	constructor(
 		hostname: string,
 		properties?: ShellProperties,
-		vfsOptions?: VfsOptions,
+		vfsOptionsOrInstance?: VfsOptions | VirtualShellVfsLike | VirtualShellVfsOptions,
 	) {
 		super();
 		perf.mark("constructor");
 		this.hostname = hostname;
 		this.properties = properties || defaultShellProperties;
 		this.startTime = Date.now();
-		this.vfs = new VirtualFileSystem(vfsOptions ?? {});
+
+		if (isVirtualShellVfsLike(vfsOptionsOrInstance)) {
+			this.vfs = vfsOptionsOrInstance as unknown as VirtualFileSystem;
+		} else if (hasVfsInstance(vfsOptionsOrInstance)) {
+			this.vfs = vfsOptionsOrInstance.vfsInstance as unknown as VirtualFileSystem;
+		} else {
+			this.vfs = new VirtualFileSystem((vfsOptionsOrInstance as VfsOptions) ?? {});
+		}
 		this.users = new VirtualUserManager(this.vfs, resolveAutoSudoForNewUsers());
 		this.packageManager = new VirtualPackageManager(this.vfs, this.users);
 

package/src/VirtualShell/shell.ts

@@ -3,7 +3,6 @@ import { readFile, unlink, writeFile } from "node:fs/promises";
 import * as path from "node:path";
 import type { ShellProperties, VirtualShell } from ".";
 import { getCommandNames, makeDefaultEnv, runCommand } from "../commands";
-import type { ShellEnv } from "../types/commands";
 import {
 	spawnHtopProcess,
 	spawnNanoEditorProcess,
@@ -14,8 +13,9 @@ import {
 	type TerminalSize,
 	toTtyLines,
 } from "../modules/shellRuntime";
-import { formatLoginDate } from "../SSHMimic/loginFormat";
+import { buildLoginBanner } from "../SSHMimic/loginBanner";
 import { buildPrompt } from "../SSHMimic/prompt";
+import type { ShellEnv } from "../types/commands";
 import type { ShellStream } from "../types/streams";
 import type VirtualFileSystem from "../VirtualFileSystem";
 
@@ -411,35 +411,7 @@ export function startShell(
 	function renderLoginBanner(): void {
 		const last = readLastLogin();
 		const nowIso = new Date().toISOString();
-
-		stream.write(
-			`Linux ${hostname} ${properties.kernel} ${properties.arch}\r\n`,
-		);
-		stream.write("\r\n");
-		stream.write(
-			"The programs included with the Fortune GNU/Linux system are free software;\r\n",
-		);
-		stream.write(
-			"the exact distribution terms for each program are described in the\r\n",
-		);
-		stream.write("individual files in /usr/share/doc/*/copyright.\r\n");
-		stream.write("\r\n");
-		stream.write(
-			"Fortune GNU/Linux comes with ABSOLUTELY NO WARRANTY, to the extent\r\n",
-		);
-		stream.write("permitted by applicable law.\r\n");
-
-		if (last) {
-			const when = new Date(last.at);
-			const displayed = Number.isNaN(when.getTime())
-				? last.at
-				: formatLoginDate(when);
-			stream.write(
-				`Last login: ${displayed} from ${last.from || "unknown"}\r\n`,
-			);
-		}
-
-		stream.write("\r\n");
+		stream.write(buildLoginBanner(hostname, properties, last));
 		writeLastLogin(nowIso);
 	}
 

package/src/self-standalone.ts

@@ -0,0 +1,183 @@
+import { basename } from "node:path";
+import { stdin, stdout } from "node:process";
+import { createInterface, type Interface } from "node:readline";
+
+import { makeDefaultEnv, runCommand } from "./commands/runtime";
+import { buildLoginBanner, type LoginBannerState } from "./SSHMimic/loginBanner";
+import { buildPrompt } from "./SSHMimic/prompt";
+import { VirtualShell } from "./VirtualShell";
+
+const hostname = process.env.SSH_MIMIC_HOSTNAME ?? "typescript-vm";
+const argv = process.argv.slice(2);
+
+function readUserArg(): string {
+	for (let index = 0; index < argv.length; index += 1) {
+		const current = argv[index];
+		if (current === "--user") {
+			const next = argv[index + 1];
+			if (!next || next.startsWith("--")) {
+				throw new Error("self-standalone: --user requires a value");
+			}
+			return next;
+		}
+		if (current?.startsWith("--user=")) {
+			return current.slice("--user=".length) || "root";
+		}
+	}
+
+	return "root";
+}
+
+const initialUser = readUserArg();
+const virtualShell = new VirtualShell(hostname, undefined, {
+	mode: "fs",
+	snapshotPath: ".vfs",
+});
+
+function readLastLogin(username: string): LoginBannerState | null {
+	const lastlogPath = `/virtual-env-js/.lastlog/${username}.json`;
+	if (!virtualShell.vfs.exists(lastlogPath)) {
+		return null;
+	}
+
+	try {
+		return JSON.parse(virtualShell.vfs.readFile(lastlogPath)) as LoginBannerState;
+	} catch {
+		return null;
+	}
+}
+
+function askQuestion(rl: Interface, promptText: string): Promise<string> {
+	return new Promise((resolve) => {
+		rl.question(promptText, resolve);
+	});
+}
+
+function writeLastLogin(username: string, from: string): void {
+	const dir = "/virtual-env-js/.lastlog";
+	if (!virtualShell.vfs.exists(dir)) {
+		virtualShell.vfs.mkdir(dir, 0o700);
+	}
+
+	virtualShell.vfs.writeFile(
+		`/virtual-env-js/.lastlog/${username}.json`,
+		JSON.stringify({ at: new Date().toISOString(), from }),
+	);
+}
+
+virtualShell.addCommand("demo", [], () => {
+	return {
+		stdout: "This is a demo command. It does nothing useful.",
+		exitCode: 0,
+	};
+});
+
+async function runReadlineShell() {
+	const rl = createInterface({ input: stdin, output: stdout, terminal: true });
+	await virtualShell.ensureInitialized();
+
+	const selectedUser = initialUser.trim() || "root";
+	const userExists = virtualShell.users.getPasswordHash(selectedUser) !== null;
+	if (!userExists) {
+		process.stderr.write(`self-standalone: user '${selectedUser}' does not exist\n`);
+		process.exit(1);
+	}
+
+	const shellEnv = makeDefaultEnv(selectedUser, hostname);
+	let authUser = selectedUser;
+	let cwd = `/home/${authUser}`;
+	shellEnv.vars.PWD = cwd;
+	const remoteAddress = "localhost";
+
+	if (process.env.USER !== "root" && virtualShell.users.hasPassword(authUser)) {
+		const password = await askQuestion(rl, `Password for ${authUser}: `);
+		if (!virtualShell.users.verifyPassword(authUser, password)) {
+			process.stderr.write("self-standalone: authentication failed\n");
+			process.exit(1);
+		}
+	}
+
+	const renderPrompt = (): string => {
+		const cwdLabel = cwd === `/home/${authUser}` ? "~" : basename(cwd) || "/";
+		return buildPrompt(authUser, hostname, cwdLabel);
+	};
+
+	const prompt = (): void => {
+		rl.setPrompt(renderPrompt());
+		rl.prompt();
+	};
+
+	rl.on("SIGINT", () => {
+		stdout.write("^C\n");
+		rl.write("", { ctrl: true, name: "u" });
+		prompt();
+	});
+
+	rl.on("close", () => {
+		console.log("")
+		process.exit(0);
+	});
+
+	stdout.write(buildLoginBanner(hostname, virtualShell.properties, readLastLogin(authUser)));
+	writeLastLogin(authUser, remoteAddress);
+	prompt();
+
+	while (true) {
+		const inputLine = await new Promise<string>((resolve) => {
+			rl.once("line", (line) => resolve(line));
+		});
+
+		rl.pause();
+
+		const result = await runCommand(inputLine, authUser, hostname, "shell", cwd, virtualShell, undefined, shellEnv);
+
+		if (result.stdout) {
+			stdout.write(result.stdout.endsWith("\n") ? result.stdout : `${result.stdout}\n`);
+		}
+
+		if (result.stderr) {
+			process.stderr.write(result.stderr.endsWith("\n") ? result.stderr : `${result.stderr}\n`);
+		}
+
+		if (result.clearScreen) {
+			stdout.write("\u001b[2J\u001b[H");
+		}
+
+		if (result.switchUser) {
+			authUser = result.switchUser;
+			cwd = result.nextCwd ?? `/home/${authUser}`;
+			shellEnv.vars.USER = authUser;
+			shellEnv.vars.LOGNAME = authUser;
+			shellEnv.vars.HOME = `/home/${authUser}`;
+			shellEnv.vars.PWD = cwd;
+		} else if (result.nextCwd) {
+			cwd = result.nextCwd;
+			shellEnv.vars.PWD = cwd;
+		}
+
+		if (result.closeSession) {
+			rl.close();
+			process.exit(result.exitCode ?? 0);
+		}
+
+		prompt();
+		rl.resume();
+	}
+}
+
+runReadlineShell().catch((error: unknown) => {
+	console.error("Failed to start readline SSH emulation:", error);
+	process.exit(1);
+});
+
+process.on("uncaughtException", (error) => {
+	console.log("Oh my god, something terrible happened: ", error);
+});
+
+process.on("unhandledRejection", (error, promise) => {
+	console.log(
+		" Oh Lord! We forgot to handle a promise rejection here: ",
+		promise,
+	);
+	console.log(" The error was: ", error);
+});

package/src/web-api.ts

@@ -0,0 +1,62 @@
+import type { CommandResult, ShellEnv, } from "./types/commands";
+import { createWebShell } from "./web";
+
+/**
+ * Browser shim that exposes a VirtualShell-like API backed by the WebShell
+ * implementation (IndexedDB mirror). This avoids importing Node-only
+ * modules while providing a familiar surface for browser demos.
+ */
+class VirtualShellShim {
+  private readonly shell: ReturnType<typeof createWebShell>;
+
+  constructor(hostname = "typescript-vm") {
+    this.shell = createWebShell(hostname, {});
+  }
+
+  async ensureInitialized(): Promise<void> {
+    await this.shell.ensureInitialized();
+  }
+
+  /** Execute a command line and return the command result. */
+  async executeCommandLine(raw: string): Promise<CommandResult> {
+    return this.shell.executeCommandLine(raw);
+  }
+
+  /** Alias for executeCommandLine to match some APIs. */
+  async run(raw: string): Promise<CommandResult> {
+    return this.executeCommandLine(raw);
+  }
+
+  getVfs() {
+    return this.shell.vfs;
+  }
+
+  getHostname() {
+    return this.shell.hostname;
+  }
+
+  /** Minimal compatibility: write a file as user (no quota checks in browser). */
+  writeFileAsUser(_authUser: string, targetPath: string, content: string | Uint8Array) {
+    return this.shell.vfs.writeFile(targetPath, content);
+  }
+
+  /** Expose env for simple inspection */
+  getEnv(): ShellEnv {
+    return this.shell.env as ShellEnv;
+  }
+
+  /** Register a custom command into the web shell. */
+  addCommand(name: string, params: string[], callback: (ctx: unknown) => CommandResult | Promise<CommandResult>) {
+    // WebShell keeps a private register() method; cast to a minimal register shape.
+    const registrable = this.shell as unknown as {
+      register(cmd: { name: string; params: string[]; aliases: string[]; description: string; run: (c: unknown) => CommandResult | Promise<CommandResult> }): void;
+    };
+    registrable.register({ name, params, aliases: [], description: "", run: callback });
+  }
+}
+
+export function createVirtualShellShim(hostname?: string) {
+  return new VirtualShellShim(hostname);
+}
+
+export type { VirtualShellShim };

package/src/web-full.ts

@@ -0,0 +1,11 @@
+import VirtualFileSystem from "./VirtualFileSystem";
+import { VirtualShell } from "./VirtualShell";
+
+export function createFullWebShell(hostname = "typescript-vm") {
+  // Use the real VirtualFileSystem so the existing shell runtime gets the full
+  // API surface it expects. The default persistence mode is in-memory, which
+  // keeps this usable in browser bundles without a host filesystem.
+  return new VirtualShell(hostname, undefined, new VirtualFileSystem({}));
+}
+
+export type { VirtualShell } from "./VirtualShell";