Added state-mcp

.github/workflows/build.yml

@@ -171,6 +171,10 @@ jobs:
             {
                 "ID": "Build-Executor",
                 "Args": ["state", "run", "build-exec"]
+            },
+            {
+                "ID": "Build-MCP",
+                "Args": ["state", "run", "build-mcp"]
             }
           ]
           EOF
@@ -226,6 +230,11 @@ jobs:
         shell: bash
         run: parallelize results Build-Executor
 
+      - # === "Build: MCP" ===
+        name: "Build: MCP"
+        shell: bash
+        run: parallelize results Build-MCP
+
       - # === Prepare Windows Cert ===
         name: Prepare Windows Cert
         shell: bash
@@ -246,6 +255,7 @@ jobs:
           signtool.exe sign -d "ActiveState State Service" -f "Cert.p12" -p ${CODE_SIGNING_PASSWD} ./build/state-svc.exe
           signtool.exe sign -d "ActiveState State Installer" -f "Cert.p12" -p ${CODE_SIGNING_PASSWD} ./build/state-installer.exe
           signtool.exe sign -d "ActiveState State Tool Remote Installer" -f "Cert.p12" -p ${CODE_SIGNING_PASSWD} ./build/state-remote-installer.exe
+          signtool.exe sign -d "ActiveState State MCP" -f "Cert.p12" -p ${CODE_SIGNING_PASSWD} ./build/state-mcp.exe
         env:
           CODE_SIGNING_PASSWD: ${{ secrets.CODE_SIGNING_PASSWD }}
 

activestate.windows.yaml

@@ -7,6 +7,8 @@ constants:
     value: state-exec.exe
   - name: BUILD_INSTALLER_TARGET
     value: state-installer.exe
+  - name: BUILD_MCP_TARGET
+    value: state-mcp.exe
   - name: SVC_BUILDFLAGS
     value: -ldflags="-s -w -H=windowsgui"
   - name: SCRIPT_EXT

activestate.yaml

@@ -10,6 +10,8 @@ constants:
     value: ./cmd/state-installer
   - name: EXECUTOR_PKGS
     value: ./cmd/state-exec
+  - name: MCP_PKGS
+    value: ./cmd/state-mcp
   - name: BUILD_TARGET_PREFIX_DIR
     value: ./build
   - name: BUILD_TARGET
@@ -29,6 +31,9 @@ constants:
     value: state-installer
   - name: BUILD_REMOTE_INSTALLER_TARGET
     value: state-remote-installer
+  - name: BUILD_MCP_TARGET
+    if: ne .OS.Name "Windows"
+    value: state-mcp
   - name: INTEGRATION_TEST_REGEX
     value: 'integration\|automation'
   - name: SET_ENV
@@ -104,7 +109,9 @@ scripts:
         go generate
         popd > /dev/null
       fi
-      go build -tags "$GO_BUILD_TAGS" -o $BUILD_TARGET_DIR/$constants.BUILD_TARGET $constants.CLI_BUILDFLAGS $constants.CLI_PKGS
+      TARGET=$BUILD_TARGET_DIR/$constants.BUILD_TARGET
+      echo "Building $TARGET"
+      go build -tags "$GO_BUILD_TAGS" -o $TARGET $constants.CLI_BUILDFLAGS $constants.CLI_PKGS
   - name: build-svc
     language: bash
     standalone: true
@@ -119,16 +126,29 @@ scripts:
         go generate
         popd > /dev/null
       fi
-      go build -tags "$GO_BUILD_TAGS" -o $BUILD_TARGET_DIR/$constants.BUILD_DAEMON_TARGET $constants.SVC_BUILDFLAGS $constants.DAEMON_PKGS
+      TARGET=$BUILD_TARGET_DIR/$constants.BUILD_DAEMON_TARGET
+      echo "Building $TARGET"
+      go build -tags "$GO_BUILD_TAGS" -o $TARGET $constants.SVC_BUILDFLAGS $constants.DAEMON_PKGS
   - name: build-exec
     description: Builds the State Executor application
     language: bash
     standalone: true
     value: |
       set -e
       $constants.SET_ENV
-
-      go build -tags "$GO_BUILD_TAGS" -o $BUILD_TARGET_DIR/$constants.BUILD_EXEC_TARGET $constants.CLI_BUILDFLAGS $constants.EXECUTOR_PKGS
+      TARGET=$BUILD_TARGET_DIR/$constants.BUILD_EXEC_TARGET
+      echo "Building $TARGET"
+      go build -tags "$GO_BUILD_TAGS" -o $TARGET $constants.CLI_BUILDFLAGS $constants.EXECUTOR_PKGS
+  - name: build-mcp
+    description: Builds the State MCP application
+    language: bash
+    standalone: true
+    value: |
+      set -e
+      $constants.SET_ENV
+      TARGET=$BUILD_TARGET_DIR/$constants.BUILD_MCP_TARGET
+      echo "Building $TARGET"
+      go build -tags "$GO_BUILD_TAGS" -o $TARGET $constants.CLI_BUILDFLAGS $constants.MCP_PKGS
   - name: build-all
     description: Builds all our tools
     language: bash
@@ -145,6 +165,8 @@ scripts:
       $scripts.build-svc.path()
       echo "Building State Executor"
       $scripts.build-exec.path()
+      echo "Building State MCP"
+      $scripts.build-mcp.path()
   - name: build-installer
     language: bash
     standalone: true

cmd/state-installer/cmd.go

@@ -475,11 +475,7 @@ func storeInstallSource(installSource string) {
 		installSource = "state-installer"
 	}
 
-	appData, err := storage.AppDataPath()
-	if err != nil {
-		multilog.Error("Could not store install source due to AppDataPath error: %s", errs.JoinMessage(err))
-		return
-	}
+	appData := storage.AppDataPath()
 	if err := fileutils.WriteFile(filepath.Join(appData, constants.InstallSourceFile), []byte(installSource)); err != nil {
 		multilog.Error("Could not store install source due to WriteFile error: %s", errs.JoinMessage(err))
 	}

cmd/state-mcp/internal/mcpserver/server.go

@@ -0,0 +1,74 @@
+package mcpserver
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/ActiveState/cli/internal/constants"
+	"github.com/ActiveState/cli/internal/errs"
+	"github.com/ActiveState/cli/internal/logging"
+	"github.com/ActiveState/cli/internal/primer"
+	"github.com/mark3labs/mcp-go/mcp"
+	"github.com/mark3labs/mcp-go/server"
+)
+
+type ToolHandlerFunc func(context.Context, *primer.Values, mcp.CallToolRequest) (*mcp.CallToolResult, error)
+
+// Handler wraps the MCP server and provides methods for adding tools and resources
+type Handler struct {
+	Server *server.MCPServer
+	primeGetter func() (*primer.Values, func() error, error)
+}
+
+func New(primeGetter func() (*primer.Values, func() error, error)) *Handler {
+	s := server.NewMCPServer(
+		constants.StateMCPCmd,
+		constants.VersionNumber,
+	)
+
+	mcpHandler := &Handler{
+		Server: s,
+		primeGetter: primeGetter,
+	}
+
+	return mcpHandler
+}
+
+func (m Handler) ServeStdio() error {
+	if err := server.ServeStdio(m.Server); err != nil {
+		logging.Error("Server error: %v\n", err)
+	}
+	return nil
+}
+
+// addResource adds a resource to the MCP server with error handling and logging
+func (m *Handler) AddResource(resource mcp.Resource, handler server.ResourceHandlerFunc) {
+	m.Server.AddResource(resource, func(ctx context.Context, request mcp.ReadResourceRequest) ([]mcp.ResourceContents, error) {
+		r, err := handler(ctx, request)
+		if err != nil {
+			logging.Error("%s: Error handling resource request: %v", resource.Name, err)
+			return nil, errs.Wrap(err, "Failed to handle resource request")
+		}
+		return r, nil
+	})
+}
+
+// addTool adds a tool to the MCP server with error handling and logging
+func (m *Handler) AddTool(tool mcp.Tool, handler ToolHandlerFunc) {
+	m.Server.AddTool(tool, func(ctx context.Context, request mcp.CallToolRequest) (r *mcp.CallToolResult, rerr error) {
+		p, closer, err := m.primeGetter()
+		if err != nil {
+			return nil, errs.Wrap(err, "Failed to get primer")
+		}
+		defer closer()
+		r, err = handler(ctx, p, request)
+		if err != nil {
+			logging.Error("%s: Error handling tool request: %v", tool.Name, errs.JoinMessage(err))
+			// Format all errors as a single string, so the client gets the full context
+			return nil, fmt.Errorf("%s: %s", tool.Name, errs.JoinMessage(err))
+		}
+		return r, nil
+	})
+}
+
+

cmd/state-mcp/internal/toolregistry/categories.go

@@ -0,0 +1,23 @@
+package toolregistry
+
+type ToolCategory string
+
+const (
+	ToolCategoryDebug ToolCategory = "debug"
+)
+
+type ToolCategories []ToolCategory
+
+func (c ToolCategories) String() []string {
+	result := []string{}
+	for _, category := range c {
+		result = append(result, string(category))
+	}
+	return result
+}
+
+func Categories() ToolCategories {
+	return ToolCategories{
+		ToolCategoryDebug,
+	}
+}

cmd/state-mcp/internal/toolregistry/registry.go

@@ -0,0 +1,56 @@
+package toolregistry
+
+import (
+	"context"
+	"slices"
+
+	"github.com/ActiveState/cli/internal/primer"
+	"github.com/mark3labs/mcp-go/mcp"
+)
+
+type Tool struct {
+	mcp.Tool
+	Category ToolCategory
+	Handler func(context.Context, *primer.Values, mcp.CallToolRequest) (*mcp.CallToolResult, error)
+}
+
+type Registry struct {
+	tools map[ToolCategory][]Tool
+}
+
+func New() *Registry {
+	r := &Registry{
+		tools: make(map[ToolCategory][]Tool),
+	}
+
+	r.RegisterTool(HelloWorldTool())
+
+	return r
+}
+
+func (r *Registry) RegisterTool(tool Tool) {
+	if _, ok := r.tools[tool.Category]; !ok {
+		r.tools[tool.Category] = []Tool{}
+	}
+	r.tools[tool.Category] = append(r.tools[tool.Category], tool)
+}
+
+func (r *Registry) GetTools(requestCategories ...string) []Tool {
+	if len(requestCategories) == 0 {
+		for _, category := range Categories() {
+			if category == ToolCategoryDebug {
+				// Debug must be explicitly requested
+				continue
+			}
+			requestCategories = append(requestCategories, string(category))
+		}
+	}
+	categories := Categories()
+	result := []Tool{}
+	for _, category := range categories {
+		if slices.Contains(requestCategories, string(category)) {
+			result = append(result, r.tools[category]...)
+		}
+	}
+	return result
+}

cmd/state-mcp/internal/toolregistry/tools.go

@@ -0,0 +1,40 @@
+package toolregistry
+
+import (
+	"context"
+	"strings"
+
+	"github.com/ActiveState/cli/internal/primer"
+	"github.com/ActiveState/cli/internal/runners/hello"
+	"github.com/mark3labs/mcp-go/mcp"
+)
+
+func HelloWorldTool() Tool {
+	return Tool{
+		Category: ToolCategoryDebug,
+		Tool: mcp.NewTool(
+			"hello",
+			mcp.WithDescription("Hello world tool"),
+			mcp.WithString("name", mcp.Required(), mcp.Description("The name to say hello to")),
+		),
+		Handler: func(ctx context.Context, p *primer.Values, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+			name, err := request.RequireString("name")
+			if err != nil {
+				return mcp.NewToolResultError(err.Error()), nil
+			}
+
+			runner := hello.New(p)
+			params := hello.NewParams()
+			params.Name = name
+
+			err = runner.Run(params)
+			if err != nil {
+				return mcp.NewToolResultError(err.Error()), nil
+			}
+
+			return mcp.NewToolResultText(
+				strings.Join(p.Output().History().Print, "\n"),
+			), nil
+		},
+	}
+}

cmd/state-mcp/main.go

@@ -0,0 +1,55 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"os"
+	"runtime/debug"
+	"strings"
+	"time"
+
+	"github.com/ActiveState/cli/cmd/state-mcp/internal/mcpserver"
+	"github.com/ActiveState/cli/cmd/state-mcp/internal/toolregistry"
+	"github.com/ActiveState/cli/internal/events"
+	"github.com/ActiveState/cli/internal/logging"
+)
+
+func main() {
+	defer func() {
+		logging.Debug("Exiting")
+		if r := recover(); r != nil {
+			logging.Error("Recovered from panic: %v", r)
+			fmt.Printf("Recovered from panic: %v, stack: %s\n", r, string(debug.Stack()))
+			os.Exit(1)
+		}
+	}()
+	defer func() {
+		if err := events.WaitForEvents(5*time.Second, logging.Close); err != nil {
+			logging.Warning("Failed waiting for events: %v", err)
+		}
+	}()
+
+	// Parse command line flags
+	rawFlag := flag.String("categories", "", "Comma separated list of categories to register tools for")
+	flag.Parse()
+
+	mcps := setupServer(strings.Split(*rawFlag, ",")...)
+
+	// Start the stdio server
+	logging.Info("Starting MCP server")
+	if err := mcps.ServeStdio(); err != nil {
+		logging.Error("Server error: %v\n", err)
+	}
+}
+
+func setupServer(categories ...string) *mcpserver.Handler {
+	mcps := mcpserver.New(newPrimer)
+
+	registry := toolregistry.New()
+	tools := registry.GetTools(categories...)
+	for _, tool := range tools {
+		mcps.AddTool(tool.Tool, tool.Handler)
+	}
+
+	return mcps
+}