package handler import ( "encoding/json" stderrors "errors" "html/template" "net/http" "net/url" "os" "strings" "github.com/gin-gonic/gin" "github.com/Tencent/WeKnora/internal/errors" "github.com/Tencent/WeKnora/internal/logger" "github.com/Tencent/WeKnora/internal/plugin/activate" "github.com/Tencent/WeKnora/internal/plugin/configschema" "github.com/Tencent/WeKnora/internal/plugin/install" "github.com/Tencent/WeKnora/internal/plugin/manifest" pluginoauth "github.com/Tencent/WeKnora/internal/plugin/oauth" "github.com/Tencent/WeKnora/internal/plugin/registry" "github.com/Tencent/WeKnora/internal/plugin/tenancy" "github.com/Tencent/WeKnora/internal/types" "github.com/Tencent/WeKnora/internal/types/interfaces" "github.com/Tencent/WeKnora/pluginsdk/pluginapi" ) // PluginFormsHandler serves what plugin forms need from the plugin while // they are being filled: dynamic choices (x-options) and OAuth connections // (x-oauth). type PluginFormsHandler struct { registry *registry.Registry tenancy *tenancy.Service invoker *activate.Invoker plugins interfaces.PluginRepository dataSources interfaces.DataSourceRepository webSearch interfaces.WebSearchProviderRepository oauth *pluginoauth.Service } // NewPluginFormsHandler creates the handler. func NewPluginFormsHandler( reg *registry.Registry, t *tenancy.Service, iv *activate.Invoker, plugins interfaces.PluginRepository, dataSources interfaces.DataSourceRepository, webSearch interfaces.WebSearchProviderRepository, oauth *pluginoauth.Service, ) *PluginFormsHandler { return &PluginFormsHandler{ registry: reg, tenancy: t, invoker: iv, plugins: plugins, dataSources: dataSources, webSearch: webSearch, oauth: oauth, } } // PluginOptionsRequest asks a plugin for a field's choices. type PluginOptionsRequest struct { Name string `json:"name" binding:"required"` Field string `json:"field" binding:"required"` // Scope is system, tenant or instance. Scope string `json:"scope" binding:"required"` // Contribution is "/" of the instance ("connectors/jira"). Contribution string `json:"contribution"` // InstanceID is the instance being edited; its stored secrets fill in // the fields the form did not change. InstanceID string `json:"instanceId"` // Values are what the form holds now, in the scope's shape. Values map[string]any `json:"values"` Query string `json:"query"` } // Options godoc // @Summary 插件表单的动态选项 // @Description 用表单当前的值(未修改的密钥用已存的值补齐)向插件取某个字段的可选项(x-options) // @Tags Plugins // @Accept json // @Produce json // @Param id path string true "插件 ID" // @Param request body PluginOptionsRequest true "请求" // @Success 200 {object} map[string]interface{} // @Security Bearer // @Router /plugins/{id}/options [post] func (h *PluginFormsHandler) Options(c *gin.Context) { limitJSONBody(c, 1<<20) var req PluginOptionsRequest if err := c.ShouldBindJSON(&req); err != nil { _ = c.Error(errors.NewBadRequestError("name, field and scope are required")) return } ctx := c.Request.Context() m, ok := h.codePlugin(c, c.Param("id"), req.Scope) if !ok { return } tenantID := c.GetUint64(types.TenantIDContextKey.String()) values := req.Values if values == nil { values = map[string]any{} } var override activate.ConfigOverride var instance map[string]any switch req.Scope { case pluginapi.OptionsScopeSystem: stored, _, err := install.OpenSystemConfig(ctx, h.plugins, m) if err != nil { h.fail(c, err) return } override.System = mergeForm(m.Config.SystemSchema, stored, values) case pluginapi.OptionsScopeTenant: stored, _, err := h.tenancy.OpenConfig(ctx, tenantID, m.ID) if err != nil { h.fail(c, err) return } override.Tenant = mergeForm(m.Config.TenantSchema, stored, values) case pluginapi.OptionsScopeInstance: var err error if instance, err = h.instanceValues(c, tenantID, req, values); err != nil { h.fail(c, err) return } default: _ = c.Error(errors.NewBadRequestError("scope must be system, tenant or instance")) return } in := pluginapi.OptionsInput{Field: req.Field, Scope: req.Scope, Contribution: req.Contribution, Query: req.Query} var out pluginapi.OptionsOutput err := h.invoker.CallOverriding(ctx, m, pluginapi.OptionsPath(req.Name), instance, override, in, &out) if err != nil { h.fail(c, err) return } if out.Options == nil { out.Options = []pluginapi.Option{} } c.JSON(http.StatusOK, gin.H{"success": true, "data": out}) } // codePlugin finds a plugin with code the caller may ask for this scope. func (h *PluginFormsHandler) codePlugin(c *gin.Context, id, scope string) (*manifest.Manifest, bool) { ctx := c.Request.Context() m, ok := h.registry.Plugin(id) if !ok || (m.Runtime.Type != manifest.RuntimeHost && m.Runtime.Type != manifest.RuntimeRemote) { _ = c.Error(errors.NewNotFoundError("no such plugin with code")) return nil, false } if scope == pluginapi.OptionsScopeSystem { if !types.IsSystemAdminFromContext(ctx) { c.AbortWithStatusJSON(http.StatusForbidden, gin.H{"error": "Forbidden: system administrators only"}) return nil, false } return m, true } tenantID := c.GetUint64(types.TenantIDContextKey.String()) if on, err := h.tenancy.PluginEnabled(ctx, tenantID, id); err != nil || !on { _ = c.Error(errors.NewNotFoundError("the plugin is not enabled in this workspace")) return nil, false } return m, true } // mergeForm fills the fields a form left redacted ("***") or empty with the // stored values. func mergeForm(rawSchema json.RawMessage, stored, values map[string]any) map[string]any { if len(rawSchema) == 0 { return values } schema, err := configschema.Parse(rawSchema) if err != nil { return values } return configschema.Merge(schema, stored, values) } // instanceValues is the instance the form holds, with the stored instance's // secrets filled in where the form has none (forms never receive secrets). func (h *PluginFormsHandler) instanceValues( c *gin.Context, tenantID uint64, req PluginOptionsRequest, values map[string]any, ) (map[string]any, error) { point, _, _ := strings.Cut(req.Contribution, "/") switch manifest.Point(point) { case manifest.PointConnectors: creds, _ := values["credentials"].(map[string]any) if creds == nil { creds = map[string]any{} } if req.InstanceID != "" { ds, err := h.dataSources.FindByID(c.Request.Context(), req.InstanceID) if err != nil || ds == nil || ds.TenantID != tenantID { return nil, errInstanceNotFound } cfg, err := ds.ParseConfig() if err != nil { return nil, err } for k, v := range cfg.Credentials { if s, _ := creds[k].(string); s == "" || s == types.RedactedSecretPlaceholder { creds[k] = v } } } out := map[string]any{ "credentials": creds, "settings": values["settings"], "resourceIds": values["resourceIds"], } if out["settings"] == nil { out["settings"] = map[string]any{} } return out, nil case manifest.PointWebSearch: out := map[string]any{} for k, v := range values { out[k] = v } if key, _ := out["api_key"].(string); req.InstanceID != "" && (key == "" || key == types.RedactedSecretPlaceholder) { p, err := h.webSearch.GetByID(c.Request.Context(), tenantID, req.InstanceID) if err != nil || p == nil { return nil, errInstanceNotFound } out["api_key"] = p.Parameters.APIKey } return out, nil default: return values, nil } } var errInstanceNotFound = stderrors.New("instance not found") // fail maps a plugin form failure: the plugin's own field problems go back // to the form as they are. func (h *PluginFormsHandler) fail(c *gin.Context, err error) { if stderrors.Is(err, errInstanceNotFound) { _ = c.Error(errors.NewNotFoundError("instance not found")) return } if pe, ok := pluginapi.AsError(err); ok { switch pe.Code { case pluginapi.CodeInvalidConfig, pluginapi.CodeUnauthorized, pluginapi.CodeBadRequest: body := gin.H{"success": false, "error": gin.H{"code": string(pe.Code), "message": pe.Message}} if pe.Details != nil && len(pe.Details.Fields) > 0 { body["error"].(gin.H)["fields"] = pe.Details.Fields } c.JSON(http.StatusBadRequest, body) return case pluginapi.CodeNotFound: _ = c.Error(errors.NewNotFoundError(pe.Message)) return } } logger.Warnf(c.Request.Context(), "[plugin] form request to %s failed: %v", c.Param("id"), err) c.JSON(http.StatusBadGateway, gin.H{"success": false, "error": gin.H{"message": err.Error()}}) } // PluginOAuthStartRequest starts connecting an x-oauth field. type PluginOAuthStartRequest struct { Scope string `json:"scope" binding:"required"` Contribution string `json:"contribution"` Field string `json:"field" binding:"required"` } // OAuthStart godoc // @Summary 开始插件字段的 OAuth 授权 // @Description 为 x-oauth 字段生成授权地址;授权完成后回调页把连接 ID 交回表单,令牌只保存在服务端 // @Tags Plugins // @Accept json // @Produce json // @Param id path string true "插件 ID" // @Param request body PluginOAuthStartRequest true "字段" // @Success 200 {object} map[string]interface{} // @Security Bearer // @Router /plugins/{id}/oauth/start [post] func (h *PluginFormsHandler) OAuthStart(c *gin.Context) { var req PluginOAuthStartRequest if err := c.ShouldBindJSON(&req); err != nil { _ = c.Error(errors.NewBadRequestError("scope and field are required")) return } m, ok := h.codePlugin(c, c.Param("id"), req.Scope) if !ok { return } target := pluginoauth.Target{ PluginID: m.ID, Scope: req.Scope, Contribution: req.Contribution, Field: req.Field, } if req.Scope != pluginapi.OptionsScopeSystem { target.TenantID = c.GetUint64(types.TenantIDContextKey.String()) } userID, _ := types.UserIDFromContext(c.Request.Context()) origin, base := appOrigin(c) url, state, err := h.oauth.Start(c.Request.Context(), target, userID, origin, base) if err != nil { _ = c.Error(errors.NewBadRequestError(err.Error())) return } c.JSON(http.StatusOK, gin.H{"success": true, "data": gin.H{ "authorizeUrl": url, "state": state, "redirectUri": base + pluginoauth.CallbackPath, }}) } // appOrigin is the app's origin (where the callback page reports back) and // the base URL authorization servers send the browser to: APP_EXTERNAL_URL // when set, else the origin the browser called from. func appOrigin(c *gin.Context) (origin, base string) { if ext := strings.TrimSuffix(strings.TrimSpace(os.Getenv("APP_EXTERNAL_URL")), "/"); ext != "" { if u, err := url.Parse(ext); err == nil && u.Host != "" { return u.Scheme + "://" + u.Host, ext } } if o := c.GetHeader("Origin"); strings.HasPrefix(o, "http://") || strings.HasPrefix(o, "https://") { return o, o } scheme := "http" if c.Request.TLS != nil || strings.EqualFold(c.GetHeader("X-Forwarded-Proto"), "https") { scheme = "https" } host := c.Request.Host if fh := c.GetHeader("X-Forwarded-Host"); fh != "" { host = fh } o := scheme + "://" + host return o, o } var oauthDoneTemplate = template.Must(template.New("oauth").Parse(` WeKnora

{{.Message}}

`)) // OAuthCallback is where authorization servers send the browser back. It // needs no login (the state names the pending authorization) and answers // with a page that hands the result to the form that opened it. func (h *PluginFormsHandler) OAuthCallback(c *gin.Context) { res := h.oauth.Complete(c.Request.Context(), c.Query("state"), c.Query("code"), c.Query("error")) data := map[string]any{ "State": res.State, "Origin": res.Origin, "OK": res.Err == nil, "Connection": "", "Error": "", "Message": "Connected. You can close this window.", } if res.Err != nil { data["Error"], data["Message"] = res.Err.Error(), res.Err.Error() } else { data["Connection"] = configschema.OAuthRefPrefix + res.ConnectionID } c.Header("Content-Type", "text/html; charset=utf-8") c.Header("Cache-Control", "no-store") c.Header("Referrer-Policy", "no-referrer") status := http.StatusOK if res.Err != nil { status = http.StatusBadRequest } c.Status(status) _ = oauthDoneTemplate.Execute(c.Writer, data) }