[wrangler] sweep stale .wrangler/tmp/* dirs at startup (#13930)

Author: shiminshen

.changeset/wrangler-tmp-orphan-sweep.md

@@ -0,0 +1,9 @@
+---
+"wrangler": patch
+---
+
+Sweep stale `.wrangler/tmp/*` dirs left behind by abnormal exits
+
+A `wrangler dev` session creates `.wrangler/tmp/bundle-*` and `.wrangler/tmp/dev-*` directories at startup and removes them via a `signal-exit` hook on graceful shutdown. When the process exited abnormally (SIGKILL, OOM, host crash) those directories were left behind and accumulated across sessions, slowing down dependency-walking tools that follow the bundle-emitted absolute-path imports.
+
+`wrangler` now sweeps entries in `.wrangler/tmp/` older than 24 hours when a new temporary directory is requested, bounding the leak regardless of how prior sessions exited.

packages/wrangler/src/__tests__/paths.test.ts

@@ -1,10 +1,13 @@
+import fs from "node:fs";
 import * as path from "node:path";
 import { describe, it } from "vitest";
 import {
 	getBasePath,
 	getWranglerHiddenDirPath,
 	readableRelative,
+	sweepStaleWranglerTmpDirs,
 } from "../paths";
+import { runInTempDir } from "./helpers/run-in-tmp";
 
 describe("paths", () => {
 	describe("getBasePath()", () => {
@@ -39,6 +42,54 @@ describe("paths", () => {
 	});
 });
 
+describe("sweepStaleWranglerTmpDirs()", () => {
+	runInTempDir();
+
+	const ageDir = (dir: string, ageMs: number): void => {
+		const seconds = (Date.now() - ageMs) / 1000;
+		fs.utimesSync(dir, seconds, seconds);
+	};
+
+	it("removes orphaned dirs older than the staleness threshold", ({
+		expect,
+	}) => {
+		const tmpRoot = path.join(process.cwd(), ".wrangler", "tmp");
+		fs.mkdirSync(tmpRoot, { recursive: true });
+		const stale = path.join(tmpRoot, "bundle-stale");
+		const fresh = path.join(tmpRoot, "bundle-fresh");
+		fs.mkdirSync(stale);
+		fs.mkdirSync(fresh);
+		ageDir(stale, 2 * 24 * 60 * 60 * 1000);
+
+		sweepStaleWranglerTmpDirs(tmpRoot);
+
+		expect(fs.existsSync(stale)).toBe(false);
+		expect(fs.existsSync(fresh)).toBe(true);
+	});
+
+	it("does not throw when the tmp root is missing", ({ expect }) => {
+		const tmpRoot = path.join(process.cwd(), ".wrangler", "tmp");
+		expect(() => sweepStaleWranglerTmpDirs(tmpRoot)).not.toThrow();
+	});
+
+	it("only sweeps a given root once per process", ({ expect }) => {
+		const tmpRoot = path.join(process.cwd(), ".wrangler", "tmp");
+		fs.mkdirSync(tmpRoot, { recursive: true });
+		const orphan = path.join(tmpRoot, "bundle-orphan");
+		fs.mkdirSync(orphan);
+		ageDir(orphan, 2 * 24 * 60 * 60 * 1000);
+
+		sweepStaleWranglerTmpDirs(tmpRoot);
+		expect(fs.existsSync(orphan)).toBe(false);
+
+		// Recreate an equally stale entry; the cached root must skip rescanning.
+		fs.mkdirSync(orphan);
+		ageDir(orphan, 2 * 24 * 60 * 60 * 1000);
+		sweepStaleWranglerTmpDirs(tmpRoot);
+		expect(fs.existsSync(orphan)).toBe(true);
+	});
+});
+
 describe("readableRelative", () => {
 	const base = process.cwd();
 

packages/wrangler/src/paths.ts

@@ -92,6 +92,55 @@ export function getWranglerHiddenDirPath(
 	return path.join(projectRoot, ".wrangler");
 }
 
+/**
+ * Maximum age of a `.wrangler/tmp/*` entry before we treat it as orphaned and
+ * eligible for the startup sweep. Tuned to avoid touching any directory a
+ * concurrent wrangler session might still own.
+ */
+const STALE_WRANGLER_TMP_DIR_MS = 24 * 60 * 60 * 1000;
+
+/**
+ * Tracks tmp roots already swept by this process so repeated
+ * `getWranglerTmpDir` calls within one wrangler invocation only scan once.
+ */
+const sweptTmpRoots = new Set<string>();
+
+/**
+ * Removes stale `.wrangler/tmp/*` entries left behind by previous wrangler
+ * sessions that exited abnormally (SIGKILL, OOM, host crash) and so missed
+ * the `signal-exit` cleanup. Runs at most once per tmp root per process.
+ *
+ * Exported for tests.
+ */
+export function sweepStaleWranglerTmpDirs(tmpRoot: string): void {
+	if (sweptTmpRoots.has(tmpRoot)) {
+		return;
+	}
+	sweptTmpRoots.add(tmpRoot);
+
+	let entries: fs.Dirent[];
+	try {
+		entries = fs.readdirSync(tmpRoot, { withFileTypes: true });
+	} catch {
+		return;
+	}
+
+	const cutoff = Date.now() - STALE_WRANGLER_TMP_DIR_MS;
+	for (const entry of entries) {
+		if (!entry.isDirectory()) {
+			continue;
+		}
+		const entryPath = path.join(tmpRoot, entry.name);
+		try {
+			if (fs.statSync(entryPath).mtimeMs < cutoff) {
+				removeDirSync(entryPath);
+			}
+		} catch {
+			/* best effort — another process may have removed it first */
+		}
+	}
+}
+
 /**
  * Gets a temporary directory in the project's `.wrangler` folder with the
  * specified prefix. We create temporary directories in `.wrangler` as opposed
@@ -106,6 +155,7 @@ export function getWranglerTmpDir(
 ): EphemeralDirectory {
 	const tmpRoot = path.join(getWranglerHiddenDirPath(projectRoot), "tmp");
 	fs.mkdirSync(tmpRoot, { recursive: true });
+	sweepStaleWranglerTmpDirs(tmpRoot);
 
 	const tmpPrefix = path.join(tmpRoot, `${prefix}-`);
 	const tmpDir = fs.realpathSync(fs.mkdtempSync(tmpPrefix));