fix(options): handle invalid entries after map (#90)

* fix(options): handle invalid entries after map

* test: use more consistent unicode across platforms

* test: handle file join on windows

* test: add log for giget core

* fix(unpack): validate directory exists first before creating

* test: clear cases

* test: add giget core reproduction

Author: ayuhito

src/fs/unpack.ts

@@ -180,11 +180,6 @@ function createFSHandler(directoryPath: string, options: UnpackOptionsFS) {
 
 			// Check if the directory exists.
 			try {
-				await fs.mkdir(dirPath, { mode: dmode });
-				return "directory";
-			} catch (err: unknown) {
-				if ((err as NodeJS.ErrnoException).code !== "EEXIST") throw err;
-
 				const stat = await fs.lstat(dirPath);
 				if (stat.isDirectory()) return "directory";
 
@@ -200,6 +195,12 @@ function createFSHandler(directoryPath: string, options: UnpackOptionsFS) {
 					if (realStat.isDirectory()) return "directory";
 				}
 				throw new Error(`"${dirPath}" is not a valid directory component.`);
+			} catch (err: unknown) {
+				if ((err as NodeJS.ErrnoException).code === "ENOENT") {
+					await fs.mkdir(dirPath, { mode: dmode });
+					return "directory";
+				}
+				throw err;
 			}
 		})();
 

src/tar/options.ts

@@ -39,5 +39,18 @@ export function transformHeader(
 		return null; // Skip filtered entry
 	}
 
-	return map ? map(h) : h;
+	const result = map ? map(h) : h;
+
+	// Skip entries with empty names, whitespace only names, or paths that would resolve to extraction root.
+	if (
+		result &&
+		(!result.name ||
+			!result.name.trim() ||
+			result.name === "." ||
+			result.name === "/")
+	) {
+		return null;
+	}
+
+	return result;
 }

tests/fs/unpack.test.ts

@@ -607,5 +607,88 @@ describe("extract", () => {
 			const readContent = await fs.readFile(filePath, "utf-8");
 			expect(readContent).toBe(content);
 		});
+
+		it("map filters out empty directory names", async () => {
+			const sourceDir = path.join(tmpDir, "source");
+			await fs.mkdir(path.join(sourceDir, "dir"), { recursive: true });
+
+			const packStream = packTar(sourceDir);
+			const packData: Buffer[] = [];
+			for await (const chunk of packStream) {
+				packData.push(Buffer.from(chunk));
+			}
+
+			const extractDir = path.join(tmpDir, "extract");
+			const readStream = Readable.from([Buffer.concat(packData)]);
+
+			const unpackStream = unpackTar(extractDir, {
+				map(entry) {
+					if (entry.name === "dir/") entry.name = ""; // Creates empty name
+					return entry;
+				},
+			});
+
+			// Should complete without hanging (empty entries are filtered out)
+			await pipeline(readStream, unpackStream);
+
+			// Should have no files since the only directory entry was filtered out
+			try {
+				const files = await fs.readdir(extractDir);
+				expect(files).toHaveLength(0);
+			} catch (error) {
+				// If directory doesn't exist because no entries were extracted, that's fine
+				expect((error as NodeJS.ErrnoException).code).toBe("ENOENT");
+			}
+		}, 2000);
+
+		it("handles mapping with subdir extraction", async () => {
+			// Create a test archive that mimics GitHub tarball structure
+			const sourceDir = path.join(tmpDir, "source");
+			const rootDir = path.join(sourceDir, "withastro-starlight-abc123");
+			const examplesDir = path.join(rootDir, "examples");
+			const basicsDir = path.join(examplesDir, "basics");
+			const srcDir = path.join(basicsDir, "src");
+			const pagesDir = path.join(srcDir, "pages");
+
+			await fs.mkdir(pagesDir, { recursive: true });
+			await fs.writeFile(
+				path.join(basicsDir, "package.json"),
+				'{"name": "@example/basics", "type": "module"}',
+			);
+			await fs.writeFile(path.join(pagesDir, "index.mdx"), "# Welcome");
+
+			const packStream = packTar(sourceDir);
+			const packData: Buffer[] = [];
+			for await (const chunk of packStream) {
+				packData.push(Buffer.from(chunk));
+			}
+
+			// Reproduce exact giget-core extraction logic
+			const extractDir = path.join(tmpDir, "starlight-unpack");
+			const readStream = Readable.from([Buffer.concat(packData)]);
+			const subdir = "examples/basics/";
+
+			const unpackStream = unpackTar(extractDir, {
+				filter(entry) {
+					const path = entry.name.split("/").slice(1).join("/");
+					if (path === "") return false;
+					return path.startsWith(subdir);
+				},
+				map(entry) {
+					let path = entry.name.split("/").slice(1).join("/");
+					if (subdir) path = path.slice(subdir.length);
+					entry.name = path;
+					return entry;
+				},
+			});
+
+			// This should now work without hanging
+			await pipeline(readStream, unpackStream);
+
+			// Verify extraction worked correctly
+			const files = await fs.readdir(extractDir, { recursive: true });
+			expect(files).toContain("package.json");
+			expect(files.some((f) => f.includes("pages"))).toBe(true);
+		});
 	});
 });