fix(dsn): prevent silent exit during uncached DSN auto-detection (#411)

Replace Bun.Glob.scan() async iterators with readdir() in DSN detection
paths. The async iterators don't ref-count the event loop, causing the
process to exit with code 0 and no output while scanning is still in
progress on first run (uncached).

Changes:
- bin.ts: Add setInterval keepalive cleared via .finally() to prevent
  premature event loop drain (can't use top-level await due to CJS bundle)
- project-root.ts: Replace anyGlobMatches() Bun.Glob.scan() with
  readdir() + synchronous Bun.Glob.match() for language marker detection
- env-file.ts: Replace Bun.Glob.scan('*') with readdir() in
  detectFromMonorepoEnvFiles() for listing monorepo package directories

Author: BYK

src/lib/dsn/env-file.ts

@@ -8,7 +8,7 @@
  * to find DSNs in individual packages/apps.
  */
 
-import { stat } from "node:fs/promises";
+import { opendir, stat } from "node:fs/promises";
 import { join } from "node:path";
 import { createDetectedDsn } from "./parser.js";
 import { scanSpecificFiles } from "./scanner.js";
@@ -154,6 +154,38 @@ export async function detectFromAllEnvFiles(
   return { dsns: allDsns, sourceMtimes: allMtimes };
 }
 
+/**
+ * Check if a directory entry is a non-hidden directory, following symlinks.
+ *
+ * Skips dotfiles (e.g. `.git`, `.cache`) to match old `Bun.Glob("*").scan()`
+ * default. Follows symlinks via `stat()` so symlinked packages (e.g. pnpm
+ * workspaces) are detected.
+ *
+ * @param entry - Directory entry to check
+ * @param parentDir - Parent directory path (for resolving symlinks)
+ * @returns True if the entry is a non-hidden directory
+ */
+async function isPackageDir(
+  entry: import("node:fs").Dirent,
+  parentDir: string
+): Promise<boolean> {
+  if (entry.name.startsWith(".")) {
+    return false;
+  }
+  if (entry.isDirectory()) {
+    return true;
+  }
+  // Dirent.isDirectory() doesn't follow symlinks — resolve them via stat()
+  if (!entry.isSymbolicLink()) {
+    return false;
+  }
+  try {
+    return (await stat(join(parentDir, entry.name))).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
 /**
  * Detect DSN from .env files in monorepo package directories.
  *
@@ -168,30 +200,22 @@ export async function detectFromMonorepoEnvFiles(
 ): Promise<EnvFileScanResult> {
   const dsns: DetectedDsn[] = [];
   const sourceMtimes: Record<string, number> = {};
-  const pkgGlob = new Bun.Glob("*");
 
   for (const monorepoRoot of MONOREPO_ROOTS) {
     const rootDir = join(cwd, monorepoRoot);
 
+    // Bun's opendir() may not throw on a missing directory — the error
+    // surfaces when iterating. Wrap the full open+iterate in one try/catch.
+    // No explicit handle.close() needed: for-await-of auto-closes the Dir
+    // handle when the loop exits (including early return or break).
     try {
-      // Scan for subdirectories (each is a potential package/app)
-      for await (const pkgName of pkgGlob.scan({
-        cwd: rootDir,
-        onlyFiles: false,
-      })) {
-        const pkgDir = join(rootDir, pkgName);
-
-        // Only process directories, not files
-        try {
-          const stats = await stat(pkgDir);
-          if (!stats.isDirectory()) {
-            continue;
-          }
-        } catch {
+      for await (const entry of await opendir(rootDir)) {
+        if (!(await isPackageDir(entry, rootDir))) {
           continue;
         }
 
-        const packagePath = `${monorepoRoot}/${pkgName}`;
+        const pkgDir = join(rootDir, entry.name);
+        const packagePath = `${monorepoRoot}/${entry.name}`;
 
         const result = await detectDsnInPackage(pkgDir, packagePath);
         if (result.dsn) {

src/lib/dsn/project-root.ts

@@ -13,7 +13,7 @@
  * Stops at: home directory or filesystem root
  */
 
-import { stat } from "node:fs/promises";
+import { opendir, stat } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { anyTrue } from "../promises.js";
@@ -187,23 +187,35 @@ function anyExists(dir: string, names: readonly string[]): Promise<boolean> {
 
 /**
  * Check if any files matching glob patterns exist in a directory.
- * Runs pattern checks in parallel and resolves as soon as any finds a match.
+ * Uses `opendir` to lazily stream directory entries and exits on first match
+ * without reading the entire directory. Matches via synchronous
+ * `Bun.Glob.match()` (no async I/O, event-loop safe).
  *
  * @param dir - Directory to check
  * @param patterns - Glob patterns to match
  * @returns True if any matching file exists
  */
-function anyGlobMatches(
+async function anyGlobMatches(
   dir: string,
   patterns: readonly string[]
 ): Promise<boolean> {
-  return anyTrue(patterns, async (pattern) => {
-    const glob = new Bun.Glob(pattern);
-    for await (const _match of glob.scan({ cwd: dir, onlyFiles: true })) {
-      return true;
+  // Bun's opendir() may not throw on a missing directory — the error
+  // surfaces when iterating. Wrap the full open+iterate in one try/catch.
+  // No explicit handle.close() needed: for-await-of auto-closes the Dir
+  // handle when the loop exits (including early return or break).
+  try {
+    for await (const entry of await opendir(dir)) {
+      if (
+        entry.isFile() &&
+        patterns.some((p) => new Bun.Glob(p).match(entry.name))
+      ) {
+        return true;
+      }
     }
     return false;
-  });
+  } catch {
+    return false;
+  }
 }
 
 /**