typescript-virtual-container 1.0.4 → 1.0.6

package/src/VirtualShell/commands/command-helpers.ts

@@ -0,0 +1,135 @@
+type ArgParseOptions = {
+	flags?: string[];
+	flagsWithValue?: string[];
+};
+
+function toFlagList(flags: string | string[]): string[] {
+	return Array.isArray(flags) ? flags : [flags];
+}
+
+function matchFlagToken(
+	token: string,
+	flag: string,
+): { matched: boolean; inlineValue: string | null } {
+	if (token === flag) {
+		return { matched: true, inlineValue: null };
+	}
+
+	const prefix = `${flag}=`;
+	if (token.startsWith(prefix)) {
+		return { matched: true, inlineValue: token.slice(prefix.length) };
+	}
+
+	return { matched: false, inlineValue: null };
+}
+
+function collectPositionals(
+	args: string[],
+	options: ArgParseOptions = {},
+): string[] {
+	const boolFlags = new Set(options.flags ?? []);
+	const valueFlags = new Set(options.flagsWithValue ?? []);
+	const positionals: string[] = [];
+	let passthrough = false;
+
+	for (let index = 0; index < args.length; index += 1) {
+		const arg = args[index]!;
+
+		if (passthrough) {
+			positionals.push(arg);
+			continue;
+		}
+
+		if (arg === "--") {
+			passthrough = true;
+			continue;
+		}
+
+		let consumed = false;
+
+		for (const flag of boolFlags) {
+			const { matched } = matchFlagToken(arg, flag);
+			if (matched) {
+				consumed = true;
+				break;
+			}
+		}
+
+		if (consumed) {
+			continue;
+		}
+
+		for (const flag of valueFlags) {
+			const match = matchFlagToken(arg, flag);
+			if (!match.matched) {
+				continue;
+			}
+
+			consumed = true;
+			if (match.inlineValue === null && index + 1 < args.length) {
+				index += 1;
+			}
+			break;
+		}
+
+		if (!consumed) {
+			positionals.push(arg);
+		}
+	}
+
+	return positionals;
+}
+
+export function ifFlag(args: string[], flags: string | string[]): boolean {
+	const allFlags = toFlagList(flags);
+
+	for (const arg of args) {
+		for (const flag of allFlags) {
+			if (matchFlagToken(arg, flag).matched) {
+				return true;
+			}
+		}
+	}
+
+	return false;
+}
+
+export function getFlag(
+	args: string[],
+	flags: string | string[],
+): string | true | undefined {
+	const allFlags = toFlagList(flags);
+
+	for (let index = 0; index < args.length; index += 1) {
+		const arg = args[index]!;
+
+		for (const flag of allFlags) {
+			const match = matchFlagToken(arg, flag);
+			if (!match.matched) {
+				continue;
+			}
+
+			if (match.inlineValue !== null) {
+				return match.inlineValue;
+			}
+
+			const next = args[index + 1];
+			if (next !== undefined && next !== "--") {
+				return next;
+			}
+
+			return true;
+		}
+	}
+
+	return undefined;
+}
+
+export function getArg(
+	args: string[],
+	index: number,
+	options: ArgParseOptions = {},
+): string | undefined {
+	const positionals = collectPositionals(args, options);
+	return positionals[index];
+}

package/src/{SSHMimic → VirtualShell}/commands/curl.ts

@@ -1,43 +1,12 @@
 import { spawn } from "node:child_process";
 import type { ShellModule } from "../../types/commands";
+import { getArg, getFlag, ifFlag } from "./command-helpers";
 import {
 	assertPathAccess,
 	normalizeTerminalOutput,
 	resolvePath,
 } from "./helpers";
 
-function parseCurlOutputPath(args: string[]): {
-	outputPath: string | null;
-	inputArgs: string[];
-} {
-	const filtered: string[] = [];
-	let outputPath: string | null = null;
-
-	for (let index = 0; index < args.length; index += 1) {
-		const arg = args[index]!;
-
-		if (arg === "-o" || arg === "--output") {
-			outputPath = args[index + 1] ?? null;
-			index += 1;
-			continue;
-		}
-
-		if (arg.startsWith("-o=")) {
-			outputPath = arg.slice(3);
-			continue;
-		}
-
-		if (arg.startsWith("--output=")) {
-			outputPath = arg.slice("--output=".length);
-			continue;
-		}
-
-		filtered.push(arg);
-	}
-
-	return { outputPath, inputArgs: filtered };
-}
-
 function runHostCurl(args: string[]): Promise<{
 	stdout: string;
 	stderr: string;
@@ -110,12 +79,22 @@ export const curlCommand: ShellModule = {
 	name: "curl",
 	params: ["[-o file] <url>"],
 	run: async ({ authUser, vfs, cwd, args }) => {
-		const { outputPath, inputArgs } = parseCurlOutputPath(args);
+		const outputPathValue = getFlag(args, ["-o", "--output"]);
+		const outputPath =
+			typeof outputPathValue === "string" && outputPathValue.length > 0
+				? outputPathValue
+				: null;
+		const parserOptions = { flagsWithValue: ["-o", "--output"] };
+		const inputArgs: string[] = [];
+		for (let index = 0; ; index += 1) {
+			const arg = getArg(args, index, parserOptions);
+			if (!arg) {
+				break;
+			}
+			inputArgs.push(arg);
+		}
 		const url = inputArgs[0];
-		const isHelpLike = inputArgs.some(
-			(arg) =>
-				arg === "-h" || arg === "--help" || arg === "-V" || arg === "--version",
-		);
+		const isHelpLike = ifFlag(args, ["-h", "--help", "-V", "--version"]);
 
 		if (!url) {
 			return { stderr: "curl: missing URL", exitCode: 1 };

package/src/{SSHMimic → VirtualShell}/commands/echo.ts

@@ -1,4 +1,5 @@
 import type { ShellModule } from "../../types/commands";
+import { getArg, ifFlag } from "./command-helpers";
 import { getAllEnvVars } from "./set";
 
 function expandEnvVars(input: string, env: Record<string, string>): string {
@@ -11,8 +12,15 @@ export const echoCommand: ShellModule = {
 	name: "echo",
 	params: ["[options] [text...]"],
 	run: ({ args, authUser, stdin }) => {
-		const newline = !args.includes("-n");
-		const filteredArgs = args.filter((arg) => arg !== "-n");
+		const newline = !ifFlag(args, "-n");
+		const filteredArgs: string[] = [];
+		for (let index = 0; ; index += 1) {
+			const value = getArg(args, index, { flags: ["-n"] });
+			if (value === undefined) {
+				break;
+			}
+			filteredArgs.push(value);
+		}
 		const env = getAllEnvVars(authUser);
 		const rawText =
 			filteredArgs.length > 0 ? filteredArgs.join(" ") : (stdin ?? "");

package/src/{SSHMimic → VirtualShell}/commands/export.ts

@@ -1,4 +1,5 @@
 import type { ShellModule } from "../../types/commands";
+import { getArg } from "./command-helpers";
 import { getEnvVar, setEnvVar } from "./set";
 
 export const exportCommand: ShellModule = {
@@ -15,7 +16,12 @@ export const exportCommand: ShellModule = {
 		}
 
 		// Parse VAR=value format
-		for (const arg of args) {
+		for (let index = 0; ; index += 1) {
+			const arg = getArg(args, index);
+			if (!arg) {
+				break;
+			}
+
 			if (arg.includes("=")) {
 				const [varName, varValue] = arg.split("=", 2);
 				if (varName && varValue !== undefined) {

package/src/{SSHMimic → VirtualShell}/commands/grep.ts

@@ -1,25 +1,32 @@
 import type { ShellModule } from "../../types/commands";
+import { getArg, ifFlag } from "./command-helpers";
 import { assertPathAccess, resolvePath } from "./helpers";
 
 export const grepCommand: ShellModule = {
 	name: "grep",
 	params: ["[-i] [-v] <pattern> [file...]"],
 	run: ({ authUser, vfs, cwd, args, stdin }) => {
-		const caseInsensitive = args.includes("-i");
-		const invertMatch = args.includes("-v");
-		const filteredArgs = args.filter((arg) => arg !== "-i" && arg !== "-v");
+		const caseInsensitive = ifFlag(args, "-i");
+		const invertMatch = ifFlag(args, "-v");
+		const parserOptions = { flags: ["-i", "-v"] };
+		const pattern = getArg(args, 0, parserOptions);
+		const files: string[] = [];
+		for (let index = 1; ; index += 1) {
+			const file = getArg(args, index, parserOptions);
+			if (!file) {
+				break;
+			}
+			files.push(file);
+		}
 
-		if (filteredArgs.length === 0) {
+		if (!pattern) {
 			return { stderr: "grep: no pattern specified", exitCode: 1 };
 		}
 
-		const pattern = filteredArgs[0];
-		const files = filteredArgs.slice(1);
-
 		let regex: RegExp;
 		try {
 			const flags = caseInsensitive ? "gmi" : "gm";
-			regex = new RegExp(pattern as string, flags);
+			regex = new RegExp(pattern, flags);
 		} catch {
 			return { stderr: `grep: invalid regex: ${pattern}`, exitCode: 1 };
 		}

package/src/{SSHMimic → VirtualShell}/commands/helpers.ts

@@ -58,43 +58,6 @@ export function assertPathAccess(
 	}
 }
 
-export function parseOutputPath(args: string[]): {
-	outputPath: string | null;
-	inputArgs: string[];
-} {
-	const filtered: string[] = [];
-	let outputPath: string | null = null;
-
-	for (let index = 0; index < args.length; index += 1) {
-		const arg = args[index]!;
-
-		if (
-			arg === "-o" ||
-			arg === "-O" ||
-			arg === "--output" ||
-			arg === "--output-document"
-		) {
-			outputPath = args[index + 1] ?? null;
-			index += 1;
-			continue;
-		}
-
-		if (arg.startsWith("-o=")) {
-			outputPath = arg.slice(3);
-			continue;
-		}
-
-		if (arg.startsWith("-O=")) {
-			outputPath = arg.slice(3);
-			continue;
-		}
-
-		filtered.push(arg);
-	}
-
-	return { outputPath, inputArgs: filtered };
-}
-
 export function stripUrlFilename(url: string): string {
 	const cleaned = url.split("?")[0]?.split("#")[0] ?? url;
 	const lastPart = cleaned.split("/").filter(Boolean).pop();

package/src/{SSHMimic → VirtualShell}/commands/index.ts

@@ -1,11 +1,13 @@
+import type { ShellProperties } from "..";
+import type { VirtualUserManager } from "../../SSHMimic/users";
 import type {
+	CommandContext,
 	CommandMode,
 	CommandOutcome,
 	CommandResult,
 	ShellModule,
 } from "../../types/commands";
 import type VirtualFileSystem from "../../VirtualFileSystem";
-import type { VirtualUserManager } from "../users";
 import { adduserCommand } from "./adduser";
 import { catCommand } from "./cat";
 import { cdCommand } from "./cd";
@@ -23,6 +25,7 @@ import { htopCommand } from "./htop";
 import { lsCommand } from "./ls";
 import { mkdirCommand } from "./mkdir";
 import { nanoCommand } from "./nano";
+import { neofetchCommand } from "./neofetch";
 import { pwdCommand } from "./pwd";
 import { rmCommand } from "./rm";
 import { setCommand } from "./set";
@@ -50,6 +53,7 @@ const BASE_COMMANDS: ShellModule[] = [
 	rmCommand,
 	treeCommand,
 	nanoCommand,
+	neofetchCommand,
 	htopCommand,
 	adduserCommand,
 	deluserCommand,
@@ -67,18 +71,72 @@ const BASE_COMMANDS: ShellModule[] = [
 	exitCommand,
 ];
 
-const COMMANDS: ShellModule[] = [
-	...BASE_COMMANDS,
-	createHelpCommand(() => COMMANDS.map((cmd) => cmd.name)),
-];
+const customCommands: ShellModule[] = [];
+
+const helpCommand = createHelpCommand(() =>
+	getCommandModules().map((cmd) => cmd.name),
+);
+
+function getCommandModules(): ShellModule[] {
+	return [...BASE_COMMANDS, ...customCommands, helpCommand];
+}
+
+function getTakenCommandNames(modules: ShellModule[]): Set<string> {
+	const taken = new Set<string>();
+	for (const mod of modules) {
+		taken.add(mod.name);
+		for (const alias of mod.aliases ?? []) {
+			taken.add(alias);
+		}
+	}
+	return taken;
+}
+
+export function registerCommand(module: ShellModule): void {
+	const normalized: ShellModule = {
+		...module,
+		name: module.name.trim().toLowerCase(),
+		aliases: module.aliases?.map((alias) => alias.trim().toLowerCase()),
+	};
+
+	const names = [normalized.name, ...(normalized.aliases ?? [])];
+	if (names.some((name) => name.length === 0 || /\s/.test(name))) {
+		throw new Error(
+			"Command names and aliases must be non-empty and contain no spaces",
+		);
+	}
+
+	const takenNames = getTakenCommandNames(getCommandModules());
+	const conflict = names.find((name) => takenNames.has(name));
+	if (conflict) {
+		throw new Error(`Command '${conflict}' already exists`);
+	}
+
+	customCommands.push(normalized);
+}
+
+export function createCustomCommand(
+	name: string,
+	params: string[],
+	run: (ctx: CommandContext) => CommandResult | Promise<CommandResult>,
+): ShellModule {
+	return {
+		name,
+		params,
+		run,
+	};
+}
 
 export function getCommandNames(): string[] {
-	return COMMANDS.flatMap((cmd) => [cmd.name, ...(cmd.aliases ?? [])]);
+	return getCommandModules().flatMap((cmd) => [
+		cmd.name,
+		...(cmd.aliases ?? []),
+	]);
 }
 
 function resolveModule(name: string): ShellModule | undefined {
 	const lowered = name.toLowerCase();
-	return COMMANDS.find(
+	return getCommandModules().find(
 		(cmd) => cmd.name === lowered || cmd.aliases?.includes(lowered),
 	);
 }
@@ -141,6 +199,7 @@ async function runCommandInternal(
 	users: VirtualUserManager,
 	mode: CommandMode,
 	cwd: string,
+	shellProps: ShellProperties,
 	vfs: VirtualFileSystem,
 	stdin?: string,
 ): Promise<CommandResult> {
@@ -152,7 +211,7 @@ async function runCommandInternal(
 	) {
 		// Use pipeline executor
 		const { parseShellPipeline } = await import("../shellParser");
-		const { executePipeline } = await import("../executor");
+		const { executePipeline } = await import("../../SSHMimic/executor");
 
 		const pipeline = parseShellPipeline(rawInput);
 		if (!pipeline.isValid) {
@@ -199,6 +258,7 @@ async function runCommandInternal(
 			rawInput,
 			mode,
 			args,
+			shellProps,
 			stdin,
 			cwd,
 			vfs,
@@ -218,6 +278,7 @@ export function runCommand(
 	users: VirtualUserManager,
 	mode: CommandMode,
 	cwd: string,
+	shellProps: ShellProperties,
 	vfs: VirtualFileSystem,
 	stdin?: string,
 ): CommandOutcome {
@@ -236,6 +297,7 @@ export function runCommand(
 			users,
 			mode,
 			cwd,
+			shellProps,
 			vfs,
 			stdin,
 		);
@@ -264,6 +326,7 @@ export function runCommand(
 			stdin,
 			cwd,
 			vfs,
+			shellProps,
 		});
 	} catch (error: unknown) {
 		const message = error instanceof Error ? error.message : "Command failed";

package/src/{SSHMimic → VirtualShell}/commands/ls.ts

@@ -1,4 +1,5 @@
 import type { ShellModule } from "../../types/commands";
+import { getArg, ifFlag } from "./command-helpers";
 import { assertPathAccess, joinListWithType, resolvePath } from "./helpers";
 
 function formatPermissions(mode: number, isDirectory: boolean): string {
@@ -29,8 +30,8 @@ export const lsCommand: ShellModule = {
 	name: "ls",
 	params: ["[path]"],
 	run: ({ authUser, vfs, cwd, args }) => {
-		const longFormat = args.includes("-l") || args.includes("--long");
-		const targetArg = args.find((arg) => !arg.startsWith("-"));
+		const longFormat = ifFlag(args, ["-l", "--long"]);
+		const targetArg = getArg(args, 0, { flags: ["-l", "--long"] });
 		const target = resolvePath(cwd, targetArg ?? cwd);
 		assertPathAccess(authUser, target, "ls");
 		const items = vfs.list(target).filter((name) => !name.startsWith("."));

package/src/{SSHMimic → VirtualShell}/commands/mkdir.ts

@@ -1,4 +1,5 @@
 import type { ShellModule } from "../../types/commands";
+import { getArg } from "./command-helpers";
 import { assertPathAccess, resolvePath } from "./helpers";
 
 export const mkdirCommand: ShellModule = {
@@ -9,7 +10,11 @@ export const mkdirCommand: ShellModule = {
 			return { stderr: "mkdir: missing operand", exitCode: 1 };
 		}
 
-		for (const dir of args) {
+		for (let index = 0; index < args.length; index++) {
+			const dir = getArg(args, index);
+			if (!dir) {
+				return { stderr: "mkdir: missing operand", exitCode: 1 };
+			}
 			const target = resolvePath(cwd, dir);
 			assertPathAccess(authUser, target, "mkdir");
 			vfs.mkdir(target);

package/src/VirtualShell/commands/neofetch.ts

@@ -0,0 +1,37 @@
+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 }) => {
+		const env = getAllEnvVars(authUser);
+
+		if (ifFlag(args, "--help")) {
+			return {
+				stdout: "Usage: neofetch [--off]",
+				exitCode: 0,
+			};
+		}
+
+		if (ifFlag(args, "--off")) {
+			return {
+				stdout: `${authUser}@${hostname}`,
+				exitCode: 0,
+			};
+		}
+
+		return {
+			stdout: buildNeofetchOutput({
+				user: authUser,
+				host: hostname,
+				shell: env.SHELL,
+				shellProps: shellProps,
+				terminal: env.TERM,
+			}),
+			exitCode: 0,
+		};
+	},
+};

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

@@ -1,4 +1,5 @@
 import type { ShellModule } from "../../types/commands";
+import { getArg, ifFlag } from "./command-helpers";
 import { assertPathAccess, resolvePath } from "./helpers";
 
 export const rmCommand: ShellModule = {
@@ -9,9 +10,15 @@ export const rmCommand: ShellModule = {
 			return { stderr: "rm: missing operand", exitCode: 1 };
 		}
 
-		const recursive =
-			args.includes("-r") || args.includes("-rf") || args.includes("-fr");
-		const targets = args.filter((arg) => !arg.startsWith("-"));
+		const recursive = ifFlag(args, ["-r", "-rf", "-fr"]);
+		const targets: string[] = [];
+		for (let index = 0; ; index += 1) {
+			const target = getArg(args, index, { flags: ["-r", "-rf", "-fr"] });
+			if (!target) {
+				break;
+			}
+			targets.push(target);
+		}
 
 		if (targets.length === 0) {
 			return { stderr: "rm: missing operand", exitCode: 1 };

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

@@ -1,5 +1,6 @@
 /** biome-ignore-all lint/style/useNamingConvention: env variables */
 import type { ShellModule } from "../../types/commands";
+import { getArg } from "./command-helpers";
 
 // Simple in-memory environment variables store
 // In a real implementation, this would be per-session/per-user
@@ -41,7 +42,12 @@ export const setCommand: ShellModule = {
 
 		// Parse VAR=value format
 		const assignments: string[] = [];
-		for (const arg of args) {
+		for (let index = 0; ; index += 1) {
+			const arg = getArg(args, index);
+			if (!arg) {
+				break;
+			}
+
 			if (arg.includes("=")) {
 				const [varName, varValue] = arg.split("=", 2);
 				if (varName && varValue !== undefined) {

package/src/VirtualShell/commands/sh.ts

@@ -0,0 +1,68 @@
+import { defaultShellProperties } from "..";
+import type { CommandContext, ShellModule } from "../../types/commands";
+import { getArg, getFlag } from "./command-helpers";
+import { runCommand } from "./index";
+
+/** Simple shell script executor with basic variable support */
+export const shCommand: ShellModule = {
+	name: "sh",
+	params: ["-c <script>", "[<file>]"],
+	aliases: ["bash"],
+	run: async (ctx: CommandContext) => {
+		const { vfs, args, authUser, hostname, users, mode, cwd } = ctx;
+
+		// Handle -c option: sh -c "command"
+		if (getFlag(args, "-c") && args.length >= 2) {
+			const script = getArg(args, 1) ?? "";
+			if (!script) {
+				return { stderr: "sh: -c requires a script", exitCode: 1 };
+			}
+			const scriptArgs = args.slice(2);
+
+			// Split by semicolon and newline
+			const lines = script
+				.split(/[;\n]/)
+				.map((line) => line.trim())
+				.filter((line) => line && !line.startsWith("#"));
+
+			let output = "";
+			const exitCode = 0;
+
+			for (const line of lines) {
+				// Simple variable substitution
+				let command = line;
+				for (let i = 0; i < scriptArgs.length; i++) {
+					const arg = scriptArgs[i] ?? "";
+					command = command.replaceAll(`$${i}`, arg);
+				}
+				command = command.replaceAll("$@", scriptArgs.join(" "));
+
+				// Execute the command
+				const result = await Promise.resolve(
+					runCommand(
+						command,
+						authUser,
+						hostname,
+						users,
+						mode,
+						cwd,
+						defaultShellProperties,
+						vfs,
+					),
+				);
+
+				if (result.stdout) {
+					output += `${result.stdout}\n`;
+				}
+
+				if (result.stderr) {
+					return { stderr: result.stderr, exitCode: result.exitCode ?? 1 };
+				}
+			}
+
+			return { stdout: output.trim(), exitCode };
+		}
+
+		return { stderr: "sh: invalid usage", exitCode: 1 };
+	},
+};