typescript-virtual-container 1.4.3 → 1.4.4

package/src/utils/expand.ts

@@ -20,35 +20,152 @@
 
 // ─── arithmetic evaluator ────────────────────────────────────────────────────
 
+type ArithToken =
+	| { type: "number"; value: number }
+	| { type: "plus" | "minus" | "mul" | "div" | "mod" | "pow" | "lparen" | "rparen" };
+
+function tokenizeArith(expr: string, env: Record<string, string>): ArithToken[] {
+	const tokens: ArithToken[] = [];
+	let i = 0;
+	while (i < expr.length) {
+		const ch = expr[i]!;
+		if (/\s/.test(ch)) {
+			i++;
+			continue;
+		}
+		if (ch === "+") { tokens.push({ type: "plus" }); i++; continue; }
+		if (ch === "-") { tokens.push({ type: "minus" }); i++; continue; }
+		if (ch === "*") {
+			if (expr[i + 1] === "*") { tokens.push({ type: "pow" }); i += 2; continue; }
+			tokens.push({ type: "mul" });
+			i++;
+			continue;
+		}
+		if (ch === "/") { tokens.push({ type: "div" }); i++; continue; }
+		if (ch === "%") { tokens.push({ type: "mod" }); i++; continue; }
+		if (ch === "(") { tokens.push({ type: "lparen" }); i++; continue; }
+		if (ch === ")") { tokens.push({ type: "rparen" }); i++; continue; }
+		if (/\d/.test(ch)) {
+			let j = i + 1;
+			while (j < expr.length && /\d/.test(expr[j]!)) j++;
+			tokens.push({ type: "number", value: Number(expr.slice(i, j)) });
+			i = j;
+			continue;
+		}
+		if (/[A-Za-z_]/.test(ch)) {
+			let j = i + 1;
+			while (j < expr.length && /[A-Za-z0-9_]/.test(expr[j]!)) j++;
+			const name = expr.slice(i, j);
+			const raw = env[name];
+			const value = raw === undefined || raw === "" ? 0 : Number(raw);
+			tokens.push({ type: "number", value: Number.isFinite(value) ? value : 0 });
+			i = j;
+			continue;
+		}
+		return [];
+	}
+	return tokens;
+}
+
 /**
- * Evaluate a simple integer arithmetic expression.
+ * Evaluate a simple integer arithmetic expression with a bounded parser.
  * Supports: +  -  *  /  %  **  unary-  ( )
- * Variables are resolved from `env` before evaluation.
+ * Variables are resolved from `env`.
  * Returns NaN on syntax error.
  */
 export function evalArith(expr: string, env: Record<string, string>): number {
-	// Substitute variable names before evaluating
-	const substituted = expr.replace(
-		/\b([A-Za-z_][A-Za-z0-9_]*)\b/g,
-		(_, name) => {
-			const val = env[name];
-			return val !== undefined && val !== "" ? val : "0";
-		},
-	);
-
-	// Whitelist: only digits, operators, spaces, parens
-	if (!/^[\d\s+\-*/%()^!&|<>=,. ]+$/.test(substituted)) return NaN;
+	const trimmed = expr.trim();
+	if (trimmed.length === 0 || trimmed.length > 1024) return NaN;
+	const tokens = tokenizeArith(trimmed, env);
+	if (tokens.length === 0) return NaN;
 
-	try {
-		// Use Function constructor for safe subset (no identifiers remain)
-		// eslint-disable-next-line no-new-func
-		const result = Function(
-			`"use strict"; return (${substituted.replace(/\*\*/g, "**")});`,
-		)();
-		return typeof result === "number" ? Math.trunc(result) : NaN;
-	} catch {
+	let index = 0;
+
+	const peek = () => tokens[index];
+	const consume = () => tokens[index++];
+
+	const parsePrimary = (): number => {
+		const token = consume();
+		if (!token) return NaN;
+		if (token.type === "number") return token.value;
+		if (token.type === "lparen") {
+			const value = parseExpression();
+			if (tokens[index]?.type !== "rparen") return NaN;
+			index++;
+			return value;
+		}
 		return NaN;
-	}
+	};
+
+	const parseUnary = (): number => {
+		const token = peek();
+		if (token?.type === "plus") {
+			consume();
+			return parseUnary();
+		}
+		if (token?.type === "minus") {
+			consume();
+			return -parseUnary();
+		}
+		return parsePrimary();
+	};
+
+	const parsePower = (): number => {
+		let left = parseUnary();
+		while (peek()?.type === "pow") {
+			consume();
+			const right = parseUnary();
+			left = left ** right;
+		}
+		return left;
+	};
+
+	const parseTerm = (): number => {
+		let left = parsePower();
+		while (true) {
+			const token = peek();
+			if (token?.type === "mul") {
+				consume();
+				left *= parsePower();
+				continue;
+			}
+			if (token?.type === "div") {
+				consume();
+				const right = parsePower();
+				left = right === 0 ? NaN : left / right;
+				continue;
+			}
+			if (token?.type === "mod") {
+				consume();
+				const right = parsePower();
+				left = right === 0 ? NaN : left % right;
+				continue;
+			}
+			return left;
+		}
+	};
+
+	const parseExpression = (): number => {
+		let left = parseTerm();
+		while (true) {
+			const token = peek();
+			if (token?.type === "plus") {
+				consume();
+				left += parseTerm();
+				continue;
+			}
+			if (token?.type === "minus") {
+				consume();
+				left -= parseTerm();
+				continue;
+			}
+			return left;
+		}
+	};
+
+	const result = parseExpression();
+	if (!Number.isFinite(result) || index !== tokens.length) return NaN;
+	return Math.trunc(result);
 }
 
 // ─── synchronous expansion ───────────────────────────────────────────────────
@@ -105,67 +222,121 @@ function outsideSingleQuotes(
  * Returns a single-element array when no brace expansion applies.
  */
 export function expandBraces(token: string): string[] {
-	// Find the first { not preceded by $
-	let depth = 0;
-	let start = -1;
-	for (let i = 0; i < token.length; i++) {
-		const ch = token[i]!;
-		if (ch === "{" && token[i - 1] !== "$") {
-			if (depth === 0) start = i;
-			depth++;
-		} else if (ch === "}") {
-			depth--;
-			if (depth === 0 && start !== -1) {
-				const prefix  = token.slice(0, start);
-				const inner   = token.slice(start + 1, i);
-				const suffix  = token.slice(i + 1);
-
-				// Range: {1..5} or {a..e}
-				const rangeMatch = inner.match(/^(-?\d+)\.\.(-?\d+)(?:\.\.-?(\d+))?$/) ||
-				                   inner.match(/^([a-z])\.\.([a-z])$/);
-				if (rangeMatch) {
-					const items: string[] = [];
-					if (/\d/.test(rangeMatch[1]!)) {
-						const from = parseInt(rangeMatch[1]!, 10);
-						const to   = parseInt(rangeMatch[2]!, 10);
-						const step = rangeMatch[3] ? parseInt(rangeMatch[3], 10) : 1;
-						const inc  = from <= to ? step : -step;
-						for (let n = from; from <= to ? n <= to : n >= to; n += inc) {
-							items.push(String(n));
+	const MaxBraceDepth = 8;
+	const MaxBraceExpansions = 256;
+
+	function expandBracesInternal(value: string, depth: number): string[] {
+		if (depth > MaxBraceDepth) return [value];
+		// Find the first { not preceded by $
+		let braceDepth = 0;
+		let start = -1;
+		for (let i = 0; i < value.length; i++) {
+			const ch = value[i]!;
+			if (ch === "{" && value[i - 1] !== "$") {
+				if (braceDepth === 0) start = i;
+				braceDepth++;
+			} else if (ch === "}") {
+				braceDepth--;
+				if (braceDepth === 0 && start !== -1) {
+					const prefix = value.slice(0, start);
+					const inner = value.slice(start + 1, i);
+					const suffix = value.slice(i + 1);
+
+					// Range: {1..5} or {a..e}
+					const rangeMatch = inner.match(/^(-?\d+)\.\.(-?\d+)(?:\.\.-?(\d+))?$/) ||
+					                   inner.match(/^([a-z])\.\.([a-z])$/);
+					if (rangeMatch) {
+						const items: string[] = [];
+						if (/\d/.test(rangeMatch[1]!)) {
+							const from = parseInt(rangeMatch[1]!, 10);
+							const to = parseInt(rangeMatch[2]!, 10);
+							const step = rangeMatch[3] ? parseInt(rangeMatch[3], 10) : 1;
+							const inc = from <= to ? step : -step;
+							for (let n = from; from <= to ? n <= to : n >= to; n += inc) {
+								items.push(String(n));
+							}
+						} else {
+							const from = rangeMatch[1]!.charCodeAt(0);
+							const to = rangeMatch[2]!.charCodeAt(0);
+							const inc = from <= to ? 1 : -1;
+							for (let c = from; from <= to ? c <= to : c >= to; c += inc) {
+								items.push(String.fromCharCode(c));
+							}
 						}
-					} else {
-						const from = rangeMatch[1]!.charCodeAt(0);
-						const to   = rangeMatch[2]!.charCodeAt(0);
-						const inc  = from <= to ? 1 : -1;
-						for (let c = from; from <= to ? c <= to : c >= to; c += inc) {
-							items.push(String.fromCharCode(c));
+
+						const expanded = items.map((v) => `${prefix}${v}${suffix}`);
+						const output: string[] = [];
+						for (const item of expanded) {
+							output.push(...expandBracesInternal(item, depth + 1));
+							if (output.length > MaxBraceExpansions) return [value];
 						}
+						return output;
 					}
-					const expanded = items.map((v) => `${prefix}${v}${suffix}`);
-					return expanded.flatMap(expandBraces);
-				}
 
-				// Comma list: {a,b,c} — split respecting nested braces
-				const parts: string[] = [];
-				let cur = "";
-				let d2 = 0;
-				for (const ch2 of inner) {
-					if (ch2 === "{") { d2++; cur += ch2; }
-					else if (ch2 === "}") { d2--; cur += ch2; }
-					else if (ch2 === "," && d2 === 0) { parts.push(cur); cur = ""; }
-					else { cur += ch2; }
+					// Comma list: {a,b,c} — split respecting nested braces
+					const parts: string[] = [];
+					let cur = "";
+					let innerDepth = 0;
+					for (const ch2 of inner) {
+						if (ch2 === "{") { innerDepth++; cur += ch2; }
+						else if (ch2 === "}") { innerDepth--; cur += ch2; }
+						else if (ch2 === "," && innerDepth === 0) { parts.push(cur); cur = ""; }
+						else { cur += ch2; }
+					}
+					parts.push(cur);
+
+					if (parts.length > 1) {
+						const output: string[] = [];
+						for (const part of parts) {
+							output.push(...expandBracesInternal(`${prefix}${part}${suffix}`, depth + 1));
+							if (output.length > MaxBraceExpansions) return [value];
+						}
+						return output;
+					}
+					break;
 				}
-				parts.push(cur);
+			}
+		}
+		return [value];
+	}
+
+	return expandBracesInternal(token, 0);
+}
 
-				if (parts.length > 1) {
-					const expanded = parts.map((p) => `${prefix}${p}${suffix}`);
-					return expanded.flatMap(expandBraces);
+function expandArithmeticChunks(input: string, env: Record<string, string>): string {
+	let result = "";
+	let index = 0;
+	while (index < input.length) {
+		if (input[index] === "$" && input[index + 1] === "(" && input[index + 2] === "(") {
+			let scan = index + 3;
+			let depth = 0;
+			while (scan < input.length) {
+				const ch = input[scan]!;
+				if (ch === "(") {
+					depth++;
+				} else if (ch === ")") {
+					if (depth > 0) {
+						depth--;
+					} else if (input[scan + 1] === ")") {
+						const expr = input.slice(index + 3, scan);
+						const value = evalArith(expr, env);
+						result += Number.isNaN(value) ? "0" : String(value);
+						index = scan + 2;
+						break;
+					}
 				}
+				scan++;
+			}
+			if (scan >= input.length) {
+				result += input.slice(index);
 				break;
 			}
+			continue;
 		}
+		result += input[index]!
+		index++;
 	}
-	return [token];
+	return result;
 }
 
 export function expandSync(
@@ -191,10 +362,7 @@ export function expandSync(
 		s = s.replace(/\$#/g, "0");
 
 		// $(( arithmetic )) — must come before ${ and $VAR to avoid conflicts
-		s = s.replace(/\$\(\(([^)]+(?:\([^)]*\)[^)]*)*)\)\)/g, (_, expr) => {
-			const result = evalArith(expr, env);
-			return Number.isNaN(result) ? "0" : String(result);
-		});
+		s = expandArithmeticChunks(s, env);
 
 		// ${#VAR} — string length
 		s = s.replace(/\$\{#([A-Za-z_][A-Za-z0-9_]*)\}/g, (_, name) =>
@@ -254,6 +422,14 @@ export async function expandAsync(
 	lastExit: number,
 	runCmd: (cmd: string) => Promise<string>,
 ): Promise<string> {
+	const depthKey = "__shellExpandDepth";
+	const maxDepth = 8;
+	const currentDepth = Number(env[depthKey] ?? "0");
+	if (currentDepth >= maxDepth) {
+		return expandSync(input, env, lastExit);
+	}
+	env[depthKey] = String(currentDepth + 1);
+	try {
 	// $(cmd) substitution — skip content inside single quotes
 	if (input.includes("$(")) {
 		let result = "";
@@ -308,4 +484,8 @@ export async function expandAsync(
 	}
 
 	return expandSync(input, env, lastExit);
+	} finally {
+		if (currentDepth <= 0) delete env[depthKey];
+		else env[depthKey] = String(currentDepth);
+	}
 }

package/src/utils/perfLogger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"perfLogger.d.ts","sourceRoot":"","sources":["perfLogger.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,UAAU,GAAG;IACxB,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAC9B,IAAI,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;CAC/B,CAAC;AAiBF,wBAAgB,oBAAoB,IAAI,OAAO,CAI9C;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,CA0B1D;AAED,wBAAsB,QAAQ,CAAC,CAAC,EAC/B,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GACpB,OAAO,CAAC,CAAC,CAAC,CAYZ"}

package/src/utils/tokenize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokenize.d.ts","sourceRoot":"","sources":["tokenize.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CA8EvD"}

package/src/utils/vfsDiff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vfsDiff.d.ts","sourceRoot":"","sources":["vfsDiff.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,KAAK,EACX,WAAW,EAIX,MAAM,cAAc,CAAC;AAItB,oDAAoD;AACpD,MAAM,WAAW,YAAY;IAC5B,6CAA6C;IAC7C,IAAI,EAAE,MAAM,CAAC;IACb,6CAA6C;IAC7C,IAAI,EAAE,MAAM,GAAG,WAAW,CAAC;CAC3B;AAED,uEAAuE;AACvE,MAAM,WAAW,eAAgB,SAAQ,YAAY;IACpD,IAAI,EAAE,MAAM,CAAC;IACb,uDAAuD;IACvD,MAAM,EAAE,MAAM,CAAC;IACf,sDAAsD;IACtD,KAAK,EAAE,MAAM,CAAC;CACd;AAED,gDAAgD;AAChD,MAAM,WAAW,OAAO;IACvB,oDAAoD;IACpD,KAAK,EAAE,YAAY,EAAE,CAAC;IACtB,oDAAoD;IACpD,OAAO,EAAE,YAAY,EAAE,CAAC;IACxB,6DAA6D;IAC7D,QAAQ,EAAE,eAAe,EAAE,CAAC;IAC5B,0CAA0C;IAC1C,KAAK,EAAE,OAAO,CAAC;CACf;AA4BD;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAC5B,MAAM,EAAE,WAAW,EACnB,KAAK,EAAE,WAAW,EAClB,OAAO,GAAE;IACR,yEAAyE;IACzE,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;CACb,GACJ,OAAO,CAsET;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CACzB,IAAI,EAAE,OAAO,EACb,OAAO,GAAE;IACR,wDAAwD;IACxD,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,6DAA6D;IAC7D,eAAe,CAAC,EAAE,MAAM,CAAC;CACpB,GACJ,MAAM,CAsCR;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CACzB,IAAI,EAAE,OAAO,EACb,MAAM,EAAE;IACP,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;CACpB,GACC,IAAI,CA4BN"}

package/src/web-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"web-api.d.ts","sourceRoot":"","sources":["web-api.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAG,MAAM,kBAAkB,CAAC;AAGjE;;;;GAIG;AACH,cAAM,gBAAgB;IACpB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAoC;gBAE9C,QAAQ,SAAkB;IAIhC,iBAAiB,IAAI,OAAO,CAAC,IAAI,CAAC;IAIxC,4DAA4D;IACtD,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IAI7D,uDAAuD;IACjD,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IAI9C,MAAM;IAIN,WAAW;IAIX,gFAAgF;IAChF,eAAe,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,UAAU;IAInF,uCAAuC;IACvC,MAAM,IAAI,QAAQ;IAIlB,oDAAoD;IACpD,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,QAAQ,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC;CAO9G;AAED,wBAAgB,sBAAsB,CAAC,QAAQ,CAAC,EAAE,MAAM,oBAEvD;AAED,YAAY,EAAE,gBAAgB,EAAE,CAAC"}

package/src/web-full.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"web-full.d.ts","sourceRoot":"","sources":["web-full.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C,wBAAgB,kBAAkB,CAAC,QAAQ,SAAkB,gBAK5D;AAED,YAAY,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC"}

package/src/web.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"web.d.ts","sourceRoot":"","sources":["web.ts"],"names":[],"mappings":"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"}

package/tests/command-helpers.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=command-helpers.test.d.ts.map

package/tests/command-helpers.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-helpers.test.d.ts","sourceRoot":"","sources":["command-helpers.test.ts"],"names":[],"mappings":""}

package/tests/command-helpers.test.js

@@ -0,0 +1,92 @@
+import { describe, expect, test } from "bun:test";
+import { getArg, getFlag, ifFlag } from "../src/commands/command-helpers";
+describe("command-helpers", () => {
+    test("ifFlag detects plain and inline flag forms", () => {
+        expect(ifFlag(["-l", "docs"], ["-l", "--long"])).toBe(true);
+        expect(ifFlag(["--user=root", "whoami"], "--user")).toBe(true);
+        expect(ifFlag(["docs"], ["-l", "--long"])).toBe(false);
+    });
+    test("ifFlag with multiple flags checks all", () => {
+        expect(ifFlag(["-l", "-h"], ["-l", "--long"])).toBe(true);
+        expect(ifFlag(["-h"], ["-l", "--long"])).toBe(false);
+        expect(ifFlag(["-l"], ["-l", "--long"])).toBe(true);
+    });
+    test("ifFlag empty args returns false", () => {
+        expect(ifFlag([], ["-l", "--long"])).toBe(false);
+    });
+    test("ifFlag single flag array", () => {
+        expect(ifFlag(["-n"], "-n")).toBe(true);
+        expect(ifFlag(["-m"], "-n")).toBe(false);
+    });
+    test("getFlag returns value for adjacent and inline forms", () => {
+        expect(getFlag(["-u", "root", "id"], ["-u", "--user"])).toBe("root");
+        expect(getFlag(["--user=alice", "id"], ["-u", "--user"])).toBe("alice");
+        expect(getFlag(["-i", "whoami"], "-i")).toBe("whoami");
+        expect(getFlag(["-o"], "-o")).toBe(true);
+        expect(getFlag(["pwd"], ["-u", "--user"])).toBeUndefined();
+    });
+    test("getFlag with multiple flag aliases", () => {
+        expect(getFlag(["-u", "john"], ["-u", "--user", "-U"])).toBe("john");
+        expect(getFlag(["--user=mary"], ["-u", "--user"])).toBe("mary");
+        expect(getFlag(["-U", "admin"], ["-u", "--user", "-U"])).toBe("admin");
+    });
+    test("getFlag inline with equals", () => {
+        expect(getFlag(["--option=value"], "--option")).toBe("value");
+        expect(getFlag(["--opt=123"], "--opt")).toBe("123");
+    });
+    test("getFlag first occurrence", () => {
+        expect(getFlag(["-u", "first", "-u", "second"], "-u")).toBe("first");
+    });
+    test("getFlag with boolean flag", () => {
+        expect(getFlag(["-v"], "-v")).toBe(true);
+        expect(getFlag(["-v", "file.txt"], "-v")).toBe("file.txt");
+    });
+    test("getArg skips bool and value flags", () => {
+        const args = ["-i", "-u", "root", "sh", "-c", "whoami"];
+        const options = { flags: ["-i"], flagsWithValue: ["-u"] };
+        expect(getArg(args, 0, options)).toBe("sh");
+        expect(getArg(args, 1, options)).toBe("-c");
+        expect(getArg(args, 2, options)).toBe("whoami");
+        expect(getArg(args, 3, options)).toBeUndefined();
+    });
+    test("getArg with no flags", () => {
+        const args = ["file1", "file2", "file3"];
+        const options = { flags: [], flagsWithValue: [] };
+        expect(getArg(args, 0, options)).toBe("file1");
+        expect(getArg(args, 1, options)).toBe("file2");
+        expect(getArg(args, 2, options)).toBe("file3");
+    });
+    test("getArg empty args", () => {
+        const args = [];
+        const options = { flags: ["-n"] };
+        expect(getArg(args, 0, options)).toBeUndefined();
+    });
+    test("getArg skips values for flagsWithValue", () => {
+        const args = ["-d", ":", "-f", "1", "input.txt"];
+        const options = { flagsWithValue: ["-d", "-f"] };
+        expect(getArg(args, 0, options)).toBe("input.txt");
+    });
+    test("getArg keeps tokens after -- as positional", () => {
+        const args = ["-n", "--", "-n", "hello"];
+        const options = { flags: ["-n"] };
+        expect(getArg(args, 0, options)).toBe("-n");
+        expect(getArg(args, 1, options)).toBe("hello");
+    });
+    test("getArg -- blocks all flag processing", () => {
+        const args = ["-a", "--", "-a", "-b", "-c"];
+        const options = { flags: ["-a", "-b", "-c"] };
+        expect(getArg(args, 0, options)).toBe("-a");
+        expect(getArg(args, 1, options)).toBe("-b");
+        expect(getArg(args, 2, options)).toBe("-c");
+    });
+    test("getArg with mixed flags and positionals", () => {
+        const args = ["-v", "file1", "-o", "output.txt", "file2"];
+        const options = { flags: ["-v"], flagsWithValue: ["-o"] };
+        expect(getArg(args, 0, options)).toBe("file1");
+        expect(getArg(args, 1, options)).toBe("file2");
+    });
+    test("getArg at end of args", () => {
+        const args = ["a", "b", "c"];
+        expect(getArg(args, 5, {})).toBeUndefined();
+    });
+});

package/tests/command-helpers.test.ts

@@ -8,6 +8,21 @@ describe("command-helpers", () => {
 		expect(ifFlag(["docs"], ["-l", "--long"])).toBe(false);
 	});
 
+	test("ifFlag with multiple flags checks all", () => {
+		expect(ifFlag(["-l", "-h"], ["-l", "--long"])).toBe(true);
+		expect(ifFlag(["-h"], ["-l", "--long"])).toBe(false);
+		expect(ifFlag(["-l"], ["-l", "--long"])).toBe(true);
+	});
+
+	test("ifFlag empty args returns false", () => {
+		expect(ifFlag([], ["-l", "--long"])).toBe(false);
+	});
+
+	test("ifFlag single flag array", () => {
+		expect(ifFlag(["-n"], "-n")).toBe(true);
+		expect(ifFlag(["-m"], "-n")).toBe(false);
+	});
+
 	test("getFlag returns value for adjacent and inline forms", () => {
 		expect(getFlag(["-u", "root", "id"], ["-u", "--user"])).toBe("root");
 		expect(getFlag(["--user=alice", "id"], ["-u", "--user"])).toBe("alice");
@@ -16,6 +31,26 @@ describe("command-helpers", () => {
 		expect(getFlag(["pwd"], ["-u", "--user"])).toBeUndefined();
 	});
 
+	test("getFlag with multiple flag aliases", () => {
+		expect(getFlag(["-u", "john"], ["-u", "--user", "-U"])).toBe("john");
+		expect(getFlag(["--user=mary"], ["-u", "--user"])).toBe("mary");
+		expect(getFlag(["-U", "admin"], ["-u", "--user", "-U"])).toBe("admin");
+	});
+
+	test("getFlag inline with equals", () => {
+		expect(getFlag(["--option=value"], "--option")).toBe("value");
+		expect(getFlag(["--opt=123"], "--opt")).toBe("123");
+	});
+
+	test("getFlag first occurrence", () => {
+		expect(getFlag(["-u", "first", "-u", "second"], "-u")).toBe("first");
+	});
+
+	test("getFlag with boolean flag", () => {
+		expect(getFlag(["-v"], "-v")).toBe(true);
+		expect(getFlag(["-v", "file.txt"], "-v")).toBe("file.txt");
+	});
+
 	test("getArg skips bool and value flags", () => {
 		const args = ["-i", "-u", "root", "sh", "-c", "whoami"];
 		const options = { flags: ["-i"], flagsWithValue: ["-u"] };
@@ -26,6 +61,29 @@ describe("command-helpers", () => {
 		expect(getArg(args, 3, options)).toBeUndefined();
 	});
 
+	test("getArg with no flags", () => {
+		const args = ["file1", "file2", "file3"];
+		const options = { flags: [], flagsWithValue: [] };
+
+		expect(getArg(args, 0, options)).toBe("file1");
+		expect(getArg(args, 1, options)).toBe("file2");
+		expect(getArg(args, 2, options)).toBe("file3");
+	});
+
+	test("getArg empty args", () => {
+		const args: string[] = [];
+		const options = { flags: ["-n"] };
+
+		expect(getArg(args, 0, options)).toBeUndefined();
+	});
+
+	test("getArg skips values for flagsWithValue", () => {
+		const args = ["-d", ":", "-f", "1", "input.txt"];
+		const options = { flagsWithValue: ["-d", "-f"] };
+
+		expect(getArg(args, 0, options)).toBe("input.txt");
+	});
+
 	test("getArg keeps tokens after -- as positional", () => {
 		const args = ["-n", "--", "-n", "hello"];
 		const options = { flags: ["-n"] };
@@ -33,4 +91,26 @@ describe("command-helpers", () => {
 		expect(getArg(args, 0, options)).toBe("-n");
 		expect(getArg(args, 1, options)).toBe("hello");
 	});
+
+	test("getArg -- blocks all flag processing", () => {
+		const args = ["-a", "--", "-a", "-b", "-c"];
+		const options = { flags: ["-a", "-b", "-c"] };
+
+		expect(getArg(args, 0, options)).toBe("-a");
+		expect(getArg(args, 1, options)).toBe("-b");
+		expect(getArg(args, 2, options)).toBe("-c");
+	});
+
+	test("getArg with mixed flags and positionals", () => {
+		const args = ["-v", "file1", "-o", "output.txt", "file2"];
+		const options = { flags: ["-v"], flagsWithValue: ["-o"] };
+
+		expect(getArg(args, 0, options)).toBe("file1");
+		expect(getArg(args, 1, options)).toBe("file2");
+	});
+
+	test("getArg at end of args", () => {
+		const args = ["a", "b", "c"];
+		expect(getArg(args, 5, {})).toBeUndefined();
+	});
 });

package/tests/commands-admin-net.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=commands-admin-net.test.d.ts.map

package/tests/commands-admin-net.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commands-admin-net.test.d.ts","sourceRoot":"","sources":["commands-admin-net.test.ts"],"names":[],"mappings":""}