fix: test

# Conflicts:
#	pkg/download/extension.go

bind/common.go

@@ -0,0 +1,41 @@
+package bind
+
+import (
+	"encoding/json"
+	"errors"
+	"github.com/GopeedLab/gopeed/pkg/api"
+	"github.com/GopeedLab/gopeed/pkg/api/model"
+)
+
+// Global singleton instance
+var instance *api.Instance
+
+func Init(config *model.StartConfig) (err error) {
+	if instance != nil {
+		return nil
+	}
+
+	config.ProductionMode = true
+	instance, err = api.Create(config)
+	return
+}
+
+func Invoke(request *api.Request) string {
+	if instance == nil {
+		return BuildResult(errors.New("instance not initialized"))
+	}
+	return jsonEncode(api.Invoke(instance, request))
+}
+
+func BuildResult(data any) string {
+	if err, ok := data.(error); ok {
+		buf, _ := json.Marshal(model.NewErrorResult[any](err.Error()))
+		return string(buf)
+	}
+	return jsonEncode(model.NewOkResult(data))
+}
+
+func jsonEncode(data any) string {
+	buf, _ := json.Marshal(data)
+	return string(buf)
+}

bind/desktop/main.go

@@ -3,27 +3,32 @@ package main
 import "C"
 import (
 	"encoding/json"
-	"github.com/GopeedLab/gopeed/pkg/rest"
-	"github.com/GopeedLab/gopeed/pkg/rest/model"
+	"github.com/GopeedLab/gopeed/bind"
+	"github.com/GopeedLab/gopeed/pkg/api"
+	"github.com/GopeedLab/gopeed/pkg/api/model"
 )
 
 func main() {}
 
-//export Start
-func Start(cfg *C.char) (int, *C.char) {
+//export Init
+func Init(cfg *C.char) *C.char {
 	var config model.StartConfig
 	if err := json.Unmarshal([]byte(C.GoString(cfg)), &config); err != nil {
-		return 0, C.CString(err.Error())
+		return C.CString(err.Error())
 	}
-	config.ProductionMode = true
-	realPort, err := rest.Start(&config)
-	if err != nil {
-		return 0, C.CString(err.Error())
+	if err := bind.Init(&config); err != nil {
+		return C.CString(err.Error())
 	}
-	return realPort, nil
+
+	return nil
 }
 
-//export Stop
-func Stop() {
-	rest.Stop()
+//export Invoke
+func Invoke(req *C.char) *C.char {
+	var request api.Request
+	if err := json.Unmarshal([]byte(C.GoString(req)), &request); err != nil {
+		return C.CString(bind.BuildResult(err))
+	}
+
+	return C.CString(bind.Invoke(&request))
 }

bind/mobile/main.go

@@ -3,20 +3,15 @@ package libgopeed
 // #cgo LDFLAGS: -static-libstdc++
 import "C"
 import (
-	"encoding/json"
-	"github.com/GopeedLab/gopeed/pkg/rest"
-	"github.com/GopeedLab/gopeed/pkg/rest/model"
+	"github.com/GopeedLab/gopeed/bind"
+	"github.com/GopeedLab/gopeed/pkg/api"
+	"github.com/GopeedLab/gopeed/pkg/api/model"
 )
 
-func Start(cfg string) (int, error) {
-	var config model.StartConfig
-	if err := json.Unmarshal([]byte(cfg), &config); err != nil {
-		return 0, err
-	}
-	config.ProductionMode = true
-	return rest.Start(&config)
+func Init(cfg *model.StartConfig) error {
+	return bind.Init(cfg)
 }
 
-func Stop() {
-	rest.Stop()
+func Invoke(request *api.Request) string {
+	return bind.Invoke(request)
 }

cmd/api/main.go

@@ -2,15 +2,21 @@ package main
 
 import (
 	"github.com/GopeedLab/gopeed/cmd"
-	"github.com/GopeedLab/gopeed/pkg/rest/model"
+	"github.com/GopeedLab/gopeed/pkg/api/model"
+	"github.com/GopeedLab/gopeed/pkg/base"
 )
 
 // only for local development
 func main() {
 	cfg := &model.StartConfig{
-		Network:   "tcp",
-		Address:   "127.0.0.1:9999",
-		Storage:   model.StorageBolt,
+		Storage: model.StorageBolt,
+		DownloadConfig: &base.DownloaderStoreConfig{
+			Http: &base.DownloaderHttpConfig{
+				Enable: true,
+				Host:   "127.0.0.1",
+				Port:   9999,
+			},
+		},
 		WebEnable: true,
 	}
 	cmd.Start(cfg)

cmd/server.go

@@ -3,10 +3,9 @@ package cmd
 import (
 	_ "embed"
 	"fmt"
+	"github.com/GopeedLab/gopeed/pkg/api"
+	"github.com/GopeedLab/gopeed/pkg/api/model"
 	"github.com/GopeedLab/gopeed/pkg/base"
-	"github.com/GopeedLab/gopeed/pkg/rest"
-	"github.com/GopeedLab/gopeed/pkg/rest/model"
-	"net/http"
 	"os"
 	"os/signal"
 	"path/filepath"
@@ -18,20 +17,22 @@ var banner string
 
 func Start(cfg *model.StartConfig) {
 	fmt.Println(banner)
-	srv, listener, err := rest.BuildServer(cfg)
+	instance, err := api.Create(cfg)
 	if err != nil {
 		panic(err)
 	}
-	downloadCfg, err := rest.Downloader.GetConfig()
-	if err != nil {
-		panic(err)
+
+	downloadCfgResult := instance.GetConfig()
+	if downloadCfgResult.HasError() {
+		panic(downloadCfgResult.Msg)
 	}
+	downloadCfg := downloadCfgResult.Data
 	if downloadCfg.FirstLoad {
 		// Set default download config
 		if cfg.DownloadConfig != nil {
 			cfg.DownloadConfig.Merge(downloadCfg)
 			// TODO Use PatchConfig
-			rest.Downloader.PutConfig(cfg.DownloadConfig)
+			instance.PutConfig(cfg.DownloadConfig)
 			downloadCfg = cfg.DownloadConfig
 		}
 
@@ -48,25 +49,28 @@ func Start(cfg *model.StartConfig) {
 			}
 			if downloadDir != "" {
 				downloadCfg.DownloadDir = downloadDir
-				rest.Downloader.PutConfig(downloadCfg)
+				instance.PutConfig(downloadCfg)
 			}
 		}
 	}
-	watchExit()
 
-	fmt.Printf("Server start success on http://%s\n", listener.Addr().String())
-	if err := srv.Serve(listener); err != nil && err != http.ErrServerClosed {
+	watchExit(instance)
+
+	port, start, err := api.ListenHttp(cfg.DownloadConfig.Http, instance)
+	if err != nil {
 		panic(err)
 	}
+	fmt.Printf("Server start success on http://%s:%d\n", cfg.DownloadConfig.Http.Host, port)
+	start()
 }
 
-func watchExit() {
+func watchExit(instance *api.Instance) {
 	sigs := make(chan os.Signal, 1)
 	signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
 	go func() {
 		sig := <-sigs
 		fmt.Printf("Server is shutting down due to signal: %s\n", sig)
-		rest.Downloader.Close()
+		instance.Close()
 		os.Exit(0)
 	}()
 }

cmd/web/flags.go

@@ -10,7 +10,7 @@ import (
 )
 
 type args struct {
-	Address    *string `json:"address"`
+	Host       *string `json:"host"`
 	Port       *int    `json:"port"`
 	Username   *string `json:"username"`
 	Password   *string `json:"password"`
@@ -24,7 +24,7 @@ type args struct {
 
 func parse() *args {
 	var cliArgs args
-	cliArgs.Address = flag.String("A", "0.0.0.0", "Bind Address")
+	cliArgs.Host = flag.String("H", "0.0.0.0", "Bind Host")
 	cliArgs.Port = flag.Int("P", 9999, "Bind Port")
 	cliArgs.Username = flag.String("u", "gopeed", "HTTP Basic Auth Username")
 	cliArgs.Password = flag.String("p", "", "HTTP Basic Auth Pwd")
@@ -35,8 +35,8 @@ func parse() *args {
 
 	// args priority: config file > cli args
 	cfgArgs := loadConfig(*cliArgs.configPath)
-	if cfgArgs.Address == nil {
-		cfgArgs.Address = cliArgs.Address
+	if cfgArgs.Host == nil {
+		cfgArgs.Host = cliArgs.Host
 	}
 	if cfgArgs.Port == nil {
 		cfgArgs.Port = cliArgs.Port

cmd/web/main.go

@@ -5,9 +5,9 @@ package main
 
 import (
 	"embed"
-	"fmt"
 	"github.com/GopeedLab/gopeed/cmd"
-	"github.com/GopeedLab/gopeed/pkg/rest/model"
+	"github.com/GopeedLab/gopeed/pkg/api/model"
+	"github.com/GopeedLab/gopeed/pkg/base"
 	"io/fs"
 	"os"
 	"path/filepath"
@@ -42,12 +42,19 @@ func main() {
 		dir = filepath.Dir(exe)
 	}
 
+	if args.DownloadConfig == nil {
+		args.DownloadConfig = &base.DownloaderStoreConfig{}
+	}
+	args.DownloadConfig.Http = &base.DownloaderHttpConfig{
+		Enable:   true,
+		Host:     *args.Host,
+		Port:     *args.Port,
+		ApiToken: *args.ApiToken,
+	}
+
 	cfg := &model.StartConfig{
-		Network:        "tcp",
-		Address:        fmt.Sprintf("%s:%d", *args.Address, *args.Port),
 		Storage:        model.StorageBolt,
 		StorageDir:     filepath.Join(dir, "storage"),
-		ApiToken:       *args.ApiToken,
 		DownloadConfig: args.DownloadConfig,
 		ProductionMode: true,
 		WebEnable:      true,

internal/protocol/bt/fetcher.go

@@ -332,7 +332,7 @@ func (f *Fetcher) doUpload(fromUpload bool) {
 	}
 }
 
-// Get torrent stats maybe panic, see https://github.com/anacrolix/torrent/issues/972
+// get torrent stats maybe panic, see https://github.com/anacrolix/torrent/issues/972
 func (f *Fetcher) torrentStats() torrent.TorrentStats {
 	defer func() {
 		if r := recover(); r != nil {

internal/protocol/http/fetcher.go

@@ -146,7 +146,7 @@ func (f *Fetcher) Resolve(req *base.Request) error {
 			file.Name = filename
 		}
 	}
-	// Get file filePath by URL
+	// get file filePath by URL
 	if file.Name == "" {
 		file.Name = path.Base(httpReq.URL.Path)
 	}
@@ -499,7 +499,7 @@ func (fm *FetcherManager) ParseName(u string) string {
 	if err != nil {
 		return ""
 	}
-	// Get filePath by URL
+	// get filePath by URL
 	name = path.Base(url.Path)
 	// If file name is empty, use host name
 	if name == "" || name == "/" || name == "." {

pkg/api/api.go

@@ -0,0 +1,400 @@
+package api
+
+import (
+	"context"
+	"fmt"
+	"github.com/GopeedLab/gopeed/pkg/api/model"
+	"github.com/GopeedLab/gopeed/pkg/base"
+	"github.com/GopeedLab/gopeed/pkg/download"
+	"github.com/GopeedLab/gopeed/pkg/util"
+	"net"
+	"net/http"
+	"reflect"
+	"runtime"
+	"sync"
+)
+
+type Instance struct {
+	startCfg   *model.StartConfig
+	downloader *download.Downloader
+
+	httpLock sync.Mutex
+	srv      *http.Server
+	listener net.Listener
+}
+
+func Create(startCfg *model.StartConfig) (*Instance, error) {
+	if startCfg == nil {
+		startCfg = &model.StartConfig{}
+	}
+	startCfg.Init()
+
+	i := &Instance{
+		startCfg: startCfg,
+	}
+
+	downloadCfg := &download.DownloaderConfig{
+		ProductionMode:  startCfg.ProductionMode,
+		RefreshInterval: startCfg.RefreshInterval,
+	}
+	if startCfg.Storage == model.StorageBolt {
+		downloadCfg.Storage = download.NewBoltStorage(startCfg.StorageDir)
+	} else {
+		downloadCfg.Storage = download.NewMemStorage()
+	}
+	downloadCfg.StorageDir = startCfg.StorageDir
+	downloadCfg.Init()
+	downloader := download.NewDownloader(downloadCfg)
+	if err := downloader.Setup(); err != nil {
+		return nil, err
+	}
+	i.downloader = downloader
+	i.httpLock = sync.Mutex{}
+
+	return i, nil
+}
+
+func (i *Instance) Listener(listener download.Listener) *model.Result[any] {
+	i.downloader.Listener(listener)
+	return model.NewNilResult()
+}
+
+func (i *Instance) StartHttp() *model.Result[int] {
+	i.httpLock.Lock()
+	defer i.httpLock.Unlock()
+
+	return i.startHttp()
+}
+
+func (i *Instance) startHttp() *model.Result[int] {
+	httpCfg := i.getHttpConfig()
+	if httpCfg == nil || !httpCfg.Enable {
+		return model.NewErrorResult[int]("HTTP API server not enabled")
+	}
+	if i.srv != nil {
+		return model.NewErrorResult[int]("HTTP API server already started")
+	}
+
+	port, start, err := ListenHttp(httpCfg, i)
+	if err != nil {
+		return model.NewErrorResult[int](err.Error())
+	}
+	httpCfg.RunningPort = port
+	go start()
+	return model.NewOkResult(port)
+}
+
+func (i *Instance) getHttpConfig() *base.DownloaderHttpConfig {
+	var httpCfg *base.DownloaderHttpConfig
+	if i.startCfg.DownloadConfig != nil && i.startCfg.DownloadConfig.Http != nil {
+		httpCfg = i.startCfg.DownloadConfig.Http
+	} else {
+		cfg, _ := i.downloader.GetConfig()
+		httpCfg = cfg.Http
+	}
+	return httpCfg
+}
+
+func (i *Instance) StopHttp() *model.Result[any] {
+	i.httpLock.Lock()
+	defer i.httpLock.Unlock()
+
+	return i.stopHttp()
+}
+
+func (i *Instance) stopHttp() *model.Result[any] {
+	if i.srv != nil {
+		if err := i.srv.Shutdown(context.Background()); err != nil {
+			i.downloader.Logger.Warn().Err(err).Msg("shutdown http server failed")
+		}
+		i.srv = nil
+		i.listener = nil
+	}
+	httpCfg := i.getHttpConfig()
+	if httpCfg != nil {
+		httpCfg.RunningPort = 0
+	}
+	return model.NewNilResult()
+}
+
+func (i *Instance) RestartHttp() *model.Result[int] {
+	i.httpLock.Lock()
+	defer i.httpLock.Unlock()
+
+	i.stopHttp()
+	return i.startHttp()
+}
+
+func (i *Instance) Info() *model.Result[map[string]any] {
+	return model.NewOkResult(map[string]any{
+		"version":  base.Version,
+		"runtime":  runtime.Version(),
+		"os":       runtime.GOOS,
+		"arch":     runtime.GOARCH,
+		"inDocker": base.InDocker == "true",
+	})
+}
+
+func (i *Instance) Resolve(req *base.Request) *model.Result[*download.ResolveResult] {
+	rr, err := i.downloader.Resolve(req)
+	if err != nil {
+		return model.NewErrorResult[*download.ResolveResult](err.Error())
+	}
+	return model.NewOkResult(rr)
+}
+
+func (i *Instance) CreateTask(req *model.CreateTask) *model.Result[string] {
+	var (
+		taskId string
+		err    error
+	)
+	if req.Rid != "" {
+		taskId, err = i.downloader.Create(req.Rid, req.Opt)
+	} else if req.Req != nil {
+		taskId, err = i.downloader.CreateDirect(req.Req, req.Opt)
+	} else {
+		return model.NewErrorResult[string]("param invalid: rid or req", model.CodeInvalidParam)
+	}
+	if err != nil {
+		return model.NewErrorResult[string](err.Error())
+	}
+	return model.NewOkResult(taskId)
+}
+
+func (i *Instance) CreateTaskBatch(req *model.CreateTaskBatch) *model.Result[[]string] {
+	if len(req.Reqs) == 0 {
+		return model.NewErrorResult[[]string]("param invalid: reqs", model.CodeInvalidParam)
+	}
+	taskIds, err := i.downloader.CreateDirectBatch(req.Reqs, req.Opt)
+	if err != nil {
+		return model.NewErrorResult[[]string](err.Error())
+	}
+	return model.NewOkResult(taskIds)
+}
+
+func (i *Instance) PauseTask(taskId string) *model.Result[any] {
+	err := i.downloader.Pause(&download.TaskFilter{
+		ID: []string{taskId},
+	})
+	if err != nil {
+		return model.NewErrorResult[any](err.Error())
+	}
+	return model.NewNilResult()
+}
+
+func (i *Instance) PauseTasks(filter *download.TaskFilter) *model.Result[any] {
+	err := i.downloader.Pause(filter)
+	if err != nil {
+		return model.NewErrorResult[any](err.Error())
+	}
+	return model.NewNilResult()
+}
+
+func (i *Instance) ContinueTask(taskId string) *model.Result[any] {
+	err := i.downloader.Continue(&download.TaskFilter{
+		ID: []string{taskId},
+	})
+	if err != nil {
+		return model.NewErrorResult[any](err.Error())
+	}
+	return model.NewNilResult()
+}
+
+func (i *Instance) ContinueTasks(filter *download.TaskFilter) *model.Result[any] {
+	err := i.downloader.Continue(filter)
+	if err != nil {
+		return model.NewErrorResult[any](err.Error())
+	}
+	return model.NewNilResult()
+}
+
+func (i *Instance) DeleteTask(taskId string, force bool) *model.Result[any] {
+	err := i.downloader.Delete(&download.TaskFilter{
+		ID: []string{taskId},
+	}, force)
+	if err != nil {
+		return model.NewErrorResult[any](err.Error())
+	}
+	return model.NewNilResult()
+}
+
+func (i *Instance) DeleteTasks(filter *download.TaskFilter, force bool) *model.Result[any] {
+	err := i.downloader.Delete(filter, force)
+	if err != nil {
+		return model.NewErrorResult[any](err.Error())
+	}
+	return model.NewNilResult()
+}
+
+func (i *Instance) GetTask(taskId string) *model.Result[*download.Task] {
+	if taskId == "" {
+		return model.NewErrorResult[*download.Task]("param invalid: id", model.CodeInvalidParam)
+	}
+	task := i.downloader.GetTask(taskId)
+	if task == nil {
+		return model.NewErrorResult[*download.Task]("task not found", model.CodeTaskNotFound)
+	}
+	return model.NewOkResult(task)
+}
+
+func (i *Instance) GetTasks(filter *download.TaskFilter) *model.Result[[]*download.Task] {
+	return model.NewOkResult(i.downloader.GetTasksByFilter(filter))
+}
+
+func (i *Instance) GetTaskStats(taskId string) *model.Result[any] {
+	stats, err := i.downloader.GetTaskStats(taskId)
+	if err != nil {
+		return model.NewErrorResult[any](err.Error())
+	}
+	return model.NewOkResult(stats)
+}
+
+func (i *Instance) GetConfig() *model.Result[*base.DownloaderStoreConfig] {
+	config, err := i.downloader.GetConfig()
+	if err != nil {
+		return model.NewErrorResult[*base.DownloaderStoreConfig](err.Error())
+	}
+	return model.NewOkResult(config)
+}
+
+func (i *Instance) PutConfig(cfg *base.DownloaderStoreConfig) *model.Result[any] {
+	err := i.downloader.PutConfig(cfg)
+	if err != nil {
+		return model.NewErrorResult[any](err.Error())
+	}
+	return model.NewNilResult()
+}
+
+func (i *Instance) InstallExtension(req *model.InstallExtension) *model.Result[string] {
+	var (
+		installedExt *download.Extension
+		err          error
+	)
+	if req.DevMode {
+		installedExt, err = i.downloader.InstallExtensionByFolder(req.URL, true)
+	} else {
+		installedExt, err = i.downloader.InstallExtensionByGit(req.URL)
+	}
+	if err != nil {
+		return model.NewErrorResult[string](err.Error())
+	}
+
+	return model.NewOkResult(installedExt.Identity)
+}
+
+func (i *Instance) GetExtension(identity string) *model.Result[*download.Extension] {
+	extension, err := i.downloader.GetExtension(identity)
+	if err != nil {
+		return model.NewErrorResult[*download.Extension](err.Error())
+	}
+	return model.NewOkResult(extension)
+}
+
+func (i *Instance) GetExtensions() *model.Result[[]*download.Extension] {
+	return model.NewOkResult(i.downloader.GetExtensions())
+}
+
+func (i *Instance) UpdateExtensionSettings(identity string, req *model.UpdateExtensionSettings) *model.Result[any] {
+	err := i.downloader.UpdateExtensionSettings(identity, req.Settings)
+	if err != nil {
+		return model.NewErrorResult[any](err.Error())
+	}
+	return model.NewNilResult()
+}
+
+func (i *Instance) SwitchExtension(identity string, req *model.SwitchExtension) *model.Result[any] {
+	err := i.downloader.SwitchExtension(identity, req.Status)
+	if err != nil {
+		return model.NewErrorResult[any](err.Error())
+	}
+	return model.NewNilResult()
+}
+
+func (i *Instance) DeleteExtension(identity string) *model.Result[any] {
+	err := i.downloader.DeleteExtension(identity)
+	if err != nil {
+		return model.NewErrorResult[any](err.Error())
+	}
+	return model.NewNilResult()
+}
+
+func (i *Instance) UpgradeCheckExtension(identity string) *model.Result[*model.UpgradeCheckExtensionResp] {
+	newVersion, err := i.downloader.UpgradeCheckExtension(identity)
+	if err != nil {
+		return model.NewErrorResult[*model.UpgradeCheckExtensionResp](err.Error())
+	}
+
+	return model.NewOkResult(&model.UpgradeCheckExtensionResp{
+		NewVersion: newVersion,
+	})
+}
+
+func (i *Instance) UpgradeExtension(identity string) *model.Result[any] {
+	err := i.downloader.UpgradeExtension(identity)
+	if err != nil {
+		return model.NewErrorResult[any](err.Error())
+	}
+	return model.NewNilResult()
+}
+
+func (i *Instance) Close() *model.Result[any] {
+	i.StopHttp()
+	if i.downloader != nil {
+		if err := i.downloader.Close(); err != nil {
+			i.downloader.Logger.Warn().Err(err).Msg("close downloader failed")
+		}
+		i.downloader = nil
+	}
+
+	return model.NewNilResult()
+}
+
+func (i *Instance) Clear() *model.Result[any] {
+	if err := i.downloader.Clear(); err != nil {
+		return model.NewErrorResult[any](err.Error())
+	}
+	return model.NewNilResult()
+}
+
+type Request struct {
+	Method string `json:"method"`
+	Params []any  `json:"params"`
+}
+
+// Invoke support dynamic call method
+func Invoke(instance *Instance, request *Request) (ret any) {
+	defer func() {
+		if err := recover(); err != nil {
+			ret = model.NewErrorResult[any](fmt.Sprintf("%v", err))
+		}
+	}()
+
+	method, args := request.Method, request.Params
+	dsType := reflect.ValueOf(instance)
+	fn := dsType.MethodByName(method)
+	numIn := fn.Type().NumIn()
+	in := make([]reflect.Value, numIn)
+	for i := 0; i < numIn; i++ {
+		paramType := fn.Type().In(i)
+		arg := args[i]
+		if arg == nil {
+			in[i] = reflect.Zero(fn.Type().In(i))
+			continue
+		}
+		var param reflect.Value
+		var paramPtr any
+		if paramType.Kind() == reflect.Ptr {
+			param = reflect.New(paramType.Elem())
+			paramPtr = param.Interface()
+		} else {
+			param = reflect.New(paramType).Elem()
+			paramPtr = param.Addr().Interface()
+		}
+		if err := util.MapToStruct(arg, paramPtr); err != nil {
+			panic(err)
+		}
+		in[i] = param
+	}
+	retVals := fn.Call(in)
+	return retVals[0].Interface()
+}

pkg/api/api_test.go

@@ -0,0 +1,42 @@
+package api
+
+import (
+	"encoding/json"
+	"github.com/GopeedLab/gopeed/pkg/api/model"
+	"github.com/GopeedLab/gopeed/pkg/download"
+	"testing"
+)
+
+func TestInvoke(t *testing.T) {
+	doTestInvoke(t, "Info", []any{}, model.CodeOk)
+	doTestInvoke(t, "Info1", []any{}, model.CodeError)
+	doTestInvoke(t, "CreateTask", []any{nil}, model.CodeError)
+	doTestInvoke(t, "GetTasks", nil, model.CodeError)
+	doTestInvoke(t, "GetTasks", []any{}, model.CodeError)
+	doTestInvoke(t, "GetTasks", []any{"{abc:123"}, model.CodeError)
+	doTestInvoke(t, "GetTasks", []any{&download.TaskFilter{}}, model.CodeOk)
+	doTestInvoke(t, "SwitchExtension", []any{"test", &model.SwitchExtension{Status: true}}, model.CodeError)
+}
+
+func doTestInvoke(t *testing.T, method string, params []any, expectCode model.RespCode) {
+	instance, _ := Create(nil)
+	defer instance.Close()
+
+	result := Invoke(instance, &Request{
+		Method: method,
+		Params: params,
+	})
+	buf, err := json.Marshal(result)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	var res model.Result[any]
+	if err := json.Unmarshal(buf, &res); err != nil {
+		t.Fatal(err)
+	}
+
+	if res.Code != expectCode {
+		t.Fatalf("Invoke method [%s] failed, expect code [%d], got [%d], msg: %s", method, expectCode, res.Code, res.Msg)
+	}
+}

pkg/api/http.go

@@ -0,0 +1,451 @@
+package api
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"github.com/GopeedLab/gopeed/pkg/api/model"
+	"github.com/GopeedLab/gopeed/pkg/base"
+	"github.com/GopeedLab/gopeed/pkg/download"
+	"github.com/gorilla/handlers"
+	"github.com/gorilla/mux"
+	"github.com/pkg/errors"
+	"io"
+	"net"
+	"net/http"
+	"net/url"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+)
+
+const instanceKey string = "apiInstance"
+
+func ListenHttp(httpCfg *base.DownloaderHttpConfig, ai *Instance) (int, func(), error) {
+	var r = mux.NewRouter()
+	r.Methods(http.MethodGet).Path("/api/v1/info").HandlerFunc(Info)
+	r.Methods(http.MethodPost).Path("/api/v1/resolve").HandlerFunc(Resolve)
+	r.Methods(http.MethodPost).Path("/api/v1/tasks").HandlerFunc(CreateTask)
+	r.Methods(http.MethodPost).Path("/api/v1/tasks/batch").HandlerFunc(CreateTaskBatch)
+	r.Methods(http.MethodPut).Path("/api/v1/tasks/{id}/pause").HandlerFunc(PauseTask)
+	r.Methods(http.MethodPut).Path("/api/v1/tasks/pause").HandlerFunc(PauseTasks)
+	r.Methods(http.MethodPut).Path("/api/v1/tasks/{id}/continue").HandlerFunc(ContinueTask)
+	r.Methods(http.MethodPut).Path("/api/v1/tasks/continue").HandlerFunc(ContinueTasks)
+	r.Methods(http.MethodDelete).Path("/api/v1/tasks/{id}").HandlerFunc(DeleteTask)
+	r.Methods(http.MethodDelete).Path("/api/v1/tasks").HandlerFunc(DeleteTasks)
+	r.Methods(http.MethodGet).Path("/api/v1/tasks/{id}").HandlerFunc(GetTask)
+	r.Methods(http.MethodGet).Path("/api/v1/tasks").HandlerFunc(GetTasks)
+	r.Methods(http.MethodGet).Path("/api/v1/tasks/{id}/stats").HandlerFunc(GetTaskStats)
+	r.Methods(http.MethodGet).Path("/api/v1/config").HandlerFunc(GetConfig)
+	r.Methods(http.MethodPut).Path("/api/v1/config").HandlerFunc(PutConfig)
+	r.Methods(http.MethodPost).Path("/api/v1/extensions").HandlerFunc(InstallExtension)
+	r.Methods(http.MethodGet).Path("/api/v1/extensions").HandlerFunc(GetExtensions)
+	r.Methods(http.MethodGet).Path("/api/v1/extensions/{identity}").HandlerFunc(GetExtension)
+	r.Methods(http.MethodPut).Path("/api/v1/extensions/{identity}/settings").HandlerFunc(UpdateExtensionSettings)
+	r.Methods(http.MethodPut).Path("/api/v1/extensions/{identity}/switch").HandlerFunc(SwitchExtension)
+	r.Methods(http.MethodDelete).Path("/api/v1/extensions/{identity}").HandlerFunc(DeleteExtension)
+	r.Methods(http.MethodGet).Path("/api/v1/extensions/{identity}/upgrade").HandlerFunc(UpgradeCheckExtension)
+	r.Methods(http.MethodPost).Path("/api/v1/extensions/{identity}/upgrade").HandlerFunc(UpgradeExtension)
+	if ai.startCfg.WebEnable {
+		r.Path("/api/v1/proxy").HandlerFunc(DoProxy)
+		r.PathPrefix("/fs/tasks").Handler(http.FileServer(&taskFileSystem{
+			downloader: ai.downloader,
+		}))
+		r.PathPrefix("/fs/extensions").Handler(http.FileServer(&extensionFileSystem{
+			downloader: ai.downloader,
+		}))
+		r.PathPrefix("/").Handler(http.FileServer(http.FS(ai.startCfg.WebFS)))
+	}
+
+	r.Use(func(h http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			ctx := context.WithValue(r.Context(), instanceKey, ai)
+			h.ServeHTTP(w, r.WithContext(ctx))
+		})
+	})
+
+	if httpCfg.ApiToken != "" || (ai.startCfg.WebEnable && ai.startCfg.WebBasicAuth != nil) {
+		r.Use(func(h http.Handler) http.Handler {
+			return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				if httpCfg.ApiToken != "" && r.Header.Get("X-Api-Token") == httpCfg.ApiToken {
+					h.ServeHTTP(w, r)
+					return
+				}
+				if ai.startCfg.WebEnable && ai.startCfg.WebBasicAuth != nil {
+					if r.Header.Get("Authorization") == ai.startCfg.WebBasicAuth.Authorization() {
+						h.ServeHTTP(w, r)
+						return
+					}
+					w.Header().Set("WWW-Authenticate", "Basic realm=\"gopeed web\"")
+				}
+				WriteStatusJson(w, http.StatusUnauthorized, model.NewErrorResult[any]("unauthorized", model.CodeUnauthorized))
+			})
+		})
+	}
+
+	// recover panic
+	r.Use(func(h http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			defer func() {
+				if v := recover(); v != nil {
+					err := errors.WithStack(fmt.Errorf("%v", v))
+					ai.downloader.Logger.Error().Stack().Err(err).Msgf("http server panic: %s %s", r.Method, r.RequestURI)
+					WriteJson(w, model.NewErrorResult[any](err.Error(), model.CodeError))
+				}
+			}()
+			h.ServeHTTP(w, r)
+		})
+	})
+
+	srv := &http.Server{Handler: handlers.CORS(
+		handlers.AllowedHeaders([]string{"Content-Type", "X-Api-Token", "X-Target-Uri"}),
+		handlers.AllowedMethods([]string{"GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"}),
+		handlers.AllowedOrigins([]string{"*"}),
+	)(r)}
+
+	listener, err := net.Listen("tcp", net.JoinHostPort(httpCfg.Host, fmt.Sprintf("%d", httpCfg.Port)))
+	if err != nil {
+		return 0, nil, err
+	}
+	ai.srv = srv
+	ai.listener = listener
+
+	return listener.Addr().(*net.TCPAddr).Port, func() {
+		if err := srv.Serve(listener); err != nil && !errors.Is(err, http.ErrServerClosed) {
+			ai.downloader.Logger.Error().Err(err).Msg("http server listen error")
+		}
+	}, nil
+}
+
+func getInstance(r *http.Request) *Instance {
+	return r.Context().Value(instanceKey).(*Instance)
+}
+
+func Info(w http.ResponseWriter, r *http.Request) {
+	WriteJson(w, getInstance(r).Info())
+}
+
+func Resolve(w http.ResponseWriter, r *http.Request) {
+	var req base.Request
+	if ReadJson(r, w, &req) {
+		WriteJson(w, getInstance(r).Resolve(&req))
+	}
+}
+
+func CreateTask(w http.ResponseWriter, r *http.Request) {
+	var req model.CreateTask
+	if ReadJson(r, w, &req) {
+		WriteJson(w, getInstance(r).CreateTask(&req))
+	}
+}
+
+func CreateTaskBatch(w http.ResponseWriter, r *http.Request) {
+	var req model.CreateTaskBatch
+	if ReadJson(r, w, &req) {
+		WriteJson(w, getInstance(r).CreateTaskBatch(&req))
+	}
+}
+
+func PauseTask(w http.ResponseWriter, r *http.Request) {
+	var taskId string
+	if !parseTaskId(r, w, &taskId) {
+		return
+	}
+	WriteJson(w, getInstance(r).PauseTask(taskId))
+}
+
+func PauseTasks(w http.ResponseWriter, r *http.Request) {
+	var filter download.TaskFilter
+	if !parseFilter(r, w, &filter) {
+		return
+	}
+	WriteJson(w, getInstance(r).PauseTasks(&filter))
+}
+
+func ContinueTask(w http.ResponseWriter, r *http.Request) {
+	var taskId string
+	if !parseTaskId(r, w, &taskId) {
+		return
+	}
+	WriteJson(w, getInstance(r).ContinueTask(taskId))
+}
+
+func ContinueTasks(w http.ResponseWriter, r *http.Request) {
+	var filter download.TaskFilter
+	if !parseFilter(r, w, &filter) {
+		return
+	}
+	WriteJson(w, getInstance(r).ContinueTasks(&filter))
+}
+
+func DeleteTask(w http.ResponseWriter, r *http.Request) {
+	var taskId string
+	if !parseTaskId(r, w, &taskId) {
+		return
+	}
+	force := r.FormValue("force")
+	WriteJson(w, getInstance(r).DeleteTask(taskId, force == "true"))
+}
+
+func DeleteTasks(w http.ResponseWriter, r *http.Request) {
+	var filter download.TaskFilter
+	if !parseFilter(r, w, &filter) {
+		return
+	}
+	force := r.FormValue("force")
+	WriteJson(w, getInstance(r).DeleteTasks(&filter, force == "true"))
+}
+
+func GetTask(w http.ResponseWriter, r *http.Request) {
+	var taskId string
+	if !parseTaskId(r, w, &taskId) {
+		return
+	}
+	WriteJson(w, getInstance(r).GetTask(taskId))
+}
+
+func GetTasks(w http.ResponseWriter, r *http.Request) {
+	var filter download.TaskFilter
+	if !parseFilter(r, w, &filter) {
+		return
+	}
+	WriteJson(w, getInstance(r).GetTasks(&filter))
+}
+
+func GetTaskStats(w http.ResponseWriter, r *http.Request) {
+	var taskId string
+	if !parseTaskId(r, w, &taskId) {
+		return
+	}
+	WriteJson(w, getInstance(r).GetTaskStats(taskId))
+}
+
+func GetConfig(w http.ResponseWriter, r *http.Request) {
+	WriteJson(w, getInstance(r).GetConfig())
+}
+
+func PutConfig(w http.ResponseWriter, r *http.Request) {
+	var cfg base.DownloaderStoreConfig
+	if !ReadJson(r, w, &cfg) {
+		return
+	}
+	WriteJson(w, getInstance(r).PutConfig(&cfg))
+}
+
+func InstallExtension(w http.ResponseWriter, r *http.Request) {
+	var req model.InstallExtension
+	if !ReadJson(r, w, &req) {
+		return
+	}
+	WriteJson(w, getInstance(r).InstallExtension(&req))
+}
+
+func GetExtensions(w http.ResponseWriter, r *http.Request) {
+	WriteJson(w, getInstance(r).GetExtensions())
+}
+
+func GetExtension(w http.ResponseWriter, r *http.Request) {
+	var identity string
+	if !parseIdentity(r, w, &identity) {
+		return
+	}
+	WriteJson(w, getInstance(r).GetExtension(identity))
+}
+
+func UpdateExtensionSettings(w http.ResponseWriter, r *http.Request) {
+	var identity string
+	if !parseIdentity(r, w, &identity) {
+		return
+	}
+	var req model.UpdateExtensionSettings
+	if !ReadJson(r, w, &req) {
+		return
+	}
+	WriteJson(w, getInstance(r).UpdateExtensionSettings(identity, &req))
+}
+
+func SwitchExtension(w http.ResponseWriter, r *http.Request) {
+	var identity string
+	if !parseIdentity(r, w, &identity) {
+		return
+	}
+	var switchExtension model.SwitchExtension
+	if !ReadJson(r, w, &switchExtension) {
+		return
+	}
+	WriteJson(w, getInstance(r).SwitchExtension(identity, &switchExtension))
+}
+
+func DeleteExtension(w http.ResponseWriter, r *http.Request) {
+	var identity string
+	if !parseIdentity(r, w, &identity) {
+		return
+	}
+	WriteJson(w, getInstance(r).DeleteExtension(identity))
+}
+
+func UpgradeCheckExtension(w http.ResponseWriter, r *http.Request) {
+	var identity string
+	if !parseIdentity(r, w, &identity) {
+		return
+	}
+	WriteJson(w, getInstance(r).UpgradeCheckExtension(identity))
+}
+
+func UpgradeExtension(w http.ResponseWriter, r *http.Request) {
+	var identity string
+	if !parseIdentity(r, w, &identity) {
+		return
+	}
+	WriteJson(w, getInstance(r).UpgradeExtension(identity))
+}
+
+func DoProxy(w http.ResponseWriter, r *http.Request) {
+	target := r.Header.Get("X-Target-Uri")
+	if target == "" {
+		writeError(w, "param invalid: X-Target-Uri")
+		return
+	}
+	targetUrl, err := url.Parse(target)
+	if err != nil {
+		writeError(w, err.Error())
+		return
+	}
+	r.RequestURI = ""
+	r.URL = targetUrl
+	r.Host = targetUrl.Host
+	resp, err := http.DefaultClient.Do(r)
+	if err != nil {
+		writeError(w, err.Error())
+		return
+	}
+	defer resp.Body.Close()
+	for k, vv := range resp.Header {
+		for _, v := range vv {
+			w.Header().Set(k, v)
+		}
+	}
+	w.WriteHeader(resp.StatusCode)
+	buf, err := io.ReadAll(resp.Body)
+	if err != nil {
+		writeError(w, err.Error())
+		return
+	}
+	w.Write(buf)
+}
+
+func parsePathParam(r *http.Request, w http.ResponseWriter, name string, value *string) bool {
+	vars := mux.Vars(r)
+	*value = vars[name]
+	if *value == "" {
+		WriteJson(w, model.NewErrorResult[any]("param invalid: id", model.CodeInvalidParam))
+		return false
+	}
+	return true
+}
+
+func parseTaskId(r *http.Request, w http.ResponseWriter, taskId *string) bool {
+	return parsePathParam(r, w, "id", taskId)
+}
+
+func parseIdentity(r *http.Request, w http.ResponseWriter, identity *string) bool {
+	return parsePathParam(r, w, "identity", identity)
+}
+
+func parseFilter(r *http.Request, w http.ResponseWriter, filter *download.TaskFilter) bool {
+	if err := r.ParseForm(); err != nil {
+		WriteJson(w, model.NewErrorResult[any](err.Error()))
+		return false
+	}
+
+	filter.ID = r.Form["id"]
+	filter.Status = convertStatues(r.Form["status"])
+	filter.NotStatus = convertStatues(r.Form["notStatus"])
+	return true
+}
+
+func convertStatues(statues []string) []base.Status {
+	result := make([]base.Status, 0)
+	for _, status := range statues {
+		result = append(result, base.Status(status))
+	}
+	return result
+}
+
+func writeError(w http.ResponseWriter, msg string) {
+	w.WriteHeader(http.StatusInternalServerError)
+	w.Write([]byte(msg))
+}
+
+func ReadJson(r *http.Request, w http.ResponseWriter, v any) bool {
+	if err := json.NewDecoder(r.Body).Decode(v); err != nil {
+		WriteJson(w, model.NewErrorResult[any](err.Error()))
+		return false
+	}
+	return true
+}
+
+func WriteJson(w http.ResponseWriter, v any) {
+	WriteStatusJson(w, http.StatusOK, v)
+}
+
+func WriteStatusJson(w http.ResponseWriter, statusCode int, v any) {
+	w.Header().Set("Content-Type", "application/json; charset=utf-8")
+	w.WriteHeader(statusCode)
+	json.NewEncoder(w).Encode(v)
+}
+
+func resolvePath(urlPath string, prefix string) (identity string, path string, err error) {
+	// remove prefix
+	clearPath := strings.TrimPrefix(urlPath, prefix)
+	// match extension identity, eg: /fs/extensions/identity/xxx
+	reg := regexp.MustCompile(`^/([^/]+)/(.*)$`)
+	if !reg.MatchString(clearPath) {
+		err = os.ErrNotExist
+		return
+	}
+	matched := reg.FindStringSubmatch(clearPath)
+	if len(matched) != 3 {
+		err = os.ErrNotExist
+		return
+	}
+	return matched[1], matched[2], nil
+}
+
+// handle task file resource
+type taskFileSystem struct {
+	downloader *download.Downloader
+}
+
+func (e *taskFileSystem) Open(name string) (http.File, error) {
+	// get extension identity
+	identity, path, err := resolvePath(name, "/fs/tasks")
+	if err != nil {
+		return nil, err
+	}
+	task := e.downloader.GetTask(identity)
+	if task == nil {
+		return nil, os.ErrNotExist
+	}
+	return os.Open(filepath.Join(task.Meta.RootDirPath(), path))
+}
+
+// handle extension file resource
+type extensionFileSystem struct {
+	downloader *download.Downloader
+}
+
+func (e *extensionFileSystem) Open(name string) (http.File, error) {
+	// get extension identity
+	identity, path, err := resolvePath(name, "/fs/extensions")
+	if err != nil {
+		return nil, err
+	}
+	extension, err := e.downloader.GetExtension(identity)
+	if err != nil {
+		return nil, os.ErrNotExist
+	}
+	extensionPath := e.downloader.ExtensionPath(extension)
+	return os.Open(filepath.Join(extensionPath, path))
+}

pkg/api/http_test.go

@@ -1,4 +1,4 @@
-package rest
+package api
 
 import (
 	"bytes"
@@ -7,9 +7,9 @@ import (
 	"errors"
 	"fmt"
 	"github.com/GopeedLab/gopeed/internal/test"
+	"github.com/GopeedLab/gopeed/pkg/api/model"
 	"github.com/GopeedLab/gopeed/pkg/base"
 	"github.com/GopeedLab/gopeed/pkg/download"
-	"github.com/GopeedLab/gopeed/pkg/rest/model"
 	"io"
 	"net"
 	"net/http"
@@ -21,7 +21,8 @@ import (
 )
 
 var (
-	restPort int
+	httpInstance *Instance
+	restPort     int
 
 	taskReq = &base.Request{
 		Extra: map[string]any{
@@ -90,7 +91,7 @@ func TestCreateTask(t *testing.T) {
 
 		var wg sync.WaitGroup
 		wg.Add(1)
-		Downloader.Listener(func(event *download.Event) {
+		httpInstance.Listener(func(event *download.Event) {
 			if event.Key == download.EventKeyFinally {
 				wg.Done()
 			}
@@ -117,7 +118,7 @@ func TestCreateDirectTask(t *testing.T) {
 	doTest(func() {
 		var wg sync.WaitGroup
 		wg.Add(1)
-		Downloader.Listener(func(event *download.Event) {
+		httpInstance.Listener(func(event *download.Event) {
 			if event.Key == download.EventKeyFinally {
 				wg.Done()
 			}
@@ -156,7 +157,7 @@ func TestCreateDirectTaskWithResoled(t *testing.T) {
 	doTest(func() {
 		var wg sync.WaitGroup
 		wg.Add(1)
-		Downloader.Listener(func(event *download.Event) {
+		httpInstance.Listener(func(event *download.Event) {
 			if event.Key == download.EventKeyFinally {
 				wg.Done()
 			}
@@ -180,7 +181,7 @@ func TestPauseAndContinueTask(t *testing.T) {
 	doTest(func() {
 		var wg sync.WaitGroup
 		wg.Add(1)
-		Downloader.Listener(func(event *download.Event) {
+		httpInstance.Listener(func(event *download.Event) {
 			switch event.Key {
 			case download.EventKeyFinally:
 				wg.Done()
@@ -214,10 +215,7 @@ func TestPauseAndContinueTask(t *testing.T) {
 
 func TestPauseAllAndContinueALLTasks(t *testing.T) {
 	doTest(func() {
-		cfg, err := Downloader.GetConfig()
-		if err != nil {
-			t.Fatal(err)
-		}
+		cfg := UnwrapResult(httpInstance.GetConfig())
 
 		createAndPause := func() {
 			taskId := httpRequestCheckOk[string](http.MethodPost, "/api/v1/tasks", createReq)
@@ -275,7 +273,7 @@ func TestDeleteAllTasks(t *testing.T) {
 
 		var wg sync.WaitGroup
 		wg.Add(taskCount)
-		Downloader.Listener(func(event *download.Event) {
+		httpInstance.Listener(func(event *download.Event) {
 			if event.Key == download.EventKeyFinally {
 				wg.Done()
 			}
@@ -301,7 +299,7 @@ func TestDeleteTasksByStatues(t *testing.T) {
 
 		var wg sync.WaitGroup
 		wg.Add(taskCount)
-		Downloader.Listener(func(event *download.Event) {
+		httpInstance.Listener(func(event *download.Event) {
 			if event.Key == download.EventKeyFinally {
 				wg.Done()
 			}
@@ -325,7 +323,7 @@ func TestGetTasks(t *testing.T) {
 	doTest(func() {
 		var wg sync.WaitGroup
 		wg.Add(1)
-		Downloader.Listener(func(event *download.Event) {
+		httpInstance.Listener(func(event *download.Event) {
 			if event.Key == download.EventKeyFinally {
 				wg.Done()
 			}
@@ -354,7 +352,10 @@ func TestGetAndPutConfig(t *testing.T) {
 		cfg := httpRequestCheckOk[*base.DownloaderStoreConfig](http.MethodGet, "/api/v1/config", nil)
 		cfg.DownloadDir = "./download"
 		cfg.Extra = map[string]any{
-			"serverConfig": &Config{
+			"serverConfig": &struct {
+				Host string `json:"host"`
+				Port int    `json:"port"`
+			}{
 				Host: "127.0.0.1",
 				Port: 8080,
 			},
@@ -446,16 +447,16 @@ func TestDeleteExtension(t *testing.T) {
 	})
 }
 
-func TestUpdateCheckExtension(t *testing.T) {
+func TestUpgradeCheckExtension(t *testing.T) {
 	doTest(func() {
 		identity := httpRequestCheckOk[string](http.MethodPost, "/api/v1/extensions", installExtensionReq)
-		resp := httpRequestCheckOk[*model.UpdateCheckExtensionResp](http.MethodGet, "/api/v1/extensions/"+identity+"/update", nil)
+		resp := httpRequestCheckOk[*model.UpgradeCheckExtensionResp](http.MethodGet, "/api/v1/extensions/"+identity+"/upgrade", nil)
 		// no new version
 		if resp.NewVersion != "" {
-			t.Errorf("UpdateCheckExtension() got = %v, want %v", resp.NewVersion, "")
+			t.Errorf("UpgradeCheckExtension() got = %v, want %v", resp.NewVersion, "")
 		}
 		// force update
-		httpRequestCheckOk[any](http.MethodPost, "/api/v1/extensions/"+identity+"/update", nil)
+		httpRequestCheckOk[any](http.MethodPost, "/api/v1/extensions/"+identity+"/upgrade", nil)
 	})
 }
 
@@ -506,13 +507,19 @@ func TestDoProxy(t *testing.T) {
 func TestApiToken(t *testing.T) {
 	var cfg = &model.StartConfig{}
 	cfg.Init()
-	cfg.ApiToken = "123456"
-	fileListener := doStart(cfg)
+	cfg.DownloadConfig = &base.DownloaderStoreConfig{
+		Http: &base.DownloaderHttpConfig{
+			Enable:   true,
+			ApiToken: "123456",
+		},
+	}
+	httpInstance, _ = Create(cfg)
+	fileListener := doStart()
 	defer func() {
 		if err := fileListener.Close(); err != nil {
 			panic(err)
 		}
-		Stop()
+		httpInstance.Close()
 	}()
 
 	status, _ := doHttpRequest0(http.MethodGet, "/api/v1/config", nil, nil)
@@ -521,7 +528,7 @@ func TestApiToken(t *testing.T) {
 	}
 
 	status, _ = doHttpRequest0(http.MethodGet, "/api/v1/config", map[string]string{
-		"X-Api-Token": cfg.ApiToken,
+		"X-Api-Token": cfg.DownloadConfig.Http.ApiToken,
 	}, nil)
 	if status != http.StatusOK {
 		t.Errorf("TestApiToken() got = %v, want %v", status, http.StatusOK)
@@ -532,18 +539,24 @@ func TestApiToken(t *testing.T) {
 func TestAuthorization(t *testing.T) {
 	var cfg = &model.StartConfig{}
 	cfg.Init()
-	cfg.ApiToken = "123456"
+	cfg.DownloadConfig = &base.DownloaderStoreConfig{
+		Http: &base.DownloaderHttpConfig{
+			Enable:   true,
+			ApiToken: "123456",
+		},
+	}
 	cfg.WebEnable = true
 	cfg.WebBasicAuth = &model.WebBasicAuth{
 		Username: "admin",
 		Password: "123456",
 	}
-	fileListener := doStart(cfg)
+	httpInstance, _ = Create(cfg)
+	fileListener := doStart()
 	defer func() {
 		if err := fileListener.Close(); err != nil {
 			panic(err)
 		}
-		Stop()
+		httpInstance.Close()
 	}()
 
 	status, _ := doHttpRequest0(http.MethodGet, "/api/v1/config", nil, nil)
@@ -559,7 +572,7 @@ func TestAuthorization(t *testing.T) {
 	}
 
 	status, _ = doHttpRequest0(http.MethodGet, "/api/v1/config", map[string]string{
-		"X-Api-Token": cfg.ApiToken,
+		"X-Api-Token": cfg.DownloadConfig.Http.ApiToken,
 	}, nil)
 	if status != http.StatusOK {
 		t.Errorf("TestAuthorization() got = %v, want %v", status, http.StatusOK)
@@ -573,17 +586,23 @@ func doTest(handler func()) {
 		cfg.Storage = storage
 		cfg.StorageDir = ".test_storage"
 		cfg.WebEnable = true
-		fileListener := doStart(cfg)
+		cfg.DownloadConfig = &base.DownloaderStoreConfig{
+			Http: &base.DownloaderHttpConfig{
+				Enable: true,
+			},
+		}
+		httpInstance, _ = Create(cfg)
+		fileListener := doStart()
 		defer func() {
 			if err := fileListener.Close(); err != nil {
 				panic(err)
 			}
-			Stop()
-			Downloader.Clear()
+			httpInstance.StopHttp()
+			httpInstance.Clear()
 		}()
 		defer func() {
-			Downloader.Pause(nil)
-			Downloader.Delete(nil, true)
+			httpInstance.PauseTasks(nil)
+			httpInstance.DeleteTasks(nil, true)
 			os.RemoveAll(cfg.StorageDir)
 		}()
 		taskReq.URL = "http://" + fileListener.Addr().String() + "/" + test.BuildName
@@ -593,15 +612,19 @@ func doTest(handler func()) {
 	testFunc(model.StorageBolt)
 }
 
-func doStart(cfg *model.StartConfig) net.Listener {
-	port, err := Start(cfg)
-	if err != nil {
-		panic(err)
-	}
+func doStart() net.Listener {
+	port := UnwrapResult(httpInstance.StartHttp())
 	restPort = port
 	return test.StartTestFileServer()
 }
 
+func UnwrapResult[T any](result *model.Result[T]) T {
+	if result.HasError() {
+		panic(result.Msg)
+	}
+	return result.Data
+}
+
 func doHttpRequest0(method string, path string, headers map[string]string, body any) (int, []byte) {
 	var reader io.Reader
 	if body != nil {

pkg/api/model/api.go

@@ -14,13 +14,10 @@ const (
 )
 
 type StartConfig struct {
-	Network           string                      `json:"network"`
-	Address           string                      `json:"address"`
 	RefreshInterval   int                         `json:"refreshInterval"`
 	Storage           Storage                     `json:"storage"`
 	StorageDir        string                      `json:"storageDir"`
 	WhiteDownloadDirs []string                    `json:"whiteDownloadDirs"`
-	ApiToken          string                      `json:"apiToken"`
 	DownloadConfig    *base.DownloaderStoreConfig `json:"downloadConfig"`
 
 	ProductionMode bool
@@ -31,12 +28,6 @@ type StartConfig struct {
 }
 
 func (cfg *StartConfig) Init() *StartConfig {
-	if cfg.Network == "" {
-		cfg.Network = "tcp"
-	}
-	if cfg.Address == "" {
-		cfg.Address = "127.0.0.1:0"
-	}
 	if cfg.RefreshInterval == 0 {
 		cfg.RefreshInterval = 350
 	}
@@ -59,3 +50,9 @@ func (cfg *WebBasicAuth) Authorization() string {
 	userId := cfg.Username + ":" + cfg.Password
 	return "Basic " + base64.StdEncoding.EncodeToString([]byte(userId))
 }
+
+type HttpListenResult struct {
+	Host string `json:"host"`
+	// Port is the http server real listen port.
+	Port int `json:"port"`
+}

pkg/api/model/extension.go

@@ -13,6 +13,6 @@ type SwitchExtension struct {
 	Status bool `json:"status"`
 }
 
-type UpdateCheckExtensionResp struct {
+type UpgradeCheckExtensionResp struct {
 	NewVersion string `json:"newVersion"`
 }

pkg/api/model/result.go

@@ -1,5 +1,7 @@
 package model
 
+import "encoding/json"
+
 type RespCode int
 
 const (
@@ -20,6 +22,15 @@ type Result[T any] struct {
 	Data T        `json:"data"`
 }
 
+func (r *Result[T]) Json() string {
+	buf, _ := json.Marshal(r)
+	return string(buf)
+}
+
+func (r *Result[T]) HasError() bool {
+	return r.Code != CodeOk
+}
+
 func NewOkResult[T any](data T) *Result[T] {
 	return &Result[T]{
 		Code: CodeOk,
@@ -33,14 +44,14 @@ func NewNilResult() *Result[any] {
 	}
 }
 
-func NewErrorResult(msg string, code ...RespCode) *Result[any] {
+func NewErrorResult[T any](msg string, code ...RespCode) *Result[T] {
 	// if code is not provided, the default code is CodeError
 	c := CodeError
 	if len(code) > 0 {
 		c = code[0]
 	}
 
-	return &Result[any]{
+	return &Result[T]{
 		Code: c,
 		Msg:  msg,
 	}

pkg/base/model.go

@@ -171,6 +171,7 @@ type DownloaderStoreConfig struct {
 	MaxRunning     int                    `json:"maxRunning"`     // MaxRunning is the max running download count
 	ProtocolConfig map[string]any         `json:"protocolConfig"` // ProtocolConfig is special config for each protocol
 	Extra          map[string]any         `json:"extra"`
+	Http           *DownloaderHttpConfig  `json:"http"`
 	Proxy          *DownloaderProxyConfig `json:"proxy"`
 }
 
@@ -181,6 +182,12 @@ func (cfg *DownloaderStoreConfig) Init() *DownloaderStoreConfig {
 	if cfg.ProtocolConfig == nil {
 		cfg.ProtocolConfig = make(map[string]any)
 	}
+	if cfg.Extra == nil {
+		cfg.Extra = make(map[string]any)
+	}
+	if cfg.Http == nil {
+		cfg.Http = &DownloaderHttpConfig{}
+	}
 	if cfg.Proxy == nil {
 		cfg.Proxy = &DownloaderProxyConfig{}
 	}
@@ -203,12 +210,28 @@ func (cfg *DownloaderStoreConfig) Merge(beforeCfg *DownloaderStoreConfig) *Downl
 	if cfg.Extra == nil {
 		cfg.Extra = beforeCfg.Extra
 	}
+	if cfg.Http == nil {
+		cfg.Http = beforeCfg.Http
+	}
 	if cfg.Proxy == nil {
 		cfg.Proxy = beforeCfg.Proxy
 	}
 	return cfg
 }
 
+type DownloaderHttpConfig struct {
+	// Enable is the flag that enable http server
+	Enable bool `json:"Enable"`
+	// Host is the http server listen address.
+	Host string `json:"host"`
+	// Port is the http server listen port.
+	Port int `json:"port"`
+	// ApiToken is the auth token for http API
+	ApiToken string `json:"apiToken"`
+	// RunningPort is the http server real listen port.
+	RunningPort int `json:"runningPort"`
+}
+
 type DownloaderProxyConfig struct {
 	Enable bool `json:"enable"`
 	// System is the flag that use system proxy

pkg/base/model_test.go

@@ -17,6 +17,8 @@ func TestDownloaderStoreConfig_Init(t *testing.T) {
 			&DownloaderStoreConfig{
 				MaxRunning:     5,
 				ProtocolConfig: map[string]any{},
+				Extra:          make(map[string]any),
+				Http:           &DownloaderHttpConfig{},
 				Proxy:          &DownloaderProxyConfig{},
 			},
 		},
@@ -28,6 +30,8 @@ func TestDownloaderStoreConfig_Init(t *testing.T) {
 			&DownloaderStoreConfig{
 				MaxRunning:     10,
 				ProtocolConfig: map[string]any{},
+				Extra:          make(map[string]any),
+				Http:           &DownloaderHttpConfig{},
 				Proxy:          &DownloaderProxyConfig{},
 			},
 		},
@@ -43,6 +47,8 @@ func TestDownloaderStoreConfig_Init(t *testing.T) {
 				ProtocolConfig: map[string]any{
 					"key": "value",
 				},
+				Extra: make(map[string]any),
+				Http:  &DownloaderHttpConfig{},
 				Proxy: &DownloaderProxyConfig{},
 			},
 		},
@@ -56,6 +62,8 @@ func TestDownloaderStoreConfig_Init(t *testing.T) {
 			&DownloaderStoreConfig{
 				MaxRunning:     5,
 				ProtocolConfig: map[string]any{},
+				Extra:          make(map[string]any),
+				Http:           &DownloaderHttpConfig{},
 				Proxy: &DownloaderProxyConfig{
 					Enable: true,
 				},

pkg/download/downloader.go

@@ -252,7 +252,7 @@ func (d *Downloader) setupFetcher(fm fetcher.FetcherManager, fetcher fetcher.Fet
 	ctl.GetConfig = func(v any) {
 		d.getProtocolConfig(fm.Name(), v)
 	}
-	// Get proxy config, task request proxy config has higher priority, then use global proxy config
+	// get proxy config, task request proxy config has higher priority, then use global proxy config
 	ctl.GetProxy = func(requestProxy *base.RequestProxy) func(*gohttp.Request) (*url.URL, error) {
 		if requestProxy == nil {
 			return d.cfg.Proxy.ToHandler()
@@ -390,7 +390,7 @@ func (d *Downloader) Pause(filter *TaskFilter) (err error) {
 		return d.pauseAll()
 	}
 
-	filter.NotStatuses = []base.Status{base.DownloadStatusPause, base.DownloadStatusError, base.DownloadStatusDone}
+	filter.NotStatus = []base.Status{base.DownloadStatusPause, base.DownloadStatusError, base.DownloadStatusDone}
 	pauseTasks := d.GetTasksByFilter(filter)
 	if len(pauseTasks) == 0 {
 		return ErrTaskNotFound
@@ -430,7 +430,7 @@ func (d *Downloader) Continue(filter *TaskFilter) (err error) {
 		return d.continueAll()
 	}
 
-	filter.NotStatuses = []base.Status{base.DownloadStatusRunning, base.DownloadStatusDone}
+	filter.NotStatus = []base.Status{base.DownloadStatusRunning, base.DownloadStatusDone}
 	continueTasks := d.GetTasksByFilter(filter)
 	if len(continueTasks) == 0 {
 		return ErrTaskNotFound
@@ -527,7 +527,7 @@ func (d *Downloader) ContinueBatch(filter *TaskFilter) (err error) {
 
 func (d *Downloader) Delete(filter *TaskFilter, force bool) (err error) {
 	if filter == nil || filter.IsEmpty() {
-		return d.deleteAll()
+		return d.deleteAll(force)
 	}
 
 	deleteTasks := d.GetTasksByFilter(filter)
@@ -572,24 +572,27 @@ func (d *Downloader) Delete(filter *TaskFilter, force bool) (err error) {
 	return
 }
 
-func (d *Downloader) deleteAll() (err error) {
+func (d *Downloader) deleteAll(force bool) (err error) {
+	deleteTasksPtr := make([]*Task, 0)
+
 	func() {
 		d.lock.Lock()
 		defer d.lock.Unlock()
 
+		deleteTasksPtr = append(deleteTasksPtr, d.tasks...)
 		d.tasks = make([]*Task, 0)
 		d.waitTasks = make([]*Task, 0)
 	}()
 
-	for _, task := range d.tasks {
-		if err = d.doDelete(task, true); err != nil {
+	for _, task := range deleteTasksPtr {
+		if err = d.doDelete(task, force); err != nil {
 			return
 		}
 	}
 	return
 }
 
-func (d *Downloader) Stats(id string) (sr any, err error) {
+func (d *Downloader) GetTaskStats(id string) (sr any, err error) {
 	task := d.GetTask(id)
 	if task == nil {
 		return sr, ErrTaskNotFound
@@ -719,10 +722,10 @@ func (d *Downloader) GetTasksByFilter(filter *TaskFilter) []*Task {
 	}
 
 	idMatch := func(task *Task) bool {
-		if len(filter.IDs) == 0 {
+		if len(filter.ID) == 0 {
 			return true
 		}
-		for _, id := range filter.IDs {
+		for _, id := range filter.ID {
 			if task.ID == id {
 				return true
 			}
@@ -730,10 +733,10 @@ func (d *Downloader) GetTasksByFilter(filter *TaskFilter) []*Task {
 		return false
 	}
 	statusMatch := func(task *Task) bool {
-		if len(filter.Statuses) == 0 {
+		if len(filter.Status) == 0 {
 			return true
 		}
-		for _, status := range filter.Statuses {
+		for _, status := range filter.Status {
 			if task.Status == status {
 				return true
 			}
@@ -741,10 +744,10 @@ func (d *Downloader) GetTasksByFilter(filter *TaskFilter) []*Task {
 		return false
 	}
 	notStatusMatch := func(task *Task) bool {
-		if len(filter.NotStatuses) == 0 {
+		if len(filter.NotStatus) == 0 {
 			return true
 		}
-		for _, status := range filter.NotStatuses {
+		for _, status := range filter.NotStatus {
 			if task.Status == status {
 				return false
 			}

pkg/download/downloader_test.go

@@ -400,7 +400,7 @@ func TestDownloader_StoreAndRestore(t *testing.T) {
 		t.Fatal(err)
 	}
 	time.Sleep(time.Millisecond * 1001)
-	err = downloader.Pause(&TaskFilter{IDs: []string{id}})
+	err = downloader.Pause(&TaskFilter{ID: []string{id}})
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -424,7 +424,7 @@ func TestDownloader_StoreAndRestore(t *testing.T) {
 			wg.Done()
 		}
 	})
-	err = downloader.Continue(&TaskFilter{IDs: []string{id}})
+	err = downloader.Continue(&TaskFilter{ID: []string{id}})
 	wg.Wait()
 	if err != nil {
 		t.Fatal(err)
@@ -551,7 +551,7 @@ func TestDownloader_GetTasksByFilter(t *testing.T) {
 
 	t.Run("GetTasksByFilter ids", func(t *testing.T) {
 		tasks := downloader.GetTasksByFilter(&TaskFilter{
-			IDs: taskIds,
+			ID: taskIds,
 		})
 		if len(tasks) != len(reqs) {
 			t.Errorf("GetTasksByFilter ids task got = %v, want %v", len(tasks), len(reqs))
@@ -560,7 +560,7 @@ func TestDownloader_GetTasksByFilter(t *testing.T) {
 
 	t.Run("GetTasksByFilter match ids", func(t *testing.T) {
 		tasks := downloader.GetTasksByFilter(&TaskFilter{
-			IDs: []string{taskIds[0]},
+			ID: []string{taskIds[0]},
 		})
 		if len(tasks) != 1 {
 			t.Errorf("GetTasksByFilter ids task got = %v, want %v", len(tasks), 1)
@@ -569,7 +569,7 @@ func TestDownloader_GetTasksByFilter(t *testing.T) {
 
 	t.Run("GetTasksByFilter not match ids", func(t *testing.T) {
 		tasks := downloader.GetTasksByFilter(&TaskFilter{
-			IDs: []string{"xxx"},
+			ID: []string{"xxx"},
 		})
 		if len(tasks) != 0 {
 			t.Errorf("GetTasksByFilter ids task got = %v, want %v", len(tasks), 0)
@@ -578,7 +578,7 @@ func TestDownloader_GetTasksByFilter(t *testing.T) {
 
 	t.Run("GetTasksByFilter status", func(t *testing.T) {
 		tasks := downloader.GetTasksByFilter(&TaskFilter{
-			Statuses: []base.Status{base.DownloadStatusDone},
+			Status: []base.Status{base.DownloadStatusDone},
 		})
 		if len(tasks) != len(reqs) {
 			t.Errorf("GetTasksByFilter status task got = %v, want %v", len(tasks), len(reqs))
@@ -587,7 +587,7 @@ func TestDownloader_GetTasksByFilter(t *testing.T) {
 
 	t.Run("GetTasksByFilter not match status", func(t *testing.T) {
 		tasks := downloader.GetTasksByFilter(&TaskFilter{
-			Statuses: []base.Status{base.DownloadStatusError},
+			Status: []base.Status{base.DownloadStatusError},
 		})
 		if len(tasks) != 0 {
 			t.Errorf("GetTasksByFilter status task got = %v, want %v", len(tasks), 0)
@@ -596,7 +596,7 @@ func TestDownloader_GetTasksByFilter(t *testing.T) {
 
 	t.Run("GetTasksByFilter match notStatus", func(t *testing.T) {
 		tasks := downloader.GetTasksByFilter(&TaskFilter{
-			NotStatuses: []base.Status{base.DownloadStatusRunning, base.DownloadStatusPause},
+			NotStatus: []base.Status{base.DownloadStatusRunning, base.DownloadStatusPause},
 		})
 		if len(tasks) != len(reqs) {
 			t.Errorf("GetTasksByFilter match notStatus task got = %v, want %v", len(tasks), len(reqs))
@@ -605,7 +605,7 @@ func TestDownloader_GetTasksByFilter(t *testing.T) {
 
 	t.Run("GetTasksByFilter not match notStatus", func(t *testing.T) {
 		tasks := downloader.GetTasksByFilter(&TaskFilter{
-			NotStatuses: []base.Status{base.DownloadStatusDone},
+			NotStatus: []base.Status{base.DownloadStatusDone},
 		})
 		if len(tasks) != 0 {
 			t.Errorf("GetTasksByFilter not match notStatus task got = %v, want %v", len(tasks), 0)
@@ -614,8 +614,8 @@ func TestDownloader_GetTasksByFilter(t *testing.T) {
 
 	t.Run("GetTasksByFilter match ids and status", func(t *testing.T) {
 		tasks := downloader.GetTasksByFilter(&TaskFilter{
-			IDs:      []string{taskIds[0]},
-			Statuses: []base.Status{base.DownloadStatusDone},
+			ID:     []string{taskIds[0]},
+			Status: []base.Status{base.DownloadStatusDone},
 		})
 		if len(tasks) != 1 {
 			t.Errorf("GetTasksByFilter match ids and status task got = %v, want %v", len(tasks), 1)
@@ -624,8 +624,8 @@ func TestDownloader_GetTasksByFilter(t *testing.T) {
 
 	t.Run("GetTasksByFilter not match ids and status", func(t *testing.T) {
 		tasks := downloader.GetTasksByFilter(&TaskFilter{
-			IDs:      []string{taskIds[0]},
-			Statuses: []base.Status{base.DownloadStatusError},
+			ID:     []string{taskIds[0]},
+			Status: []base.Status{base.DownloadStatusError},
 		})
 		if len(tasks) != 0 {
 			t.Errorf("GetTasksByFilter not match ids and status task got = %v, want %v", len(tasks), 0)

pkg/download/extension.go

@@ -727,13 +727,13 @@ func NewExtensionTask(download *Downloader, task *Task) *ExtensionTask {
 
 func (t *ExtensionTask) Continue() error {
 	return t.download.Continue(&TaskFilter{
-		IDs: []string{t.task.ID},
+		ID: []string{t.task.ID},
 	})
 }
 
 func (t *ExtensionTask) Pause() error {
 	return t.download.Pause(&TaskFilter{
-		IDs: []string{t.task.ID},
+		ID: []string{t.task.ID},
 	})
 }
 

pkg/download/model.go

@@ -75,7 +75,7 @@ func (t *Task) Name() string {
 		return t.Meta.Res.Name
 	}
 
-	// Get the name of the first file
+	// get the name of the first file
 	return t.Meta.Res.Files[0].Name
 }
 
@@ -113,13 +113,13 @@ func (t *Task) calcSpeed(speedArr []int64, downloaded int64, usedTime float64) i
 }
 
 type TaskFilter struct {
-	IDs         []string
-	Statuses    []base.Status
-	NotStatuses []base.Status
+	ID        []string      `json:"id"`
+	Status    []base.Status `json:"status"`
+	NotStatus []base.Status `json:"notStatus"`
 }
 
 func (f *TaskFilter) IsEmpty() bool {
-	return len(f.IDs) == 0 && len(f.Statuses) == 0 && len(f.NotStatuses) == 0
+	return len(f.ID) == 0 && len(f.Status) == 0 && len(f.NotStatus) == 0
 }
 
 type DownloaderConfig struct {

pkg/rest/api.go

@@ -1,389 +0,0 @@
-package rest
-
-import (
-	"github.com/GopeedLab/gopeed/pkg/base"
-	"github.com/GopeedLab/gopeed/pkg/download"
-	"github.com/GopeedLab/gopeed/pkg/rest/model"
-	"github.com/gorilla/mux"
-	"io"
-	"net/http"
-	"net/url"
-	"runtime"
-)
-
-func Info(w http.ResponseWriter, r *http.Request) {
-	info := map[string]any{
-		"version":  base.Version,
-		"runtime":  runtime.Version(),
-		"os":       runtime.GOOS,
-		"arch":     runtime.GOARCH,
-		"inDocker": base.InDocker == "true",
-	}
-	WriteJson(w, model.NewOkResult(info))
-}
-
-func Resolve(w http.ResponseWriter, r *http.Request) {
-	var req base.Request
-	if ReadJson(r, w, &req) {
-		rr, err := Downloader.Resolve(&req)
-		if err != nil {
-			WriteJson(w, model.NewErrorResult(err.Error()))
-			return
-		}
-		WriteJson(w, model.NewOkResult(rr))
-	}
-}
-
-func CreateTask(w http.ResponseWriter, r *http.Request) {
-	var req model.CreateTask
-	if ReadJson(r, w, &req) {
-		var (
-			taskId string
-			err    error
-		)
-		if req.Rid != "" {
-			taskId, err = Downloader.Create(req.Rid, req.Opt)
-		} else if req.Req != nil {
-			taskId, err = Downloader.CreateDirect(req.Req, req.Opt)
-		} else {
-			WriteJson(w, model.NewErrorResult("param invalid: rid or req", model.CodeInvalidParam))
-			return
-		}
-		if err != nil {
-			WriteJson(w, model.NewErrorResult(err.Error()))
-			return
-		}
-		WriteJson(w, model.NewOkResult(taskId))
-	}
-}
-
-func CreateTaskBatch(w http.ResponseWriter, r *http.Request) {
-	var req model.CreateTaskBatch
-	if ReadJson(r, w, &req) {
-		if len(req.Reqs) == 0 {
-			WriteJson(w, model.NewErrorResult("param invalid: reqs", model.CodeInvalidParam))
-			return
-		}
-		taskIds, err := Downloader.CreateDirectBatch(req.Reqs, req.Opt)
-		if err != nil {
-			WriteJson(w, model.NewErrorResult(err.Error()))
-			return
-		}
-		WriteJson(w, model.NewOkResult(taskIds))
-	}
-}
-
-func PauseTask(w http.ResponseWriter, r *http.Request) {
-	filter, errResult := parseIdFilter(r)
-	if errResult != nil {
-		WriteJson(w, errResult)
-		return
-	}
-
-	if err := Downloader.Pause(filter); err != nil {
-		WriteJson(w, model.NewErrorResult(err.Error()))
-		return
-	}
-	WriteJson(w, model.NewNilResult())
-}
-
-func PauseTasks(w http.ResponseWriter, r *http.Request) {
-	filter, errResult := parseFilter(r)
-	if errResult != nil {
-		WriteJson(w, errResult)
-		return
-	}
-
-	if err := Downloader.Pause(filter); err != nil {
-		WriteJson(w, model.NewErrorResult(err.Error()))
-		return
-	}
-	WriteJson(w, model.NewNilResult())
-}
-
-func ContinueTask(w http.ResponseWriter, r *http.Request) {
-	filter, errResult := parseIdFilter(r)
-	if errResult != nil {
-		WriteJson(w, errResult)
-		return
-	}
-
-	if err := Downloader.Continue(filter); err != nil {
-		WriteJson(w, model.NewErrorResult(err.Error()))
-		return
-	}
-	WriteJson(w, model.NewNilResult())
-}
-
-func ContinueTasks(w http.ResponseWriter, r *http.Request) {
-	filter, errResult := parseFilter(r)
-	if errResult != nil {
-		WriteJson(w, errResult)
-		return
-	}
-
-	if err := Downloader.Continue(filter); err != nil {
-		WriteJson(w, model.NewErrorResult(err.Error()))
-		return
-	}
-	WriteJson(w, model.NewNilResult())
-}
-
-func DeleteTask(w http.ResponseWriter, r *http.Request) {
-	filter, errResult := parseIdFilter(r)
-	if errResult != nil {
-		WriteJson(w, errResult)
-		return
-	}
-	force := r.FormValue("force")
-
-	if err := Downloader.Delete(filter, force == "true"); err != nil {
-		WriteJson(w, model.NewErrorResult(err.Error()))
-		return
-	}
-	WriteJson(w, model.NewNilResult())
-}
-
-func DeleteTasks(w http.ResponseWriter, r *http.Request) {
-	filter, errResult := parseFilter(r)
-	if errResult != nil {
-		WriteJson(w, errResult)
-		return
-	}
-	force := r.FormValue("force")
-
-	if err := Downloader.Delete(filter, force == "true"); err != nil {
-		WriteJson(w, model.NewErrorResult(err.Error()))
-		return
-	}
-	WriteJson(w, model.NewNilResult())
-}
-
-func GetTask(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-	taskId := vars["id"]
-	if taskId == "" {
-		WriteJson(w, model.NewErrorResult("param invalid: id", model.CodeInvalidParam))
-		return
-	}
-	task := Downloader.GetTask(taskId)
-	if task == nil {
-		WriteJson(w, model.NewErrorResult("task not found", model.CodeTaskNotFound))
-		return
-	}
-	WriteJson(w, model.NewOkResult(task))
-}
-
-func GetTasks(w http.ResponseWriter, r *http.Request) {
-	filter, errResult := parseFilter(r)
-	if errResult != nil {
-		WriteJson(w, errResult)
-		return
-	}
-
-	tasks := Downloader.GetTasksByFilter(filter)
-	WriteJson(w, model.NewOkResult(tasks))
-}
-
-func GetConfig(w http.ResponseWriter, r *http.Request) {
-	WriteJson(w, model.NewOkResult(getServerConfig()))
-}
-
-func PutConfig(w http.ResponseWriter, r *http.Request) {
-	var cfg base.DownloaderStoreConfig
-	if ReadJson(r, w, &cfg) {
-		if err := Downloader.PutConfig(&cfg); err != nil {
-			WriteJson(w, model.NewErrorResult(err.Error()))
-			return
-		}
-	}
-	WriteJson(w, model.NewNilResult())
-}
-
-func InstallExtension(w http.ResponseWriter, r *http.Request) {
-	var req model.InstallExtension
-	if ReadJson(r, w, &req) {
-		var (
-			installedExt *download.Extension
-			err          error
-		)
-		if req.DevMode {
-			installedExt, err = Downloader.InstallExtensionByFolder(req.URL, true)
-		} else {
-			installedExt, err = Downloader.InstallExtensionByGit(req.URL)
-		}
-		if err != nil {
-			WriteJson(w, model.NewErrorResult(err.Error()))
-			return
-		}
-		WriteJson(w, model.NewOkResult(installedExt.Identity))
-	}
-}
-
-func GetExtensions(w http.ResponseWriter, r *http.Request) {
-	list := Downloader.GetExtensions()
-	WriteJson(w, model.NewOkResult(list))
-}
-
-func GetExtension(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-	identity := vars["identity"]
-	ext, err := Downloader.GetExtension(identity)
-	if err != nil {
-		WriteJson(w, model.NewErrorResult(err.Error()))
-		return
-	}
-	WriteJson(w, model.NewOkResult(ext))
-}
-
-func UpdateExtensionSettings(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-	identity := vars["identity"]
-	var req model.UpdateExtensionSettings
-	if ReadJson(r, w, &req) {
-		if err := Downloader.UpdateExtensionSettings(identity, req.Settings); err != nil {
-			WriteJson(w, model.NewErrorResult(err.Error()))
-			return
-		}
-	}
-	WriteJson(w, model.NewNilResult())
-}
-
-func SwitchExtension(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-	identity := vars["identity"]
-	var switchExtension model.SwitchExtension
-	if ReadJson(r, w, &switchExtension) {
-		if err := Downloader.SwitchExtension(identity, switchExtension.Status); err != nil {
-			WriteJson(w, model.NewErrorResult(err.Error()))
-			return
-		}
-	}
-	WriteJson(w, model.NewNilResult())
-}
-
-func DeleteExtension(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-	identity := vars["identity"]
-	if err := Downloader.DeleteExtension(identity); err != nil {
-		WriteJson(w, model.NewErrorResult(err.Error()))
-		return
-	}
-	WriteJson(w, model.NewNilResult())
-}
-
-func UpdateCheckExtension(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-	identity := vars["identity"]
-	newVersion, err := Downloader.UpgradeCheckExtension(identity)
-	if err != nil {
-		WriteJson(w, model.NewErrorResult(err.Error()))
-		return
-	}
-	WriteJson(w, model.NewOkResult(&model.UpdateCheckExtensionResp{
-		NewVersion: newVersion,
-	}))
-}
-
-func UpdateExtension(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-	identity := vars["identity"]
-	if err := Downloader.UpgradeExtension(identity); err != nil {
-		WriteJson(w, model.NewErrorResult(err.Error()))
-		return
-	}
-	WriteJson(w, model.NewNilResult())
-}
-
-func DoProxy(w http.ResponseWriter, r *http.Request) {
-	target := r.Header.Get("X-Target-Uri")
-	if target == "" {
-		writeError(w, "param invalid: X-Target-Uri")
-		return
-	}
-	targetUrl, err := url.Parse(target)
-	if err != nil {
-		writeError(w, err.Error())
-		return
-	}
-	r.RequestURI = ""
-	r.URL = targetUrl
-	r.Host = targetUrl.Host
-	resp, err := http.DefaultClient.Do(r)
-	if err != nil {
-		writeError(w, err.Error())
-		return
-	}
-	defer resp.Body.Close()
-	for k, vv := range resp.Header {
-		for _, v := range vv {
-			w.Header().Set(k, v)
-		}
-	}
-	w.WriteHeader(resp.StatusCode)
-	buf, err := io.ReadAll(resp.Body)
-	if err != nil {
-		writeError(w, err.Error())
-		return
-	}
-	w.Write(buf)
-}
-
-func GetStats(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-	taskId := vars["id"]
-	if taskId == "" {
-		WriteJson(w, model.NewErrorResult("param invalid: id", model.CodeInvalidParam))
-		return
-	}
-	statsResult, err := Downloader.Stats(taskId)
-	if err != nil {
-		writeError(w, err.Error())
-		return
-	}
-	WriteJson(w, model.NewOkResult(statsResult))
-}
-
-func parseIdFilter(r *http.Request) (*download.TaskFilter, any) {
-	vars := mux.Vars(r)
-	taskId := vars["id"]
-	if taskId == "" {
-		return nil, model.NewErrorResult("param invalid: id", model.CodeInvalidParam)
-	}
-
-	filter := &download.TaskFilter{
-		IDs: []string{taskId},
-	}
-	return filter, nil
-}
-
-func parseFilter(r *http.Request) (*download.TaskFilter, any) {
-	if err := r.ParseForm(); err != nil {
-		return nil, model.NewErrorResult(err.Error())
-	}
-
-	filter := &download.TaskFilter{
-		IDs:         r.Form["id"],
-		Statuses:    convertStatues(r.Form["status"]),
-		NotStatuses: convertStatues(r.Form["notStatus"]),
-	}
-	return filter, nil
-}
-
-func convertStatues(statues []string) []base.Status {
-	result := make([]base.Status, 0)
-	for _, status := range statues {
-		result = append(result, base.Status(status))
-	}
-	return result
-}
-
-func writeError(w http.ResponseWriter, msg string) {
-	w.WriteHeader(http.StatusInternalServerError)
-	w.Write([]byte(msg))
-}
-
-func getServerConfig() *base.DownloaderStoreConfig {
-	cfg, _ := Downloader.GetConfig()
-	return cfg
-}

pkg/rest/config.go

@@ -1,6 +0,0 @@
-package rest
-
-type Config struct {
-	Host string `json:"host"`
-	Port int    `json:"port"`
-}

pkg/rest/server.go

@@ -1,241 +0,0 @@
-package rest
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"github.com/GopeedLab/gopeed/pkg/download"
-	"github.com/GopeedLab/gopeed/pkg/rest/model"
-	"github.com/GopeedLab/gopeed/pkg/util"
-	"github.com/gorilla/handlers"
-	"github.com/gorilla/mux"
-	"github.com/pkg/errors"
-	"net"
-	"net/http"
-	"os"
-	"path/filepath"
-	"regexp"
-	"strings"
-)
-
-var (
-	srv         *http.Server
-	runningPort int
-
-	Downloader *download.Downloader
-)
-
-func Start(startCfg *model.StartConfig) (port int, err error) {
-	// avoid repeat start
-	if srv != nil {
-		return runningPort, nil
-	}
-
-	var listener net.Listener
-	srv, listener, err = BuildServer(startCfg)
-	if err != nil {
-		return
-	}
-
-	go func() {
-		if err := srv.Serve(listener); err != nil && !errors.Is(err, http.ErrServerClosed) {
-			panic(err)
-		}
-	}()
-
-	if addr, ok := listener.Addr().(*net.TCPAddr); ok {
-		port = addr.Port
-		runningPort = port
-	}
-	return
-}
-
-func Stop() {
-	defer func() {
-		srv = nil
-	}()
-
-	if srv != nil {
-		if err := srv.Shutdown(context.TODO()); err != nil {
-			Downloader.Logger.Warn().Err(err).Msg("shutdown server failed")
-		}
-	}
-	if Downloader != nil {
-		if err := Downloader.Close(); err != nil {
-			Downloader.Logger.Warn().Err(err).Msg("close downloader failed")
-		}
-	}
-}
-
-func BuildServer(startCfg *model.StartConfig) (*http.Server, net.Listener, error) {
-	if startCfg == nil {
-		startCfg = &model.StartConfig{}
-	}
-	startCfg.Init()
-
-	downloadCfg := &download.DownloaderConfig{
-		ProductionMode:  startCfg.ProductionMode,
-		RefreshInterval: startCfg.RefreshInterval,
-	}
-	if startCfg.Storage == model.StorageBolt {
-		downloadCfg.Storage = download.NewBoltStorage(startCfg.StorageDir)
-	} else {
-		downloadCfg.Storage = download.NewMemStorage()
-	}
-	downloadCfg.StorageDir = startCfg.StorageDir
-	downloadCfg.Init()
-	Downloader = download.NewDownloader(downloadCfg)
-	if err := Downloader.Setup(); err != nil {
-		return nil, nil, err
-	}
-
-	if startCfg.Network == "unix" {
-		util.SafeRemove(startCfg.Address)
-	}
-
-	listener, err := net.Listen(startCfg.Network, startCfg.Address)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	var r = mux.NewRouter()
-	r.Methods(http.MethodGet).Path("/api/v1/info").HandlerFunc(Info)
-	r.Methods(http.MethodPost).Path("/api/v1/resolve").HandlerFunc(Resolve)
-	r.Methods(http.MethodPost).Path("/api/v1/tasks").HandlerFunc(CreateTask)
-	r.Methods(http.MethodPost).Path("/api/v1/tasks/batch").HandlerFunc(CreateTaskBatch)
-	r.Methods(http.MethodPut).Path("/api/v1/tasks/{id}/pause").HandlerFunc(PauseTask)
-	r.Methods(http.MethodPut).Path("/api/v1/tasks/pause").HandlerFunc(PauseTasks)
-	r.Methods(http.MethodPut).Path("/api/v1/tasks/{id}/continue").HandlerFunc(ContinueTask)
-	r.Methods(http.MethodPut).Path("/api/v1/tasks/continue").HandlerFunc(ContinueTasks)
-	r.Methods(http.MethodDelete).Path("/api/v1/tasks/{id}").HandlerFunc(DeleteTask)
-	r.Methods(http.MethodDelete).Path("/api/v1/tasks").HandlerFunc(DeleteTasks)
-	r.Methods(http.MethodGet).Path("/api/v1/tasks/{id}").HandlerFunc(GetTask)
-	r.Methods(http.MethodGet).Path("/api/v1/tasks").HandlerFunc(GetTasks)
-	r.Methods(http.MethodGet).Path("/api/v1/tasks/{id}/stats").HandlerFunc(GetStats)
-	r.Methods(http.MethodGet).Path("/api/v1/config").HandlerFunc(GetConfig)
-	r.Methods(http.MethodPut).Path("/api/v1/config").HandlerFunc(PutConfig)
-	r.Methods(http.MethodPost).Path("/api/v1/extensions").HandlerFunc(InstallExtension)
-	r.Methods(http.MethodGet).Path("/api/v1/extensions").HandlerFunc(GetExtensions)
-	r.Methods(http.MethodGet).Path("/api/v1/extensions/{identity}").HandlerFunc(GetExtension)
-	r.Methods(http.MethodPut).Path("/api/v1/extensions/{identity}/settings").HandlerFunc(UpdateExtensionSettings)
-	r.Methods(http.MethodPut).Path("/api/v1/extensions/{identity}/switch").HandlerFunc(SwitchExtension)
-	r.Methods(http.MethodDelete).Path("/api/v1/extensions/{identity}").HandlerFunc(DeleteExtension)
-	r.Methods(http.MethodGet).Path("/api/v1/extensions/{identity}/update").HandlerFunc(UpdateCheckExtension)
-	r.Methods(http.MethodPost).Path("/api/v1/extensions/{identity}/update").HandlerFunc(UpdateExtension)
-	r.Path("/api/v1/proxy").HandlerFunc(DoProxy)
-	if startCfg.WebEnable {
-		r.PathPrefix("/fs/tasks").Handler(http.FileServer(new(taskFileSystem)))
-		r.PathPrefix("/fs/extensions").Handler(http.FileServer(new(extensionFileSystem)))
-		r.PathPrefix("/").Handler(http.FileServer(http.FS(startCfg.WebFS)))
-	}
-
-	if startCfg.ApiToken != "" || (startCfg.WebEnable && startCfg.WebBasicAuth != nil) {
-		r.Use(func(h http.Handler) http.Handler {
-			return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-				if startCfg.ApiToken != "" && r.Header.Get("X-Api-Token") == startCfg.ApiToken {
-					h.ServeHTTP(w, r)
-					return
-				}
-				if startCfg.WebEnable && startCfg.WebBasicAuth != nil {
-					if r.Header.Get("Authorization") == startCfg.WebBasicAuth.Authorization() {
-						h.ServeHTTP(w, r)
-						return
-					}
-					w.Header().Set("WWW-Authenticate", "Basic realm=\"gopeed web\"")
-				}
-				WriteStatusJson(w, http.StatusUnauthorized, model.NewErrorResult("unauthorized", model.CodeUnauthorized))
-			})
-		})
-	}
-
-	// recover panic
-	r.Use(func(h http.Handler) http.Handler {
-		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			defer func() {
-				if v := recover(); v != nil {
-					err := errors.WithStack(fmt.Errorf("%v", v))
-					Downloader.Logger.Error().Stack().Err(err).Msgf("http server panic: %s %s", r.Method, r.RequestURI)
-					WriteJson(w, model.NewErrorResult(err.Error(), model.CodeError))
-				}
-			}()
-			h.ServeHTTP(w, r)
-		})
-	})
-
-	srv = &http.Server{Handler: handlers.CORS(
-		handlers.AllowedHeaders([]string{"Content-Type", "X-Api-Token", "X-Target-Uri"}),
-		handlers.AllowedMethods([]string{"GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"}),
-		handlers.AllowedOrigins([]string{"*"}),
-	)(r)}
-	return srv, listener, nil
-}
-
-func resolvePath(urlPath string, prefix string) (identity string, path string, err error) {
-	// remove prefix
-	clearPath := strings.TrimPrefix(urlPath, prefix)
-	// match extension identity, eg: /fs/extensions/identity/xxx
-	reg := regexp.MustCompile(`^/([^/]+)/(.*)$`)
-	if !reg.MatchString(clearPath) {
-		err = os.ErrNotExist
-		return
-	}
-	matched := reg.FindStringSubmatch(clearPath)
-	if len(matched) != 3 {
-		err = os.ErrNotExist
-		return
-	}
-	return matched[1], matched[2], nil
-}
-
-// handle task file resource
-type taskFileSystem struct {
-}
-
-func (e *taskFileSystem) Open(name string) (http.File, error) {
-	// get extension identity
-	identity, path, err := resolvePath(name, "/fs/tasks")
-	if err != nil {
-		return nil, err
-	}
-	task := Downloader.GetTask(identity)
-	if task == nil {
-		return nil, os.ErrNotExist
-	}
-	return os.Open(filepath.Join(task.Meta.RootDirPath(), path))
-}
-
-// handle extension file resource
-type extensionFileSystem struct {
-}
-
-func (e *extensionFileSystem) Open(name string) (http.File, error) {
-	// get extension identity
-	identity, path, err := resolvePath(name, "/fs/extensions")
-	if err != nil {
-		return nil, err
-	}
-	extension, err := Downloader.GetExtension(identity)
-	if err != nil {
-		return nil, os.ErrNotExist
-	}
-	extensionPath := Downloader.ExtensionPath(extension)
-	return os.Open(filepath.Join(extensionPath, path))
-}
-
-func ReadJson(r *http.Request, w http.ResponseWriter, v any) bool {
-	if err := json.NewDecoder(r.Body).Decode(v); err != nil {
-		WriteJson(w, model.NewErrorResult(err.Error()))
-		return false
-	}
-	return true
-}
-
-func WriteJson(w http.ResponseWriter, v any) {
-	WriteStatusJson(w, http.StatusOK, v)
-}
-
-func WriteStatusJson(w http.ResponseWriter, statusCode int, v any) {
-	w.Header().Set("Content-Type", "application/json; charset=utf-8")
-	w.WriteHeader(statusCode)
-	json.NewEncoder(w).Encode(v)
-}

ui/flutter/include/libgopeed.h

@@ -74,14 +74,8 @@ typedef struct { void *data; GoInt len; GoInt cap; } GoSlice;
 extern "C" {
 #endif
 
-
-/* Return type for Start */
-struct Start_return {
-	GoInt r0;
-	char* r1;
-};
-extern struct Start_return Start(char* cfg);
-extern void Stop();
+extern __declspec(dllexport) char* Init(char* cfg);
+extern __declspec(dllexport) char* Invoke(char* req);
 
 #ifdef __cplusplus
 }

ui/flutter/lib/api/api.dart

@@ -1,210 +0,0 @@
-import 'dart:io';
-
-import 'package:dio/dio.dart';
-import 'package:dio/io.dart';
-import 'package:flutter/foundation.dart';
-import 'package:gopeed/api/model/extension.dart';
-import 'package:gopeed/api/model/install_extension.dart';
-import 'package:gopeed/api/model/switch_extension.dart';
-
-import '../util/util.dart';
-import 'model/create_task.dart';
-import 'model/downloader_config.dart';
-import 'model/request.dart';
-import 'model/resolve_result.dart';
-import 'model/result.dart';
-import 'model/task.dart';
-import 'model/update_extension_settings.dart';
-import 'model/update_check_extension_resp.dart';
-
-class _Client {
-  static _Client? _instance;
-
-  late Dio dio;
-
-  _Client._internal();
-
-  factory _Client(String network, String address, String apiToken) {
-    if (_instance == null) {
-      _instance = _Client._internal();
-      var dio = Dio();
-      final isUnixSocket = network == 'unix';
-      var baseUrl = 'http://127.0.0.1';
-      if (!isUnixSocket) {
-        if (Util.isWeb()) {
-          baseUrl = kDebugMode ? 'http://127.0.0.1:9999' : '';
-        } else {
-          baseUrl = 'http://$address';
-        }
-      }
-      dio.options.baseUrl = baseUrl;
-      dio.options.contentType = Headers.jsonContentType;
-      dio.options.sendTimeout = const Duration(seconds: 5);
-      dio.options.connectTimeout = const Duration(seconds: 5);
-      dio.options.receiveTimeout = const Duration(seconds: 60);
-      dio.interceptors.add(InterceptorsWrapper(onRequest: (options, handler) {
-        if (apiToken.isNotEmpty) {
-          options.headers['X-Api-Token'] = apiToken;
-        }
-        handler.next(options);
-      }));
-
-      _instance!.dio = dio;
-      if (isUnixSocket) {
-        (_instance!.dio.httpClientAdapter as IOHttpClientAdapter)
-            .createHttpClient = () {
-          final client = HttpClient();
-          client.connectionFactory =
-              (Uri uri, String? proxyHost, int? proxyPort) {
-            return Socket.startConnect(
-                InternetAddress(address, type: InternetAddressType.unix), 0);
-          };
-          return client;
-        };
-      }
-    }
-    return _instance!;
-  }
-}
-
-class TimeoutException implements Exception {
-  final String message;
-
-  TimeoutException(this.message);
-}
-
-late _Client _client;
-
-void init(String network, String address, String apiToken) {
-  _client = _Client(network, address, apiToken);
-}
-
-Future<T> _parse<T>(
-  Future<Response> Function() fetch,
-  T Function(dynamic json)? fromJsonT,
-) async {
-  try {
-    var resp = await fetch();
-    fromJsonT ??= (json) => null as T;
-    final result = Result<T>.fromJson(resp.data, fromJsonT);
-    if (result.code == 0) {
-      return result.data as T;
-    } else {
-      throw Exception(result);
-    }
-  } on DioException catch (e) {
-    if (e.type == DioExceptionType.sendTimeout ||
-        e.type == DioExceptionType.receiveTimeout ||
-        e.type == DioExceptionType.connectionTimeout) {
-      throw TimeoutException("request timeout");
-    }
-    throw Exception(Result(code: 1000, msg: e.message));
-  }
-}
-
-Future<ResolveResult> resolve(Request request) async {
-  return _parse<ResolveResult>(
-      () => _client.dio.post("/api/v1/resolve", data: request),
-      (data) => ResolveResult.fromJson(data));
-}
-
-Future<String> createTask(CreateTask createTask) async {
-  return _parse<String>(
-      () => _client.dio.post("/api/v1/tasks", data: createTask),
-      (data) => data as String);
-}
-
-Future<List<Task>> getTasks(List<Status> statuses) async {
-  return _parse<List<Task>>(
-      () => _client.dio.get(
-          "/api/v1/tasks?${statuses.map((e) => "status=${e.name}").join("&")}"),
-      (data) => (data as List).map((e) => Task.fromJson(e)).toList());
-}
-
-Future<void> pauseTask(String id) async {
-  return _parse(() => _client.dio.put("/api/v1/tasks/$id/pause"), null);
-}
-
-Future<void> continueTask(String id) async {
-  return _parse(() => _client.dio.put("/api/v1/tasks/$id/continue"), null);
-}
-
-Future<void> pauseAllTasks() async {
-  return _parse(() => _client.dio.put("/api/v1/tasks/pause"), null);
-}
-
-Future<void> continueAllTasks() async {
-  return _parse(() => _client.dio.put("/api/v1/tasks/continue"), null);
-}
-
-Future<void> deleteTask(String id, bool force) async {
-  return _parse(
-      () => _client.dio.delete("/api/v1/tasks/$id?force=$force"), null);
-}
-
-Future<DownloaderConfig> getConfig() async {
-  return _parse(() => _client.dio.get("/api/v1/config"),
-      (data) => DownloaderConfig.fromJson(data));
-}
-
-Future<void> putConfig(DownloaderConfig config) async {
-  return _parse(() => _client.dio.put("/api/v1/config", data: config), null);
-}
-
-Future<void> installExtension(InstallExtension installExtension) async {
-  return _parse(
-      () => _client.dio.post("/api/v1/extensions", data: installExtension),
-      null);
-}
-
-Future<List<Extension>> getExtensions() async {
-  return _parse<List<Extension>>(() => _client.dio.get("/api/v1/extensions"),
-      (data) => (data as List).map((e) => Extension.fromJson(e)).toList());
-}
-
-Future<void> updateExtensionSettings(
-    String identity, UpdateExtensionSettings updateExtensionSettings) async {
-  return _parse(
-      () => _client.dio.put("/api/v1/extensions/$identity/settings",
-          data: updateExtensionSettings),
-      null);
-}
-
-Future<void> switchExtension(
-    String identity, SwitchExtension switchExtension) async {
-  return _parse(
-      () => _client.dio
-          .put("/api/v1/extensions/$identity/switch", data: switchExtension),
-      null);
-}
-
-Future<void> deleteExtension(String identity) async {
-  return _parse(() => _client.dio.delete("/api/v1/extensions/$identity"), null);
-}
-
-Future<UpdateCheckExtensionResp> upgradeCheckExtension(String identity) async {
-  return _parse(() => _client.dio.get("/api/v1/extensions/$identity/update"),
-      (data) => UpdateCheckExtensionResp.fromJson(data));
-}
-
-Future<void> updateExtension(String identity) async {
-  return _parse(
-      () => _client.dio.post("/api/v1/extensions/$identity/update"), null);
-}
-
-Future<Response<String>> proxyRequest<T>(String uri,
-    {data, Options? options}) async {
-  options ??= Options();
-  options.headers ??= {};
-  options.headers!["X-Target-Uri"] = uri;
-
-  // add timestamp to avoid cache
-  return _client.dio.request(
-      "/api/v1/proxy?t=${DateTime.now().millisecondsSinceEpoch}",
-      data: data,
-      options: options);
-}
-
-String join(String path) {
-  return "${_client.dio.options.baseUrl}/${Util.cleanPath(path)}";
-}

ui/flutter/lib/api/api_exception.dart

@@ -0,0 +1,6 @@
+class ApiException implements Exception {
+  final int code;
+  final String message;
+
+  ApiException(this.code, this.message);
+}

ui/flutter/lib/api/entry/libgopeed_boot_base.dart

@@ -0,0 +1,25 @@
+import 'package:dio/dio.dart';
+
+import '../api_exception.dart';
+import '../model/result.dart';
+
+mixin LibgopeedBootBase {
+  Dio createDio() {
+    Dio dio = Dio();
+    dio.options.contentType = Headers.jsonContentType;
+    dio.options.sendTimeout = const Duration(seconds: 5);
+    dio.options.connectTimeout = const Duration(seconds: 5);
+    dio.options.receiveTimeout = const Duration(seconds: 60);
+    return dio;
+  }
+
+  T handleResult<T>(
+    Result<T> result,
+  ) {
+    if (result.code == 0) {
+      return result.data as T;
+    } else {
+      throw ApiException(result.code, result.msg ?? '');
+    }
+  }
+}

ui/flutter/lib/api/entry/libgopeed_boot_native.dart

@@ -0,0 +1,239 @@
+import 'dart:async';
+import 'dart:convert';
+import 'dart:ffi';
+import 'dart:io';
+
+import 'package:dio/dio.dart';
+
+import '../../api/model/create_task.dart';
+import '../../api/model/create_task_batch.dart';
+import '../../api/model/downloader_config.dart';
+import '../../api/model/extension.dart';
+import '../../api/model/http_listen_result.dart';
+import '../../api/model/info.dart';
+import '../../api/model/install_extension.dart';
+import '../../api/model/request.dart';
+import '../../api/model/resolve_result.dart';
+import '../../api/model/result.dart';
+import '../../api/model/switch_extension.dart';
+import '../../api/model/task.dart';
+import '../../api/model/task_filter.dart';
+import '../../api/model/update_check_extension_resp.dart';
+import '../../api/model/update_extension_settings.dart';
+import '../../util/extensions.dart';
+import '../../util/util.dart';
+import '../libgopeed_boot.dart';
+import '../native/channel/libgopeed_channel.dart';
+import '../native/ffi/libgopeed_bind.dart';
+import '../native/ffi/libgopeed_ffi.dart';
+import '../native/libgopeed_interface.dart';
+import '../native/model/invoke_request.dart';
+import '../native/model/start_config.dart';
+import 'libgopeed_boot_base.dart';
+
+LibgopeedBoot create() => LibgopeedBootNative();
+
+class LibgopeedBootNative
+    with LibgopeedBootBase
+    implements LibgopeedBoot, LibgopeedApi {
+  late LibgopeedAbi _libgopeedAbi;
+  late Dio _dio;
+
+  LibgopeedBootNative() {
+    if (Util.isDesktop()) {
+      var libName = "libgopeed.";
+      if (Platform.isWindows) {
+        libName += "dll";
+      }
+      if (Platform.isMacOS) {
+        libName += "dylib";
+      }
+      if (Platform.isLinux) {
+        libName += "so";
+      }
+      _libgopeedAbi = LibgopeedFFi(LibgopeedBind(DynamicLibrary.open(libName)));
+    } else {
+      _libgopeedAbi = LibgopeedChannel();
+    }
+  }
+
+  Future<T> _invoke<T>(
+    String method,
+    List<dynamic> params,
+    T Function(dynamic json)? fromJsonT,
+  ) async {
+    final invokeRequest = InvokeRequest(method: method, params: params);
+    final resp = await _libgopeedAbi.invoke(jsonEncode(invokeRequest));
+    final result =
+        Result<T>.fromJson(jsonDecode(resp), fromJsonT ??= (json) => null as T);
+    return handleResult(result);
+  }
+
+  List<dynamic> _parseTaskFilter(TaskFilter? filter) {
+    if (filter == null) {
+      return [null];
+    }
+    return [filter];
+  }
+
+  @override
+  Future<LibgopeedApi> init(StartConfig cfg) async {
+    await _libgopeedAbi.init(jsonEncode(cfg.toJson()));
+    _dio = createDio();
+    return this;
+  }
+
+  @override
+  Future<HttpListenResult> startHttp() async {
+    return _invoke<HttpListenResult>(
+        "StartHttp", [], (json) => HttpListenResult.fromJson(json));
+  }
+
+  @override
+  Future<void> stopHttp() async {
+    await _invoke<void>("StopHttp", [], null);
+  }
+
+  @override
+  Future<void> restartHttp() async {
+    await _invoke<void>("RestartHttp", [], null);
+  }
+
+  @override
+  Future<Info> info() async {
+    return _invoke<Info>("Info", [], (json) => Info.fromJson(json));
+  }
+
+  @override
+  Future<ResolveResult> resolve(Request request) async {
+    return _invoke<ResolveResult>(
+        "Resolve", [request], (json) => ResolveResult.fromJson(json));
+  }
+
+  @override
+  Future<String> createTask(CreateTask createTask) async {
+    return _invoke<String>(
+        "CreateTask", [createTask], (json) => json as String);
+  }
+
+  @override
+  Future<String> createTaskBatch(CreateTaskBatch createTask) async {
+    return _invoke<String>(
+        "CreateTaskBatch", [createTask], (json) => json as String);
+  }
+
+  @override
+  Future<void> pauseTask(String id) async {
+    await _invoke<void>("PauseTask", [id], null);
+  }
+
+  @override
+  Future<void> pauseTasks(TaskFilter? filter) async {
+    await _invoke<void>("PauseTasks", _parseTaskFilter(filter), null);
+  }
+
+  @override
+  Future<void> continueTask(String id) async {
+    await _invoke<void>("ContinueTask", [id], null);
+  }
+
+  @override
+  Future<void> continueTasks(TaskFilter? filter) async {
+    await _invoke<void>("ContinueTasks", _parseTaskFilter(filter), null);
+  }
+
+  @override
+  Future<void> deleteTask(String id, bool force) async {
+    await _invoke<void>("DeleteTask", [id, force], null);
+  }
+
+  @override
+  Future<void> deleteTasks(TaskFilter? filter, bool force) async {
+    await _invoke<void>(
+        "DeleteTasks",
+        _parseTaskFilter(filter).apply((it) {
+          it.add(force);
+        }),
+        null);
+  }
+
+  @override
+  Future<Task> getTask(String id) async {
+    return _invoke<Task>("GetTask", [id], (json) => Task.fromJson(json));
+  }
+
+  @override
+  Future<List<Task>> getTasks(TaskFilter? filter) async {
+    return _invoke<List<Task>>("GetTasks", _parseTaskFilter(filter),
+        (json) => (json as List).map((e) => Task.fromJson(e)).toList());
+  }
+
+  @override
+  Future<Map<String, dynamic>> getTaskStats(String id) async {
+    return _invoke<Map<String, dynamic>>(
+        "GetTaskStats", [id], (json) => json as Map<String, dynamic>);
+  }
+
+  @override
+  Future<DownloaderConfig> getConfig() async {
+    return _invoke<DownloaderConfig>(
+        "GetConfig", [], (json) => DownloaderConfig.fromJson(json));
+  }
+
+  @override
+  Future<void> putConfig(DownloaderConfig config) async {
+    await _invoke<void>("PutConfig", [config], null);
+  }
+
+  @override
+  Future<void> installExtension(InstallExtension installExtension) async {
+    await _invoke<void>("InstallExtension", [installExtension], null);
+  }
+
+  @override
+  Future<List<Extension>> getExtensions() async {
+    return _invoke<List<Extension>>("GetExtensions", [],
+        (json) => (json as List).map((e) => Extension.fromJson(e)).toList());
+  }
+
+  @override
+  Future<void> updateExtensionSettings(
+      String identity, UpdateExtensionSettings updateExtensionSettings) async {
+    await _invoke<void>(
+        "UpdateExtensionSettings", [identity, updateExtensionSettings], null);
+  }
+
+  @override
+  Future<void> switchExtension(
+      String identity, SwitchExtension switchExtension) async {
+    await _invoke<void>("SwitchExtension", [identity, switchExtension], null);
+  }
+
+  @override
+  Future<void> deleteExtension(String identity) async {
+    await _invoke<void>("DeleteExtension", [identity], null);
+  }
+
+  @override
+  Future<UpdateCheckExtensionResp> upgradeCheckExtension(
+      String identity) async {
+    return _invoke<UpdateCheckExtensionResp>("UpgradeCheckExtension",
+        [identity], (json) => UpdateCheckExtensionResp.fromJson(json));
+  }
+
+  @override
+  Future<void> upgradeExtension(String identity) async {
+    await _invoke<void>("UpgradeExtension", [identity], null);
+  }
+
+  @override
+  Future<void> close() async {
+    await _invoke<void>("Close", [], null);
+  }
+
+  @override
+  Future<Response<String>> proxyRequest<T>(String uri,
+      {data, Options? options}) {
+    return _dio.request(uri, data: data, options: options);
+  }
+}

ui/flutter/lib/api/entry/libgopeed_boot_web.dart

@@ -0,0 +1,277 @@
+import 'package:dio/dio.dart';
+import 'package:flutter/foundation.dart';
+
+import '../../api/model/create_task.dart';
+import '../../api/model/create_task_batch.dart';
+import '../../api/model/downloader_config.dart';
+import '../../api/model/extension.dart';
+import '../../api/model/http_listen_result.dart';
+import '../../api/model/info.dart';
+import '../../api/model/install_extension.dart';
+import '../../api/model/request.dart';
+import '../../api/model/resolve_result.dart';
+import '../../api/model/result.dart';
+import '../../api/model/switch_extension.dart';
+import '../../api/model/task.dart';
+import '../../api/model/task_filter.dart';
+import '../../api/model/update_check_extension_resp.dart';
+import '../../api/model/update_extension_settings.dart';
+import '../../util/extensions.dart';
+import '../../util/util.dart';
+import '../api_exception.dart';
+import '../libgopeed_boot.dart';
+import '../native/libgopeed_interface.dart';
+import '../native/model/start_config.dart';
+import 'libgopeed_boot_base.dart';
+
+LibgopeedBoot create() => LibgopeedBootWeb();
+
+class LibgopeedBootWeb
+    with LibgopeedBootBase
+    implements LibgopeedBoot, LibgopeedApi {
+  late Dio _dio;
+  static const String _apiPrefix = '/api/v1';
+
+  LibgopeedBootWeb();
+
+  Future<T> _fetch<T>(
+    Future<Response> Function() fetch,
+    T Function(dynamic json)? fromJsonT,
+  ) async {
+    try {
+      var resp = await fetch();
+      fromJsonT ??= (json) => null as T;
+      final result = Result<T>.fromJson(resp.data, fromJsonT);
+      return handleResult(result);
+    } on DioException catch (e) {
+      if (e.type == DioExceptionType.sendTimeout ||
+          e.type == DioExceptionType.receiveTimeout ||
+          e.type == DioExceptionType.connectionTimeout) {
+        throw ApiException(1000, 'request timeout');
+      }
+      throw ApiException(1000, e.message ?? "");
+    }
+  }
+
+  Map<String, dynamic>? _parseTaskFilter(TaskFilter? filter) {
+    if (filter == null) {
+      return null;
+    }
+
+    Map<String, dynamic> params = {};
+    if (filter.id != null) {
+      params['id'] = filter.id;
+    }
+    if (filter.status != null) {
+      params['status'] = filter.status;
+    }
+    if (filter.notStatus != null) {
+      params['notStatus'] = filter.notStatus;
+    }
+    if (params.isEmpty) {
+      return null;
+    }
+    return params;
+  }
+
+  @override
+  Future<LibgopeedApi> init(StartConfig cfg) async {
+    _dio = createDio();
+    _dio.options.baseUrl = kDebugMode ? 'http://127.0.0.1:9999' : '';
+    return this;
+  }
+
+  @override
+  Future<HttpListenResult> startHttp() async {
+    throw UnimplementedError();
+  }
+
+  @override
+  Future<void> stopHttp() async {
+    throw UnimplementedError();
+  }
+
+  @override
+  Future<void> restartHttp() async {
+    throw UnimplementedError();
+  }
+
+  @override
+  Future<Info> info() {
+    return _fetch<Info>(
+        () => _dio.get("$_apiPrefix/info"), (data) => Info.fromJson(data));
+  }
+
+  @override
+  Future<ResolveResult> resolve(Request request) async {
+    return _fetch<ResolveResult>(
+        () => _dio.post("$_apiPrefix/resolve", data: request),
+        (data) => ResolveResult.fromJson(data));
+  }
+
+  @override
+  Future<String> createTask(CreateTask createTask) async {
+    return _fetch<String>(
+        () => _dio.post("$_apiPrefix/tasks", data: createTask),
+        (data) => data as String);
+  }
+
+  @override
+  Future<String> createTaskBatch(CreateTaskBatch createTask) async {
+    return _fetch<String>(
+        () => _dio.post("$_apiPrefix/tasks", data: createTask),
+        (data) => data as String);
+  }
+
+  @override
+  Future<void> pauseTask(String id) async {
+    await _fetch<void>(() => _dio.put("$_apiPrefix/tasks/$id/pause"), null);
+  }
+
+  @override
+  Future<void> pauseTasks(TaskFilter? filter) async {
+    await _fetch<void>(
+        () => _dio.put("$_apiPrefix/tasks/pause",
+            queryParameters: _parseTaskFilter(filter)),
+        null);
+  }
+
+  @override
+  Future<void> continueTask(String id) async {
+    await _fetch<void>(() => _dio.put("$_apiPrefix/tasks/$id/continue"), null);
+  }
+
+  @override
+  Future<void> continueTasks(TaskFilter? filter) async {
+    await _fetch<void>(
+        () => _dio.put("$_apiPrefix/tasks/continue",
+            queryParameters: _parseTaskFilter(filter)),
+        null);
+  }
+
+  @override
+  Future<void> deleteTask(String id, bool force) async {
+    await _fetch<void>(
+        () => _dio
+            .delete("$_apiPrefix/tasks/$id", queryParameters: {'force': force}),
+        null);
+  }
+
+  @override
+  Future<void> deleteTasks(TaskFilter? filter, bool force) async {
+    await _fetch<void>(
+        () => _dio.delete("$_apiPrefix/tasks",
+            queryParameters: _parseTaskFilter(filter)?.apply((it) {
+              it['force'] = force;
+            })),
+        null);
+  }
+
+  @override
+  Future<Task> getTask(String id) async {
+    return _fetch<Task>(
+        () => _dio.get("$_apiPrefix/tasks/$id"), (data) => Task.fromJson(data));
+  }
+
+  @override
+  Future<List<Task>> getTasks(TaskFilter? filter) async {
+    return _fetch<List<Task>>(
+        () => _dio.get("$_apiPrefix/tasks",
+            queryParameters: _parseTaskFilter(filter)),
+        (data) => (data as List).map((e) => Task.fromJson(e)).toList());
+  }
+
+  @override
+  Future<Map<String, dynamic>> getTaskStats(String id) async {
+    return _fetch<Map<String, dynamic>>(
+        () => _dio.get("$_apiPrefix/tasks/$id/stats"),
+        (data) => data as Map<String, dynamic>);
+  }
+
+  @override
+  Future<DownloaderConfig> getConfig() async {
+    return _fetch<DownloaderConfig>(() => _dio.get("$_apiPrefix/config"),
+        (data) => DownloaderConfig.fromJson(data));
+  }
+
+  @override
+  Future<void> putConfig(DownloaderConfig config) async {
+    await _fetch<void>(
+        () => _dio.put("$_apiPrefix/config", data: config), null);
+  }
+
+  @override
+  Future<void> installExtension(InstallExtension installExtension) async {
+    await _fetch<void>(
+        () => _dio.post("$_apiPrefix/extensions", data: installExtension),
+        null);
+  }
+
+  @override
+  Future<List<Extension>> getExtensions() async {
+    return _fetch<List<Extension>>(() => _dio.get("$_apiPrefix/extensions"),
+        (data) => (data as List).map((e) => Extension.fromJson(e)).toList());
+  }
+
+  @override
+  Future<void> updateExtensionSettings(
+      String identity, UpdateExtensionSettings updateExtensionSettings) async {
+    await _fetch<void>(
+        () => _dio.put("$_apiPrefix/extensions/$identity/settings",
+            data: updateExtensionSettings),
+        null);
+  }
+
+  @override
+  Future<void> switchExtension(
+      String identity, SwitchExtension switchExtension) async {
+    await _fetch<void>(
+        () => _dio.put("$_apiPrefix/extensions/$identity/switch",
+            data: switchExtension),
+        null);
+  }
+
+  @override
+  Future<void> deleteExtension(String identity) async {
+    await _fetch<void>(
+        () => _dio.delete("$_apiPrefix/extensions/$identity"), null);
+  }
+
+  @override
+  Future<UpdateCheckExtensionResp> upgradeCheckExtension(
+      String identity) async {
+    return _fetch<UpdateCheckExtensionResp>(
+        () => _dio.get("$_apiPrefix/extensions/$identity/upgrade"),
+        (data) => UpdateCheckExtensionResp.fromJson(data));
+  }
+
+  @override
+  Future<void> upgradeExtension(String identity) async {
+    await _fetch<void>(
+        () => _dio.post("$_apiPrefix/extensions/$identity/upgrade"), null);
+  }
+
+  @override
+  Future<void> close() async {
+    throw UnimplementedError();
+  }
+
+  // To avoid CORS, use a backend proxy to forward the request
+  @override
+  Future<Response<String>> proxyRequest<T>(String uri,
+      {data, Options? options}) async {
+    options ??= Options();
+    options.headers ??= {};
+    options.headers!["X-Target-Uri"] = uri;
+
+    // add timestamp to avoid cache
+    return _dio.request(
+        "/api/v1/proxy?t=${DateTime.now().millisecondsSinceEpoch}",
+        data: data,
+        options: options);
+  }
+
+  String join(String path) {
+    return "${_dio.options.baseUrl}/${Util.cleanPath(path)}";
+  }
+}

ui/flutter/lib/api/libgopeed_boot.dart

@@ -0,0 +1,18 @@
+import "libgopeed_boot_stub.dart"
+    if (dart.library.html) 'entry/libgopeed_boot_browser.dart'
+    if (dart.library.io) 'entry/libgopeed_boot_native.dart';
+import 'native/libgopeed_interface.dart';
+
+abstract class LibgopeedBoot implements LibgopeedApiSingleton {
+  static LibgopeedApi? _instance;
+
+  static void singleton(LibgopeedApi instance) {
+    _instance ??= instance;
+  }
+
+  static LibgopeedApi get instance {
+    return _instance!;
+  }
+
+  factory LibgopeedBoot() => create();
+}

ui/flutter/lib/api/model/create_task_batch.dart

@@ -0,0 +1,20 @@
+import 'package:gopeed/api/model/extension.dart';
+import 'package:gopeed/api/model/request.dart';
+import 'package:json_annotation/json_annotation.dart';
+
+part 'create_task_batch.g.dart';
+
+@JsonSerializable()
+class CreateTaskBatch {
+  List<Request> reqs;
+  Option? opt;
+
+  CreateTaskBatch({
+    this.reqs = const [],
+    this.opt,
+  });
+
+  factory CreateTaskBatch.fromJson(Map<String, dynamic> json) =>
+      _$CreateTaskBatchFromJson(json);
+  Map<String, dynamic> toJson() => _$CreateTaskBatchToJson(this);
+}

ui/flutter/lib/api/model/create_task_batch.g.dart

@@ -0,0 +1,33 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'create_task_batch.dart';
+
+// **************************************************************************
+// JsonSerializableGenerator
+// **************************************************************************
+
+CreateTaskBatch _$CreateTaskBatchFromJson(Map<String, dynamic> json) =>
+    CreateTaskBatch(
+      reqs: (json['reqs'] as List<dynamic>?)
+              ?.map((e) => Request.fromJson(e as Map<String, dynamic>))
+              .toList() ??
+          const [],
+      opt: json['opt'] == null
+          ? null
+          : Option.fromJson(json['opt'] as Map<String, dynamic>),
+    );
+
+Map<String, dynamic> _$CreateTaskBatchToJson(CreateTaskBatch instance) {
+  final val = <String, dynamic>{
+    'reqs': instance.reqs,
+  };
+
+  void writeNotNull(String key, dynamic value) {
+    if (value != null) {
+      val[key] = value;
+    }
+  }
+
+  writeNotNull('opt', instance.opt);
+  return val;
+}

ui/flutter/lib/api/model/http_listen_result.dart

@@ -0,0 +1,18 @@
+import 'package:json_annotation/json_annotation.dart';
+
+part 'http_listen_result.g.dart';
+
+@JsonSerializable()
+class HttpListenResult {
+  String host;
+  int port;
+
+  HttpListenResult({
+    this.host = '',
+    this.port = 0,
+  });
+
+  factory HttpListenResult.fromJson(Map<String, dynamic> json) =>
+      _$HttpListenResultFromJson(json);
+  Map<String, dynamic> toJson() => _$HttpListenResultToJson(this);
+}

ui/flutter/lib/api/model/http_listen_result.g.dart

@@ -0,0 +1,19 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'http_listen_result.dart';
+
+// **************************************************************************
+// JsonSerializableGenerator
+// **************************************************************************
+
+HttpListenResult _$HttpListenResultFromJson(Map<String, dynamic> json) =>
+    HttpListenResult(
+      host: json['host'] as String? ?? '',
+      port: (json['port'] as num?)?.toInt() ?? 0,
+    );
+
+Map<String, dynamic> _$HttpListenResultToJson(HttpListenResult instance) =>
+    <String, dynamic>{
+      'host': instance.host,
+      'port': instance.port,
+    };

ui/flutter/lib/api/model/info.dart

@@ -0,0 +1,23 @@
+import 'package:json_annotation/json_annotation.dart';
+
+part 'info.g.dart';
+
+@JsonSerializable()
+class Info {
+  String version;
+  String runtime;
+  String os;
+  String arch;
+  bool inDocker;
+
+  Info({
+    this.version = '',
+    this.runtime = '',
+    this.os = '',
+    this.arch = '',
+    this.inDocker = false,
+  });
+
+  factory Info.fromJson(Map<String, dynamic> json) => _$InfoFromJson(json);
+  Map<String, dynamic> toJson() => _$InfoToJson(this);
+}

ui/flutter/lib/api/model/info.g.dart

@@ -0,0 +1,23 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'info.dart';
+
+// **************************************************************************
+// JsonSerializableGenerator
+// **************************************************************************
+
+Info _$InfoFromJson(Map<String, dynamic> json) => Info(
+      version: json['version'] as String? ?? '',
+      runtime: json['runtime'] as String? ?? '',
+      os: json['os'] as String? ?? '',
+      arch: json['arch'] as String? ?? '',
+      inDocker: json['inDocker'] as bool? ?? false,
+    );
+
+Map<String, dynamic> _$InfoToJson(Info instance) => <String, dynamic>{
+      'version': instance.version,
+      'runtime': instance.runtime,
+      'os': instance.os,
+      'arch': instance.arch,
+      'inDocker': instance.inDocker,
+    };

ui/flutter/lib/api/model/options.g.dart

@@ -10,7 +10,7 @@ Options _$OptionsFromJson(Map<String, dynamic> json) => Options(
       name: json['name'] as String,
       path: json['path'] as String,
       selectFiles: (json['selectFiles'] as List<dynamic>?)
-              ?.map((e) => e as int)
+              ?.map((e) => (e as num).toInt())
               .toList() ??
           const [],
       extra: json['extra'],
@@ -35,7 +35,7 @@ Map<String, dynamic> _$OptionsToJson(Options instance) {
 
 OptsExtraHttp _$OptsExtraHttpFromJson(Map<String, dynamic> json) =>
     OptsExtraHttp()
-      ..connections = json['connections'] as int
+      ..connections = (json['connections'] as num).toInt()
       ..autoTorrent = json['autoTorrent'] as bool;
 
 Map<String, dynamic> _$OptsExtraHttpToJson(OptsExtraHttp instance) =>

ui/flutter/lib/api/model/result.g.dart

@@ -11,7 +11,7 @@ Result<T> _$ResultFromJson<T>(
   T Function(Object? json) fromJsonT,
 ) =>
     Result<T>(
-      code: json['code'] as int,
+      code: (json['code'] as num).toInt(),
       msg: json['msg'] as String?,
       data: _$nullableGenericFromJson(json['data'], fromJsonT),
     );

ui/flutter/lib/api/model/task_filter.dart

@@ -0,0 +1,17 @@
+import 'package:gopeed/api/model/task.dart';
+import 'package:json_annotation/json_annotation.dart';
+
+part 'task_filter.g.dart';
+
+@JsonSerializable()
+class TaskFilter {
+  List<String>? id;
+  List<Status>? status;
+  List<Status>? notStatus;
+
+  TaskFilter({this.id, this.status, this.notStatus});
+
+  factory TaskFilter.fromJson(Map<String, dynamic> json) =>
+      _$TaskFilterFromJson(json);
+  Map<String, dynamic> toJson() => _$TaskFilterToJson(this);
+}

ui/flutter/lib/api/model/task_filter.g.dart

@@ -0,0 +1,43 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'task_filter.dart';
+
+// **************************************************************************
+// JsonSerializableGenerator
+// **************************************************************************
+
+TaskFilter _$TaskFilterFromJson(Map<String, dynamic> json) => TaskFilter(
+      id: (json['ids'] as List<dynamic>?)?.map((e) => e as String).toList(),
+      status: (json['statuses'] as List<dynamic>?)
+          ?.map((e) => $enumDecode(_$StatusEnumMap, e))
+          .toList(),
+      notStatus: (json['notStatuses'] as List<dynamic>?)
+          ?.map((e) => $enumDecode(_$StatusEnumMap, e))
+          .toList(),
+    );
+
+Map<String, dynamic> _$TaskFilterToJson(TaskFilter instance) {
+  final val = <String, dynamic>{};
+
+  void writeNotNull(String key, dynamic value) {
+    if (value != null) {
+      val[key] = value;
+    }
+  }
+
+  writeNotNull('ids', instance.id);
+  writeNotNull(
+      'statuses', instance.status?.map((e) => _$StatusEnumMap[e]!).toList());
+  writeNotNull('notStatuses',
+      instance.notStatus?.map((e) => _$StatusEnumMap[e]!).toList());
+  return val;
+}
+
+const _$StatusEnumMap = {
+  Status.ready: 'ready',
+  Status.running: 'running',
+  Status.pause: 'pause',
+  Status.wait: 'wait',
+  Status.error: 'error',
+  Status.done: 'done',
+};

ui/flutter/lib/api/native/channel/libgopeed_channel.dart

@@ -0,0 +1,22 @@
+import 'package:flutter/services.dart';
+
+import '../libgopeed_interface.dart';
+
+class LibgopeedChannel implements LibgopeedAbi {
+  static const _channel = MethodChannel('gopeed.com/libgopeed');
+
+  @override
+  Future<void> init(String cfg) async {
+    await _channel.invokeMethod<String>('init', {
+      'cfg': cfg,
+    });
+  }
+
+  @override
+  Future<String> invoke(String params) async {
+    final result = await _channel.invokeMethod<String>('invoke', {
+      'params': params,
+    });
+    return result!;
+  }
+}

ui/flutter/lib/api/native/ffi/libgopeed_bind.dart

@@ -857,27 +857,33 @@ class LibgopeedBind {
   late final __FCmulcr =
       __FCmulcrPtr.asFunction<_Fcomplex Function(_Fcomplex, double)>();
 
-  Start_return Start(
+  ffi.Pointer<ffi.Char> Init(
     ffi.Pointer<ffi.Char> cfg,
   ) {
-    return _Start(
+    return _Init(
       cfg,
     );
   }
 
-  late final _StartPtr =
-      _lookup<ffi.NativeFunction<Start_return Function(ffi.Pointer<ffi.Char>)>>(
-          'Start');
-  late final _Start =
-      _StartPtr.asFunction<Start_return Function(ffi.Pointer<ffi.Char>)>();
+  late final _InitPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Char>)>>('Init');
+  late final _Init = _InitPtr.asFunction<
+      ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Char>)>();
 
-  void Stop() {
-    return _Stop();
+  ffi.Pointer<ffi.Char> Invoke(
+    ffi.Pointer<ffi.Char> req,
+  ) {
+    return _Invoke(
+      req,
+    );
   }
 
-  late final _StopPtr =
-      _lookup<ffi.NativeFunction<ffi.Void Function()>>('Stop');
-  late final _Stop = _StopPtr.asFunction<void Function()>();
+  late final _InvokePtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Char>)>>('Invoke');
+  late final _Invoke = _InvokePtr.asFunction<
+      ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Char>)>();
 }
 
 typedef va_list = ffi.Pointer<ffi.Char>;
@@ -914,6 +920,7 @@ final class _Mbstatet extends ffi.Struct {
 }
 
 typedef errno_t = ffi.Int;
+typedef Darterrno_t = int;
 
 final class _GoString_ extends ffi.Struct {
   external ffi.Pointer<ffi.Char> p;
@@ -923,6 +930,7 @@ final class _GoString_ extends ffi.Struct {
 }
 
 typedef ptrdiff_t = ffi.LongLong;
+typedef Dartptrdiff_t = int;
 
 final class _C_double_complex extends ffi.Struct {
   @ffi.Array.multi([2])
@@ -957,13 +965,7 @@ final class GoSlice extends ffi.Struct {
 
 typedef GoInt = GoInt64;
 typedef GoInt64 = ffi.LongLong;
-
-final class Start_return extends ffi.Struct {
-  @GoInt()
-  external int r0;
-
-  external ffi.Pointer<ffi.Char> r1;
-}
+typedef DartGoInt64 = int;
 
 const int _VCRT_COMPILER_PREPROCESSOR = 1;
 
@@ -993,6 +995,10 @@ const int _HAS_CXX23 = 0;
 
 const int _HAS_NODISCARD = 1;
 
+const int _ARM_WINAPI_PARTITION_DESKTOP_SDK_AVAILABLE = 1;
+
+const int _CRT_BUILD_DESKTOP_APP = 1;
+
 const int _UCRT_DISABLED_WARNINGS = 4324;
 
 const int _ARGMAX = 100;
@@ -1009,9 +1015,7 @@ const int _CRT_FUNCTIONS_REQUIRED = 1;
 
 const int _CRT_HAS_CXX17 = 0;
 
-const int _ARM_WINAPI_PARTITION_DESKTOP_SDK_AVAILABLE = 1;
-
-const int _CRT_BUILD_DESKTOP_APP = 1;
+const int _CRT_HAS_C11 = 0;
 
 const int _CRT_INTERNAL_NONSTDC_NAMES = 1;
 

ui/flutter/lib/api/native/ffi/libgopeed_ffi.dart

@@ -0,0 +1,41 @@
+import 'dart:async';
+import 'dart:ffi';
+
+import 'package:ffi/ffi.dart';
+
+import '../libgopeed_interface.dart';
+import 'libgopeed_bind.dart';
+
+class LibgopeedFFi implements LibgopeedAbi {
+  late LibgopeedBind _libgopeed;
+
+  LibgopeedFFi(LibgopeedBind libgopeed) {
+    _libgopeed = libgopeed;
+  }
+
+  @override
+  Future<void> init(String cfg) {
+    final cfgPtr = cfg.toNativeUtf8();
+    try {
+      final result = _libgopeed.Init(cfgPtr.cast());
+      if (result != nullptr) {
+        throw Exception(
+            'Libgopeed init failed: ${result.cast<Utf8>().toDartString()}');
+      }
+      return Future.value();
+    } finally {
+      calloc.free(cfgPtr);
+    }
+  }
+
+  @override
+  Future<String> invoke(String params) {
+    final paramsPtr = params.toNativeUtf8();
+    try {
+      final result = _libgopeed.Invoke(paramsPtr.cast());
+      return Future.value(result.cast<Utf8>().toDartString());
+    } finally {
+      calloc.free(paramsPtr);
+    }
+  }
+}

ui/flutter/lib/api/native/libgopeed_interface.dart

@@ -0,0 +1,85 @@
+import 'package:dio/dio.dart';
+
+import '../model/create_task.dart';
+import '../model/create_task_batch.dart';
+import '../model/downloader_config.dart';
+import '../model/extension.dart';
+import '../model/http_listen_result.dart';
+import '../model/info.dart';
+import '../model/install_extension.dart';
+import '../model/request.dart';
+import '../model/resolve_result.dart';
+import '../model/switch_extension.dart';
+import '../model/task.dart';
+import '../model/task_filter.dart';
+import '../model/update_check_extension_resp.dart';
+import '../model/update_extension_settings.dart';
+import 'model/start_config.dart';
+
+abstract class LibgopeedAbi {
+  Future<void> init(String cfg);
+  Future<String> invoke(String params);
+}
+
+abstract class LibgopeedApiSingleton {
+  Future<LibgopeedApi> init(StartConfig config);
+}
+
+abstract class LibgopeedApi {
+  Future<HttpListenResult> startHttp();
+
+  Future<void> stopHttp();
+
+  Future<void> restartHttp();
+
+  Future<Info> info();
+
+  Future<ResolveResult> resolve(Request request);
+
+  Future<String> createTask(CreateTask createTask);
+
+  Future<String> createTaskBatch(CreateTaskBatch createTask);
+
+  Future<void> pauseTask(String id);
+
+  Future<void> pauseTasks(TaskFilter? filter);
+
+  Future<void> continueTask(String id);
+
+  Future<void> continueTasks(TaskFilter? filter);
+
+  Future<void> deleteTask(String id, bool force);
+
+  Future<void> deleteTasks(TaskFilter? filter, bool force);
+
+  Future<Task> getTask(String id);
+
+  Future<List<Task>> getTasks(TaskFilter? filter);
+
+  Future<Map<String, dynamic>> getTaskStats(String id);
+
+  Future<DownloaderConfig> getConfig();
+
+  Future<void> putConfig(DownloaderConfig config);
+
+  Future<void> installExtension(InstallExtension installExtension);
+
+  Future<List<Extension>> getExtensions();
+
+  Future<void> updateExtensionSettings(
+      String identity, UpdateExtensionSettings updateExtensionSettings);
+
+  Future<void> switchExtension(
+      String identity, SwitchExtension switchExtension);
+
+  Future<void> deleteExtension(String identity);
+
+  Future<UpdateCheckExtensionResp> upgradeCheckExtension(String identity);
+
+  Future<void> upgradeExtension(String identity);
+
+  Future<void> close();
+
+  Future<Response<String>> proxyRequest<T>(String uri,
+      {data, Options? options});
+}

ui/flutter/lib/api/native/model/invoke_request.dart

@@ -0,0 +1,19 @@
+import 'package:json_annotation/json_annotation.dart';
+
+part 'invoke_request.g.dart';
+
+@JsonSerializable()
+class InvokeRequest {
+  String method;
+  List<dynamic> params;
+
+  InvokeRequest({
+    this.method = '',
+    this.params = const [],
+  });
+
+  factory InvokeRequest.fromJson(Map<String, dynamic> json) =>
+      _$InvokeRequestFromJson(json);
+
+  Map<String, dynamic> toJson() => _$InvokeRequestToJson(this);
+}

ui/flutter/lib/api/native/model/invoke_request.g.dart

@@ -0,0 +1,22 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'invoke_request.dart';
+
+// **************************************************************************
+// JsonSerializableGenerator
+// **************************************************************************
+
+InvokeRequest _$InvokeRequestFromJson(Map<String, dynamic> json) =>
+    InvokeRequest(
+      method: json['method'] as String? ?? '',
+      params: (json['params'] as List<dynamic>?)
+              ?.map((e) => e as String)
+              .toList() ??
+          const [],
+    );
+
+Map<String, dynamic> _$InvokeRequestToJson(InvokeRequest instance) =>
+    <String, dynamic>{
+      'method': instance.method,
+      'params': instance.params,
+    };