Add inline auto-update prompt after version notification

cmd/entire/cli/integration_test/interactive.go

@@ -26,7 +26,8 @@ func (env *TestEnv) RunCommandInteractive(args []string, respond func(ptyFile *o
 	cmd.Env = append(testutil.GitIsolatedEnv(),
 		"ENTIRE_TEST_CLAUDE_PROJECT_DIR="+env.ClaudeProjectDir,
 		"TERM=xterm",
-		"ACCESSIBLE=1", // Required: makes huh read from stdin instead of /dev/tty
+		"ACCESSIBLE=1",      // Required: makes huh read from stdin instead of /dev/tty
+		"ENTIRE_TEST_TTY=1", // Force CanPromptInteractively()=true: the subprocess has a real pty but may inherit CI=true from the runner, which would otherwise short-circuit the interactive gate.
 	)
 
 	// Start command with a pty

cmd/entire/cli/interactive/interactive.go

@@ -25,7 +25,7 @@ import (
 //     actual environment, so tests that need a specific answer should set
 //     ENTIRE_TEST_TTY explicitly rather than assume a non-interactive host.
 func CanPromptInteractively() bool {
-	if v, ok := os.LookupEnv("ENTIRE_TEST_TTY"); ok {
+	if v := os.Getenv("ENTIRE_TEST_TTY"); v != "" {
 		return v == "1"
 	}
 
@@ -43,6 +43,15 @@ func CanPromptInteractively() bool {
 		return false
 	}
 
+	// CI=<non-empty> is the de-facto CI-provider convention (GitHub Actions,
+	// CircleCI, GitLab, Travis, Buildkite). Self-hosted runners expose /dev/tty,
+	// so the probe below isn't enough — an interactive prompt on CI hangs.
+	// CI=false is the `is-ci` escape hatch for developers who need to override
+	// an inherited value.
+	if v := os.Getenv("CI"); v != "" && v != "false" {
+		return false
+	}
+
 	tty, err := os.OpenFile("/dev/tty", os.O_RDWR, 0)
 	if err != nil {
 		return false

cmd/entire/cli/interactive/interactive_test.go

@@ -44,6 +44,26 @@ func TestCanPromptInteractively_AgentEnvGuards(t *testing.T) {
 	}
 }
 
+func TestCanPromptInteractively_CIEnv(t *testing.T) {
+	t.Setenv("ENTIRE_TEST_TTY", "")
+	_ = os.Unsetenv("ENTIRE_TEST_TTY")
+	t.Setenv("CI", "true")
+	if CanPromptInteractively() {
+		t.Error("CanPromptInteractively() = true; want false when CI=true")
+	}
+}
+
+// CI=false is the `is-ci` escape hatch: a dev may set it to override an
+// inherited CI=true. Verify the CI branch doesn't short-circuit to false,
+// using ENTIRE_TEST_TTY=1 to stand in for a real TTY in the test host.
+func TestCanPromptInteractively_CIFalseOverride(t *testing.T) {
+	t.Setenv("CI", "false")
+	t.Setenv("ENTIRE_TEST_TTY", "1")
+	if !CanPromptInteractively() {
+		t.Error("CanPromptInteractively() = false; want true when CI=false")
+	}
+}
+
 func TestIsTerminalWriter_NonFile(t *testing.T) {
 	t.Parallel()
 	if IsTerminalWriter(&bytes.Buffer{}) {

cmd/entire/cli/setup_github.go

@@ -309,7 +309,7 @@ func ghFlagsProvided(opts GitHubBootstrapOptions) bool {
 
 // confirmCreateGitHubRepo asks the user whether they want to also create
 // a matching GitHub repository. Interactive-only; callers gate on
-// CanPromptInteractively.
+// interactive.CanPromptInteractively.
 func confirmCreateGitHubRepo() (bool, error) {
 	confirmed := true
 	form := NewAccessibleForm(

cmd/entire/cli/versioncheck/autoupdate.go

@@ -0,0 +1,112 @@
+package versioncheck
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"runtime"
+
+	"github.com/charmbracelet/huh"
+
+	"github.com/entireio/cli/cmd/entire/cli/interactive"
+	"github.com/entireio/cli/cmd/entire/cli/logging"
+)
+
+// envKillSwitch disables the interactive update prompt regardless of TTY.
+const envKillSwitch = "ENTIRE_NO_AUTO_UPDATE"
+
+// Test seams.
+var (
+	runInstaller  = realRunInstaller
+	confirmUpdate = realConfirmUpdate
+	isTerminalOut = interactive.IsTerminalWriter
+)
+
+// MaybeAutoUpdate offers an interactive upgrade after the standard
+// "version available" notification has been printed. Silent on every
+// failure path — it must never interrupt the CLI.
+//
+// If the installer command fails, a hint with the exact command is
+// printed so the user can retry manually. The 24h version-check cache
+// is not invalidated on failure: we don't want to re-prompt on every
+// invocation while an upstream issue (network, auth, repo outage) is
+// still in place.
+//
+// When the prompt cannot be shown (kill switch set, or non-interactive
+// environment like CI / agent subprocess / no TTY) the installer
+// command is printed so the user still learns what to run manually.
+func MaybeAutoUpdate(ctx context.Context, w io.Writer, currentVersion string) {
+	// Windows + unknown install manager: the POSIX curl-pipe-bash fallback
+	// would error if auto-run, and there's no safe native equivalent. Point
+	// the user at the releases page so they can download manually.
+	if !canAutoInstall() {
+		fmt.Fprintf(w, "To update, download the latest release from:\n  %s\n", downloadsURL)
+		return
+	}
+	if os.Getenv(envKillSwitch) != "" || !interactive.CanPromptInteractively() || !isTerminalOut(w) {
+		fmt.Fprintf(w, "To update, run:\n  %s\n", updateCommand(currentVersion))
+		return
+	}
+
+	confirmed, err := confirmUpdate()
+	if err != nil {
+		logging.Debug(ctx, "auto-update: prompt failed", "error", err.Error())
+		return
+	}
+	if !confirmed {
+		return
+	}
+
+	cmdStr := updateCommand(currentVersion)
+	fmt.Fprintf(w, "\nUpdating Entire CLI: %s\n", cmdStr)
+	if err := runInstaller(ctx, cmdStr); err != nil {
+		fmt.Fprintf(w, "Update failed: %v\nTry again later running:\n  %s\n", err, cmdStr)
+		return
+	}
+	fmt.Fprintln(w, "Update complete. Re-run entire to use the new version.")
+}
+
+func realConfirmUpdate() (bool, error) {
+	// Pre-select "Yes" so pressing Enter accepts — matches the (Y/n) UX.
+	confirmed := true
+	form := huh.NewForm(
+		huh.NewGroup(
+			huh.NewConfirm().
+				Title("Install the new version now?").
+				Affirmative("Yes").
+				Negative("No").
+				Value(&confirmed),
+		),
+	).WithTheme(huh.ThemeDracula())
+	if os.Getenv("ACCESSIBLE") != "" {
+		form = form.WithAccessible(true)
+	}
+	if err := form.Run(); err != nil {
+		if errors.Is(err, huh.ErrUserAborted) || errors.Is(err, huh.ErrTimeout) {
+			return false, nil
+		}
+		return false, fmt.Errorf("confirm form: %w", err)
+	}
+	return confirmed, nil
+}
+
+// realRunInstaller shells out to the installer command, streaming stdin/stdout/stderr
+// so password prompts and progress output reach the user.
+func realRunInstaller(ctx context.Context, cmdStr string) error {
+	var c *exec.Cmd
+	if runtime.GOOS == goosWindows {
+		c = exec.CommandContext(ctx, "cmd", "/C", cmdStr)
+	} else {
+		c = exec.CommandContext(ctx, "sh", "-c", cmdStr)
+	}
+	c.Stdin = os.Stdin
+	c.Stdout = os.Stdout
+	c.Stderr = os.Stderr
+	if err := c.Run(); err != nil {
+		return fmt.Errorf("installer exited: %w", err)
+	}
+	return nil
+}