fix(engine): thread CommandName through Options for multi-node errors

helpers.FailIfMultiNodes(ctx, name) embeds the name in its error
message. The call site in engine.Render hardcoded "talm template",
which was accurate when Render was only called from the template
subcommand. PR #119 made apply call Render too, so users running
`talm apply` with a multi-node modeline saw an error talking about
`talm template` — confusing.

Add Options.CommandName, default to "talm" when empty, set
"talm apply" in apply's buildApplyRenderOptions and "talm template"
in template's option-build. TestRenderFailIfMultiNodes_UsesCommandName
covers both subcommands plus the empty-string fallback and explicitly
asserts the historical "talm template" no longer leaks into the apply
case.

Closes #121

Assisted-By: Claude <noreply@anthropic.com>
Signed-off-by: Aleksei Sviridkin <f@lex.la>

Author: lexfrei

pkg/commands/apply.go

@@ -221,6 +221,7 @@ func buildApplyRenderOptions(modelineTemplates []string, withSecretsPath string)
 		Full:              true,
 		Root:              Config.RootDir,
 		TemplateFiles:     resolvedTemplates,
+		CommandName:       "talm apply",
 	}
 }
 

pkg/commands/template.go

@@ -288,6 +288,7 @@ func generateOutput(ctx context.Context, c *client.Client, args []string) (strin
 		Offline:           templateCmdFlags.offline,
 		KubernetesVersion: templateCmdFlags.kubernetesVersion,
 		TemplateFiles:     resolvedTemplateFiles,
+		CommandName:       "talm template",
 	}
 
 	result, err := engine.Render(ctx, c, opts)

pkg/engine/engine.go

@@ -56,6 +56,9 @@ type Options struct {
 	TemplateFiles     []string
 	ClusterName       string
 	Endpoint          string
+	// CommandName names the caller subcommand for error messages such as
+	// the one produced by FailIfMultiNodes. Empty value falls back to "talm".
+	CommandName string
 }
 
 // NormalizeTemplatePath converts OS-specific path separators to forward slash.
@@ -215,7 +218,11 @@ func Render(ctx context.Context, c *client.Client, opts Options) ([]byte, error)
 
 	// Gather facts and enable lookup options
 	if !opts.Offline {
-		if err := helpers.FailIfMultiNodes(ctx, "talm template"); err != nil {
+		cmdName := opts.CommandName
+		if cmdName == "" {
+			cmdName = "talm"
+		}
+		if err := helpers.FailIfMultiNodes(ctx, cmdName); err != nil {
 			return nil, err
 		}
 		helmEngine.LookupFunc = newLookupFunction(ctx, c)

pkg/engine/render_test.go

@@ -24,6 +24,7 @@ import (
 	"testing"
 
 	helmEngine "github.com/cozystack/talm/pkg/engine/helm"
+	"github.com/siderolabs/talos/pkg/machinery/client"
 	"helm.sh/helm/v3/pkg/chart/loader"
 	"helm.sh/helm/v3/pkg/chartutil"
 )
@@ -930,6 +931,51 @@ func TestMultiDocGeneric_VlanOnBondTopology(t *testing.T) {
 	assertNotContains(t, result, "kind: LinkConfig")
 }
 
+// TestRenderFailIfMultiNodes_UsesCommandName covers #121: the multi-node
+// rejection error must reference the calling subcommand passed via
+// Options.CommandName, not the historical hardcoded "talm template" that
+// confused users running `talm apply`.
+func TestRenderFailIfMultiNodes_UsesCommandName(t *testing.T) {
+	tests := []struct {
+		name        string
+		commandName string
+		wantInError string
+	}{
+		{"talm apply", "talm apply", "talm apply"},
+		{"talm template", "talm template", "talm template"},
+		{"empty falls back to talm", "", "talm"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ctx := client.WithNodes(context.Background(), "10.0.0.1", "10.0.0.2")
+			opts := Options{
+				Offline:     false,
+				CommandName: tt.commandName,
+			}
+			_, err := Render(ctx, nil, opts)
+			if err == nil {
+				t.Fatalf("Render expected an error, got nil")
+			}
+			if !strings.Contains(err.Error(), tt.wantInError) {
+				t.Errorf("error = %q, expected to contain %q", err.Error(), tt.wantInError)
+			}
+		})
+	}
+
+	t.Run("non-empty CommandName must not leak the historical default", func(t *testing.T) {
+		ctx := client.WithNodes(context.Background(), "10.0.0.1", "10.0.0.2")
+		opts := Options{Offline: false, CommandName: "talm apply"}
+		_, err := Render(ctx, nil, opts)
+		if err == nil {
+			t.Fatal("Render expected an error, got nil")
+		}
+		if strings.Contains(err.Error(), "talm template") {
+			t.Errorf("error must not mention 'talm template' when CommandName is 'talm apply'; got %q", err.Error())
+		}
+	})
+}
+
 // TestRenderInvalidTalosVersion verifies that malformed TalosVersion values
 // surface a user-friendly error before template rendering, instead of the
 // opaque "error calling semverCompare: invalid semantic version" that escapes