Add MTProxy, MASQUE, VPN, Link parser. Update AmneziaWG. Remove Tunneling

experimental/clashapi/provider.go

@@ -4,48 +4,78 @@ import (
 	"context"
 	"net/http"
 
+	"github.com/sagernet/sing-box/adapter"
+	C "github.com/sagernet/sing-box/constant"
+	"github.com/sagernet/sing/common/json/badjson"
+
 	"github.com/go-chi/chi/v5"
 	"github.com/go-chi/render"
 )
 
-func proxyProviderRouter() http.Handler {
+func proxyProviderRouter(server *Server) http.Handler {
 	r := chi.NewRouter()
-	r.Get("/", getProviders)
+	r.Get("/", getProviders(server))
 
 	r.Route("/{name}", func(r chi.Router) {
-		r.Use(parseProviderName, findProviderByName)
-		r.Get("/", getProvider)
+		r.Use(parseProviderName, findProviderByName(server))
+		r.Get("/", getProvider(server))
 		r.Put("/", updateProvider)
 		r.Get("/healthcheck", healthCheckProvider)
 	})
 	return r
 }
 
-func getProviders(w http.ResponseWriter, r *http.Request) {
-	render.JSON(w, r, render.M{
-		"providers": render.M{},
-	})
+func getProviders(server *Server) func(w http.ResponseWriter, r *http.Request) {
+	return func(w http.ResponseWriter, r *http.Request) {
+		providerMap := make(render.M)
+		for _, provider := range server.provider.Providers() {
+			providerMap[provider.Tag()] = providerInfo(server, provider)
+		}
+		render.JSON(w, r, render.M{
+			"providers": providerMap,
+		})
+	}
 }
 
-func getProvider(w http.ResponseWriter, r *http.Request) {
-	/*provider := r.Context().Value(CtxKeyProvider).(provider.ProxyProvider)
-	render.JSON(w, r, provider)*/
-	render.NoContent(w, r)
+func getProvider(server *Server) func(w http.ResponseWriter, r *http.Request) {
+	return func(w http.ResponseWriter, r *http.Request) {
+		provider := r.Context().Value(CtxKeyProvider).(adapter.Provider)
+		render.JSON(w, r, providerInfo(server, provider))
+	}
+}
+
+func providerInfo(server *Server, p adapter.Provider) *badjson.JSONObject {
+	var info badjson.JSONObject
+	proxies := make([]*badjson.JSONObject, 0)
+	for _, detour := range p.Outbounds() {
+		proxies = append(proxies, proxyInfo(server, detour))
+	}
+	info.Put("type", "Proxy")                                // Proxy, Rule
+	info.Put("vehicleType", C.ProviderDisplayName(p.Type())) // HTTP, File, Compatible
+	info.Put("name", p.Tag())
+	info.Put("proxies", proxies)
+	info.Put("updatedAt", p.UpdatedAt())
+	if p, ok := p.(adapter.ProviderSubscriptionInfo); ok {
+		info.Put("subscriptionInfo", p.SubscriptionInfo())
+	}
+	return &info
 }
 
 func updateProvider(w http.ResponseWriter, r *http.Request) {
-	/*provider := r.Context().Value(CtxKeyProvider).(provider.ProxyProvider)
-	if err := provider.Update(); err != nil {
-		render.Status(r, http.StatusServiceUnavailable)
-		render.JSON(w, r, newError(err.Error()))
-		return
-	}*/
+	provider := r.Context().Value(CtxKeyProvider).(adapter.Provider)
+	if provider, isUpdater := provider.(adapter.ProviderUpdater); isUpdater {
+		if err := provider.Update(); err != nil {
+			render.Status(r, http.StatusServiceUnavailable)
+			render.JSON(w, r, newError(err.Error()))
+			return
+		}
+	}
 	render.NoContent(w, r)
 }
 
 func healthCheckProvider(w http.ResponseWriter, r *http.Request) {
-	/*provider := r.Context().Value(CtxKeyProvider).(provider.ProxyProvider)
-	provider.HealthCheck()*/
+	provider := r.Context().Value(CtxKeyProvider).(adapter.Provider)
+	provider.HealthCheck(r.Context())
 	render.NoContent(w, r)
 }
 
@@ -57,18 +87,19 @@ func parseProviderName(next http.Handler) http.Handler {
 	})
 }
 
-func findProviderByName(next http.Handler) http.Handler {
-	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		/*name := r.Context().Value(CtxKeyProviderName).(string)
-		providers := tunnel.ProxyProviders()
-		provider, exist := providers[name]
-		if !exist {*/
-		render.Status(r, http.StatusNotFound)
-		render.JSON(w, r, ErrNotFound)
-		//return
-		//}
+func findProviderByName(server *Server) func(next http.Handler) http.Handler {
+	return func(next http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			name := r.Context().Value(CtxKeyProviderName).(string)
+			provider, exist := server.provider.Get(name)
+			if !exist {
+				render.Status(r, http.StatusNotFound)
+				render.JSON(w, r, ErrNotFound)
+				return
+			}
 
-		// ctx := context.WithValue(r.Context(), CtxKeyProvider, provider)
-		// next.ServeHTTP(w, r.WithContext(ctx))
-	})
+			ctx := context.WithValue(r.Context(), CtxKeyProvider, provider)
+			next.ServeHTTP(w, r.WithContext(ctx))
+		})
+	}
 }

experimental/clashapi/server.go

@@ -46,6 +46,7 @@ type Server struct {
 	dnsRouter      adapter.DNSRouter
 	outbound       adapter.OutboundManager
 	endpoint       adapter.EndpointManager
+	provider       adapter.ProviderManager
 	logger         log.Logger
 	httpServer     *http.Server
 	trafficManager *trafficontrol.Manager
@@ -71,6 +72,7 @@ func NewServer(ctx context.Context, logFactory log.ObservableFactory, options op
 		dnsRouter: service.FromContext[adapter.DNSRouter](ctx),
 		outbound:  service.FromContext[adapter.OutboundManager](ctx),
 		endpoint:  service.FromContext[adapter.EndpointManager](ctx),
+		provider:  service.FromContext[adapter.ProviderManager](ctx),
 		logger:    logFactory.NewLogger("clash-api"),
 		httpServer: &http.Server{
 			Addr:    options.ExternalController,
@@ -122,7 +124,7 @@ func NewServer(ctx context.Context, logFactory log.ObservableFactory, options op
 		r.Mount("/proxies", proxyRouter(s, s.router))
 		r.Mount("/rules", ruleRouter(s.router))
 		r.Mount("/connections", connectionRouter(s.ctx, s.router, trafficManager))
-		r.Mount("/providers/proxies", proxyProviderRouter())
+		r.Mount("/providers/proxies", proxyProviderRouter(s))
 		r.Mount("/providers/rules", ruleProviderRouter())
 		r.Mount("/script", scriptRouter())
 		r.Mount("/profile", profileRouter())