You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@kie.apache.org by tr...@apache.org on 2025/03/18 16:07:29 UTC

(incubator-kie-tools) branch main updated: kie-issues#1586: [kn-plugin-workflow] Evaluate if we should install operator via cli

This is an automated email from the ASF dual-hosted git repository.

treblereel pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/incubator-kie-tools.git


The following commit(s) were added to refs/heads/main by this push:
     new 7f51166d788 kie-issues#1586: [kn-plugin-workflow] Evaluate if we should install operator via cli
7f51166d788 is described below

commit 7f51166d7881a79023b61cd66d91fe510ff4551e
Author: Dmitrii Tikhomirov <tr...@users.noreply.github.com>
AuthorDate: Tue Mar 18 09:07:25 2025 -0700

    kie-issues#1586: [kn-plugin-workflow] Evaluate if we should install operator via cli
---
 packages/kn-plugin-workflow/Makefile               |   9 +-
 packages/kn-plugin-workflow/e2e-tests/main_test.go |   4 +-
 .../e2e-tests/operator_helper.go                   | 124 +++++++
 .../pkg/command/deploy_undeploy_common.go          |   2 +-
 .../kn-plugin-workflow/pkg/command/gen_manifest.go |   2 +-
 .../pkg/command/operator/install.go                |  72 ++++
 .../pkg/command/operator/operator.go               |  54 +++
 .../pkg/command/operator/status.go                 |  67 ++++
 .../pkg/command/operator/uninstall.go              |  83 +++++
 .../pkg/command/quarkus/deploy_test.go             |   8 +-
 .../pkg/common/k8sclient/fake.go                   |   2 +-
 .../pkg/common/k8sclient/goapi.go                  | 189 +++++++++--
 packages/kn-plugin-workflow/pkg/common/kubectl.go  |  61 +++-
 packages/kn-plugin-workflow/pkg/common/operator.go | 365 ++++++++++++++++++++-
 .../kn-plugin-workflow/pkg/metadata/constants.go   |   8 +-
 .../kn-plugin-workflow/pkg/openshift/operation.go  |  51 +++
 packages/kn-plugin-workflow/pkg/root/root.go       |   2 +
 packages/kn-plugin-workflow/pkg/root/root_test.go  |   1 +
 18 files changed, 1050 insertions(+), 54 deletions(-)

diff --git a/packages/kn-plugin-workflow/Makefile b/packages/kn-plugin-workflow/Makefile
index d2ea6cce538..69a8a377243 100644
--- a/packages/kn-plugin-workflow/Makefile
+++ b/packages/kn-plugin-workflow/Makefile
@@ -34,6 +34,7 @@ SET_KOGITO_VERSION            := $(METADATA_PATH).KogitoVersion=$(KOGITO_VERSION
 LDFLAGS                       := "-X $(SET_QUARKUS_PLATFORM_GROUP_ID) -X $(SET_QUARKUS_VERSION) -X $(SET_VERSION) -X $(SET_DEV_MODE_IMAGE) -X $(SET_KOGITO_VERSION)"
 
 KIND_VERSION ?= v0.20.0
+OLM_VERSION = v0.31.0
 
 ARCH := $(shell uname -m)
 ifeq ($(ARCH),arm64)
@@ -69,7 +70,7 @@ clean:
 test-e2e:
 	@$(MAKE) install-kind
 	@$(MAKE) create-cluster
-	@$(MAKE) install-operator
+	@$(MAKE) install-operator-framework
 	@$(MAKE) go-test-e2e
 	@$(MAKE) go-test-e2e-report
 
@@ -82,9 +83,9 @@ install-kind:
 create-cluster: install-kind
 	kind create cluster
 
-.PHONY: install-operator
-install-operator:
-	kubectl create -f ../sonataflow-operator/operator.yaml
+.PHONY: install-operator-framework
+install-operator-framework:
+	curl -sL https://github.com/operator-framework/operator-lifecycle-manager/releases/download/$(OLM_VERSION)/install.sh | bash -s $(OLM_VERSION)
 
 .PHONY: go-test-e2e
 go-test-e2e:
diff --git a/packages/kn-plugin-workflow/e2e-tests/main_test.go b/packages/kn-plugin-workflow/e2e-tests/main_test.go
index 0fa8bb5abd5..d271db57d2f 100644
--- a/packages/kn-plugin-workflow/e2e-tests/main_test.go
+++ b/packages/kn-plugin-workflow/e2e-tests/main_test.go
@@ -38,7 +38,6 @@ var KnExecutable string
 
 var TestPrintCmdOutput = flag.Bool("logs", true, "Print command output during tests")
 
-var operatorCRD = "operator.yaml"
 
 func TestMain(m *testing.M) {
 
@@ -56,9 +55,12 @@ func TestMain(m *testing.M) {
 
 	checkAndBuildExecutable()
 
+	InstallOperator()
 	// Run tests
 	exitCode := m.Run()
 
+	UninstallOperator()
+
 	// Cleanup after tests
 	cleanUpTemp(workingPath, tempDirName)
 
diff --git a/packages/kn-plugin-workflow/e2e-tests/operator_helper.go b/packages/kn-plugin-workflow/e2e-tests/operator_helper.go
new file mode 100644
index 00000000000..35e792d94e9
--- /dev/null
+++ b/packages/kn-plugin-workflow/e2e-tests/operator_helper.go
@@ -0,0 +1,124 @@
+//go:build e2e_tests
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package e2e_tests
+
+import (
+	"fmt"
+	"os"
+	"time"
+
+	"github.com/apache/incubator-kie-tools/packages/kn-plugin-workflow/pkg/command/operator"
+	"github.com/apache/incubator-kie-tools/packages/kn-plugin-workflow/pkg/common"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+)
+
+var operatorManager = common.NewOperatorManager("")
+
+func InstallOperator() {
+	installOperator()
+	waitForOperatorReady()
+	checkOperatorInstalled()
+}
+
+func UninstallOperator() {
+	uninstallOperator()
+}
+
+func installOperator() {
+	var install = operator.NewInstallOperatorCommand()
+	err := install.Execute()
+	if err != nil {
+		fmt.Println("Failed to install operator:", err)
+		os.Exit(1)
+	}
+}
+
+func waitForOperatorReady() {
+	deployed := make(chan bool)
+	defer close(deployed)
+	timeoutCh := time.After(5 * time.Minute)
+
+	go func() {
+		for {
+			select {
+			case <-timeoutCh:
+				fmt.Println("Timeout waiting for operator to be ready")
+				os.Exit(1)
+			default:
+				resources, err := operatorManager.ListOperatorResources();
+				if err != nil {
+					fmt.Println("Failed to list operator resources:", err)
+					os.Exit(1)
+				}
+
+				if(len(resources) == 0) {
+					continue
+				}
+
+				var ready = true
+				for _, resource := range resources {
+					phase, found, err := unstructured.NestedString(resource.Object, "status", "phase")
+					if !found {
+						ready = false
+					}
+					if err != nil {
+						fmt.Println("Failed to get resource status:", err)
+						os.Exit(1)
+					}
+					if phase != "Succeeded" {
+						ready = false
+					}
+				}
+
+				if ready {
+					deployed <- true
+					return
+
+				}
+				time.Sleep(5 * time.Second)
+			}
+		}
+	}()
+
+	select {
+	case <-deployed:
+		fmt.Printf(" - ✅ Operator is ready\n")
+	}
+}
+
+func checkOperatorInstalled() {
+	var status = operator.NewStatusOperatorCommand()
+	err := status.Execute()
+	if err != nil {
+		fmt.Println("Failed to check operator status:", err)
+		os.Exit(1)
+	}
+}
+
+func uninstallOperator() {
+	var uninstall = operator.NewUnInstallOperatorCommand()
+	err := uninstall.Execute()
+	if err != nil {
+		fmt.Println("Failed to uninstall operator:", err)
+		os.Exit(1)
+	}
+}
diff --git a/packages/kn-plugin-workflow/pkg/command/deploy_undeploy_common.go b/packages/kn-plugin-workflow/pkg/command/deploy_undeploy_common.go
index bd9c3d7305c..ccd6b0eed99 100644
--- a/packages/kn-plugin-workflow/pkg/command/deploy_undeploy_common.go
+++ b/packages/kn-plugin-workflow/pkg/command/deploy_undeploy_common.go
@@ -66,7 +66,7 @@ func checkEnvironment(cfg *DeployUndeployCmdConfig) error {
 
 	//setup namespace
 	if len(cfg.NameSpace) == 0 {
-		if defaultNamespace, err := common.GetNamespace(); err == nil {
+		if defaultNamespace, err := common.GetCurrentNamespace(); err == nil {
 			cfg.NameSpace = defaultNamespace
 		} else {
 			return err
diff --git a/packages/kn-plugin-workflow/pkg/command/gen_manifest.go b/packages/kn-plugin-workflow/pkg/command/gen_manifest.go
index b7dc0b6a7c5..93b8ae96826 100644
--- a/packages/kn-plugin-workflow/pkg/command/gen_manifest.go
+++ b/packages/kn-plugin-workflow/pkg/command/gen_manifest.go
@@ -198,7 +198,7 @@ func setupEnvironment(cfg *DeployUndeployCmdConfig) error {
 
 	//setup namespace
 	if len(cfg.NameSpace) == 0 && !cfg.EmptyNameSpace {
-		if defaultNamespace, err := common.GetNamespace(); err == nil {
+		if defaultNamespace, err := common.GetCurrentNamespace(); err == nil {
 			cfg.NameSpace = defaultNamespace
 			fmt.Printf(" - ✅  resolved namespace: %s\n", cfg.NameSpace)
 		} else {
diff --git a/packages/kn-plugin-workflow/pkg/command/operator/install.go b/packages/kn-plugin-workflow/pkg/command/operator/install.go
new file mode 100644
index 00000000000..261b9164b4a
--- /dev/null
+++ b/packages/kn-plugin-workflow/pkg/command/operator/install.go
@@ -0,0 +1,72 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package operator
+
+import (
+	"fmt"
+	"github.com/apache/incubator-kie-tools/packages/kn-plugin-workflow/pkg/common"
+	"github.com/ory/viper"
+	"github.com/spf13/cobra"
+)
+
+func NewInstallOperatorCommand() *cobra.Command {
+	var cmd = &cobra.Command{
+		Use:   "install",
+		Short: "Install the SonataFlow Operator, which is responsible for deploying SonataFlow projects on Kubernetes.",
+		Long: `
+	Install the SonataFlow Operator, which is responsible for deploying SonataFlow projects on Kubernetes.
+	`,
+		Example: `
+	# Install the SonataFlow Operator. Usually in Openshift the namespace is "openshift-operators", in case of Minikube or Kind, with
+	# default OLM installation, the namespace is "operators".
+	{{.Name}} operator install --namespace <your_operator_namespace>
+		`,
+		PreRunE:    common.BindEnv("namespace"),
+	}
+
+	cmd.RunE = func(cmd *cobra.Command, args []string) error {
+		return runInstallOperatorCommand(cmd, args)
+	}
+	cmd.Flags().StringP("namespace", "n", "", "Target namespace of your Operator deployment.")
+	cmd.SetHelpFunc(common.DefaultTemplatedHelp)
+
+	return cmd
+}
+
+func runInstallOperatorCommand(cmd *cobra.Command, args []string) error {
+	fmt.Println("🚀 Installing the SonataFlow Operator...")
+
+	namespace := viper.GetString("namespace")
+
+	operator := common.NewOperatorManager(namespace)
+
+	err := operator.CheckOLMInstalled()
+	if err != nil {
+		return err
+	}
+
+	err = operator.InstallSonataflowOperator()
+	if err != nil {
+		return err
+	}
+	fmt.Println("🎉 SonataFlow Operator successfully installed, wait for the operator to be ready.")
+
+	return nil
+}
diff --git a/packages/kn-plugin-workflow/pkg/command/operator/operator.go b/packages/kn-plugin-workflow/pkg/command/operator/operator.go
new file mode 100644
index 00000000000..afba4a58c7b
--- /dev/null
+++ b/packages/kn-plugin-workflow/pkg/command/operator/operator.go
@@ -0,0 +1,54 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package operator
+
+import (
+	"github.com/apache/incubator-kie-tools/packages/kn-plugin-workflow/pkg/common"
+	"github.com/spf13/cobra"
+)
+
+func NewOperatorCommand() *cobra.Command {
+	var cmd = &cobra.Command{
+		Use:   "operator",
+		Short: "Manage the SonataFlow Operator, which is responsible for deploying SonataFlow projects on Kubernetes.",
+		Long: `
+	Install or uninstall the SonataFlow Operator, which is responsible for deploying SonataFlow projects on Kubernetes.
+	`,
+		Example: `
+	# Install the SonataFlow Operator.
+	{{.Name}} operator install
+
+	# Uninstall the SonataFlow Operator.
+	{{.Name}} operator uninstall
+
+	# Check the status of the SonataFlow Operator.
+	{{.Name}} operator status
+		`,
+	}
+
+	cmd.AddCommand(NewInstallOperatorCommand())
+	cmd.AddCommand(NewUnInstallOperatorCommand())
+	cmd.AddCommand(NewStatusOperatorCommand())
+
+
+	cmd.SetHelpFunc(common.DefaultTemplatedHelp)
+
+	return cmd
+}
diff --git a/packages/kn-plugin-workflow/pkg/command/operator/status.go b/packages/kn-plugin-workflow/pkg/command/operator/status.go
new file mode 100644
index 00000000000..3bdc2b7a65c
--- /dev/null
+++ b/packages/kn-plugin-workflow/pkg/command/operator/status.go
@@ -0,0 +1,67 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package operator
+
+import (
+	"github.com/apache/incubator-kie-tools/packages/kn-plugin-workflow/pkg/common"
+	"github.com/ory/viper"
+	"github.com/spf13/cobra"
+)
+
+func NewStatusOperatorCommand() *cobra.Command {
+	var cmd = &cobra.Command{
+		Use:   "status",
+		Short: "Get the status of deployed SonataFlow Operator.",
+		Long: `
+	Get the status of deployed SonataFlow Operator.
+	`,
+		Example: `
+	# Check the status of the SonataFlow Operator.
+	{{.Name}} operator status --namespace <your_operator_namespace>
+		`,
+		PreRunE:    common.BindEnv("namespace"),
+	}
+
+	cmd.RunE = func(cmd *cobra.Command, args []string) error {
+		return runStatusCommand(cmd, args)
+	}
+	cmd.Flags().StringP("namespace", "n", "", "Target namespace of your Operator deployment.")
+
+	cmd.SetHelpFunc(common.DefaultTemplatedHelp)
+
+	return cmd
+}
+
+func runStatusCommand(cmd *cobra.Command, args []string) error {
+	namespace := viper.GetString("namespace")
+
+	operator := common.NewOperatorManager(namespace)
+
+	err:= operator.CheckOLMInstalled()
+	if err != nil {
+		return err
+	}
+
+	err = operator.GetSonataflowOperatorStats()
+	if err != nil {
+		return err
+	}
+	return nil
+}
diff --git a/packages/kn-plugin-workflow/pkg/command/operator/uninstall.go b/packages/kn-plugin-workflow/pkg/command/operator/uninstall.go
new file mode 100644
index 00000000000..ec383b238f0
--- /dev/null
+++ b/packages/kn-plugin-workflow/pkg/command/operator/uninstall.go
@@ -0,0 +1,83 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package operator
+
+import (
+	"fmt"
+	"github.com/apache/incubator-kie-tools/packages/kn-plugin-workflow/pkg/common"
+	"github.com/ory/viper"
+	"github.com/spf13/cobra"
+)
+
+func NewUnInstallOperatorCommand() *cobra.Command {
+	var cmd = &cobra.Command{
+		Use:   "uninstall",
+		Short: "Uninstall the SonataFlow Operator.",
+		Long: `
+	Uninstall the SonataFlow Operator.
+	`,
+		Example: `
+	# Uninstall the SonataFlow Operator.
+	{{.Name}} operator uninstall --namespace <your_operator_namespace>
+		`,
+		PreRunE:    common.BindEnv("namespace"),
+	}
+
+	cmd.RunE = func(cmd *cobra.Command, args []string) error {
+		return runUnInstallOperatorCommand(cmd, args)
+	}
+	cmd.Flags().StringP("namespace", "n", "", "Target namespace of your Operator deployment.")
+
+	cmd.SetHelpFunc(common.DefaultTemplatedHelp)
+
+	return cmd
+}
+
+func runUnInstallOperatorCommand(cmd *cobra.Command, args []string) error {
+	fmt.Println("🚀 Uninstalling the SonataFlow Operator...")
+
+	namespace := viper.GetString("namespace")
+
+	operator := common.NewOperatorManager(namespace)
+
+	err := operator.RemoveCR()
+	if err != nil {
+		return fmt.Errorf("failed to remove CR: %v", err)
+	}
+
+	err = operator.RemoveCSV()
+	if err != nil {
+		return fmt.Errorf("failed to remove CSV: %v", err)
+	}
+
+	err = operator.RemoveCRD()
+	if err != nil {
+		return fmt.Errorf("failed to remove CRD: %v", err)
+	}
+
+	err = operator.RemoveSubscription()
+	if err != nil {
+		return fmt.Errorf("failed to remove subscription: %v", err)
+	}
+
+	fmt.Println("🎉 SonataFlow Operator successfully uninstalled.")
+
+	return nil
+}
diff --git a/packages/kn-plugin-workflow/pkg/command/quarkus/deploy_test.go b/packages/kn-plugin-workflow/pkg/command/quarkus/deploy_test.go
index addfccc4af4..f8bf333e7f3 100644
--- a/packages/kn-plugin-workflow/pkg/command/quarkus/deploy_test.go
+++ b/packages/kn-plugin-workflow/pkg/command/quarkus/deploy_test.go
@@ -91,19 +91,19 @@ func TestRunDeploy(t *testing.T) {
 	common.FS = afero.NewMemMapFs()
 	originalParseYamlFile := k8sclient.ParseYamlFile
 	originalDynamicClient := k8sclient.DynamicClient
-	originalGetNamespace := k8sclient.GetNamespace
+	originalGetNamespace := k8sclient.GetCurrentNamespace
 
 	fakeClient := k8sclient.Fake{FS: common.FS}
 
 	defer func() {
 		k8sclient.ParseYamlFile = originalParseYamlFile
 		k8sclient.DynamicClient = originalDynamicClient
-		k8sclient.GetNamespace = originalGetNamespace
+		k8sclient.GetCurrentNamespace = originalGetNamespace
 	}()
 
 	k8sclient.ParseYamlFile = fakeClient.FakeParseYamlFile
 	k8sclient.DynamicClient = fakeClient.FakeDynamicClient
-	k8sclient.GetNamespace = fakeClient.GetNamespace
+	k8sclient.GetCurrentNamespace = fakeClient.GetCurrentNamespace
 
 	for _, test := range testRunDeploy {
 		checkDeploy(t, test)
@@ -197,7 +197,7 @@ func knativeFixQuarkusVersionAndWriteToTestFolder(t *testing.T, test testDeploy)
 
 func checkObjectCreated(obj unstructured.Unstructured, namespace string) (bool, error) {
 	if namespace == "" {
-		currentNamespace, err := common.GetNamespace()
+		currentNamespace, err := common.GetCurrentNamespace()
 		if err != nil {
 			return false, fmt.Errorf("❌ ERROR: Failed to get current namespace: %v", err)
 		}
diff --git a/packages/kn-plugin-workflow/pkg/common/k8sclient/fake.go b/packages/kn-plugin-workflow/pkg/common/k8sclient/fake.go
index 4e6813a4608..7e3903ce246 100644
--- a/packages/kn-plugin-workflow/pkg/common/k8sclient/fake.go
+++ b/packages/kn-plugin-workflow/pkg/common/k8sclient/fake.go
@@ -47,7 +47,7 @@ func (m Fake) FakeDynamicClient() (dynamic.Interface, error) {
 	return currentDynamicClient, nil
 }
 
-func (m Fake) GetNamespace() (string, error) {
+func (m Fake) GetCurrentNamespace() (string, error) {
 	return "default", nil
 }
 
diff --git a/packages/kn-plugin-workflow/pkg/common/k8sclient/goapi.go b/packages/kn-plugin-workflow/pkg/common/k8sclient/goapi.go
index df34b8348db..f3d14b26316 100644
--- a/packages/kn-plugin-workflow/pkg/common/k8sclient/goapi.go
+++ b/packages/kn-plugin-workflow/pkg/common/k8sclient/goapi.go
@@ -17,6 +17,7 @@
  * under the License.
  */
 
+
 package k8sclient
 
 import (
@@ -30,12 +31,15 @@ import (
 	"strings"
 
 	v1 "k8s.io/api/apps/v1"
+	corev1 "k8s.io/api/core/v1"
 	"k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset"
 	"k8s.io/apimachinery/pkg/api/errors"
 	"k8s.io/apimachinery/pkg/api/meta"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/apimachinery/pkg/util/yaml"
+
 	"k8s.io/client-go/dynamic"
 	"k8s.io/client-go/kubernetes"
 	"k8s.io/client-go/rest"
@@ -47,8 +51,70 @@ import (
 
 type GoAPI struct{}
 
-func (m GoAPI) GetNamespace() (string, error) {
-	return GetNamespace()
+var selfSubjectAccessGVR = schema.GroupVersionResource{
+	Group:    "authorization.k8s.io",
+	Version:  "v1",
+	Resource: "selfsubjectaccessreviews",
+}
+
+var kubeconfigInfoDisplayed = false
+
+func (m GoAPI) IsCreateAllowed(resourcePath string, namespace string) (bool, error) {
+	dynamicClient, err := DynamicClient()
+	if err != nil {
+		return false, fmt.Errorf("❌ ERROR: Failed to create dynamic Kubernetes client: %v", err)
+	}
+
+	if resources, err := ParseYamlFile(resourcePath); err != nil {
+		return false, fmt.Errorf("❌ ERROR: Failed to parse YAML file: %v", err)
+	} else {
+		for _, resource := range resources {
+			sar := parseResource(resource, namespace)
+
+			result, err := dynamicClient.Resource(selfSubjectAccessGVR).Create(context.TODO(), sar, metav1.CreateOptions{})
+			if err != nil {
+				return false, fmt.Errorf("failed to perform access review: %v", err)
+			}
+
+			allowed, _, _ := unstructured.NestedBool(result.Object, "status", "allowed")
+			return allowed, nil
+		}
+	}
+	return false, nil
+}
+
+func (m GoAPI) IsDeleteAllowed(name string, namespace string) error {
+	dynamicClient, err := DynamicClient()
+	if err != nil {
+		return fmt.Errorf("❌ ERROR: Failed to create dynamic Kubernetes client: %v", err)
+	}
+
+	err = dynamicClient.Resource(selfSubjectAccessGVR).Namespace(namespace).Delete(context.TODO(), name, metav1.DeleteOptions{})
+	if err != nil {
+		return fmt.Errorf("failed to perform access review: %v", err)
+	}
+	return nil
+}
+
+func (m GoAPI) GetCurrentNamespace() (string, error) {
+	return GetCurrentNamespace()
+}
+
+func (m GoAPI) GetNamespace(namespace string) (*corev1.Namespace, error) {
+	config, err := KubeRestConfig()
+	if err != nil {
+		return nil, fmt.Errorf("❌ ERROR: Failed to create rest config for Kubernetes client: %v", err)
+	}
+
+	clientSet, err := kubernetes.NewForConfig(config)
+	if err != nil {
+		return nil, fmt.Errorf("❌ ERROR: Failed to create k8s client: %v", err)
+	}
+	ns, err := clientSet.CoreV1().Namespaces().Get(context.TODO(), namespace, metav1.GetOptions{})
+	if err != nil {
+		return nil, fmt.Errorf("❌ ERROR: Failed to get namespace: %v", err)
+	}
+	return ns, nil
 }
 
 func (m GoAPI) CheckContext() (string, error) {
@@ -72,7 +138,7 @@ func (m GoAPI) ExecuteApply(path, namespace string) error {
 	fmt.Printf("🔨 Applying YAML file %s\n", path)
 
 	if namespace == "" {
-		currentNamespace, err := m.GetNamespace()
+		currentNamespace, err := m.GetCurrentNamespace()
 		if err != nil {
 			return fmt.Errorf("❌ ERROR: Failed to get current namespace: %w", err)
 		}
@@ -119,14 +185,36 @@ func (m GoAPI) ExecuteApply(path, namespace string) error {
 	return nil
 }
 
-func (m GoAPI) ExecuteDelete(path, namespace string) error {
-	client, err := DynamicClient()
+func (m GoAPI) ExecuteCreate(gvr schema.GroupVersionResource, object *unstructured.Unstructured, namespace string) (*unstructured.Unstructured, error) {
+	dynamicClient, err := DynamicClient()
 	if err != nil {
-		return fmt.Errorf("❌ ERROR: Failed to create dynamic Kubernetes client: %v", err)
+		return nil, fmt.Errorf("❌ ERROR: Failed to create dynamic Kubernetes client: %v", err)
+	}
+	resulted, err := dynamicClient.Resource(gvr).Namespace(namespace).Create(context.Background(), object, metav1.CreateOptions{})
+	if err != nil {
+		if errors.IsAlreadyExists(err) {
+			fmt.Printf("✅ Resource %q already exists\n", object.GetName())
+		}
+		return nil, fmt.Errorf("❌ Failed to create resource: %v", err)
 	}
 
+	return resulted, nil
+}
+
+func (m GoAPI) ExecuteGet(gvr schema.GroupVersionResource, name string, namespace string) (*unstructured.Unstructured, error) {
+	dynamicClient, err := DynamicClient()
+	if err != nil {
+		return nil, fmt.Errorf("❌ ERROR: Failed to create dynamic Kubernetes client: %v", err)
+	}
+
+	return dynamicClient.Resource(gvr).Namespace(namespace).Get(context.Background(), name, metav1.GetOptions{})
+}
+
+func (m GoAPI) ExecuteDelete(path, namespace string) error {
+	fmt.Println("🔨 Deleting resources...", path)
+
 	if namespace == "" {
-		currentNamespace, err := m.GetNamespace()
+		currentNamespace, err := m.GetCurrentNamespace()
 		if err != nil {
 			return fmt.Errorf("❌ ERROR: Failed to get current namespace: %w", err)
 		}
@@ -136,22 +224,36 @@ func (m GoAPI) ExecuteDelete(path, namespace string) error {
 	if resources, err := ParseYamlFile(path); err != nil {
 		return fmt.Errorf("❌ ERROR: Failed to parse YAML file: %v", err)
 	} else {
-		deletePolicy := metav1.DeletePropagationForeground
 		for _, resource := range resources {
 			gvk := resource.GroupVersionKind()
 			gvr, _ := meta.UnsafeGuessKindToResource(gvk)
 
-			err = client.Resource(gvr).Namespace(namespace).Delete(context.Background(), resource.GetName(), metav1.DeleteOptions{
-				PropagationPolicy: &deletePolicy,
-			})
+			err := m.ExecuteDeleteGVR(gvr, resource.GetName(), namespace)
 			if err != nil {
-				return fmt.Errorf("❌ ERROR: Failed to delete Resource: %w", err)
+				return fmt.Errorf("❌ ERROR: Failed to delete resource: %v", err)
 			}
 		}
 	}
 	return nil
 }
 
+func (m GoAPI) ExecuteDeleteGVR(gvr schema.GroupVersionResource, name string, namespace string) error {
+	client, err := DynamicClient()
+	if err != nil {
+		return fmt.Errorf("❌ ERROR: Failed to create dynamic Kubernetes client: %v", err)
+	}
+
+	deletePolicy := metav1.DeletePropagationForeground
+	err = client.Resource(gvr).Namespace(namespace).Delete(context.Background(), name, metav1.DeleteOptions{
+		PropagationPolicy: &deletePolicy,
+	})
+
+	if err != nil {
+		return fmt.Errorf("❌ ERROR: Failed to delete Resource: %w", err)
+	}
+	return nil
+}
+
 func (m GoAPI) CheckCrdExists(crd string) error {
 	config, err := KubeRestConfig()
 	if err != nil {
@@ -173,7 +275,7 @@ func (m GoAPI) CheckCrdExists(crd string) error {
 
 func (m GoAPI) GetDeploymentStatus(namespace, deploymentName string) (v1.DeploymentStatus, error) {
 	if namespace == "" {
-		currentNamespace, err := m.GetNamespace()
+		currentNamespace, err := m.GetCurrentNamespace()
 		if err != nil {
 			return v1.DeploymentStatus{}, fmt.Errorf("❌ ERROR: Failed to get current namespace: %w", err)
 		}
@@ -189,7 +291,7 @@ func (m GoAPI) GetDeploymentStatus(namespace, deploymentName string) (v1.Deploym
 	if err != nil {
 		return v1.DeploymentStatus{}, fmt.Errorf("❌ ERROR: Failed to create k8s client: %v", err)
 	}
-	deployments, err := newConfig.AppsV1().Deployments("default").List(context.TODO(), metav1.ListOptions{
+	deployments, err := newConfig.AppsV1().Deployments(namespace).List(context.TODO(), metav1.ListOptions{
 		LabelSelector: fmt.Sprintf("sonataflow.org/workflow-app=%s", deploymentName),
 	})
 
@@ -210,7 +312,7 @@ func (m GoAPI) GetDeploymentStatus(namespace, deploymentName string) (v1.Deploym
 
 func (m GoAPI) PortForward(namespace, serviceName, portFrom, portTo string, onReady func()) error  {
 	if namespace == "" {
-		currentNamespace, err := m.GetNamespace()
+		currentNamespace, err := m.GetCurrentNamespace()
 		if err != nil {
 			return fmt.Errorf("❌ ERROR: Failed to get current namespace: %w", err)
 		}
@@ -249,7 +351,7 @@ func (m GoAPI) PortForward(namespace, serviceName, portFrom, portTo string, onRe
 	}
 
 	req := clientSet.CoreV1().RESTClient().Post().Resource("pods").Namespace(pods.Items[0].Namespace).
-								  Name(pods.Items[0].Name).SubResource("portforward")
+		Name(pods.Items[0].Name).SubResource("portforward")
 
 	transport, upgrader, err := spdy.RoundTripperFor(config)
 	if err != nil {
@@ -285,12 +387,30 @@ func (m GoAPI) PortForward(namespace, serviceName, portFrom, portTo string, onRe
 	return nil
 }
 
+func (m GoAPI) ExecuteList(gvr schema.GroupVersionResource, namespace string) (*unstructured.UnstructuredList, error) {
+	client, err := DynamicClient()
+	if err != nil {
+		return nil, fmt.Errorf("❌ ERROR: Failed to create dynamic Kubernetes client: %v", err)
+	}
+
+	list, err := client.Resource(gvr).Namespace(namespace).List(context.Background(), metav1.ListOptions{})
+	if err != nil {
+		return nil, fmt.Errorf("❌ ERROR: Failed to list resources: %v", err)
+	}
+
+	return list, nil
+}
+
 func KubeApiConfig() (*api.Config, error) {
 	homeDir, err := os.UserHomeDir()
 	if err != nil {
 		return nil, fmt.Errorf("error getting user home dir: %w", err)
 	}
 	kubeConfigPath := filepath.Join(homeDir, ".kube", "config")
+	if !kubeconfigInfoDisplayed {
+		fmt.Printf("🔎 Using kubeconfig: %s\n", kubeConfigPath)
+		kubeconfigInfoDisplayed = true
+	}
 	config, err := clientcmd.LoadFromFile(kubeConfigPath)
 	if err != nil {
 		return nil, fmt.Errorf("❌ ERROR: Failed to load kubeconfig: %w", err)
@@ -308,7 +428,7 @@ func KubeRestConfig() (*rest.Config, error) {
 		clientConfig := clientcmd.NewDefaultClientConfig(*kubeConfig, &clientcmd.ConfigOverrides{})
 		restConfig, err := clientConfig.ClientConfig()
 		if err != nil {
-			log.Fatalf("❌ Error converting to rest.Config: %v", err)
+			log.Fatalf("Error converting to rest.Config: %v", err)
 		}
 		return restConfig, nil
 	}
@@ -347,30 +467,43 @@ var ParseYamlFile = func(path string) ([]unstructured.Unstructured, error) {
 	return result, nil
 }
 
-var GetNamespace = func() (string, error) {
+var GetCurrentNamespace = func() (string, error) {
 	fmt.Println("🔎 Checking current namespace in k8s...")
 
 	config, err := KubeApiConfig()
 	if err != nil {
-		fmt.Println("❌ ERROR: Failed to get current k8s namespace: %w", err)
 		return "", fmt.Errorf("❌ ERROR: Failed to get current k8s namespace: %w", err)
 	}
+	namespace := config.Contexts[config.CurrentContext].Namespace
 
-	var namespace string
-
-	if contextes, ok := config.Contexts[config.CurrentContext]; !ok {
+	if len(namespace) == 0 {
 		namespace = "default"
-	} else {
-		if len(contextes.Namespace) == 0 {
-			namespace = "default"
-		} else {
-			namespace = contextes.Namespace
-		}
 	}
 	fmt.Printf(" - ✅  k8s current namespace: %s\n", namespace)
 	return namespace, nil
 }
 
+func parseResource(resource unstructured.Unstructured, namespace string) *unstructured.Unstructured {
+	gvk := resource.GroupVersionKind()
+	gvr, _ := meta.UnsafeGuessKindToResource(gvk)
+
+	sar := &unstructured.Unstructured{
+		Object: map[string]interface{}{
+			"apiVersion": "authorization.k8s.io/v1",
+			"kind":       "SelfSubjectAccessReview",
+			"spec": map[string]interface{}{
+				"resourceAttributes": map[string]interface{}{
+					"namespace": namespace,
+					"verb":      gvr.Version,
+					"group":     gvk.Group,
+					"resource":  gvr.Resource,
+				},
+			},
+		},
+	}
+	return sar
+}
+
 func doRollback(created []unstructured.Unstructured, applyNamespace string, client dynamic.Interface) error {
 	for _, r := range created {
 		gvk := r.GroupVersionKind()
diff --git a/packages/kn-plugin-workflow/pkg/common/kubectl.go b/packages/kn-plugin-workflow/pkg/common/kubectl.go
index ab549256905..780901d56b1 100644
--- a/packages/kn-plugin-workflow/pkg/common/kubectl.go
+++ b/packages/kn-plugin-workflow/pkg/common/kubectl.go
@@ -22,34 +22,73 @@ package common
 import (
 	"github.com/apache/incubator-kie-tools/packages/kn-plugin-workflow/pkg/common/k8sclient"
 	v1 "k8s.io/api/apps/v1"
+	corev1 "k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	"k8s.io/apimachinery/pkg/runtime/schema"
 )
 
 type K8sApi interface {
-	GetNamespace() (string, error)
+
+	IsCreateAllowed(resourcePath string, namespace string) (bool, error)
+	IsDeleteAllowed(resourcePath string, namespace string) error
+	GetCurrentNamespace() (string, error)
+	GetNamespace(namespace string) (*corev1.Namespace, error)
 	CheckContext() (string, error)
-	ExecuteApply(crd, namespace string) error
-	ExecuteDelete(crd, namespace string) error
-	CheckCrdExists(crd string) error
+	ExecuteApply(path, namespace string) error
+	ExecuteCreate(gvr schema.GroupVersionResource, object *unstructured.Unstructured, namespace string) (*unstructured.Unstructured, error)
+	ExecuteDelete(path, namespace string) error
+	ExecuteDeleteGVR(gvr schema.GroupVersionResource, name string, namespace string) error
+	ExecuteGet(gvr schema.GroupVersionResource, name string, namespace string) (*unstructured.Unstructured, error)
+	ExecuteList(gvr schema.GroupVersionResource, namespace string) (*unstructured.UnstructuredList, error)
+	CheckCrdExists(path string) error
 	GetDeploymentStatus(namespace, deploymentName string) (v1.DeploymentStatus, error)
 	PortForward(namespace, serviceName, portFrom, portTo string, onReady func()) error
 }
 
 var Current K8sApi = k8sclient.GoAPI{}
 
+func IsCreateAllowed(resourcePath string, namespace string) (bool, error) {
+	return Current.IsCreateAllowed(resourcePath, namespace)
+}
+
+func IsDeleteAllowed(name string, namespace string) error {
+	return Current.IsDeleteAllowed(name, namespace)
+}
+
 func CheckContext() (string, error) {
-	return Current.GetNamespace()
+	return Current.GetCurrentNamespace()
+}
+
+func GetCurrentNamespace() (string, error) {
+	return Current.GetCurrentNamespace()
+}
+
+func GetNamespace(namespace string) (*corev1.Namespace, error)  {
+	return Current.GetNamespace(namespace)
+}
+
+var ExecuteApply = func(path, namespace string) error {
+	return Current.ExecuteApply(path, namespace)
+}
+
+func ExecuteCreate(gvr schema.GroupVersionResource, object *unstructured.Unstructured, namespace string) (*unstructured.Unstructured, error) {
+	return Current.ExecuteCreate(gvr, object, namespace)
+}
+
+func ExecuteDelete(path, namespace string) error {
+	return Current.ExecuteDelete(path, namespace)
 }
 
-func GetNamespace() (string, error) {
-	return Current.GetNamespace()
+func ExecuteDeleteGVR(gvr schema.GroupVersionResource, name string, namespace string) error {
+	return Current.ExecuteDeleteGVR(gvr, name, namespace)
 }
 
-var ExecuteApply = func(crd, namespace string) error {
-	return Current.ExecuteApply(crd, namespace)
+func ExecuteGet(gvr schema.GroupVersionResource, name string, namespace string) (*unstructured.Unstructured, error) {
+	return Current.ExecuteGet(gvr, name, namespace)
 }
 
-func ExecuteDelete(crd, namespace string) error {
-	return Current.ExecuteDelete(crd, namespace)
+func ExecuteList(gvr schema.GroupVersionResource, namespace string)(*unstructured.UnstructuredList, error)  {
+	return Current.ExecuteList(gvr, namespace)
 }
 
 func CheckCrdExists(crd string) error {
diff --git a/packages/kn-plugin-workflow/pkg/common/operator.go b/packages/kn-plugin-workflow/pkg/common/operator.go
index 5a92f31e393..8a6f27e873b 100644
--- a/packages/kn-plugin-workflow/pkg/common/operator.go
+++ b/packages/kn-plugin-workflow/pkg/common/operator.go
@@ -20,13 +20,22 @@
 package common
 
 import (
+	"context"
 	"fmt"
-	"github.com/apache/incubator-kie-tools/packages/kn-plugin-workflow/pkg/metadata"
-	"gopkg.in/yaml.v2"
 	"io"
+	"k8s.io/client-go/discovery"
+	"k8s.io/client-go/dynamic"
 	"os"
 	"path/filepath"
 	"strings"
+
+	"github.com/apache/incubator-kie-tools/packages/kn-plugin-workflow/pkg/common/k8sclient"
+	"github.com/apache/incubator-kie-tools/packages/kn-plugin-workflow/pkg/metadata"
+	"gopkg.in/yaml.v2"
+	"k8s.io/apimachinery/pkg/api/errors"
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	"k8s.io/apimachinery/pkg/runtime/schema"
 )
 
 type Document struct {
@@ -36,6 +45,78 @@ type Document struct {
 	} `yaml:"metadata"`
 }
 
+var namespacesGVR = schema.GroupVersionResource{
+	Group:    "",
+	Version:  "v1",
+	Resource: "namespaces",
+}
+
+var sonataflowGVR = schema.GroupVersionResource{
+	Group:    "sonataflow.org",
+	Version:  "v1alpha08",
+	Resource: "sonataflows",
+}
+
+var subscriptionsGVR = schema.GroupVersionResource{
+	Group:    "operators.coreos.com",
+	Version:  "v1alpha1",
+	Resource: "subscriptions",
+}
+
+var clusterServiceVersionsGVR = schema.GroupVersionResource{
+	Group:    "operators.coreos.com",
+	Version:  "v1alpha1",
+	Resource: "clusterserviceversions",
+}
+
+var customResourceDefinitionsGVR = schema.GroupVersionResource{
+	Group:    "apiextensions.k8s.io",
+	Version:  "v1",
+	Resource: "customresourcedefinitions",
+}
+
+var catalogSourcesGVR = schema.GroupVersionResource{
+	Group:    "operators.coreos.com",
+	Version:  "v1alpha1",
+	Resource: "catalogsources",
+}
+
+type OperatorManager struct {
+	namespace     string
+	isOpenshift   bool
+	dynamicClient dynamic.Interface
+}
+
+var openshiftOperatorNamespaces = []string{"openshift-operators", "community-operators"}
+
+func NewOperatorManager(namespace string) *OperatorManager {
+	isOpenshift, err := isOpenshift()
+	if err != nil {
+		fmt.Printf("❌ ERROR: %v\n", err)
+		os.Exit(1)
+	}
+
+	if namespace == "" {
+		namespace, err = guessOperatorNamespace(isOpenshift)
+		if err != nil {
+			fmt.Printf("❌ ERROR: %v\n", err)
+			os.Exit(1)
+		}
+	}
+
+	dynamicClient, err := k8sclient.DynamicClient()
+	if err != nil {
+		fmt.Printf("❌ ERROR: %v\n", err)
+		os.Exit(1)
+	}
+
+	return &OperatorManager{
+		namespace:     namespace,
+		isOpenshift:   isOpenshift,
+		dynamicClient: dynamicClient,
+	}
+}
+
 func checkOperatorRunning(getPodsOutPut string) bool {
 	pods := strings.Split(getPodsOutPut, "\n")
 	for _, pod := range pods {
@@ -91,3 +172,283 @@ func FindServiceFiles(directory string) ([]string, error) {
 
 	return serviceFiles, nil
 }
+
+func (m OperatorManager) CheckOLMInstalled() error {
+	resources, err := m.dynamicClient.Resource(catalogSourcesGVR).List(context.Background(), v1.ListOptions{})
+	if err != nil {
+		return fmt.Errorf("❌ ERROR: OLM (Operator Lifecycle Manager) isn't installed, install OLM first : %v\n", err)
+	}
+	var operatorSources []string
+
+	if m.isOpenshift {
+		operatorSources = append(operatorSources, openshiftOperatorNamespaces...)
+	} else {
+		operatorSources = append(operatorSources, "operatorhubio-catalog")
+	}
+
+	for _, resource := range resources.Items {
+		name, found, err := unstructured.NestedString(resource.Object, "metadata", "name")
+		namespace, found, err := unstructured.NestedString(resource.Object, "metadata", "namespace")
+		if err != nil || !found {
+			continue
+		}
+		for _, operatorSource := range operatorSources {
+			if name == operatorSource && metadata.OLMCatalogSourcesMap[name] == namespace {
+				return nil
+			}
+		}
+	}
+
+	return fmt.Errorf("❌ ERROR: OLM (Operator Lifecycle Manager) is not installed. Please install OLM before installing the SonataFlow Operator.")
+}
+
+func (m OperatorManager) InstallSonataflowOperator() error {
+	var source string
+	var sourceNamespace string
+
+	if m.isOpenshift {
+		source = "community-operators"
+		sourceNamespace = "openshift-marketplace"
+	} else {
+		source = "operatorhubio-catalog"
+		sourceNamespace = "olm"
+	}
+
+	subscriptionUnstructured := &unstructured.Unstructured{
+		Object: map[string]interface{}{
+			"apiVersion": "operators.coreos.com/v1alpha1",
+			"kind":       "Subscription",
+			"metadata": map[string]interface{}{
+				"name":      metadata.SonataFlowOperatorName,
+				"namespace": m.namespace,
+			},
+			"spec": map[string]interface{}{
+				"channel":         "alpha",
+				"name":            "sonataflow-operator",
+				"source":          source,
+				"sourceNamespace": sourceNamespace,
+			},
+		},
+	}
+
+	_, err := ExecuteCreate(subscriptionsGVR, subscriptionUnstructured, m.namespace)
+	if err != nil {
+		return fmt.Errorf("❌ Failed to create subscription: %v", err)
+	}
+	fmt.Println("✅ Subscription created successfully")
+
+	return nil
+}
+
+func (m OperatorManager) GetSonataflowOperatorStats() error {
+	subscription, err := ExecuteGet(subscriptionsGVR, metadata.SonataFlowOperatorName, m.namespace)
+	if err != nil {
+		return fmt.Errorf("❌ SonataFlow Operator is not installed.")
+	}
+
+	status, found, err := unstructured.NestedMap(subscription.Object, "status")
+	if err != nil {
+		return fmt.Errorf("error getting status: %v", err)
+	}
+	if !found {
+		return fmt.Errorf("status not found in subscription")
+	}
+
+	currentCSV, _, _ := unstructured.NestedString(status, "currentCSV")
+	installedCSV, _, _ := unstructured.NestedString(status, "installedCSV")
+	state, _, _ := unstructured.NestedString(status, "state")
+
+	fmt.Println()
+	fmt.Println("📊 Subscription Status:")
+	fmt.Println()
+
+	fmt.Printf("Current CSV: %s\n", currentCSV)
+	fmt.Printf("Installed CSV: %s\n", installedCSV)
+	fmt.Printf("State: %s\n", state)
+
+	conditions, exists, _ := unstructured.NestedSlice(status, "conditions")
+	if exists {
+		fmt.Println()
+		fmt.Printf("Conditions:\n")
+		for _, c := range conditions {
+			condition := c.(map[string]interface{})
+			fmt.Printf("Type: %s\n", condition["type"])
+			fmt.Printf("Status: %s\n", condition["status"])
+			fmt.Printf("Message: %s\n", condition["message"])
+			fmt.Printf("Last Transition Time: %s\n\n", condition["lastTransitionTime"])
+		}
+	}
+
+	return nil
+}
+
+func (m OperatorManager) RemoveSubscription() error {
+	fmt.Println("🔧 Deleting the SonataFlow Operator subscription...")
+
+	err := ExecuteDeleteGVR(subscriptionsGVR, metadata.SonataFlowOperatorName, m.namespace)
+	if err != nil {
+		return fmt.Errorf("❌ Failed to delete subscription `sonataflow-operator` in namespace %s: %v\n", m.namespace, err)
+	}
+	fmt.Printf("✅ Subscription `sonataflow-operator` deleted successfully in namespace %s\n", m.namespace)
+
+	return nil
+}
+
+func (m OperatorManager) RemoveCSV() error {
+	resources, err := ExecuteList(clusterServiceVersionsGVR, m.namespace)
+	if err != nil {
+		return fmt.Errorf("❌ ERROR: failed to get CSV resources: %v", err)
+	}
+	for _, resource := range resources.Items {
+		name, found, err := unstructured.NestedString(resource.Object, "metadata", "name")
+		if err != nil || !found {
+			continue
+		}
+		if strings.HasPrefix(name, metadata.SonataFlowOperatorName) {
+			err := ExecuteDeleteGVR(clusterServiceVersionsGVR, name, m.namespace)
+			if err != nil {
+				return fmt.Errorf("❌ ERROR: Failed to delete CSV `sonataflow-operator` in namespace %s: %v\n", m.namespace, err)
+			}
+			fmt.Printf("✅ CSV `sonataflow-operator` deleted successfully in namespace %s\n", m.namespace)
+			return nil
+		}
+	}
+	return fmt.Errorf("❌ ERROR: CSV `sonataflow-operator` not found in namespace %s\n", m.namespace)
+}
+
+func (m OperatorManager) ListOperatorResources() ([]unstructured.Unstructured, error) {
+	resources, err := m.dynamicClient.Resource(clusterServiceVersionsGVR).List(context.Background(), v1.ListOptions{})
+	if err != nil {
+		return nil, fmt.Errorf("❌ ERROR: Failed to list resources: %v", err)
+	}
+
+	if len(resources.Items) == 0 {
+		return nil, fmt.Errorf("❌ No resources found")
+	}
+	var result []unstructured.Unstructured
+	for _, csv := range resources.Items {
+		if strings.HasPrefix(csv.GetName(), metadata.SonataFlowOperatorName) {
+			result = append(result, csv)
+		}
+	}
+	return result, nil
+}
+
+func (m OperatorManager) RemoveCRD() error {
+	subscription, err := ExecuteGet(subscriptionsGVR, metadata.SonataFlowOperatorName, m.namespace)
+	if err != nil {
+		return fmt.Errorf("failed to get subscription %s: %v", metadata.SonataFlowOperatorName, err)
+	}
+
+	installedCSV, found, err := unstructured.NestedString(subscription.Object, "status", "installedCSV")
+	if err != nil || !found {
+		return fmt.Errorf("failed to extract installedCSV from subscription: %v", err)
+	}
+
+	csvObj, err := ExecuteGet(clusterServiceVersionsGVR, installedCSV, m.namespace)
+	if err != nil {
+		return fmt.Errorf("❌ Failed to get CSV %q in namespace %q: %v", installedCSV, m.namespace, err)
+	}
+
+	ownedCRDs, found, err := unstructured.NestedSlice(csvObj.Object,
+		"spec", "customresourcedefinitions", "owned")
+	if err != nil {
+		return fmt.Errorf("❌ Failed to extract owned CRDs: %v", err)
+	}
+	if !found {
+		fmt.Println("✅ No owned CRDs found in CSV")
+		return nil
+	}
+
+	for _, crdRaw := range ownedCRDs {
+		crdMap, ok := crdRaw.(map[string]interface{})
+		if !ok {
+			continue
+		}
+		crdName, _, _ := unstructured.NestedString(crdMap, "name")
+		crdKind, _, _ := unstructured.NestedString(crdMap, "kind")
+		crdVersion, _, _ := unstructured.NestedString(crdMap, "version")
+
+		fmt.Printf("✅ CRD Name: %s, Kind: %s, Version: %s\n", crdName, crdKind, crdVersion)
+
+		err := ExecuteDeleteGVR(customResourceDefinitionsGVR, crdName, "")
+		if err != nil {
+			return fmt.Errorf("❌ ERROR: Failed to delete CRD %q: %v\n", crdName, err)
+		}
+		fmt.Printf("✅ CRD %q deleted\n", crdName)
+	}
+	return nil
+}
+
+func (m OperatorManager) RemoveCR() error {
+	namespaces, err := ExecuteList(namespacesGVR, "")
+	if err != nil {
+		return fmt.Errorf("❌ Failed to list resources in namespace: %v", err)
+	}
+
+	for _, ns := range namespaces.Items {
+		namespace := ns.GetName()
+
+		sonataflows, err := ExecuteList(sonataflowGVR, namespace)
+		if err != nil {
+			if !errors.IsNotFound(err) && !errors.IsForbidden(err) {
+				return fmt.Errorf("❌ Error listing sonataflows in namespace %s: %v\n", namespace, err)
+			}
+			continue
+		}
+
+		if len(sonataflows.Items) > 0 {
+			for _, deployment := range sonataflows.Items {
+				name := deployment.GetName()
+				err := ExecuteDeleteGVR(sonataflowGVR, name, namespace)
+				if err != nil {
+					return fmt.Errorf("❌ Failed to delete %s: %v\n", name, err)
+				} else {
+					fmt.Printf("✅ Deleted %s successfully\n", name)
+				}
+			}
+		}
+	}
+
+	return nil
+}
+
+func isOpenshift() (bool, error) {
+	dynamicConfig, err := k8sclient.KubeRestConfig()
+	if err != nil {
+		return false, fmt.Errorf("❌ ERROR: Failed to create dynamic Kubernetes client: %v", err)
+	}
+
+	discoveryClient, err := discovery.NewDiscoveryClientForConfig(dynamicConfig)
+	if err != nil {
+		return false, err
+	}
+
+	apiGroups, err := discoveryClient.ServerGroups()
+	if err != nil {
+		return false, fmt.Errorf("❌ ERROR: Failed to discover server groups: %v", err)
+	}
+
+	for _, group := range apiGroups.Groups {
+		if group.Name == "route.openshift.io" {
+			return true, nil
+		}
+	}
+	return false, nil
+}
+
+var possibleOpenshiftNamespaces = []string{"openshift-operators", "community-operators"}
+
+func guessOperatorNamespace(isOpenshift bool) (string, error) {
+	if isOpenshift {
+		for _, ns := range possibleOpenshiftNamespaces {
+			if _, err := GetNamespace(ns); err == nil {
+				return ns, nil
+			}
+		}
+	} else {
+		// In case of Minikube or Kind, with default OLM installation, the namespace is "operators"
+		return "operators", nil
+	}
+	return "", fmt.Errorf("❌ ERROR: No valid namespace found for the Operator, please provide a namespace with the --namespace flag")
+}
diff --git a/packages/kn-plugin-workflow/pkg/metadata/constants.go b/packages/kn-plugin-workflow/pkg/metadata/constants.go
index 37d9284e796..871bdd087e4 100644
--- a/packages/kn-plugin-workflow/pkg/metadata/constants.go
+++ b/packages/kn-plugin-workflow/pkg/metadata/constants.go
@@ -49,9 +49,15 @@ var KogitoDependencies = []Dependency{
 }
 
 // requared crds for sonataflow
-var SonataflowCRDs = []string{"sonataflowbuilds.sonataflow.org", "sonataflowclusterplatforms.sonataflow.org", "sonataflowplatforms.sonataflow.org", "sonataflows.sonataflow.org"}
+var SonataflowCRDs = []string{"sonataflows.sonataflow.org", "sonataflowbuilds.sonataflow.org", "sonataflowplatforms.sonataflow.org"}
 var KnativeCoreServingCRDs = []string{"images.caching.internal.knative.dev", "certificates.networking.internal.knative.dev", "configurations.serving.knative.dev", "clusterdomainclaims.networking.internal.knative.dev", "domainmappings.serving.knative.dev", "ingresses.networking.internal.knative.dev", "metrics.autoscaling.internal.knative.dev", "podautoscalers.autoscaling.internal.knative.dev", "revisions.serving.knative.dev", "routes.serving.knative.dev", "services.serving.knative.dev", " [...]
 
+// OLM CatalogSources
+var OLMCatalogSourcesMap = map[string]string{"operatorhubio-catalog": "olm", "community-operators": "openshift-marketplace"}
+
+var SonataFlowOperatorName = "sonataflow-operator"
+
+
 const (
 	QuarkusMavenPlugin                          = "quarkus-maven-plugin"
 	QuarkusKubernetesExtension                  = "quarkus-kubernetes"
diff --git a/packages/kn-plugin-workflow/pkg/openshift/operation.go b/packages/kn-plugin-workflow/pkg/openshift/operation.go
new file mode 100644
index 00000000000..991d3863288
--- /dev/null
+++ b/packages/kn-plugin-workflow/pkg/openshift/operation.go
@@ -0,0 +1,51 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package openshift
+
+import (
+	"fmt"
+	"github.com/apache/incubator-kie-tools/packages/kn-plugin-workflow/pkg/common"
+)
+
+func CheckOCInstalled() error {
+	fmt.Println("✅ Checking if Openshift CLI installed...")
+	ocCheck := common.ExecCommand("oc", "version")
+	err := ocCheck.Run()
+	if err != nil {
+		fmt.Println("ERROR: Openshift CLI not found.")
+		return fmt.Errorf("rror while checking if Openshift CLI is installed: %w", err)
+	}
+	return nil
+}
+
+func CheckPermissions() error {
+	fmt.Println("✅ Checking permissions...")
+	namespace := "sonataflow-operator-system"
+	checkPermissions := common.ExecCommand("oc", "auth", "can-i", "create", "subscription", "-n", namespace)
+	result, err := checkPermissions.CombinedOutput()
+	if err != nil {
+		return fmt.Errorf("error while checking permissions: %w", err)
+	}
+	if string(result) != "yes\n" {
+		return fmt.Errorf("you don't have the required permissions to create a subscription in the namespace %s", namespace)
+	}
+
+	return nil
+}
\ No newline at end of file
diff --git a/packages/kn-plugin-workflow/pkg/root/root.go b/packages/kn-plugin-workflow/pkg/root/root.go
index 343b9ecab6e..be2aed47d5e 100644
--- a/packages/kn-plugin-workflow/pkg/root/root.go
+++ b/packages/kn-plugin-workflow/pkg/root/root.go
@@ -21,6 +21,7 @@ package root
 
 import (
 	"fmt"
+	"github.com/apache/incubator-kie-tools/packages/kn-plugin-workflow/pkg/command/operator"
 	"github.com/apache/incubator-kie-tools/packages/kn-plugin-workflow/pkg/command/specs"
 
 	"github.com/apache/incubator-kie-tools/packages/kn-plugin-workflow/pkg/command/quarkus"
@@ -78,6 +79,7 @@ func NewRootCommand(cfg RootCmdConfig) *cobra.Command {
 	cmd.AddCommand(quarkus.NewQuarkusCommand())
 	cmd.AddCommand(command.NewVersionCommand(cfg.Version))
 	cmd.AddCommand(specs.SpecsCommand())
+	cmd.AddCommand(operator.NewOperatorCommand())
 
 	cmd.SetHelpFunc(func(cmd *cobra.Command, args []string) {
 		runRootHelp(cmd, args)
diff --git a/packages/kn-plugin-workflow/pkg/root/root_test.go b/packages/kn-plugin-workflow/pkg/root/root_test.go
index eb901e24f19..fd5a3f60d1c 100644
--- a/packages/kn-plugin-workflow/pkg/root/root_test.go
+++ b/packages/kn-plugin-workflow/pkg/root/root_test.go
@@ -50,6 +50,7 @@ func TestNewRootCommand(t *testing.T) {
 			"undeploy",
 			"gen-manifest",
 			"version",
+			"operator",
 		}
 
 		cmd := NewRootCommand(cfgTestInputRoot)


---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@kie.apache.org
For additional commands, e-mail: commits-help@kie.apache.org