Simplify handlers & IPC client: move from Result pattern to throwing errors (#120)

src/components/ChatList.tsx

@@ -92,11 +92,7 @@ export function ChatList({ show }: { show?: boolean }) {
 
   const handleDeleteChat = async (chatId: number) => {
     try {
-      const result = await IpcClient.getInstance().deleteChat(chatId);
+      await IpcClient.getInstance().deleteChat(chatId);
-      if (!result.success) {
-        showError("Failed to delete chat");
-        return;
-      }
       showSuccess("Chat deleted successfully");
 
       // If the deleted chat was selected, navigate to home

src/components/GitHubConnector.tsx

@@ -153,18 +153,14 @@ export function GitHubConnector({ appId, folderName }: GitHubConnectorProps) {
     setIsCreatingRepo(true);
     setCreateRepoSuccess(false);
     try {
-      const result = await IpcClient.getInstance().createGithubRepo(
+      await IpcClient.getInstance().createGithubRepo(
         githubOrg,
         repoName,
         appId!,
       );
-      if (result.success) {
       setCreateRepoSuccess(true);
       setRepoCheckError(null);
       refreshApp();
-      } else {
-        setCreateRepoError(result.error || "Failed to create repository.");
-      }
     } catch (err: any) {
       setCreateRepoError(err.message || "Failed to create repository.");
     } finally {
@@ -180,12 +176,8 @@ export function GitHubConnector({ appId, folderName }: GitHubConnectorProps) {
     setIsDisconnecting(true);
     setDisconnectError(null);
     try {
-      const result = await IpcClient.getInstance().disconnectGithubRepo(appId);
+      await IpcClient.getInstance().disconnectGithubRepo(appId);
-      if (result.success) {
       refreshApp();
-      } else {
-        setDisconnectError(result.error || "Failed to disconnect repository.");
-      }
     } catch (err: any) {
       setDisconnectError(err.message || "Failed to disconnect repository.");
     } finally {

src/components/HelpDialog.tsx

@@ -171,17 +171,12 @@ ${debugInfo.logs.slice(-3_500) || "No logs available"}
 
       const { uploadUrl, filename } = await response.json();
 
-      // Upload to the signed URL using IPC
+      await IpcClient.getInstance().uploadToSignedUrl(
-      const uploadResult = await IpcClient.getInstance().uploadToSignedUrl(
         uploadUrl,
         "application/json",
         chatLogsJson,
       );
 
-      if (!uploadResult.success) {
-        throw new Error(`Failed to upload logs: ${uploadResult.error}`);
-      }
-
       // Extract session ID (filename without extension)
       const sessionId = filename.replace(".json", "");
       setSessionId(sessionId);

src/components/chat/ChatInput.tsx

@@ -58,7 +58,7 @@ import { useVersions } from "@/hooks/useVersions";
 import { useAttachments } from "@/hooks/useAttachments";
 import { AttachmentsList } from "./AttachmentsList";
 import { DragDropOverlay } from "./DragDropOverlay";
-import { showUncommittedFilesWarning } from "@/lib/toast";
+import { showError, showUncommittedFilesWarning } from "@/lib/toast";
 const showTokenBarAtom = atom(false);
 
 export function ChatInput({ chatId }: { chatId?: number }) {
@@ -182,13 +182,6 @@ export function ChatInput({ chatId }: { chatId?: number }) {
         chatId,
         messageId,
       });
-      if (result.success) {
-        console.log("Proposal approved successfully");
-        // TODO: Maybe refresh proposal state or show confirmation?
-      } else {
-        console.error("Failed to approve proposal:", result.error);
-        setError(result.error || "Failed to approve proposal");
-      }
       if (result.uncommittedFiles) {
         showUncommittedFilesWarning(result.uncommittedFiles);
       }
@@ -215,17 +208,10 @@ export function ChatInput({ chatId }: { chatId?: number }) {
     setIsRejecting(true);
     posthog.capture("chat:reject");
     try {
-      const result = await IpcClient.getInstance().rejectProposal({
+      await IpcClient.getInstance().rejectProposal({
         chatId,
         messageId,
       });
-      if (result.success) {
-        console.log("Proposal rejected successfully");
-        // TODO: Maybe refresh proposal state or show confirmation?
-      } else {
-        console.error("Failed to reject proposal:", result.error);
-        setError(result.error || "Failed to reject proposal");
-      }
     } catch (err) {
       console.error("Error rejecting proposal:", err);
       setError((err as Error)?.message || "An error occurred while rejecting");
@@ -389,6 +375,7 @@ function SummarizeInNewChatButton() {
       console.error("No app id found");
       return;
     }
+    try {
       const newChatId = await IpcClient.getInstance().createChat(appId);
       // navigate to new chat
       await navigate({ to: "/chat", search: { id: newChatId } });
@@ -396,6 +383,9 @@ function SummarizeInNewChatButton() {
         prompt: "Summarize from chat-id=" + chatId,
         chatId: newChatId,
       });
+    } catch (err) {
+      showError(err);
+    }
   };
   return (
     <TooltipProvider>

src/components/chat/MessagesList.tsx

@@ -89,14 +89,13 @@ export const MessagesList = forwardRef<HTMLDivElement, MessagesListProps>(
                           await revertVersion({
                             versionId: chat.initialCommitHash,
                           });
-                          const result =
+                          try {
                             await IpcClient.getInstance().deleteMessages(
                               selectedChatId,
                             );
-                          if (result.success) {
                             setMessages([]);
-                          } else {
+                          } catch (err) {
-                            showError(result.error);
+                            showError(err);
                           }
                         } else {
                           showWarning(

src/components/preview_panel/FileEditor.tsx

@@ -6,6 +6,7 @@ import { ChevronRight, Circle } from "lucide-react";
 import "@/components/chat/monaco";
 import { IpcClient } from "@/ipc/ipc_client";
 import { useSettings } from "@/hooks/useSettings";
+import { showError } from "@/lib/toast";
 
 interface FileEditorProps {
   appId: number | null;
@@ -132,8 +133,7 @@ export const FileEditor = ({ appId, filePath }: FileEditorProps) => {
       needsSaveRef.current = false;
       setDisplayUnsavedChanges(false);
     } catch (error) {
-      console.error("Error saving file:", error);
+      showError(error);
-      // Could add error notification here
     } finally {
       isSavingRef.current = false;
     }

src/hooks/useSupabase.ts

@@ -42,14 +42,8 @@ export function useSupabase() {
     async (projectId: string, appId: number) => {
       setLoading(true);
       try {
-        const result = await ipcClient.setSupabaseAppProject(projectId, appId);
+        await ipcClient.setSupabaseAppProject(projectId, appId);
-
-        if (result.success) {
         setError(null);
-          return result;
-        } else {
-          throw new Error("Failed to set project for app");
-        }
       } catch (error) {
         console.error("Error setting Supabase project for app:", error);
         setError(error instanceof Error ? error : new Error(String(error)));
@@ -68,14 +62,8 @@ export function useSupabase() {
     async (appId: number) => {
       setLoading(true);
       try {
-        const result = await ipcClient.unsetSupabaseAppProject(appId);
+        await ipcClient.unsetSupabaseAppProject(appId);
-
-        if (result.success) {
         setError(null);
-          return result;
-        } else {
-          throw new Error("Failed to unset project for app");
-        }
       } catch (error) {
         console.error("Error unsetting Supabase project for app:", error);
         setError(error instanceof Error ? error : new Error(String(error)));

src/ipc/handlers/app_handlers.ts

@@ -32,8 +32,10 @@ import killPort from "kill-port";
 import util from "util";
 import log from "electron-log";
 import { getSupabaseProjectName } from "../../supabase_admin/supabase_management_client";
+import { createLoggedHandler } from "./safe_handle";
 
 const logger = log.scope("app_handlers");
+const handle = createLoggedHandler(logger);
 
 // Needed, otherwise electron in MacOS/Linux will not be able
 // to find node/pnpm.
@@ -137,7 +139,12 @@ async function killProcessOnPort(port: number): Promise<void> {
 }
 
 export function registerAppHandlers() {
-  ipcMain.handle("create-app", async (_, params: CreateAppParams) => {
+  handle(
+    "create-app",
+    async (
+      _,
+      params: CreateAppParams,
+    ): Promise<{ app: any; chatId: number }> => {
       const appPath = params.name;
       const fullAppPath = getDyadAppPath(appPath);
       if (fs.existsSync(fullAppPath)) {
@@ -200,12 +207,12 @@ export function registerAppHandlers() {
       } catch (error) {
         logger.error("Error in background app initialization:", error);
       }
-    // })();
 
       return { app, chatId: chat.id };
-  });
+    },
+  );
 
-  ipcMain.handle("get-app", async (_, appId: number): Promise<App> => {
+  handle("get-app", async (_, appId: number): Promise<App> => {
     const app = await db.query.apps.findFirst({
       where: eq(apps.id, appId),
     });
@@ -281,6 +288,7 @@ export function registerAppHandlers() {
     },
   );
 
+  // Do NOT use handle for this, it contains sensitive information.
   ipcMain.handle("get-env-vars", async () => {
     const envVars: Record<string, string | undefined> = {};
     for (const key of ALLOWED_ENV_VARS) {
@@ -294,13 +302,12 @@ export function registerAppHandlers() {
     async (
       event: Electron.IpcMainInvokeEvent,
       { appId }: { appId: number },
-    ) => {
+    ): Promise<void> => {
       return withLock(appId, async () => {
         // Check if app is already running
         if (runningApps.has(appId)) {
           logger.debug(`App ${appId} is already running.`);
-          // Potentially return the existing process info or confirm status
+          return;
-          return { success: true, message: "App already running." };
         }
 
         const app = await db.query.apps.findFirst({
@@ -315,9 +322,9 @@ export function registerAppHandlers() {
 
         const appPath = getDyadAppPath(app.path);
         try {
-          const currentProcessId = await executeApp({ appPath, appId, event });
+          await executeApp({ appPath, appId, event });
 
-          return { success: true, processId: currentProcessId };
+          return;
         } catch (error: any) {
           logger.error(`Error running app ${appId}:`, error);
           // Ensure cleanup if error happens during setup but before process events are handled
@@ -333,7 +340,9 @@ export function registerAppHandlers() {
     },
   );
 
-  ipcMain.handle("stop-app", async (_, { appId }: { appId: number }) => {
+  ipcMain.handle(
+    "stop-app",
+    async (_, { appId }: { appId: number }): Promise<void> => {
       logger.log(
         `Attempting to stop app ${appId}. Current running apps: ${runningApps.size}`,
       );
@@ -344,10 +353,7 @@ export function registerAppHandlers() {
           logger.log(
             `App ${appId} not found in running apps map. Assuming already stopped.`,
           );
-        return {
+          return;
-          success: true,
-          message: "App not running.",
-        };
         }
 
         const { process, processId } = appInfo;
@@ -361,7 +367,7 @@ export function registerAppHandlers() {
             `Process for app ${appId} (PID: ${process.pid}) already exited (code: ${process.exitCode}, signal: ${process.signalCode}). Cleaning up map.`,
           );
           runningApps.delete(appId); // Ensure cleanup if somehow missed
-        return { success: true, message: "Process already exited." };
+          return;
         }
 
         try {
@@ -371,7 +377,7 @@ export function registerAppHandlers() {
           // Now, safely remove the app from the map *after* confirming closure
           removeAppIfCurrentProcess(appId, process);
 
-        return { success: true };
+          return;
         } catch (error: any) {
           logger.error(
             `Error stopping app ${appId} (PID: ${process.pid}, processId: ${processId}):`,
@@ -382,7 +388,8 @@ export function registerAppHandlers() {
           throw new Error(`Failed to stop app ${appId}: ${error.message}`);
         }
       });
-  });
+    },
+  );
 
   ipcMain.handle(
     "restart-app",
@@ -392,7 +399,7 @@ export function registerAppHandlers() {
         appId,
         removeNodeModules,
       }: { appId: number; removeNodeModules?: boolean },
-    ) => {
+    ): Promise<void> => {
       logger.log(`Restarting app ${appId}`);
       return withLock(appId, async () => {
         try {
@@ -447,7 +454,7 @@ export function registerAppHandlers() {
 
           await executeApp({ appPath, appId, event }); // This will handle starting either mode
 
-          return { success: true };
+          return;
         } catch (error) {
           logger.error(`Error restarting app ${appId}:`, error);
           throw error;
@@ -465,7 +472,7 @@ export function registerAppHandlers() {
         filePath,
         content,
       }: { appId: number; filePath: string; content: string },
-    ) => {
+    ): Promise<void> => {
       const app = await db.query.apps.findFirst({
         where: eq(apps.id, appId),
       });
@@ -505,7 +512,7 @@ export function registerAppHandlers() {
           });
         }
 
-        return { success: true };
+        return;
       } catch (error: any) {
         logger.error(`Error writing file ${filePath} for app ${appId}:`, error);
         throw new Error(`Failed to write file: ${error.message}`);
@@ -513,7 +520,9 @@ export function registerAppHandlers() {
     },
   );
 
-  ipcMain.handle("delete-app", async (_, { appId }: { appId: number }) => {
+  ipcMain.handle(
+    "delete-app",
+    async (_, { appId }: { appId: number }): Promise<void> => {
       // Static server worker is NOT terminated here anymore
 
       return withLock(appId, async () => {
@@ -552,13 +561,16 @@ export function registerAppHandlers() {
         try {
           await db.delete(apps).where(eq(apps.id, appId));
           // Note: Associated chats will cascade delete if that's set up in the schema
-        return { success: true };
+          return;
         } catch (error: any) {
           logger.error(`Error deleting app ${appId} from database:`, error);
-        throw new Error(`Failed to delete app from database: ${error.message}`);
+          throw new Error(
+            `Failed to delete app from database: ${error.message}`,
+          );
         }
       });
-  });
+    },
+  );
 
   ipcMain.handle(
     "rename-app",
@@ -569,7 +581,7 @@ export function registerAppHandlers() {
         appName,
         appPath,
       }: { appId: number; appName: string; appPath: string },
-    ) => {
+    ): Promise<void> => {
       return withLock(appId, async () => {
         // Check if app exists
         const app = await db.query.apps.findFirst({
@@ -642,7 +654,7 @@ export function registerAppHandlers() {
 
         // Update app in database
         try {
-          const [updatedApp] = await db
+          await db
             .update(apps)
             .set({
               name: appName,
@@ -651,7 +663,7 @@ export function registerAppHandlers() {
             .where(eq(apps.id, appId))
             .returning();
 
-          return { success: true, app: updatedApp };
+          return;
         } catch (error: any) {
           // Attempt to rollback the file move
           if (newAppPath !== oldAppPath) {
@@ -672,7 +684,7 @@ export function registerAppHandlers() {
     },
   );
 
-  ipcMain.handle("reset-all", async () => {
+  ipcMain.handle("reset-all", async (): Promise<void> => {
     logger.log("start: resetting all apps and settings.");
     // Stop all running apps first
     logger.log("stopping all running apps...");
@@ -722,10 +734,9 @@ export function registerAppHandlers() {
     }
     logger.log("all app files removed.");
     logger.log("reset all complete.");
-    return { success: true, message: "Successfully reset everything" };
   });
 
-  ipcMain.handle("get-app-version", async () => {
+  ipcMain.handle("get-app-version", async (): Promise<{ version: string }> => {
     // Read version from package.json at project root
     const packageJsonPath = path.resolve(__dirname, "..", "..", "package.json");
     const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));

src/ipc/handlers/chat_handlers.ts

@@ -5,14 +5,16 @@ import { desc, eq } from "drizzle-orm";
 import type { ChatSummary } from "../../lib/schemas";
 import * as git from "isomorphic-git";
 import * as fs from "fs";
+import { createLoggedHandler } from "./safe_handle";
 
 import log from "electron-log";
 import { getDyadAppPath } from "../../paths/paths";
 
 const logger = log.scope("chat_handlers");
+const handle = createLoggedHandler(logger);
 
 export function registerChatHandlers() {
-  ipcMain.handle("create-chat", async (_, appId: number) => {
+  handle("create-chat", async (_, appId: number): Promise<number> => {
     // Get the app's path first
     const app = await db.query.apps.findFirst({
       where: eq(apps.id, appId),
@@ -74,9 +76,7 @@ export function registerChatHandlers() {
     return chat;
   });
 
-  ipcMain.handle(
+  handle("get-chats", async (_, appId?: number): Promise<ChatSummary[]> => {
-    "get-chats",
-    async (_, appId?: number): Promise<ChatSummary[]> => {
     // If appId is provided, filter chats for that app
     const query = appId
       ? db.query.chats.findMany({
@@ -101,27 +101,13 @@ export function registerChatHandlers() {
 
     const allChats = await query;
     return allChats;
-    },
-  );
-
-  ipcMain.handle("delete-chat", async (_, chatId: number) => {
-    try {
-      // Delete the chat and its associated messages
-      await db.delete(chats).where(eq(chats.id, chatId));
-      return { success: true };
-    } catch (error) {
-      logger.error("Error deleting chat:", error);
-      return { success: false, error: (error as Error).message };
-    }
   });
 
-  ipcMain.handle("delete-messages", async (_, chatId: number) => {
+  handle("delete-chat", async (_, chatId: number): Promise<void> => {
-    try {
+    await db.delete(chats).where(eq(chats.id, chatId));
+  });
+
+  handle("delete-messages", async (_, chatId: number): Promise<void> => {
     await db.delete(messages).where(eq(messages.chatId, chatId));
-      return { success: true };
-    } catch (error) {
-      logger.error("Error deleting messages:", error);
-      return { success: false, error: (error as Error).message };
-    }
   });
 }

src/ipc/handlers/dependency_handlers.ts

@@ -1,17 +1,21 @@
-import { ipcMain } from "electron";
 import { db } from "../../db";
 import { messages, apps, chats } from "../../db/schema";
 import { eq } from "drizzle-orm";
 import { getDyadAppPath } from "../../paths/paths";
 import { executeAddDependency } from "../processors/executeAddDependency";
+import { createLoggedHandler } from "./safe_handle";
+import log from "electron-log";
+
+const logger = log.scope("dependency_handlers");
+const handle = createLoggedHandler(logger);
 
 export function registerDependencyHandlers() {
-  ipcMain.handle(
+  handle(
     "chat:add-dep",
     async (
       _event,
       { chatId, packages }: { chatId: number; packages: string[] },
-    ) => {
+    ): Promise<void> => {
       // Find the message from the database
       const foundMessages = await db.query.messages.findMany({
         where: eq(messages.chatId, chatId),

src/ipc/handlers/github_handlers.ts

@@ -285,7 +285,7 @@ function handleStartGithubFlow(
 async function handleIsRepoAvailable(
   event: IpcMainInvokeEvent,
   { org, repo }: { org: string; repo: string },
-) {
+): Promise<{ available: boolean; error?: string }> {
   try {
     // Get access token from settings
     const settings = readSettings();
@@ -323,13 +323,12 @@ async function handleIsRepoAvailable(
 async function handleCreateRepo(
   event: IpcMainInvokeEvent,
   { org, repo, appId }: { org: string; repo: string; appId: number },
-) {
+): Promise<void> {
-  try {
   // Get access token from settings
   const settings = readSettings();
   const accessToken = settings.githubAccessToken?.value;
   if (!accessToken) {
-      return { success: false, error: "Not authenticated with GitHub." };
+    throw new Error("Not authenticated with GitHub.");
   }
   // If org is empty, create for the authenticated user
   let owner = org;
@@ -358,14 +357,10 @@ async function handleCreateRepo(
   });
   if (!res.ok) {
     const data = await res.json();
-      return { success: false, error: data.message || "Failed to create repo" };
+    throw new Error(data.message || "Failed to create repo");
   }
   // Store org and repo in the app's DB row (apps table)
   await updateAppGithubRepo(appId, owner, repo);
-    return { success: true };
-  } catch (err: any) {
-    return { success: false, error: err.message || "Unknown error" };
-  }
 }
 
 // --- GitHub Push Handler ---
@@ -420,8 +415,7 @@ async function handlePushToGithub(
 async function handleDisconnectGithubRepo(
   event: IpcMainInvokeEvent,
   { appId }: { appId: number },
-) {
+): Promise<void> {
-  try {
   logger.log(`Disconnecting GitHub repo for appId: ${appId}`);
 
   // Get the app from the database
@@ -430,7 +424,7 @@ async function handleDisconnectGithubRepo(
   });
 
   if (!app) {
-      return { success: false, error: "App not found" };
+    throw new Error("App not found");
   }
 
   // Update app in database to remove GitHub repo and org
@@ -441,15 +435,6 @@ async function handleDisconnectGithubRepo(
       githubOrg: null,
     })
     .where(eq(apps.id, appId));
-
-    return { success: true };
-  } catch (error) {
-    logger.error(`Error disconnecting GitHub repo: ${error}`);
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : String(error),
-    };
-  }
 }
 
 // --- Registration ---

src/ipc/handlers/local_model_lmstudio_handler.ts

@@ -18,7 +18,6 @@ export interface LMStudioModel {
 }
 
 export async function fetchLMStudioModels(): Promise<LocalModelListResponse> {
-  try {
   const modelsResponse: Response = await fetch(
     "http://localhost:1234/api/v0/models",
   );
@@ -36,10 +35,7 @@ export async function fetchLMStudioModels(): Promise<LocalModelListResponse> {
     }));
 
   logger.info(`Successfully fetched ${models.length} models from LM Studio`);
-    return { models, error: null };
+  return { models };
-  } catch {
-    return { models: [], error: "Failed to fetch models from LM Studio" };
-  }
 }
 
 export function registerLMStudioHandlers() {

src/ipc/handlers/local_model_ollama_handler.ts

@@ -47,20 +47,17 @@ export async function fetchOllamaModels(): Promise<LocalModelListResponse> {
       };
     });
     logger.info(`Successfully fetched ${models.length} models from Ollama`);
-    return { models, error: null };
+    return { models };
   } catch (error) {
     if (
       error instanceof TypeError &&
       (error as Error).message.includes("fetch failed")
     ) {
-      logger.error("Could not connect to Ollama");
+      throw new Error(
-      return {
-        models: [],
-        error:
         "Could not connect to Ollama. Make sure it's running at http://localhost:11434",
-      };
+      );
     }
-    return { models: [], error: "Failed to fetch models from Ollama" };
+    throw new Error("Failed to fetch models from Ollama");
   }
 }
 

src/ipc/handlers/proposal_handlers.ts

@@ -1,4 +1,4 @@
-import { ipcMain, type IpcMainInvokeEvent } from "electron";
+import { type IpcMainInvokeEvent } from "electron";
 import type {
   CodeProposal,
   ProposalResult,
@@ -29,9 +29,9 @@ import {
 import { extractCodebase } from "../../utils/codebase";
 import { getDyadAppPath } from "../../paths/paths";
 import { withLock } from "../utils/lock_utils";
-
+import { createLoggedHandler } from "./safe_handle";
 const logger = log.scope("proposal_handlers");
-
+const handle = createLoggedHandler(logger);
 // Cache for codebase token counts
 interface CodebaseTokenCache {
   chatId: number;
@@ -317,15 +317,8 @@ const approveProposalHandler = async (
   _event: IpcMainInvokeEvent,
   { chatId, messageId }: { chatId: number; messageId: number },
 ): Promise<{
-  success: boolean;
-  error?: string;
   uncommittedFiles?: string[];
 }> => {
-  logger.log(
-    `IPC: approve-proposal called for chatId: ${chatId}, messageId: ${messageId}`,
-  );
-
-  try {
   // 1. Fetch the specific assistant message
   const messageToApprove = await db.query.messages.findFirst({
     where: and(
@@ -339,10 +332,9 @@ const approveProposalHandler = async (
   });
 
   if (!messageToApprove?.content) {
-      logger.error(
+    throw new Error(
       `Assistant message not found for chatId: ${chatId}, messageId: ${messageId}`,
     );
-      return { success: false, error: "Assistant message not found." };
   }
 
   // 2. Process the actions defined in the message content
@@ -357,38 +349,23 @@ const approveProposalHandler = async (
   );
 
   if (processResult.error) {
-      logger.error(
+    throw new Error(
-        `Error processing actions for message ${messageId}:`,
+      `Error processing actions for message ${messageId}: ${processResult.error}`,
-        processResult.error,
     );
-      // Optionally: Update message state to 'error' or similar?
-      // For now, just return error to frontend
-      return {
-        success: false,
-        error: `Action processing failed: ${processResult.error}`,
-      };
   }
 
-    return { success: true, uncommittedFiles: processResult.uncommittedFiles };
+  return { uncommittedFiles: processResult.uncommittedFiles };
-  } catch (error) {
-    logger.error(`Error approving proposal for messageId ${messageId}:`, error);
-    return {
-      success: false,
-      error: (error as Error)?.message || "Unknown error",
-    };
-  }
 };
 
 // Handler to reject a proposal (just update message state)
 const rejectProposalHandler = async (
   _event: IpcMainInvokeEvent,
   { chatId, messageId }: { chatId: number; messageId: number },
-): Promise<{ success: boolean; error?: string }> => {
+): Promise<void> => {
   logger.log(
     `IPC: reject-proposal called for chatId: ${chatId}, messageId: ${messageId}`,
   );
 
-  try {
   // 1. Verify the message exists and is an assistant message
   const messageToReject = await db.query.messages.findFirst({
     where: and(
@@ -400,10 +377,9 @@ const rejectProposalHandler = async (
   });
 
   if (!messageToReject) {
-      logger.error(
+    throw new Error(
       `Assistant message not found for chatId: ${chatId}, messageId: ${messageId}`,
     );
-      return { success: false, error: "Assistant message not found." };
   }
 
   // 2. Update the message's approval state to 'rejected'
@@ -413,19 +389,11 @@ const rejectProposalHandler = async (
     .where(eq(messages.id, messageId));
 
   logger.log(`Message ${messageId} marked as rejected.`);
-    return { success: true };
-  } catch (error) {
-    logger.error(`Error rejecting proposal for messageId ${messageId}:`, error);
-    return {
-      success: false,
-      error: (error as Error)?.message || "Unknown error",
-    };
-  }
 };
 
 // Function to register proposal-related handlers
 export function registerProposalHandlers() {
-  ipcMain.handle("get-proposal", getProposalHandler);
+  handle("get-proposal", getProposalHandler);
-  ipcMain.handle("approve-proposal", approveProposalHandler);
+  handle("approve-proposal", approveProposalHandler);
-  ipcMain.handle("reject-proposal", rejectProposalHandler);
+  handle("reject-proposal", rejectProposalHandler);
 }

src/ipc/handlers/safe_handle.ts

@@ -1,7 +1,7 @@
 import { ipcMain, IpcMainInvokeEvent } from "electron";
 import log from "electron-log";
 
-export function createSafeHandler(logger: log.LogFunctions) {
+export function createLoggedHandler(logger: log.LogFunctions) {
   return (
     channel: string,
     fn: (event: IpcMainInvokeEvent, ...args: any[]) => Promise<any>,
@@ -9,8 +9,11 @@ export function createSafeHandler(logger: log.LogFunctions) {
     ipcMain.handle(
       channel,
       async (event: IpcMainInvokeEvent, ...args: any[]) => {
+        logger.log(`IPC: ${channel} called with args: ${JSON.stringify(args)}`);
         try {
-          return await fn(event, ...args);
+          const result = await fn(event, ...args);
+          logger.log(`IPC: ${channel} returned: ${JSON.stringify(result)}`);
+          return result;
         } catch (error) {
           logger.error(
             `Error in ${fn.name}: args: ${JSON.stringify(args)}`,

src/ipc/handlers/settings_handlers.ts

@@ -4,11 +4,13 @@ import { writeSettings } from "../../main/settings";
 import { readSettings } from "../../main/settings";
 
 export function registerSettingsHandlers() {
+  // Intentionally do NOT use handle because it could log sensitive data from the return value.
   ipcMain.handle("get-user-settings", async () => {
     const settings = readSettings();
     return settings;
   });
 
+  // Intentionally do NOT use handle because it could log sensitive data from the args.
   ipcMain.handle(
     "set-user-settings",
     async (_, settings: Partial<UserSettings>) => {

src/ipc/handlers/shell_handler.ts

@@ -1,45 +1,29 @@
-import { ipcMain, shell } from "electron";
+import { shell } from "electron";
 import log from "electron-log";
+import { createLoggedHandler } from "./safe_handle";
 
 const logger = log.scope("shell_handlers");
+const handle = createLoggedHandler(logger);
 
 export function registerShellHandlers() {
-  ipcMain.handle("open-external-url", async (_event, url: string) => {
+  handle("open-external-url", async (_event, url: string) => {
-    try {
+    if (!url) {
-      // Basic validation to ensure it's a http/https url
+      throw new Error("No URL provided.");
-      if (url && (url.startsWith("http://") || url.startsWith("https://"))) {
+    }
+    if (!url.startsWith("http://") && !url.startsWith("https://")) {
+      throw new Error("Attempted to open invalid or non-http URL: " + url);
+    }
     await shell.openExternal(url);
     logger.debug("Opened external URL:", url);
-        return { success: true };
-      }
-      logger.error("Attempted to open invalid or non-http URL:", url);
-      return {
-        success: false,
-        error: "Invalid URL provided. Only http/https URLs are allowed.",
-      };
-    } catch (error) {
-      logger.error(`Failed to open external URL ${url}:`, error);
-      return { success: false, error: (error as Error).message };
-    }
   });
 
-  ipcMain.handle("show-item-in-folder", async (_event, fullPath: string) => {
+  handle("show-item-in-folder", async (_event, fullPath: string) => {
-    try {
     // Validate that a path was provided
     if (!fullPath) {
-        logger.error("Attempted to show item with empty path");
+      throw new Error("No file path provided.");
-        return {
-          success: false,
-          error: "No file path provided.",
-        };
     }
 
     shell.showItemInFolder(fullPath);
     logger.debug("Showed item in folder:", fullPath);
-      return { success: true };
-    } catch (error) {
-      logger.error(`Failed to show item in folder ${fullPath}:`, error);
-      return { success: false, error: (error as Error).message };
-    }
   });
 }

src/ipc/handlers/supabase_handlers.ts

@@ -1,63 +1,39 @@
-import { ipcMain } from "electron";
 import log from "electron-log";
 import { db } from "../../db";
 import { eq } from "drizzle-orm";
 import { apps } from "../../db/schema";
 import { getSupabaseClient } from "../../supabase_admin/supabase_management_client";
+import { createLoggedHandler } from "./safe_handle";
 
 const logger = log.scope("supabase_handlers");
+const handle = createLoggedHandler(logger);
 
 export function registerSupabaseHandlers() {
-  // List all Supabase projects
+  handle("supabase:list-projects", async () => {
-  ipcMain.handle("supabase:list-projects", async () => {
-    try {
     const supabase = await getSupabaseClient();
-      // Call the API according to supabase-management-js structure
+    return supabase.getProjects();
-      const projects = await supabase.getProjects();
-      return projects;
-    } catch (error) {
-      logger.error("Error listing Supabase projects:", error);
-      throw error;
-    }
   });
 
   // Set app project - links a Dyad app to a Supabase project
-  ipcMain.handle(
+  handle(
     "supabase:set-app-project",
     async (_, { project, app }: { project: string; app: number }) => {
-      try {
-        // Here you could store the project-app association in your database
-        // For example:
       await db
         .update(apps)
         .set({ supabaseProjectId: project })
         .where(eq(apps.id, app));
 
       logger.info(`Associated app ${app} with Supabase project ${project}`);
-        return { success: true, appId: app, projectId: project };
-      } catch (error) {
-        logger.error("Error setting Supabase project for app:", error);
-        throw error;
-      }
     },
   );
 
   // Unset app project - removes the link between a Dyad app and a Supabase project
-  ipcMain.handle(
+  handle("supabase:unset-app-project", async (_, { app }: { app: number }) => {
-    "supabase:unset-app-project",
-    async (_, { app }: { app: number }) => {
-      try {
     await db
       .update(apps)
       .set({ supabaseProjectId: null })
       .where(eq(apps.id, app));
 
     logger.info(`Removed Supabase project association for app ${app}`);
-        return { success: true, appId: app };
+  });
-      } catch (error) {
-        logger.error("Error unsetting Supabase project for app:", error);
-        throw error;
-      }
-    },
-  );
 }

src/ipc/handlers/token_count_handlers.ts

@@ -1,4 +1,3 @@
-import { ipcMain } from "electron";
 import { db } from "../../db";
 import { chats } from "../../db/schema";
 import { eq } from "drizzle-orm";
@@ -15,15 +14,16 @@ import { getSupabaseContext } from "../../supabase_admin/supabase_context";
 import { TokenCountParams } from "../ipc_types";
 import { TokenCountResult } from "../ipc_types";
 import { estimateTokens, getContextWindow } from "../utils/token_utils";
+import { createLoggedHandler } from "./safe_handle";
 
 const logger = log.scope("token_count_handlers");
 
+const handle = createLoggedHandler(logger);
+
 export function registerTokenCountHandlers() {
-  ipcMain.handle(
+  handle(
     "chat:count-tokens",
     async (event, req: TokenCountParams): Promise<TokenCountResult> => {
-      try {
-        // Get the chat with messages
       const chat = await db.query.chats.findFirst({
         where: eq(chats.id, req.chatId),
         with: {
@@ -60,9 +60,7 @@ export function registerTokenCountHandlers() {
         systemPrompt += "\n\n" + SUPABASE_NOT_AVAILABLE_SYSTEM_PROMPT;
       }
 
-        const systemPromptTokens = estimateTokens(
+      const systemPromptTokens = estimateTokens(systemPrompt + supabaseContext);
-          systemPrompt + supabaseContext,
-        );
 
       // Extract codebase information if app is associated with the chat
       let codebaseInfo = "";
@@ -70,15 +68,11 @@ export function registerTokenCountHandlers() {
 
       if (chat.app) {
         const appPath = getDyadAppPath(chat.app.path);
-          try {
         codebaseInfo = await extractCodebase(appPath);
         codebaseTokens = estimateTokens(codebaseInfo);
         logger.log(
           `Extracted codebase information from ${appPath}, tokens: ${codebaseTokens}`,
         );
-          } catch (error) {
-            logger.error("Error extracting codebase:", error);
-          }
       }
 
       // Calculate total tokens
@@ -96,10 +90,6 @@ export function registerTokenCountHandlers() {
         systemPromptTokens,
         contextWindow: getContextWindow(),
       };
-      } catch (error) {
-        logger.error("Error counting tokens:", error);
-        throw error;
-      }
     },
   );
 }

src/ipc/handlers/upload_handlers.ts

@@ -1,9 +1,11 @@
-import { ipcMain } from "electron";
 import log from "electron-log";
 import fetch from "node-fetch";
+import { createLoggedHandler } from "./safe_handle";
 
 const logger = log.scope("upload_handlers");
 
+const handle = createLoggedHandler(logger);
+
 interface UploadToSignedUrlParams {
   url: string;
   contentType: string;
@@ -11,13 +13,10 @@ interface UploadToSignedUrlParams {
 }
 
 export function registerUploadHandlers() {
-  ipcMain.handle(
+  handle("upload-to-signed-url", async (_, params: UploadToSignedUrlParams) => {
-    "upload-to-signed-url",
-    async (_, params: UploadToSignedUrlParams) => {
     const { url, contentType, data } = params;
     logger.debug("IPC: upload-to-signed-url called");
 
-      try {
     // Validate the signed URL
     if (!url || typeof url !== "string" || !url.startsWith("https://")) {
       throw new Error("Invalid signed URL provided");
@@ -44,16 +43,7 @@ export function registerUploadHandlers() {
     }
 
     logger.debug("Successfully uploaded data to signed URL");
-        return { success: true };
+  });
-      } catch (error) {
-        logger.error("Failed to upload to signed URL:", error);
-        return {
-          success: false,
-          error: error instanceof Error ? error.message : String(error),
-        };
-      }
-    },
-  );
 
   logger.debug("Registered upload IPC handlers");
 }

src/ipc/handlers/version_handlers.ts

@@ -10,11 +10,11 @@ import { promises as fsPromises } from "node:fs";
 import { withLock } from "../utils/lock_utils";
 import { getGitAuthor } from "../utils/git_author";
 import log from "electron-log";
-import { createSafeHandler } from "./safe_handle";
+import { createLoggedHandler } from "./safe_handle";
 
 const logger = log.scope("version_handlers");
 
-const handle = createSafeHandler(logger);
+const handle = createLoggedHandler(logger);
 
 export function registerVersionHandlers() {
   handle("list-versions", async (_, { appId }: { appId: number }) => {

src/ipc/ipc_client.ts

@@ -150,23 +150,11 @@ export class IpcClient {
 
   // Create a new app with an initial chat
   public async createApp(params: CreateAppParams): Promise<CreateAppResult> {
-    try {
+    return this.ipcRenderer.invoke("create-app", params);
-      const result = await this.ipcRenderer.invoke("create-app", params);
-      return result as CreateAppResult;
-    } catch (error) {
-      showError(error);
-      throw error;
-    }
   }
 
   public async getApp(appId: number): Promise<App> {
-    try {
+    return this.ipcRenderer.invoke("get-app", appId);
-      const data = await this.ipcRenderer.invoke("get-app", appId);
-      return data;
-    } catch (error) {
-      showError(error);
-      throw error;
-    }
   }
 
   public async getChat(chatId: number): Promise<Chat> {
@@ -192,28 +180,14 @@ export class IpcClient {
 
   // Get all apps
   public async listApps(): Promise<ListAppsResponse> {
-    try {
+    return this.ipcRenderer.invoke("list-apps");
-      const data = await this.ipcRenderer.invoke("list-apps");
-      return data;
-    } catch (error) {
-      showError(error);
-      throw error;
-    }
   }
 
-  // Read a file from an app directory
   public async readAppFile(appId: number, filePath: string): Promise<string> {
-    try {
+    return this.ipcRenderer.invoke("read-app-file", {
-      const content = await this.ipcRenderer.invoke("read-app-file", {
       appId,
       filePath,
     });
-      return content as string;
-    } catch (error) {
-      // No toast because sometimes the file will disappear.
-      console.error(error);
-      throw error;
-    }
   }
 
   // Edit a file in an app directory
@@ -221,18 +195,12 @@ export class IpcClient {
     appId: number,
     filePath: string,
     content: string,
-  ): Promise<{ success: boolean }> {
+  ): Promise<void> {
-    try {
+    await this.ipcRenderer.invoke("edit-app-file", {
-      const result = await this.ipcRenderer.invoke("edit-app-file", {
       appId,
       filePath,
       content,
     });
-      return result as { success: boolean };
-    } catch (error) {
-      showError(error);
-      throw error;
-    }
   }
 
   // New method for streaming responses
@@ -321,91 +289,38 @@ export class IpcClient {
 
   // Create a new chat for an app
   public async createChat(appId: number): Promise<number> {
-    try {
+    return this.ipcRenderer.invoke("create-chat", appId);
-      const chatId = await this.ipcRenderer.invoke("create-chat", appId);
-      return chatId as number;
-    } catch (error) {
-      showError(error);
-      throw error;
-    }
   }
 
-  public async deleteChat(
+  public async deleteChat(chatId: number): Promise<void> {
-    chatId: number,
+    await this.ipcRenderer.invoke("delete-chat", chatId);
-  ): Promise<{ success: boolean; error?: string }> {
-    try {
-      const result = await this.ipcRenderer.invoke("delete-chat", chatId);
-      return result as { success: boolean; error?: string };
-    } catch (error) {
-      showError(error);
-      throw error;
-    }
   }
 
-  public async deleteMessages(
+  public async deleteMessages(chatId: number): Promise<void> {
-    chatId: number,
+    await this.ipcRenderer.invoke("delete-messages", chatId);
-  ): Promise<{ success: boolean; error?: string }> {
-    try {
-      const result = await this.ipcRenderer.invoke("delete-messages", chatId);
-      return result as { success: boolean; error?: string };
-    } catch (error) {
-      showError(error);
-      throw error;
-    }
   }
 
   // Open an external URL using the default browser
-  public async openExternalUrl(
+  public async openExternalUrl(url: string): Promise<void> {
-    url: string,
+    await this.ipcRenderer.invoke("open-external-url", url);
-  ): Promise<{ success: boolean; error?: string }> {
-    try {
-      const result = await this.ipcRenderer.invoke("open-external-url", url);
-      return result as { success: boolean; error?: string };
-    } catch (error) {
-      showError(error);
-      throw error;
-    }
   }
 
-  public async showItemInFolder(
+  public async showItemInFolder(fullPath: string): Promise<void> {
-    fullPath: string,
+    await this.ipcRenderer.invoke("show-item-in-folder", fullPath);
-  ): Promise<{ success: boolean; error?: string }> {
-    try {
-      const result = await this.ipcRenderer.invoke(
-        "show-item-in-folder",
-        fullPath,
-      );
-      return result as { success: boolean; error?: string };
-    } catch (error) {
-      showError(error);
-      throw error;
-    }
   }
 
   // Run an app
   public async runApp(
     appId: number,
     onOutput: (output: AppOutput) => void,
-  ): Promise<{ success: boolean }> {
+  ): Promise<void> {
-    try {
+    await this.ipcRenderer.invoke("run-app", { appId });
-      const result = await this.ipcRenderer.invoke("run-app", { appId });
     this.appStreams.set(appId, { onOutput });
-      return result;
-    } catch (error) {
-      showError(error);
-      throw error;
-    }
   }
 
   // Stop a running app
-  public async stopApp(appId: number): Promise<{ success: boolean }> {
+  public async stopApp(appId: number): Promise<void> {
-    try {
+    await this.ipcRenderer.invoke("stop-app", { appId });
-      const result = await this.ipcRenderer.invoke("stop-app", { appId });
-      return result;
-    } catch (error) {
-      showError(error);
-      throw error;
-    }
   }
 
   // Restart a running app
@@ -514,14 +429,8 @@ export class IpcClient {
   }
 
   // Delete an app and all its files
-  public async deleteApp(appId: number): Promise<{ success: boolean }> {
+  public async deleteApp(appId: number): Promise<void> {
-    try {
+    await this.ipcRenderer.invoke("delete-app", { appId });
-      const result = await this.ipcRenderer.invoke("delete-app", { appId });
-      return result as { success: boolean };
-    } catch (error) {
-      showError(error);
-      throw error;
-    }
   }
 
   // Rename an app (update name and path)
@@ -533,29 +442,17 @@ export class IpcClient {
     appId: number;
     appName: string;
     appPath: string;
-  }): Promise<{ success: boolean; app: App }> {
+  }): Promise<void> {
-    try {
+    await this.ipcRenderer.invoke("rename-app", {
-      const result = await this.ipcRenderer.invoke("rename-app", {
       appId,
       appName,
       appPath,
     });
-      return result as { success: boolean; app: App };
-    } catch (error) {
-      showError(error);
-      throw error;
-    }
   }
 
   // Reset all - removes all app files, settings, and drops the database
-  public async resetAll(): Promise<{ success: boolean; message: string }> {
+  public async resetAll(): Promise<void> {
-    try {
+    await this.ipcRenderer.invoke("reset-all");
-      const result = await this.ipcRenderer.invoke("reset-all");
-      return result as { success: boolean; message: string };
-    } catch (error) {
-      showError(error);
-      throw error;
-    }
   }
 
   public async addDependency({
@@ -565,26 +462,15 @@ export class IpcClient {
     chatId: number;
     packages: string[];
   }): Promise<void> {
-    try {
     await this.ipcRenderer.invoke("chat:add-dep", {
       chatId,
       packages,
     });
-    } catch (error) {
-      showError(error);
-      throw error;
-    }
   }
 
   // Check Node.js and npm status
   public async getNodejsStatus(): Promise<NodeSystemInfo> {
-    try {
+    return this.ipcRenderer.invoke("nodejs-status");
-      const result = await this.ipcRenderer.invoke("nodejs-status");
-      return result;
-    } catch (error) {
-      showError(error);
-      throw error;
-    }
   }
 
   // --- GitHub Device Flow ---
@@ -631,11 +517,6 @@ export class IpcClient {
       this.ipcRenderer.removeListener("github:flow-error", listener);
     };
   }
-
-  // TODO: Implement cancel method if needed
-  // public cancelGithubDeviceFlow(): void {
-  //   this.ipcRenderer.sendMessage("github:cancel-flow");
-  // }
   // --- End GitHub Device Flow ---
 
   // --- GitHub Repo Management ---
@@ -643,32 +524,22 @@ export class IpcClient {
     org: string,
     repo: string,
   ): Promise<{ available: boolean; error?: string }> {
-    try {
+    return this.ipcRenderer.invoke("github:is-repo-available", {
-      const result = await this.ipcRenderer.invoke("github:is-repo-available", {
       org,
       repo,
     });
-      return result;
-    } catch (error: any) {
-      return { available: false, error: error.message || "Unknown error" };
-    }
   }
 
   public async createGithubRepo(
     org: string,
     repo: string,
     appId: number,
-  ): Promise<{ success: boolean; error?: string }> {
+  ): Promise<void> {
-    try {
+    await this.ipcRenderer.invoke("github:create-repo", {
-      const result = await this.ipcRenderer.invoke("github:create-repo", {
       org,
       repo,
       appId,
     });
-      return result;
-    } catch (error: any) {
-      return { success: false, error: error.message || "Unknown error" };
-    }
   }
 
   // Sync (push) local repo to GitHub
@@ -684,30 +555,17 @@ export class IpcClient {
     }
   }
 
-  public async disconnectGithubRepo(
+  public async disconnectGithubRepo(appId: number): Promise<void> {
-    appId: number,
+    await this.ipcRenderer.invoke("github:disconnect", {
-  ): Promise<{ success: boolean; error?: string }> {
-    try {
-      const result = await this.ipcRenderer.invoke("github:disconnect", {
       appId,
     });
-      return result as { success: boolean; error?: string };
-    } catch (error) {
-      showError(error);
-      throw error;
-    }
   }
   // --- End GitHub Repo Management ---
 
   // Get the main app version
   public async getAppVersion(): Promise<string> {
-    try {
     const result = await this.ipcRenderer.invoke("get-app-version");
     return result.version as string;
-    } catch (error) {
-      showError(error);
-      throw error;
-    }
   }
 
   // Get proposal details
@@ -734,24 +592,12 @@ export class IpcClient {
     chatId: number;
     messageId: number;
   }): Promise<{
-    success: boolean;
-    error?: string;
     uncommittedFiles?: string[];
   }> {
-    try {
+    return this.ipcRenderer.invoke("approve-proposal", {
-      const result = await this.ipcRenderer.invoke("approve-proposal", {
       chatId,
       messageId,
     });
-      return result as {
-        success: boolean;
-        error?: string;
-        uncommittedFiles?: string[];
-      };
-    } catch (error) {
-      showError(error);
-      return { success: false, error: (error as Error).message };
-    }
   }
 
   public async rejectProposal({
@@ -760,132 +606,66 @@ export class IpcClient {
   }: {
     chatId: number;
     messageId: number;
-  }): Promise<{ success: boolean; error?: string }> {
+  }): Promise<void> {
-    try {
+    await this.ipcRenderer.invoke("reject-proposal", {
-      const result = await this.ipcRenderer.invoke("reject-proposal", {
       chatId,
       messageId,
     });
-      return result as { success: boolean; error?: string };
-    } catch (error) {
-      showError(error);
-      return { success: false, error: (error as Error).message };
-    }
   }
   // --- End Proposal Management ---
 
   // --- Supabase Management ---
   public async listSupabaseProjects(): Promise<any[]> {
-    try {
+    return this.ipcRenderer.invoke("supabase:list-projects");
-      const projects = await this.ipcRenderer.invoke("supabase:list-projects");
-      return projects;
-    } catch (error) {
-      showError(error);
-      throw error;
-    }
   }
 
   public async setSupabaseAppProject(
     project: string,
     app: number,
-  ): Promise<{ success: boolean; appId: number; projectId: string }> {
+  ): Promise<void> {
-    try {
+    await this.ipcRenderer.invoke("supabase:set-app-project", {
-      const result = await this.ipcRenderer.invoke("supabase:set-app-project", {
       project,
       app,
     });
-      return result;
-    } catch (error) {
-      showError(error);
-      throw error;
-    }
   }
 
-  public async unsetSupabaseAppProject(
+  public async unsetSupabaseAppProject(app: number): Promise<void> {
-    app: number,
+    await this.ipcRenderer.invoke("supabase:unset-app-project", {
-  ): Promise<{ success: boolean; appId: number }> {
-    try {
-      const result = await this.ipcRenderer.invoke(
-        "supabase:unset-app-project",
-        {
       app,
-        },
+    });
-      );
-      return result;
-    } catch (error) {
-      showError(error);
-      throw error;
-    }
   }
   // --- End Supabase Management ---
 
-  // Get system debug information
   public async getSystemDebugInfo(): Promise<SystemDebugInfo> {
-    try {
+    return this.ipcRenderer.invoke("get-system-debug-info");
-      const data = await this.ipcRenderer.invoke("get-system-debug-info");
-      return data as SystemDebugInfo;
-    } catch (error) {
-      showError(error);
-      throw error;
-    }
   }
 
   public async getChatLogs(chatId: number): Promise<ChatLogsData> {
-    try {
+    return this.ipcRenderer.invoke("get-chat-logs", chatId);
-      const data = await this.ipcRenderer.invoke("get-chat-logs", chatId);
-      return data as ChatLogsData;
-    } catch (error) {
-      showError(error);
-      throw error;
-    }
   }
 
   public async uploadToSignedUrl(
     url: string,
     contentType: string,
     data: any,
-  ): Promise<{ success: boolean; error?: string }> {
+  ): Promise<void> {
-    try {
+    await this.ipcRenderer.invoke("upload-to-signed-url", {
-      const result = await this.ipcRenderer.invoke("upload-to-signed-url", {
       url,
       contentType,
       data,
     });
-      return result as { success: boolean; error?: string };
-    } catch (error) {
-      showError(error);
-      throw error;
-    }
   }
 
   public async listLocalOllamaModels(): Promise<LocalModel[]> {
-    try {
+    const response = await this.ipcRenderer.invoke("local-models:list-ollama");
-      const response = await this.ipcRenderer.invoke(
-        "local-models:list-ollama",
-      );
     return response?.models || [];
-    } catch (error) {
-      if (error instanceof Error) {
-        throw new Error(`Failed to fetch Ollama models: ${error.message}`);
-      }
-      throw new Error("Failed to fetch Ollama models: Unknown error occurred");
-    }
   }
 
   public async listLocalLMStudioModels(): Promise<LocalModel[]> {
-    try {
     const response = await this.ipcRenderer.invoke(
       "local-models:list-lmstudio",
     );
     return response?.models || [];
-    } catch (error) {
-      if (error instanceof Error) {
-        throw new Error(`Failed to fetch LM Studio models: ${error.message}`);
-      }
-      throw new Error(
-        "Failed to fetch LM Studio models: Unknown error occurred",
-      );
-    }
   }
 
   // Listen for deep link events

src/ipc/ipc_types.ts

@@ -111,7 +111,6 @@ export interface LocalModel {
 
 export type LocalModelListResponse = {
   models: LocalModel[];
-  error: string | null;
 };
 
 export interface TokenCountParams {

src/pages/app-details.tsx

@@ -28,6 +28,7 @@ import {
 } from "@/components/ui/dialog";
 import { GitHubConnector } from "@/components/GitHubConnector";
 import { SupabaseConnector } from "@/components/SupabaseConnector";
+import { showError } from "@/lib/toast";
 
 export default function AppDetailsPage() {
   const navigate = useNavigate();
@@ -62,7 +63,7 @@ export default function AppDetailsPage() {
       await refreshApps();
       navigate({ to: "/", search: {} });
     } catch (error) {
-      console.error("Failed to delete app:", error);
+      showError(error);
     } finally {
       setIsDeleting(false);
     }

src/pages/settings.tsx

@@ -27,12 +27,8 @@ export default function SettingsPage() {
     setIsResetting(true);
     try {
       const ipcClient = IpcClient.getInstance();
-      const result = await ipcClient.resetAll();
+      await ipcClient.resetAll();
-      if (result.success) {
       showSuccess("Successfully reset everything. Restart the application.");
-      } else {
-        showError(result.message || "Failed to reset everything.");
-      }
     } catch (error) {
       console.error("Error resetting:", error);
       showError(