typescript-virtual-container 1.2.8 → 1.3.0

package/src/commands/set.ts

@@ -11,9 +11,13 @@ const _globalEnv: Record<string, string> = {
 };
 
 /** @deprecated use env.vars from CommandContext */
-export function getEnvVar(name: string): string | undefined { return _globalEnv[name]; }
+export function getEnvVar(name: string): string | undefined {
+	return _globalEnv[name];
+}
 /** @deprecated use env.vars from CommandContext */
-export function setEnvVar(name: string, value: string): void { _globalEnv[name] = value; }
+export function setEnvVar(name: string, value: string): void {
+	_globalEnv[name] = value;
+}
 /** @deprecated use env.vars from CommandContext */
 export function getAllEnvVars(authUser: string): Record<string, string> {
 	_globalEnv.USER = authUser;
@@ -28,7 +32,9 @@ export const setCommand: ShellModule = {
 	params: ["[VAR=value]"],
 	run: ({ args, env }) => {
 		if (args.length === 0) {
-			const out = Object.entries(env.vars).map(([k, v]) => `${k}=${v}`).join("\n");
+			const out = Object.entries(env.vars)
+				.map(([k, v]) => `${k}=${v}`)
+				.join("\n");
 			return { stdout: out, exitCode: 0 };
 		}
 		for (const arg of args) {

package/src/commands/sh.ts

@@ -1,20 +1,48 @@
-import type { CommandContext, CommandResult, ShellModule } from "../types/commands";
-import { getArg, ifFlag } from "./command-helpers";
+import type {
+    CommandContext,
+    CommandResult,
+    ShellModule,
+} from "../types/commands";
+import { expandAsync } from "../utils/expand";
+import { ifFlag } from "./command-helpers";
 import { resolvePath } from "./helpers";
-import { runCommand } from "./index";
+import { runCommand } from "./runtime";
 
-/** Expand $VAR and ${VAR:-default} in a line using the current env */
-function expandVars(line: string, env: Record<string, string>, lastExit: number): string {
-	return line
-		.replace(/\$\?/g, String(lastExit))
-		.replace(/\$\{([^}:]+):-([^}]*)\}/g, (_, n, d) => env[n] ?? d)
-		.replace(/\$\{([^}]+)\}/g, (_, n) => env[n] ?? "")
-		.replace(/\$([A-Za-z_][A-Za-z0-9_]*)/g, (_, n) => env[n] ?? "")
-		.replace(/^~(\/|$)/, `${env.HOME ?? "/home/user"}$1`);
+/** Alias for clarity inside sh.ts */
+type ShellContext = CommandContext;
+
+/**
+ * Expand all shell forms including $(cmd) substitution.
+ * Delegates to centralised expandAsync (single-quote-aware, depth-tracked).
+ */
+async function expandVars(
+	line: string,
+	env: Record<string, string>,
+	lastExit: number,
+	ctx: ShellContext,
+): Promise<string> {
+	return expandAsync(line, env, lastExit, (sub) =>
+		runCommand(
+			sub,
+			ctx.authUser,
+			ctx.hostname,
+			ctx.mode,
+			ctx.cwd,
+			ctx.shell,
+			undefined,
+			ctx.env,
+		).then((r) => r.stdout ?? ""),
+	);
 }
 
 type Block =
-	| { type: "if"; cond: string; then: string[]; elif: Array<{ cond: string; body: string[] }>; else_: string[] }
+	| {
+			type: "if";
+			cond: string;
+			then_: string[];
+			elif: Array<{ cond: string; body: string[] }>;
+			else_: string[];
+	  }
 	| { type: "for"; var: string; list: string; body: string[] }
 	| { type: "while"; cond: string; body: string[] }
 	| { type: "cmd"; line: string };
@@ -25,10 +53,16 @@ function parseBlocks(lines: string[]): Block[] {
 	let i = 0;
 	while (i < lines.length) {
 		const line = lines[i]!.trim();
-		if (!line || line.startsWith("#")) { i++; continue; }
+		if (!line || line.startsWith("#")) {
+			i++;
+			continue;
+		}
 
 		if (line.startsWith("if ") || line === "if") {
-			const cond = line.replace(/^if\s+/, "").replace(/;\s*then\s*$/, "").trim();
+			const cond = line
+				.replace(/^if\s+/, "")
+				.replace(/;\s*then\s*$/, "")
+				.trim();
 			const thenLines: string[] = [];
 			const elifBlocks: Array<{ cond: string; body: string[] }> = [];
 			const elseLines: string[] = [];
@@ -37,36 +71,54 @@ function parseBlocks(lines: string[]): Block[] {
 			i++;
 			while (i < lines.length && lines[i]?.trim() !== "fi") {
 				const l = lines[i]!.trim();
-				if (l.startsWith("elif ")) { section = "elif"; elifCond = l.replace(/^elif\s+/, "").replace(/;\s*then\s*$/, "").trim(); elifBlocks.push({ cond: elifCond, body: [] }); }
-				else if (l === "else") { section = "else"; }
-				else if (l !== "then") {
+				if (l.startsWith("elif ")) {
+					section = "elif";
+					elifCond = l
+						.replace(/^elif\s+/, "")
+						.replace(/;\s*then\s*$/, "")
+						.trim();
+					elifBlocks.push({ cond: elifCond, body: [] });
+				} else if (l === "else") {
+					section = "else";
+				} else if (l !== "then") {
 					if (section === "then") thenLines.push(l);
-					else if (section === "elif" && elifBlocks.length > 0) elifBlocks[elifBlocks.length - 1]!.body.push(l);
+					else if (section === "elif" && elifBlocks.length > 0)
+						elifBlocks[elifBlocks.length - 1]!.body.push(l);
 					else elseLines.push(l);
 				}
 				i++;
 			}
-			// biome-ignore lint/suspicious/noThenProperty: expected behavior for if/elif parsing
-			blocks.push({ type: "if", cond, then: thenLines, elif: elifBlocks, else_: elseLines });
+			blocks.push({
+				type: "if",
+				cond,
+				then_: thenLines,
+				elif: elifBlocks,
+				else_: elseLines,
+			});
 		} else if (line.startsWith("for ")) {
 			const m = line.match(/^for\s+(\w+)\s+in\s+(.+?)(?:\s*;\s*do)?$/);
 			if (m) {
 				const body: string[] = [];
 				i++;
 				while (i < lines.length && lines[i]?.trim() !== "done") {
-					const l = lines[i]!.trim();
-					if (l !== "do") body.push(l);
+					const l = lines[i]!.trim().replace(/^do\s+/, "");
+					if (l && l !== "do") body.push(l);
 					i++;
 				}
 				blocks.push({ type: "for", var: m[1]!, list: m[2]!, body });
-			} else { blocks.push({ type: "cmd", line }); }
+			} else {
+				blocks.push({ type: "cmd", line });
+			}
 		} else if (line.startsWith("while ")) {
-			const cond = line.replace(/^while\s+/, "").replace(/;\s*do\s*$/, "").trim();
+			const cond = line
+				.replace(/^while\s+/, "")
+				.replace(/;\s*do\s*$/, "")
+				.trim();
 			const body: string[] = [];
 			i++;
 			while (i < lines.length && lines[i]?.trim() !== "done") {
-				const l = lines[i]!.trim();
-				if (l !== "do") body.push(l);
+				const l = lines[i]!.trim().replace(/^do\s+/, "");
+				if (l && l !== "do") body.push(l);
 				i++;
 			}
 			blocks.push({ type: "while", cond, body });
@@ -78,8 +130,16 @@ function parseBlocks(lines: string[]): Block[] {
 	return blocks;
 }
 
-async function evalCondition(cond: string, ctx: CommandContext): Promise<boolean> {
-	const expanded = expandVars(cond, ctx.env.vars, ctx.env.lastExitCode);
+async function evalCondition(
+	cond: string,
+	ctx: CommandContext,
+): Promise<boolean> {
+	const expanded = await expandVars(
+		cond,
+		ctx.env.vars,
+		ctx.env.lastExitCode,
+		ctx,
+	);
 	// test -f / test -d / [ ... ]
 	const testMatch = expanded.match(/^\[?\s*(.+?)\s*\]?$/);
 	if (testMatch) {
@@ -89,8 +149,12 @@ async function evalCondition(cond: string, ctx: CommandContext): Promise<boolean
 		if (fTest) {
 			const [, flag, arg] = fTest;
 			const p = resolvePath(ctx.cwd, arg!);
-			if (flag === "f") return ctx.shell.vfs.exists(p) && ctx.shell.vfs.stat(p).type === "file";
-			if (flag === "d") return ctx.shell.vfs.exists(p) && ctx.shell.vfs.stat(p).type === "directory";
+			if (flag === "f")
+				return ctx.shell.vfs.exists(p) && ctx.shell.vfs.stat(p).type === "file";
+			if (flag === "d")
+				return (
+					ctx.shell.vfs.exists(p) && ctx.shell.vfs.stat(p).type === "directory"
+				);
 			if (flag === "e") return ctx.shell.vfs.exists(p);
 			if (flag === "z") return (arg ?? "").length === 0;
 			if (flag === "n") return (arg ?? "").length > 0;
@@ -106,7 +170,8 @@ async function evalCondition(cond: string, ctx: CommandContext): Promise<boolean
 		const numMatch = expr.match(/^(\S+)\s+(-eq|-ne|-lt|-le|-gt|-ge)\s+(\S+)$/);
 		if (numMatch) {
 			const [, a, op, b] = numMatch;
-			const na = Number(a), nb = Number(b);
+			const na = Number(a),
+				nb = Number(b);
 			if (op === "-eq") return na === nb;
 			if (op === "-ne") return na !== nb;
 			if (op === "-lt") return na < nb;
@@ -116,18 +181,60 @@ async function evalCondition(cond: string, ctx: CommandContext): Promise<boolean
 		}
 	}
 	// fallback: run command and check exit code
-	const r = await runCommand(expanded, ctx.authUser, ctx.hostname, ctx.mode, ctx.cwd, ctx.shell, undefined, ctx.env);
+	const r = await runCommand(
+		expanded,
+		ctx.authUser,
+		ctx.hostname,
+		ctx.mode,
+		ctx.cwd,
+		ctx.shell,
+		undefined,
+		ctx.env,
+	);
 	return (r.exitCode ?? 0) === 0;
 }
 
-async function runBlocks(blocks: Block[], ctx: CommandContext): Promise<CommandResult> {
+async function runBlocks(
+	blocks: Block[],
+	ctx: CommandContext,
+): Promise<CommandResult> {
 	let lastResult: CommandResult = { exitCode: 0 };
 	let output = "";
 
 	for (const block of blocks) {
 		if (block.type === "cmd") {
-			const expanded = expandVars(block.line, ctx.env.vars, ctx.env.lastExitCode);
-			const r = await runCommand(expanded, ctx.authUser, ctx.hostname, ctx.mode, ctx.cwd, ctx.shell, undefined, ctx.env);
+			const expanded = await expandVars(
+				block.line,
+				ctx.env.vars,
+				ctx.env.lastExitCode,
+				ctx,
+			);
+
+			// Bare VAR=val assignment(s) — handle before dispatching to runCommand
+			const assignRe = /^([A-Za-z_][A-Za-z0-9_]*)=(.*)/;
+			const tokens = expanded.trim().split(/\s+/);
+			if (tokens.length > 0 && assignRe.test(tokens[0]!)) {
+				const allAssign = tokens.every((t) => assignRe.test(t));
+				if (allAssign) {
+					for (const tok of tokens) {
+						const m = tok.match(assignRe)!;
+						ctx.env.vars[m[1]!] = m[2]!;
+					}
+					ctx.env.lastExitCode = 0;
+					continue;
+				}
+			}
+
+			const r = await runCommand(
+				expanded,
+				ctx.authUser,
+				ctx.hostname,
+				ctx.mode,
+				ctx.cwd,
+				ctx.shell,
+				undefined,
+				ctx.env,
+			);
 			ctx.env.lastExitCode = r.exitCode ?? 0;
 			if (r.stdout) output += `${r.stdout}\n`;
 			if (r.stderr) return { ...r, stdout: output.trim() };
@@ -135,7 +242,7 @@ async function runBlocks(blocks: Block[], ctx: CommandContext): Promise<CommandR
 		} else if (block.type === "if") {
 			let ran = false;
 			if (await evalCondition(block.cond, ctx)) {
-				const sub = await runBlocks(parseBlocks(block.then), ctx);
+				const sub = await runBlocks(parseBlocks(block.then_), ctx);
 				if (sub.stdout) output += `${sub.stdout}\n`;
 				ran = true;
 			} else {
@@ -143,7 +250,8 @@ async function runBlocks(blocks: Block[], ctx: CommandContext): Promise<CommandR
 					if (await evalCondition(elif.cond, ctx)) {
 						const sub = await runBlocks(parseBlocks(elif.body), ctx);
 						if (sub.stdout) output += `${sub.stdout}\n`;
-						ran = true; break;
+						ran = true;
+						break;
 					}
 				}
 				if (!ran && block.else_.length > 0) {
@@ -152,7 +260,12 @@ async function runBlocks(blocks: Block[], ctx: CommandContext): Promise<CommandR
 				}
 			}
 		} else if (block.type === "for") {
-			const listExpanded = expandVars(block.list, ctx.env.vars, ctx.env.lastExitCode);
+			const listExpanded = await expandVars(
+				block.list,
+				ctx.env.vars,
+				ctx.env.lastExitCode,
+				ctx,
+			);
 			const items = listExpanded.trim().split(/\s+/);
 			for (const item of items) {
 				ctx.env.vars[block.var] = item;
@@ -162,7 +275,7 @@ async function runBlocks(blocks: Block[], ctx: CommandContext): Promise<CommandR
 			}
 		} else if (block.type === "while") {
 			let iterations = 0;
-			while (iterations < 1000 && await evalCondition(block.cond, ctx)) {
+			while (iterations < 1000 && (await evalCondition(block.cond, ctx))) {
 				const sub = await runBlocks(parseBlocks(block.body), ctx);
 				if (sub.stdout) output += `${sub.stdout}\n`;
 				if (sub.closeSession) return sub;
@@ -184,9 +297,12 @@ export const shCommand: ShellModule = {
 
 		// sh -c "inline script"
 		if (ifFlag(args, "-c")) {
-			const script = getArg(args, 1) ?? "";
+			const script = args[args.indexOf("-c") + 1] ?? "";
 			if (!script) return { stderr: "sh: -c requires a script", exitCode: 1 };
-			const lines = script.split(/[;\n]/).map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
+			const lines = script
+				.split(/[;\n]/)
+				.map((l) => l.trim())
+				.filter((l) => l && !l.startsWith("#"));
 			const blocks = parseBlocks(lines);
 			return runBlocks(blocks, ctx);
 		}
@@ -195,13 +311,23 @@ export const shCommand: ShellModule = {
 		const fileArg = args[0];
 		if (fileArg) {
 			const p = resolvePath(cwd, fileArg);
-			if (!shell.vfs.exists(p)) return { stderr: `sh: ${fileArg}: No such file or directory`, exitCode: 1 };
+			if (!shell.vfs.exists(p))
+				return {
+					stderr: `sh: ${fileArg}: No such file or directory`,
+					exitCode: 1,
+				};
 			const content = shell.vfs.readFile(p);
-			const lines = content.split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
+			const lines = content
+				.split("\n")
+				.map((l) => l.trim())
+				.filter((l) => l && !l.startsWith("#"));
 			const blocks = parseBlocks(lines);
 			return runBlocks(blocks, ctx);
 		}
 
-		return { stderr: "sh: invalid usage. Use: sh -c 'cmd' or sh <file>", exitCode: 1 };
+		return {
+			stderr: "sh: invalid usage. Use: sh -c 'cmd' or sh <file>",
+			exitCode: 1,
+		};
 	},
 };

package/src/commands/shift.ts

@@ -0,0 +1,53 @@
+import type { ShellModule } from "../types/commands";
+
+export const shiftCommand: ShellModule = {
+	name: "shift",
+	description: "Shift positional parameters",
+	category: "shell",
+	params: ["[n]"],
+	// shift is meaningful only inside sh scripts where positional params exist.
+	// In the current impl, positional params ($1 $2 …) aren't tracked in env by default.
+	// We store them under env.vars.__argv and shift there if present.
+	run: ({ args, env }) => {
+		if (!env) return { exitCode: 0 };
+		const n = parseInt(args[0] ?? "1", 10) || 1;
+		const argv = env.vars.__argv?.split("\x00").filter(Boolean) ?? [];
+		env.vars.__argv = argv.slice(n).join("\x00");
+		// Update $1 $2 … in env
+		const shifted = argv.slice(n);
+		for (let i = 1; i <= 9; i++) {
+			env.vars[String(i)] = shifted[i - 1] ?? "";
+		}
+		return { exitCode: 0 };
+	},
+};
+
+export const trapCommand: ShellModule = {
+	name: "trap",
+	description: "Trap signals and events",
+	category: "shell",
+	params: ["[action] [signal...]"],
+	// Store trap handlers in env for EXIT signal support
+	run: ({ args, env }) => {
+		if (!env || args.length === 0) return { exitCode: 0 };
+		const action = args[0] ?? "";
+		const signals = args.slice(1);
+		for (const sig of signals) {
+			env.vars[`__trap_${sig.toUpperCase()}`] = action;
+		}
+		return { exitCode: 0 };
+	},
+};
+
+export const returnCommand: ShellModule = {
+	name: "return",
+	description: "Return from a shell function",
+	category: "shell",
+	params: ["[n]"],
+	run: ({ args, env }) => {
+		const code = parseInt(args[0] ?? "0", 10);
+		if (env) env.lastExitCode = code;
+		// Signal the caller via exitCode; function return is handled by runBlocks
+		return { exitCode: code };
+	},
+};

package/src/commands/sleep.ts

@@ -7,7 +7,8 @@ export const sleepCommand: ShellModule = {
 	params: ["<seconds>"],
 	run: async ({ args }) => {
 		const secs = parseFloat(args[0] ?? "1");
-		if (Number.isNaN(secs) || secs < 0) return { stderr: "sleep: invalid time", exitCode: 1 };
+		if (Number.isNaN(secs) || secs < 0)
+			return { stderr: "sleep: invalid time", exitCode: 1 };
 		await new Promise((r) => setTimeout(r, secs * 1000));
 		return { exitCode: 0 };
 	},

package/src/commands/sort.ts

@@ -15,12 +15,16 @@ export const sortCommand: ShellModule = {
 
 		const getContent = (): string => {
 			if (files.length > 0) {
-				return files.map((f) => {
-					try {
-						assertPathAccess(authUser, resolvePath(cwd, f), "sort");
-						return shell.vfs.readFile(resolvePath(cwd, f));
-					} catch { return ""; }
-				}).join("\n");
+				return files
+					.map((f) => {
+						try {
+							assertPathAccess(authUser, resolvePath(cwd, f), "sort");
+							return shell.vfs.readFile(resolvePath(cwd, f));
+						} catch {
+							return "";
+						}
+					})
+					.join("\n");
 			}
 			return stdin ?? "";
 		};

package/src/commands/source.ts

@@ -0,0 +1,47 @@
+import type { ShellModule } from "../types/commands";
+import { resolvePath } from "./helpers";
+import { runCommand } from "./runtime";
+
+export const sourceCommand: ShellModule = {
+	name: "source",
+	aliases: ["."],
+	description: "Execute commands from a file in the current shell environment",
+	category: "shell",
+	params: ["<file> [args...]"],
+	run: async ({ args, authUser, hostname, cwd, shell, env }) => {
+		const fileArg = args[0];
+		if (!fileArg) {
+			return { stderr: "source: missing filename", exitCode: 1 };
+		}
+
+		const filePath = resolvePath(cwd, fileArg);
+		if (!shell.vfs.exists(filePath)) {
+			return {
+				stderr: `source: ${fileArg}: No such file or directory`,
+				exitCode: 1,
+			};
+		}
+
+		const content = shell.vfs.readFile(filePath);
+		let lastExitCode = 0;
+
+		for (const line of content.split("\n")) {
+			const l = line.trim();
+			if (!l || l.startsWith("#")) continue;
+			const result = await runCommand(
+				l,
+				authUser,
+				hostname,
+				"shell",
+				cwd,
+				shell,
+				undefined,
+				env,
+			);
+			lastExitCode = result.exitCode ?? 0;
+			if (result.closeSession || result.switchUser) return result;
+		}
+
+		return { exitCode: lastExitCode };
+	},
+};

package/src/commands/sudo.ts

@@ -1,6 +1,6 @@
 import type { ShellModule } from "../types/commands";
 import { parseArgs } from "./command-helpers";
-import { runCommand } from "./index";
+import { runCommand } from "./runtime";
 
 function parseSudoArgs(args: string[]): {
 	targetUser: string;

package/src/commands/tar.ts

@@ -12,13 +12,22 @@ export const tarCommand: ShellModule = {
 		const extract = ifFlag(args, ["-x"]);
 		const list = ifFlag(args, ["-t"]);
 		const fFlag = args.findIndex((a) => a.includes("f"));
-		const archiveName = fFlag !== -1 ? args[fFlag + 1] : args.find((a) => a.endsWith(".tar") || a.endsWith(".tar.gz") || a.endsWith(".tgz"));
+		const archiveName =
+			fFlag !== -1
+				? args[fFlag + 1]
+				: args.find(
+						(a) =>
+							a.endsWith(".tar") || a.endsWith(".tar.gz") || a.endsWith(".tgz"),
+					);
 
-		if (!archiveName) return { stderr: "tar: no archive specified", exitCode: 1 };
+		if (!archiveName)
+			return { stderr: "tar: no archive specified", exitCode: 1 };
 		const archivePath = resolvePath(cwd, archiveName);
 
 		if (create) {
-			const fileArgs = args.filter((a) => !a.startsWith("-") && a !== archiveName);
+			const fileArgs = args.filter(
+				(a) => !a.startsWith("-") && a !== archiveName,
+			);
 			const entries: Record<string, string> = {};
 			for (const f of fileArgs) {
 				const p = resolvePath(cwd, f);
@@ -28,7 +37,8 @@ export const tarCommand: ShellModule = {
 					else {
 						const walk = (dir: string, prefix: string) => {
 							for (const e of shell.vfs.list(dir)) {
-								const full = `${dir}/${e}`, rel = `${prefix}/${e}`;
+								const full = `${dir}/${e}`,
+									rel = `${prefix}/${e}`;
 								const s = shell.vfs.stat(full);
 								if (s.type === "file") entries[rel] = shell.vfs.readFile(full);
 								else walk(full, rel);
@@ -36,7 +46,12 @@ export const tarCommand: ShellModule = {
 						};
 						walk(p, f);
 					}
-				} catch { return { stderr: `tar: ${f}: No such file or directory`, exitCode: 1 }; }
+				} catch {
+					return {
+						stderr: `tar: ${f}: No such file or directory`,
+						exitCode: 1,
+					};
+				}
 			}
 			shell.writeFileAsUser(authUser, archivePath, JSON.stringify(entries));
 			return { exitCode: 0 };
@@ -44,8 +59,14 @@ export const tarCommand: ShellModule = {
 
 		if (list || extract) {
 			let entries: Record<string, string>;
-			try { entries = JSON.parse(shell.vfs.readFile(archivePath)); }
-			catch { return { stderr: `tar: ${archiveName}: cannot open archive`, exitCode: 1 }; }
+			try {
+				entries = JSON.parse(shell.vfs.readFile(archivePath));
+			} catch {
+				return {
+					stderr: `tar: ${archiveName}: cannot open archive`,
+					exitCode: 1,
+				};
+			}
 			if (list) return { stdout: Object.keys(entries).join("\n"), exitCode: 0 };
 			for (const [name, content] of Object.entries(entries)) {
 				shell.writeFileAsUser(authUser, resolvePath(cwd, name), content);

package/src/commands/tee.ts

@@ -14,7 +14,13 @@ export const teeCommand: ShellModule = {
 		for (const f of files) {
 			const p = resolvePath(cwd, f);
 			if (append) {
-				const existing = (() => { try { return shell.vfs.readFile(p); } catch { return ""; } })();
+				const existing = (() => {
+					try {
+						return shell.vfs.readFile(p);
+					} catch {
+						return "";
+					}
+				})();
 				shell.writeFileAsUser(authUser, p, existing + input);
 			} else {
 				shell.writeFileAsUser(authUser, p, input);