feat(tui): add instance actions in detail view, drop auto-SSH on deploy

- TUI detail view now supports start, stop, force stop, restart, force
  restart, and rename (inline text input) without leaving the TUI
- Removed post-deploy "Connect now?" prompt — deploy just prints the
  success card and returns
- SSH command shows "OS is still being installed" message when connection
  fails within 10 minutes of instance creation instead of falling through
  to sshpass auth errors

Author: hassan-bazzi

cmd/instances/deploy.go

@@ -4,7 +4,6 @@ import (
 	"encoding/json"
 	"fmt"
 	"os"
-	"os/exec"
 	"strings"
 	"time"
 
@@ -207,7 +206,6 @@ func runDeploy(cmd *cobra.Command, args []string) error {
 		return printJSONResult(instance, selectedRegion, selectedPlan)
 	}
 	displayDeployResult(instance, selectedRegion, selectedPlan)
-	promptSSHConnect(hostname)
 	return nil
 }
 
@@ -536,30 +534,6 @@ SSH:            ssh %s@%s`,
 	fmt.Println("\n" + cardStyle.Render(cardContent) + "\n")
 }
 
-func promptSSHConnect(hostname string) {
-	connectNow := true
-	err := huh.NewConfirm().
-		Title("Connect now?").
-		Value(&connectNow).
-		Run()
-	if err != nil {
-		return
-	}
-	if connectNow {
-		// Re-exec as subprocess so os.Exit in RunSSH doesn't bypass our deferred cleanup
-		binary, err := os.Executable()
-		if err != nil {
-			fmt.Fprintf(os.Stderr, "Error: %v\n", err)
-			return
-		}
-		cmd := exec.Command(binary, "ssh", hostname)
-		cmd.Stdin = os.Stdin
-		cmd.Stdout = os.Stdout
-		cmd.Stderr = os.Stderr
-		cmd.Run()
-	}
-}
-
 // --- Search helpers ---
 
 func findTemplate(templates []api.Template, name string) (*api.Template, error) {

cmd/instances/list.go

@@ -2,11 +2,14 @@ package instances
 
 import (
 	"fmt"
+	"time"
 
 	tea "github.com/charmbracelet/bubbletea"
 	"github.com/hostodo/hostodo-cli/pkg/api"
 	"github.com/hostodo/hostodo-cli/pkg/auth"
 	"github.com/hostodo/hostodo-cli/pkg/config"
+	"github.com/hostodo/hostodo-cli/pkg/deploy"
+	"github.com/hostodo/hostodo-cli/pkg/resolver"
 	"github.com/hostodo/hostodo-cli/pkg/ui"
 	"github.com/spf13/cobra"
 )
@@ -84,21 +87,18 @@ func runList(cmd *cobra.Command, args []string) {
 
 	// Display based on output format
 	if instanceListJSON {
-		// JSON output
 		output, err := ui.FormatInstancesJSON(instancesResp.Results)
 		if err != nil {
 			exitWithError("Failed to format JSON: %v", err)
 		}
 		fmt.Println(output)
 	} else if instanceListSimple {
-		// Simple table output
-		fmt.Println() // Add spacing
+		fmt.Println()
 		output := ui.FormatInstancesSimpleTable(instancesResp.Results)
 		fmt.Println(output)
 		fmt.Printf("\nTotal: %d instances\n", instancesResp.Count)
 	} else if instanceListDetails {
-		// Detailed output
-		fmt.Println() // Add spacing
+		fmt.Println()
 		output := ui.FormatInstancesDetailedTable(instancesResp.Results)
 		fmt.Println(output)
 		fmt.Printf("\nTotal: %d instances\n", instancesResp.Count)
@@ -109,9 +109,115 @@ func runList(cmd *cobra.Command, args []string) {
 		if err != nil {
 			exitWithError("Failed to run interactive table: %v", err)
 		}
-		// Check if user requested SSH from detail view
-		if tm, ok := finalModel.(ui.TableModel); ok && tm.SSHHostname != "" {
+		tm, ok := finalModel.(ui.TableModel)
+		if !ok {
+			return
+		}
+		// Handle actions requested from within the TUI
+		if tm.SSHHostname != "" {
 			RunSSH(SSHCmd, []string{tm.SSHHostname})
+			return
+		}
+		if tm.APIAction != "" && tm.ActionInstance != nil {
+			runTUIAction(client, tm)
+		}
+	}
+}
+
+// runTUIAction executes an instance action that was triggered from the TUI detail view.
+func runTUIAction(client *api.Client, tm ui.TableModel) {
+	instance := tm.ActionInstance
+	fmt.Println()
+
+	switch tm.APIAction {
+	case "start":
+		fmt.Printf("Starting instance %s (%s)...\n", instance.Hostname, instance.MainIP)
+		if err := client.StartInstance(instance.InstanceID); err != nil {
+			exitWithError("Failed to start instance: %v", err)
+		}
+		fmt.Println("✓ Start command sent")
+		fmt.Print("\nWaiting for instance to start")
+		pollPower(client, instance.InstanceID, "running", 30)
+
+	case "stop":
+		fmt.Printf("Stopping instance %s (%s)...\n", instance.Hostname, instance.MainIP)
+		if err := client.StopInstance(instance.InstanceID, false); err != nil {
+			exitWithError("Failed to stop instance: %v", err)
+		}
+		fmt.Println("✓ Stop command sent")
+		fmt.Print("\nWaiting for instance to stop")
+		pollPower(client, instance.InstanceID, "stopped", 30)
+
+	case "force-stop":
+		fmt.Printf("Force stopping instance %s (%s)...\n", instance.Hostname, instance.MainIP)
+		if err := client.StopInstance(instance.InstanceID, true); err != nil {
+			exitWithError("Failed to force stop instance: %v", err)
+		}
+		fmt.Println("✓ Force stop command sent")
+
+	case "restart":
+		fmt.Printf("Restarting instance %s (%s)...\n", instance.Hostname, instance.MainIP)
+		if err := client.RebootInstance(instance.InstanceID, false); err != nil {
+			exitWithError("Failed to restart instance: %v", err)
+		}
+		fmt.Println("✓ Restart command sent")
+		fmt.Print("\nWaiting for instance to restart")
+		pollRestart(client, instance.InstanceID, 60)
+
+	case "force-restart":
+		fmt.Printf("Force restarting instance %s (%s)...\n", instance.Hostname, instance.MainIP)
+		if err := client.RebootInstance(instance.InstanceID, true); err != nil {
+			exitWithError("Failed to force restart instance: %v", err)
+		}
+		fmt.Println("✓ Force restart command sent")
+
+	case "rename":
+		newHostname := tm.RenameTarget
+		if err := deploy.Validate(newHostname); err != nil {
+			exitWithError("Invalid hostname %q: %v", newHostname, err)
+		}
+		fmt.Printf("Renaming instance %s to %s...\n", instance.Hostname, newHostname)
+		if err := client.RenameInstance(instance.InstanceID, newHostname); err != nil {
+			exitWithError("Failed to rename instance: %v", err)
+		}
+		resolver.InvalidateCache()
+		fmt.Printf("✓ Instance renamed to %s\n", newHostname)
+	}
+}
+
+// pollPower polls until the instance reaches targetStatus or timeout.
+func pollPower(client *api.Client, instanceID, targetStatus string, seconds int) {
+	for i := 0; i < seconds; i++ {
+		fmt.Print(".")
+		time.Sleep(1 * time.Second)
+		status, err := client.GetInstancePowerStatus(instanceID)
+		if err == nil && status == targetStatus {
+			fmt.Println()
+			fmt.Printf("✓ Instance is now %s\n", targetStatus)
+			return
+		}
+	}
+	fmt.Println()
+	fmt.Println("⚠ Operation in progress (this may take a few moments)")
+}
+
+// pollRestart polls for running state after a reboot, allowing for a stop transition.
+func pollRestart(client *api.Client, instanceID string, seconds int) {
+	sawStopped := false
+	for i := 0; i < seconds; i++ {
+		fmt.Print(".")
+		time.Sleep(1 * time.Second)
+		status, err := client.GetInstancePowerStatus(instanceID)
+		if err == nil {
+			if status == "stopped" {
+				sawStopped = true
+			} else if status == "running" && (sawStopped || i >= 5) {
+				fmt.Println()
+				fmt.Println("✓ Instance has restarted and is now running")
+				return
+			}
 		}
 	}
+	fmt.Println()
+	fmt.Println("⚠ Instance is restarting (this may take a few moments)")
 }

cmd/instances/ssh.go

@@ -5,6 +5,7 @@ import (
 	"os"
 	"os/exec"
 	"runtime"
+	"time"
 
 	"github.com/hostodo/hostodo-cli/pkg/api"
 	"github.com/hostodo/hostodo-cli/pkg/auth"
@@ -137,6 +138,11 @@ func RunSSH(cmd *cobra.Command, args []string) {
 	// Only retry with sshpass on SSH connection/auth failure (exit code 255).
 	// Other non-zero codes (1-254) are the remote command's exit status from
 	// a session that connected successfully — don't retry those.
+	if exitCode == 255 && isRecentlyCreated(instance, 10*time.Minute) {
+		fmt.Fprintf(os.Stderr, "\nOS is still being installed — hang tight! Try again in a minute or two.\n")
+		os.Exit(exitCode)
+	}
+
 	if exitCode == 255 && instance.DefaultPassword != "" {
 		sshpassBinary, err := exec.LookPath("sshpass")
 		if err != nil {
@@ -197,6 +203,19 @@ func buildSSHArgs(target string, hasPasswordFallback bool, extraArgs []string) [
 	return args
 }
 
+// isRecentlyCreated returns true if the instance was created within the given window.
+// The API serializes DateTimeField as ISO 8601 with microseconds and UTC Z suffix.
+func isRecentlyCreated(instance *api.Instance, window time.Duration) bool {
+	if instance.CreatedAt == "" {
+		return false
+	}
+	t, err := time.Parse("2006-01-02T15:04:05.999999Z", instance.CreatedAt)
+	if err != nil {
+		return false
+	}
+	return time.Since(t) < window
+}
+
 func runSSHCommand(binary string, args []string) int {
 	cmd := exec.Command(binary, args...)
 	cmd.Stdin = os.Stdin