fix(dsn): treat EISDIR and ENOTDIR as ignorable file errors (#464)

## Summary

Fixes [CLI-G5](https://sentry.sentry.io/issues/7344013745/) — high
priority, 9 occurrences.

When a user has `.env` as a **directory** (not a file) in their project,
the DSN scanner tries to read it with `Bun.file(path).text()`, which
throws `EISDIR`. This error was caught but not recognized as ignorable,
so it got reported to Sentry as an unexpected error.

## Changes

- **`src/lib/dsn/fs-utils.ts`**: Add `EISDIR` and `ENOTDIR` to
`isIgnorableFileError()`. These are normal filesystem conditions during
scanning — a path being a directory or a path component not being a
directory — and should be silently skipped, just like `ENOENT`,
`EACCES`, and `EPERM` already are. This single change fixes all 4 call
sites that use `handleFileError()`.

- **`test/lib/dsn/fs-utils.test.ts`**: New test file covering all 5
ignorable error codes, unexpected errors, and context propagation to
Sentry.

Author: BYK

src/lib/dsn/fs-utils.ts

@@ -14,6 +14,8 @@ import * as Sentry from "@sentry/bun";
  * - ENOENT: File or directory does not exist
  * - EACCES: Permission denied (e.g., no read access)
  * - EPERM: Operation not permitted (e.g., file locked, or system-level restriction)
+ * - EISDIR: Path is a directory, not a file (e.g., `.env/` directory instead of `.env` file)
+ * - ENOTDIR: A path component is not a directory (e.g., `/file.txt/child`)
  *
  * All other errors are unexpected and should be reported to Sentry.
  *
@@ -23,7 +25,13 @@ import * as Sentry from "@sentry/bun";
 function isIgnorableFileError(error: unknown): boolean {
   if (error instanceof Error && "code" in error) {
     const code = (error as NodeJS.ErrnoException).code;
-    return code === "ENOENT" || code === "EACCES" || code === "EPERM";
+    return (
+      code === "ENOENT" ||
+      code === "EACCES" ||
+      code === "EPERM" ||
+      code === "EISDIR" ||
+      code === "ENOTDIR"
+    );
   }
   return false;
 }

test/isolated/dsn/fs-utils.test.ts

@@ -0,0 +1,116 @@
+/**
+ * Tests for DSN file system utilities.
+ *
+ * Verifies that handleFileError correctly distinguishes expected filesystem
+ * errors (silently ignored) from unexpected ones (reported to Sentry).
+ */
+
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+const captureException = mock();
+
+mock.module("@sentry/bun", () => ({
+  captureException,
+  startSpan: (_opts: unknown, fn: () => unknown) => fn(),
+}));
+
+const { handleFileError } = await import("../../../src/lib/dsn/fs-utils.js");
+
+/** Create an Error with a `code` property, mimicking Node/Bun errno errors. */
+function errnoError(code: string, message?: string): Error {
+  const err = new Error(message ?? code) as NodeJS.ErrnoException;
+  err.code = code;
+  return err;
+}
+
+describe("handleFileError", () => {
+  beforeEach(() => {
+    captureException.mockClear();
+  });
+
+  afterEach(() => {
+    captureException.mockClear();
+  });
+
+  describe("ignorable errors (should NOT report to Sentry)", () => {
+    test("ENOENT — file does not exist", () => {
+      handleFileError(errnoError("ENOENT"), {
+        operation: "test",
+        path: "/missing",
+      });
+      expect(captureException).not.toHaveBeenCalled();
+    });
+
+    test("EACCES — permission denied", () => {
+      handleFileError(errnoError("EACCES"), {
+        operation: "test",
+        path: "/secret",
+      });
+      expect(captureException).not.toHaveBeenCalled();
+    });
+
+    test("EPERM — operation not permitted", () => {
+      handleFileError(errnoError("EPERM"), {
+        operation: "test",
+        path: "/locked",
+      });
+      expect(captureException).not.toHaveBeenCalled();
+    });
+
+    test("EISDIR — path is a directory, not a file", () => {
+      handleFileError(
+        errnoError("EISDIR", "Directories cannot be read like files"),
+        {
+          operation: "checkEnvForDsn",
+          path: "/project/.env",
+        }
+      );
+      expect(captureException).not.toHaveBeenCalled();
+    });
+
+    test("ENOTDIR — path component is not a directory", () => {
+      handleFileError(errnoError("ENOTDIR"), {
+        operation: "test",
+        path: "/file.txt/child",
+      });
+      expect(captureException).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("unexpected errors (SHOULD report to Sentry)", () => {
+    test("EIO — I/O error", () => {
+      handleFileError(errnoError("EIO"), {
+        operation: "test",
+        path: "/disk-fail",
+      });
+      expect(captureException).toHaveBeenCalledTimes(1);
+    });
+
+    test("ENOMEM — out of memory", () => {
+      handleFileError(errnoError("ENOMEM"), { operation: "test" });
+      expect(captureException).toHaveBeenCalledTimes(1);
+    });
+
+    test("generic Error without code", () => {
+      handleFileError(new Error("something broke"), { operation: "test" });
+      expect(captureException).toHaveBeenCalledTimes(1);
+    });
+
+    test("non-Error value", () => {
+      handleFileError("string error", { operation: "test" });
+      expect(captureException).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  test("passes context tags and extras to Sentry", () => {
+    const error = errnoError("EIO");
+    handleFileError(error, {
+      operation: "checkEnvForDsn",
+      path: "/project/.env",
+    });
+    expect(captureException).toHaveBeenCalledWith(error, {
+      tags: { operation: "checkEnvForDsn" },
+      extra: { path: "/project/.env" },
+    });
+  });
+});