//go:build darwin && (amd64 || arm64) package nativehost import ( "encoding/json" "fmt" "unsafe" "clusterflow.dev/cfbrowser/api" "clusterflow.dev/cfbrowser/internal/capture" "clusterflow.dev/cfbrowser/protocol" "github.com/ebitengine/purego" "github.com/ebitengine/purego/objc" ) type cocoaPoint struct{ X, Y float64 } type cocoaSize struct{ Width, Height float64 } type cocoaRect struct { Origin cocoaPoint Size cocoaSize } func selector(name string) objc.SEL { return objc.RegisterName(name) } func send(id objc.ID, name string, args ...any) objc.ID { return id.Send(selector(name), args...) } func class(name string) objc.ID { return objc.ID(objc.GetClass(name)) } func retain(id objc.ID) objc.ID { return send(id, "retain") } func release(id objc.ID) { if id != 0 { send(id, "release") } } func nsString(s string) objc.ID { return send(class("NSString"), "stringWithUTF8String:", s) } // Objective-C blocks contain only a numeric token, never a Go heap pointer. // The framework copies the heap block; its final release belongs to WebKit. type objcBlock struct { Isa uintptr Flags, Reserved int32 Invoke uintptr Descriptor unsafe.Pointer Token uint64 } type blockDescriptor struct { Reserved, Size uintptr Signature unsafe.Pointer } type cocoaPage struct { view, window, delegate, navigation objc.ID navigate func(string, error) blocks map[uint64]bool } type Darwin struct { options api.EngineOptions app, pool, store, world, mode objc.ID delegateClass objc.Class pages map[uint64]*cocoaPage byView map[objc.ID]*cocoaPage blocks map[uint64]func(objc.ID, objc.ID) nextBlock uint64 blockISA, blockInvoke uintptr descriptor unsafe.Pointer malloc func(uintptr) unsafe.Pointer free func(unsafe.Pointer) copyBlock func(unsafe.Pointer) unsafe.Pointer releaseBlock func(unsafe.Pointer) closed bool } // NewDarwin must execute on the process main OS thread, pinned in main.init. func NewDarwin() (*Darwin, error) { for _, path := range []string{"/System/Library/Frameworks/Cocoa.framework/Cocoa", "/System/Library/Frameworks/WebKit.framework/WebKit"} { if _, err := purego.Dlopen(path, purego.RTLD_NOW|purego.RTLD_GLOBAL); err != nil { return nil, api.Err("BROWSER_RUNTIME_UNAVAILABLE", err.Error()) } } d := &Darwin{pages: map[uint64]*cocoaPage{}, byView: map[objc.ID]*cocoaPage{}, blocks: map[uint64]func(objc.ID, objc.ID){}} d.pool = send(class("NSAutoreleasePool"), "new") if !objc.Send[bool](class("NSThread"), selector("isMainThread")) { d.Close() return nil, api.Err("BROWSER_RUNTIME_UNAVAILABLE", "WKWebView requires the process main thread") } if objc.GetClass("WKContentWorld") == 0 { d.Close() return nil, api.Err("BROWSER_RUNTIME_UNAVAILABLE", "WKWebView isolated worlds require macOS 11 or later") } if err := d.initBlocks(); err != nil { d.Close() return nil, err } var err error d.delegateClass, err = objc.RegisterClass("CFBrowserNavigationDelegate", objc.GetClass("NSObject"), nil, nil, []objc.MethodDef{ {Cmd: selector("webView:didFinishNavigation:"), Fn: func(_ objc.ID, _ objc.SEL, view, nav objc.ID) { d.finishNavigation(view, nav, 0) }}, {Cmd: selector("webView:didFailNavigation:withError:"), Fn: func(_ objc.ID, _ objc.SEL, view, nav, exception objc.ID) { d.finishNavigation(view, nav, exception) }}, {Cmd: selector("webView:didFailProvisionalNavigation:withError:"), Fn: func(_ objc.ID, _ objc.SEL, view, nav, exception objc.ID) { d.finishNavigation(view, nav, exception) }}, {Cmd: selector("webViewWebContentProcessDidTerminate:"), Fn: func(_ objc.ID, _ objc.SEL, view objc.ID) { if p := d.byView[view]; p != nil && p.navigate != nil { fn := p.navigate p.navigate = nil fn("", api.Err("BROWSER_WORKER_EXITED", "WebKit content process terminated")) } }}, }) if err != nil { d.Close() return nil, err } d.app = send(class("NSApplication"), "sharedApplication") send(d.app, "setActivationPolicy:", int64(1)) send(d.app, "finishLaunching") d.mode = retain(nsString("kCFRunLoopDefaultMode")) d.store = retain(send(class("WKWebsiteDataStore"), "nonPersistentDataStore")) d.world = retain(send(class("WKContentWorld"), "worldWithName:", nsString("cfbrowser-isolated"))) return d, nil } func (d *Darwin) Configure(opts api.EngineOptions, done func(error)) { d.options = opts; done(nil) } func (d *Darwin) NewPage(id uint64, done func(error)) { configuration := send(class("WKWebViewConfiguration"), "new") defer release(configuration) send(configuration, "setWebsiteDataStore:", d.store) preferences := send(configuration, "preferences") send(preferences, "setJavaScriptCanOpenWindowsAutomatically:", false) controller := send(configuration, "userContentController") // A script retains the named world across separate evaluations and snapshots. script := send(send(class("WKUserScript"), "alloc"), "initWithSource:injectionTime:forMainFrameOnly:inContentWorld:", nsString("void 0"), int64(0), true, d.world) send(controller, "addUserScript:", script) release(script) frame := cocoaRect{Size: cocoaSize{float64(d.options.ViewportWidth), float64(d.options.ViewportHeight)}} view := send(send(class("WKWebView"), "alloc"), "initWithFrame:configuration:", frame, configuration) if view == 0 { done(api.Err("BROWSER_RUNTIME_UNAVAILABLE", "cannot create WKWebView")) return } delegate := send(objc.ID(d.delegateClass), "new") send(view, "setNavigationDelegate:", delegate) window := send(send(class("NSWindow"), "alloc"), "initWithContentRect:styleMask:backing:defer:", frame, uint64(1|2|8), uint64(2), false) if window == 0 { send(view, "setNavigationDelegate:", objc.ID(0)) release(delegate) release(view) done(api.Err("BROWSER_RUNTIME_UNAVAILABLE", "cannot create WebKit host window")) return } send(window, "setReleasedWhenClosed:", false) send(window, "setTitle:", nsString("CFBrowser")) send(window, "setContentView:", view) p := &cocoaPage{view: view, window: window, delegate: delegate, blocks: map[uint64]bool{}} d.pages[id] = p d.byView[view] = p if !d.options.Headless { send(window, "orderFront:", objc.ID(0)) } done(nil) } func (d *Darwin) finishNavigation(view, nav, exception objc.ID) { p := d.byView[view] if p == nil || p.navigate == nil || nav != p.navigation { return } fn := p.navigate p.navigate = nil if exception != 0 { fn("", d.nativeError(exception, "BROWSER_NAVIGATION_FAILED")) return } url, err := d.string(send(send(view, "URL"), "absoluteString"), 8192) fn(url, err) } func (d *Darwin) Navigate(id uint64, url, op string, done func(string, error)) { p := d.pages[id] if p == nil { done("", api.Err("BROWSER_PAGE_NOT_FOUND", "WKWebView page is closed")) return } if p.navigate != nil { fn := p.navigate p.navigate = nil send(p.view, "stopLoading") fn("", api.Err("BROWSER_CANCELED", "navigation superseded")) } if op == "back" || op == "forward" { name := "canGoBack" if op == "forward" { name = "canGoForward" } if !objc.Send[bool](p.view, selector(name)) { s, err := d.string(send(send(p.view, "URL"), "absoluteString"), 8192) done(s, err) return } } p.navigate = done switch op { case "goto": u := send(class("NSURL"), "URLWithString:", nsString(url)) if u == 0 { p.navigate = nil done("", api.Err("BROWSER_INVALID_ARGUMENT", "invalid URL")) return } request := send(class("NSURLRequest"), "requestWithURL:", u) p.navigation = send(p.view, "loadRequest:", request) case "reload": p.navigation = send(p.view, "reload") case "back": p.navigation = send(p.view, "goBack") case "forward": p.navigation = send(p.view, "goForward") default: p.navigate = nil done("", api.Err("BROWSER_INVALID_ARGUMENT", "invalid navigation operation")) return } if p.navigation == 0 { p.navigate = nil done("", api.Err("BROWSER_NAVIGATION_FAILED", "WKWebView returned no navigation")) } } func (d *Darwin) completion(p *cocoaPage, fn func(objc.ID, objc.ID)) (unsafe.Pointer, error) { if len(d.blocks) >= 32 { return nil, api.Err("BROWSER_LIMIT", "too many native evaluations pending") } d.nextBlock++ token := d.nextBlock literal := d.malloc(unsafe.Sizeof(objcBlock{})) if literal == nil { return nil, fmt.Errorf("cannot allocate completion block") } *(*objcBlock)(literal) = objcBlock{Isa: d.blockISA, Flags: 1 << 30, Invoke: d.blockInvoke, Descriptor: d.descriptor, Token: token} block := d.copyBlock(literal) d.free(literal) if block == nil { return nil, fmt.Errorf("cannot copy completion block") } p.blocks[token] = true d.blocks[token] = func(value, exception objc.ID) { delete(p.blocks, token); fn(value, exception) } return block, nil } func (d *Darwin) Evaluate(id uint64, expression string, done func(json.RawMessage, error)) { p := d.pages[id] if p == nil { done(nil, api.Err("BROWSER_PAGE_NOT_FOUND", "WKWebView page is closed")) return } block, err := d.completion(p, func(value, exception objc.ID) { if d.pages[id] != p { done(nil, api.Err("BROWSER_CLOSED", "page closed during evaluation")) return } if exception != 0 { done(nil, d.nativeError(exception, "BROWSER_SCRIPT_FAILED")) return } valueString, e := d.string(value, protocol.MaxMessage-1024) if e == nil && !json.Valid([]byte(valueString)) { e = api.Err("BROWSER_INVALID_RESULT", "WKWebView evaluation returned no JSON value") } done(json.RawMessage(valueString), e) }) if err != nil { done(nil, err) return } send(p.view, "evaluateJavaScript:inFrame:inContentWorld:completionHandler:", nsString("JSON.stringify(("+expression+"))"), objc.ID(0), d.world, block) d.releaseBlock(block) } func (d *Darwin) string(value objc.ID, limit int) (string, error) { if value == 0 { return "", nil } if !objc.Send[bool](value, selector("isKindOfClass:"), objc.GetClass("NSString")) { return "", api.Err("BROWSER_INVALID_RESULT", "expected an NSString result") } ptr := objc.Send[*byte](value, selector("UTF8String")) if ptr == nil { return "", nil } for i := 0; i <= limit; i++ { if *(*byte)(unsafe.Add(unsafe.Pointer(ptr), i)) == 0 { return string(unsafe.Slice(ptr, i)), nil } } return "", api.Err("BROWSER_RESULT_LIMIT", "WKWebView string exceeds worker limit") } func (d *Darwin) nativeError(value objc.ID, code string) error { s, err := d.string(send(value, "localizedDescription"), 4096) if err != nil || s == "" { s = "WKWebView operation failed" } return api.Err(code, s) } func (d *Darwin) ClosePage(id uint64) error { p := d.pages[id] if p == nil { return nil } delete(d.pages, id) delete(d.byView, p.view) for token := range p.blocks { delete(d.blocks, token) } if p.navigate != nil { fn := p.navigate p.navigate = nil fn("", api.Err("BROWSER_CLOSED", "page closed")) } send(p.view, "stopLoading") send(p.view, "setNavigationDelegate:", objc.ID(0)) send(p.view, "removeFromSuperview") send(p.window, "close") release(p.view) release(p.delegate) release(p.window) return nil } func (d *Darwin) Pump() error { release(d.pool) d.pool = send(class("NSAutoreleasePool"), "new") for i := 0; i < 100; i++ { event := send(d.app, "nextEventMatchingMask:untilDate:inMode:dequeue:", ^uint64(0), send(class("NSDate"), "distantPast"), d.mode, true) if event == 0 { break } send(d.app, "sendEvent:", event) } send(d.app, "updateWindows") return nil } func (d *Darwin) Close() { if d.closed { return } d.closed = true for id := range d.pages { _ = d.ClosePage(id) } clear(d.blocks) release(d.world) release(d.store) release(d.mode) release(d.pool) d.world = 0 d.store = 0 d.mode = 0 d.pool = 0 } func (d *Darwin) initBlocks() error { lib, err := purego.Dlopen("/usr/lib/libSystem.B.dylib", purego.RTLD_NOW|purego.RTLD_GLOBAL) if err != nil { return err } purego.RegisterLibFunc(&d.malloc, lib, "malloc") purego.RegisterLibFunc(&d.free, lib, "free") purego.RegisterLibFunc(&d.copyBlock, lib, "_Block_copy") purego.RegisterLibFunc(&d.releaseBlock, lib, "_Block_release") d.blockISA, err = purego.Dlsym(lib, "_NSConcreteStackBlock") if err != nil { return err } d.blockInvoke = purego.NewCallback(func(block *objcBlock, value, exception objc.ID) { fn := d.blocks[block.Token] delete(d.blocks, block.Token) if fn != nil && !d.closed { fn(value, exception) } }) // Descriptor/signature live until process exit; pending WebKit blocks can outlive Close. d.descriptor = d.malloc(unsafe.Sizeof(blockDescriptor{})) if d.descriptor == nil { return fmt.Errorf("cannot allocate block descriptor") } const encoding = "v24@?0@8@16\x00" signature := d.malloc(uintptr(len(encoding))) if signature == nil { return fmt.Errorf("cannot allocate block signature") } copy(unsafe.Slice((*byte)(signature), len(encoding)), encoding) *(*blockDescriptor)(d.descriptor) = blockDescriptor{Size: unsafe.Sizeof(objcBlock{}), Signature: signature} return nil } // Capture uses WKWebView's public snapshot API without exposing the window. func (d *Darwin) Capture(id uint64, full bool, done func([]byte, error)) { if full { done(nil, api.Err("BROWSER_CAPABILITY_UNSUPPORTED", "WKWebView full-page capture is not implemented")) return } p := d.pages[id] if p == nil { done(nil, api.Err("BROWSER_PAGE_NOT_FOUND", "WKWebView page is closed")) return } config := send(class("WKSnapshotConfiguration"), "new") defer release(config) send(config, "setAfterScreenUpdates:", true) block, err := d.completion(p, func(image, exception objc.ID) { if d.pages[id] != p { done(nil, api.Err("BROWSER_CLOSED", "page closed during capture")) return } if exception != 0 { done(nil, d.nativeError(exception, "BROWSER_CAPTURE_FAILED")) return } if image == 0 { done(nil, api.Err("BROWSER_CAPTURE_FAILED", "WKWebView returned no image")) return } tiff := send(image, "TIFFRepresentation") bitmap := send(class("NSBitmapImageRep"), "imageRepWithData:", tiff) if bitmap == 0 { done(nil, api.Err("BROWSER_CAPTURE_FAILED", "cannot encode snapshot")) return } width := objc.Send[int64](bitmap, selector("pixelsWide")) height := objc.Send[int64](bitmap, selector("pixelsHigh")) if width < 1 || height < 1 || width > capture.MaxDimension || height > capture.MaxDimension { done(nil, api.Err("BROWSER_RESULT_LIMIT", "capture dimensions exceed 4096 x 4096")) return } data := send(bitmap, "representationUsingType:properties:", uint64(4), send(class("NSDictionary"), "dictionary")) n := objc.Send[uint64](data, selector("length")) if n == 0 || n > capture.MaxBytes { done(nil, api.Err("BROWSER_RESULT_LIMIT", "capture exceeds 4 MiB or is empty")) return } ptr := objc.Send[*byte](data, selector("bytes")) if ptr == nil { done(nil, api.Err("BROWSER_CAPTURE_FAILED", "empty PNG buffer")) return } png := append([]byte(nil), unsafe.Slice(ptr, int(n))...) done(png, capture.Validate(png)) }) if err != nil { done(nil, err) return } send(p.view, "takeSnapshotWithConfiguration:completionHandler:", config, block) d.releaseBlock(block) }