agentica 0.44.0-dev.20260313 → 0.44.0-dev.20260313-2

package/dist/index.mjs

@@ -2,11 +2,13 @@ import process$1, { stdin, stdout } from 'node:process';
 import { stripVTControlCharacters } from 'node:util';
 import * as g from 'node:readline';
 import g__default from 'node:readline';
-import { Writable } from 'node:stream';
+import { Writable, Readable } from 'node:stream';
 import { createRequire } from 'node:module';
-import fss, { existsSync } from 'node:fs';
-import fs, { rm, appendFile, readFile, writeFile } from 'node:fs/promises';
-import path, { join } from 'node:path';
+import fss, { createWriteStream, existsSync } from 'node:fs';
+import * as fs from 'node:fs/promises';
+import fs__default, { rm, appendFile, readFile, writeFile } from 'node:fs/promises';
+import * as path from 'node:path';
+import path__default, { join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { spawn as spawn$1 } from 'node:child_process';
 import { once, on } from 'node:events';
@@ -16,7 +18,6 @@ import detectIndent from 'detect-indent';
 import indentString from 'indent-string';
 import os from 'node:os';
 import { createGunzip } from 'node:zlib';
-import { unpackTar } from 'modern-tar/fs';
 
 function getDefaultExportFromCjs (x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
@@ -4560,7 +4561,7 @@ const {
   Help,
 } = commander;
 
-const version = "0.44.0-dev.20260313";
+const version = "0.44.0-dev.20260313-2";
 
 /**
  * Error thrown when type assertion fails.
@@ -4685,7 +4686,7 @@ const getOptions = ({
 	cwd: cwdOption = '.',
 	...options
 }) => {
-	const cwd = cwdOption instanceof URL ? fileURLToPath(cwdOption) : path.resolve(cwdOption);
+	const cwd = cwdOption instanceof URL ? fileURLToPath(cwdOption) : path__default.resolve(cwdOption);
 	const env = envOption ? {...process$1.env, ...envOption} : undefined;
 	const input = stdio[0]?.string;
 	return {
@@ -4698,16 +4699,16 @@ const getOptions = ({
 };
 
 const addLocalPath = ({Path = '', PATH = Path, ...env}, cwd) => {
-	const pathParts = PATH.split(path.delimiter);
-	const localPaths = getLocalPaths([], path.resolve(cwd))
-		.map(localPath => path.join(localPath, 'node_modules/.bin'))
+	const pathParts = PATH.split(path__default.delimiter);
+	const localPaths = getLocalPaths([], path__default.resolve(cwd))
+		.map(localPath => path__default.join(localPath, 'node_modules/.bin'))
 		.filter(localPath => !pathParts.includes(localPath));
-	return {...env, PATH: [...localPaths, PATH].filter(Boolean).join(path.delimiter)};
+	return {...env, PATH: [...localPaths, PATH].filter(Boolean).join(path__default.delimiter)};
 };
 
 const getLocalPaths = (localPaths, localPath) => localPaths.at(-1) === localPath
 	? localPaths
-	: getLocalPaths([...localPaths, localPath], path.resolve(localPath, '..'));
+	: getLocalPaths([...localPaths, localPath], path__default.resolve(localPath, '..'));
 
 // When setting `shell: true` under-the-hood, we must manually escape the file and arguments.
 // This ensures arguments are properly split, and prevents command injection.
@@ -4741,11 +4742,11 @@ const memoize = function_ => (...arguments_) =>
 	// Use returned assignment to keep code small
 	EXE_MEMO[arguments_.join('\0')] ??= function_(...arguments_);
 
-const access = memoize(fs.access);
+const access = memoize(fs__default.access);
 const mIsExe = memoize(async (file, cwd, PATH) => {
 	const parts = PATH
 		// `PATH` is ;-separated on Windows
-		.split(path.delimiter)
+		.split(path__default.delimiter)
 		// `PATH` allows leading/trailing ; on Windows
 		.filter(Boolean)
 		// `PATH` parts can be double quoted on Windows
@@ -4755,7 +4756,7 @@ const mIsExe = memoize(async (file, cwd, PATH) => {
 	try {
 		await Promise.any(
 			[cwd, ...parts].flatMap(part => exeExtensions
-				.map(extension => access(`${path.resolve(part, file)}${extension}`)),
+				.map(extension => access(`${path__default.resolve(part, file)}${extension}`)),
 			),
 		);
 	} catch {
@@ -5161,6 +5162,598 @@ function insertCodeIntoAgenticaStarter({ content, importCode, connectorCode }) {
   return insertWithIndent(result, "/// INSERT CONTROLLER HERE", connectorCode);
 }
 
+//#region src/web/compression.ts
+
+//#endregion
+//#region src/web/options.ts
+function createTarOptionsTransformer(options = {}) {
+	return new TransformStream({ async transform(entry, controller) {
+		let header = entry.header;
+		const stripCount = options.strip;
+		if (stripCount && stripCount > 0) {
+			const newName = stripPathComponents(header.name, stripCount);
+			if (newName === null) {
+				drainStream(entry.body);
+				return;
+			}
+			let newLinkname = header.linkname;
+			if (newLinkname?.startsWith("/")) {
+				const strippedLinkTarget = stripPathComponents(newLinkname, stripCount);
+				newLinkname = strippedLinkTarget === null ? "/" : `/${strippedLinkTarget}`;
+			}
+			header = {
+				...header,
+				name: header.type === "directory" && !newName.endsWith("/") ? `${newName}/` : newName,
+				linkname: newLinkname
+			};
+		}
+		if (options.filter && options.filter(header) === false) {
+			drainStream(entry.body);
+			return;
+		}
+		if (options.map) header = options.map(header);
+		controller.enqueue({
+			header,
+			body: entry.body
+		});
+	} });
+}
+function stripPathComponents(path, stripCount) {
+	const components = path.split("/").filter((c) => c.length > 0);
+	if (stripCount >= components.length) return null;
+	return components.slice(stripCount).join("/");
+}
+function drainStream(stream) {
+	(async () => {
+		const reader = stream.getReader();
+		try {
+			while (true) {
+				const { done } = await reader.read();
+				if (done) break;
+			}
+		} catch (error) {
+			console.debug("Stream drain error (non-critical):", error);
+		} finally {
+			reader.releaseLock();
+		}
+	})();
+}
+
+//#endregion
+//#region src/web/constants.ts
+const BLOCK_SIZE = 512;
+const BLOCK_SIZE_MASK = 511;
+const USTAR_NAME_OFFSET = 0;
+const USTAR_NAME_SIZE = 100;
+const USTAR_MODE_OFFSET = 100;
+const USTAR_MODE_SIZE = 8;
+const USTAR_UID_OFFSET = 108;
+const USTAR_UID_SIZE = 8;
+const USTAR_GID_OFFSET = 116;
+const USTAR_GID_SIZE = 8;
+const USTAR_SIZE_OFFSET = 124;
+const USTAR_SIZE_SIZE = 12;
+const USTAR_MTIME_OFFSET = 136;
+const USTAR_MTIME_SIZE = 12;
+const USTAR_CHECKSUM_OFFSET = 148;
+const USTAR_CHECKSUM_SIZE = 8;
+const USTAR_TYPEFLAG_OFFSET = 156;
+const USTAR_TYPEFLAG_SIZE = 1;
+const USTAR_LINKNAME_OFFSET = 157;
+const USTAR_LINKNAME_SIZE = 100;
+const USTAR_MAGIC_OFFSET = 257;
+const USTAR_MAGIC_SIZE = 6;
+const USTAR_UNAME_OFFSET = 265;
+const USTAR_UNAME_SIZE = 32;
+const USTAR_GNAME_OFFSET = 297;
+const USTAR_GNAME_SIZE = 32;
+const USTAR_PREFIX_OFFSET = 345;
+const USTAR_PREFIX_SIZE = 155;
+const FLAGTYPE = {
+	"0": "file",
+	"1": "link",
+	"2": "symlink",
+	"3": "character-device",
+	"4": "block-device",
+	"5": "directory",
+	"6": "fifo",
+	x: "pax-header",
+	g: "pax-global-header",
+	L: "gnu-long-name",
+	K: "gnu-long-link-name"
+};
+
+//#endregion
+//#region src/web/utils.ts
+new TextEncoder();
+const decoder = new TextDecoder();
+function readString(view, offset, size) {
+	const end = view.indexOf(0, offset);
+	const sliceEnd = end === -1 || end > offset + size ? offset + size : end;
+	return decoder.decode(view.subarray(offset, sliceEnd));
+}
+function readOctal(view, offset, size) {
+	let value = 0;
+	const end = offset + size;
+	for (let i = offset; i < end; i++) {
+		const charCode = view[i];
+		if (charCode === 0) break;
+		if (charCode === 32) continue;
+		value = (value << 3) + (charCode - 48);
+	}
+	return value;
+}
+function readNumeric(view, offset, size) {
+	if (view[offset] & 128) {
+		let result = 0;
+		for (let i = 0; i < size; i++) result = result << 8 | view[offset + i];
+		return result & ~(128 << (size - 1) * 8);
+	}
+	return readOctal(view, offset, size);
+}
+async function streamToBuffer(stream) {
+	const chunks = [];
+	const reader = stream.getReader();
+	let totalLength = 0;
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			chunks.push(value);
+			totalLength += value.length;
+		}
+		const result = new Uint8Array(totalLength);
+		let offset = 0;
+		for (const chunk of chunks) {
+			result.set(chunk, offset);
+			offset += chunk.length;
+		}
+		return result;
+	} finally {
+		reader.releaseLock();
+	}
+}
+
+//#endregion
+//#region src/web/checksum.ts
+const CHECKSUM_SPACE = 32;
+function validateChecksum(block) {
+	const stored = readOctal(block, USTAR_CHECKSUM_OFFSET, USTAR_CHECKSUM_SIZE);
+	let sum = 0;
+	for (let i = 0; i < block.length; i++) if (i >= USTAR_CHECKSUM_OFFSET && i < USTAR_CHECKSUM_OFFSET + USTAR_CHECKSUM_SIZE) sum += CHECKSUM_SPACE;
+	else sum += block[i];
+	return stored === sum;
+}
+
+//#endregion
+//#region src/web/unpack.ts
+function createTarDecoder(options = {}) {
+	const strict = options.strict ?? false;
+	const chunks = [];
+	let totalLength = 0;
+	let offset = 0;
+	let currentEntry = null;
+	let paxGlobals = {};
+	let nextEntryOverrides = {};
+function consume(size) {
+		if (totalLength < size || chunks.length === 0) return null;
+		totalLength -= size;
+		const firstChunk = chunks[0];
+		if (firstChunk.length - offset >= size) {
+			const data$1 = firstChunk.slice(offset, offset + size);
+			offset += size;
+			if (offset === firstChunk.length) {
+				chunks.shift();
+				offset = 0;
+			}
+			return data$1;
+		}
+		const data = new Uint8Array(size);
+		let bytesCopied = 0;
+		while (bytesCopied < size) {
+			const chunk = chunks[0];
+			const bytesToCopy = Math.min(size - bytesCopied, chunk.length - offset);
+			data.set(chunk.subarray(offset, offset + bytesToCopy), bytesCopied);
+			bytesCopied += bytesToCopy;
+			offset += bytesToCopy;
+			if (offset === chunk.length) {
+				chunks.shift();
+				offset = 0;
+			}
+		}
+		return data;
+	}
+function forward(size, targetController) {
+		const bytesToForward = Math.min(size, totalLength);
+		let forwarded = 0;
+		while (forwarded < bytesToForward && chunks.length > 0) {
+			const firstChunk = chunks[0];
+			const availableInChunk = firstChunk.length - offset;
+			const bytesToSend = Math.min(bytesToForward - forwarded, availableInChunk);
+			targetController.enqueue(firstChunk.subarray(offset, offset + bytesToSend));
+			forwarded += bytesToSend;
+			offset += bytesToSend;
+			if (offset === firstChunk.length) {
+				chunks.shift();
+				offset = 0;
+			}
+		}
+		totalLength -= forwarded;
+		return forwarded;
+	}
+function unshift(data) {
+		if (offset > 0) {
+			chunks[0] = chunks[0].subarray(offset);
+			offset = 0;
+		}
+		chunks.unshift(data);
+		totalLength += data.length;
+	}
+	return new TransformStream({
+		transform(chunk, controller) {
+			chunks.push(chunk);
+			totalLength += chunk.length;
+			while (true) {
+				if (currentEntry) {
+					const forwarded = forward(currentEntry.bytesLeft, currentEntry.controller);
+					currentEntry.bytesLeft -= forwarded;
+					if (currentEntry.bytesLeft === 0) {
+						const padding = -currentEntry.header.size & BLOCK_SIZE_MASK;
+						if (consume(padding) === null) break;
+						try {
+							currentEntry.controller.close();
+						} catch {}
+						currentEntry = null;
+					} else break;
+				}
+				const headerBlock = consume(BLOCK_SIZE);
+				if (headerBlock === null) break;
+				if (headerBlock.every((b) => b === 0)) {
+					const nextBlock = consume(BLOCK_SIZE);
+					if (nextBlock === null) {
+						unshift(headerBlock);
+						break;
+					}
+					if (nextBlock.every((b) => b === 0)) {
+						controller.terminate();
+						return;
+					} else {
+						unshift(nextBlock);
+						unshift(headerBlock);
+					}
+				}
+				const header = parseUstarHeader(headerBlock, strict);
+				const metaParser = getMetaParser(header.type);
+				if (metaParser) {
+					const dataSize = header.size;
+					const dataBlocksSize = dataSize + BLOCK_SIZE_MASK & -BLOCK_SIZE;
+					if (totalLength < dataBlocksSize) {
+						unshift(headerBlock);
+						break;
+					}
+					const data = consume(dataSize);
+					if (data === null) {
+						unshift(headerBlock);
+						break;
+					}
+					const padding = dataBlocksSize - dataSize;
+					if (padding > 0) {
+						if (consume(padding) === null) {
+							unshift(data);
+							unshift(headerBlock);
+							break;
+						}
+					}
+					const overrides = metaParser(data);
+					if (header.type === "pax-global-header") paxGlobals = Object.assign({}, paxGlobals, overrides);
+					else nextEntryOverrides = Object.assign({}, nextEntryOverrides, overrides);
+					continue;
+				}
+				const finalHeader = header;
+				applyOverrides(finalHeader, paxGlobals);
+				applyOverrides(finalHeader, nextEntryOverrides);
+				if (header.prefix && header.magic === "ustar" && !nextEntryOverrides.name && !paxGlobals.name) finalHeader.name = `${header.prefix}/${finalHeader.name}`;
+				nextEntryOverrides = {};
+				let bodyController;
+				const body = new ReadableStream({ start: (c) => bodyController = c });
+				controller.enqueue({
+					header: finalHeader,
+					body
+				});
+				if (finalHeader.size > 0) currentEntry = {
+					header: finalHeader,
+					bytesLeft: finalHeader.size,
+					controller: bodyController
+				};
+				else try {
+					bodyController.close();
+				} catch {}
+			}
+		},
+		flush(controller) {
+			if (currentEntry) if (strict) {
+				const error = /* @__PURE__ */ new Error(`Tar archive is truncated. Expected ${currentEntry.header.size} bytes but received ${currentEntry.header.size - currentEntry.bytesLeft}.`);
+				currentEntry.controller.error(error);
+				controller.error(error);
+			} else try {
+				currentEntry.controller.close();
+			} catch {}
+			if (strict) {
+				if (chunks.length > 0 && offset < chunks[0].length) {
+					if (chunks[0].subarray(offset).some((b) => b !== 0)) {
+						controller.error(/* @__PURE__ */ new Error("Unexpected data at end of archive."));
+						return;
+					}
+				}
+				for (let i = 1; i < chunks.length; i++) if (chunks[i].some((b) => b !== 0)) {
+					controller.error(/* @__PURE__ */ new Error("Unexpected data at end of archive."));
+					return;
+				}
+			}
+		}
+	});
+}
+function parseUstarHeader(block, strict) {
+	if (strict && !validateChecksum(block)) throw new Error("Invalid tar header checksum.");
+	const typeflag = readString(block, USTAR_TYPEFLAG_OFFSET, USTAR_TYPEFLAG_SIZE);
+	const magic = readString(block, USTAR_MAGIC_OFFSET, USTAR_MAGIC_SIZE);
+	if (strict && magic !== "ustar") throw new Error(`Invalid USTAR magic: expected "ustar", got "${magic}"`);
+	return {
+		name: readString(block, USTAR_NAME_OFFSET, USTAR_NAME_SIZE),
+		mode: readOctal(block, USTAR_MODE_OFFSET, USTAR_MODE_SIZE),
+		uid: readNumeric(block, USTAR_UID_OFFSET, USTAR_UID_SIZE),
+		gid: readNumeric(block, USTAR_GID_OFFSET, USTAR_GID_SIZE),
+		size: readNumeric(block, USTAR_SIZE_OFFSET, USTAR_SIZE_SIZE),
+		mtime: /* @__PURE__ */ new Date(readNumeric(block, USTAR_MTIME_OFFSET, USTAR_MTIME_SIZE) * 1e3),
+		checksum: readOctal(block, USTAR_CHECKSUM_OFFSET, USTAR_CHECKSUM_SIZE),
+		type: FLAGTYPE[typeflag] || "file",
+		linkname: readString(block, USTAR_LINKNAME_OFFSET, USTAR_LINKNAME_SIZE),
+		magic,
+		uname: readString(block, USTAR_UNAME_OFFSET, USTAR_UNAME_SIZE),
+		gname: readString(block, USTAR_GNAME_OFFSET, USTAR_GNAME_SIZE),
+		prefix: readString(block, USTAR_PREFIX_OFFSET, USTAR_PREFIX_SIZE)
+	};
+}
+function parsePax(buffer) {
+	const overrides = {};
+	const pax = {};
+	let offset = 0;
+	while (offset < buffer.length) {
+		const spaceIndex = buffer.indexOf(32, offset);
+		if (spaceIndex === -1) break;
+		const length = parseInt(decoder.decode(buffer.subarray(offset, spaceIndex)), 10);
+		if (Number.isNaN(length) || length === 0) break;
+		const recordEnd = offset + length;
+		const [key, value] = decoder.decode(buffer.subarray(spaceIndex + 1, recordEnd - 1)).split("=", 2);
+		if (key && value !== void 0) {
+			pax[key] = value;
+			switch (key) {
+				case "path":
+					overrides.name = value;
+					break;
+				case "linkpath":
+					overrides.linkname = value;
+					break;
+				case "size":
+					overrides.size = parseInt(value, 10);
+					break;
+				case "mtime":
+					overrides.mtime = parseFloat(value);
+					break;
+				case "uid":
+					overrides.uid = parseInt(value, 10);
+					break;
+				case "gid":
+					overrides.gid = parseInt(value, 10);
+					break;
+				case "uname":
+					overrides.uname = value;
+					break;
+				case "gname":
+					overrides.gname = value;
+					break;
+			}
+		}
+		offset = recordEnd;
+	}
+	if (Object.keys(pax).length > 0) overrides.pax = pax;
+	return overrides;
+}
+function applyOverrides(header, overrides) {
+	if (overrides.name !== void 0) header.name = overrides.name;
+	if (overrides.linkname !== void 0) header.linkname = overrides.linkname;
+	if (overrides.size !== void 0) header.size = overrides.size;
+	if (overrides.mtime !== void 0) header.mtime = /* @__PURE__ */ new Date(overrides.mtime * 1e3);
+	if (overrides.uid !== void 0) header.uid = overrides.uid;
+	if (overrides.gid !== void 0) header.gid = overrides.gid;
+	if (overrides.uname !== void 0) header.uname = overrides.uname;
+	if (overrides.gname !== void 0) header.gname = overrides.gname;
+	if (overrides.pax) header.pax = Object.assign({}, header.pax ?? {}, overrides.pax);
+}
+function getMetaParser(type) {
+	switch (type) {
+		case "pax-global-header":
+		case "pax-header": return parsePax;
+		case "gnu-long-name": return (data) => ({ name: readString(data, 0, data.length) });
+		case "gnu-long-link-name": return (data) => ({ linkname: readString(data, 0, data.length) });
+		default: return;
+	}
+}
+
+//#endregion
+//#region src/fs/path.ts
+const unicodeCache = /* @__PURE__ */ new Map();
+const MAX_CACHE_SIZE = 1e4;
+const normalizeUnicode = (s) => {
+	let result = unicodeCache.get(s);
+	if (result !== void 0) unicodeCache.delete(s);
+	result = result ?? s.normalize("NFD");
+	unicodeCache.set(s, result);
+	const overflow = unicodeCache.size - MAX_CACHE_SIZE;
+	if (overflow > MAX_CACHE_SIZE / 10) {
+		const keys = unicodeCache.keys();
+		for (let i = 0; i < overflow; i++) unicodeCache.delete(keys.next().value);
+	}
+	return result;
+};
+async function validatePath(currentPath, root, cache) {
+	const normalizedPath = normalizeUnicode(currentPath);
+	if (normalizedPath === root || cache.has(normalizedPath)) return;
+	const relativePath = path.relative(root, normalizedPath);
+	if (!relativePath) return;
+	const components = relativePath.split(path.sep);
+	let current = root;
+	for (const component of components) {
+		current = path.join(current, component);
+		if (cache.has(current)) continue;
+		let stat$1;
+		try {
+			stat$1 = await fs.lstat(current);
+		} catch (err) {
+			if (err instanceof Error && "code" in err && (err.code === "ENOENT" || err.code === "EPERM")) {
+				cache.add(current);
+				continue;
+			}
+			throw err;
+		}
+		if (stat$1.isDirectory()) {
+			cache.add(current);
+			continue;
+		}
+		if (stat$1.isSymbolicLink()) {
+			const realPath = await fs.realpath(current);
+			validateBounds(realPath, root, `Path traversal attempt detected: symlink "${current}" points outside the extraction directory.`);
+			cache.add(current);
+			continue;
+		}
+		throw new Error(`Path traversal attempt detected: "${current}" is not a valid directory component.`);
+	}
+}
+function validateBounds(targetPath, destDir, errorMessage) {
+	const normalizedTarget = normalizeUnicode(targetPath);
+	if (!(normalizedTarget === destDir || normalizedTarget.startsWith(destDir + path.sep))) throw new Error(errorMessage);
+}
+
+//#endregion
+//#region src/fs/unpack.ts
+function unpackTar(directoryPath, options = {}) {
+	const { readable, writable: webWritable } = new TransformStream();
+	const entryStream = readable.pipeThrough(createTarDecoder(options)).pipeThrough(createTarOptionsTransformer(options));
+	const webWriter = webWritable.getWriter();
+	let isWriterClosed = false;
+	let isProcessingComplete = false;
+	const processingPromise = (async () => {
+		const resolvedDestDir = normalizeUnicode(path.resolve(directoryPath));
+		const validatedDirs = new Set([resolvedDestDir]);
+		await fs.mkdir(resolvedDestDir, { recursive: true });
+		const reader = entryStream.getReader();
+		try {
+			const maxDepth = options.maxDepth ?? 1024;
+			while (true) {
+				const { done, value: entry } = await reader.read();
+				if (done) break;
+				const { header } = entry;
+				const normalizedName = normalizeUnicode(header.name);
+				if (maxDepth !== Infinity) {
+					const depth = normalizedName.split("/").length;
+					if (depth > maxDepth) throw new Error(`Path depth of entry "${header.name}" (${depth}) exceeds the maximum allowed depth of ${maxDepth}.`);
+				}
+				if (path.isAbsolute(normalizedName)) throw new Error(`Path traversal attempt detected for entry "${header.name}".`);
+				const outPath = path.join(resolvedDestDir, normalizedName);
+				validateBounds(outPath, resolvedDestDir, `Path traversal attempt detected for entry "${header.name}".`);
+				const parentDir = path.dirname(outPath);
+				await validatePath(parentDir, resolvedDestDir, validatedDirs);
+				await fs.mkdir(parentDir, { recursive: true });
+				switch (header.type) {
+					case "directory": {
+						const mode = options.dmode ?? header.mode;
+						await fs.mkdir(outPath, {
+							recursive: true,
+							mode
+						});
+						validatedDirs.add(outPath);
+						break;
+					}
+					case "file":
+						if (header.size <= 32 * 1024) await fs.writeFile(outPath, await streamToBuffer(entry.body), { mode: options.fmode ?? header.mode });
+						else await pipeline(Readable.fromWeb(entry.body), createWriteStream(outPath, { mode: options.fmode ?? header.mode }));
+						break;
+					case "symlink":
+						if (!header.linkname) break;
+						if (options.validateSymlinks ?? true) {
+							const symlinkDir = path.dirname(outPath);
+							const resolvedTarget = path.resolve(symlinkDir, header.linkname);
+							validateBounds(resolvedTarget, resolvedDestDir, `Symlink target "${header.linkname}" points outside the extraction directory.`);
+						}
+						await fs.symlink(header.linkname, outPath);
+						if (process.platform === "win32") {
+							validatedDirs.clear();
+							validatedDirs.add(resolvedDestDir);
+						} else validatedDirs.delete(outPath);
+						break;
+					case "link": {
+						if (!header.linkname) break;
+						const normalizedLinkname = normalizeUnicode(header.linkname);
+						if (path.isAbsolute(normalizedLinkname)) throw new Error(`Hardlink target "${header.linkname}" points outside the extraction directory.`);
+						const resolvedLinkTarget = path.resolve(resolvedDestDir, normalizedLinkname);
+						validateBounds(resolvedLinkTarget, resolvedDestDir, `Hardlink target "${header.linkname}" points outside the extraction directory.`);
+						await validatePath(path.dirname(resolvedLinkTarget), resolvedDestDir, validatedDirs);
+						await fs.link(resolvedLinkTarget, outPath);
+						break;
+					}
+					default:
+						await entry.body.cancel();
+						break;
+				}
+				if (header.mtime) try {
+					await (header.type === "symlink" ? fs.lutimes : fs.utimes)(outPath, header.mtime, header.mtime);
+				} catch {}
+			}
+		} finally {
+			isProcessingComplete = true;
+			reader.releaseLock();
+		}
+	})().catch((err) => {
+		isProcessingComplete = true;
+		throw err;
+	});
+	return new Writable({
+		async write(chunk, _encoding, callback) {
+			if (isWriterClosed || isProcessingComplete || webWriter.desiredSize === null) return callback();
+			try {
+				await webWriter.write(chunk);
+				callback();
+			} catch (err) {
+				if (err instanceof TypeError && err.stack?.includes("TransformStream") && webWriter.desiredSize === null) return callback();
+				callback(err);
+			}
+		},
+		async final(callback) {
+			if (isWriterClosed) return callback();
+			try {
+				isWriterClosed = true;
+				try {
+					await webWriter.close();
+				} catch {}
+				await processingPromise;
+				callback();
+			} catch (err) {
+				callback(err);
+			}
+		},
+		destroy(err, callback) {
+			if (isWriterClosed) return callback(err);
+			isWriterClosed = true;
+			isProcessingComplete = true;
+			webWriter.abort(err).catch(() => {});
+			entryStream.cancel(err).catch(() => {});
+			processingPromise.finally(() => {
+				callback(err);
+			});
+		}
+	});
+}
+
 class UnsupportedProviderError extends Error {}
 class DownloadFailedError extends Error {}
 class SubdirNotFoundError extends Error {}
@@ -5174,7 +5767,7 @@ class DirExistError extends Error {}
 /** @type {AsyncTemplateProvider} */
 const http = async (input, options) => {
   const url = new URL(input);
-  const name = path.basename(url.pathname);
+  const name = path__default.basename(url.pathname);
   return {
     name,
     version: undefined,
@@ -5350,7 +5943,7 @@ function getProvider(input, providerName, providers$1) {
 async function download(url, filePath, options = {}) {
   const infoPath = filePath + '.json';
   /** @type {{ etag?: string }} */
-  const info = JSON.parse(await fs.readFile(infoPath, 'utf8').catch(() => '{}'));
+  const info = JSON.parse(await fs__default.readFile(infoPath, 'utf8').catch(() => '{}'));
   const headResponse = await sendFetch(url, {
     ...options,
     method: 'HEAD',
@@ -5376,11 +5969,11 @@ async function download(url, filePath, options = {}) {
     )
   }
 
-  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  await fs__default.mkdir(path__default.dirname(filePath), { recursive: true });
   const stream = fss.createWriteStream(filePath);
   await pipeline(response.body, stream);
 
-  await fs.writeFile(infoPath, JSON.stringify(info), 'utf8');
+  await fs__default.writeFile(infoPath, JSON.stringify(info), 'utf8');
 }
 
 const inputRegex =
@@ -5428,8 +6021,8 @@ async function sendFetch(url, options = {}) {
 
 function cacheDirectory() {
   return process.env.XDG_CACHE_HOME
-    ? path.resolve(process.env.XDG_CACHE_HOME, 'bluwy-giget')
-    : path.resolve(os.homedir(), '.cache/bluwy-giget')
+    ? path__default.resolve(process.env.XDG_CACHE_HOME, 'bluwy-giget')
+    : path__default.resolve(os.homedir(), '.cache/bluwy-giget')
 }
 
 /**
@@ -5454,7 +6047,7 @@ async function extract(tarPath, extractPath, subdir) {
 
   let subdirFound = false;
   // Create an empty directory here to make tar happy
-  await fs.mkdir(extractPath, { recursive: true });
+  await fs__default.mkdir(extractPath, { recursive: true });
 
   const readStream = fss.createReadStream(tarPath);
   const unpackStream = unpackTar(extractPath, {
@@ -5493,7 +6086,7 @@ async function extract(tarPath, extractPath, subdir) {
 
   if (subdir && !subdirFound) {
     // Clean up as it should be empty
-    await fs.rm(extractPath, { recursive: true, force: true });
+    await fs__default.rm(extractPath, { recursive: true, force: true });
     throw new SubdirNotFoundError(`Subdirectory not found in tar: ${subdir}`)
   }
 }
@@ -5529,12 +6122,12 @@ async function downloadTemplate(input, options = {}) {
   );
 
   // Download template source
-  const temporaryDirectory = path.resolve(
+  const temporaryDirectory = path__default.resolve(
     cacheDirectory(),
     providerName,
     template.name,
   );
-  const tarPath = path.resolve(
+  const tarPath = path__default.resolve(
     temporaryDirectory,
     (template.version || template.name) + '.tar.gz',
   );
@@ -5561,10 +6154,10 @@ async function downloadTemplate(input, options = {}) {
   }
 
   // Extract template
-  const cwd = path.resolve(options.cwd || '.');
-  const extractPath = path.resolve(cwd, options.dir || template.defaultDir);
+  const cwd = path__default.resolve(options.cwd || '.');
+  const extractPath = path__default.resolve(cwd, options.dir || template.defaultDir);
   if (options.force === 'clean') {
-    await fs.rm(extractPath, { recursive: true, force: true });
+    await fs__default.rm(extractPath, { recursive: true, force: true });
   } else if (
     !options.force &&
     fss.existsSync(extractPath) &&