mirror of
https://github.com/1Panel-dev/1Panel.git
synced 2026-11-20 00:01:06 +00:00
* feat(mcp): add 1Panel MCP and enhance MCP credential management * feat(i18n): implement MCP document localization and remove legacy code
137 lines
3.5 KiB
Go
137 lines
3.5 KiB
Go
package service
|
|
|
|
import (
|
|
"encoding/json"
|
|
"net/http"
|
|
"slices"
|
|
|
|
"github.com/1Panel-dev/1Panel/core/app/auth"
|
|
"github.com/1Panel-dev/1Panel/core/app/dto"
|
|
"github.com/1Panel-dev/1Panel/core/app/model"
|
|
contract "github.com/1Panel-dev/1Panel/core/utils/mcp"
|
|
)
|
|
|
|
func (s *MCPService) Nodes(owner auth.APIKeyOwner) ([]dto.MCPNodeItem, error) {
|
|
if s.NodeProvider == nil {
|
|
return nil, contract.Forbidden()
|
|
}
|
|
nodes, err := s.NodeProvider.ListMCPNodes(owner)
|
|
if err != nil {
|
|
return nil, contract.Forbidden()
|
|
}
|
|
items := make([]dto.MCPNodeItem, 0, len(nodes))
|
|
seen := make(map[string]bool, len(nodes))
|
|
for _, node := range nodes {
|
|
if !contract.ValidateNodeID(node.ID) || node.IsLocal != (node.ID == "local") || seen[node.ID] {
|
|
return nil, contract.Forbidden()
|
|
}
|
|
seen[node.ID] = true
|
|
items = append(items, dto.MCPNodeItem{ID: node.ID, Name: node.Name, Status: node.Status, IsLocal: node.IsLocal})
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
func mcpNodeItemIDs(nodes []dto.MCPNodeItem) []string {
|
|
ids := make([]string, 0, len(nodes))
|
|
for _, node := range nodes {
|
|
ids = append(ids, node.ID)
|
|
}
|
|
return ids
|
|
}
|
|
|
|
func mcpEncodeNodeIDs(ids []string) string {
|
|
data, _ := json.Marshal(ids)
|
|
return string(data)
|
|
}
|
|
|
|
func mcpCredentialNodeIDs(key model.MCPCredential) ([]string, error) {
|
|
var ids []string
|
|
if json.Unmarshal([]byte(key.NodeIDs), &ids) != nil || len(ids) == 0 || len(ids) > 256 {
|
|
return nil, contract.Forbidden()
|
|
}
|
|
for _, id := range ids {
|
|
if !contract.ValidateNodeID(id) {
|
|
return nil, contract.Forbidden()
|
|
}
|
|
}
|
|
return ids, nil
|
|
}
|
|
|
|
func (s *MCPService) validateNodeIDs(owner auth.APIKeyOwner, ids *[]string) error {
|
|
if len(*ids) == 0 || len(*ids) > 256 {
|
|
return contract.Invalid()
|
|
}
|
|
for _, id := range *ids {
|
|
if !contract.ValidateNodeID(id) {
|
|
return contract.Invalid()
|
|
}
|
|
}
|
|
slices.Sort(*ids)
|
|
*ids = slices.Compact(*ids)
|
|
nodes, err := s.Nodes(owner)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
available := mcpNodeItemIDs(nodes)
|
|
for _, id := range *ids {
|
|
if !slices.Contains(available, id) {
|
|
return contract.Forbidden()
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (s *MCPService) credentialNodes(key model.MCPCredential, owner auth.APIKeyOwner) ([]dto.MCPNodeItem, error) {
|
|
ids, err := mcpCredentialNodeIDs(key)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
nodes, err := s.Nodes(owner)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
allowed := make([]dto.MCPNodeItem, 0, len(nodes))
|
|
for _, node := range nodes {
|
|
if slices.Contains(ids, node.ID) {
|
|
allowed = append(allowed, node)
|
|
}
|
|
}
|
|
return allowed, nil
|
|
}
|
|
|
|
func mcpIsNodeDiscovery(tool contract.Tool) bool {
|
|
return tool.ToolID == "list_nodes" && tool.ReadOnly && len(tool.Operations) == 1 &&
|
|
tool.Operations[0].ID == "nodes" && tool.Operations[0].Method == http.MethodGet &&
|
|
tool.Operations[0].Path == contract.NodesPath
|
|
}
|
|
|
|
func (s *MCPService) authorizeToolOnNodes(owner auth.APIKeyOwner, nodeIDs []string, tool contract.Tool) error {
|
|
if mcpIsNodeDiscovery(tool) {
|
|
return nil
|
|
}
|
|
for _, nodeID := range nodeIDs {
|
|
if s.authorizeToolOnNode(owner, nodeID, tool) == nil {
|
|
return nil
|
|
}
|
|
}
|
|
return contract.Forbidden()
|
|
}
|
|
|
|
func (s *MCPService) authorizeInvocationNode(key model.MCPCredential, owner auth.APIKeyOwner, nodeID string, tool contract.Tool) error {
|
|
if mcpIsNodeDiscovery(tool) {
|
|
if nodeID != "local" {
|
|
return contract.Forbidden()
|
|
}
|
|
_, err := s.credentialNodes(key, owner)
|
|
return err
|
|
}
|
|
nodes, err := s.credentialNodes(key, owner)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if !slices.Contains(mcpNodeItemIDs(nodes), nodeID) {
|
|
return contract.Forbidden()
|
|
}
|
|
return s.authorizeToolOnNode(owner, nodeID, tool)
|
|
}
|