Skip to content

Open-source LLM knowledge platform: turn raw documents into a queryable RAG, an autonomous reasoning agent, and a self-maintaining Wiki.

fix(desktop): pair the Lite browser against the local API listener (#3677)

nullptr-error65d8a34ead4c
diff --git a/cmd/desktop/main.go b/cmd/desktop/main.go
index f0b7e640a..8efa7f2e8 100644
--- a/cmd/desktop/main.go
+++ b/cmd/desktop/main.go
@@ -340,7 +340,7 @@ func main() {
// Wait for the backend URL to be set
targetURL, _ := url.Parse(app.backendURL)
- proxy := httputil.NewSingleHostReverseProxy(targetURL)
+ proxy := desktopAPIProxy(targetURL)
// Start Wails application
// We use a Reverse Proxy to seamlessly proxy Wails' frontend to our Go backend
@@ -443,6 +443,26 @@ func resolveDesktopDataPath(rawPath, defaultRelativePath, appSupportDir string)
return filepath.Join(appSupportDir, filepath.Clean(trimmed))
}
+// desktopAPIProxy forwards the webview to the loopback Gin server. Pairing
+// needs the API listener as Host so the link cannot be aimed at another
+// machine. Other routes keep the page Host (wails.localhost), which OIDC
+// callbacks and embed origin checks still compare against.
+func desktopAPIProxy(target *url.URL) *httputil.ReverseProxy {
+ return &httputil.ReverseProxy{
+ Rewrite: func(r *httputil.ProxyRequest) {
+ r.SetURL(target)
+ r.SetXForwarded()
+ if !isBrowserPairingRequest(r.In) {
+ r.Out.Host = r.In.Host
+ }
+ },
+ }
+}
+
+func isBrowserPairingRequest(req *http.Request) bool {
+ return req != nil && req.URL != nil && req.Method == http.MethodPost && req.URL.Path == "/api/v1/me/browser"
+}
+
// desktopBackendListenAddr returns the TCP address for the embedded Gin server (Wails desktop).
// Binds 127.0.0.1 by default, or 0.0.0.0 when http_bind_public is set in desktop-prefs.json.
func desktopBackendListenAddr() string {
diff --git a/cmd/desktop/proxy_test.go b/cmd/desktop/proxy_test.go
new file mode 100644
index 000000000..529af6d93
--- /dev/null
+++ b/cmd/desktop/proxy_test.go
@@ -0,0 +1,61 @@
+//go:build !bindings
+
+package main
+
+import (
+ "io"
+ "net/http"
+ "net/http/httptest"
+ "net/url"
+ "testing"
+
+ "github.com/stretchr/testify/require"
+)
+
+func TestDesktopAPIProxyRewritesWailsHostToLoopback(t *testing.T) {
+ var got string
+ backend := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ got = r.Host
+ w.WriteHeader(http.StatusNoContent)
+ }))
+ defer backend.Close()
+
+ target, err := url.Parse(backend.URL)
+ require.NoError(t, err)
+ front := httptest.NewServer(desktopAPIProxy(target))
+ defer front.Close()
+
+ req, err := http.NewRequest(http.MethodPost, front.URL+"/api/v1/me/browser", nil)
+ require.NoError(t, err)
+ req.Host = "wails.localhost"
+ resp, err := front.Client().Do(req)
+ require.NoError(t, err)
+ _, _ = io.Copy(io.Discard, resp.Body)
+ require.NoError(t, resp.Body.Close())
+ require.Equal(t, http.StatusNoContent, resp.StatusCode)
+ require.Equal(t, target.Host, got)
+}
+
+func TestDesktopAPIProxyKeepsHostForOtherRoutes(t *testing.T) {
+ var got string
+ backend := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ got = r.Host
+ w.WriteHeader(http.StatusNoContent)
+ }))
+ defer backend.Close()
+
+ target, err := url.Parse(backend.URL)
+ require.NoError(t, err)
+ front := httptest.NewServer(desktopAPIProxy(target))
+ defer front.Close()
+
+ req, err := http.NewRequest(http.MethodGet, front.URL+"/api/v1/auth/oidc/start", nil)
+ require.NoError(t, err)
+ req.Host = "wails.localhost"
+ resp, err := front.Client().Do(req)
+ require.NoError(t, err)
+ _, _ = io.Copy(io.Discard, resp.Body)
+ require.NoError(t, resp.Body.Close())
+ require.Equal(t, http.StatusNoContent, resp.StatusCode)
+ require.Equal(t, "wails.localhost", got)
+}
diff --git a/frontend/src/utils/browserPairingOrigin.test.mjs b/frontend/src/utils/browserPairingOrigin.test.mjs
new file mode 100644
index 000000000..fa3c08301
--- /dev/null
+++ b/frontend/src/utils/browserPairingOrigin.test.mjs
@@ -0,0 +1,35 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+
+import { pairingPageOrigin, preferredDesktopAPIBase } from './browserPairingOrigin.ts'
+
+test('pairingPageOrigin keeps an http or https page', () => {
+ assert.equal(pairingPageOrigin('https://weknora.example'), 'https://weknora.example')
+ assert.equal(pairingPageOrigin('http://127.0.0.1:8080'), 'http://127.0.0.1:8080')
+})
+
+test('pairingPageOrigin uses the desktop API host when the page is the Wails shell', () => {
+ assert.equal(
+ pairingPageOrigin('wails://wails.localhost', 'http://127.0.0.1:53124/api/v1'),
+ 'http://127.0.0.1:53124',
+ )
+})
+
+test('pairingPageOrigin leaves a non-http page alone when no API base is known', () => {
+ assert.equal(pairingPageOrigin('wails://wails.localhost', ''), 'wails://wails.localhost')
+})
+
+test('pairingPageOrigin ignores a non-loopback API base for the Wails shell', () => {
+ assert.equal(
+ pairingPageOrigin('wails://wails.localhost', 'https://evil.example/api/v1'),
+ 'wails://wails.localhost',
+ )
+})
+
+test('preferredDesktopAPIBase uses the native binding before the page global', () => {
+ assert.equal(
+ preferredDesktopAPIBase('http://127.0.0.1:53124/api/v1', 'https://evil.example/api/v1'),
+ 'http://127.0.0.1:53124/api/v1',
+ )
+ assert.equal(preferredDesktopAPIBase('', 'http://127.0.0.1:53124/api/v1'), 'http://127.0.0.1:53124/api/v1')
+})
diff --git a/frontend/src/utils/browserPairingOrigin.ts b/frontend/src/utils/browserPairingOrigin.ts
new file mode 100644
index 000000000..35b7805ae
--- /dev/null
+++ b/frontend/src/utils/browserPairingOrigin.ts
@@ -0,0 +1,41 @@
+const loopbackHosts = new Set(['localhost', '127.0.0.1', '::1'])
+
+function isLoopbackHostname(hostname: string): boolean {
+ return loopbackHosts.has(hostname.replace(/^\[|\]$/g, '').toLowerCase())
+}
+
+// Native GetAPIBaseURL is the desktop listener. The page global is only a
+// fallback, because any script in the Lite window can overwrite it.
+export function preferredDesktopAPIBase(nativeBase?: string | null, injectedBase?: string | null): string {
+ const native = (nativeBase ?? '').trim()
+ if (native) return native
+ return (injectedBase ?? '').trim()
+}
+
+// The pairing link is a WebSocket the Chrome extension dials. A normal site
+// uses the page origin so a proxy port is preserved. The Lite window is
+// wails://wails.localhost, which cannot become ws/wss, so a loopback desktop
+// API base supplies the origin instead.
+export function pairingPageOrigin(pageOrigin: string, apiBase?: string): string {
+ try {
+ const page = new URL(pageOrigin)
+ if (page.protocol === 'http:' || page.protocol === 'https:') {
+ return page.origin
+ }
+ } catch {
+ /* custom schemes and empty origins fall through */
+ }
+ const base = (apiBase || '').trim()
+ if (!base) {
+ return pageOrigin
+ }
+ try {
+ const api = new URL(base)
+ if ((api.protocol !== 'http:' && api.protocol !== 'https:') || !isLoopbackHostname(api.hostname)) {
+ return pageOrigin
+ }
+ return api.origin
+ } catch {
+ return pageOrigin
+ }
+}
diff --git a/frontend/src/views/settings/BrowserConnectionSettings.vue b/frontend/src/views/settings/BrowserConnectionSettings.vue
index 7488ae9a8..b18348662 100644
--- a/frontend/src/views/settings/BrowserConnectionSettings.vue
+++ b/frontend/src/views/settings/BrowserConnectionSettings.vue
@@ -168,6 +168,7 @@
import { computed, onMounted, onBeforeUnmount, ref } from 'vue'
import { useI18n } from 'vue-i18n'
import { get, post, getDown } from '@/utils/request'
+import { pairingPageOrigin, preferredDesktopAPIBase } from '@/utils/browserPairingOrigin'
import { useBrowserConnectionStore } from '@/stores/browserConnection'
import { useUIStore } from '@/stores/ui'
import browserLogo from '@/assets/browserskill/logo.png'
@@ -206,6 +207,22 @@ const capabilities = [
]
const formatDate = (value: string) => new Date(value).toLocaleString(locale.value, { dateStyle: 'short', timeStyle: 'short' })
function clearPairing() { pairing.value = ''; copied.value = false; copyFallback.value = false; clearTimeout(expiry) }
+async function desktopApiBase(): Promise<string> {
+ const win = window as Window & {
+ __WEKNORA_API_BASE__?: string
+ go?: { main?: { App?: { GetAPIBaseURL?: () => Promise<string> | string } } }
+ }
+ let native = ''
+ const fn = win.go?.main?.App?.GetAPIBaseURL
+ if (typeof fn === 'function') {
+ try {
+ native = String(await Promise.resolve(fn()) || '')
+ } catch {
+ native = ''
+ }
+ }
+ return preferredDesktopAPIBase(native, win.__WEKNORA_API_BASE__)
+}
async function refresh() {
try {
if (!busy.value && !document.hidden) {
@@ -225,7 +242,8 @@ async function pair() {
busy.value = true; error.value = ''; revision++
try {
if (!pairing.value || Date.now() >= pairExpires) {
- const result = await post<{ data: { pairing_link: string } }>(endpoint, { action: 'pair', origin: window.location.origin }, { timeout: 15000, signal: controller.signal })
+ const origin = pairingPageOrigin(window.location.origin, await desktopApiBase())
+ const result = await post<{ data: { pairing_link: string } }>(endpoint, { action: 'pair', origin }, { timeout: 15000, signal: controller.signal })
if (!alive) return
pairing.value = result.data.pairing_link; pairExpires = Date.now() + 5 * 60 * 1000
clearTimeout(expiry); expiry = setTimeout(clearPairing, 5 * 60 * 1000)
diff --git a/internal/handler/session/browserskill.go b/internal/handler/session/browserskill.go
index 60d266f38..95371d4bc 100644
--- a/internal/handler/session/browserskill.go
+++ b/internal/handler/session/browserskill.go
@@ -2,7 +2,11 @@ package session
import (
"context"
+ "net"
"net/http"
+ "net/url"
+ "strconv"
+ "strings"
"time"
"github.com/Tencent/WeKnora/internal/browserskill"
@@ -10,6 +14,115 @@ import (
"github.com/gin-gonic/gin"
)
+// pairingOrigin chooses the WebSocket host the extension will dial.
+// A loopback API listener always wins, so a Lite page cannot point the
+// extension at another host. A public page origin is kept only when its
+// hostname is the request host; the port still comes from that page so a
+// reverse proxy can preserve the external port.
+func pairingOrigin(r *http.Request, page string) string {
+ host := ""
+ if r != nil {
+ host = r.Host
+ }
+ if isLoopbackHostname(requestHostname(host)) {
+ if origin, ok := loopbackPairingOrigin(host); ok {
+ return origin
+ }
+ return ""
+ }
+ if origin, ok := pageOriginMatchingHost(page, host); ok {
+ return origin
+ }
+ if isHTTPOrigin(page) {
+ if origin := requestHTTPOrigin(r); origin != "" {
+ return origin
+ }
+ }
+ return page
+}
+
+func requestHostname(host string) string {
+ if parsed, _, err := net.SplitHostPort(host); err == nil {
+ return parsed
+ }
+ return host
+}
+
+func isLoopbackHostname(hostname string) bool {
+ switch strings.ToLower(hostname) {
+ case "localhost", "127.0.0.1", "::1":
+ return true
+ default:
+ return false
+ }
+}
+
+func loopbackPairingOrigin(host string) (string, bool) {
+ host = strings.TrimSpace(host)
+ if host == "" || strings.ContainsAny(host, " \t\r\n/@\\") {
+ return "", false
+ }
+ hostname, port := host, ""
+ if parsed, parsedPort, err := net.SplitHostPort(host); err == nil {
+ hostname, port = parsed, parsedPort
+ }
+ if port != "" {
+ n, err := strconv.Atoi(port)
+ if err != nil || n < 1 || n > 65535 || strconv.Itoa(n) != port {
+ return "", false
+ }
+ }
+ switch strings.ToLower(hostname) {
+ case "localhost", "127.0.0.1":
+ if port == "" {
+ return "http://" + hostname, true
+ }
+ return "http://" + hostname + ":" + port, true
+ case "::1":
+ if port == "" {
+ return "http://[::1]", true
+ }
+ return "http://[::1]:" + port, true
+ default:
+ return "", false
+ }
+}
+
+func pageOriginMatchingHost(page, requestHost string) (string, bool) {
+ u, err := url.Parse(page)
+ if err != nil || u.User != nil || u.Host == "" || (u.Scheme != "http" && u.Scheme != "https") {
+ return "", false
+ }
+ reqName := requestHostname(requestHost)
+ if reqName == "" || !strings.EqualFold(u.Hostname(), reqName) {
+ return "", false
+ }
+ return u.Scheme + "://" + u.Host, true
+}
+
+func isHTTPOrigin(page string) bool {
+ u, err := url.Parse(page)
+ return err == nil && u.Host != "" && (u.Scheme == "http" || u.Scheme == "https")
+}
+
+func requestHTTPOrigin(r *http.Request) string {
+ if r == nil {
+ return ""
+ }
+ host := strings.TrimSpace(r.Host)
+ if host == "" || strings.ContainsAny(host, " \t\r\n/@\\") {
+ return ""
+ }
+ if _, err := url.ParseRequestURI("http://" + host + "/"); err != nil {
+ return ""
+ }
+ scheme := "http"
+ if r.TLS != nil || strings.EqualFold(r.Header.Get("X-Forwarded-Proto"), "https") {
+ scheme = "https"
+ }
+ return scheme + "://" + host
+}
+
func browserSkillScope(ctx context.Context) browserskill.Scope {
tenant, _ := types.TenantIDFromContext(ctx)
user, _ := types.UserIDFromContext(ctx)
@@ -120,7 +233,7 @@ func (h *Handler) BrowserSkillAccount(c *gin.Context) {
}
switch input.Action {
case "pair":
- link, err := h.browserSkill.Pair(ctx, scope, input.Origin)
+ link, err := h.browserSkill.Pair(ctx, scope, pairingOrigin(c.Request, input.Origin))
if err != nil {
c.JSON(http.StatusConflict, gin.H{"error": err.Error()})
return
diff --git a/internal/handler/session/browserskill_test.go b/internal/handler/session/browserskill_test.go
index 2549b318e..8270aca42 100644
--- a/internal/handler/session/browserskill_test.go
+++ b/internal/handler/session/browserskill_test.go
@@ -33,6 +33,31 @@ func TestBrowserAccountStatusDoesNotRequireConversation(t *testing.T) {
require.False(t, payload.Data.Connected)
}
+func TestPairingOriginUsesLoopbackListenerForWailsPage(t *testing.T) {
+ req := httptest.NewRequest("POST", "http://127.0.0.1:53124/api/v1/me/browser", nil)
+ req.Host = "127.0.0.1:53124"
+ require.Equal(t, "http://127.0.0.1:53124", pairingOrigin(req, "wails://wails.localhost"))
+
+ req.Host = "[::1]:8080"
+ require.Equal(t, "http://[::1]:8080", pairingOrigin(req, "wails://wails.localhost"))
+
+ req.Host = "weknora.example"
+ require.Equal(t, "wails://wails.localhost", pairingOrigin(req, "wails://wails.localhost"))
+ require.Equal(t, "https://weknora.example", pairingOrigin(req, "https://weknora.example"))
+ require.Equal(t, "https://weknora.example:8443", pairingOrigin(req, "https://weknora.example:8443"))
+}
+
+func TestPairingOriginIgnoresForeignHostOnLoopback(t *testing.T) {
+ req := httptest.NewRequest("POST", "http://127.0.0.1:53124/api/v1/me/browser", nil)
+ req.Host = "127.0.0.1:53124"
+ require.Equal(t, "http://127.0.0.1:53124", pairingOrigin(req, "https://evil.example"))
+ require.Equal(t, "http://127.0.0.1:53124", pairingOrigin(req, "http://127.0.0.1:9"))
+
+ req.Host = "weknora.example"
+ require.NotEqual(t, "https://evil.example", pairingOrigin(req, "https://evil.example"))
+ require.Equal(t, "http://weknora.example", pairingOrigin(req, "https://evil.example"))
+}
+
func TestBrowserAccountRequiresUser(t *testing.T) {
h := &Handler{browserSkill: browserskill.NewManager()}
response := httptest.NewRecorder()