// Package nativehost dispatches worker RPC calls onto a native UI thread. package nativehost import ( "context" "encoding/json" "strings" "sync" "clusterflow.dev/cfbrowser/api" "clusterflow.dev/cfbrowser/internal/capture" "clusterflow.dev/cfbrowser/protocol" ) // Backend methods and their completion callbacks must run on the UI thread. // A method reports its synchronous or asynchronous result exactly once. type Backend interface { Configure(api.EngineOptions, func(error)) NewPage(uint64, func(error)) Navigate(uint64, string, string, func(string, error)) Evaluate(uint64, string, func(json.RawMessage, error)) ClosePage(uint64) error Close() } type captureBackend interface { Capture(uint64, bool, func([]byte, error)) } type inputBackend interface { Input(uint64, string, string, float64, float64, func(error)) } type result struct { value any err error } type Host struct { Queue chan func() backend Backend options api.EngineOptions configured bool configuring bool pages map[uint64]bool next uint64 evaluations int nextEvaluation uint64 pending map[uint64]map[uint64]func() } func New(backend Backend) *Host { return &Host{Queue: make(chan func(), 32), backend: backend, pages: map[uint64]bool{}, pending: map[uint64]map[uint64]func(){}} } func (h *Host) call(ctx context.Context, start func(func(any, error))) (any, error) { if err := ctx.Err(); err != nil { return nil, err } done := make(chan result, 1) var once sync.Once complete := func(v any, e error) { once.Do(func() { done <- result{v, e} }) } select { case h.Queue <- func() { if err := ctx.Err(); err != nil { complete(nil, err) return } start(complete) }: case <-ctx.Done(): return nil, ctx.Err() } select { case r := <-done: return r.value, r.err case <-ctx.Done(): return nil, ctx.Err() } } func (h *Host) Handle(ctx context.Context, method string, raw json.RawMessage) (any, error) { if method == "configure" { var opts api.EngineOptions if err := json.Unmarshal(raw, &opts); err != nil { return nil, api.Err("BROWSER_INVALID_ARGUMENT", "invalid engine options") } if opts.ViewportWidth == 0 { opts.ViewportWidth = 1280 } if opts.ViewportHeight == 0 { opts.ViewportHeight = 800 } if opts.ViewportWidth < 1 || opts.ViewportWidth > 4096 || opts.ViewportHeight < 1 || opts.ViewportHeight > 4096 { return nil, api.Err("BROWSER_INVALID_CONFIG", "viewport must be between 1 and 4096 pixels") } return h.call(ctx, func(done func(any, error)) { if h.configured || h.configuring { done(nil, api.Err("BROWSER_INVALID_CONFIG", "worker is already configured")) return } h.options = opts h.configuring = true h.backend.Configure(opts, func(err error) { h.configuring = false; h.configured = err == nil; done(err == nil, err) }) }) } var args struct { Page uint64 `json:"page"` FullPage bool `json:"fullPage"` Action string `json:"action"` Value string `json:"value"` X float64 `json:"x"` Y float64 `json:"y"` URL string `json:"url"` Op string `json:"op"` Script string `json:"script"` } if method != "page.new" && method != "session.features" { if err := json.Unmarshal(raw, &args); err != nil { return nil, api.Err("BROWSER_INVALID_ARGUMENT", "invalid page arguments") } } return h.call(ctx, func(done func(any, error)) { if !h.configured { done(nil, api.Err("BROWSER_INVALID_CONFIG", "configure worker first")) return } if method == "session.features" { done(map[string]int{"featureVersion": protocol.FeatureVersion}, nil) return } if method == "page.new" { if len(h.pages) >= 16 { done(nil, api.Err("BROWSER_LIMIT", "native page quota reached")) return } h.next++ id := h.next h.pages[id] = true h.backend.NewPage(id, func(err error) { if err != nil { delete(h.pages, id) done(nil, err) return } if ctx.Err() != nil { _ = h.backend.ClosePage(id) delete(h.pages, id) done(nil, ctx.Err()) return } done(id, nil) }) return } if method != "page.navigate" && method != "page.evaluate" && method != "page.close" && method != "page.capture" && method != "page.input" { done(nil, api.Err("BROWSER_CAPABILITY_UNSUPPORTED", "unknown native worker method")) return } if !h.pages[args.Page] { done(nil, api.Err("BROWSER_PAGE_NOT_FOUND", "native page is unavailable")) return } switch method { case "page.capture", "page.input": if h.evaluations >= 32 { done(nil, api.Err("BROWSER_LIMIT", "too many native operations pending")) return } complete := h.track(args.Page, done) if method == "page.input" { backend, ok := h.backend.(inputBackend) if !ok { complete(nil, api.Err("BROWSER_CAPABILITY_UNSUPPORTED", "native trusted input is unavailable")) return } backend.Input(args.Page, args.Action, args.Value, args.X, args.Y, func(err error) { complete(true, err) }) } else { backend, ok := h.backend.(captureBackend) if !ok { complete(nil, api.Err("BROWSER_CAPABILITY_UNSUPPORTED", "native capture is unavailable")) return } captureCompleted := false backend.Capture(args.Page, args.FullPage, func(data []byte, err error) { if captureCompleted { return } captureCompleted = true if ctx.Err() != nil { complete(nil, ctx.Err()) return } if !h.pages[args.Page] { complete(nil, api.Err("BROWSER_CLOSED", "page closed during capture")) return } var name string if err == nil { name, err = capture.Save(h.options.DownloadDir, data) } complete(name, err) }) } case "page.close": delete(h.pages, args.Page) h.cancelEvaluations(args.Page) done(true, h.backend.ClosePage(args.Page)) case "page.navigate": if strings.ContainsRune(args.URL, 0) { done(nil, api.Err("BROWSER_INVALID_ARGUMENT", "URL contains NUL")) return } if args.Op != "goto" && args.Op != "back" && args.Op != "forward" && args.Op != "reload" { done(nil, api.Err("BROWSER_INVALID_ARGUMENT", "invalid navigation operation")) return } h.backend.Navigate(args.Page, args.URL, args.Op, func(url string, err error) { done(url, err) }) case "page.evaluate": if strings.ContainsRune(args.Script, 0) { done(nil, api.Err("BROWSER_INVALID_ARGUMENT", "script contains NUL")) return } if len(args.Script) > protocol.MaxMessage/2 { done(nil, api.Err("BROWSER_ARGUMENT_LIMIT", "script exceeds worker limit")) return } if h.evaluations >= 32 { done(nil, api.Err("BROWSER_LIMIT", "too many native evaluations pending")) return } h.evaluations++ h.nextEvaluation++ evaluation := h.nextEvaluation if h.pending[args.Page] == nil { h.pending[args.Page] = map[uint64]func(){} } finished := false complete := func(value json.RawMessage, err error) { if finished { return } finished = true h.evaluations-- delete(h.pending[args.Page], evaluation) if len(h.pending[args.Page]) == 0 { delete(h.pending, args.Page) } if err == nil && (len(value) > protocol.MaxMessage-1024 || !json.Valid(value)) { err = api.Err("BROWSER_INVALID_RESULT", "native evaluation did not return bounded JSON") } done(value, err) } h.pending[args.Page][evaluation] = func() { complete(nil, api.Err("BROWSER_CLOSED", "page closed during evaluation")) } h.backend.Evaluate(args.Page, args.Script, complete) } }) } // Close is called on the UI thread after protocol handlers have been canceled. func (h *Host) Close() { for page := range h.pending { h.cancelEvaluations(page) } h.pages = map[uint64]bool{} h.backend.Close() } func (h *Host) cancelEvaluations(page uint64) { for _, cancel := range h.pending[page] { cancel() } } func (h *Host) track(page uint64, done func(any, error)) func(any, error) { h.evaluations++ h.nextEvaluation++ id := h.nextEvaluation if h.pending[page] == nil { h.pending[page] = map[uint64]func(){} } finished := false complete := func(v any, e error) { if finished { return } finished = true h.evaluations-- delete(h.pending[page], id) if len(h.pending[page]) == 0 { delete(h.pending, page) } done(v, e) } h.pending[page][id] = func() { complete(nil, api.Err("BROWSER_CLOSED", "page closed during operation")) } return complete }