fix(proxy): use async communication for the ui

fix: name

fix: update naming

fix: add

Author: cenk1cenk2

lua/mcphub/extensions/proxy/init.lua

@@ -36,7 +36,7 @@ function M.get()
         url = "",
         headers = {},
         env = {},
-        alwaysAllow = true,
+        autoApprove = true,
     }
 end
 
@@ -89,99 +89,122 @@ function M.get_all_servers()
     return formatted_servers
 end
 
---- Call a tool via hub.
+--- Send result back to proxy.js via notification
+---@param request_id string The request ID to respond to
+---@param result table The result to send
+local function send_result(request_id, result)
+    vim.rpcnotify(0, "mcphub_proxy_result", request_id, result)
+end
+
+--- Async version of call_tool for proxy (uses nice UI)
+---@param request_id string Request ID for async response
 ---@param server_name string Name of the server
 ---@param tool_name string Name of the tool
 ---@param params table Parameters including arguments and caller context
----@return table Result or error
-function M.call_tool(server_name, tool_name, params)
-    local mcphub = require("mcphub")
-    local hub = mcphub.get_hub_instance()
-
-    if not hub or not hub:is_ready() then
-        return { error = "Hub is not ready" }
-    end
-
-    local arguments = params.arguments or {}
-    local caller = params.caller or { type = "proxy" }
-
-    -- Handle approval flow (synchronous version for RPC context)
-    local parsed_params = shared.parse_params({
-        server_name = server_name,
-        tool_name = tool_name,
-        tool_input = arguments,
-    }, "use_mcp_tool")
-
-    if #parsed_params.errors > 0 then
-        return { error = table.concat(parsed_params.errors, "\n") }
-    end
-
-    local approval = shared.handle_auto_approval_decision_sync(parsed_params)
-    if approval.error then
-        return { error = approval.error }
-    end
-
-    local result, err = hub:call_tool(server_name, tool_name, arguments, {
-        parse_response = false,
-        caller = vim.tbl_extend("force", caller, { auto_approve = approval.approve }),
-    })
-
-    if err then
-        return { error = err }
-    elseif result and result.result then
-        return result.result
-    elseif result then
-        return result
-    end
+function M.call_tool(request_id, server_name, tool_name, params)
+    local async = require("plenary.async")
+
+    async.run(function()
+        local mcphub = require("mcphub")
+        local hub = mcphub.get_hub_instance()
+
+        if not hub or not hub:is_ready() then
+            send_result(request_id, { error = "Hub is not ready" })
+            return
+        end
+
+        local arguments = params.arguments or {}
+        local caller = params.caller or { type = "proxy" }
+
+        -- Parse and validate params
+        local parsed_params = shared.parse_params({
+            server_name = server_name,
+            tool_name = tool_name,
+            tool_input = arguments,
+        }, "use_mcp_tool")
+
+        if #parsed_params.errors > 0 then
+            send_result(request_id, { error = table.concat(parsed_params.errors, "\n") })
+            return
+        end
+
+        -- Use the async approval with nice UI!
+        local approval = shared.handle_auto_approval_decision(parsed_params)
+        if approval.error then
+            send_result(request_id, { error = approval.error })
+            return
+        end
+
+        local result, err = hub:call_tool(server_name, tool_name, arguments, {
+            parse_response = false,
+            caller = vim.tbl_extend("force", caller, { auto_approve = approval.approve }),
+        })
 
-    return { error = "No result returned from hub" }
+        if err then
+            send_result(request_id, { error = err })
+        elseif result and result.result then
+            send_result(request_id, result.result)
+        elseif result then
+            send_result(request_id, result)
+        else
+            send_result(request_id, { error = "No result returned from hub" })
+        end
+    end)
 end
 
---- Access a resource via hub.
+--- Async version of access_resource for proxy (uses nice UI)
+---@param request_id string Request ID for async response
 ---@param server_name string Name of the server
 ---@param uri string Resource URI
 ---@param params? table Optional parameters including caller context
----@return table Result or error
-function M.access_resource(server_name, uri, params)
-    params = params or {}
-    local mcphub = require("mcphub")
-    local hub = mcphub.get_hub_instance()
-
-    if not hub or not hub:is_ready() then
-        return { error = "Hub is not ready" }
-    end
-
-    local caller = params.caller or { type = "proxy" }
-
-    -- Handle approval flow (same as codecompanion/avante)
-    local parsed_params = shared.parse_params({
-        server_name = server_name,
-        uri = uri,
-    }, "access_mcp_resource")
-
-    if #parsed_params.errors > 0 then
-        return { error = table.concat(parsed_params.errors, "\n") }
-    end
-
-    local approval = shared.handle_auto_approval_decision_sync(parsed_params)
-    if approval.error then
-        return { error = approval.error }
-    end
-
-    local result, err = hub:access_resource(server_name, uri, {
-        parse_response = false,
-        caller = vim.tbl_extend("force", caller, { auto_approve = approval.approve }),
-    })
-
-    if err then
-        return { error = err }
-    elseif result and result.result then
-        return result.result
-    elseif result then
-        return result
-    end
+function M.access_resource(request_id, server_name, uri, params)
+    local async = require("plenary.async")
+
+    async.run(function()
+        params = params or {}
+        local mcphub = require("mcphub")
+        local hub = mcphub.get_hub_instance()
+
+        if not hub or not hub:is_ready() then
+            send_result(request_id, { error = "Hub is not ready" })
+            return
+        end
+
+        local caller = params.caller or { type = "proxy" }
+
+        -- Parse and validate params
+        local parsed_params = shared.parse_params({
+            server_name = server_name,
+            uri = uri,
+        }, "access_mcp_resource")
+
+        if #parsed_params.errors > 0 then
+            send_result(request_id, { error = table.concat(parsed_params.errors, "\n") })
+            return
+        end
+
+        -- Use the async approval with nice UI!
+        local approval = shared.handle_auto_approval_decision(parsed_params)
+        if approval.error then
+            send_result(request_id, { error = approval.error })
+            return
+        end
+
+        local result, err = hub:access_resource(server_name, uri, {
+            parse_response = false,
+            caller = vim.tbl_extend("force", caller, { auto_approve = approval.approve }),
+        })
 
-    return { error = "No result returned from hub" }
+        if err then
+            send_result(request_id, { error = err })
+        elseif result and result.result then
+            send_result(request_id, result.result)
+        elseif result then
+            send_result(request_id, result)
+        else
+            send_result(request_id, { error = "No result returned from hub" })
+        end
+    end)
 end
 
 --- Get a prompt via hub.

lua/mcphub/extensions/shared.lua

@@ -292,107 +292,6 @@ function M.show_mcp_tool_prompt(params)
     return confirmed, cancelled
 end
 
---- Synchronous version for RPC context (can't use async UI)
----@param params MCPHub.ParsedParams
----@return boolean confirmed
----@return boolean cancelled
-function M.show_mcp_tool_prompt_sync(params)
-    local action_name = params.action
-    local server_name = params.server_name
-    local tool_name = params.tool_name
-    local uri = params.uri
-    local arguments = params.arguments or {}
-
-    local lines = {}
-    local is_tool = action_name == "use_mcp_tool"
-
-    -- Header as a question
-    local header_line = NuiLine()
-    header_line:append(Text.icons.event, Text.highlights.warn)
-    header_line:append(" Do you want to ", Text.highlights.text)
-    if is_tool then
-        header_line:append("call ", Text.highlights.text)
-        header_line:append(tool_name, Text.highlights.warn_italic)
-    else
-        header_line:append("access ", Text.highlights.text)
-        header_line:append(uri, Text.highlights.link)
-    end
-    header_line:append(" on ", Text.highlights.text)
-    header_line:append(server_name, Text.highlights.success_italic)
-    header_line:append("?", Text.highlights.text)
-    table.insert(lines, header_line)
-
-    -- Parameters section
-    if is_tool and next(arguments) then
-        table.insert(lines, NuiLine():append(""))
-
-        for key, value in pairs(arguments) do
-            -- Parameter name
-            local param_name_line = NuiLine()
-            param_name_line:append(Text.icons.param, Text.highlights.info)
-            param_name_line:append(" " .. key .. ":", Text.highlights.json_property)
-            table.insert(lines, param_name_line)
-
-            -- Parameter value
-            local function add_value_lines(val)
-                if type(val) == "string" then
-                    local value_lines = val:find("\n") and vim.split(val, "\n", { plain = true })
-                        or { '"' .. val .. '"' }
-                    for _, line in ipairs(value_lines) do
-                        local value_line = NuiLine()
-                        value_line:append("    " .. line, Text.highlights.json_string)
-                        table.insert(lines, value_line)
-                    end
-                elseif type(val) == "boolean" then
-                    local value_line = NuiLine()
-                    value_line:append("    " .. tostring(val), Text.highlights.json_boolean)
-                    table.insert(lines, value_line)
-                elseif type(val) == "number" then
-                    local value_line = NuiLine()
-                    value_line:append("    " .. tostring(val), Text.highlights.json_number)
-                    table.insert(lines, value_line)
-                else
-                    for _, line in ipairs(vim.split(vim.inspect(val), "\n", { plain = true })) do
-                        local value_line = NuiLine()
-                        value_line:append("    " .. line, Text.highlights.muted)
-                        table.insert(lines, value_line)
-                    end
-                end
-            end
-
-            add_value_lines(value)
-            table.insert(lines, NuiLine():append(""))
-        end
-    end
-
-    -- Fire event before showing confirmation window
-    utils.fire("MCPHubApprovalWindowOpened", {
-        action = action_name,
-        server_name = server_name,
-        tool_name = tool_name,
-        uri = uri,
-        arguments = arguments,
-    })
-
-    local confirmed, cancelled = ui_utils.confirm_sync(lines, {
-        min_width = 70,
-        max_width = 100,
-    })
-
-    -- Fire event after user makes decision
-    utils.fire("MCPHubApprovalWindowClosed", {
-        action = action_name,
-        server_name = server_name,
-        tool_name = tool_name,
-        uri = uri,
-        arguments = arguments,
-        confirmed = confirmed,
-        cancelled = cancelled,
-    })
-
-    return confirmed, cancelled
-end
-
 --- Check auto-approval status without showing any dialog
 ---@param parsed_params MCPHub.ParsedParams
 ---@return {error?:string, approve:boolean}
@@ -437,22 +336,4 @@ function M.handle_auto_approval_decision(parsed_params)
     return status
 end
 
---- Synchronous version for RPC context (can't use async UI)
----@param parsed_params MCPHub.ParsedParams
----@return {error?:string, approve:boolean}
-function M.handle_auto_approval_decision_sync(parsed_params)
-    local status = M.check_auto_approval(parsed_params)
-
-    if status.error then
-        return { error = status.error or "Something went wrong with auto-approval", approve = false }
-    end
-
-    if status.approve == false and parsed_params.needs_confirmation_window then
-        local confirmed, _ = M.show_mcp_tool_prompt_sync(parsed_params)
-        return { error = not confirmed and "User cancelled the operation", approve = confirmed }
-    end
-
-    return status
-end
-
 return M