wip: mcp server execute code

Author: marle3003

mcp/run.go

@@ -3,7 +3,15 @@ package mcp
 import (
 	"context"
 	_ "embed"
+	"fmt"
+	"io"
+	"mokapi/js/faker"
+	"mokapi/providers/openapi"
+	"mokapi/providers/openapi/schema"
 	"mokapi/runtime"
+	"mokapi/schema/json/generator"
+	"net/http"
+	"net/textproto"
 	"reflect"
 	"slices"
 	"strings"
@@ -122,6 +130,7 @@ type ApiSummary struct {
 func (m *mokapi) init(obj *goja.Object) {
 	_ = obj.Set("getApis", m.getApis)
 	_ = obj.Set("getApi", m.getApi)
+	_ = obj.Set("fake", m.fake)
 }
 
 func (m *mokapi) getApis() []ApiSummary {
@@ -146,20 +155,30 @@ func (m *mokapi) getApi(name string) any {
 	for _, api := range m.app.ListHttp() {
 		if api.Info.Name == name {
 			return &OpenAPI{
-				Name: name,
-				Type: "http",
-				info: api,
+				Name:    name,
+				Type:    "http",
+				info:    api,
+				handler: api.Handler(m.app.Monitor.Http, m.app.Engine, m.app.Events),
 			}
 		}
 	}
 	return nil
 }
 
+func (m *mokapi) fake(v goja.Value) (any, error) {
+	js, err := faker.ToJsonSchema(v, m.vm)
+	if err != nil {
+		return nil, err
+	}
+	return generator.New(&generator.Request{Schema: js})
+}
+
 type OpenAPI struct {
 	Name string `json:"name"`
 	Type string `json:"type"`
 
-	info *runtime.HttpInfo
+	info    *runtime.HttpInfo
+	handler openapi.Handler
 }
 
 type OperationSummary struct {
@@ -169,11 +188,41 @@ type OperationSummary struct {
 }
 
 type OperationDetails struct {
-	OperationId string `json:"operationId"`
-	Method      string `json:"method"`
-	Path        string `json:"path"`
-	Summary     string `json:"summary"`
-	Description string `json:"description"`
+	OperationId string              `json:"operationId"`
+	Method      string              `json:"method"`
+	Path        string              `json:"path"`
+	Summary     string              `json:"summary"`
+	Description string              `json:"description,omitempty"`
+	Parameters  []RequestParameters `json:"parameters,omitempty"`
+	RequestBody RequestBody         `json:"requestBody,omitempty"`
+
+	spec    *openapi.Operation
+	handler openapi.Handler
+}
+
+type RequestParameters struct {
+	Name        string `json:"name"`
+	In          string `json:"in"`
+	Required    bool   `json:"required"`
+	Schema      *schema.Schema
+	Description string `json:"description,omitempty"`
+}
+
+type RequestBody struct {
+	Description string    `json:"description,omitempty"`
+	Required    bool      `json:"required"`
+	Contents    []Content `json:"contents"`
+}
+
+type Content struct {
+	ContentType string         `json:"contentType"`
+	Schema      *schema.Schema `json:"schema"`
+}
+
+type Response struct {
+	StatusCode  int       `json:"statusCode"`
+	Description string    `json:"description,omitempty"`
+	Content     []Content `json:"content"`
 }
 
 func (o *OpenAPI) GetOperations() []OperationSummary {
@@ -215,17 +264,164 @@ func (o *OpenAPI) GetOperationDetails(path, method string) *OperationDetails {
 		if op == nil {
 			continue
 		}
-		return &OperationDetails{
+		r := &OperationDetails{
 			OperationId: op.OperationId,
 			Method:      method,
 			Path:        p.Value.Path,
 			Summary:     op.Summary,
 			Description: op.Description,
+			spec:        op,
+			handler:     o.handler,
+		}
+		for _, param := range op.Parameters {
+			if param.Value == nil {
+				continue
+			}
+			r.Parameters = append(r.Parameters, RequestParameters{
+				Name:        param.Value.Name,
+				In:          param.Value.Type.String(),
+				Required:    param.Value.Required,
+				Schema:      param.Value.Schema,
+				Description: param.Value.Description,
+			})
 		}
+		if op.RequestBody != nil && op.RequestBody.Value != nil {
+			r.RequestBody = RequestBody{
+				Description: op.RequestBody.Value.Description,
+				Required:    op.RequestBody.Value.Required,
+			}
+			for ct, content := range op.RequestBody.Value.Content {
+				r.RequestBody.Contents = append(r.RequestBody.Contents, Content{
+					ContentType: ct,
+					Schema:      content.Schema,
+				})
+			}
+		}
+		return r
 	}
 	return nil
 }
 
+func (op *OperationDetails) GetResponseSchema(statusCode int) *Response {
+	r := op.spec.Responses.GetResponse(statusCode)
+	if r == nil {
+		return nil
+	}
+	result := &Response{
+		StatusCode:  statusCode,
+		Description: r.Description,
+	}
+	for ct, content := range r.Content {
+		result.Content = append(result.Content, Content{
+			ContentType: ct,
+			Schema:      content.Schema,
+		})
+	}
+	return result
+}
+
+type InvokeRequest struct {
+	Path   map[string]string   `json:"path"`
+	Query  map[string]string   `json:"query"`
+	Header map[string][]string `json:"header"`
+	Body   string              `json:"body"`
+}
+
+type InvokeResponse struct {
+	StatusCode int                 `json:"statusCode"`
+	Headers    map[string][]string `json:"headers"`
+	Body       string              `json:"body"`
+}
+
+func (op *OperationDetails) Invoke(req InvokeRequest) (InvokeResponse, error) {
+	result := InvokeResponse{Headers: make(map[string][]string)}
+
+	var body io.Reader
+	if req.Body != "" {
+		body = strings.NewReader(req.Body)
+	}
+
+	path := op.Path
+	query := ""
+	params := append(op.spec.Path.Parameters, op.spec.Parameters...)
+	for _, p := range params {
+		if p.Value == nil {
+			continue
+		}
+		switch p.Value.Type {
+		case openapi.ParameterPath:
+			if req.Path == nil {
+				return result, fmt.Errorf("invoke request %s %s failed: missing path parameter '%s'", op.Method, op.Path, p.Value.Name)
+			}
+			val, ok := req.Path[p.Value.Name]
+			if !ok {
+				return result, fmt.Errorf("invoke request %s %s failed: missing path parameter '%s'", op.Method, op.Path, p.Value.Name)
+			}
+			path = strings.ReplaceAll(path, fmt.Sprintf("{%s}", p.Value.Name), val)
+		case openapi.ParameterQuery:
+			if req.Query == nil && p.Value.Required {
+				return result, fmt.Errorf("invoke request %s %s failed: missing query parameter '%s'", op.Method, op.Path, p.Value.Name)
+			}
+			val, ok := req.Query[p.Value.Name]
+			if !ok {
+				if !p.Value.Required {
+					continue
+				}
+				return result, fmt.Errorf("invoke request %s %s failed: missing query parameter '%s'", op.Method, op.Path, p.Value.Name)
+			}
+			if query != "" {
+				query += "&"
+			}
+			query += fmt.Sprintf("%s=%s", p.Value.Name, val)
+		}
+	}
+
+	if query != "" {
+		path += "?" + query
+	}
+
+	r, err := http.NewRequest(op.Method, path, body)
+	if err != nil {
+		return result, fmt.Errorf("error creating request: %w", err)
+	}
+	for _, p := range params {
+		if p.Value == nil || p.Value.Type != openapi.ParameterHeader {
+			continue
+		}
+		if req.Header == nil && p.Value.Required {
+			return result, fmt.Errorf("invoke request %s %s failed: missing header parameter '%s'", op.Method, op.Path, p.Value.Name)
+		}
+		val, ok := req.Header[p.Value.Name]
+		if !ok {
+			if !p.Value.Required {
+				continue
+			}
+			return result, fmt.Errorf("invoke request %s %s failed: missing header parameter '%s'", op.Method, op.Path, p.Value.Name)
+		}
+		r.Header[textproto.CanonicalMIMEHeaderKey(p.Value.Name)] = val
+	}
+
+	he := op.handler.ServeHTTP(&result, r)
+	if he != nil {
+		result.StatusCode = he.StatusCode
+		result.Body = he.Message
+	}
+	return result, nil
+}
+
+func (r *InvokeResponse) Header() http.Header {
+	return r.Headers
+}
+
+func (r *InvokeResponse) WriteHeader(statusCode int) {
+	r.StatusCode = statusCode
+}
+
+func (r *InvokeResponse) Write(body []byte) (int, error) {
+	r.Body = string(body)
+	return len(body), nil
+}
+
 type customFieldNameMapper struct {
 }