fix(hot reload context)

Author: jr-k

internal/ui/app_context.go

@@ -78,6 +78,18 @@ func (a *App) SetDefaultContext(contextName string) {
 		return
 	}
 
+	a.ReloadContext(contextName)
+}
+
+// ReloadContext rebuilds the Docker client for contextName, even when it
+// is already the active context. Used after editing a context (endpoint
+// or credentials change) so changes apply without restarting d4s.
+func (a *App) ReloadContext(contextName string) {
+	contextName = strings.TrimSpace(contextName)
+	if contextName == "" {
+		return
+	}
+
 	a.SetFlashPending(fmt.Sprintf("switching context to %s...", contextName))
 	a.SetPaused(true)
 	a.StopAutoRefresh()
@@ -94,6 +106,9 @@ func (a *App) SetDefaultContext(contextName string) {
 	a.ActiveFilter = ""
 	for _, v := range a.Views {
 		v.SetLoading(true)
+		// Free the fetch guard held by any fetch still running against the
+		// old endpoint (possibly hung), and mark its results as stale.
+		v.InvalidateFetch()
 	}
 	a.RestoreFocus()
 	a.UpdateShortcuts()

internal/ui/app_view.go

@@ -132,10 +132,11 @@ func (a *App) RefreshCurrentView() {
 
 		// Skip this tick if the previous fetch is still in flight
 		// (slow SSH transport): avoids piling up redundant API calls.
-		if !v.TryAcquireFetch() {
+		gen, acquired := v.TryAcquireFetch()
+		if !acquired {
 			return
 		}
-		defer v.ReleaseFetch()
+		defer v.ReleaseFetch(gen)
 
 		var err error
 		var data []dao.Resource
@@ -161,6 +162,11 @@ func (a *App) RefreshCurrentView() {
 		}
 
 		a.SafeQueueUpdateDraw(func() {
+			// Drop stale results if the context was reloaded mid-fetch
+			if v.FetchGen() != gen {
+				return
+			}
+
 			// Check if page changed while fetching?
 			currentPage, _ := a.Pages.GetFrontPage()
 			if currentPage != page {

internal/ui/common/common.go

@@ -77,6 +77,7 @@ type AppController interface {
 
 	// Context Management
 	SetDefaultContext(contextName string)
+	ReloadContext(contextName string)
 
 	// Port-Forward Management
 	GetPortForwardManager() *portforward.Manager

internal/ui/components/view/view.go

@@ -18,11 +18,34 @@ import (
 // TryAcquireFetch reports whether a new background fetch may start.
 // It returns false while another fetch for this view is still running,
 // preventing refresh ticks from piling up on slow (SSH) transports.
-func (v *ResourceView) TryAcquireFetch() bool {
-	return v.fetchInFlight.CompareAndSwap(false, true)
+// The returned generation must be passed back to ReleaseFetch.
+func (v *ResourceView) TryAcquireFetch() (int64, bool) {
+	if !v.fetchInFlight.CompareAndSwap(false, true) {
+		return 0, false
+	}
+	return v.fetchGen.Load(), true
+}
+
+// ReleaseFetch clears the in-flight guard, unless the fetch was
+// invalidated (context reload) while it was running: in that case the
+// guard now belongs to the new context's fetches.
+func (v *ResourceView) ReleaseFetch(gen int64) {
+	if v.fetchGen.Load() == gen {
+		v.fetchInFlight.Store(false)
+	}
+}
+
+// FetchGen returns the current fetch generation. A fetch whose acquired
+// generation no longer matches must discard its results (stale context).
+func (v *ResourceView) FetchGen() int64 {
+	return v.fetchGen.Load()
 }
 
-func (v *ResourceView) ReleaseFetch() {
+// InvalidateFetch cancels any in-flight fetch: its results will be
+// dropped and the guard is freed so the new context can fetch
+// immediately instead of waiting for the old (possibly hung) transport.
+func (v *ResourceView) InvalidateFetch() {
+	v.fetchGen.Add(1)
 	v.fetchInFlight.Store(false)
 }
 
@@ -47,6 +70,7 @@ type ResourceView struct {
 
 	// Guard against overlapping background fetches (slow SSH transports)
 	fetchInFlight atomic.Bool
+	fetchGen      atomic.Int64
 
 	// Pinned sort: always applied first (unless user sorts on this column)
 	PinnedSortColumn string // Column name (e.g. "ANON"), resolved dynamically

internal/ui/views/contexts/contexts.go

@@ -243,6 +243,11 @@ func Edit(app common.AppController, v *view.ResourceView) {
 		}
 	}
 
+	if strings.HasPrefix(currentEndpoint, "ssh://") {
+		editSSH(app, id, currentDesc, currentEndpoint)
+		return
+	}
+
 	fields := []dialogs.FormField{
 		{Name: "description", Label: "Description", Type: dialogs.FieldTypeInput, Default: currentDesc},
 		{Name: "host", Label: "Docker Host", Type: dialogs.FieldTypeInput, Default: currentEndpoint},
@@ -256,13 +261,143 @@ func Edit(app common.AppController, v *view.ResourceView) {
 
 		app.RunInBackground(func() {
 			err := app.GetDocker().UpdateContext(id, description, host)
+			isCurrent := app.GetDocker().ContextName == id
 			app.GetTviewApp().QueueUpdateDraw(func() {
 				if err != nil {
 					app.AppendFlashError(fmt.Sprintf("failed to update context: %v", err))
+					app.RefreshCurrentView()
+					return
+				}
+				app.AppendFlashSuccess(fmt.Sprintf("context %s updated", id))
+				if isCurrent {
+					// Rebuild the client so the new endpoint applies immediately
+					app.ReloadContext(id)
 				} else {
-					app.AppendFlashSuccess(fmt.Sprintf("context %s updated", id))
+					app.RefreshCurrentView()
+				}
+			})
+		})
+	})
+}
+
+// parseSSHURL splits "ssh://user@ip[:port][/socket/path]" into the host
+// part and the optional remote socket path.
+func parseSSHURL(endpoint string) (host, socket string) {
+	rest := strings.TrimPrefix(endpoint, "ssh://")
+	if idx := strings.Index(rest, "/"); idx >= 0 {
+		return rest[:idx], rest[idx:]
+	}
+	return rest, ""
+}
+
+func editSSH(app common.AppController, id, currentDesc, currentEndpoint string) {
+	existing, _ := secrets.Load(id)
+
+	currentAuth := secrets.AuthTypeKey
+	if existing != nil && existing.AuthType != "" {
+		currentAuth = existing.AuthType
+	}
+
+	items := []dialogs.PickerItem{
+		{Label: "SSH Key", Description: "authenticate with a private key", Value: secrets.AuthTypeKey},
+		{Label: "Password", Description: "authenticate with a password", Value: secrets.AuthTypePassword},
+	}
+	for i := range items {
+		if items[i].Value == currentAuth {
+			items[i].Description += " (current)"
+		}
+	}
+
+	dialogs.ShowPicker(app, "Authentication Method", items, func(authType string) {
+		showSSHEditForm(app, id, currentDesc, currentEndpoint, authType, existing)
+	})
+}
+
+func showSSHEditForm(app common.AppController, id, currentDesc, currentEndpoint, authType string, existing *secrets.SSHCredentials) {
+	currentHost, currentSocket := parseSSHURL(currentEndpoint)
+	if currentSocket == "" {
+		currentSocket = "/var/run/docker.sock"
+	}
+
+	// Pre-fill credentials only when the auth method is unchanged
+	var defaultKey, defaultPassphrase, defaultPassword string
+	if existing != nil && existing.AuthType == authType {
+		defaultKey = existing.KeyPath
+		defaultPassphrase = existing.Passphrase
+		defaultPassword = existing.Password
+	}
+
+	fields := []dialogs.FormField{
+		{Name: "description", Label: "Description", Type: dialogs.FieldTypeInput, Default: currentDesc},
+		{Name: "host", Label: "Host (user@ip)", Type: dialogs.FieldTypeInput, Default: currentHost},
+	}
+
+	if authType == secrets.AuthTypeKey {
+		fields = append(fields,
+			dialogs.FormField{Name: "key", Label: "SSH Key", Type: dialogs.FieldTypeInput, Default: defaultKey, Placeholder: "~/.ssh/id_ed25519"},
+			dialogs.FormField{Name: "passphrase", Label: "Passphrase (optional)", Type: dialogs.FieldTypeInput, Default: defaultPassphrase, Secret: true},
+		)
+	} else {
+		fields = append(fields,
+			dialogs.FormField{Name: "password", Label: "Password", Type: dialogs.FieldTypeInput, Default: defaultPassword, Secret: true},
+		)
+	}
+
+	fields = append(fields,
+		dialogs.FormField{Name: "socket", Label: "Docker Socket", Type: dialogs.FieldTypeInput, Default: currentSocket},
+	)
+
+	dialogs.ShowFormWithDescription(app, fmt.Sprintf("Edit Context: %s", id), "Updates the SSH context and its credentials", fields, func(result dialogs.FormResult) {
+		description := result["description"]
+		host := strings.TrimSpace(result["host"])
+		socket := strings.TrimSpace(result["socket"])
+
+		if host == "" {
+			app.SetFlashError("host is required")
+			return
+		}
+		if authType == secrets.AuthTypePassword && result["password"] == "" {
+			app.SetFlashError("password is required")
+			return
+		}
+
+		creds := secrets.SSHCredentials{
+			AuthType:   authType,
+			KeyPath:    expandHome(strings.TrimSpace(result["key"])),
+			Passphrase: result["passphrase"],
+			Password:   result["password"],
+		}
+
+		sshURL := fmt.Sprintf("ssh://%s", host)
+		if socket != "" && socket != "/var/run/docker.sock" {
+			sshURL = fmt.Sprintf("ssh://%s%s", host, socket)
+		}
+
+		app.AppendFlashPending(fmt.Sprintf("updating context %s...", id))
+
+		app.RunInBackground(func() {
+			err := app.GetDocker().UpdateContext(id, description, sshURL)
+			if err == nil {
+				if kerr := secrets.Save(id, creds); kerr != nil {
+					app.GetTviewApp().QueueUpdateDraw(func() {
+						app.AppendFlashError(fmt.Sprintf("context updated but credentials not saved: %v", kerr))
+					})
+				}
+			}
+			isCurrent := app.GetDocker().ContextName == id
+			app.GetTviewApp().QueueUpdateDraw(func() {
+				if err != nil {
+					app.AppendFlashError(fmt.Sprintf("failed to update context: %v", err))
+					app.RefreshCurrentView()
+					return
+				}
+				app.AppendFlashSuccess(fmt.Sprintf("SSH context '%s' updated", id))
+				if isCurrent {
+					// Rebuild the client so the new endpoint/credentials apply immediately
+					app.ReloadContext(id)
+				} else {
+					app.RefreshCurrentView()
 				}
-				app.RefreshCurrentView()
 			})
 		})
 	})