//go:build windows && (amd64 || arm64) package nativehost import ( "encoding/json" "fmt" "os" "path/filepath" "runtime" "syscall" "time" "unicode/utf16" "unsafe" "clusterflow.dev/cfbrowser/api" "clusterflow.dev/cfbrowser/internal/capture" "clusterflow.dev/cfbrowser/internal/devtools" "clusterflow.dev/cfbrowser/protocol" "encoding/base64" "github.com/wailsapp/go-webview2/pkg/combridge" "github.com/wailsapp/go-webview2/webviewloader" "golang.org/x/sys/windows" ) // Slots are the published ICoreWebView2/Controller ABI, including IUnknown. // Only the loader and COM lifetime bridge are reused; no application bridge is installed. type winObject struct{ table *[64]uintptr } //go:uintptrescapes func (o *winObject) call(slot int, args ...uintptr) uintptr { all := append([]uintptr{uintptr(unsafe.Pointer(o))}, args...) hr, _, _ := syscall.SyscallN(o.table[slot], all...) runtime.KeepAlive(o) return hr } func (o *winObject) release() { if o != nil { o.call(2) } } func hrError(hr uintptr) error { if int32(hr) < 0 { return fmt.Errorf("WebView2 HRESULT 0x%08x", uint32(hr)) } return nil } type controllerCallback interface { Complete(uintptr, *winObject) uintptr } type navigationStartCallback interface { Started(*winObject, *winObject) uintptr } type navigationDoneCallback interface { Finished(*winObject, *winObject) uintptr } type protocolCallback interface { Completed(uintptr, *uint16) uintptr } type controllerDone struct{ fn func(uintptr, *winObject) } func (c *controllerDone) Complete(hr uintptr, o *winObject) uintptr { c.fn(hr, o); return 0 } type navStart struct{ fn func(*winObject) } func (c *navStart) Started(_ *winObject, args *winObject) uintptr { c.fn(args); return 0 } type navDone struct{ fn func(*winObject) } func (c *navDone) Finished(_ *winObject, args *winObject) uintptr { c.fn(args); return 0 } type cdpDone struct{ fn func(uintptr, *uint16) } func (c *cdpDone) Completed(hr uintptr, s *uint16) uintptr { c.fn(hr, s); return 0 } func init() { combridge.RegisterVTable[combridge.IUnknown, controllerCallback]("{6C4819F3-C9B7-4260-8127-C9F5BDE7F68C}", func(this, hr uintptr, o *winObject) uintptr { return combridge.Resolve[controllerCallback](this).Complete(hr, o) }) combridge.RegisterVTable[combridge.IUnknown, navigationStartCallback]("{9ADBE429-F36D-432B-9DDC-F8881FBD76E3}", func(this uintptr, sender, args *winObject) uintptr { return combridge.Resolve[navigationStartCallback](this).Started(sender, args) }) combridge.RegisterVTable[combridge.IUnknown, navigationDoneCallback]("{D33A35BF-1C49-4F98-93AB-006E0533FE1C}", func(this uintptr, sender, args *winObject) uintptr { return combridge.Resolve[navigationDoneCallback](this).Finished(sender, args) }) combridge.RegisterVTable[combridge.IUnknown, protocolCallback]("{5C4889F0-5EF6-4C5A-952C-D8F1B92D0574}", func(this, hr uintptr, s *uint16) uintptr { return combridge.Resolve[protocolCallback](this).Completed(hr, s) }) } var user32 = windows.NewLazySystemDLL("user32.dll") var registerClass = user32.NewProc("RegisterClassExW") var createWindow = user32.NewProc("CreateWindowExW") var defWindowProc = user32.NewProc("DefWindowProcW") var destroyWindow = user32.NewProc("DestroyWindow") var showWindow = user32.NewProc("ShowWindow") var peekMessage = user32.NewProc("PeekMessageW") var translateMessage = user32.NewProc("TranslateMessage") var dispatchMessage = user32.NewProc("DispatchMessageW") var adjustRect = user32.NewProc("AdjustWindowRectEx") var wndProc = windows.NewCallback(func(hwnd uintptr, msg uint32, wparam, lparam uintptr) uintptr { if msg == 0x0010 { showWindow.Call(hwnd, 0) return 0 } r, _, _ := defWindowProc.Call(hwnd, uintptr(msg), wparam, lparam) return r }) type winRect struct{ Left, Top, Right, Bottom int32 } type winPoint struct{ X, Y int32 } type winMessage struct { Window uintptr Message uint32 WParam, LParam uintptr Time uint32 Point winPoint Private uint32 } type winClass struct { Size, Style uint32 Procedure uintptr ClassExtra, WindowExtra int32 Instance, Icon, Cursor, Background uintptr Menu, Name *uint16 SmallIcon uintptr } type winPage struct { window uintptr controller, view *winObject start *combridge.ComObject[navigationStartCallback] finish *combridge.ComObject[navigationDoneCallback] startToken, finishToken int64 navigationID uint64 navigate func(string, error) closed bool } type Windows struct { options api.EngineOptions environment *winObject pages map[uint64]*winPage processes map[uint32]bool className *uint16 instance uintptr initialized bool closed bool temporary string } func NewWindows() (*Windows, error) { hr := windows.CoInitializeEx(0, windows.COINIT_APARTMENTTHREADED) if hr != nil { return nil, api.Err("BROWSER_RUNTIME_UNAVAILABLE", "WebView2 requires an STA UI thread") } w := &Windows{pages: map[uint64]*winPage{}, processes: map[uint32]bool{}, initialized: true} var module windows.Handle err := windows.GetModuleHandleEx(windows.GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT, nil, &module) if err != nil { w.Close() return nil, err } w.instance = uintptr(module) w.className, _ = windows.UTF16PtrFromString("CFBrowserNativeWebView2") class := winClass{Size: uint32(unsafe.Sizeof(winClass{})), Procedure: wndProc, Instance: w.instance, Name: w.className} r, _, err := registerClass.Call(uintptr(unsafe.Pointer(&class))) if r == 0 && err != windows.ERROR_CLASS_ALREADY_EXISTS { w.Close() return nil, err } return w, nil } type environmentDone struct { fn func(webviewloader.HRESULT, *webviewloader.ICoreWebView2Environment) } func (e *environmentDone) EnvironmentCompleted(hr webviewloader.HRESULT, env *webviewloader.ICoreWebView2Environment) webviewloader.HRESULT { e.fn(hr, env) return 0 } func (w *Windows) Configure(opts api.EngineOptions, done func(error)) { w.options = opts root := opts.DownloadDir if root == "" { var err error root, err = os.MkdirTemp("", "cfbrowser-webview2-") if err != nil { done(err) return } w.temporary = root } profile, err := filepath.Abs(filepath.Join(root, "webview2-profile")) if err != nil { done(err) return } args := "--disable-background-networking --disable-quic" if opts.NoSandbox { args += " --no-sandbox" } err = webviewloader.CreateCoreWebView2EnvironmentWithOptions(&environmentDone{fn: func(hr webviewloader.HRESULT, env *webviewloader.ICoreWebView2Environment) { if err := hrError(uintptr(uint32(hr))); err != nil { done(api.Err("BROWSER_RUNTIME_UNAVAILABLE", err.Error())) return } if env == nil { done(api.Err("BROWSER_RUNTIME_UNAVAILABLE", "WebView2 returned no environment")) return } if w.closed { done(api.Err("BROWSER_CLOSED", "worker is closing")) return } env.AddRef() w.environment = (*winObject)(unsafe.Pointer(env)) done(nil) }}, webviewloader.WithUserDataFolder(profile), webviewloader.WithAdditionalBrowserArguments(args), webviewloader.WithExclusiveUserDataFolderAccess(true)) if err != nil { done(api.Err("BROWSER_RUNTIME_UNAVAILABLE", "cannot create WebView2 environment; install the Evergreen WebView2 Runtime: "+err.Error())) } } func (w *Windows) NewPage(id uint64, done func(error)) { if w.environment == nil { done(api.Err("BROWSER_RUNTIME_UNAVAILABLE", "WebView2 environment is unavailable")) return } const style = 0x00CA0000 | 0x02000000 rect := winRect{Right: int32(w.options.ViewportWidth), Bottom: int32(w.options.ViewportHeight)} adjustRect.Call(uintptr(unsafe.Pointer(&rect)), style, 0, 0) title, _ := windows.UTF16PtrFromString("CFBrowser") hwnd, _, err := createWindow.Call(0, uintptr(unsafe.Pointer(w.className)), uintptr(unsafe.Pointer(title)), style, 0, 0, uintptr(rect.Right-rect.Left), uintptr(rect.Bottom-rect.Top), 0, 0, w.instance, 0) if hwnd == 0 { done(err) return } p := &winPage{window: hwnd} w.pages[id] = p callback := combridge.New[controllerCallback](&controllerDone{fn: func(hr uintptr, controller *winObject) { if err := hrError(hr); err != nil || controller == nil { _ = w.ClosePage(id) if err == nil { err = api.Err("BROWSER_RUNTIME_UNAVAILABLE", "WebView2 returned no controller") } done(err) return } controller.call(1) p.controller = controller if p.closed || w.closed { controller.call(24) controller.release() p.controller = nil done(api.Err("BROWSER_CLOSED", "page closed during startup")) return } if err := hrError(controller.call(25, uintptr(unsafe.Pointer(&p.view)))); err != nil { _ = w.ClosePage(id) done(err) return } if err := putControllerBounds(controller, winRect{Right: int32(w.options.ViewportWidth), Bottom: int32(w.options.ViewportHeight)}); err != nil { _ = w.ClosePage(id) done(err) return } if err := hrError(controller.call(4, 1)); err != nil { _ = w.ClosePage(id) done(err) return } var settings *winObject if err := hrError(p.view.call(3, uintptr(unsafe.Pointer(&settings)))); err != nil { _ = w.ClosePage(id) done(err) return } for _, slot := range []int{6, 8, 12, 16} { if err := hrError(settings.call(slot, 0)); err != nil { settings.release() _ = w.ClosePage(id) done(err) return } } settings.release() p.start = combridge.New[navigationStartCallback](&navStart{fn: func(args *winObject) { if p.navigate != nil { var navID uint64 if hrError(args.call(9, uintptr(unsafe.Pointer(&navID)))) == nil { p.navigationID = navID } } }}) p.finish = combridge.New[navigationDoneCallback](&navDone{fn: func(args *winObject) { if p.closed || p.navigate == nil { return } var navID uint64 if hrError(args.call(5, uintptr(unsafe.Pointer(&navID)))) != nil || navID != p.navigationID { return } var success int32 err := hrError(args.call(3, uintptr(unsafe.Pointer(&success)))) cb := p.navigate p.navigate = nil if err != nil || success == 0 { cb("", api.Err("BROWSER_NAVIGATION_FAILED", "WebView2 navigation failed")) return } url, err := p.source() cb(url, err) }}) if err := hrError(p.view.call(7, p.start.Ref(), uintptr(unsafe.Pointer(&p.startToken)))); err != nil { _ = w.ClosePage(id) done(err) return } if err := hrError(p.view.call(15, p.finish.Ref(), uintptr(unsafe.Pointer(&p.finishToken)))); err != nil { _ = w.ClosePage(id) done(err) return } var pid uint32 if hrError(p.view.call(37, uintptr(unsafe.Pointer(&pid)))) == nil && pid != 0 { w.processes[pid] = true } if !w.options.Headless { showWindow.Call(hwnd, 4) } done(nil) }}) err = hrError(w.environment.call(3, hwnd, callback.Ref())) _ = callback.Close() if err != nil { _ = w.ClosePage(id) done(err) } } func (p *winPage) source() (string, error) { var value *uint16 if err := hrError(p.view.call(4, uintptr(unsafe.Pointer(&value)))); err != nil { return "", err } defer windows.CoTaskMemFree(unsafe.Pointer(value)) return boundedUTF16(value, 8192) } func boundedUTF16(ptr *uint16, limit int) (string, error) { if ptr == nil { return "", nil } units := make([]uint16, 0, 256) for i := 0; i <= limit; i++ { c := *(*uint16)(unsafe.Add(unsafe.Pointer(ptr), i*2)) if c == 0 { return string(utf16.Decode(units)), nil } if i == limit { return "", api.Err("BROWSER_RESULT_LIMIT", "WebView2 string exceeds worker limit") } units = append(units, c) } return "", api.Err("BROWSER_INVALID_RESULT", "invalid UTF-16 string") } func (w *Windows) Navigate(id uint64, url, op string, done func(string, error)) { p := w.pages[id] if p == nil || p.closed || p.view == nil { done("", api.Err("BROWSER_PAGE_NOT_FOUND", "WebView2 page is closed")) return } if p.navigate != nil { old := p.navigate p.navigate = nil p.view.call(43) old("", api.Err("BROWSER_CANCELED", "navigation superseded")) } if op == "back" || op == "forward" { slot := 38 if op == "forward" { slot = 39 } var can int32 if err := hrError(p.view.call(slot, uintptr(unsafe.Pointer(&can)))); err != nil { done("", err) return } if can == 0 { value, err := p.source() done(value, err) return } } p.navigationID = 0 p.navigate = done var err error switch op { case "goto": var value *uint16 value, err = windows.UTF16PtrFromString(url) if err == nil { err = hrError(p.view.call(5, uintptr(unsafe.Pointer(value)))) } case "reload": err = hrError(p.view.call(31)) case "back": err = hrError(p.view.call(40)) case "forward": err = hrError(p.view.call(41)) default: err = api.Err("BROWSER_INVALID_ARGUMENT", "invalid navigation operation") } if err != nil { p.navigate = nil done("", err) } } func (w *Windows) Evaluate(id uint64, script string, done func(json.RawMessage, error)) { p := w.pages[id] if p == nil || p.closed || p.view == nil { done(nil, api.Err("BROWSER_PAGE_NOT_FOUND", "WebView2 page is closed")) return } CDPEvaluate(CDPCall(w.protocolCall(p)), script, done) } func (w *Windows) protocolCall(p *winPage) devtools.Call { return func(method string, params json.RawMessage, cb func(json.RawMessage, error)) { if p.closed || w.closed { cb(nil, api.Err("BROWSER_CLOSED", "page closed during evaluation")) return } methodPtr, err := windows.UTF16PtrFromString(method) if err != nil { cb(nil, err) return } paramsPtr, err := windows.UTF16PtrFromString(string(params)) if err != nil { cb(nil, err) return } responseLimit := protocol.MaxMessage if method == "Page.captureScreenshot" { responseLimit = base64.StdEncoding.EncodedLen(capture.MaxBytes) + 1024 } callback := combridge.New[protocolCallback](&cdpDone{fn: func(hr uintptr, value *uint16) { if err := hrError(hr); err != nil { cb(nil, err) return } s, err := boundedUTF16(value, responseLimit) cb(json.RawMessage(s), err) }}) err = hrError(p.view.call(36, uintptr(unsafe.Pointer(methodPtr)), uintptr(unsafe.Pointer(paramsPtr)), callback.Ref())) _ = callback.Close() if err != nil { cb(nil, err) } } } func (w *Windows) Input(id uint64, action, value string, x, y float64, done func(error)) { p := w.pages[id] if p == nil || p.closed || p.view == nil { done(api.Err("BROWSER_PAGE_NOT_FOUND", "WebView2 page is closed")) return } devtools.Input(w.protocolCall(p), action, value, x, y, done) } func (w *Windows) Capture(id uint64, full bool, done func([]byte, error)) { p := w.pages[id] if p == nil || p.closed || p.view == nil { done(nil, api.Err("BROWSER_PAGE_NOT_FOUND", "WebView2 page is closed")) return } devtools.Capture(w.protocolCall(p), full, done) } func (w *Windows) ClosePage(id uint64) error { p := w.pages[id] if p == nil { return nil } delete(w.pages, id) p.closed = true if p.navigate != nil { cb := p.navigate p.navigate = nil cb("", api.Err("BROWSER_CLOSED", "page closed")) } if p.view != nil { if p.start != nil { p.view.call(8, uintptr(p.startToken)) } if p.finish != nil { p.view.call(16, uintptr(p.finishToken)) } } if p.controller != nil { p.controller.call(24) } if p.start != nil { _ = p.start.Close() } if p.finish != nil { _ = p.finish.Close() } p.view.release() p.controller.release() p.view = nil p.controller = nil if p.window != 0 { destroyWindow.Call(p.window) p.window = 0 } return nil } func (w *Windows) Pump() error { for i := 0; i < 100; i++ { var message winMessage result, _, _ := peekMessage.Call(uintptr(unsafe.Pointer(&message)), 0, 0, 0, 1) if result == 0 { return nil } if message.Message == 0x12 { return api.Err("BROWSER_CLOSED", "Windows message loop stopped") } translateMessage.Call(uintptr(unsafe.Pointer(&message))) dispatchMessage.Call(uintptr(unsafe.Pointer(&message))) } return nil } func (w *Windows) Close() { if w.closed { return } w.closed = true for id := range w.pages { _ = w.ClosePage(id) } w.environment.release() w.environment = nil deadline := time.Now().Add(750 * time.Millisecond) for pid := range w.processes { process, err := windows.OpenProcess(windows.SYNCHRONIZE, false, pid) if err != nil { continue } for time.Now().Before(deadline) { state, _ := windows.WaitForSingleObject(process, 0) if state == windows.WAIT_OBJECT_0 { break } _ = w.Pump() time.Sleep(5 * time.Millisecond) } windows.CloseHandle(process) } if w.initialized { windows.CoUninitialize() w.initialized = false } if w.temporary != "" { _ = os.RemoveAll(w.temporary) } }