js/src/lib/sentry.ts

@@ -1,28 +1,41 @@
 import * as Sentry from "@sentry/electron/renderer";
 import { appConfig } from "@/config/env";
-import { installErrorSinks } from "@/lib/errors";
+import { installErrorSinks, reportError } from "@/lib/errors";
 
 /**
- * Initialise Sentry for a renderer process. No-ops when `sentryDsn` is empty
+ * Initialise renderer error handling. When a DSN is configured, Sentry's
- * so dev builds and unconfigured envs stay quiet.
+ * own global handlers capture uncaught exceptions and unhandled promise
+ * rejections. Otherwise we install a minimal fallback so stray rejections
+ * aren't silent in dev / unconfigured envs.
  */
 export function initSentryRenderer(): void {
-  if (!appConfig.sentryDsn) return;
+  if (appConfig.sentryDsn) {
+    Sentry.init({
+      dsn: appConfig.sentryDsn,
+      tracesSampleRate: 0,
+    });
 
-  Sentry.init({
+    installErrorSinks({
-    dsn: appConfig.sentryDsn,
+      capture: (err, context) =>
-    tracesSampleRate: 0,
+        Sentry.captureException(err, { extra: context }),
+      breadcrumb: (err, context) =>
+        Sentry.addBreadcrumb({
+          category: "error",
+          level: "error",
+          message: err instanceof Error ? err.message : String(err),
+          data: context,
+        }),
+    });
+    return;
+  }
+
+  window.addEventListener("unhandledrejection", (event) => {
+    reportError(event.reason, { scope: "unhandledrejection" });
   });
-
+  window.addEventListener("error", (event) => {
-  installErrorSinks({
+    reportError(event.error ?? new Error(event.message), {
-    capture: (err, context) =>
+      scope: "window.error",
-      Sentry.captureException(err, { extra: context }),
+    });
-    breadcrumb: (err, context) =>
-      Sentry.addBreadcrumb({
-        category: "error",
-        level: "error",
-        message: err instanceof Error ? err.message : String(err),
-        data: context,
-      }),
   });
 }
+

js/src/main/sentry.ts

@@ -1,30 +1,39 @@
 import { app } from "electron";
 import * as Sentry from "@sentry/electron/main";
 import { appConfig } from "@/config/env";
-import { installErrorSinks } from "@/lib/errors";
+import { installErrorSinks, reportError } from "@/lib/errors";
 
 /**
- * Initialise Sentry for the main process. Captures uncaught exceptions from
+ * Initialise main-process error handling. Sentry owns uncaught-exception
- * the Node side and the crash reporter. Safe to call before `app.whenReady`.
+ * capture when a DSN is configured; otherwise we install a minimal Node
+ * fallback so rejections aren't silent. Safe to call before `app.whenReady`.
  */
 export function initSentryMain(): void {
-  if (!appConfig.sentryDsn) return;
+  if (appConfig.sentryDsn) {
+    Sentry.init({
+      dsn: appConfig.sentryDsn,
+      tracesSampleRate: 0,
+      release: app.getVersion(),
+    });
 
-  Sentry.init({
+    installErrorSinks({
-    dsn: appConfig.sentryDsn,
+      capture: (err, context) =>
-    tracesSampleRate: 0,
+        Sentry.captureException(err, { extra: context }),
-    release: app.getVersion(),
+      breadcrumb: (err, context) =>
+        Sentry.addBreadcrumb({
+          category: "error",
+          level: "error",
+          message: err instanceof Error ? err.message : String(err),
+          data: context,
+        }),
+    });
+    return;
+  }
+
+  process.on("uncaughtException", (err) => {
+    reportError(err, { scope: "uncaughtException" });
   });
-
+  process.on("unhandledRejection", (reason) => {
-  installErrorSinks({
+    reportError(reason, { scope: "unhandledRejection" });
-    capture: (err, context) =>
-      Sentry.captureException(err, { extra: context }),
-    breadcrumb: (err, context) =>
-      Sentry.addBreadcrumb({
-        category: "error",
-        level: "error",
-        message: err instanceof Error ? err.message : String(err),
-        data: context,
-      }),
   });
 }