fix(live): propagate caller ctx into ResourceGroup inventory ops

Apply/ApplyWithPrune/ResourceGroupCRDMatched passed context.TODO(),
so Ctrl-C and command-level timeouts could not cancel in-flight
apply/destroy/plan calls. Carry ctx on the InventoryResourceGroup
struct and inject it via new WrapInventoryObjWithContext,
NewClusterClientFactoryWithContext, ResourceGroupCRDMatchedWithContext,
and NewClusterPlannerWithContext. Legacy entry points kept as thin
back-compat wrappers; nil ctx normalized to Background().

Signed-off-by: Jaisheesh-2006 <jaicodes2006@gmail.com>

Author: Jaisheesh-2006

commands/alpha/live/plan/command.go

@@ -133,7 +133,7 @@ func (r *Runner) RunE(c *cobra.Command, args []string) error {
 	}
 
 	// Create and execute the planner.
-	planner, err := kptplanner.NewClusterPlanner(r.ctx, r.factory)
+	planner, err := kptplanner.NewClusterPlannerWithContext(r.ctx, r.factory)
 	if err != nil {
 		return err
 	}

commands/live/apply/cmdapply.go

@@ -228,7 +228,7 @@ func runApply(r *Runner, invInfo inventory.Info, objs []*unstructured.Unstructur
 			if err = cmdutil.InstallResourceGroupCRD(r.ctx, f); err != nil {
 				return err
 			}
-		} else if !live.ResourceGroupCRDMatched(r.ctx, f) {
+		} else if !live.ResourceGroupCRDMatchedWithContext(r.ctx, f) {
 			if err = cmdutil.InstallResourceGroupCRD(r.ctx, f); err != nil {
 				return &cmdutil.ResourceGroupCRDNotLatestError{
 					Err: err,

pkg/live/inventoryrg.go

@@ -109,9 +109,15 @@ func WrapInventoryObj(obj *unstructured.Unstructured) inventory.Storage {
 // inventory.NewClient's WrapObjFunc parameter. The returned function
 // produces an InventoryResourceGroup that carries ctx, so subsequent
 // Apply / ApplyWithPrune calls honor the caller's cancellation and
-// timeout. ctx MUST NOT be nil; pass context.Background() explicitly if
-// you truly want no cancellation.
+// timeout.
+//
+// If ctx is nil it is normalized to context.Background() so callers
+// cannot accidentally trigger a nil-deref inside client-go. Prefer
+// passing a real ctx (e.g. cmd.Context()) to actually gain cancellation.
 func WrapInventoryObjWithContext(ctx context.Context) func(*unstructured.Unstructured) inventory.Storage {
+	if ctx == nil {
+		ctx = context.Background()
+	}
 	return func(obj *unstructured.Unstructured) inventory.Storage {
 		if obj != nil {
 			klog.V(4).Infof("wrapping Inventory obj with ctx: %s/%s\n", obj.GetNamespace(), obj.GetName())
@@ -427,9 +433,22 @@ func ResourceGroupCRDApplied(factory cmdutil.Factory) bool {
 // ResourceGroupCRDMatched checks if the ResourceGroup CRD
 // in the cluster matches the CRD in the kpt binary.
 //
-// ctx is used for the live cluster Get call; cancelling it (e.g. via
-// Ctrl-C or a command-level timeout) aborts the check.
-func ResourceGroupCRDMatched(ctx context.Context, factory cmdutil.Factory) bool {
+// This signature is preserved for backward compatibility with external
+// callers; it delegates to ResourceGroupCRDMatchedWithContext with
+// context.Background(). Prefer ResourceGroupCRDMatchedWithContext when
+// you have a caller context so Ctrl-C and timeouts can abort the check.
+func ResourceGroupCRDMatched(factory cmdutil.Factory) bool {
+	return ResourceGroupCRDMatchedWithContext(context.Background(), factory)
+}
+
+// ResourceGroupCRDMatchedWithContext is the context-aware variant of
+// ResourceGroupCRDMatched. ctx is used for the live cluster Get call;
+// cancelling it (e.g. via Ctrl-C or a command-level timeout) aborts the
+// check. A nil ctx is normalized to context.Background().
+func ResourceGroupCRDMatchedWithContext(ctx context.Context, factory cmdutil.Factory) bool {
+	if ctx == nil {
+		ctx = context.Background()
+	}
 	mapper, err := factory.ToRESTMapper()
 	if err != nil {
 		klog.V(4).Infof("error retrieving RESTMapper when checking ResourceGroup CRD: %s\n", err)

pkg/live/inventoryrg_test.go

@@ -20,6 +20,7 @@ import (
 
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 	"k8s.io/apimachinery/pkg/runtime/schema"
+	cmdutil "k8s.io/kubectl/pkg/cmd/util"
 	"sigs.k8s.io/cli-utils/pkg/apis/actuation"
 	"sigs.k8s.io/cli-utils/pkg/common"
 	"sigs.k8s.io/cli-utils/pkg/inventory"
@@ -277,6 +278,41 @@ func TestWrapInventoryObj_LeavesContextNil(t *testing.T) {
 	}
 }
 
+// TestWrapInventoryObjWithContext_NilCtxDefaultsToBackground proves the
+// factory is nil-safe: passing a nil ctx cannot produce a wrapper that
+// would nil-deref inside client-go. The stored ctx is normalized to
+// context.Background() at factory construction time.
+func TestWrapInventoryObjWithContext_NilCtxDefaultsToBackground(t *testing.T) {
+	//nolint:staticcheck // SA1012: deliberately passing a nil context to exercise the nil-safety guard.
+	storage := WrapInventoryObjWithContext(nil)(inventoryObj)
+	icm, ok := storage.(*InventoryResourceGroup)
+	if !ok {
+		t.Fatalf("WrapInventoryObjWithContext(nil) produced unexpected type %T", storage)
+	}
+	if icm.ctx == nil {
+		t.Fatal("expected nil ctx to be normalized to Background(); got nil")
+	}
+	// Background() never cancels; Done() returns a nil channel.
+	if icm.ctx.Done() != nil {
+		t.Fatalf("expected Background()-equivalent ctx; Done() returned non-nil")
+	}
+}
+
+// TestResourceGroupCRDMatched_BackCompatSignaturePreserved is a
+// compile-time guard that the legacy ResourceGroupCRDMatched(factory)
+// signature is still exported, alongside the new context-aware
+// ResourceGroupCRDMatchedWithContext(ctx, factory). If either function
+// is renamed, removed, or has its signature changed, this test stops
+// compiling and the API-compat break is visible immediately.
+//
+// We don't invoke them here because both require a live cmdutil.Factory
+// and short-circuit only after several cluster/mapper calls; their
+// runtime behavior is exercised by the apply/destroy e2e tests.
+func TestResourceGroupCRDMatched_BackCompatSignaturePreserved(t *testing.T) {
+	var _ func(cmdutil.Factory) bool = ResourceGroupCRDMatched
+	var _ func(context.Context, cmdutil.Factory) bool = ResourceGroupCRDMatchedWithContext
+}
+
 // TestContextOrBackground covers both the override path (caller-supplied
 // ctx is returned verbatim, including cancellation state) and the
 // fallback path (nil ctx becomes context.Background()).

pkg/live/planner/cluster.go

@@ -47,11 +47,23 @@ type ClusterPlanner struct {
 	resourceFetcher ResourceFetcher
 }
 
-// NewClusterPlanner builds a ClusterPlanner. ctx is the caller's context
-// and is plumbed into the inventory wrapper so Apply / ApplyWithPrune on
-// the underlying ResourceGroup honor caller cancellation (Ctrl-C,
-// deadlines).
-func NewClusterPlanner(ctx context.Context, f util.Factory) (*ClusterPlanner, error) {
+// NewClusterPlanner builds a ClusterPlanner using context.Background()
+// for the underlying inventory-client cluster calls.
+//
+// This signature is preserved for backward compatibility with external
+// callers; it delegates to NewClusterPlannerWithContext. Prefer the
+// context-aware constructor when you have a caller context so Ctrl-C
+// and command-level timeouts can cancel inventory I/O.
+func NewClusterPlanner(f util.Factory) (*ClusterPlanner, error) {
+	return NewClusterPlannerWithContext(context.Background(), f)
+}
+
+// NewClusterPlannerWithContext is the context-aware variant of
+// NewClusterPlanner. ctx is plumbed into the inventory wrapper so
+// Apply / ApplyWithPrune on the underlying ResourceGroup honor caller
+// cancellation (Ctrl-C, deadlines). A nil ctx is normalized to
+// context.Background() by WrapInventoryObjWithContext.
+func NewClusterPlannerWithContext(ctx context.Context, f util.Factory) (*ClusterPlanner, error) {
 	fetcher, err := NewResourceFetcher(f)
 	if err != nil {
 		return nil, err

pkg/live/planner/cluster_test.go

@@ -21,6 +21,7 @@ import (
 	"github.com/google/go-cmp/cmp"
 	"github.com/stretchr/testify/require"
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	"k8s.io/kubectl/pkg/cmd/util"
 	"sigs.k8s.io/cli-utils/pkg/apply"
 	"sigs.k8s.io/cli-utils/pkg/apply/event"
 	"sigs.k8s.io/cli-utils/pkg/inventory"
@@ -166,3 +167,18 @@ func (fii *FakeInventoryInfo) ID() string {
 func (fii *FakeInventoryInfo) Strategy() inventory.Strategy {
 	return inventory.NameStrategy
 }
+
+// TestNewClusterPlanner_BackCompatSignaturePreserved is a compile-time
+// guard that both the legacy NewClusterPlanner(f) entry point and the
+// new context-aware NewClusterPlannerWithContext(ctx, f) remain
+// exported with their current signatures. If either is renamed,
+// removed, or has its parameter list changed, this test stops
+// compiling and the API-compat break is visible immediately.
+//
+// Runtime behavior of both constructors is exercised through the
+// command-level tests that instantiate the planner via the real
+// factory in commands/alpha/live/plan.
+func TestNewClusterPlanner_BackCompatSignaturePreserved(t *testing.T) {
+	var _ func(util.Factory) (*ClusterPlanner, error) = NewClusterPlanner
+	var _ func(context.Context, util.Factory) (*ClusterPlanner, error) = NewClusterPlannerWithContext
+}