Handle sessions and store_last_stdout in runnerv2service

internal/api/runme/runner/v2alpha1/runner.proto

@@ -107,9 +107,6 @@ message ExecuteRequest {
   // has no effect in non-interactive mode
   optional Winsize winsize = 10;
 
-  // background, if true, will send process' PID as a first response.
-  bool background = 11;
-
   // session_id indicates in which Session the program should execute.
   // Executing in a Session might provide additional context like
   // environment variables.
@@ -121,19 +118,9 @@ message ExecuteRequest {
   // project used to load environment variables from .env files.
   optional Project project = 22;
 
-  // store_last_output, if true, will store the stdout of
+  // store_last_stdout, if true, will store the stdout of
   // the last ran block in the environment variable `__`.
-  bool store_last_output = 23;
-
-  // language_id indicates a language to exeucute scripts/commands.
-  string language_id = 25;
-
-  // file_extension is associated with the script.
-  string file_extension = 26;
-}
-
-message ProcessPID {
-  int64 pid = 1;
+  bool store_last_stdout = 23;
 }
 
 message ExecuteResponse {
@@ -149,7 +136,7 @@ message ExecuteResponse {
   // pid contains the process' PID.
   // This is only sent once in an initial response
   // for background processes.
-  ProcessPID pid = 4;
+  google.protobuf.UInt32Value pid = 4;
 }
 
 service RunnerService {

internal/cmd/server.go

@@ -94,9 +94,11 @@ The kernel is used to run long running processes like shells and interacting wit
 
 			logger.Info("started listening", zap.String("addr", lis.Addr().String()))
 
+			const maxMsgSize = 4 * 1024 * 1024 // 4 MiB
+
 			server := grpc.NewServer(
-				grpc.MaxRecvMsgSize(runner.MaxMsgSize),
-				grpc.MaxSendMsgSize(runner.MaxMsgSize),
+				grpc.MaxRecvMsgSize(maxMsgSize),
+				grpc.MaxSendMsgSize(maxMsgSize),
 			)
 			parserv1.RegisterParserServiceServer(server, editorservice.NewParserServiceServer(logger))
 			projectv1.RegisterProjectServiceServer(server, projectservice.NewProjectServiceServer(logger))

internal/command/command_exec_normalizer.go

@@ -20,10 +20,10 @@ const (
 	envEndFileName   = ".env_end"
 )
 
-// envDumpCommand is a command that dumps the environment variables.
+// EnvDumpCommand is a command that dumps the environment variables.
 // It is declared as a var, because it must be replaced in tests.
 // Equivalent is `env -0`.
-var envDumpCommand = func() string {
+var EnvDumpCommand = func() string {
 	path, err := os.Executable()
 	if err != nil {
 		panic(errors.WithMessage(err, "failed to get the executable path"))
@@ -59,7 +59,7 @@ func (n *argsNormalizer) Normalize(cfg *Config) (*Config, error) {
 				if err := n.createTempDir(); err != nil {
 					return nil, err
 				}
-				_, _ = buf.WriteString(fmt.Sprintf("%s > %s\n", envDumpCommand, filepath.Join(n.tempDir, envStartFileName)))
+				_, _ = buf.WriteString(fmt.Sprintf("%s > %s\n", EnvDumpCommand, filepath.Join(n.tempDir, envStartFileName)))
 			}
 		}
 
@@ -74,7 +74,7 @@ func (n *argsNormalizer) Normalize(cfg *Config) (*Config, error) {
 
 		if isShellLanguage(filepath.Base(cfg.ProgramName)) {
 			if n.session != nil {
-				_, _ = buf.WriteString(fmt.Sprintf("%s > %s\n", envDumpCommand, filepath.Join(n.tempDir, envEndFileName)))
+				_, _ = buf.WriteString(fmt.Sprintf("%s > %s\n", EnvDumpCommand, filepath.Join(n.tempDir, envEndFileName)))
 
 				n.isEnvCollectable = true
 			}

internal/command/command_native_test.go

@@ -51,17 +51,6 @@ func TestNativeCommand(t *testing.T) {
 		assert.Equal(t, "test", stdout.String())
 	})
 
-	t.Run("WithSession", func(t *testing.T) {
-		sess := NewSession()
-		opts := &NativeCommandOptions{
-			Session: sess,
-		}
-		cmd, err := NewNative(testConfigShellProgram, opts)
-		require.NoError(t, err)
-		require.NoError(t, cmd.Start(context.Background()))
-		require.NoError(t, cmd.Wait())
-	})
-
 	t.Run("DevStdin", func(t *testing.T) {
 		cmd, err := NewNative(testConfigShellProgram, &NativeCommandOptions{Stdin: os.Stdin})
 		require.NoError(t, err)

internal/command/command_test.go

@@ -36,7 +36,7 @@ var (
 )
 
 func init() {
-	envDumpCommand = "env -0"
+	EnvDumpCommand = "env -0"
 }
 
 func TestExecutionCommandFromCodeBlocks(t *testing.T) {

internal/command/command_virtual.go

@@ -105,19 +105,6 @@ func (c *VirtualCommand) Pid() int {
 	return c.cmd.Process.Pid
 }
 
-func (c *VirtualCommand) SetWinsize(rows, cols, x, y uint16) error {
-	if c.pty == nil {
-		return nil
-	}
-	err := pty.Setsize(c.pty, &pty.Winsize{
-		Rows: rows,
-		Cols: cols,
-		X:    x,
-		Y:    y,
-	})
-	return errors.WithStack(err)
-}
-
 func (c *VirtualCommand) Start(ctx context.Context) (err error) {
 	argsNormalizer := &argsNormalizer{
 		session: c.opts.Session,
@@ -280,6 +267,16 @@ func (c *VirtualCommand) cleanup() {
 	}
 }
 
+type Winsize pty.Winsize
+
+func SetWinsize(cmd *VirtualCommand, winsize *Winsize) error {
+	if cmd.pty == nil {
+		return nil
+	}
+	err := pty.Setsize(cmd.pty, (*pty.Winsize)(winsize))
+	return errors.WithStack(err)
+}
+
 func isNil(val any) bool {
 	if val == nil {
 		return true

internal/command/command_virtual_test.go

@@ -86,7 +86,7 @@ func TestVirtualCommand(t *testing.T) {
 		)
 		require.NoError(t, err)
 		require.NoError(t, cmd.Start(context.Background()))
-		require.NoError(t, cmd.SetWinsize(24, 80, 0, 0))
+		require.NoError(t, SetWinsize(cmd, &Winsize{Rows: 24, Cols: 80, X: 0, Y: 0}))
 		require.NoError(t, cmd.Wait())
 		require.Equal(t, "80\r\n24\r\n", stdout.String())
 	})

internal/command/env_store.go

@@ -1,21 +1,16 @@
 package command
 
 import (
-	"errors"
 	"strings"
 	"sync"
 
 	"golang.org/x/exp/slices"
 )
 
-// maxEnvironSize is a maximum limit of size of all env name and value pairs,
-// including equal sign and NUL in each pair.
-const maxEnvironSize = 32760
-
-func envPairSize(k, v string) int {
-	// +2 for the '=' and '\0' separators
-	return len(k) + len(v) + 2
-}
+// func envPairSize(k, v string) int {
+// 	// +2 for the '=' and '\0' separators
+// 	return len(k) + len(v) + 2
+// }
 
 type envStore struct {
 	mu    sync.RWMutex
@@ -39,18 +34,18 @@ func (s *envStore) Set(k, v string) (*envStore, error) {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 
-	environSize := envPairSize(k, v)
+	// environSize := envPairSize(k, v)
 
-	for key, value := range s.items {
-		if key == k {
-			continue
-		}
-		environSize += envPairSize(key, value)
-	}
+	// for key, value := range s.items {
+	// 	if key == k {
+	// 		continue
+	// 	}
+	// 	environSize += envPairSize(key, value)
+	// }
 
-	if environSize > maxEnvironSize {
-		return s, errors.New("could not set environment variable, environment size limit exceeded")
-	}
+	// if environSize > MaxEnvironSizInBytes {
+	// 	return s, errors.New("could not set environment variable, environment size limit exceeded")
+	// }
 
 	s.items[k] = v
 

internal/command/env_store_unix.go

@@ -0,0 +1,9 @@
+//go:build !windows
+
+package command
+
+// MaxEnvironSizInBytes is the maximum size of an environment variable
+// including equal sign and NUL separators.
+//
+// This size is an artificial limit as Linux and macOS do not have a real limit.
+const MaxEnvironSizInBytes = 128 * 1000 * 1000 // 128 MB

internal/command/env_store_windows.go

@@ -0,0 +1,7 @@
+//go:build windows
+
+package command
+
+// MaxEnvironSizInBytes is the maximum size of an environment variable
+// including equal sign and NUL separators.
+const MaxEnvironSizInBytes = 32767

internal/command/session.go

@@ -1,14 +1,24 @@
 package command
 
+import (
+	"sync"
+
+	lru "github.com/hashicorp/golang-lru/v2"
+
+	"github.com/stateful/runme/internal/ulid"
+)
+
 // Session is an object which lifespan contains multiple executions.
 // It's used to exchange information between executions. Currently,
 // it only keeps track of environment variables.
 type Session struct {
+	ID       string
 	envStore *envStore
 }
 
 func NewSession() *Session {
 	return &Session{
+		ID:       ulid.GenerateID(),
 		envStore: newEnvStore(),
 	}
 }
@@ -38,3 +48,59 @@ func (s *Session) GetEnv() []string {
 	}
 	return s.envStore.Items()
 }
+
+// SessionListCapacity is a maximum number of sessions
+// stored in a single SessionList.
+const SessionListCapacity = 1024
+
+type SessionList struct {
+	items *lru.Cache[string, *Session]
+	// Even though, the lry.Cache is thread-safe, it does not provide a way to
+	// get the most recent added session.
+	mu            sync.Mutex
+	latestSession *Session
+}
+
+func NewSessionList() (*SessionList, error) {
+	cache, err := lru.New[string, *Session](SessionListCapacity)
+	if err != nil {
+		return nil, err
+	}
+	return &SessionList{items: cache}, nil
+}
+
+func (sl *SessionList) Add(session *Session) {
+	sl.items.Add(session.ID, session)
+
+	sl.mu.Lock()
+	sl.latestSession = session
+	sl.mu.Unlock()
+}
+
+func (sl *SessionList) Get(id string) (*Session, bool) {
+	return sl.items.Get(id)
+}
+
+func (sl *SessionList) List() []*Session {
+	return sl.items.Values()
+}
+
+func (sl *SessionList) Delete(id string) bool {
+	ok := sl.items.Remove(id)
+	if !ok {
+		return ok
+	}
+
+	sl.mu.Lock()
+	if sl.latestSession != nil && sl.latestSession.ID == id {
+		keys := sl.items.Keys()
+		sl.latestSession, _ = sl.items.Get(keys[len(keys)-1])
+	}
+	sl.mu.Unlock()
+
+	return ok
+}
+
+func (sl *SessionList) Newest() (*Session, bool) {
+	return sl.latestSession, sl.latestSession != nil
+}