Merge main into refactor/instance-split

Resolved conflicts in:
- pkg/instance/instance.go: Combined remote detection logic from main with refactored structure
- pkg/manager/manager_test.go: Updated manager initialization to include localNodeName parameter
- pkg/manager/remote_ops.go: Removed stripNodesFromOptions function that was deleted in main
- pkg/manager/remote_ops_test.go: Removed file that was deleted in main

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

pkg/manager/manager.go

@@ -49,6 +49,7 @@ type instanceManager struct {
 	ports            map[int]bool
 	instancesConfig  config.InstancesConfig
 	backendsConfig   config.BackendConfig
+	localNodeName    string // Name of the local node
 
 	// Timeout checker
 	timeoutChecker *time.Ticker
@@ -63,7 +64,7 @@ type instanceManager struct {
 }
 
 // NewInstanceManager creates a new instance of InstanceManager.
-func NewInstanceManager(backendsConfig config.BackendConfig, instancesConfig config.InstancesConfig, nodesConfig map[string]config.NodeConfig) InstanceManager {
+func NewInstanceManager(backendsConfig config.BackendConfig, instancesConfig config.InstancesConfig, nodesConfig map[string]config.NodeConfig, localNodeName string) InstanceManager {
 	if instancesConfig.TimeoutCheckInterval <= 0 {
 		instancesConfig.TimeoutCheckInterval = 5 // Default to 5 minutes if not set
 	}
@@ -81,6 +82,7 @@ func NewInstanceManager(backendsConfig config.BackendConfig, instancesConfig con
 		ports:            make(map[int]bool),
 		instancesConfig:  instancesConfig,
 		backendsConfig:   backendsConfig,
+		localNodeName:    localNodeName,
 
 		timeoutChecker: time.NewTicker(time.Duration(instancesConfig.TimeoutCheckInterval) * time.Minute),
 		shutdownChan:   make(chan struct{}),
@@ -274,7 +276,8 @@ func (im *instanceManager) loadInstance(name, path string) error {
 	options := persistedInstance.GetOptions()
 
 	// Check if this is a remote instance
-	isRemote := options != nil && len(options.Nodes) > 0
+	// An instance is remote if Nodes is specified AND the first node is not the local node
+	isRemote := options != nil && len(options.Nodes) > 0 && options.Nodes[0] != im.localNodeName
 
 	var statusCallback func(oldStatus, newStatus instance.Status)
 	if !isRemote {
@@ -285,7 +288,7 @@ func (im *instanceManager) loadInstance(name, path string) error {
 	}
 
 	// Create new inst using NewInstance (handles validation, defaults, setup)
-	inst := instance.NewInstance(name, &im.backendsConfig, &im.instancesConfig, options, statusCallback)
+	inst := instance.NewInstance(name, &im.backendsConfig, &im.instancesConfig, options, im.localNodeName, statusCallback)
 
 	// Restore persisted fields that NewInstance doesn't set
 	inst.Created = persistedInstance.Created

pkg/manager/manager_test.go

@@ -34,7 +34,7 @@ func TestNewInstanceManager(t *testing.T) {
 		TimeoutCheckInterval: 5,
 	}
 
-	mgr := manager.NewInstanceManager(backendConfig, cfg, map[string]config.NodeConfig{})
+	mgr := manager.NewInstanceManager(backendConfig, cfg, map[string]config.NodeConfig{}, "main")
 	if mgr == nil {
 		t.Fatal("NewInstanceManager returned nil")
 	}
@@ -69,7 +69,7 @@ func TestPersistence(t *testing.T) {
 	}
 
 	// Test instance persistence on creation
-	manager1 := manager.NewInstanceManager(backendConfig, cfg, map[string]config.NodeConfig{})
+	manager1 := manager.NewInstanceManager(backendConfig, cfg, map[string]config.NodeConfig{}, "main")
 	options := &instance.Options{
 		BackendType: backends.BackendTypeLlamaCpp,
 		LlamaServerOptions: &llamacpp.LlamaServerOptions{
@@ -90,7 +90,7 @@ func TestPersistence(t *testing.T) {
 	}
 
 	// Test loading instances from disk
-	manager2 := manager.NewInstanceManager(backendConfig, cfg, map[string]config.NodeConfig{})
+	manager2 := manager.NewInstanceManager(backendConfig, cfg, map[string]config.NodeConfig{}, "main")
 	instances, err := manager2.ListInstances()
 	if err != nil {
 		t.Fatalf("ListInstances failed: %v", err)
@@ -207,7 +207,7 @@ func createTestManager() manager.InstanceManager {
 		DefaultRestartDelay:  5,
 		TimeoutCheckInterval: 5,
 	}
-	return manager.NewInstanceManager(backendConfig, cfg, map[string]config.NodeConfig{})
+	return manager.NewInstanceManager(backendConfig, cfg, map[string]config.NodeConfig{}, "main")
 }
 
 func TestAutoRestartDisabledInstanceStatus(t *testing.T) {
@@ -227,7 +227,7 @@ func TestAutoRestartDisabledInstanceStatus(t *testing.T) {
 	}
 
 	// Create first manager and instance with auto-restart disabled
-	manager1 := manager.NewInstanceManager(backendConfig, cfg, map[string]config.NodeConfig{})
+	manager1 := manager.NewInstanceManager(backendConfig, cfg, map[string]config.NodeConfig{}, "main")
 
 	autoRestart := false
 	options := &instance.Options{
@@ -252,7 +252,7 @@ func TestAutoRestartDisabledInstanceStatus(t *testing.T) {
 	manager1.Shutdown()
 
 	// Create second manager (simulating restart of llamactl)
-	manager2 := manager.NewInstanceManager(backendConfig, cfg, map[string]config.NodeConfig{})
+	manager2 := manager.NewInstanceManager(backendConfig, cfg, map[string]config.NodeConfig{}, "main")
 
 	// Get the loaded instance
 	loadedInst, err := manager2.GetInstance("test-instance")

pkg/manager/operations.go

@@ -99,7 +99,8 @@ func (im *instanceManager) CreateInstance(name string, options *instance.Options
 	}
 
 	// Check if this is a remote instance
-	isRemote := len(options.Nodes) > 0
+	// An instance is remote if Nodes is specified AND the first node is not the local node
+	isRemote := len(options.Nodes) > 0 && options.Nodes[0] != im.localNodeName
 	var nodeConfig *config.NodeConfig
 
 	if isRemote {
@@ -119,7 +120,7 @@ func (im *instanceManager) CreateInstance(name string, options *instance.Options
 
 		// Create a local stub that preserves the Nodes field for tracking
 		// We keep the original options (with Nodes) so IsRemote() works correctly
-		inst := instance.NewInstance(name, &im.backendsConfig, &im.instancesConfig, options, nil)
+		inst := instance.NewInstance(name, &im.backendsConfig, &im.instancesConfig, options, im.localNodeName, nil)
 
 		// Update the local stub with all remote data (preserving Nodes)
 		im.updateLocalInstanceFromRemote(inst, remoteInst)
@@ -152,7 +153,7 @@ func (im *instanceManager) CreateInstance(name string, options *instance.Options
 		im.onStatusChange(name, oldStatus, newStatus)
 	}
 
-	inst := instance.NewInstance(name, &im.backendsConfig, &im.instancesConfig, options, statusCallback)
+	inst := instance.NewInstance(name, &im.backendsConfig, &im.instancesConfig, options, im.localNodeName, statusCallback)
 	im.instances[inst.Name] = inst
 
 	if err := im.persistInstance(inst); err != nil {

pkg/manager/operations_test.go

@@ -75,7 +75,7 @@ func TestCreateInstance_ValidationAndLimits(t *testing.T) {
 		MaxInstances:         1, // Very low limit for testing
 		TimeoutCheckInterval: 5,
 	}
-	limitedManager := manager.NewInstanceManager(backendConfig, cfg, map[string]config.NodeConfig{})
+	limitedManager := manager.NewInstanceManager(backendConfig, cfg, map[string]config.NodeConfig{}, "main")
 
 	_, err = limitedManager.CreateInstance("instance1", options)
 	if err != nil {

pkg/manager/remote_ops.go

@@ -10,31 +10,10 @@ import (
 	"net/http"
 )
 
-// stripNodesFromOptions creates a copy of the instance options without the Nodes field
-// to prevent routing loops when sending requests to remote nodes
-func (im *instanceManager) stripNodesFromOptions(options *instance.Options) *instance.Options {
-	if options == nil {
-		return nil
-	}
-
-	// Create a copy of the options struct
-	optionsCopy := *options
-
-	// Clear the Nodes field to prevent the remote node from trying to route further
-	optionsCopy.Nodes = nil
-
-	return &optionsCopy
-}
-
 // makeRemoteRequest is a helper function to make HTTP requests to a remote node
 func (im *instanceManager) makeRemoteRequest(nodeConfig *config.NodeConfig, method, path string, body any) (*http.Response, error) {
 	var reqBody io.Reader
 	if body != nil {
-		// Strip nodes from CreateInstanceOptions to prevent routing loops
-		if options, ok := body.(*instance.Options); ok {
-			body = im.stripNodesFromOptions(options)
-		}
-
 		jsonData, err := json.Marshal(body)
 		if err != nil {
 			return nil, fmt.Errorf("failed to marshal request body: %w", err)

pkg/manager/remote_ops_test.go

@@ -1,39 +0,0 @@
-package manager
-
-import (
-	"llamactl/pkg/backends"
-	"llamactl/pkg/instance"
-	"testing"
-)
-
-func TestStripNodesFromOptions(t *testing.T) {
-	im := &instanceManager{}
-
-	// Test nil case
-	if result := im.stripNodesFromOptions(nil); result != nil {
-		t.Errorf("Expected nil, got %+v", result)
-	}
-
-	// Test main case: nodes should be stripped, other fields preserved
-	options := &instance.Options{
-		BackendType: backends.BackendTypeLlamaCpp,
-		Nodes:       []string{"node1", "node2"},
-		Environment: map[string]string{"TEST": "value"},
-	}
-
-	result := im.stripNodesFromOptions(options)
-
-	if result.Nodes != nil {
-		t.Errorf("Expected Nodes to be nil, got %+v", result.Nodes)
-	}
-	if result.BackendType != backends.BackendTypeLlamaCpp {
-		t.Errorf("Expected BackendType preserved")
-	}
-	if result.Environment["TEST"] != "value" {
-		t.Errorf("Expected Environment preserved")
-	}
-	// Original should not be modified
-	if len(options.Nodes) != 2 {
-		t.Errorf("Original options should not be modified")
-	}
-}

pkg/manager/timeout_test.go

@@ -23,7 +23,7 @@ func TestTimeoutFunctionality(t *testing.T) {
 		MaxInstances:         5,
 	}
 
-	manager := manager.NewInstanceManager(backendConfig, cfg, map[string]config.NodeConfig{})
+	manager := manager.NewInstanceManager(backendConfig, cfg, map[string]config.NodeConfig{}, "main")
 	if manager == nil {
 		t.Fatal("Manager should be initialized with timeout checker")
 	}