feat: add sandbox MCP tools

Author: BhautikChudasama

README.md

@@ -151,6 +151,7 @@ port: 8080
 base_url: https://your-domain.com
 authorization_server_url: https://your-auth-server.com
 api_base_url: https://api.createos.nodeops.network
+sandbox_api_base_url: https://your-fc-control-api.example.com
 transport: http       # "http" or "stdio"
 log_level: debug
 

config-files/config.yaml

@@ -2,6 +2,7 @@ port: 8080
 base_url:
 authorization_server_url:
 api_base_url:
+sandbox_api_base_url:
 transport: http
 log_level: debug
 

config/config.go

@@ -12,6 +12,7 @@ type Config struct {
 	BaseURL                string `yaml:"base_url"`
 	AuthorizationServerUrl string `yaml:"authorization_server_url"`
 	APIBaseUrl             string `yaml:"api_base_url"`
+	SandboxAPIBaseUrl      string `yaml:"sandbox_api_base_url"`
 	Transport              string `yaml:"transport"`
 	LogLevel               string `yaml:"log_level"`
 

handlers/CreateSandbox.go

@@ -0,0 +1,27 @@
+package handler
+
+import (
+	"context"
+	"fmt"
+
+	mcputils "github.com/NodeOps-app/createos-mcp/helpers"
+	"github.com/mark3labs/mcp-go/mcp"
+)
+
+type CreateSandboxParams struct {
+	Body map[string]interface{} `json:"body"`
+}
+
+func CreateSandboxHandler(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	authInfo, args, err := handleRequest(ctx, request)
+	if err != nil {
+		return nil, err
+	}
+
+	params, err := mcputils.ParamsParser[CreateSandboxParams](args)
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse parameters: %w", err)
+	}
+
+	return makeSandboxPostRequest("/v1/sandboxes", params.Body, authInfo)
+}

handlers/DeleteSandbox.go

@@ -0,0 +1,27 @@
+package handler
+
+import (
+	"context"
+	"fmt"
+
+	mcputils "github.com/NodeOps-app/createos-mcp/helpers"
+	"github.com/mark3labs/mcp-go/mcp"
+)
+
+type DeleteSandboxParams struct {
+	ID string `json:"id"`
+}
+
+func DeleteSandboxHandler(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	authInfo, args, err := handleRequest(ctx, request)
+	if err != nil {
+		return nil, err
+	}
+
+	params, err := mcputils.ParamsParser[DeleteSandboxParams](args)
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse parameters: %w", err)
+	}
+
+	return makeSandboxDeleteRequest(fmt.Sprintf("/v1/sandboxes/%s", params.ID), authInfo)
+}

handlers/ExecSandbox.go

@@ -0,0 +1,31 @@
+package handler
+
+import (
+	"context"
+	"fmt"
+
+	mcputils "github.com/NodeOps-app/createos-mcp/helpers"
+	"github.com/mark3labs/mcp-go/mcp"
+)
+
+type ExecSandboxParams struct {
+	ID   string                 `json:"id"`
+	Body map[string]interface{} `json:"body"`
+}
+
+func ExecSandboxHandler(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	authInfo, args, err := handleRequest(ctx, request)
+	if err != nil {
+		return nil, err
+	}
+
+	params, err := mcputils.ParamsParser[ExecSandboxParams](args)
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse parameters: %w", err)
+	}
+	if stream, ok := params.Body["stream"].(bool); ok && stream {
+		return nil, fmt.Errorf("streaming exec is not supported by ExecSandbox yet; omit stream or set it to false")
+	}
+
+	return makeSandboxPostRequest(fmt.Sprintf("/v1/sandboxes/%s/exec", params.ID), params.Body, authInfo)
+}

handlers/UpdateSandbox.go

@@ -0,0 +1,28 @@
+package handler
+
+import (
+	"context"
+	"fmt"
+
+	mcputils "github.com/NodeOps-app/createos-mcp/helpers"
+	"github.com/mark3labs/mcp-go/mcp"
+)
+
+type UpdateSandboxParams struct {
+	ID   string                 `json:"id"`
+	Body map[string]interface{} `json:"body"`
+}
+
+func UpdateSandboxHandler(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	authInfo, args, err := handleRequest(ctx, request)
+	if err != nil {
+		return nil, err
+	}
+
+	params, err := mcputils.ParamsParser[UpdateSandboxParams](args)
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse parameters: %w", err)
+	}
+
+	return makeSandboxPatchRequest(fmt.Sprintf("/v1/sandboxes/%s", params.ID), params.Body, authInfo)
+}

handlers/helpers.go

@@ -86,3 +86,42 @@ func makeDeleteRequest(path string, authInfo *AuthInfo) (*mcp.CallToolResult, er
 		},
 	}, nil
 }
+
+func makeSandboxPostRequest(path string, body interface{}, authInfo *AuthInfo) (*mcp.CallToolResult, error) {
+	resp, err := mcputils.SandboxPost(path, body, authInfo.Method, authInfo.Value)
+	if err != nil {
+		return nil, err
+	}
+
+	return &mcp.CallToolResult{
+		Content: []mcp.Content{
+			mcp.NewTextContent(string(resp.Body())),
+		},
+	}, nil
+}
+
+func makeSandboxPatchRequest(path string, body interface{}, authInfo *AuthInfo) (*mcp.CallToolResult, error) {
+	resp, err := mcputils.SandboxPatch(path, body, authInfo.Method, authInfo.Value)
+	if err != nil {
+		return nil, err
+	}
+
+	return &mcp.CallToolResult{
+		Content: []mcp.Content{
+			mcp.NewTextContent(string(resp.Body())),
+		},
+	}, nil
+}
+
+func makeSandboxDeleteRequest(path string, authInfo *AuthInfo) (*mcp.CallToolResult, error) {
+	resp, err := mcputils.SandboxDelete(path, authInfo.Method, authInfo.Value)
+	if err != nil {
+		return nil, err
+	}
+
+	return &mcp.CallToolResult{
+		Content: []mcp.Content{
+			mcp.NewTextContent(string(resp.Body())),
+		},
+	}, nil
+}

helpers/httpclient.go

@@ -11,16 +11,39 @@ import (
 
 // Client returns a configured Resty client with base URL and auth token
 func Client() *resty.Client {
-	baseURL := config.Cfg.APIBaseUrl
-
 	client := resty.New().
-		SetBaseURL(baseURL).
+		SetBaseURL(config.Cfg.APIBaseUrl).
 		SetHeader("Content-Type", "application/json").
 		SetHeader("Accept", "application/json")
 
 	return client
 }
 
+func SandboxClient() (*resty.Client, error) {
+	if config.Cfg.SandboxAPIBaseUrl == "" {
+		return nil, fmt.Errorf("sandbox_api_base_url is required for sandbox tools")
+	}
+
+	client := resty.New().
+		SetBaseURL(config.Cfg.SandboxAPIBaseUrl).
+		SetHeader("Content-Type", "application/json").
+		SetHeader("Accept", "application/json")
+
+	return client, nil
+}
+
+func setAuth(req *resty.Request, authMethod string, authValue string) error {
+	switch authMethod {
+	case "api-key":
+		req.SetHeader("X-Api-Key", authValue)
+	case "bearer-token":
+		req.SetHeader("X-Access-Token", authValue)
+	default:
+		return fmt.Errorf("unsupported auth method: %s", authMethod)
+	}
+	return nil
+}
+
 // Get makes a GET request with authentication
 func Get(path string, queryParams map[string]string, authMethod string, authValue string) (*resty.Response, error) {
 	req := Client().R()
@@ -180,3 +203,69 @@ func DeleteWithBody(path string, body interface{}, authMethod string, authValue
 
 	return resp, nil
 }
+
+// SandboxPost makes a POST request to the sandbox API with authentication.
+func SandboxPost(path string, body interface{}, authMethod string, authValue string) (*resty.Response, error) {
+	client, err := SandboxClient()
+	if err != nil {
+		return nil, err
+	}
+	req := client.R().SetBody(body)
+	if err := setAuth(req, authMethod, authValue); err != nil {
+		return nil, err
+	}
+
+	resp, err := req.Post(path)
+	if err != nil {
+		return nil, fmt.Errorf("sandbox POST request failed: %w", err)
+	}
+	if resp.IsError() {
+		return resp, fmt.Errorf("sandbox API error (status %d)", resp.StatusCode())
+	}
+
+	return resp, nil
+}
+
+// SandboxPatch makes a PATCH request to the sandbox API with authentication.
+func SandboxPatch(path string, body interface{}, authMethod string, authValue string) (*resty.Response, error) {
+	client, err := SandboxClient()
+	if err != nil {
+		return nil, err
+	}
+	req := client.R().SetBody(body)
+	if err := setAuth(req, authMethod, authValue); err != nil {
+		return nil, err
+	}
+
+	resp, err := req.Patch(path)
+	if err != nil {
+		return nil, fmt.Errorf("sandbox PATCH request failed: %w", err)
+	}
+	if resp.IsError() {
+		return resp, fmt.Errorf("sandbox API error (status %d)", resp.StatusCode())
+	}
+
+	return resp, nil
+}
+
+// SandboxDelete makes a DELETE request to the sandbox API with authentication.
+func SandboxDelete(path string, authMethod string, authValue string) (*resty.Response, error) {
+	client, err := SandboxClient()
+	if err != nil {
+		return nil, err
+	}
+	req := client.R()
+	if err := setAuth(req, authMethod, authValue); err != nil {
+		return nil, err
+	}
+
+	resp, err := req.Delete(path)
+	if err != nil {
+		return nil, fmt.Errorf("sandbox DELETE request failed: %w", err)
+	}
+	if resp.IsError() {
+		return resp, fmt.Errorf("sandbox API error (status %d)", resp.StatusCode())
+	}
+
+	return resp, nil
+}