refactor(sfcompute): use Brev integration API

go.mod

@@ -20,7 +20,6 @@ require (
 	github.com/nebius/gosdk v0.2.22
 	github.com/pkg/errors v0.9.1
 	github.com/sfcompute/nodes-go v0.1.0-alpha.4
-	github.com/sfcompute/sfc-go v0.1.0-preview.3
 	github.com/stretchr/testify v1.11.1
 	golang.org/x/crypto v0.52.0
 	golang.org/x/text v0.37.0
@@ -84,7 +83,6 @@ require (
 	github.com/sirupsen/logrus v1.9.3 // indirect
 	github.com/spf13/afero v1.15.0 // indirect
 	github.com/spf13/pflag v1.0.10 // indirect
-	github.com/spyzhov/ajson v0.8.0 // indirect
 	github.com/tidwall/gjson v1.18.0 // indirect
 	github.com/tidwall/match v1.1.1 // indirect
 	github.com/tidwall/pretty v1.2.1 // indirect

go.sum

@@ -156,16 +156,12 @@ github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0t
 github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
 github.com/sfcompute/nodes-go v0.1.0-alpha.4 h1:oFBWcMPSpqLYm/NDs5I1jTvzgx9rsXDL9Ghsm30Hc0Q=
 github.com/sfcompute/nodes-go v0.1.0-alpha.4/go.mod h1:nUviHgK+Fgt2hDFcRL3M8VoyiypC8fc0dsY8C30QU8M=
-github.com/sfcompute/sfc-go v0.1.0-preview.3 h1:azKThmbm9ljQ+z8RP4039XwV4bJMTcYKNpKcxrpNf5A=
-github.com/sfcompute/sfc-go v0.1.0-preview.3/go.mod h1:SDgYqB2R6gFM+bzLBeF/Fb+J1HHaTlDuStSkiFuMWDU=
 github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ=
 github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ=
 github.com/spf13/afero v1.15.0 h1:b/YBCLWAJdFWJTN9cLhiXXcD7mzKn9Dm86dNnfyQw1I=
 github.com/spf13/afero v1.15.0/go.mod h1:NC2ByUVxtQs4b3sIUphxK0NioZnmxgyCrfzeuq8lxMg=
 github.com/spf13/pflag v1.0.10 h1:4EBh2KAYBwaONj6b2Ye1GiHfwjqyROoF4RwYO+vPwFk=
 github.com/spf13/pflag v1.0.10/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
-github.com/spyzhov/ajson v0.8.0 h1:sFXyMbi4Y/BKjrsfkUZHSjA2JM1184enheSjjoT/zCc=
-github.com/spyzhov/ajson v0.8.0/go.mod h1:63V+CGM6f1Bu/p4nLIN8885ojBdt88TbLoSFzyqMuVA=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
 github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=

v1/providers/sfcomputev2/api_client.go

@@ -0,0 +1,293 @@
+package v2
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"strings"
+	"time"
+)
+
+const (
+	defaultAPIURL            = "https://api.sfcompute.com"
+	apiBasePath              = "/integrations/brev/v1"
+	maxInstanceIDsPerRequest = 200
+)
+
+type apiClient struct {
+	baseURL    string
+	apiKey     string
+	httpClient *http.Client
+}
+
+type instanceTypeResponse struct {
+	ID                     string `json:"id"`
+	AvailableCount         int64  `json:"available_count"`
+	VCPU                   int32  `json:"vcpu"`
+	MemoryGB               int64  `json:"memory_gb"`
+	DiskGB                 int64  `json:"disk_gb"`
+	GPUCount               int32  `json:"gpu_count"`
+	GPUType                string `json:"gpu_type"`
+	GPUMemoryGB            int64  `json:"gpu_memory_gb"`
+	GPUNetworkDetails      string `json:"gpu_network_details"`
+	Architecture           string `json:"architecture"`
+	PriceDollarsPerHour    string `json:"price_dollars_per_hour"`
+	EstimatedDeploySeconds int64  `json:"estimated_deploy_seconds"`
+}
+
+type listInstanceTypesResponse struct {
+	Data []instanceTypeResponse `json:"data"`
+}
+
+type createInstanceRequest struct {
+	Workspace            string            `json:"workspace"`
+	RefID                string            `json:"ref_id"`
+	CloudCredentialRefID string            `json:"cloud_credential_ref_id"`
+	Name                 *string           `json:"name,omitempty"`
+	InstanceType         string            `json:"instance_type"`
+	SSHPublicKey         string            `json:"ssh_public_key"`
+	Tags                 map[string]string `json:"tags,omitempty"`
+}
+
+type instanceResponse struct {
+	ID                   string              `json:"id"`
+	Name                 string              `json:"name"`
+	RefID                string              `json:"ref_id"`
+	CloudCredentialRefID string              `json:"cloud_credential_ref_id"`
+	InstanceType         string              `json:"instance_type"`
+	DiskGB               int64               `json:"disk_gb"`
+	Status               string              `json:"status"`
+	CreatedAt            int64               `json:"created_at"`
+	Tags                 map[string]string   `json:"tags"`
+	Connection           *instanceConnection `json:"connection"`
+}
+
+type instanceConnection struct {
+	Hostname string `json:"hostname"`
+	Port     int    `json:"port"`
+	Username string `json:"username"`
+}
+
+type listInstancesResponse struct {
+	Cursor  string             `json:"cursor"`
+	HasMore bool               `json:"has_more"`
+	Data    []instanceResponse `json:"data"`
+}
+
+type apiError struct {
+	StatusCode int
+	Type       string
+	Code       string
+	Message    string
+}
+
+type apiErrorResponse struct {
+	Error struct {
+		Type    string `json:"type"`
+		Message string `json:"message"`
+		Details []struct {
+			Code    string `json:"code"`
+			Message string `json:"message"`
+		} `json:"details"`
+	} `json:"error"`
+}
+
+func (e *apiError) Error() string {
+	if e.Code != "" {
+		return fmt.Sprintf("SFC integration API returned %d (%s): %s", e.StatusCode, e.Code, e.Message)
+	}
+	return fmt.Sprintf("SFC integration API returned %d: %s", e.StatusCode, e.Message)
+}
+
+func newAPIClient(apiKey string) *apiClient {
+	return &apiClient{
+		baseURL: strings.TrimRight(defaultAPIURL, "/"),
+		apiKey:  apiKey,
+		httpClient: &http.Client{
+			Timeout: 30 * time.Second,
+		},
+	}
+}
+
+func (c *apiClient) listInstanceTypes(ctx context.Context, workspace string) ([]instanceTypeResponse, error) {
+	var response listInstanceTypesResponse
+	err := c.do(ctx, http.MethodGet, c.workspacePath("/instance_types", workspace), nil, &response)
+	return response.Data, err
+}
+
+func (c *apiClient) createInstance(
+	ctx context.Context,
+	request createInstanceRequest,
+) (*instanceResponse, error) {
+	var response instanceResponse
+	if err := c.do(ctx, http.MethodPost, apiBasePath+"/instances", request, &response); err != nil {
+		return nil, err
+	}
+	return &response, nil
+}
+
+func (c *apiClient) listInstances(
+	ctx context.Context,
+	workspace string,
+	instanceIDs []string,
+) ([]instanceResponse, error) {
+	if len(instanceIDs) == 0 {
+		return c.listInstancesBatch(ctx, workspace, nil)
+	}
+
+	responses := make([]instanceResponse, 0, len(instanceIDs))
+	for start := 0; start < len(instanceIDs); start += maxInstanceIDsPerRequest {
+		end := min(start+maxInstanceIDsPerRequest, len(instanceIDs))
+		batch, err := c.listInstancesBatch(ctx, workspace, instanceIDs[start:end])
+		if err != nil {
+			return nil, err
+		}
+		responses = append(responses, batch...)
+	}
+	return responses, nil
+}
+
+func (c *apiClient) listInstancesBatch(
+	ctx context.Context,
+	workspace string,
+	instanceIDs []string,
+) ([]instanceResponse, error) {
+	query := url.Values{}
+	query.Set("workspace", workspace)
+	query.Set("limit", fmt.Sprint(maxInstanceIDsPerRequest))
+	for _, id := range instanceIDs {
+		query.Add("id", id)
+	}
+
+	var responses []instanceResponse
+	var cursor string
+	for {
+		if cursor != "" {
+			query.Set("starting_after", cursor)
+		}
+
+		var response listInstancesResponse
+		if err := c.do(
+			ctx,
+			http.MethodGet,
+			apiBasePath+"/instances?"+query.Encode(),
+			nil,
+			&response,
+		); err != nil {
+			return nil, err
+		}
+		responses = append(responses, response.Data...)
+		if !response.HasMore {
+			return responses, nil
+		}
+		if response.Cursor == "" || response.Cursor == cursor {
+			return nil, fmt.Errorf("SFC integration API returned an invalid pagination cursor")
+		}
+		cursor = response.Cursor
+	}
+}
+
+func (c *apiClient) getInstance(ctx context.Context, workspace, id string) (*instanceResponse, error) {
+	var response instanceResponse
+	path := apiBasePath + "/instances/" + url.PathEscape(id)
+	if err := c.do(ctx, http.MethodGet, addWorkspace(path, workspace), nil, &response); err != nil {
+		return nil, err
+	}
+	return &response, nil
+}
+
+func (c *apiClient) terminateInstance(ctx context.Context, workspace, id string) (*instanceResponse, error) {
+	var response instanceResponse
+	path := apiBasePath + "/instances/" + url.PathEscape(id) + "/terminate"
+	if err := c.do(ctx, http.MethodPost, addWorkspace(path, workspace), nil, &response); err != nil {
+		return nil, err
+	}
+	return &response, nil
+}
+
+func (c *apiClient) workspacePath(path, workspace string) string {
+	return addWorkspace(apiBasePath+path, workspace)
+}
+
+func addWorkspace(path, workspace string) string {
+	query := url.Values{}
+	query.Set("workspace", workspace)
+	return path + "?" + query.Encode()
+}
+
+func (c *apiClient) do(
+	ctx context.Context,
+	method string,
+	path string,
+	requestValue any,
+	responseValue any,
+) error {
+	var requestBody io.Reader
+	if requestValue != nil {
+		encodedBody, err := json.Marshal(requestValue)
+		if err != nil {
+			return fmt.Errorf("encode SFC integration request: %w", err)
+		}
+		requestBody = bytes.NewReader(encodedBody)
+	}
+
+	httpRequest, err := http.NewRequestWithContext(
+		ctx,
+		method,
+		strings.TrimRight(c.baseURL, "/")+path,
+		requestBody,
+	)
+	if err != nil {
+		return fmt.Errorf("create SFC integration request: %w", err)
+	}
+	httpRequest.Header.Set("Accept", "application/json")
+	httpRequest.Header.Set("Authorization", "Bearer "+c.apiKey)
+	if requestValue != nil {
+		httpRequest.Header.Set("Content-Type", "application/json")
+	}
+
+	httpResponse, err := c.httpClient.Do(httpRequest)
+	if err != nil {
+		return fmt.Errorf("call SFC integration API: %w", err)
+	}
+	defer func() { _ = httpResponse.Body.Close() }()
+
+	if httpResponse.StatusCode < http.StatusOK || httpResponse.StatusCode >= http.StatusMultipleChoices {
+		return decodeAPIError(httpResponse)
+	}
+	if responseValue == nil {
+		_, err = io.Copy(io.Discard, httpResponse.Body)
+		return err
+	}
+	if err := json.NewDecoder(httpResponse.Body).Decode(responseValue); err != nil {
+		return fmt.Errorf("decode SFC integration response: %w", err)
+	}
+	return nil
+}
+
+func decodeAPIError(httpResponse *http.Response) error {
+	var response apiErrorResponse
+	if err := json.NewDecoder(io.LimitReader(httpResponse.Body, 1<<20)).Decode(&response); err != nil {
+		return &apiError{
+			StatusCode: httpResponse.StatusCode,
+			Message:    http.StatusText(httpResponse.StatusCode),
+		}
+	}
+
+	responseError := &apiError{
+		StatusCode: httpResponse.StatusCode,
+		Type:       response.Error.Type,
+		Message:    response.Error.Message,
+	}
+	if len(response.Error.Details) > 0 {
+		responseError.Code = response.Error.Details[0].Code
+		if responseError.Message == "" {
+			responseError.Message = response.Error.Details[0].Message
+		}
+	}
+	return responseError
+}