cmd/internal: impl current and next

cmd/internal/current.go

@@ -0,0 +1,30 @@
+package internal
+
+import (
+	"fmt"
+
+	"github.com/getsavvyinc/savvy-cli/display"
+	"github.com/getsavvyinc/savvy-cli/server/run"
+	"github.com/spf13/cobra"
+)
+
+// currentCmd represents the current command
+var currentCmd = &cobra.Command{
+	Use:   "current",
+	Short: "Get the command to run",
+	Run: func(cmd *cobra.Command, args []string) {
+		ctx := cmd.Context()
+		cl, err := run.NewDefaultClient(ctx)
+		if err != nil {
+			display.ErrorWithSupportCTA(err)
+			return
+		}
+
+		curr := cl.CurrentCommand()
+		fmt.Printf("%s", curr)
+	},
+}
+
+func init() {
+	InternalCmd.AddCommand(currentCmd)
+}

cmd/internal/next.go

@@ -0,0 +1,45 @@
+package internal
+
+import (
+	"fmt"
+
+	"github.com/getsavvyinc/savvy-cli/display"
+	"github.com/getsavvyinc/savvy-cli/server/run"
+	"github.com/spf13/cobra"
+)
+
+// nextCmd represents the next command
+var nextCmd = &cobra.Command{
+	Use:    "next",
+	Hidden: true,
+	Short:  "Update runbook state to next step",
+	Run: func(cmd *cobra.Command, args []string) {
+		ctx := cmd.Context()
+		cl, err := run.NewDefaultClient(ctx)
+		if err != nil {
+			display.ErrorWithSupportCTA(err)
+			return
+		}
+
+		curr := cl.CurrentCommand()
+		if curr != executedCommand {
+			return
+		}
+
+		idx, err := cl.NextCommand()
+		if err != nil {
+			display.ErrorWithSupportCTA(err)
+			return
+		}
+
+		fmt.Printf("%d", idx)
+	},
+}
+
+var executedCommand string
+
+func init() {
+	InternalCmd.AddCommand(nextCmd)
+
+	nextCmd.Flags().StringVarP(&executedCommand, "cmd", "c", "", "previously executed command")
+}

cmd/setup/savvy.zsh

@@ -66,7 +66,7 @@ function __savvy_runbook_runner__() {
 
   if [[ "${SAVVY_CONTEXT}" == "run"  && "${SAVVY_NEXT_STEP}" -le "${#SAVVY_COMMANDS}" ]] ; then
     #next_step_idx=${SAVVY_NEXT_STEP}
-    cmd=$(savvy internal fetch)
+    cmd=$(savvy internal current)
     BUFFER="${cmd}"
     zle end-of-line  # Accept the line for editing
   fi

server/run/client.go

@@ -10,9 +10,9 @@ import (
 
 type Client interface {
 	server.ShutdownSender
-	NextCommand() error
+	NextCommand() (int, error)
 	PreviousCommand() error
-	FetchCommand() string
+	CurrentCommand() string
 }
 
 func NewDefaultClient(ctx context.Context) (Client, error) {
@@ -45,18 +45,27 @@ func (c *client) SendShutdown() error {
 	return json.NewEncoder(conn).Encode(data)
 }
 
-func (c *client) NextCommand() error {
+func (c *client) NextCommand() (int, error) {
 	conn, err := net.Dial("unix", c.socketPath)
 	if err != nil {
-		return err
+		return 0, err
 	}
 	defer conn.Close()
 
 	data := RunCommand{
 		Command: nextCommand,
 	}
 
-	return json.NewEncoder(conn).Encode(data)
+	if err := json.NewEncoder(conn).Encode(data); err != nil {
+		return 0, err
+	}
+
+	var response RunCommandIndexResponse
+	if err := json.NewDecoder(conn).Decode(&response); err != nil {
+		return 0, err
+	}
+
+	return response.Index, nil
 }
 
 func (c *client) PreviousCommand() error {
@@ -72,14 +81,14 @@ func (c *client) PreviousCommand() error {
 	return json.NewEncoder(conn).Encode(data)
 }
 
-func (c *client) FetchCommand() string {
+func (c *client) CurrentCommand() string {
 	conn, err := net.Dial("unix", c.socketPath)
 	if err != nil {
 		return err.Error()
 	}
 
 	data := RunCommand{
-		Command: fetchCommand,
+		Command: currentCommand,
 	}
 
 	if err := json.NewEncoder(conn).Encode(data); err != nil {

server/run/run.go

@@ -50,7 +50,7 @@ func WithLogger(logger *slog.Logger) Option {
 // cleanupSocket is an internal function.
 // It is the callers responsibility to ensure the socketPath exists.
 func cleanupSocket(socketPath string) error {
-	cl, err := server.NewClient(context.Background(), socketPath)
+	cl, err := NewClient(context.Background(), socketPath)
 	if err != nil {
 		return err
 	}
@@ -140,16 +140,23 @@ func (rs *RunServer) handleConnection(c net.Conn) {
 	rs.handleCommand(cmd, c)
 }
 
+type RunCommandIndexResponse struct {
+	Index int `json:"index"`
+}
+
 func (rs *RunServer) handleCommand(cmd string, c net.Conn) {
 	switch cmd {
 	case shutdownCommand:
 		rs.Close()
 	case nextCommand:
+		var resp RunCommandIndexResponse
 		rs.mu.Lock()
 		rs.currIndex++
 		if rs.currIndex >= len(rs.commands) {
 			rs.currIndex = len(rs.commands) - 1
 		}
+		resp.Index = rs.currIndex
+		json.NewEncoder(c).Encode(resp)
 		rs.mu.Unlock()
 	case previousCommand:
 		rs.mu.Lock()
@@ -158,7 +165,7 @@ func (rs *RunServer) handleCommand(cmd string, c net.Conn) {
 			rs.currIndex = 0
 		}
 		rs.mu.Unlock()
-	case fetchCommand:
+	case currentCommand:
 		rs.mu.Lock()
 		if rs.currIndex >= len(rs.commands) {
 			rs.currIndex = len(rs.commands) - 1
@@ -182,8 +189,8 @@ func (rs *RunServer) SocketPath() string {
 const (
 	shutdownCommand = "savvy shutdown"
 	nextCommand     = "savvy internal next"
-	previousCommand = "savvy internal prev"
-	fetchCommand    = "savvy internal fetch"
+	previousCommand = "savvy internal previous"
+	currentCommand  = "savvy internal current"
 )
 
 func (rc *RunCommand) IsShutdown() bool {