typescript-virtual-container 1.2.4 → 1.2.6

package/src/commands/tr.ts

@@ -0,0 +1,24 @@
+import type { ShellModule } from "../types/commands";
+import { ifFlag } from "./command-helpers";
+
+export const trCommand: ShellModule = {
+	name: "tr",
+	description: "Translate or delete characters",
+	category: "text",
+	params: ["[-d] <set1> [set2]"],
+	run: ({ args, stdin }) => {
+		const del = ifFlag(args, ["-d"]);
+		const positionals = args.filter((a) => !a.startsWith("-"));
+		const set1 = positionals[0] ?? "";
+		const set2 = positionals[1] ?? "";
+		let input = stdin ?? "";
+		if (del) {
+			for (const c of set1) input = input.split(c).join("");
+		} else if (set2) {
+			for (let i = 0; i < set1.length; i++) {
+				input = input.split(set1[i]!).join(set2[i] ?? set2[set2.length - 1] ?? "");
+			}
+		}
+		return { stdout: input, exitCode: 0 };
+	},
+};

package/src/commands/tree.ts

@@ -4,6 +4,8 @@ import { assertPathAccess, resolvePath } from "./helpers";
 
 export const treeCommand: ShellModule = {
 	name: "tree",
+	description: "Display directory tree",
+	category: "navigation",
 	params: ["[path]"],
 	run: ({ authUser, shell, cwd, args }) => {
 		const target = resolvePath(cwd, getArg(args, 0) ?? cwd);

package/src/commands/uname.ts

@@ -0,0 +1,20 @@
+import type { ShellModule } from "../types/commands";
+import { ifFlag } from "./command-helpers";
+
+export const unameCommand: ShellModule = {
+	name: "uname",
+	description: "Print system information",
+	category: "system",
+	params: ["[-a] [-s] [-r] [-m]"],
+	run: ({ shell, args }) => {
+		const all = ifFlag(args, ["-a"]);
+		const sysname = "Linux";
+		const release = shell.properties?.kernel ?? "5.15.0";
+		const machine = shell.properties?.arch ?? "x86_64";
+		const hostname = shell.hostname;
+		if (all) return { stdout: `${sysname} ${hostname} ${release} #1 SMP ${machine} GNU/Linux`, exitCode: 0 };
+		if (ifFlag(args, ["-r"])) return { stdout: release, exitCode: 0 };
+		if (ifFlag(args, ["-m"])) return { stdout: machine, exitCode: 0 };
+		return { stdout: sysname, exitCode: 0 };
+	},
+};

package/src/commands/uniq.ts

@@ -0,0 +1,28 @@
+import type { ShellModule } from "../types/commands";
+import { ifFlag } from "./command-helpers";
+
+export const uniqCommand: ShellModule = {
+	name: "uniq",
+	description: "Report or filter out repeated lines",
+	category: "text",
+	params: ["[-c] [-d] [-u] [file]"],
+	run: ({ args, stdin }) => {
+		const count = ifFlag(args, ["-c"]);
+		const dupOnly = ifFlag(args, ["-d"]);
+		const uniqOnly = ifFlag(args, ["-u"]);
+		const lines = (stdin ?? "").split("\n");
+		const out: string[] = [];
+		let i = 0;
+		while (i < lines.length) {
+			let j = i;
+			while (j < lines.length && lines[j] === lines[i]) j++;
+			const n = j - i;
+			const line = lines[i]!;
+			if (dupOnly && n === 1) { i = j; continue; }
+			if (uniqOnly && n > 1) { i = j; continue; }
+			out.push(count ? `${String(n).padStart(4)} ${line}` : line);
+			i = j;
+		}
+		return { stdout: out.join("\n"), exitCode: 0 };
+	},
+};

package/src/commands/unset.ts

@@ -1,19 +1,12 @@
 import type { ShellModule } from "../types/commands";
-import { setEnvVar } from "./set";
 
 export const unsetCommand: ShellModule = {
 	name: "unset",
-	params: ["<VAR...>"],
-	run: ({ args }) => {
-		if (args.length === 0) {
-			return { stderr: "unset: missing variable name", exitCode: 1 };
-		}
-
-		// Unset (remove) all specified variables
-		for (const varName of args) {
-			setEnvVar(varName, "");
-		}
-
+	description: "Remove shell variable",
+	category: "shell",
+	params: ["<VAR>"],
+	run: ({ args, env }) => {
+		for (const name of args) delete env.vars[name];
 		return { exitCode: 0 };
 	},
 };

package/src/commands/wc.ts

@@ -0,0 +1,50 @@
+import type { ShellModule } from "../types/commands";
+import { ifFlag } from "./command-helpers";
+import { assertPathAccess, resolvePath } from "./helpers";
+
+export const wcCommand: ShellModule = {
+	name: "wc",
+	description: "Count words/lines/bytes",
+	category: "text",
+	params: ["[-l] [-w] [-c] [file...]"],
+	run: ({ authUser, shell, cwd, args, stdin }) => {
+		const lines = ifFlag(args, ["-l"]);
+		const words = ifFlag(args, ["-w"]);
+		const bytes = ifFlag(args, ["-c"]);
+		const showAll = !lines && !words && !bytes;
+		const positionals = args.filter((a) => !a.startsWith("-"));
+
+		const count = (content: string, label: string): string => {
+			const l = content.split("\n").length - (content.endsWith("\n") ? 1 : 0);
+			const w = content.trim().split(/\s+/).filter(Boolean).length;
+			const c = Buffer.byteLength(content, "utf8");
+			const parts: string[] = [];
+			if (showAll || lines) parts.push(String(l).padStart(7));
+			if (showAll || words) parts.push(String(w).padStart(7));
+			if (showAll || bytes) parts.push(String(c).padStart(7));
+			if (label) parts.push(` ${label}`);
+			return parts.join("");
+		};
+
+		if (positionals.length === 0) {
+			const content = stdin ?? "";
+			return { stdout: count(content, ""), exitCode: 0 };
+		}
+
+		const results: string[] = [];
+		for (const file of positionals) {
+			const filePath = resolvePath(cwd, file);
+			try {
+				assertPathAccess(authUser, filePath, "wc");
+				const content = shell.vfs.readFile(filePath);
+				results.push(count(content, file));
+			} catch {
+				return {
+					stderr: `wc: ${file}: No such file or directory`,
+					exitCode: 1,
+				};
+			}
+		}
+		return { stdout: results.join("\n"), exitCode: 0 };
+	},
+};

package/src/commands/wget.ts

@@ -82,6 +82,8 @@ function runHostWget(args: string[]): Promise<{
 
 export const wgetCommand: ShellModule = {
 	name: "wget",
+	description: "File downloader",
+	category: "network",
 	params: ["[url]"],
 	run: async ({ authUser, cwd, args, shell }) => {
 		const { flagsWithValues, positionals } = parseArgs(args, {

package/src/commands/who.ts

@@ -3,6 +3,8 @@ import type { ShellModule } from "../types/commands";
 
 export const whoCommand: ShellModule = {
 	name: "who",
+	description: "Show active sessions",
+	category: "system",
 	params: [],
 	run: ({ shell }) => {
 		const lines = shell.users.listActiveSessions().map((session) => {

package/src/commands/whoami.ts

@@ -2,6 +2,8 @@ import type { ShellModule } from "../types/commands";
 
 export const whoamiCommand: ShellModule = {
 	name: "whoami",
+	description: "Print current user",
+	category: "system",
 	params: [],
 	run: ({ authUser }) => ({ stdout: authUser, exitCode: 0 }),
 };

package/src/commands/xargs.ts

@@ -0,0 +1,17 @@
+import type { ShellModule } from "../types/commands";
+import { runCommand } from "./index";
+
+export const xargsCommand: ShellModule = {
+	name: "xargs",
+	description: "Build and execute command lines from stdin",
+	category: "text",
+	params: ["[command] [args...]"],
+	run: async ({ authUser, hostname, mode, cwd, args, stdin, shell, env }) => {
+		const baseCmd = args[0] ?? "echo";
+		const extraArgs = args.slice(1);
+		const items = (stdin ?? "").trim().split(/\s+/).filter(Boolean);
+		if (items.length === 0) return { exitCode: 0 };
+		const fullCmd = [baseCmd, ...extraArgs, ...items].join(" ");
+		return runCommand(fullCmd, authUser, hostname, mode, cwd, shell, undefined, env);
+	},
+};

package/src/index.ts

@@ -33,6 +33,7 @@ export type {
 	VfsSnapshotNode,
 	WriteFileOptions,
 } from "./types/vfs";
+export type { VfsOptions, VfsPersistenceMode } from "./VirtualFileSystem/index";
 
 export {
 	HoneyPot,

package/src/types/commands.ts

@@ -57,6 +57,14 @@ export interface NanoEditorSession {
 	initialContent: string;
 }
 
+/** Per-session shell environment (variables, last exit code). */
+export interface ShellEnv {
+	/** Environment variables visible to commands. */
+	vars: Record<string, string>;
+	/** Exit status of the last executed command. */
+	lastExitCode: number;
+}
+
 /** Runtime context object passed to each command module. */
 export interface CommandContext {
 	/** Authenticated user currently bound to stream. */
@@ -77,6 +85,8 @@ export interface CommandContext {
 	stdin?: string;
 	/** Current working directory for command execution. */
 	cwd: string;
+	/** Per-session environment available to command modules. */
+	env: ShellEnv;
 }
 
 /** Contract implemented by each shell command module. */
@@ -89,6 +99,10 @@ export interface ShellModule {
 	run: (ctx: CommandContext) => CommandResult | Promise<CommandResult>;
 	/** Optional alternative command names. */
 	aliases?: string[];
+	/** Short description shown in `help`. */
+	description?: string;
+	/** Category used for grouped help output. */
+	category?: string;
 }
 
 /** Command return union allowing sync or async handlers. */

package/src/types/pipeline.ts

@@ -12,6 +12,9 @@ export interface PipelineCommand {
 	appendOutput?: boolean;
 }
 
+/** Logical operator connecting two statement groups. */
+export type LogicalOp = "&&" | "||" | ";";
+
 /** Represents a parsed shell pipeline */
 export interface Pipeline {
 	/** List of commands in the pipeline */
@@ -21,3 +24,23 @@ export interface Pipeline {
 	/** Error message if parsing failed */
 	error?: string;
 }
+
+/** A statement: one pipeline optionally followed by && / || / ; and the next statement */
+export interface Statement {
+	/** Pipeline to execute for this statement. */
+	pipeline: Pipeline;
+	/** Operator connecting this statement to the next one. */
+	op?: LogicalOp;
+	/** Optional next statement in sequence. */
+	next?: Statement;
+}
+
+/** Top-level parse result for a script. */
+export interface Script {
+	/** Statements contained in the script. */
+	statements: Statement[];
+	/** Whether the script was parsed successfully. */
+	isValid: boolean;
+	/** Optional parse error message. */
+	error?: string;
+}