Initialize Clash Web source and deployment documentation

internal/app/api.go

@@ -0,0 +1,626 @@
+package app
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net"
+	"net/http"
+	"net/url"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+	"time"
+)
+
+type NodeView struct {
+	ID               string `json:"id"`
+	Name             string `json:"name"`
+	SubscriptionID   string `json:"subscriptionID"`
+	SubscriptionName string `json:"subscriptionName"`
+	Type             string `json:"type"`
+	UDP              bool   `json:"udp"`
+	Delay            *int   `json:"delay"`
+	Alive            *bool  `json:"alive"`
+	Selected         bool   `json:"selected"`
+}
+
+func (a *App) api() http.Handler {
+	mux := http.NewServeMux()
+	mux.HandleFunc("GET /api/v1/status", a.status)
+	mux.HandleFunc("GET /api/v1/subscriptions", a.subscriptions)
+	mux.HandleFunc("POST /api/v1/subscriptions", a.saveSubscription)
+	mux.HandleFunc("PUT /api/v1/subscriptions/{id}", a.saveSubscription)
+	mux.HandleFunc("DELETE /api/v1/subscriptions/{id}", a.deleteSubscription)
+	mux.HandleFunc("POST /api/v1/subscriptions/{id}/refresh", a.refreshSubscription)
+	mux.HandleFunc("GET /api/v1/nodes", a.nodes)
+	mux.HandleFunc("POST /api/v1/nodes/select", a.selectNode)
+	mux.HandleFunc("POST /api/v1/nodes/test", a.testNodes)
+	mux.HandleFunc("GET /api/v1/rules", a.rules)
+	mux.HandleFunc("POST /api/v1/rules", a.saveRule)
+	mux.HandleFunc("PUT /api/v1/rules/{id}", a.saveRule)
+	mux.HandleFunc("DELETE /api/v1/rules/{id}", a.deleteRule)
+	mux.HandleFunc("GET /api/v1/settings", func(w http.ResponseWriter, r *http.Request) { jsonResponse(w, 200, a.Snapshot().Settings) })
+	mux.HandleFunc("PUT /api/v1/settings", a.settings)
+	mux.HandleFunc("POST /api/v1/system/service", a.service)
+	mux.HandleFunc("GET /api/v1/system/network", a.network)
+	mux.HandleFunc("GET /api/v1/system/updates", a.coreUpdates)
+	mux.HandleFunc("GET /api/v1/system/connectivity", a.connectivitySites)
+	mux.HandleFunc("POST /api/v1/system/connectivity/test", a.testConnectivity)
+	mux.HandleFunc("GET /api/v1/system/backup", a.backup)
+	mux.HandleFunc("POST /api/v1/system/restore", a.restore)
+	mux.HandleFunc("GET /api/v1/connections", a.connections)
+	mux.HandleFunc("DELETE /api/v1/connections/{id}", a.closeConnection)
+	mux.HandleFunc("DELETE /api/v1/connections", a.closeConnection)
+	mux.HandleFunc("GET /api/v1/events", a.events)
+	mux.HandleFunc("GET /api/v1/logs", a.logs)
+	return mux
+}
+
+func (a *App) status(w http.ResponseWriter, r *http.Request) {
+	jsonResponse(w, 200, a.getStatus(r.Context()))
+}
+func (a *App) getStatus(ctx context.Context) map[string]any {
+	state := a.Snapshot()
+	ctx, cancel := context.WithTimeout(ctx, 3*time.Second)
+	defer cancel()
+	var version map[string]any
+	err := a.core.Request(ctx, "GET", "/version", nil, &version)
+	count := 0
+	for _, sub := range state.Subscriptions {
+		if sub.Enabled {
+			count += len(sub.Nodes)
+		}
+	}
+	a.mu.RLock()
+	configError := a.lastError
+	a.mu.RUnlock()
+	result := map[string]any{"coreOnline": err == nil, "coreInstalled": a.core.Binary != "", "version": "", "uptimeSeconds": int(time.Since(a.started).Seconds()), "nodeCount": count, "subscriptionCount": len(state.Subscriptions), "settings": state.Settings, "configError": configError, "actualNode": "", "selectedAvailable": false}
+	_, tunErr := net.InterfaceByName("cw-tun")
+	result["tunActive"] = err == nil && state.Settings.TunEnabled && tunErr == nil
+	if err == nil {
+		result["version"] = version["version"]
+		var group map[string]any
+		if a.core.Request(ctx, "GET", "/proxies/"+ProxyGroup, nil, &group) == nil {
+			actual, _ := group["now"].(string)
+			if actual == AutoGroup {
+				var auto map[string]any
+				if a.core.Request(ctx, "GET", "/proxies/"+AutoGroup, nil, &auto) == nil {
+					actual, _ = auto["now"].(string)
+				}
+			}
+			result["actualNode"] = actual
+			result["selectedAvailable"] = actual != "" && actual != "REJECT"
+		}
+	}
+	if err != nil {
+		result["coreError"] = err.Error()
+	}
+	return result
+}
+
+func (a *App) subscriptions(w http.ResponseWriter, r *http.Request) {
+	items := []map[string]any{}
+	for _, s := range a.Snapshot().Subscriptions {
+		a.refreshMu.Lock()
+		refreshing := a.refreshing[s.ID]
+		a.refreshMu.Unlock()
+		items = append(items, map[string]any{"id": s.ID, "name": s.Name, "url": s.URL, "enabled": s.Enabled, "intervalHours": s.IntervalHours, "updatedAt": s.UpdatedAt, "attemptedAt": s.AttemptedAt, "lastError": s.LastError, "usage": s.Usage, "nodeCount": len(s.Nodes), "refreshing": refreshing})
+	}
+	jsonResponse(w, 200, items)
+}
+
+func (a *App) saveSubscription(w http.ResponseWriter, r *http.Request) {
+	var input struct {
+		Name          string `json:"name"`
+		URL           string `json:"url"`
+		Enabled       bool   `json:"enabled"`
+		IntervalHours int    `json:"intervalHours"`
+	}
+	if err := decode(w, r, &input); err != nil {
+		writeError(w, 400, err.Error())
+		return
+	}
+	id := r.PathValue("id")
+	newSub := id == ""
+	if newSub {
+		id = randomID()
+	}
+	sub := Subscription{ID: id, Name: strings.TrimSpace(input.Name), URL: strings.TrimSpace(input.URL), Enabled: input.Enabled, IntervalHours: input.IntervalHours, Nodes: []map[string]any{}}
+	if err := validateSubscription(sub); err != nil {
+		writeError(w, 400, err.Error())
+		return
+	}
+	if newSub {
+		// Empty metadata can be saved before installing the core; importing nodes needs validation.
+		a.mu.Lock()
+		defer a.mu.Unlock()
+		candidate := cloneState(a.state)
+		if len(candidate.Subscriptions) >= 50 {
+			writeError(w, 400, "最多允许 50 个订阅")
+			return
+		}
+		candidate.Subscriptions = append(candidate.Subscriptions, sub)
+		if err := a.store.Save(candidate); err != nil {
+			writeError(w, 500, "保存失败")
+			return
+		}
+		a.state = candidate
+	} else {
+		err := a.change(r.Context(), func(s *State) error {
+			for i, old := range s.Subscriptions {
+				if old.ID == id {
+					sub.Nodes = old.Nodes
+					sub.UpdatedAt = old.UpdatedAt
+					sub.AttemptedAt = old.AttemptedAt
+					sub.LastError = old.LastError
+					sub.Usage = old.Usage
+					s.Subscriptions[i] = sub
+					return nil
+				}
+			}
+			return errors.New("订阅不存在")
+		})
+		if err != nil {
+			writeError(w, 400, err.Error())
+			return
+		}
+	}
+	jsonResponse(w, 200, map[string]any{"id": id, "ok": true})
+}
+
+func (a *App) deleteSubscription(w http.ResponseWriter, r *http.Request) {
+	id := r.PathValue("id")
+	err := a.change(r.Context(), func(state *State) error {
+		for i, sub := range state.Subscriptions {
+			if sub.ID == id {
+				state.Subscriptions = append(state.Subscriptions[:i], state.Subscriptions[i+1:]...)
+				return nil
+			}
+		}
+		return errors.New("订阅不存在")
+	})
+	if err != nil {
+		writeError(w, 400, err.Error())
+		return
+	}
+	jsonResponse(w, 200, map[string]bool{"ok": true})
+}
+func (a *App) refreshSubscription(w http.ResponseWriter, r *http.Request) {
+	if err := a.Refresh(r.Context(), r.PathValue("id")); err != nil {
+		writeError(w, 400, err.Error())
+		return
+	}
+	jsonResponse(w, 200, map[string]bool{"ok": true})
+}
+
+func nodeViews(state State, live map[string]map[string]any) []NodeView {
+	views := []NodeView{}
+	for _, sub := range state.Subscriptions {
+		if !sub.Enabled {
+			continue
+		}
+		for _, node := range sub.Nodes {
+			id, _ := node["name"].(string)
+			parts := strings.SplitN(id, "/", 3)
+			name := id
+			if len(parts) == 3 {
+				name = parts[2]
+			}
+			kind, _ := node["type"].(string)
+			udp, _ := node["udp"].(bool)
+			view := NodeView{ID: id, Name: name, SubscriptionID: sub.ID, SubscriptionName: sub.Name, Type: kind, UDP: udp, Selected: state.Settings.SelectedNode == id && state.Settings.SelectionMode == "manual"}
+			if info, ok := live[id]; ok {
+				if u, ok := info["udp"].(bool); ok {
+					view.UDP = u
+				}
+				if history, ok := info["history"].([]any); ok && len(history) > 0 {
+					if h, ok := history[len(history)-1].(map[string]any); ok {
+						if d, ok := h["delay"].(float64); ok {
+							delay := int(d)
+							view.Delay = &delay
+							alive := delay > 0
+							view.Alive = &alive
+						}
+					}
+				}
+			}
+			views = append(views, view)
+		}
+	}
+	return views
+}
+
+func (a *App) nodes(w http.ResponseWriter, r *http.Request) {
+	live := struct {
+		Proxies map[string]map[string]any `json:"proxies"`
+	}{Proxies: map[string]map[string]any{}}
+	_ = a.core.Request(r.Context(), "GET", "/proxies", nil, &live)
+	jsonResponse(w, 200, nodeViews(a.Snapshot(), live.Proxies))
+}
+func (a *App) selectNode(w http.ResponseWriter, r *http.Request) {
+	var input struct {
+		ID   string `json:"id"`
+		Mode string `json:"mode"`
+	}
+	if err := decode(w, r, &input); err != nil {
+		writeError(w, 400, err.Error())
+		return
+	}
+	err := a.change(r.Context(), func(s *State) error {
+		if input.Mode == "auto" {
+			s.Settings.SelectionMode = "auto"
+			return nil
+		}
+		if input.Mode != "manual" {
+			return errors.New("无效的选择模式")
+		}
+		for _, node := range nodeViews(*s, nil) {
+			if node.ID == input.ID {
+				s.Settings.SelectionMode = "manual"
+				s.Settings.SelectedNode = input.ID
+				return nil
+			}
+		}
+		return errors.New("节点不存在或订阅未启用")
+	})
+	if err != nil {
+		writeError(w, 400, err.Error())
+		return
+	}
+	jsonResponse(w, 200, map[string]bool{"ok": true})
+}
+func (a *App) testNodes(w http.ResponseWriter, r *http.Request) {
+	var input struct {
+		IDs []string `json:"ids"`
+	}
+	if err := decode(w, r, &input); err != nil {
+		writeError(w, 400, err.Error())
+		return
+	}
+	state := a.Snapshot()
+	known := map[string]bool{}
+	for _, n := range nodeViews(state, nil) {
+		known[n.ID] = true
+	}
+	if len(input.IDs) == 0 || len(input.IDs) > 500 {
+		writeError(w, 400, "一次可测试 1–500 个节点")
+		return
+	}
+	for _, id := range input.IDs {
+		if !known[id] {
+			writeError(w, 400, "包含未知节点")
+			return
+		}
+	}
+	results := map[string]any{}
+	for start := 0; start < len(input.IDs); start += 8 {
+		end := start + 8
+		if end > len(input.IDs) {
+			end = len(input.IDs)
+		}
+		type outcome struct {
+			ID    string
+			Delay int
+			Err   string
+		}
+		ch := make(chan outcome, end-start)
+		for _, id := range input.IDs[start:end] {
+			go func(id string) {
+				ctx, cancel := context.WithTimeout(r.Context(), time.Duration(state.Settings.TestTimeoutMS+2000)*time.Millisecond)
+				defer cancel()
+				var response struct {
+					Delay int `json:"delay"`
+				}
+				path := "/proxies/" + url.PathEscape(id) + "/delay?url=" + url.QueryEscape(state.Settings.TestURL) + fmt.Sprintf("&timeout=%d", state.Settings.TestTimeoutMS)
+				err := a.core.Request(ctx, "GET", path, nil, &response)
+				message := ""
+				if err != nil {
+					message = err.Error()
+				}
+				ch <- outcome{id, response.Delay, message}
+			}(id)
+		}
+		for i := start; i < end; i++ {
+			v := <-ch
+			results[v.ID] = map[string]any{"delay": v.Delay, "error": v.Err}
+		}
+		if r.Context().Err() != nil {
+			return
+		}
+	}
+	jsonResponse(w, 200, results)
+}
+
+func (a *App) rules(w http.ResponseWriter, r *http.Request) {
+	jsonResponse(w, 200, map[string]any{"custom": a.Snapshot().Rules, "defaults": []map[string]string{{"match": "内网、回环、链路本地及组播地址", "action": "DIRECT"}, {"match": "自定义规则（按列表顺序）", "action": "CUSTOM"}, {"match": "大陆域名 / IP 规则库", "action": "DIRECT"}, {"match": "其余目标", "action": "PROXY"}}})
+}
+func (a *App) saveRule(w http.ResponseWriter, r *http.Request) {
+	var input struct {
+		Type    string `json:"type"`
+		Value   string `json:"value"`
+		Action  string `json:"action"`
+		Enabled bool   `json:"enabled"`
+	}
+	if err := decode(w, r, &input); err != nil {
+		writeError(w, 400, err.Error())
+		return
+	}
+	id := r.PathValue("id")
+	newRule := id == ""
+	if newRule {
+		id = randomID()
+	}
+	rule := Rule{ID: id, Type: input.Type, Value: strings.ToLower(strings.TrimSpace(input.Value)), Action: input.Action, Enabled: input.Enabled}
+	err := a.change(r.Context(), func(s *State) error {
+		if newRule {
+			s.Rules = append(s.Rules, rule)
+			return nil
+		}
+		for i, r := range s.Rules {
+			if r.ID == id {
+				s.Rules[i] = rule
+				return nil
+			}
+		}
+		return errors.New("规则不存在")
+	})
+	if err != nil {
+		writeError(w, 400, err.Error())
+		return
+	}
+	jsonResponse(w, 200, map[string]string{"id": id})
+}
+func (a *App) deleteRule(w http.ResponseWriter, r *http.Request) {
+	err := a.change(r.Context(), func(s *State) error {
+		for i, rule := range s.Rules {
+			if rule.ID == r.PathValue("id") {
+				s.Rules = append(s.Rules[:i], s.Rules[i+1:]...)
+				return nil
+			}
+		}
+		return errors.New("规则不存在")
+	})
+	if err != nil {
+		writeError(w, 400, err.Error())
+		return
+	}
+	jsonResponse(w, 200, map[string]bool{"ok": true})
+}
+
+func (a *App) settings(w http.ResponseWriter, r *http.Request) {
+	var settings Settings
+	if err := decode(w, r, &settings); err != nil {
+		writeError(w, 400, err.Error())
+		return
+	}
+	if settings.TunEnabled && !interfaceExists(settings.Interface, settings.LANIP) {
+		writeError(w, 400, "VM 地址与网卡不匹配；请在正式 VM 上先配置桥接网卡和固定 IP")
+		return
+	}
+	err := a.change(r.Context(), func(s *State) error { s.Settings = settings; return nil })
+	if err != nil {
+		writeError(w, 400, err.Error())
+		return
+	}
+	jsonResponse(w, 200, settings)
+}
+func (a *App) service(w http.ResponseWriter, r *http.Request) {
+	var input struct {
+		Action string `json:"action"`
+	}
+	if err := decode(w, r, &input); err != nil {
+		writeError(w, 400, err.Error())
+		return
+	}
+	if input.Action == "start" || input.Action == "restart" {
+		a.mu.Lock()
+		config, _ := compileConfig(a.state, a.core.Secret)
+		err := a.core.Apply(r.Context(), config)
+		a.mu.Unlock()
+		if err != nil {
+			writeError(w, 400, err.Error())
+			return
+		}
+	}
+	if err := a.core.Service(r.Context(), input.Action); err != nil {
+		writeError(w, 400, err.Error())
+		return
+	}
+	if input.Action != "stop" {
+		if err := a.core.Select(r.Context(), a.Snapshot()); err != nil {
+			writeError(w, 400, err.Error())
+			return
+		}
+	}
+	jsonResponse(w, 200, map[string]bool{"ok": true})
+}
+func (a *App) connections(w http.ResponseWriter, r *http.Request) {
+	var result map[string]any
+	if err := a.core.Request(r.Context(), "GET", "/connections", nil, &result); err != nil {
+		writeError(w, 503, err.Error())
+		return
+	}
+	jsonResponse(w, 200, result)
+}
+func (a *App) closeConnection(w http.ResponseWriter, r *http.Request) {
+	path := "/connections"
+	if id := r.PathValue("id"); id != "" {
+		path += "/" + url.PathEscape(id)
+	}
+	if err := a.core.Request(r.Context(), "DELETE", path, nil, nil); err != nil {
+		writeError(w, 503, err.Error())
+		return
+	}
+	jsonResponse(w, 200, map[string]bool{"ok": true})
+}
+func (a *App) backup(w http.ResponseWriter, r *http.Request) {
+	w.Header().Set("Content-Disposition", `attachment; filename="clashweb-backup.json"`)
+	jsonResponse(w, 200, Backup{1, now(), a.Snapshot()})
+}
+func (a *App) restore(w http.ResponseWriter, r *http.Request) {
+	var backup Backup
+	if err := decode(w, r, &backup); err != nil {
+		writeError(w, 400, err.Error())
+		return
+	}
+	if backup.Version != 1 {
+		writeError(w, 400, "不支持此备份版本")
+		return
+	}
+	if backup.State.Settings.TunEnabled && !interfaceExists(backup.State.Settings.Interface, backup.State.Settings.LANIP) {
+		writeError(w, 400, "备份中的网卡和 VM 地址与当前机器不匹配；请先修改备份中的网络设置或关闭 tunEnabled")
+		return
+	}
+	err := a.change(r.Context(), func(s *State) error { *s = backup.State; return nil })
+	if err != nil {
+		writeError(w, 400, err.Error())
+		return
+	}
+	jsonResponse(w, 200, map[string]bool{"ok": true})
+}
+func (a *App) network(w http.ResponseWriter, r *http.Request) {
+	interfaces := []map[string]any{}
+	list, _ := net.Interfaces()
+	for _, i := range list {
+		if i.Flags&net.FlagLoopback != 0 {
+			continue
+		}
+		ips := []string{}
+		addresses, _ := i.Addrs()
+		for _, addr := range addresses {
+			ip, _, err := net.ParseCIDR(addr.String())
+			if err == nil && ip.To4() != nil {
+				ips = append(ips, addr.String())
+			}
+		}
+		interfaces = append(interfaces, map[string]any{"name": i.Name, "addresses": ips, "up": i.Flags&net.FlagUp != 0})
+	}
+	sort.Slice(interfaces, func(i, j int) bool { return interfaces[i]["name"].(string) < interfaces[j]["name"].(string) })
+	forward, _ := os.ReadFile("/proc/sys/net/ipv4/ip_forward")
+	_, tunErr := os.Stat("/dev/net/tun")
+	_, domainErr := os.Stat(filepath.Join(a.core.Dir, "rules/cn-domain.mrs"))
+	_, ipErr := os.Stat(filepath.Join(a.core.Dir, "rules/cn-ip.mrs"))
+	jsonResponse(w, 200, map[string]any{"interfaces": interfaces, "ipForward": strings.TrimSpace(string(forward)) == "1", "tunDevice": tunErr == nil, "rulesInstalled": domainErr == nil && ipErr == nil, "serviceControl": a.core.Helper != "", "dhcpManaged": false, "guidance": "当前光猫 DHCP 无法关闭。请手动将测试设备的 IPv4 网关和 DNS 设为 PVE VM 的固定地址；不要在 VM 启动第二个 DHCP 服务。"})
+}
+
+func streamHeaders(w http.ResponseWriter) error {
+	if _, ok := w.(http.Flusher); !ok {
+		return errors.New("不支持流式响应")
+	}
+	w.Header().Set("Content-Type", "text/event-stream")
+	w.Header().Set("Cache-Control", "no-cache")
+	w.Header().Set("X-Accel-Buffering", "no")
+	return nil
+}
+func sendEvent(w http.ResponseWriter, event string, value any) error {
+	b, err := json.Marshal(value)
+	if err != nil {
+		return err
+	}
+	_ = http.NewResponseController(w).SetWriteDeadline(time.Now().Add(10 * time.Second))
+	if _, err := fmt.Fprintf(w, "event: %s\ndata: %s\n\n", event, b); err != nil {
+		return err
+	}
+	w.(http.Flusher).Flush()
+	return nil
+}
+func (a *App) events(w http.ResponseWriter, r *http.Request) {
+	if err := streamHeaders(w); err != nil {
+		writeError(w, 500, err.Error())
+		return
+	}
+	ticker := time.NewTicker(2 * time.Second)
+	defer ticker.Stop()
+	var prevUp, prevDown float64
+	last := time.Now()
+	initialized := false
+	for {
+		if _, _, err := a.session(r); err != nil {
+			_ = sendEvent(w, "expired", nil)
+			return
+		}
+		var connections struct {
+			Upload      float64           `json:"uploadTotal"`
+			Download    float64           `json:"downloadTotal"`
+			Connections []json.RawMessage `json:"connections"`
+		}
+		ctx, cancel := context.WithTimeout(r.Context(), 3*time.Second)
+		err := a.core.Request(ctx, "GET", "/connections", nil, &connections)
+		cancel()
+		current := time.Now()
+		seconds := current.Sub(last).Seconds()
+		up, down := float64(0), float64(0)
+		if err == nil && initialized && seconds > 0 {
+			up = (connections.Upload - prevUp) / seconds
+			down = (connections.Download - prevDown) / seconds
+			if up < 0 {
+				up = 0
+			}
+			if down < 0 {
+				down = 0
+			}
+		}
+		if err == nil {
+			prevUp = connections.Upload
+			prevDown = connections.Download
+		}
+		initialized = err == nil
+		last = current
+		if sendEvent(w, "metrics", map[string]any{"up": up, "down": down, "upTotal": connections.Upload, "downTotal": connections.Download, "connections": len(connections.Connections), "coreOnline": err == nil, "time": now()}) != nil {
+			return
+		}
+		select {
+		case <-r.Context().Done():
+			return
+		case <-ticker.C:
+		}
+	}
+}
+func (a *App) logs(w http.ResponseWriter, r *http.Request) {
+	if err := streamHeaders(w); err != nil {
+		writeError(w, 500, err.Error())
+		return
+	}
+	ctx, cancel := context.WithCancel(r.Context())
+	defer cancel()
+	items := make(chan any, 32)
+	finished := make(chan error, 1)
+	go func() {
+		finished <- a.core.Logs(ctx, func(item any) error {
+			select {
+			case items <- item:
+				return nil
+			case <-ctx.Done():
+				return ctx.Err()
+			}
+		})
+	}()
+	ticker := time.NewTicker(15 * time.Second)
+	defer ticker.Stop()
+	for {
+		select {
+		case item := <-items:
+			if sendEvent(w, "log", item) != nil {
+				return
+			}
+		case err := <-finished:
+			if err != nil {
+				_ = sendEvent(w, "disconnected", map[string]string{"error": "内核日志连接已断开，正在等待重连"})
+			}
+			return
+		case <-ticker.C:
+			if _, _, err := a.session(r); err != nil {
+				_ = sendEvent(w, "expired", nil)
+				return
+			}
+			if sendEvent(w, "heartbeat", nil) != nil {
+				return
+			}
+		case <-ctx.Done():
+			return
+		}
+	}
+}