typescript-virtual-container 1.5.2 → 1.5.4

package/src/commands/chmod.ts

@@ -1,85 +0,0 @@
-import type { ShellModule } from "../types/commands";
-import { assertPathAccess, resolvePath } from "./helpers";
-
-/**
- * Parse a symbolic chmod mode string (e.g. "+x", "u+x", "go-w", "a+rx")
- * and apply it to the existing mode bits.
- * Returns null if the string is not a valid symbolic mode.
- */
-function applySymbolicMode(existing: number, modeStr: string): number | null {
-	const pattern = /^([ugoa]*)([+\-=])([rwx]*)$/;
-	const parts = modeStr.split(",");
-	let mode = existing;
-	for (const part of parts) {
-		const m = part.trim().match(pattern);
-		if (!m) return null;
-		const [, who = "a", op, perms = ""] = m;
-		const targets = who === "" || who === "a" ? ["u", "g", "o"] : who.split("");
-		const bits: Record<string, Record<string, number>> = {
-			u: { r: 0o400, w: 0o200, x: 0o100 },
-			g: { r: 0o040, w: 0o020, x: 0o010 },
-			o: { r: 0o004, w: 0o002, x: 0o001 },
-		};
-		for (const t of targets) {
-			for (const p of perms.split("")) {
-				const bit = bits[t]?.[p];
-				if (bit === undefined) continue;
-				if (op === "+") mode |= bit;
-				else if (op === "-") mode &= ~bit;
-				else if (op === "=") {
-					// clear all bits for this target, then set requested
-					const mask = Object.values(bits[t] ?? {}).reduce((a, b) => a | b, 0);
-					mode = (mode & ~mask) | bit;
-				}
-			}
-		}
-	}
-	return mode;
-}
-
-/**
- * Change file permissions (octal or symbolic).
- * @category files
- * @params ["<mode> <file>"]
- */
-export const chmodCommand: ShellModule = {
-	name: "chmod",
-	description: "Change file permissions",
-	category: "files",
-	params: ["<mode> <file>"],
-	run: ({ authUser, shell, cwd, args }) => {
-		const [modeArg, fileArg] = args;
-		if (!modeArg || !fileArg) {
-			return { stderr: "chmod: missing operand", exitCode: 1 };
-		}
-
-		const filePath = resolvePath(cwd, fileArg);
-		try {
-			assertPathAccess(authUser, filePath, "chmod");
-			if (!shell.vfs.exists(filePath)) {
-				return {
-					stderr: `chmod: ${fileArg}: No such file or directory`,
-					exitCode: 1,
-				};
-			}
-			let mode: number;
-			const octal = parseInt(modeArg, 8);
-			if (!Number.isNaN(octal) && /^[0-7]+$/.test(modeArg)) {
-				mode = octal;
-			} else {
-				// symbolic mode
-				const existing = shell.vfs.stat(filePath).mode;
-				const result = applySymbolicMode(existing, modeArg);
-				if (result === null) {
-					return { stderr: `chmod: invalid mode: ${modeArg}`, exitCode: 1 };
-				}
-				mode = result;
-			}
-			shell.vfs.chmod(filePath, mode);
-			return { exitCode: 0 };
-		} catch (err) {
-			const msg = err instanceof Error ? err.message : String(err);
-			return { stderr: `chmod: ${msg}`, exitCode: 1 };
-		}
-	},
-};

package/src/commands/clear.ts

@@ -1,15 +0,0 @@
-import type { ShellModule } from "../types/commands";
-
-/**
- * Clear the terminal screen.
- * @category shell
- * @params []
- */
-export const clearCommand: ShellModule = {
-	name: "clear",
-	description: "Clear the terminal screen",
-	category: "shell",
-	params: [],
-	// clearScreen flag triggers \x1b[2J\x1b[H in the shell layer
-	run: () => ({ clearScreen: true, stdout: "", exitCode: 0 }),
-};

package/src/commands/command-helpers.ts

@@ -1,286 +0,0 @@
-/**
- * Options for argument parsing helpers.
- * @public
- */
-export 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 };
-	}
-
-	// --flag=value style
-	const prefix = `${flag}=`;
-	if (token.startsWith(prefix)) {
-		return { matched: true, inlineValue: token.slice(prefix.length) };
-	}
-
-	// Short flag inline value: -f2, -d: (single char flag like -f, -d, -n)
-	// Only applies to single-char flags (-X), not long flags (--flag)
-	if (flag.length === 2 && flag.startsWith("-") && !flag.startsWith("--")) {
-		if (token.startsWith(flag) && token.length > flag.length) {
-			return { matched: true, inlineValue: token.slice(flag.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;
-}
-
-/**
- * Returns `true` when any of the given flags appear in `args`.
- *
- * Matches both standalone tokens (`-s`, `--silent`) and inline forms
- * (`--output=file`). Useful for simple boolean flag checks inside command
- * `run` handlers.
- *
- * @param args  Tokenized argument array from `CommandContext.args`.
- * @param flags Single flag string or array of equivalent flag strings.
- * @returns `true` if at least one flag is present, otherwise `false`.
- *
- * @example
- * ```ts
- * ifFlag(args, "-r")              // single flag
- * ifFlag(args, ["-r", "--recursive"]) // aliases
- * ```
- */
-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;
-}
-
-/**
- * Returns the value associated with a flag, or `true` if the flag is present
- * but has no associated value, or `undefined` if the flag is absent.
- *
- * Handles three forms:
- * - `--output file`   → returns `"file"` (next token)
- * - `--output=file`   → returns `"file"` (inline `=` form)
- * - `--verbose`       → returns `true` (flag with no value)
- *
- * @param args  Tokenized argument array from `CommandContext.args`.
- * @param flags Single flag string or array of equivalent flag strings.
- * @returns The flag value string, `true` when valueless, or `undefined`.
- *
- * @example
- * ```ts
- * const output = getFlag(args, ["-o", "--output"]);
- * if (typeof output === "string") { /* use path *\/ }
- * ```
- */
-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;
-}
-
-/**
- * Returns the positional argument at the given zero-based index, skipping
- * known flags and their values.
- *
- * Flags declared in `options.flags` are treated as boolean and skipped.
- * Flags declared in `options.flagsWithValue` consume the next token too.
- * Tokens after `--` are always treated as positionals.
- *
- * @param args    Tokenized argument array from `CommandContext.args`.
- * @param index   Zero-based positional index to retrieve.
- * @param options Optional flag declarations to skip during positional collection.
- * @returns The positional value, or `undefined` if the index is out of range.
- *
- * @example
- * ```ts
- * // args = ["-r", "src", "dest"]
- * getArg(args, 0, { flags: ["-r"] }) // "src"
- * getArg(args, 1, { flags: ["-r"] }) // "dest"
- * ```
- */
-export function getArg(
-	args: string[],
-	index: number,
-	options: ArgParseOptions = {},
-): string | undefined {
-	const positionals = collectPositionals(args, options);
-	return positionals[index];
-}
-
-/**
- * Parses an argument array into structured flags, flag values, and positionals.
- *
- * - `options.flags` — boolean flags (e.g. `["-r", "--recursive"]`); collected
- *   into a `Set<string>` and not treated as positionals.
- * - `options.flagsWithValue` — flags that consume the next token or an inline
- *   `=value`; collected into a `Map<string, string>`.
- * - All remaining tokens are positionals.
- * - Tokens after `--` are always positionals, regardless of `-` prefix.
- *
- * @param args    Tokenized argument array from `CommandContext.args`.
- * @param options Flag declaration lists.
- * @returns `{ flags, flagsWithValues, positionals }`.
- *
- * @example
- * ```ts
- * const { flags, flagsWithValues, positionals } = parseArgs(args, {
- *   flags:          ["-r", "--recursive"],
- *   flagsWithValue: ["-o", "--output"],
- * });
- * const recursive = flags.has("-r");
- * const output    = flagsWithValues.get("-o");
- * ```
- */
-export function parseArgs(
-	args: string[],
-	options: { flags?: string[]; flagsWithValue?: string[] } = {},
-): {
-	flags: Set<string>;
-	flagsWithValues: Map<string, string>;
-	positionals: string[];
-} {
-	const flags = new Set<string>();
-	const flagsWithValues = new Map<string, string>();
-	const positionals: string[] = [];
-	const boolFlags = new Set(options.flags ?? []);
-	const valueFlags = new Set(options.flagsWithValue ?? []);
-	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;
-		}
-
-		if (boolFlags.has(arg)) {
-			flags.add(arg);
-			continue;
-		}
-
-		if (valueFlags.has(arg)) {
-			const next = args[index + 1];
-			if (next && !next.startsWith("-")) {
-				flagsWithValues.set(arg, next);
-				index += 1;
-			} else {
-				flagsWithValues.set(arg, "");
-			}
-			continue;
-		}
-
-		const inlineFlag = Array.from(valueFlags).find((flag) =>
-			arg.startsWith(`${flag}=`),
-		);
-		if (inlineFlag) {
-			flagsWithValues.set(inlineFlag, arg.slice(inlineFlag.length + 1));
-			continue;
-		}
-
-		positionals.push(arg);
-	}
-
-	return { flags, flagsWithValues, positionals };
-}

package/src/commands/cp.ts

@@ -1,83 +0,0 @@
-import type { ShellModule } from "../types/commands";
-import { ifFlag } from "./command-helpers";
-import { assertPathAccess, resolvePath } from "./helpers";
-
-/**
- * Copy files or directories inside the virtual filesystem.
- * @category files
- * @params ["[-r] <source> <dest>"]
- */
-export const cpCommand: ShellModule = {
-	name: "cp",
-	description: "Copy files or directories",
-	category: "files",
-	params: ["[-r] <source> <dest>"],
-	run: ({ authUser, shell, cwd, args }) => {
-		const recursive = ifFlag(args, ["-r", "-R", "--recursive"]);
-		const positionals = args.filter((a) => !a.startsWith("-"));
-		const [srcArg, destArg] = positionals;
-
-		if (!srcArg || !destArg) {
-			return { stderr: "cp: missing operand", exitCode: 1 };
-		}
-
-		const srcPath = resolvePath(cwd, srcArg);
-		const destPath = resolvePath(cwd, destArg);
-
-		try {
-			assertPathAccess(authUser, srcPath, "cp");
-			assertPathAccess(authUser, destPath, "cp");
-
-			if (!shell.vfs.exists(srcPath)) {
-				return {
-					stderr: `cp: ${srcArg}: No such file or directory`,
-					exitCode: 1,
-				};
-			}
-
-			const srcStat = shell.vfs.stat(srcPath);
-
-			if (srcStat.type === "directory") {
-				if (!recursive) {
-					return {
-						stderr: `cp: ${srcArg}: is a directory (use -r)`,
-						exitCode: 1,
-					};
-				}
-				const copyDir = (from: string, to: string) => {
-					shell.vfs.mkdir(to, 0o755);
-					for (const entry of shell.vfs.list(from)) {
-						const fromEntry = `${from}/${entry}`;
-						const toEntry = `${to}/${entry}`;
-						const stat = shell.vfs.stat(fromEntry);
-						if (stat.type === "directory") {
-							copyDir(fromEntry, toEntry);
-						} else {
-							const content = shell.vfs.readFileRaw(fromEntry);
-							shell.writeFileAsUser(authUser, toEntry, content);
-						}
-					}
-				};
-				const finalDest =
-					shell.vfs.exists(destPath) &&
-					shell.vfs.stat(destPath).type === "directory"
-						? `${destPath}/${srcArg.split("/").pop()}`
-						: destPath;
-				copyDir(srcPath, finalDest);
-			} else {
-				const finalDest =
-					shell.vfs.exists(destPath) &&
-					shell.vfs.stat(destPath).type === "directory"
-						? `${destPath}/${srcArg.split("/").pop()}`
-						: destPath;
-				const content = shell.vfs.readFileRaw(srcPath);
-				shell.writeFileAsUser(authUser, finalDest, content);
-			}
-
-			return { exitCode: 0 };
-		} catch (err) {
-			const msg = err instanceof Error ? err.message : String(err);
-			return { stderr: `cp: ${msg}`, exitCode: 1 };
-		}
-	},
-};

package/src/commands/curl.ts

@@ -1,147 +0,0 @@
-import type { ShellModule } from "../types/commands";
-import { ifFlag, parseArgs } from "./command-helpers";
-import { assertPathAccess, resolvePath } from "./helpers";
-
-/**
- * HTTP client wrapper using `fetch()` semantics (virtual curl).
- * @category network
- * @params ["[options] <url>"]
- */
-export const curlCommand: ShellModule = {
-	name: "curl",
-	description: "Transfer data from or to a server (pure fetch)",
-	category: "network",
-	params: ["[options] <url>"],
-	run: async ({ authUser, cwd, args, shell }) => {
-		const { flagsWithValues, positionals } = parseArgs(args, {
-			flagsWithValue: [
-				"-o",
-				"--output",
-				"-X",
-				"--request",
-				"-d",
-				"--data",
-				"-H",
-				"--header",
-				"-u",
-				"--user",
-			],
-		});
-
-		if (ifFlag(args, ["--help", "-h"])) {
-			return {
-				stdout: [
-					"Usage: curl [options] <url>",
-					"  -o, --output <file>    Write to file",
-					"  -X, --request <method> HTTP method",
-					"  -d, --data <data>      POST data",
-					"  -H, --header <hdr>     Extra header",
-					"  -s, --silent           Silent mode",
-					"  -I, --head             Fetch headers only",
-					"  -L, --location         Follow redirects",
-					"  -v, --verbose          Verbose",
-				].join("\n"),
-				exitCode: 0,
-			};
-		}
-
-		const url = positionals[0];
-		if (!url) return { stderr: "curl: no URL specified", exitCode: 1 };
-
-		const outputPath =
-			flagsWithValues.get("-o") ?? flagsWithValues.get("--output") ?? null;
-		const method = (
-			flagsWithValues.get("-X") ??
-			flagsWithValues.get("--request") ??
-			"GET"
-		).toUpperCase();
-		const postData =
-			flagsWithValues.get("-d") ?? flagsWithValues.get("--data") ?? null;
-		const headerRaw =
-			flagsWithValues.get("-H") ?? flagsWithValues.get("--header") ?? null;
-		const silent = ifFlag(args, ["-s", "--silent"]);
-		const headOnly = ifFlag(args, ["-I", "--head"]);
-		const followRedirects = ifFlag(args, ["-L", "--location"]);
-		const verbose = ifFlag(args, ["-v", "--verbose"]);
-
-		const extraHeaders: Record<string, string> = {
-			"User-Agent": "curl/7.88.1",
-		};
-		if (headerRaw) {
-			const idx = headerRaw.indexOf(":");
-			if (idx !== -1)
-				extraHeaders[headerRaw.slice(0, idx).trim()] = headerRaw
-					.slice(idx + 1)
-					.trim();
-		}
-
-		const finalMethod = postData && method === "GET" ? "POST" : method;
-		const fetchOpts: RequestInit = {
-			method: finalMethod,
-			headers: extraHeaders,
-			redirect: followRedirects ? "follow" : "manual",
-		};
-		if (postData) {
-			extraHeaders["Content-Type"] ??= "application/x-www-form-urlencoded";
-			fetchOpts.body = postData;
-		}
-
-		const stderrLines: string[] = [];
-		if (verbose) {
-			stderrLines.push(`* Trying ${url}...`, `* Connected`);
-			stderrLines.push(
-				`> ${finalMethod} / HTTP/1.1`,
-				`> Host: ${new URL(url).host}`,
-			);
-		}
-
-		let response: Response;
-		try {
-			const urlWithHttp = url.startsWith("http://") || url.startsWith("https://") ? url : `http://${url}`;
-			response = await fetch(urlWithHttp, fetchOpts);
-		} catch (err) {
-			const msg = err instanceof Error ? err.message : String(err);
-			return {
-				stderr: `curl: (6) Could not resolve host: ${msg}`,
-				exitCode: 6,
-			};
-		}
-
-		if (verbose) {
-			stderrLines.push(`< HTTP/1.1 ${response.status} ${response.statusText}`);
-		}
-
-		if (headOnly) {
-			const lines = [`HTTP/1.1 ${response.status} ${response.statusText}`];
-			for (const [k, v] of response.headers.entries()) lines.push(`${k}: ${v}`);
-			return { stdout: `${lines.join("\r\n")}\r\n`, exitCode: 0 };
-		}
-
-		let body: string;
-		try {
-			body = await response.text();
-		} catch {
-			return { stderr: "curl: failed to read response body", exitCode: 1 };
-		}
-
-		if (outputPath) {
-			const target = resolvePath(cwd, outputPath);
-			assertPathAccess(authUser, target, "curl");
-			shell.writeFileAsUser(authUser, target, body);
-			if (!silent)
-				stderrLines.push(
-					`  % Total    % Received\n100 ${body.length}  100 ${body.length}`,
-				);
-			return {
-				stderr: stderrLines.join("\n") || undefined,
-				exitCode: response.ok ? 0 : 22,
-			};
-		}
-
-		return {
-			stdout: body,
-			stderr: stderrLines.length > 0 ? stderrLines.join("\n") : undefined,
-			exitCode: response.ok ? 0 : 22,
-		};
-	},
-};

package/src/commands/cut.ts

@@ -1,36 +0,0 @@
-import type { ShellModule } from "../types/commands";
-import { getFlag } from "./command-helpers";
-
-/**
- * Extract selected fields from each line of input.
- * @category text
- * @params ["-d <delim> -f <fields> [file]"]
- */
-export const cutCommand: ShellModule = {
-	name: "cut",
-	description: "Remove sections from lines",
-	category: "text",
-	params: ["-d <delim> -f <fields> [file]"],
-	run: ({ args, stdin }) => {
-		const delim = (getFlag(args, ["-d"]) as string | undefined) ?? "\t";
-		const fields = (getFlag(args, ["-f"]) as string | undefined) ?? "1";
-		const cols = fields.split(",").map((f) => {
-			const [a, b] = f.split("-").map(Number);
-			return b !== undefined
-				? { from: (a ?? 1) - 1, to: b - 1 }
-				: { from: (a ?? 1) - 1, to: (a ?? 1) - 1 };
-		});
-		const lines = (stdin ?? "").split("\n");
-		const out = lines.map((line) => {
-			const parts = line.split(delim);
-			const selected: string[] = [];
-			for (const col of cols) {
-				for (let i = col.from; i <= Math.min(col.to, parts.length - 1); i++) {
-					selected.push(parts[i] ?? "");
-				}
-			}
-			return selected.join(delim);
-		});
-		return { stdout: out.join("\n"), exitCode: 0 };
-	},
-};

package/src/commands/date.ts

@@ -1,30 +0,0 @@
-import type { ShellModule } from "../types/commands";
-
-/**
- * Print the current date/time or a formatted representation.
- * @category system
- * @params ["[+format]"]
- */
-export const dateCommand: ShellModule = {
-	name: "date",
-	description: "Print current date and time",
-	category: "system",
-	params: ["[+format]"],
-	run: ({ args }) => {
-		const now = new Date();
-		const fmt = args[0];
-		if (fmt?.startsWith("+")) {
-			const f = fmt
-				.slice(1)
-				.replace("%Y", String(now.getFullYear()))
-				.replace("%m", String(now.getMonth() + 1).padStart(2, "0"))
-				.replace("%d", String(now.getDate()).padStart(2, "0"))
-				.replace("%H", String(now.getHours()).padStart(2, "0"))
-				.replace("%M", String(now.getMinutes()).padStart(2, "0"))
-				.replace("%S", String(now.getSeconds()).padStart(2, "0"))
-				.replace("%s", String(Math.floor(now.getTime() / 1000)));
-			return { stdout: f, exitCode: 0 };
-		}
-		return { stdout: now.toString(), exitCode: 0 };
-	},
-};