Fix empty Settings -> MCPs tab on tool-window reopen (#22)

The host caches tool/serverUpdated notifications under
[:session :mcp-servers] but only re-broadcast them reactively, so the
React mcp.servers slice sat empty whenever the tool window was
re-opened (or the user navigated to Settings -> MCPs) after all
notifications had already fired. webview/ready now replays the cached
roster as tool/serversUpdated.

Also stops on-initialized from clobbering the whole :session map with
(fn [_] {...}). It now merges, so notifications that arrive ahead of
the initialized reply (cached MCP servers come up fast) no longer get
wiped.

Closes #22.

Author: ericdallo

CHANGELOG.md

@@ -2,6 +2,7 @@
 
 ## [Unreleased]
 
+- Fix empty Settings → MCPs tab on tool-window reopen (#22). `webview/ready` now replays the cached MCP roster as `tool/serversUpdated`, and `on-initialized` merges into `:session` instead of clobbering it (notifications that race ahead of `initialized` no longer get wiped).
 - Bump `eca-webview`: shrink the welcome-message logo and left-align the welcome text block, while keeping the logo and any markdown heading centered.
 
 ## 0.26.13

src/main/clojure/dev/eca/eca_intellij/server.clj

@@ -105,12 +105,20 @@
     (logger/info "Downloaded eca to" dest-path)))
 
 (defn ^:private on-initialized [result project]
-  (db/update-in project [:session] (fn [_]
-                                     {:models (:models result)
-                                      :chat-agents (:chat-agents result)
-                                      :chat-selected-agent (:chat-default-agent result)
-                                      :chat-selected-model (:chat-default-model result)
-                                      :welcome-message (:chat-welcome-message result)})))
+  ;; Merge on top of the existing session map instead of replacing it
+  ;; wholesale -- a wholesale replace silently wipes any keys populated
+  ;; before `initialized` completes (notably `:mcp-servers`, which
+  ;; `webview.clj`'s tool-server-updated defmethod fills in from
+  ;; reactive `tool/serverUpdated` notifications that can race ahead of
+  ;; this callback). Wiping that map then leaves the Settings -> MCPs
+  ;; tab empty after webview/ready replay until the next notification
+  ;; arrives. Closes #22.
+  (db/update-in project [:session]
+                #(merge % {:models (:models result)
+                           :chat-agents (:chat-agents result)
+                           :chat-selected-agent (:chat-default-agent result)
+                           :chat-selected-model (:chat-default-model result)
+                           :welcome-message (:chat-welcome-message result)})))
 
 (defn ^:private env []
   (let [env (EnvironmentUtil/getEnvironmentMap)

src/main/clojure/dev/eca/eca_intellij/webview.clj

@@ -189,6 +189,17 @@
         (handle-server-status-changed (db/get-in project [:status])
                                       project)
         (handle-config-changed project (db/get-in project [:server-config]))
+        ;; Replay the cached MCP server roster. `tool/serverUpdated`
+        ;; notifications from the ECA server are reactive-only -- if the
+        ;; tool window is re-opened (or the user navigates to Settings ->
+        ;; MCPs) after all notifications have already fired, the React
+        ;; Redux slice would otherwise sit empty until the next change.
+        ;; Mirrors the broadcast shape used by tool-server-updated /
+        ;; tool-server-removed so consumers converge through the same code
+        ;; path. `vec` so an empty cache serialises as `[]` instead of
+        ;; `null`, which the React slice cannot iterate over. Closes #22.
+        (send-msg! project {:type "tool/serversUpdated"
+                            :data (vec (vals (db/get-in project [:session :mcp-servers])))})
         ;; send current opened editor if any
         (when-let [editor (current-selected-editor project)]
           (on-focus-changed editor nil))

src/test/clojure/dev/eca/eca_intellij/server_lifecycle_test.clj

@@ -60,3 +60,32 @@
   (fixt/with-test-project [project
                            :initial-db {:status :starting}]
     (is (= :starting (server/status project)))))
+
+(deftest on-initialized-preserves-mcp-servers-cache
+  (testing "Regression: issue #22. Before the fix, on-initialized did
+            `(update-in [:session] (fn [_] {...}))` which wiped any
+            keys populated before `initialized` completed. The ECA
+            server can send `tool/serverUpdated` notifications ahead
+            of the `initialized` reply (especially for cached MCP
+            servers that come up fast), so wiping `:mcp-servers`
+            here was the root cause of the empty Settings -> MCPs
+            tab. on-initialized must MERGE into the existing
+            session, not replace it."
+    (fixt/with-test-project [project
+                             :initial-db {:session
+                                          {:mcp-servers
+                                           {"foo" {:name "foo"
+                                                   :status "running"}}}}]
+      (#'server/on-initialized {:models [{:id "claude"}]
+                                :chat-agents [{:id "agent"}]
+                                :chat-default-agent "agent"
+                                :chat-default-model "claude"
+                                :chat-welcome-message "hi"}
+                               project)
+      (let [session (db/get-in project [:session])]
+        (is (= {"foo" {:name "foo" :status "running"}}
+               (:mcp-servers session))
+            ":mcp-servers populated before initialized MUST survive")
+        (is (= [{:id "claude"}] (:models session)))
+        (is (= "claude" (:chat-selected-model session)))
+        (is (= "hi" (:welcome-message session)))))))

src/test/clojure/dev/eca/eca_intellij/webview_lifecycle_test.clj

@@ -73,6 +73,46 @@
           ":webview key in :on-focus-changed-fns is what cursor-editor-listener fans
            out to; missing -> no live editor-focus updates to the chat"))))
 
+(deftest webview-ready-replays-cached-mcp-servers
+  (testing "Regression: issue #22. `tool/serverUpdated` LSP
+            notifications are reactive-only; if the tool window is
+            re-opened (or the user opens Settings -> MCPs) after all
+            notifications have already fired, the React `mcp.servers`
+            slice would otherwise sit empty. `webview/ready` must
+            replay the cached roster as `tool/serversUpdated` so the
+            settings tab is never blank when servers actually exist."
+    (fixt/with-test-project [project
+                             :initial-db {:session
+                                          {:mcp-servers
+                                           {"foo" {:name "foo"
+                                                   :type "mcp"
+                                                   :status "running"
+                                                   :tools []}
+                                            "bar" {:name "bar"
+                                                   :type "mcp"
+                                                   :status "stopped"
+                                                   :tools []}}}}]
+      (fixt/with-stub-bridge bridge
+        (webview/handle (fixt/to-json-payload {:type "webview/ready"}) project)
+        (let [out (fixt/last-to-webview-of-type bridge "tool/serversUpdated")]
+          (is (some? out)
+              "webview/ready MUST emit tool/serversUpdated even with no live notification")
+          (is (= #{"foo" "bar"}
+                 (->> (:data out) (map :name) set))
+              "all cached MCP servers must be replayed"))))))
+
+(deftest webview-ready-emits-empty-mcp-list-when-no-servers
+  (testing "With an empty cache the replay still fires (just with an
+            empty list). This keeps the webview's mcp.servers slice
+            consistent with the host's truth-of-record on every ready
+            handshake and lets the React side clear any stale rows."
+    (fixt/with-test-project [project]
+      (fixt/with-stub-bridge bridge
+        (webview/handle (fixt/to-json-payload {:type "webview/ready"}) project)
+        (let [out (fixt/last-to-webview-of-type bridge "tool/serversUpdated")]
+          (is (some? out))
+          (is (= [] (:data out))))))))
+
 (deftest webview-ready-subscribes-log-store-with-replace-semantics
   (testing "Re-delivery of webview/ready (e.g. tool-window re-open) must
             replace the prior :webview log subscriber, not stack a