feat(mesh): core command surface for Kong Mesh control planes

internal/cmd/root/mesh_command_paths_test.go

@@ -0,0 +1,47 @@
+package root
+
+import (
+	"strings"
+	"testing"
+)
+
+// Mesh is reachable both directly and under the explicit product path. The
+// constructors promise both, but only the direct form was registered, so
+// `kongctl get konnect mesh` failed with "unknown command". These assert the
+// real command paths rather than the constructors.
+func TestMeshCommandPathsResolve(t *testing.T) {
+	// Every verb Kong Mesh serves here. `apply konnect` and `delete konnect`
+	// are replaced by the declarative commands and take their own arguments,
+	// so those two are served by the direct form only.
+	paths := [][]string{
+		{"apply", "mesh", "--help"},
+		{"get", "mesh", "--help"},
+		{"get", "konnect", "mesh", "--help"},
+		{"create", "mesh", "--help"},
+		{"create", "konnect", "mesh", "--help"},
+		{"delete", "mesh", "--help"},
+	}
+
+	for _, args := range paths {
+		path := strings.Join(args[:len(args)-1], " ")
+
+		t.Run(path, func(t *testing.T) {
+			result := executeRootForTest(t, args...)
+
+			if result.exitCode != 0 {
+				t.Fatalf("expected %q to succeed\nstdout:\n%s\nstderr:\n%s",
+					path, result.stdout, result.stderr)
+			}
+			if strings.Contains(result.stderr, "unknown command") {
+				t.Fatalf("expected %q to be registered\nstderr:\n%s", path, result.stderr)
+			}
+			// The mesh command's own help, not a parent's help that merely
+			// lists it: a swallowed argument prints the parent's help and
+			// still exits zero.
+			if !strings.Contains(result.stdout, "Kong Mesh control plane") {
+				t.Fatalf("expected %q help to describe the mesh command\nstdout:\n%s",
+					path, result.stdout)
+			}
+		})
+	}
+}

internal/cmd/root/products/konnect/konnect.go

@@ -3,6 +3,7 @@ package konnect
 import (
 	"context"
 	"fmt"
+	"slices"
 
 	cmdpkg "github.com/kong/kongctl/internal/cmd"
 	commoncmd "github.com/kong/kongctl/internal/cmd/common"
@@ -19,6 +20,7 @@ import (
 	"github.com/kong/kongctl/internal/cmd/root/products/konnect/eventgateway"
 	"github.com/kong/kongctl/internal/cmd/root/products/konnect/gateway"
 	"github.com/kong/kongctl/internal/cmd/root/products/konnect/me"
+	"github.com/kong/kongctl/internal/cmd/root/products/konnect/mesh"
 	"github.com/kong/kongctl/internal/cmd/root/products/konnect/organization"
 	"github.com/kong/kongctl/internal/cmd/root/products/konnect/portal"
 	"github.com/kong/kongctl/internal/cmd/root/products/konnect/regions"
@@ -201,6 +203,39 @@ func preRunE(c *cobra.Command, args []string) error {
 	return bindFlags(c, args)
 }
 
+// meshVerbs are the verbs Kong Mesh serves under the explicit product path.
+var meshVerbs = []verbs.VerbValue{verbs.Get, verbs.Create, verbs.Dump}
+
+// addMeshCommand registers Kong Mesh under the explicit product path, giving
+// `kongctl <verb> konnect mesh ...` alongside the direct `kongctl <verb> mesh
+// ...` form that the root command registers.
+//
+// Mesh serves a subset of the verbs, so an unsupported verb registers nothing
+// rather than adding a command that cannot run.
+//
+// Apply and delete are absent deliberately. `apply konnect` and `delete
+// konnect` are replaced by the declarative commands, which take their own
+// arguments, so a `mesh` subcommand there is read as one of them instead of
+// dispatching. Both are served by the direct `apply mesh` and `delete mesh`
+// forms.
+func addMeshCommand(
+	cmd *cobra.Command,
+	verb verbs.VerbValue,
+	addParentFlags func(verbs.VerbValue, *cobra.Command),
+	parentPreRun func(*cobra.Command, []string) error,
+) error {
+	if !slices.Contains(meshVerbs, verb) {
+		return nil
+	}
+
+	meshCmd, err := mesh.NewMeshCmd(verb, addParentFlags, parentPreRun)
+	if err != nil {
+		return err
+	}
+	cmd.AddCommand(meshCmd)
+	return nil
+}
+
 func NewKonnectCmd(verb verbs.VerbValue) (*cobra.Command, error) {
 	cmd := &cobra.Command{
 		Use:     konnectUse,
@@ -234,6 +269,9 @@ func NewKonnectCmd(verb verbs.VerbValue) (*cobra.Command, error) {
 		if err := addTokenCommands(cmd, verb, addFlags, preRunE); err != nil {
 			return nil, err
 		}
+		if err := addMeshCommand(cmd, verb, addFlags, preRunE); err != nil {
+			return nil, err
+		}
 		addFlags(verb, cmd)
 		return cmd, nil
 	}
@@ -420,6 +458,10 @@ func NewKonnectCmd(verb verbs.VerbValue) (*cobra.Command, error) {
 	}
 	cmd.AddCommand(egcpc)
 
+	if err := addMeshCommand(cmd, verb, addFlags, preRunE); err != nil {
+		return nil, err
+	}
+
 	if verb == verbs.Get {
 		cmd.RunE = func(c *cobra.Command, args []string) error {
 			helper := cmdpkg.BuildHelper(c, args)