//go:build linux package main import ( "context" "encoding/json" "errors" "os" "runtime" "sync/atomic" "time" "unsafe" "clusterflow.dev/cfbrowser/api" "clusterflow.dev/cfbrowser/internal/capture" "clusterflow.dev/cfbrowser/protocol" "github.com/ebitengine/purego" ) type nativePage struct { window, view uintptr loading bool failed bool } type allocation struct{ X, Y, Width, Height int32 } type nativeCapture struct { result chan evalResult page uint64 data []byte } type nativeHost struct { snapshots map[uintptr]*nativeCapture snapshot func(uintptr, int32, uint32, uintptr, uintptr, uintptr) snapshotFinish func(uintptr, uintptr, *uintptr) uintptr surfaceDestroy func(uintptr) surfaceWidth, surfaceHeight, surfaceType func(uintptr) int32 surfacePNG func(uintptr, uintptr, uintptr) int32 sizeAllocate func(uintptr, *allocation) snapshotCallback, pngCallback uintptr queue chan func() pages map[uint64]*nativePage next uint64 options api.EngineOptions configured bool webContext uintptr callbacks map[uintptr]chan evalResult evalSeq uintptr gtkInit func(uintptr, uintptr) int32 windowNew func(int32) uintptr windowSize func(uintptr, int32, int32) containerAdd func(uintptr, uintptr) show, realize, destroy func(uintptr) pending func() int32 iteration func(int32) int32 contextNew func() uintptr viewNew func(uintptr) uintptr contentManager func(uintptr) uintptr scriptNew func(string, int32, int32, string, uintptr, uintptr) uintptr addScript func(uintptr, uintptr) scriptUnref func(uintptr) load func(uintptr, string) uri func(uintptr) *byte back, forward, reload func(uintptr) eval func(uintptr, string, int64, string, string, uintptr, uintptr, uintptr) finish func(uintptr, uintptr, *uintptr) uintptr toJSON func(uintptr, uint32) *byte free, unref, errorFree func(uintptr) signal func(uintptr, string, uintptr, uintptr, uintptr, uint32) uint64 evalCallback, loadCallback, failedCallback uintptr } type evalResult struct { raw json.RawMessage err error } func openLibrary(name string) (uintptr, error) { return purego.Dlopen(name, purego.RTLD_NOW|purego.RTLD_GLOBAL) } func newHost() (*nativeHost, error) { gtk, err := openLibrary("libgtk-3.so.0") if err != nil { return nil, err } wk, err := openLibrary("libwebkit2gtk-4.1.so.0") if err != nil { return nil, err } jsc, err := openLibrary("libjavascriptcoregtk-4.1.so.0") if err != nil { return nil, err } glib, err := openLibrary("libglib-2.0.so.0") if err != nil { return nil, err } object, err := openLibrary("libgobject-2.0.so.0") if err != nil { return nil, err } cairo, err := openLibrary("libcairo.so.2") if err != nil { return nil, err } h := &nativeHost{snapshots: map[uintptr]*nativeCapture{}, queue: make(chan func(), 32), pages: map[uint64]*nativePage{}, callbacks: map[uintptr]chan evalResult{}} purego.RegisterLibFunc(&h.snapshot, wk, "webkit_web_view_get_snapshot") purego.RegisterLibFunc(&h.snapshotFinish, wk, "webkit_web_view_get_snapshot_finish") purego.RegisterLibFunc(&h.surfaceDestroy, cairo, "cairo_surface_destroy") purego.RegisterLibFunc(&h.surfaceWidth, cairo, "cairo_image_surface_get_width") purego.RegisterLibFunc(&h.surfaceHeight, cairo, "cairo_image_surface_get_height") purego.RegisterLibFunc(&h.surfaceType, cairo, "cairo_surface_get_type") purego.RegisterLibFunc(&h.surfacePNG, cairo, "cairo_surface_write_to_png_stream") purego.RegisterLibFunc(&h.sizeAllocate, gtk, "gtk_widget_size_allocate") purego.RegisterLibFunc(&h.gtkInit, gtk, "gtk_init_check") purego.RegisterLibFunc(&h.windowNew, gtk, "gtk_window_new") purego.RegisterLibFunc(&h.windowSize, gtk, "gtk_window_set_default_size") purego.RegisterLibFunc(&h.containerAdd, gtk, "gtk_container_add") purego.RegisterLibFunc(&h.show, gtk, "gtk_widget_show_all") purego.RegisterLibFunc(&h.realize, gtk, "gtk_widget_realize") purego.RegisterLibFunc(&h.destroy, gtk, "gtk_widget_destroy") purego.RegisterLibFunc(&h.pending, gtk, "gtk_events_pending") purego.RegisterLibFunc(&h.iteration, gtk, "gtk_main_iteration_do") purego.RegisterLibFunc(&h.contextNew, wk, "webkit_web_context_new_ephemeral") purego.RegisterLibFunc(&h.viewNew, wk, "webkit_web_view_new_with_context") purego.RegisterLibFunc(&h.contentManager, wk, "webkit_web_view_get_user_content_manager") purego.RegisterLibFunc(&h.scriptNew, wk, "webkit_user_script_new_for_world") purego.RegisterLibFunc(&h.addScript, wk, "webkit_user_content_manager_add_script") purego.RegisterLibFunc(&h.scriptUnref, wk, "webkit_user_script_unref") purego.RegisterLibFunc(&h.load, wk, "webkit_web_view_load_uri") purego.RegisterLibFunc(&h.uri, wk, "webkit_web_view_get_uri") purego.RegisterLibFunc(&h.back, wk, "webkit_web_view_go_back") purego.RegisterLibFunc(&h.forward, wk, "webkit_web_view_go_forward") purego.RegisterLibFunc(&h.reload, wk, "webkit_web_view_reload") purego.RegisterLibFunc(&h.eval, wk, "webkit_web_view_evaluate_javascript") purego.RegisterLibFunc(&h.finish, wk, "webkit_web_view_evaluate_javascript_finish") purego.RegisterLibFunc(&h.toJSON, jsc, "jsc_value_to_json") purego.RegisterLibFunc(&h.free, glib, "g_free") purego.RegisterLibFunc(&h.errorFree, glib, "g_error_free") purego.RegisterLibFunc(&h.unref, object, "g_object_unref") purego.RegisterLibFunc(&h.signal, object, "g_signal_connect_data") if h.gtkInit(0, 0) == 0 { return nil, api.Err("BROWSER_RUNTIME_UNAVAILABLE", "GTK display unavailable; run in a desktop session or under Xvfb") } h.webContext = h.contextNew() h.evalCallback = purego.NewCallback(func(view, result, id uintptr) { ch := h.callbacks[id] delete(h.callbacks, id) var nativeError uintptr value := h.finish(view, result, &nativeError) if nativeError != 0 { h.errorFree(nativeError) if ch != nil { ch <- evalResult{err: errors.New("WebKit evaluation failed")} } return } if value == 0 { if ch != nil { ch <- evalResult{err: errors.New("WebKit returned no value")} } return } ptr := h.toJSON(value, 0) s, e := cString(ptr, protocol.MaxMessage) if ptr != nil { h.free(uintptr(unsafe.Pointer(ptr))) } h.unref(value) if ch != nil { ch <- evalResult{raw: json.RawMessage(s), err: e} } }) h.pngCallback = purego.NewCallback(func(key uintptr, ptr *byte, n uint32) int32 { job := h.snapshots[key] if job == nil || int(n) > capture.MaxBytes-len(job.data) { return 11 } // CAIRO_STATUS_WRITE_ERROR job.data = append(job.data, unsafe.Slice(ptr, int(n))...) return 0 }) h.snapshotCallback = purego.NewCallback(func(view, result, key uintptr) { var nativeError uintptr surface := h.snapshotFinish(view, result, &nativeError) job := h.snapshots[key] if surface != 0 { defer h.surfaceDestroy(surface) } if nativeError != 0 { h.errorFree(nativeError) } if job == nil { return } defer delete(h.snapshots, key) if surface == 0 || nativeError != 0 { job.result <- evalResult{err: api.Err("BROWSER_CAPTURE_FAILED", "WebKit snapshot failed")} return } if h.surfaceType(surface) != 0 || h.surfaceWidth(surface) < 1 || h.surfaceHeight(surface) < 1 || h.surfaceWidth(surface) > capture.MaxDimension || h.surfaceHeight(surface) > capture.MaxDimension { job.result <- evalResult{err: api.Err("BROWSER_RESULT_LIMIT", "invalid capture surface dimensions")} return } status := h.surfacePNG(surface, h.pngCallback, key) if status != 0 { job.result <- evalResult{err: api.Err("BROWSER_RESULT_LIMIT", "PNG encoding failed or exceeds 4 MiB")} return } job.result <- evalResult{raw: job.data} }) h.loadCallback = purego.NewCallback(func(view uintptr, event int32, data uintptr) { for _, p := range h.pages { if p.view == view { if event == 0 { p.loading = true } if event == 3 { p.loading = false } } } }) h.failedCallback = purego.NewCallback(func(view uintptr, event int32, uri, nativeError, data uintptr) int32 { for _, p := range h.pages { if p.view == view { p.loading = false p.failed = true } } return 1 }) return h, nil } func cString(ptr *byte, max int) (string, error) { if ptr == nil { return "", nil } b := make([]byte, 0, 256) for i := 0; i <= max; i++ { v := *(*byte)(unsafe.Add(unsafe.Pointer(ptr), i)) if v == 0 { return string(b), nil } if i == max { return "", api.Err("BROWSER_RESULT_LIMIT", "native string exceeds limit") } b = append(b, v) } return "", errors.New("invalid native string") } func (h *nativeHost) dispatch(ctx context.Context, f func()) error { select { case h.queue <- f: return nil case <-ctx.Done(): return ctx.Err() } } func (h *nativeHost) call(ctx context.Context, f func() (any, error)) (any, error) { result := make(chan struct { value any err error }, 1) err := h.dispatch(ctx, func() { if ctx.Err() != nil { result <- struct { value any err error }{nil, ctx.Err()} return } v, e := f() result <- struct { value any err error }{v, e} }) if err != nil { return nil, err } select { case r := <-result: return r.value, r.err case <-ctx.Done(): return nil, ctx.Err() } } func (h *nativeHost) handle(ctx context.Context, method string, raw json.RawMessage) (any, error) { var a struct { Page uint64 `json:"page"` URL string `json:"url"` Op string `json:"op"` Script string `json:"script"` FullPage bool `json:"fullPage"` } if method != "configure" && method != "session.features" { if err := json.Unmarshal(raw, &a); err != nil && string(raw) != "null" { return nil, err } } if method == "page.capture" { ch := make(chan evalResult, 1) var id atomic.Uint64 _, err := h.call(ctx, func() (any, error) { p := h.pages[a.Page] if p == nil { return nil, api.Err("BROWSER_PAGE_NOT_FOUND", "native page not found") } if a.FullPage { return nil, api.Err("BROWSER_CAPABILITY_UNSUPPORTED", "WebKitGTK full-page capture is not implemented") } if len(h.snapshots) >= 16 { return nil, api.Err("BROWSER_LIMIT", "too many pending snapshots") } h.evalSeq++ key := h.evalSeq id.Store(uint64(key)) h.snapshots[key] = &nativeCapture{result: ch, page: a.Page} h.snapshot(p.view, 0, 0, 0, h.snapshotCallback, key) return nil, nil }) if err != nil { return nil, err } select { case r := <-ch: if r.err != nil { return nil, r.err } if ctx.Err() != nil { return nil, ctx.Err() } return capture.Save(h.options.DownloadDir, r.raw) case <-ctx.Done(): _ = h.dispatch(context.Background(), func() { delete(h.snapshots, uintptr(id.Load())) }) return nil, ctx.Err() } } if method == "page.evaluate" { ch := make(chan evalResult, 1) var id atomic.Uint64 _, err := h.call(ctx, func() (any, error) { p := h.pages[a.Page] if p == nil { return nil, api.Err("BROWSER_PAGE_NOT_FOUND", "native page not found") } h.evalSeq++ key := h.evalSeq id.Store(uint64(key)) h.callbacks[key] = ch h.eval(p.view, a.Script, int64(len(a.Script)), "cfbrowser-isolated", "", 0, h.evalCallback, key) return nil, nil }) if err != nil { return nil, err } select { case result := <-ch: return result.raw, result.err case <-ctx.Done(): _ = h.dispatch(context.Background(), func() { delete(h.callbacks, uintptr(id.Load())) }) return nil, ctx.Err() } } if method == "page.navigate" { _, err := h.call(ctx, func() (any, error) { p := h.pages[a.Page] if p == nil { return nil, api.Err("BROWSER_PAGE_NOT_FOUND", "native page not found") } p.failed = false p.loading = true switch a.Op { case "goto": h.load(p.view, a.URL) case "reload": h.reload(p.view) case "back": h.back(p.view) case "forward": h.forward(p.view) default: p.loading = false return nil, api.Err("BROWSER_INVALID_ARGUMENT", "invalid navigation") } return nil, nil }) if err != nil { return nil, err } ticker := time.NewTicker(10 * time.Millisecond) defer ticker.Stop() for { v, err := h.call(ctx, func() (any, error) { p := h.pages[a.Page] if p == nil { return nil, api.Err("BROWSER_PAGE_NOT_FOUND", "native page closed") } if p.failed { return nil, api.Err("BROWSER_NAVIGATION_FAILED", "WebKit load failed") } if p.loading { return nil, nil } return cString(h.uri(p.view), 8192) }) if err != nil { return nil, err } if v != nil { return v, nil } select { case <-ctx.Done(): return nil, ctx.Err() case <-ticker.C: } } } return h.call(ctx, func() (any, error) { switch method { case "session.features": if !h.configured { return nil, api.Err("BROWSER_INVALID_CONFIG", "configure worker first") } return map[string]int{"featureVersion": protocol.FeatureVersion}, nil case "configure": if h.configured { return nil, api.Err("BROWSER_INVALID_CONFIG", "worker is already configured") } if err := json.Unmarshal(raw, &h.options); err != nil { return nil, err } if h.options.ViewportWidth == 0 { h.options.ViewportWidth = 1280 } if h.options.ViewportHeight == 0 { h.options.ViewportHeight = 800 } if h.options.ViewportWidth < 1 || h.options.ViewportWidth > 4096 || h.options.ViewportHeight < 1 || h.options.ViewportHeight > 4096 { return nil, api.Err("BROWSER_INVALID_CONFIG", "invalid viewport dimensions") } h.configured = true return true, nil case "page.new": if !h.configured { return nil, api.Err("BROWSER_INVALID_CONFIG", "configure worker first") } if len(h.pages) >= 16 { return nil, api.Err("BROWSER_LIMIT", "native page quota reached") } window := h.windowNew(0) view := h.viewNew(h.webContext) h.windowSize(window, int32(h.options.ViewportWidth), int32(h.options.ViewportHeight)) h.containerAdd(window, view) // Retain the named script world across separate evaluation calls. script := h.scriptNew("void 0;", 1, 0, "cfbrowser-isolated", 0, 0) h.addScript(h.contentManager(view), script) h.scriptUnref(script) // Realize the native surface without mapping a top-level desktop window. h.show(view) h.realize(window) h.sizeAllocate(view, &allocation{Width: int32(h.options.ViewportWidth), Height: int32(h.options.ViewportHeight)}) if !h.options.Headless { h.show(window) } h.next++ h.pages[h.next] = &nativePage{window: window, view: view} h.signal(view, "load-changed", h.loadCallback, 0, 0, 0) h.signal(view, "load-failed", h.failedCallback, 0, 0, 0) return h.next, nil case "page.close": for key, job := range h.snapshots { if job.page == a.Page { job.result <- evalResult{err: api.Err("BROWSER_CLOSED", "page closed during capture")} delete(h.snapshots, key) } } if p := h.pages[a.Page]; p != nil { h.destroy(p.window) delete(h.pages, a.Page) } return true, nil default: return nil, api.Err("BROWSER_CAPABILITY_UNSUPPORTED", "unknown native worker method") } }) } func run() error { runtime.LockOSThread() defer runtime.UnlockOSThread() h, err := newHost() if err != nil { return err } done := make(chan error, 1) go func() { done <- protocol.Serve(context.Background(), os.Stdin, os.Stdout, h.handle) }() defer func() { for _, p := range h.pages { h.destroy(p.window) } h.unref(h.webContext) }() for { select { case err := <-done: return err case task := <-h.queue: task() default: } for i := 0; i < 100 && h.pending() != 0; i++ { h.iteration(0) } time.Sleep(time.Millisecond) } }