Files
1Panel/core/app/service/mcp_nodes.go
蘭 d7355f3ccc feat(mcp): add 1Panel MCP and enhance MCP credential management (#14189)
* feat(mcp): add 1Panel MCP and enhance MCP credential management

* feat(i18n): implement MCP document localization and remove legacy code
2026-10-26 13:59:49 +08:00

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)
}