From de4803590314bc57beee086baadcf2d018f925e9 Mon Sep 17 00:00:00 2001
From: Lcstyle <Lcstyle@pm.me>
Date: Wed, 5 Aug 2026 09:06:36 -0400
Subject: [PATCH] fix(electron): never let a failed graph save make the window
 unclosable

If frontend.db/persist! rejects, electron.listener/persist-dbs! replies on the
"persistent-dbs-error" channel. There was no handler for it, so three things went
wrong at once and the app could not be closed again for the rest of the session:

1. electron.window/close-handler had already called (.preventDefault e) and then
   parked on a bare (async/<! state/persistent-dbs-chan). The confirmation only
   ever arrives from :persistent-dbs-saved, so the go block waited forever and
   (destroy-window! win) was unreachable.

2. The message fell through to (defmethod handle :default [args]), which declares
   one parameter while (defmulti handle (fn [_window args] ...)) dispatches with
   two. That raised an arity exception rather than logging, and set-ipc-handler!
   swallowed it - so the unhandled channel left almost no trace. The one log line
   it did produce printed the BrowserWindow object, not the channel name.

3. electron/core.cljs resets *win to nil right after the first close attempt and
   guards the retry with (when window ...), so every later click on X, Quit or
   Ctrl+Q silently did nothing at all.

Handle :persistent-dbs-error by unblocking the channel, give the wait a 10s
timeout so no future failure mode can reproduce this, and fix the :default arity
so unhandled channels are actually reported.

Closing without the cache is safe: the graph's markdown files on disk are the
source of truth and are already written; the transit file is only a parsed-DB
cache, so the cost is a slower next startup, not data loss.

Refs logseq/logseq#12968
---
 src/electron/electron/handler.cljs | 16 ++++++++++++++--
 src/electron/electron/window.cljs  | 21 ++++++++++++++++-----
 2 files changed, 30 insertions(+), 7 deletions(-)

diff --git a/src/electron/electron/handler.cljs b/src/electron/electron/handler.cljs
index bf643fd54..027458e90 100644
--- a/src/electron/electron/handler.cljs
+++ b/src/electron/electron/handler.cljs
@@ -304,6 +304,15 @@
   (async/put! state/persistent-dbs-chan true)
   true)
 
+;; The renderer sends this when frontend.db/persist! rejected. Without a method here
+;; it fell through to :default, electron.window/close-handler stayed parked on
+;; persistent-dbs-chan forever, and the window could never be closed again. Unblock the
+;; close: the markdown files are the source of truth, the transit file is only a cache.
+(defmethod handle :persistent-dbs-error [_window _]
+  (logger/error "Failed to persist the graph cache. Closing anyway - your files on disk are unaffected, but the next startup will re-index.")
+  (async/put! state/persistent-dbs-chan true)
+  true)
+
 ;; Search related IPCs
 (defmethod handle :search-blocks [_window [_ repo q opts]]
   (search/search-blocks repo q opts))
@@ -691,8 +700,11 @@
 (defmethod handle :cancel-all-requests [_ args]
   (apply rsapi/cancel-all-requests (rest args)))
 
-(defmethod handle :default [args]
-  (logger/error "Error: no ipc handler for:" args))
+;; `handle` is dispatched with two arguments, so a one-argument :default threw an arity
+;; exception instead of logging -- and the exception was swallowed by set-ipc-handler!,
+;; hiding the unhandled channel entirely. Log the channel name rather than the window.
+(defmethod handle :default [_window args]
+  (logger/error "Error: no ipc handler for:" (first args)))
 
 (defn broadcast-persist-graph!
   "Receive graph-name (not graph path)
diff --git a/src/electron/electron/window.cljs b/src/electron/electron/window.cljs
index 6523d4ebc..880107326 100644
--- a/src/electron/electron/window.cljs
+++ b/src/electron/electron/window.cljs
@@ -14,6 +14,12 @@
 
 (defonce *quitting? (atom false))
 
+(def ^:private persist-dbs-timeout-ms
+  "How long close-handler waits for the renderer to confirm the graph cache was saved
+  before closing the window regardless. Generous enough for a large graph to serialize,
+  short enough that a user never faces a window that simply refuses to close."
+  10000)
+
 (def MAIN_WINDOW_ENTRY (if dev?
                          ;"http://localhost:3001"
                          (str "file://" (node-path/join js/__dirname "index.html"))
@@ -89,12 +95,17 @@
     (.send web-contents "persist-zoom-level" (.getZoomLevel web-contents))
     (.send web-contents "persistent-dbs"))
   (async/go
-    (let [_ (async/<! state/persistent-dbs-chan)]
+    ;; This runs after (.preventDefault e), so the window is already committed to not
+    ;; closing on its own. A bare <! here means any renderer that never answers -- because
+    ;; the save threw, or the renderer is wedged -- leaves the window permanently
+    ;; unclosable, with no message to the user. Time the wait out and close regardless:
+    ;; the graph's files on disk are the source of truth, the transit blob is a cache.
+    (let [timeout-ch (async/timeout persist-dbs-timeout-ms)
+          [_ port]   (async/alts! [state/persistent-dbs-chan timeout-ch])]
+      (when (identical? port timeout-ch)
+        (logger/error "Timed out after" persist-dbs-timeout-ms
+                      "ms waiting for the graph cache to be saved. Closing the window anyway; the next startup will re-index."))
       (destroy-window! win)
-      ;; (if @*quitting?
-      ;;   (doseq [win (get-all-windows)]
-      ;;     (destroy-window! win))
-      ;;   (destroy-window! win))
       (when @*quitting?
         (async/put! state/persistent-dbs-chan true)))))