Merge pull request #707 from chaitin/feat/team-mcp-hub

feat: 支持团队 MCP Hub

Author: yokowu

backend/biz/mcphub/auth/service.go

@@ -0,0 +1,81 @@
+package auth
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"log/slog"
+	"strings"
+
+	"github.com/google/uuid"
+
+	"github.com/chaitin/MonkeyCode/backend/db"
+	"github.com/chaitin/MonkeyCode/backend/db/modelapikey"
+	"github.com/chaitin/MonkeyCode/backend/db/taskvirtualmachine"
+)
+
+var (
+	ErrUnauthorized = errors.New("unauthorized")
+	ErrTaskNotBound = errors.New("task not bound")
+)
+
+type Subject struct {
+	Token         string
+	UserID        uuid.UUID
+	TaskID        uuid.UUID
+	ModelID       uuid.UUID
+	ModelAPIKeyID uuid.UUID
+}
+
+type Service struct {
+	db     *db.Client
+	logger *slog.Logger
+}
+
+func NewService(client *db.Client, logger *slog.Logger) *Service {
+	if logger == nil {
+		logger = slog.Default()
+	}
+	return &Service{
+		db:     client,
+		logger: logger,
+	}
+}
+
+func (s *Service) Resolve(ctx context.Context, token string) (*Subject, error) {
+	token = strings.TrimSpace(token)
+	if token == "" {
+		return nil, ErrUnauthorized
+	}
+
+	key, err := s.db.ModelApiKey.Query().
+		Where(modelapikey.APIKey(token)).
+		Only(ctx)
+	if err != nil {
+		if db.IsNotFound(err) || db.IsNotSingular(err) {
+			return nil, ErrUnauthorized
+		}
+		return nil, fmt.Errorf("query model api key: %w", err)
+	}
+	if strings.TrimSpace(key.VirtualmachineID) == "" {
+		return nil, ErrTaskNotBound
+	}
+
+	tvm, err := s.db.TaskVirtualMachine.Query().
+		Where(taskvirtualmachine.VirtualmachineID(key.VirtualmachineID)).
+		Only(ctx)
+	if err != nil {
+		if db.IsNotFound(err) || db.IsNotSingular(err) {
+			return nil, ErrTaskNotBound
+		}
+		return nil, fmt.Errorf("query task binding: %w", err)
+	}
+
+	return &Subject{
+		Token:         token,
+		UserID:        key.UserID,
+		TaskID:        tvm.TaskID,
+		ModelID:       key.ModelID,
+		ModelAPIKeyID: key.ID,
+	}, nil
+}

backend/biz/mcphub/auth/service_test.go

@@ -0,0 +1,58 @@
+package auth
+
+import (
+	"context"
+	"testing"
+
+	"github.com/google/uuid"
+	_ "github.com/mattn/go-sqlite3"
+
+	"github.com/chaitin/MonkeyCode/backend/db/enttest"
+)
+
+func TestResolveRejectsEmptyToken(t *testing.T) {
+	client := enttest.Open(t, "sqlite3", "file:mcphub-auth-empty?mode=memory&cache=shared&_fk=1")
+	defer client.Close()
+
+	svc := NewService(client, nil)
+	if _, err := svc.Resolve(context.Background(), " "); err != ErrUnauthorized {
+		t.Fatalf("Resolve() error = %v, want ErrUnauthorized", err)
+	}
+}
+
+func TestResolveRejectsUnboundModelKey(t *testing.T) {
+	client := enttest.Open(t, "sqlite3", "file:mcphub-auth-unbound?mode=memory&cache=shared&_fk=1")
+	defer client.Close()
+	ctx := context.Background()
+
+	userID := uuid.New()
+	modelID := uuid.New()
+	client.User.Create().
+		SetID(userID).
+		SetName("u").
+		SetEmail("u@example.com").
+		SetRole("user").
+		SetStatus("active").
+		SaveX(ctx)
+	client.Model.Create().
+		SetID(modelID).
+		SetUserID(userID).
+		SetProvider("openai").
+		SetAPIKey("upstream-key").
+		SetBaseURL("https://example.com").
+		SetModel("gpt-test").
+		SetInterfaceType("openai_chat").
+		SaveX(ctx)
+	client.ModelApiKey.Create().
+		SetID(uuid.New()).
+		SetUserID(userID).
+		SetModelID(modelID).
+		SetAPIKey("runtime-token").
+		SetVirtualmachineID("").
+		SaveX(ctx)
+
+	svc := NewService(client, nil)
+	if _, err := svc.Resolve(ctx, "runtime-token"); err != ErrTaskNotBound {
+		t.Fatalf("Resolve() error = %v, want ErrTaskNotBound", err)
+	}
+}

backend/biz/mcphub/billing/noop.go

@@ -0,0 +1,21 @@
+package billing
+
+import (
+	"context"
+
+	"github.com/chaitin/MonkeyCode/backend/biz/mcphub/repo"
+)
+
+type Noop struct{}
+
+func NewNoop() *Noop {
+	return &Noop{}
+}
+
+func (n *Noop) CanConsume(context.Context, *repo.ToolCallRecord) error {
+	return nil
+}
+
+func (n *Noop) Consume(context.Context, *repo.ToolCallRecord) error {
+	return nil
+}

backend/biz/mcphub/billing/noop_test.go

@@ -0,0 +1,16 @@
+package billing
+
+import (
+	"context"
+	"testing"
+)
+
+func TestNoopAllowsConsume(t *testing.T) {
+	b := NewNoop()
+	if err := b.CanConsume(context.Background(), nil); err != nil {
+		t.Fatalf("CanConsume() error = %v", err)
+	}
+	if err := b.Consume(context.Background(), nil); err != nil {
+		t.Fatalf("Consume() error = %v", err)
+	}
+}

backend/biz/mcphub/control/syncer/service.go

@@ -0,0 +1,101 @@
+package syncer
+
+import (
+	"context"
+	"crypto/sha256"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+
+	"github.com/google/uuid"
+
+	"github.com/chaitin/MonkeyCode/backend/biz/mcphub/repo"
+)
+
+type upstreamRepo interface {
+	Get(ctx context.Context, id uuid.UUID) (*repo.UpstreamConfig, error)
+	MarkSyncSuccess(ctx context.Context, id uuid.UUID) error
+	MarkSyncFailed(ctx context.Context, id uuid.UUID) error
+}
+
+type toolRepo interface {
+	ReplaceByUpstream(ctx context.Context, upstreamID uuid.UUID, rows []repo.UpsertToolInput) error
+}
+
+type registryPublisher interface {
+	Publish(ctx context.Context) error
+}
+
+type upstreamClient interface {
+	ListTools(ctx context.Context, upstream *repo.UpstreamConfig) ([]repo.UpstreamTool, error)
+}
+
+type Service struct {
+	upstreams upstreamRepo
+	tools     toolRepo
+	registry  registryPublisher
+	client    upstreamClient
+}
+
+func NewService(upstreams upstreamRepo, tools toolRepo, registry registryPublisher, client upstreamClient) *Service {
+	return &Service{
+		upstreams: upstreams,
+		tools:     tools,
+		registry:  registry,
+		client:    client,
+	}
+}
+
+func (s *Service) Sync(ctx context.Context, upstreamID uuid.UUID) error {
+	upstream, err := s.upstreams.Get(ctx, upstreamID)
+	if err != nil {
+		return err
+	}
+
+	tools, err := s.client.ListTools(ctx, upstream)
+	if err != nil {
+		_ = s.upstreams.MarkSyncFailed(ctx, upstreamID)
+		return err
+	}
+
+	rows := make([]repo.UpsertToolInput, 0, len(tools))
+	for _, tool := range tools {
+		rows = append(rows, repo.UpsertToolInput{
+			UpstreamID:     upstreamID,
+			Name:           tool.Name,
+			NamespacedName: NamespacedName(upstream.Slug, tool.Name),
+			Scope:          upstream.Scope,
+			UserID:         upstream.UserID,
+			TeamID:         upstream.TeamID,
+			Description:    tool.Description,
+			InputSchema:    tool.InputSchema,
+			VersionHash:    hashSchema(tool.InputSchema),
+			Price:          0,
+		})
+	}
+
+	if err := s.tools.ReplaceByUpstream(ctx, upstreamID, rows); err != nil {
+		_ = s.upstreams.MarkSyncFailed(ctx, upstreamID)
+		return err
+	}
+	if err := s.registry.Publish(ctx); err != nil {
+		_ = s.upstreams.MarkSyncFailed(ctx, upstreamID)
+		return err
+	}
+	if err := s.upstreams.MarkSyncSuccess(ctx, upstreamID); err != nil {
+		return err
+	}
+	return nil
+}
+
+func hashSchema(raw json.RawMessage) string {
+	if len(raw) == 0 {
+		raw = json.RawMessage(`{}`)
+	}
+	sum := sha256.Sum256(raw)
+	return hex.EncodeToString(sum[:])
+}
+
+func NamespacedName(slug, tool string) string {
+	return fmt.Sprintf("%s__%s", slug, tool)
+}