Implement bcloud CLI with YAML configuration and key-as-ref_id pattern

[devin-ai-integration]

Add comprehensive testing and implement GitHub feedback for CLI credential system

Summary

This PR adds extensive testing to the bcloud CLI configuration system and implements feedback to standardize credential field naming and provider IDs. The changes ensure robust error handling and edge case coverage for credential loading while maintaining backward compatibility patterns.

Key Changes:

• Added comprehensive test suite for LoadConfig() function covering success cases, fallback scenarios, and error conditions
• Added JSON tags to provider credential structs (LambdaLabsCredential, NebiusCredential) with standardized lowercase field names
• Unified Lambda Labs provider ID from "lambda-labs" to "lambdalabs" to match registry key
• Removed provider ID mapping logic and added provider constants to eliminate lint warnings
• Added tests for credential parsing, marshaling/unmarshaling, and provider registry functionality

Review & Testing Checklist for Human

Critical Items (3):

• Test end-to-end with real Lambda Labs credentials - Create a config file with actual API keys and verify bcloud commands work against live Lambda Labs API
• Verify provider ID change doesn't break existing systems - Check if any existing configs or external systems depend on the old "lambda-labs" provider ID
• Test credential file loading from both locations - Verify ~/.bcloud/credentials.yaml and ./bcloud.yaml fallback works correctly with real config files

Important Items (2):

• Validate key-as-ref_id pattern - Test that YAML keys properly become ref_id when not explicitly set, and explicit ref_id overrides work
• Check JSON tag impact on SDK - Ensure the added JSON tags to credential structs don't affect other parts of the SDK that serialize these types

---

Diagram

%%{ init : { "theme" : "default" }}%%
graph TD
    subgraph "CLI System"
        A["cmd/bcloud/config/config.go"]:::major-edit
        B["cmd/bcloud/config/config_test.go"]:::major-edit
        C["cmd/bcloud/commands/create.go"]:::context
    end
    
    subgraph "SDK Provider Structs"
        D["internal/lambdalabs/v1/client.go"]:::minor-edit
        E["internal/nebius/v1/client.go"]:::minor-edit
    end
    
    subgraph "Core SDK"
        F["pkg/v1/client.go CloudCredential interface"]:::context
    end
    
    A --> F
    A --> D
    A --> E
    B --> A
    C --> A
    D --> F
    E --> F
    
    subgraph Legend
        L1["Major Edit"]:::major-edit
        L2["Minor Edit"]:::minor-edit  
        L3["Context/No Edit"]:::context
    end

classDef major-edit fill:#90EE90
classDef minor-edit fill:#87CEEB
classDef context fill:#FFFFFF

Loading

Notes

Testing Coverage Added:

• LoadConfig success/failure scenarios with various file locations and formats
• Credential parsing edge cases (missing provider, invalid provider, unknown provider)
• Key-as-ref_id pattern with both implicit and explicit ref_id values
• JSON/YAML marshaling round-trip testing for credential entries
• Provider registry validation and wrapper type testing

Breaking Changes:

• Lambda Labs provider ID changed from "lambda-labs" to "lambdalabs"
• Added JSON tags to credential structs (should be additive, but worth verifying)

Session Info:

• Requested by: Alec Fong (@theFong)
• Session URL: https://app.devin.ai/sessions/af0c7d05c603474d91d45a15ba8a5a4c

[devin-ai-integration]

🤖 Devin AI Engineer

I'll be helping with this pull request! Here's what you should know:

✅ I will automatically:

• Address comments on this PR. Add '(aside)' to your comment to have me ignore it.
• Look at CI failures and help fix them

Note: I can only respond to comments from users who have write access to this repository.

⚙️ Control Options:

• Disable automatic comment and CI monitoring

[theFong]

I don't like how we are doing factory, config etc can we do something closer to this design?

package creds

import (
	"encoding/json"
	"fmt"
	"gopkg.in/yaml.v3"
)

// ---------- Core interfaces & registry ----------

type ProviderCredential interface {
	GetCloudProviderID() string
}

var providerRegistry = map[string]func() ProviderCredential{}

func RegisterProvider(id string, factory func() ProviderCredential) {
	providerRegistry[id] = factory
}

// ---------- Wrapper type (provider-discriminated union) ----------

type CredentialEntry struct {
	// Persisted "provider" key in files
	Provider string `json:"provider" yaml:"provider"`
	// In-memory typed value; excluded from default serialization
	Value ProviderCredential `json:"-" yaml:"-"`
}

// Common decode from a generic map (used by JSON & YAML)
func (c *CredentialEntry) decodeFromMap(m map[string]any) error {
	rawProv, ok := m["provider"]
	if !ok {
		return fmt.Errorf("missing 'provider'")
	}
	provider, ok := rawProv.(string)
	if !ok || provider == "" {
		return fmt.Errorf("invalid 'provider'")
	}
	factory, ok := providerRegistry[provider]
	if !ok {
		return fmt.Errorf("unknown provider: %s", provider)
	}
	cred := factory()

	// Reuse JSON to map→struct unmarshal; unknown keys are ignored by struct
	b, err := json.Marshal(m)
	if err != nil {
		return err
	}
	if err := json.Unmarshal(b, cred); err != nil {
		return err
	}

	c.Provider = provider
	c.Value = cred
	return nil
}

// Common encode to a generic map (used by JSON & YAML)
func (c CredentialEntry) encodeToMap() (map[string]any, error) {
	if c.Value == nil {
		return nil, fmt.Errorf("nil credential Value")
	}
	b, err := json.Marshal(c.Value) // serialize provider-specific fields
	if err != nil {
		return nil, err
	}
	out := map[string]any{}
	if err := json.Unmarshal(b, &out); err != nil {
		return nil, err
	}
	out["provider"] = c.Value.GetCloudProviderID()
	return out, nil
}

// ---------- JSON round-trip ----------

func (c *CredentialEntry) UnmarshalJSON(b []byte) error {
	m := map[string]any{}
	if err := json.Unmarshal(b, &m); err != nil {
		return err
	}
	return c.decodeFromMap(m)
}

func (c CredentialEntry) MarshalJSON() ([]byte, error) {
	m, err := c.encodeToMap()
	if err != nil {
		return nil, err
	}
	return json.Marshal(m)
}

// ---------- YAML round-trip ----------

func (c *CredentialEntry) UnmarshalYAML(n *yaml.Node) error {
	m := map[string]any{}
	if err := n.Decode(&m); err != nil {
		return err
	}
	return c.decodeFromMap(m)
}

func (c CredentialEntry) MarshalYAML() (interface{}, error) {
	m, err := c.encodeToMap()
	if err != nil {
		return nil, err
	}
	return m, nil // let yaml encode the map
}

// ---------- File container ----------

type CredentialFile struct {
	Credentials map[string]CredentialEntry `json:"credentials" yaml:"credentials"`
}

// ---------- Provider implementations this would be in the respective provider packages ----------

// Lambda Labs
type LambdaLabsCredential struct {
	APIKey          string `json:"api_key"           yaml:"api_key"`
	DefaultLocation string `json:"default_location"  yaml:"default_location"`
}
func (l *LambdaLabsCredential) GetCloudProviderID() string { return "lambdalabs" } // use provider id const

// Nebius
type NebiusCredential struct {
	ServiceAccountJSON string `json:"service_account_json" yaml:"service_account_json"`
	DefaultLocation    string `json:"default_location"     yaml:"default_location"`
	RefID              string `json:"ref_id,omitempty"     yaml:"ref_id,omitempty"`
}
func (n *NebiusCredential) GetCloudProviderID() string { return "nebius" } // use provider id const

// Register at init (or from each provider package's init)
func init() {
	RegisterProvider("lambdalabs", func() ProviderCredential { return &LambdaLabsCredential{} }) // use provider id const
	RegisterProvider("nebius",     func() ProviderCredential { return &NebiusCredential{} }) // use provider id const
}

[theFong]

lets test this method as well

[theFong]

lets write a test that says all registered providers must have a ref_id in struct

[theFong]

we don't need to recreate the credentials here this exactly logic lies in internal/lambda/v1... lets just register them. this file can probably removed and registration can happen in config.go

[theFong]

i think this file can be deleted

[theFong]

these should be the same (provider id and registry key) strings lets refactor

[theFong]

lets go in to the provider credential and use tags to change them to ref_id api_key etc.