typescript-virtual-container 1.5.2 → 1.5.4

package/src/commands/sed.ts

@@ -1,68 +0,0 @@
-import type { ShellModule } from "../types/commands";
-import { getFlag, ifFlag } from "./command-helpers";
-import { resolvePath } from "./helpers";
-
-/**
- * Stream editor for filtering and transforming text lines.
- * @category text
- * @params ["-e <expr> [file]", "s/pattern/replace/[g]"]
- */
-export const sedCommand: ShellModule = {
-	name: "sed",
-	description: "Stream editor for filtering and transforming text",
-	category: "text",
-	params: ["-e <expr> [file]", "s/pattern/replace/[g]"],
-	run: ({ authUser, shell, cwd, args, stdin }) => {
-		const inPlace = ifFlag(args, ["-i"]);
-		const expr =
-			(getFlag(args, ["-e"]) as string | undefined) ??
-			args.find((a) => !a.startsWith("-"));
-		const fileArg = args.filter((a) => !a.startsWith("-") && a !== expr).pop();
-
-		if (!expr) return { stderr: "sed: no expression", exitCode: 1 };
-
-		let content = stdin ?? "";
-		if (fileArg) {
-			const p = resolvePath(cwd, fileArg);
-			try {
-				content = shell.vfs.readFile(p);
-			} catch {
-				return {
-					stderr: `sed: ${fileArg}: No such file or directory`,
-					exitCode: 1,
-				};
-			}
-		}
-
-		// Parse s/from/to/[g]
-		const sMatch = expr.match(/^s([^a-zA-Z0-9])(.+?)\1(.*?)\1([gi]*)$/);
-		if (!sMatch)
-			return { stderr: `sed: unrecognized command: ${expr}`, exitCode: 1 };
-
-		const [, , from, to, flags] = sMatch;
-		const regexFlags = (flags ?? "").includes("i")
-			? "gi"
-			: (flags ?? "").includes("g")
-				? "g"
-				: "";
-		let regex: RegExp;
-		try {
-			regex = new RegExp(from!, regexFlags || "");
-		} catch (_e) {
-			return { stderr: `sed: invalid regex: ${from}`, exitCode: 1 };
-		}
-
-		const result =
-			(flags ?? "").includes("g") || regexFlags.includes("g")
-				? content.replace(regex, to ?? "")
-				: content.replace(regex, to ?? "");
-
-		if (inPlace && fileArg) {
-			const p = resolvePath(cwd, fileArg);
-			shell.writeFileAsUser(authUser, p, result);
-			return { exitCode: 0 };
-		}
-
-		return { stdout: result, exitCode: 0 };
-	},
-};

package/src/commands/seq.ts

@@ -1,43 +0,0 @@
-import type { ShellModule } from "../types/commands";
-
-/** Generate sequences of numbers. seq LAST / seq FIRST LAST / seq FIRST INCREMENT LAST */
-export const seqCommand: ShellModule = {
-	name: "seq",
-	description: "Print a sequence of numbers",
-	category: "text",
-	params: ["[FIRST [INCREMENT]] LAST"],
-	run: ({ args }) => {
-		const nums = args.filter((a) => !a.startsWith("-") || /^-[\d.]/.test(a)).map(Number);
-		const sep = (() => { const i = args.indexOf("-s"); return i !== -1 ? (args[i + 1] ?? "\n") : "\n"; })();
-		const fmt = (() => { const i = args.indexOf("-f"); return i !== -1 ? (args[i + 1] ?? "%g") : null; })();
-		const width = args.includes("-w");
-
-		let first = 1, inc = 1, last: number;
-		if (nums.length === 1)      { last = nums[0]!; }
-		else if (nums.length === 2) { first = nums[0]!; last = nums[1]!; }
-		else                        { first = nums[0]!; inc = nums[1]!; last = nums[2]!; }
-
-		if (inc === 0) return { stderr: "seq: zero increment\n", exitCode: 1 };
-		if ((inc > 0 && first > last) || (inc < 0 && first < last)) return { stdout: "", exitCode: 0 };
-
-		const results: string[] = [];
-		const maxSteps = 100000;
-		let steps = 0;
-		for (let n = first; inc > 0 ? n <= last : n >= last; n = Math.round((n + inc) * 1e10) / 1e10) {
-			if (++steps > maxSteps) break;
-			let s: string;
-			if (fmt) {
-				s = fmt.replace("%g", String(n)).replace("%f", n.toFixed(6)).replace("%d", String(Math.trunc(n)));
-			} else {
-				s = Number.isInteger(n) ? String(n) : n.toPrecision(12).replace(/\.?0+$/, "");
-			}
-			if (width) {
-				const maxLen = String(Math.trunc(last)).length;
-				s = s.padStart(maxLen, "0");
-			}
-			results.push(s);
-		}
-
-		return { stdout: `${results.join(sep)}\n`, exitCode: 0 };
-	},
-};

package/src/commands/set.ts

@@ -1,29 +0,0 @@
-/** biome-ignore-all lint/style/useNamingConvention: env variables */
-import type { ShellModule } from "../types/commands";
-
-/**
- * Display or set shell variables and options.
- * @category shell
- * @params ["[VAR=value]"]
- */
-export const setCommand: ShellModule = {
-	name: "set",
-	description: "Display or set shell variables",
-	category: "shell",
-	params: ["[VAR=value]"],
-	run: ({ args, env }) => {
-		if (args.length === 0) {
-			const out = Object.entries(env.vars)
-				.map(([k, v]) => `${k}=${v}`)
-				.join("\n");
-			return { stdout: out, exitCode: 0 };
-		}
-		for (const arg of args) {
-			if (arg.includes("=")) {
-				const eq = arg.indexOf("=");
-				env.vars[arg.slice(0, eq)] = arg.slice(eq + 1);
-			}
-		}
-		return { exitCode: 0 };
-	},
-};

package/src/commands/sh.ts

@@ -1,467 +0,0 @@
-import type {
-	CommandContext,
-	CommandResult,
-	ShellModule,
-} from "../types/commands";
-import { evalArith, expandAsync, expandBraces } from "../utils/expand";
-import { ifFlag } from "./command-helpers";
-import { resolvePath } from "./helpers";
-import { runCommand } from "./runtime";
-
-/** 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: "for"; var: string; list: string; body: string[] }
-	| { type: "while"; cond: string; body: string[] }
-	| { type: "func"; name: string; body: string[] }
-	| { type: "arith"; expr: string }
-	| { type: "cmd"; line: string };
-
-/** Very small shell interpreter: supports if/elif/else/fi, for/do/done, while/do/done */
-function parseBlocks(lines: string[]): Block[] {
-	const blocks: Block[] = [];
-	let i = 0;
-	while (i < lines.length) {
-		const line = lines[i]!.trim();
-		if (!line || line.startsWith("#")) {
-			i++;
-			continue;
-		}
-
-		// Function definition: name() { or function name { or name() { body }
-		const funcMatchInline = line.match(/^(?:function\s+)?(\w+)\s*\(\s*\)\s*\{(.+)\}\s*$/);
-		const funcMatch = funcMatchInline ?? (
-			line.match(/^(?:function\s+)?(\w+)\s*\(\s*\)\s*\{?\s*$/) ||
-			line.match(/^function\s+(\w+)\s*\{?\s*$/)
-		);
-		if (funcMatch) {
-			const funcName = funcMatch[1]!;
-			const body: string[] = [];
-			// Inline: name() { cmd; } — single-line form
-			if (funcMatchInline) {
-				body.push(...funcMatchInline[2]!.split(";").map((s: string) => s.trim()).filter(Boolean));
-				blocks.push({ type: "func", name: funcName, body });
-				i++;
-				continue;
-			}
-			i++;
-			while (i < lines.length && lines[i]?.trim() !== "}" && i < lines.length + 1) {
-				const l = lines[i]!.trim().replace(/^do\s+/, "");
-				if (l && l !== "{") body.push(l);
-				i++;
-			}
-			i++; // skip closing }
-			blocks.push({ type: "func", name: funcName, body });
-			continue;
-		}
-
-		// (( expr )) arithmetic statement
-		const arithMatch = line.match(/^\(\(\s*(.+?)\s*\)\)$/);
-		if (arithMatch) {
-			blocks.push({ type: "arith", expr: arithMatch[1]! });
-			i++;
-			continue;
-		}
-
-		if (line.startsWith("if ") || line === "if") {
-			const cond = line
-				.replace(/^if\s+/, "")
-				.replace(/;\s*then\s*$/, "")
-				.trim();
-			const thenLines: string[] = [];
-			const elifBlocks: Array<{ cond: string; body: string[] }> = [];
-			const elseLines: string[] = [];
-			let section: "then" | "elif" | "else" = "then";
-			let elifCond = "";
-			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 (section === "then") thenLines.push(l);
-					else if (section === "elif" && elifBlocks.length > 0)
-						elifBlocks[elifBlocks.length - 1]!.body.push(l);
-					else elseLines.push(l);
-				}
-				i++;
-			}
-			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().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 if (line.startsWith("while ")) {
-			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().replace(/^do\s+/, "");
-				if (l && l !== "do") body.push(l);
-				i++;
-			}
-			blocks.push({ type: "while", cond, body });
-		} else {
-			blocks.push({ type: "cmd", line });
-		}
-		i++;
-	}
-	return blocks;
-}
-
-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) {
-		const expr = testMatch[1]!;
-		// -f file
-		const fTest = expr.match(/^-([fdeznr])\s+(.+)$/);
-		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 === "e") return ctx.shell.vfs.exists(p);
-			if (flag === "z") return (arg ?? "").length === 0;
-			if (flag === "n") return (arg ?? "").length > 0;
-		}
-		// string comparison
-		const cmpMatch = expr.match(/^"?([^"]*)"?\s*(==|!=|=|<|>)\s*"?([^"]*)"?$/);
-		if (cmpMatch) {
-			const [, a, op, b] = cmpMatch;
-			if (op === "==" || op === "=") return a === b;
-			if (op === "!=") return a !== b;
-		}
-		// numeric
-		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);
-			if (op === "-eq") return na === nb;
-			if (op === "-ne") return na !== nb;
-			if (op === "-lt") return na < nb;
-			if (op === "-le") return na <= nb;
-			if (op === "-gt") return na > nb;
-			if (op === "-ge") return na >= nb;
-		}
-	}
-	// 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,
-	);
-	return (r.exitCode ?? 0) === 0;
-}
-
-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 = 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 (async () => {
-				// Check if expanded matches a registered function
-				const cmdName = expanded.trim().split(/\s+/)[0] ?? "";
-				const funcBody = ctx.env.vars[`__func_${cmdName}`];
-				if (funcBody) {
-					// Set positional params $1 $2 ... from remaining args
-					const funcArgs = expanded.trim().split(/\s+/).slice(1);
-					const savedVars = { ...ctx.env.vars };
-					funcArgs.forEach((a, i) => { ctx.env.vars[String(i + 1)] = a; });
-					ctx.env.vars["0"] = cmdName;
-					const funcLines = funcBody.split("\n");
-					const funcResult = await runBlocks(parseBlocks(funcLines), ctx);
-					// Restore positional params
-					for (let pi = 1; pi <= funcArgs.length; pi++) delete ctx.env.vars[String(pi)];
-					Object.assign(ctx.env.vars, { ...savedVars, ...ctx.env.vars });
-					return funcResult;
-				}
-				return 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() };
-			lastResult = r;
-		} else if (block.type === "if") {
-			let ran = false;
-			if (await evalCondition(block.cond, ctx)) {
-				const sub = await runBlocks(parseBlocks(block.then_), ctx);
-				if (sub.stdout) output += `${sub.stdout}\n`;
-				ran = true;
-			} else {
-				for (const elif of block.elif) {
-					if (await evalCondition(elif.cond, ctx)) {
-						const sub = await runBlocks(parseBlocks(elif.body), ctx);
-						if (sub.stdout) output += `${sub.stdout}\n`;
-						ran = true;
-						break;
-					}
-				}
-				if (!ran && block.else_.length > 0) {
-					const sub = await runBlocks(parseBlocks(block.else_), ctx);
-					if (sub.stdout) output += `${sub.stdout}\n`;
-				}
-			}
-		} else if (block.type === "func") {
-			// Register function in env vars as __func_<name>=<body>
-			ctx.env.vars[`__func_${block.name}`] = block.body.join("\n");
-		} else if (block.type === "arith") {
-			// (( expr )) — evaluate arithmetic, update vars
-			const expr = block.expr.trim();
-			// Handle i++ / i-- / i+=N / i-=N
-			const incMatch = expr.match(/^(\w+)\s*(\+\+|--)$/);
-			if (incMatch) {
-				const val = parseInt(ctx.env.vars[incMatch[1]!] ?? "0", 10);
-				ctx.env.vars[incMatch[1]!] = String(incMatch[2] === "++" ? val + 1 : val - 1);
-			} else {
-				const assignMatch = expr.match(/^(\w+)\s*([+\-*/])=\s*(.+)$/);
-				if (assignMatch) {
-					const lhs = parseInt(ctx.env.vars[assignMatch[1]!] ?? "0", 10);
-					const rhs = parseInt(assignMatch[3]!, 10);
-					const ops: Record<string, number> = { "+": lhs + rhs, "-": lhs - rhs, "*": lhs * rhs, "/": Math.floor(lhs / rhs) };
-					ctx.env.vars[assignMatch[1]!] = String(ops[assignMatch[2]!] ?? lhs);
-				} else {
-					const value = evalArith(expr, ctx.env.vars);
-					if (!Number.isNaN(value)) {
-						ctx.env.lastExitCode = value === 0 ? 1 : 0;
-					}
-				}
-			}
-		} else if (block.type === "for") {
-			const listExpanded = await expandVars(
-				block.list,
-				ctx.env.vars,
-				ctx.env.lastExitCode,
-				ctx,
-			);
-			// Apply brace expansion to each token in the list
-			const items = listExpanded.trim().split(/\s+/).flatMap(expandBraces);
-			for (const item of items) {
-				ctx.env.vars[block.var] = item;
-				const sub = await runBlocks(parseBlocks(block.body), ctx);
-				if (sub.stdout) output += `${sub.stdout}\n`;
-				if (sub.closeSession) return sub;
-			}
-		} else if (block.type === "while") {
-			let iterations = 0;
-			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;
-				iterations++;
-			}
-		}
-	}
-	return { ...lastResult, stdout: output.trim() || lastResult.stdout };
-}
-
-/**
- * Execute shell scripts or commands with a minimal shell interpreter.
- * Supports if/elif/else, for loops, while loops, and variable expansion.
- * @category shell
- * @params ["-c <script>", "[<file>]"]
- */
-
-/**
- * Split a sh script into logical lines, respecting:
- * - `{...}` braces (function bodies)
- * - Newlines and semicolons at depth 0 only
- */
-function splitShScript(script: string): string[] {
-	const lines: string[] = [];
-	let current = "";
-	let depth = 0;
-	let inSingleQ = false;
-	let inDoubleQ = false;
-	let i = 0;
-	while (i < script.length) {
-		const ch = script[i]!;
-		if (!inSingleQ && !inDoubleQ) {
-			if (ch === "'") { inSingleQ = true; current += ch; i++; continue; }
-			if (ch === '"') { inDoubleQ = true; current += ch; i++; continue; }
-			if (ch === "{") { depth++; current += ch; i++; continue; }
-			if (ch === "}") {
-				depth--;
-				current += ch;
-				i++;
-				// At depth 0, closing } ends the function body line
-				if (depth === 0) {
-					const t = current.trim();
-					if (t) lines.push(t);
-					current = "";
-					// Skip trailing ; or whitespace
-					while (i < script.length && (script[i] === ";" || script[i] === " ")) i++;
-				}
-				continue;
-			}
-			if (depth === 0 && (ch === ";" || ch === "\n")) {
-				const t = current.trim();
-				if (t && !t.startsWith("#")) lines.push(t);
-				current = "";
-				i++;
-				continue;
-			}
-		} else if (inSingleQ && ch === "'") {
-			inSingleQ = false;
-		} else if (inDoubleQ && ch === '"') {
-			inDoubleQ = false;
-		}
-		current += ch;
-		i++;
-	}
-	const t = current.trim();
-	if (t && !t.startsWith("#")) lines.push(t);
-	return lines;
-}
-
-export const shCommand: ShellModule = {
-	name: "sh",
-	aliases: ["bash"],
-	description: "Execute shell script or command",
-	category: "shell",
-	params: ["-c <script>", "[<file>]"],
-	run: async (ctx: CommandContext) => {
-		const { args, shell, cwd } = ctx;
-
-		// sh -c "inline script"
-		if (ifFlag(args, "-c")) {
-			const script = args[args.indexOf("-c") + 1] ?? "";
-			if (!script) return { stderr: "sh: -c requires a script", exitCode: 1 };
-			const lines = splitShScript(script);
-			const blocks = parseBlocks(lines);
-			return runBlocks(blocks, ctx);
-		}
-
-		// sh <file>
-		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,
-				};
-			const content = shell.vfs.readFile(p);
-			const lines = splitShScript(content);
-			const blocks = parseBlocks(lines);
-			return runBlocks(blocks, ctx);
-		}
-
-		return {
-			stderr: "sh: invalid usage. Use: sh -c 'cmd' or sh <file>",
-			exitCode: 1,
-		};
-	},
-};

package/src/commands/shift.ts

@@ -1,63 +0,0 @@
-import type { ShellModule } from "../types/commands";
-
-/**
- * Shift positional parameters (remove first N arguments).
- * @category shell
- * @params ["[n]"]
- */
-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 };
-	},
-};
-
-/**
- * Trap signals and execute actions on signal receipt or shell exit.
- * @category shell
- * @params ["[action] [signal...]"]
- */
-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

@@ -1,20 +0,0 @@
-import type { ShellModule } from "../types/commands";
-
-/**
- * Delay execution for a specified number of seconds.
- * @category system
- * @params ["<seconds>"]
- */
-export const sleepCommand: ShellModule = {
-	name: "sleep",
-	description: "Delay execution",
-	category: "system",
-	params: ["<seconds>"],
-	run: async ({ args }) => {
-		const secs = parseFloat(args[0] ?? "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 };
-	},
-};