wip: mcp server execute code

- add Kafka support
- refactor run code

Author: marle3003

mcp/conditional-response.md

@@ -5,6 +5,11 @@ Demonstrates how to:
 - Access request parameters
 - Apply custom logic (e.g., lookup, filtering, updates)
 
+IMPORTANT  
+Strict Specification Enforcement:
+Mokapi will throw an error if you use a status code NOT defined in the specification.
+Always verify the available status codes for each operation before calling response.rebuild() or setting response.statusCode.
+
 ```typescript
 import { on } from "mokapi"
 
@@ -24,6 +29,7 @@ export default function () {
 			case '/terminals/{id}': {
 				const terminal = terminals.find(x => x.id === request.path.id)
 				if (!terminal) {
+                    // CHECK SPEC: Is 404 defined for this path and HTTP method?
 					response.rebuild(404)
 					response.data = { error: 'terminal not found' }
 					return
@@ -48,6 +54,7 @@ export default function () {
 					if (terminal) {
 						// console output will be displayed in the Mokapi's' dashboard
 						console.log('terminal already exists', request.body)
+                        // CHECK SPEC: Is 400 defined for this path and HTTP method?
 						response.rebuild(400)
 					} else {
 						terminals.push(request.body)

mcp/mock_reference.md

@@ -11,14 +11,14 @@ with the corresponding category and name (e.g., category='types', name='http')
 Overview of TypeScript definitions for mock event handlers.
 - Use these types to ensure correct syntax for "import { ... } from 'mokapi/...'".
 
-| Type                           | Import Statement                      | Parameter Name |
-|--------------------------------|---------------------------------------|----------------|
-| **Core**                       | `import {...} from 'mokapi'`          | mokapi         |
-| **HTTP**                       | `import {...} from 'mokapi/http'`     | http           |
-| **Kafka**                      | `import {...} from 'mokapi/kafka'`    | kafka          |
-| **Faker**                      | `import {...} from 'mokapi/faker'`    | faker          |
-| **Mustache**                   | `import {...} from 'mokapi/mustache'` | mustache       |
-| **Yaml**                       | `import {...} from 'mokapi/yaml'`     | yaml           |
+| Type                           | Description                                                                                                                                                                                         | Import Statement                      | Parameter Name       |
+|--------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------------------------------|----------------------|
+| **Core**                       | Exposes the core scripting API for Mokapi. It allows you to intercept and manipulate protocol events (HTTP, Kafka, LDAP, SMTP), schedule jobs, generate mock data, and share state between scripts. | `import {...} from 'mokapi'`          | mokapi               |
+| **HTTP**                       | Exposes functions to invoke HTTP request                                                                                                                                                            | `import {...} from 'mokapi/http'`     | http                 |
+| **Kafka**                      | Exposes functions to produce Kafka message                                                                                                                                                          | `import {...} from 'mokapi/kafka'`    | kafka                |
+| **Faker**                      | Exposes functions to generate random data based on JSON schema                                                                                                                                      | `import {...} from 'mokapi/faker'`    | faker                |
+| **Mustache**                   | Exposes to render output based on mustache template                                                                                                                                                 | `import {...} from 'mokapi/mustache'` | mustache             |
+| **Yaml**                       | Exposes functions to parse or stringify YAML files                                                                                                                                                  | `import {...} from 'mokapi/yaml'`     | yaml                 |
 
 ## Scenarios
 

mcp/run.go

@@ -5,15 +5,11 @@ import (
 	_ "embed"
 	"errors"
 	"fmt"
-	"io"
 	"mokapi/js/compiler"
 	"mokapi/js/faker"
 	"mokapi/providers/openapi"
-	"mokapi/providers/openapi/schema"
 	"mokapi/runtime"
 	"mokapi/schema/json/generator"
-	"net/http"
-	"net/textproto"
 	"reflect"
 	"slices"
 	"strings"
@@ -137,32 +133,38 @@ func (m *mokapi) getApis() []ApiSummary {
 	var result []ApiSummary
 	for _, api := range m.app.ListHttp() {
 		if api.Info.Name == "" {
-			log.Warnf("mcp tool mokapi_get_api_spec: skip empty HTTTP API name")
+			log.Warnf("mcp tool mokapi_execute_code: skip empty HTTTP API name")
 			continue
 		}
 		result = append(result, ApiSummary{
 			Name: api.Info.Name,
 			Type: "http",
 		})
 	}
+	for _, api := range m.app.Kafka.List() {
+		if api.Info.Name == "" {
+			log.Warnf("mcp tool mokapi_execute_code: skip empty Kafka API name")
+			continue
+		}
+		result = append(result, ApiSummary{
+			Name: api.Info.Name,
+			Type: "kafka",
+		})
+	}
 	slices.SortStableFunc(result, func(a, b ApiSummary) int {
 		return strings.Compare(a.Name, b.Name)
 	})
 	return result
 }
 
 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,
-				handler: api.Handler(m.app.Monitor.Http, m.app.Engine, m.app.Events),
-			}
-		}
+	var api any
+	api = m.getHttpApi(name)
+	if api != nil {
+		return api
 	}
-	return nil
+	api = m.getKafkaApi(name)
+	return api
 }
 
 func (m *mokapi) fake(v goja.Value) (any, error) {
@@ -173,279 +175,6 @@ func (m *mokapi) fake(v goja.Value) (any, error) {
 	return generator.New(&generator.Request{Schema: js})
 }
 
-type OpenAPI struct {
-	Name string `json:"name"`
-	Type string `json:"type"`
-
-	info    *runtime.HttpInfo
-	handler openapi.Handler
-}
-
-type OperationSummary struct {
-	Id         string   `json:"id"`
-	Method     string   `json:"method"`
-	Path       string   `json:"path"`
-	Summary    string   `json:"summary"`
-	Parameters []string `json:"parameters"`
-}
-
-type Operation struct {
-	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 {
-	var result []OperationSummary
-	for _, p := range o.info.Paths {
-		if p.Value == nil {
-			continue
-		}
-		for method, op := range p.Value.Operations() {
-			os := OperationSummary{
-				Id:      getOperationId(method, op),
-				Method:  method,
-				Path:    p.Value.Path,
-				Summary: op.Summary,
-			}
-
-			if os.Summary == "" {
-				os.Summary = p.Value.Summary
-			}
-
-			params := append(op.Path.Parameters, op.Parameters...)
-			for _, param := range params {
-				if param.Value == nil {
-					continue
-				}
-				os.Parameters = append(os.Parameters, param.Value.Name)
-			}
-			slices.SortStableFunc(os.Parameters, func(a, b string) int {
-				return strings.Compare(a, b)
-			})
-
-			result = append(result, os)
-		}
-	}
-
-	slices.SortStableFunc(result, func(a, b OperationSummary) int {
-		c := strings.Compare(a.Path, b.Path)
-		if c != 0 {
-			return c
-		}
-		return strings.Compare(a.Method, b.Method)
-	})
-
-	return result
-}
-
-func (o *OpenAPI) GetOperation(id string) (*Operation, error) {
-	for _, p := range o.info.Paths {
-		if p.Value == nil {
-			continue
-		}
-		for method, op := range p.Value.Operations() {
-
-			operationId := getOperationId(method, op)
-			if id != operationId {
-				continue
-			}
-
-			r := &Operation{
-				OperationId: 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,
-				})
-			}
-			slices.SortStableFunc(r.Parameters, func(a, b RequestParameters) int {
-				return strings.Compare(a.Name, b.Name)
-			})
-
-			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, nil
-		}
-	}
-	return nil, fmt.Errorf("operation with ID '%s' not found. Hint: Use getOperations() to see the full list of valid IDs", id)
-}
-
-func (op *Operation) 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 *Operation) 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 {
 }