feat: add WebView support for extension (#1359)

This commit is contained in:
Levi authored and GitHub committed 2026-04-24 22:16:33 +08:00
1 parent a205c0b8d7
commit def54f8998
92 files changed
+10248 -2676

No files matched your search

+20
View File
@@ -0,0 +1,20 @@
package webview
type Provider interface {
IsAvailable() bool
Open(opts OpenOptions) (Page, error)
}
type unavailableProvider struct{}
func NewUnavailableProvider() Provider {
return unavailableProvider{}
}
func (unavailableProvider) IsAvailable() bool {
return false
}
func (unavailableProvider) Open(OpenOptions) (Page, error) {
return nil, ErrUnavailable
}
+143
View File
@@ -0,0 +1,143 @@
package webview
import "encoding/json"
const RPCEndpointPath = "/webview"
const (
MethodIsAvailable = "webview.isAvailable"
MethodPageOpen = "page.open"
MethodPageAddInitScript = "page.addInitScript"
MethodPageGoto = "page.goto"
MethodPageExecute = "page.execute"
MethodPageGetCookies = "page.getCookies"
MethodPageSetCookie = "page.setCookie"
MethodPageDeleteCookie = "page.deleteCookie"
MethodPageClearCookies = "page.clearCookies"
MethodPageClose = "page.close"
)
const (
ErrorCodeInvalidRequest = "INVALID_REQUEST"
ErrorCodeUnknownMethod = "UNKNOWN_METHOD"
ErrorCodeUnavailable = "UNAVAILABLE"
ErrorCodeBrowserNotFound = "BROWSER_NOT_FOUND"
ErrorCodePageNotFound = "PAGE_NOT_FOUND"
ErrorCodeNavigationFailed = "NAVIGATION_FAILED"
ErrorCodeEvaluationFailed = "EVALUATION_FAILED"
ErrorCodeTimeout = "TIMEOUT"
ErrorCodeInternal = "INTERNAL_ERROR"
)
type RPCConfig struct {
Network string `json:"network"`
Address string `json:"address"`
Token string `json:"token,omitempty"`
}
func (c RPCConfig) Enabled() bool {
return c.Network != "" && c.Address != ""
}
type RPCRequest struct {
Method string `json:"method"`
Params any `json:"params"`
}
type RPCResponse struct {
Result json.RawMessage `json:"result"`
Error *RPCError `json:"error"`
}
type RPCError struct {
Code string `json:"code"`
Message string `json:"message"`
}
func (e *RPCError) Error() string {
if e == nil {
return ""
}
return e.Message
}
type IsAvailableParams struct{}
type IsAvailableResult struct {
Available bool `json:"available"`
}
type PageOpenParams struct {
Headless bool `json:"headless,omitempty"`
Debug bool `json:"debug,omitempty"`
Title string `json:"title,omitempty"`
Width int `json:"width,omitempty"`
Height int `json:"height,omitempty"`
UserAgent string `json:"userAgent,omitempty"`
}
func NewPageOpenParams(opts OpenOptions) PageOpenParams {
return PageOpenParams{
Headless: opts.Headless,
Debug: opts.Debug,
Title: opts.Title,
Width: opts.Width,
Height: opts.Height,
UserAgent: opts.UserAgent,
}
}
type PageOpenResult struct {
PageID string `json:"pageId"`
}
type PageAddInitScriptParams struct {
PageID string `json:"pageId"`
Script string `json:"script"`
}
type PageGotoParams struct {
PageID string `json:"pageId"`
URL string `json:"url"`
TimeoutMS int64 `json:"timeoutMs,omitempty"`
WaitUntil string `json:"waitUntil,omitempty"`
}
func NewPageGotoParams(pageID string, url string, opts GotoOptions) PageGotoParams {
return PageGotoParams{
PageID: pageID,
URL: url,
TimeoutMS: opts.TimeoutMS,
WaitUntil: opts.WaitUntil,
}
}
type PageExecuteParams struct {
PageID string `json:"pageId"`
Expression string `json:"expression"`
Args []any `json:"args,omitempty"`
}
type PageGetCookiesParams struct {
PageID string `json:"pageId"`
}
type PageSetCookieParams struct {
PageID string `json:"pageId"`
Cookie Cookie `json:"cookie"`
}
type PageDeleteCookieParams struct {
PageID string `json:"pageId"`
Cookie Cookie `json:"cookie"`
}
type PageClearCookiesParams struct {
PageID string `json:"pageId"`
}
type PageCloseParams struct {
PageID string `json:"pageId"`
}
type EmptyResult struct{}
File diff suppressed because it is too large. Load diff
+338
View File
@@ -0,0 +1,338 @@
package webview
import (
"strings"
"testing"
"github.com/dop251/goja"
)
func TestRuntimeOpenAndExecuteFunctionSource(t *testing.T) {
opener := &fakeOpener{
page: &fakePage{executeValue: "ok"},
}
runtime := NewRuntime(opener, true)
page, err := runtime.Open(map[string]any{
"headless": true,
"debug": true,
"title": "Gopeed",
"width": 1280,
"height": 720,
"userAgent": "UA",
})
if err != nil {
t.Fatal(err)
}
vm := goja.New()
fnValue, err := vm.RunString(`(a, b) => a + b`)
if err != nil {
t.Fatal(err)
}
value, err := page.Execute(fnValue, int64(1), int64(2))
if err != nil {
t.Fatal(err)
}
if value != "ok" {
t.Fatalf("unexpected execute result: %#v", value)
}
if opener.opts.Title != "Gopeed" || opener.opts.UserAgent != "UA" {
t.Fatalf("unexpected open options: %+v", opener.opts)
}
if opener.page.lastExecuteSource != "((a, b) => a + b)" {
t.Fatalf("unexpected function source: %q", opener.page.lastExecuteSource)
}
if len(opener.page.lastExecuteArgs) != 2 || opener.page.lastExecuteArgs[0] != int64(1) || opener.page.lastExecuteArgs[1] != int64(2) {
t.Fatalf("unexpected execute args: %#v", opener.page.lastExecuteArgs)
}
}
func TestRuntimeExecuteRepairsObjectLiteralArrowFunction(t *testing.T) {
opener := &fakeOpener{
page: &fakePage{executeValue: map[string]any{"ok": true}},
}
runtime := NewRuntime(opener, true)
page, err := runtime.Open()
if err != nil {
t.Fatal(err)
}
vm := goja.New()
fnValue, err := vm.RunString(`() => ({ ok: true })`)
if err != nil {
t.Fatal(err)
}
if _, err := page.Execute(fnValue); err != nil {
t.Fatal(err)
}
if opener.page.lastExecuteSource != "(() => ({ ok: true }))" {
t.Fatalf("expected repaired function source, got %q", opener.page.lastExecuteSource)
}
}
func TestRuntimeExecuteRepairsMultilineObjectLiteralArrowFunction(t *testing.T) {
opener := &fakeOpener{
page: &fakePage{executeValue: map[string]any{"ok": true}},
}
runtime := NewRuntime(opener, true)
page, err := runtime.Open()
if err != nil {
t.Fatal(err)
}
vm := goja.New()
fnValue, err := vm.RunString(`() => ({
title: document.title || "",
url: String(location.href || ""),
userAgent: navigator.userAgent,
readyState: document.readyState,
})`)
if err != nil {
t.Fatal(err)
}
if _, err := page.Execute(fnValue); err != nil {
t.Fatal(err)
}
expected := `(() => ({
title: document.title || "",
url: String(location.href || ""),
userAgent: navigator.userAgent,
readyState: document.readyState,
}))`
if opener.page.lastExecuteSource != expected {
t.Fatalf("expected repaired multiline function source, got %q", opener.page.lastExecuteSource)
}
}
func TestRuntimeHelpers(t *testing.T) {
opener := &fakeOpener{
page: &fakePage{
executeQueue: []any{
false,
true,
map[string]any{"matched": false, "value": nil},
map[string]any{"matched": true, "value": "ready"},
"https://example.com",
"<html></html>",
},
cookies: []Cookie{
{Name: "a", Value: "1", Domain: "example.com", Path: "/"},
{Name: "b", Value: "two", Domain: "example.com", Path: "/"},
},
},
}
runtime := NewRuntime(opener, true)
page, err := runtime.Open()
if err != nil {
t.Fatal(err)
}
if err := page.AddInitScript("window.__TEST__ = true"); err != nil {
t.Fatal(err)
}
if opener.page.lastInitScript != "window.__TEST__ = true" {
t.Fatalf("unexpected init script: %q", opener.page.lastInitScript)
}
if err := page.Goto("https://example.com", map[string]any{"waitUntil": "domcontentloaded"}); err != nil {
t.Fatal(err)
}
if opener.page.lastGotoURL != "https://example.com" {
t.Fatalf("unexpected goto url: %q", opener.page.lastGotoURL)
}
if opener.page.lastGotoOpts.WaitUntil != "domcontentloaded" {
t.Fatalf("unexpected goto waitUntil: %q", opener.page.lastGotoOpts.WaitUntil)
}
found, err := page.WaitForSelector("#app", map[string]any{"timeoutMs": 50, "pollIntervalMs": 1})
if err != nil {
t.Fatal(err)
}
if !found {
t.Fatal("expected selector to be found")
}
value, err := page.WaitForFunction(`() => window.__READY__`, map[string]any{"timeoutMs": 50, "pollIntervalMs": 1})
if err != nil {
t.Fatal(err)
}
if value != "ready" {
t.Fatalf("unexpected waitForFunction value: %#v", value)
}
cookies, err := page.GetCookies()
if err != nil {
t.Fatal(err)
}
if len(cookies) != 2 || cookies[0].Name != "a" || cookies[0].Value != "1" || cookies[1].Name != "b" || cookies[1].Value != "two" {
t.Fatalf("unexpected cookies: %#v", cookies)
}
if err := page.SetCookie(map[string]any{
"name": "session",
"value": "abc",
"domain": "example.com",
"path": "/",
"secure": true,
"httpOnly": true,
}); err != nil {
t.Fatal(err)
}
if opener.page.lastSetCookie.Name != "session" || !opener.page.lastSetCookie.Secure || !opener.page.lastSetCookie.HTTPOnly {
t.Fatalf("unexpected set cookie: %#v", opener.page.lastSetCookie)
}
if err := page.DeleteCookie(map[string]any{
"name": "session",
"domain": "example.com",
"path": "/",
}); err != nil {
t.Fatal(err)
}
if opener.page.lastDeleteCookie.Name != "session" || opener.page.lastDeleteCookie.Domain != "example.com" {
t.Fatalf("unexpected delete cookie: %#v", opener.page.lastDeleteCookie)
}
if err := page.ClearCookies(); err != nil {
t.Fatal(err)
}
if !opener.page.cookiesCleared {
t.Fatal("expected cookies to be cleared")
}
url, err := page.URL()
if err != nil {
t.Fatal(err)
}
if url != "https://example.com" {
t.Fatalf("unexpected url: %q", url)
}
content, err := page.Content()
if err != nil {
t.Fatal(err)
}
if content != "<html></html>" {
t.Fatalf("unexpected content: %q", content)
}
if err := page.Close(); err != nil {
t.Fatal(err)
}
if !opener.page.closed {
t.Fatal("expected page to be closed")
}
}
func TestRuntimeInteractionHelpers(t *testing.T) {
opener := &fakeOpener{
page: &fakePage{executeValue: true},
}
runtime := NewRuntime(opener, true)
page, err := runtime.Open()
if err != nil {
t.Fatal(err)
}
if err := page.Focus("#search"); err != nil {
t.Fatal(err)
}
if len(opener.page.lastExecuteArgs) != 1 || opener.page.lastExecuteArgs[0] != "#search" {
t.Fatalf("unexpected focus args: %#v", opener.page.lastExecuteArgs)
}
if !strings.Contains(opener.page.lastExecuteSource, "element.focus()") {
t.Fatalf("unexpected focus source: %q", opener.page.lastExecuteSource)
}
if err := page.Click("#submit", map[string]any{"delay": 12}); err != nil {
t.Fatal(err)
}
if len(opener.page.lastExecuteArgs) != 2 || opener.page.lastExecuteArgs[0] != "#submit" || opener.page.lastExecuteArgs[1] != int64(12) {
t.Fatalf("unexpected click args: %#v", opener.page.lastExecuteArgs)
}
if !strings.Contains(opener.page.lastExecuteSource, "performClick") {
t.Fatalf("unexpected click source: %q", opener.page.lastExecuteSource)
}
if err := page.Type("#search", "Gopeed", map[string]any{"delay": 5}); err != nil {
t.Fatal(err)
}
if len(opener.page.lastExecuteArgs) != 3 || opener.page.lastExecuteArgs[0] != "#search" || opener.page.lastExecuteArgs[1] != "Gopeed" || opener.page.lastExecuteArgs[2] != int64(5) {
t.Fatalf("unexpected type args: %#v", opener.page.lastExecuteArgs)
}
if !strings.Contains(opener.page.lastExecuteSource, "element is not typable") {
t.Fatalf("unexpected type source: %q", opener.page.lastExecuteSource)
}
}
func TestRuntimeGotoRejectsInvalidWaitUntil(t *testing.T) {
opener := &fakeOpener{
page: &fakePage{},
}
runtime := NewRuntime(opener, true)
page, err := runtime.Open()
if err != nil {
t.Fatal(err)
}
err = page.Goto("https://example.com", map[string]any{"waitUntil": "networkidle"})
if err == nil || !strings.Contains(err.Error(), "invalid waitUntil") {
t.Fatalf("unexpected error: %v", err)
}
}
type fakeOpener struct {
opts OpenOptions
page *fakePage
}
func (o *fakeOpener) Open(opts OpenOptions) (Page, error) {
o.opts = opts
return o.page, nil
}
type fakePage struct {
lastInitScript string
lastGotoURL string
lastGotoOpts GotoOptions
lastExecuteSource string
lastExecuteArgs []any
executeValue any
executeQueue []any
cookies []Cookie
lastSetCookie Cookie
lastDeleteCookie Cookie
cookiesCleared bool
closed bool
}
func (p *fakePage) AddInitScript(script string) error {
p.lastInitScript = script
return nil
}
func (p *fakePage) Goto(url string, opts GotoOptions) error {
p.lastGotoURL = url
p.lastGotoOpts = opts
return nil
}
func (p *fakePage) Execute(expression string, args ...any) (any, error) {
p.lastExecuteSource = expression
p.lastExecuteArgs = args
if len(p.executeQueue) > 0 {
value := p.executeQueue[0]
p.executeQueue = p.executeQueue[1:]
return value, nil
}
return p.executeValue, nil
}
func (p *fakePage) GetCookies() ([]Cookie, error) {
return append([]Cookie(nil), p.cookies...), nil
}
func (p *fakePage) SetCookie(cookie Cookie) error {
p.lastSetCookie = cookie
return nil
}
func (p *fakePage) DeleteCookie(cookie Cookie) error {
p.lastDeleteCookie = cookie
return nil
}
func (p *fakePage) ClearCookies() error {
p.cookiesCleared = true
return nil
}
func (p *fakePage) Close() error {
p.closed = true
return nil
}