error toasts

Author: jonathanlab

.env.example

@@ -12,4 +12,7 @@ VITE_POSTHOG_API_HOST=xxx
 VITE_POSTHOG_UI_HOST=xxx
 
 # Use new LLM gateway locally (experimental, needs to be started in mprocs)
-LLM_GATEWAY_URL=http://localhost:3308
+LLM_GATEWAY_URL=http://localhost:3308
+
+# Whether all errors/warnings show as dismissable toasts in dev
+VITE_DEV_ERROR_TOASTS=true

apps/array/package.json

@@ -137,6 +137,7 @@
     "radix-themes-tw": "0.2.3",
     "react": "^18.2.0",
     "react-dom": "^18.2.0",
+    "react-error-boundary": "^6.0.0",
     "react-hook-form": "^7.64.0",
     "react-hotkeys-hook": "^4.4.4",
     "react-markdown": "^10.1.0",

apps/array/src/main/di/container.ts

@@ -14,6 +14,7 @@ import { ShellService } from "../services/shell/service.js";
 import { TaskLinkService } from "../services/task-link/service.js";
 import { UIService } from "../services/ui/service.js";
 import { UpdatesService } from "../services/updates/service.js";
+import { UserNotificationService } from "../services/user-notification/service.js";
 import { WorkspaceService } from "../services/workspace/service.js";
 import { MAIN_TOKENS } from "./tokens.js";
 
@@ -35,4 +36,5 @@ container.bind(MAIN_TOKENS.ShellService).to(ShellService);
 container.bind(MAIN_TOKENS.UIService).to(UIService);
 container.bind(MAIN_TOKENS.UpdatesService).to(UpdatesService);
 container.bind(MAIN_TOKENS.TaskLinkService).to(TaskLinkService);
+container.bind(MAIN_TOKENS.UserNotificationService).to(UserNotificationService);
 container.bind(MAIN_TOKENS.WorkspaceService).to(WorkspaceService);

apps/array/src/main/di/tokens.ts

@@ -21,4 +21,5 @@ export const MAIN_TOKENS = Object.freeze({
   UpdatesService: Symbol.for("Main.UpdatesService"),
   TaskLinkService: Symbol.for("Main.TaskLinkService"),
   WorkspaceService: Symbol.for("Main.WorkspaceService"),
+  UserNotificationService: Symbol.for("Main.UserNotificationService"),
 });

apps/array/src/main/index.ts

@@ -7,6 +7,10 @@ import { mkdirSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import { initializeMainErrorHandling } from "./lib/error-handling.js";
+
+initializeMainErrorHandling();
+
 import {
   app,
   BrowserWindow,
@@ -17,7 +21,6 @@ import {
   shell,
 } from "electron";
 import { createIPCHandler } from "trpc-electron/main";
-import "./lib/logger";
 import { ANALYTICS_EVENTS } from "../types/analytics.js";
 import { container } from "./di/container.js";
 import { MAIN_TOKENS } from "./di/tokens.js";

apps/array/src/main/lib/error-handling.ts

@@ -0,0 +1,20 @@
+import { ipcMain } from "electron";
+import { logger } from "./logger.js";
+
+export function initializeMainErrorHandling(): void {
+  process.on("uncaughtException", (error) => {
+    logger.error("Uncaught exception", error);
+  });
+
+  process.on("unhandledRejection", (reason) => {
+    const error = reason instanceof Error ? reason : new Error(String(reason));
+    logger.error("Unhandled rejection", error);
+  });
+
+  ipcMain.on(
+    "preload-error",
+    (_, error: { message: string; stack?: string }) => {
+      logger.error("Preload error", error);
+    },
+  );
+}

apps/array/src/main/lib/logger.ts

@@ -1,37 +1,15 @@
+import type { Logger, ScopedLogger } from "@shared/lib/create-logger.js";
+import { createLogger } from "@shared/lib/create-logger.js";
 import { app } from "electron";
 import log from "electron-log/main";
 
-// Initialize IPC transport to forward main process logs to renderer dev tools
 log.initialize();
 
-// Set levels - use debug in dev (check NODE_ENV since app.isPackaged may not be ready)
 const isDev = process.env.NODE_ENV === "development" || !app.isPackaged;
 const level = isDev ? "debug" : "info";
 log.transports.file.level = level;
 log.transports.console.level = level;
-// IPC transport needs level set separately
 log.transports.ipc.level = level;
 
-export const logger = {
-  info: (message: string, ...args: unknown[]) => log.info(message, ...args),
-  warn: (message: string, ...args: unknown[]) => log.warn(message, ...args),
-  error: (message: string, ...args: unknown[]) => log.error(message, ...args),
-  debug: (message: string, ...args: unknown[]) => log.debug(message, ...args),
-
-  scope: (name: string) => {
-    const scoped = log.scope(name);
-    return {
-      info: (message: string, ...args: unknown[]) =>
-        scoped.info(message, ...args),
-      warn: (message: string, ...args: unknown[]) =>
-        scoped.warn(message, ...args),
-      error: (message: string, ...args: unknown[]) =>
-        scoped.error(message, ...args),
-      debug: (message: string, ...args: unknown[]) =>
-        scoped.debug(message, ...args),
-    };
-  },
-};
-
-export type Logger = typeof logger;
-export type ScopedLogger = ReturnType<typeof logger.scope>;
+export const logger = createLogger(log);
+export type { Logger, ScopedLogger };

apps/array/src/main/preload.ts

@@ -1,6 +1,23 @@
+import { ipcRenderer } from "electron";
 import { exposeElectronTRPC } from "trpc-electron/main";
 import "electron-log/preload";
 
+// No TRPC available, so just use IPC
+process.on("uncaughtException", (error) => {
+  ipcRenderer.send("preload-error", {
+    message: error.message,
+    stack: error.stack,
+  });
+});
+
+process.on("unhandledRejection", (reason) => {
+  const error = reason instanceof Error ? reason : new Error(String(reason));
+  ipcRenderer.send("preload-error", {
+    message: error.message,
+    stack: error.stack,
+  });
+});
+
 process.once("loaded", async () => {
   exposeElectronTRPC();
 });

apps/array/src/main/services/user-notification/schemas.ts

@@ -0,0 +1,15 @@
+export const UserNotificationEvent = {
+  Notify: "notify",
+} as const;
+
+export type NotificationSeverity = "error" | "warning" | "info";
+
+export interface UserNotificationPayload {
+  severity: NotificationSeverity;
+  title: string;
+  description?: string;
+}
+
+export interface UserNotificationEvents {
+  [UserNotificationEvent.Notify]: UserNotificationPayload;
+}

apps/array/src/main/services/user-notification/service.ts

@@ -0,0 +1,46 @@
+import { app } from "electron";
+import { injectable, postConstruct } from "inversify";
+import { logger } from "../../lib/logger.js";
+import { TypedEventEmitter } from "../../lib/typed-event-emitter.js";
+import {
+  UserNotificationEvent,
+  type UserNotificationEvents,
+} from "./schemas.js";
+
+const isDev = process.env.NODE_ENV === "development" || !app.isPackaged;
+const devErrorToastsEnabled =
+  isDev && process.env.VITE_DEV_ERROR_TOASTS !== "false";
+
+@injectable()
+export class UserNotificationService extends TypedEventEmitter<UserNotificationEvents> {
+  @postConstruct()
+  init(): void {
+    if (devErrorToastsEnabled) {
+      logger.setDevToastEmitter((title, desc) => this.error(title, desc));
+    }
+  }
+
+  error(title: string, description?: string): void {
+    this.emit(UserNotificationEvent.Notify, {
+      severity: "error",
+      title,
+      description,
+    });
+  }
+
+  warning(title: string, description?: string): void {
+    this.emit(UserNotificationEvent.Notify, {
+      severity: "warning",
+      title,
+      description,
+    });
+  }
+
+  info(title: string, description?: string): void {
+    this.emit(UserNotificationEvent.Notify, {
+      severity: "info",
+      title,
+      description,
+    });
+  }
+}