Support resizing services

CLAUDE.md

@@ -267,7 +267,7 @@ Tiger CLI is a Go-based command-line interface for managing Tiger, the modern da
 - **Command Structure**: `internal/tiger/cmd/` - Cobra-based command definitions
   - `root.go` - Root command with global flags and configuration initialization
   - `auth.go` - Authentication commands (login, logout, status)
-  - `service.go` - Service management commands (list, create, get, fork, start, stop, delete, update-password)
+  - `service.go` - Service management commands (list, create, get, fork, start, stop, resize, delete, update-password)
   - `db.go` - Database operation commands (connection-string, connect, test-connection)
   - `config.go` - Configuration management commands (show, set, unset, reset)
   - `mcp.go` - MCP server commands (install, start, list)
@@ -277,7 +277,7 @@ Tiger CLI is a Go-based command-line interface for managing Tiger, the modern da
 - **API Client**: `internal/tiger/api/` - Generated OpenAPI client with mocks
 - **MCP Server**: `internal/tiger/mcp/` - Model Context Protocol server implementation
   - `server.go` - MCP server initialization, tool registration, and lifecycle management
-  - `service_tools.go` - Service management tools (list, get, create, fork, start, stop, update-password)
+  - `service_tools.go` - Service management tools (list, get, create, fork, start, stop, resize, update-password)
   - `db_tools.go` - Database operation tools (execute-query)
   - `proxy.go` - Proxy client that forwards tools/resources/prompts from remote docs MCP server
   - `capabilities.go` - Lists all available MCP capabilities (tools, prompts, resources, resource templates)

README.md

@@ -96,6 +96,7 @@ Tiger CLI provides the following commands:
   - `fork` - Fork an existing service
   - `start` - Start a stopped service
   - `stop` - Stop a running service
+  - `resize` - Resize service CPU and memory allocation
   - `delete` - Delete a service
   - `update-password` - Update service master password
 - `tiger db` - Database operations
@@ -178,6 +179,7 @@ The MCP server exposes the following tools to AI assistants:
 - `service_fork` - Fork an existing database service to create an independent copy
 - `service_start` - Start a stopped database service
 - `service_stop` - Stop a running database service
+- `service_resize` - Resize a database service by changing CPU and memory allocation
 - `service_update_password` - Update the master password for a service
 
 **Database Operations:**

internal/tiger/cmd/db.go

@@ -6,6 +6,7 @@ import (
 	"encoding/base64"
 	"errors"
 	"fmt"
+	"net/http"
 	"os"
 	"os/exec"
 	"strings"
@@ -787,7 +788,7 @@ func getServiceDetails(cmd *cobra.Command, cfg *common.Config, args []string) (a
 	}
 
 	// Handle API response
-	if resp.StatusCode() != 200 {
+	if resp.StatusCode() != http.StatusOK {
 		return api.Service{}, common.ExitWithErrorFromStatusCode(resp.StatusCode(), resp.JSON4XX)
 	}
 

internal/tiger/cmd/integration_test.go

@@ -1016,6 +1016,146 @@ func TestServiceLifecycleIntegration(t *testing.T) {
 		}
 	})
 
+	t.Run("ResizeService", func(t *testing.T) {
+		if serviceID == "" {
+			t.Skip("No service ID available from create test")
+		}
+
+		t.Logf("Resizing service: %s", serviceID)
+
+		// First, get current service details to see current CPU/memory
+		output, err := executeIntegrationCommand(
+			t.Context(),
+			"service", "describe", serviceID,
+			"--output", "json",
+		)
+
+		if err != nil {
+			t.Fatalf("Failed to describe service before resize: %v\nOutput: %s", err, output)
+		}
+
+		// Parse JSON to check current resources
+		var serviceBefore api.Service
+		if err := json.Unmarshal([]byte(output), &serviceBefore); err != nil {
+			t.Fatalf("Failed to parse service JSON: %v", err)
+		}
+
+		var currentCPU, currentMemory string
+		if serviceBefore.Resources != nil && len(*serviceBefore.Resources) > 0 {
+			resource := (*serviceBefore.Resources)[0]
+			if resource.Spec != nil {
+				if resource.Spec.CpuMillis != nil {
+					cpuCores := float64(*resource.Spec.CpuMillis) / 1000
+					currentCPU = fmt.Sprintf("%.1f CPU", cpuCores)
+				}
+				if resource.Spec.MemoryGbs != nil {
+					currentMemory = fmt.Sprintf("%d GB", *resource.Spec.MemoryGbs)
+				}
+			}
+		}
+
+		t.Logf("Current resources: CPU=%s, Memory=%s", currentCPU, currentMemory)
+
+		// Resize to 1 CPU / 4 GB (larger than default 0.5 CPU / 2 GB)
+		// Note: --cpu expects millicores (1000 = 1 CPU), --memory expects GB as integer
+		targetCPUMillis := "1000" // 1 CPU = 1000 millicores
+		targetMemoryGB := "4"     // 4 GB
+
+		t.Logf("Resizing to: CPU=%s millicores (1 CPU), Memory=%s GB", targetCPUMillis, targetMemoryGB)
+
+		output, err = executeIntegrationCommand(
+			t.Context(),
+			"service", "resize", serviceID,
+			"--cpu", targetCPUMillis,
+			"--memory", targetMemoryGB,
+			"--wait-timeout", "10m", // Longer timeout for resize operations
+		)
+
+		if err != nil {
+			t.Fatalf("Service resize failed: %v\nOutput: %s", err, output)
+		}
+
+		// Verify resize success message
+		if !strings.Contains(output, "Resize completed successfully") &&
+			!strings.Contains(output, "resized successfully") {
+			t.Logf("Note: Expected resize success message, got: %s", output)
+		}
+
+		t.Logf("Service resize command completed successfully")
+	})
+
+	t.Run("VerifyServiceResized", func(t *testing.T) {
+		if serviceID == "" {
+			t.Skip("No service ID available from create test")
+		}
+
+		t.Logf("Verifying service has been resized")
+
+		output, err := executeIntegrationCommand(
+			t.Context(),
+			"service", "describe", serviceID,
+			"--output", "json",
+		)
+
+		if err != nil {
+			t.Fatalf("Failed to describe service after resize: %v\nOutput: %s", err, output)
+		}
+
+		// Parse JSON to check new resources
+		var serviceAfter api.Service
+		if err := json.Unmarshal([]byte(output), &serviceAfter); err != nil {
+			t.Fatalf("Failed to parse service JSON: %v", err)
+		}
+
+		var newCPUMillis, newMemoryGbs int
+		if serviceAfter.Resources != nil && len(*serviceAfter.Resources) > 0 {
+			resource := (*serviceAfter.Resources)[0]
+			if resource.Spec != nil {
+				if resource.Spec.CpuMillis != nil {
+					newCPUMillis = *resource.Spec.CpuMillis
+				}
+				if resource.Spec.MemoryGbs != nil {
+					newMemoryGbs = *resource.Spec.MemoryGbs
+				}
+			}
+		}
+
+		newCPU := fmt.Sprintf("%.1f CPU", float64(newCPUMillis)/1000)
+		newMemory := fmt.Sprintf("%d GB", newMemoryGbs)
+
+		t.Logf("New resources after resize: CPU=%s (millis=%d), Memory=%s", newCPU, newCPUMillis, newMemory)
+
+		// Verify the service has been resized to expected values
+		expectedCPUMillis := 1000 // 1 CPU = 1000 millicores
+		expectedMemoryGbs := 4    // 4 GB
+
+		if newCPUMillis != expectedCPUMillis {
+			t.Errorf("Expected CPU to be %d millicores after resize, got %d", expectedCPUMillis, newCPUMillis)
+		} else {
+			t.Logf("✅ CPU correctly resized to %d millicores (1 CPU)", newCPUMillis)
+		}
+
+		if newMemoryGbs != expectedMemoryGbs {
+			t.Errorf("Expected Memory to be %d GB after resize, got %d", expectedMemoryGbs, newMemoryGbs)
+		} else {
+			t.Logf("✅ Memory correctly resized to %d GB", newMemoryGbs)
+		}
+
+		// Verify service is still in READY state after resize
+		var status string
+		if serviceAfter.Status != nil {
+			status = string(*serviceAfter.Status)
+		}
+
+		if status != "READY" {
+			t.Logf("Warning: Expected service status to be READY after resize, got %s", status)
+		} else {
+			t.Logf("✅ Service is correctly in READY state after resize")
+		}
+
+		t.Logf("✅ Service resize verified successfully")
+	})
+
 	t.Run("DeleteService", func(t *testing.T) {
 		if serviceID == "" {
 			t.Skip("No service ID available for deletion")
@@ -1572,6 +1712,11 @@ func TestServiceForkIntegration(t *testing.T) {
 			t.Fatalf("Login failed: %v\nOutput: %s", err, output)
 		}
 
+		// Verify login success message
+		if !strings.Contains(output, "Successfully logged in") && !strings.Contains(output, "Logged in") {
+			t.Errorf("Login output: %s", output)
+		}
+
 		t.Logf("Login successful")
 	})