Port envd from e2b with internalized shared packages and Connect RPC

- Copy envd source from e2b-dev/infra, internalize shared dependencies
  into envd/internal/shared/ (keys, filesystem, id, smap, utils)
- Switch from gRPC to Connect RPC for all envd services
- Update module paths to git.omukk.dev/wrenn/{sandbox,sandbox/envd}
- Add proto specs (process, filesystem) with buf-based code generation
- Implement full envd: process exec, filesystem ops, port forwarding,
  cgroup management, MMDS integration, and HTTP API
- Update main module dependencies (firecracker SDK, pgx, goose, etc.)
- Remove placeholder .gitkeep files replaced by real implementations

envd/internal/services/cgroups/cgroup2.go

@@ -0,0 +1,127 @@
+package cgroups
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"golang.org/x/sys/unix"
+)
+
+type Cgroup2Manager struct {
+	cgroupFDs map[ProcessType]int
+}
+
+var _ Manager = (*Cgroup2Manager)(nil)
+
+type cgroup2Config struct {
+	rootPath     string
+	processTypes map[ProcessType]Cgroup2Config
+}
+
+type Cgroup2ManagerOption func(*cgroup2Config)
+
+func WithCgroup2RootSysFSPath(path string) Cgroup2ManagerOption {
+	return func(config *cgroup2Config) {
+		config.rootPath = path
+	}
+}
+
+func WithCgroup2ProcessType(processType ProcessType, path string, properties map[string]string) Cgroup2ManagerOption {
+	return func(config *cgroup2Config) {
+		if config.processTypes == nil {
+			config.processTypes = make(map[ProcessType]Cgroup2Config)
+		}
+		config.processTypes[processType] = Cgroup2Config{Path: path, Properties: properties}
+	}
+}
+
+type Cgroup2Config struct {
+	Path       string
+	Properties map[string]string
+}
+
+func NewCgroup2Manager(opts ...Cgroup2ManagerOption) (*Cgroup2Manager, error) {
+	config := cgroup2Config{
+		rootPath: "/sys/fs/cgroup",
+	}
+
+	for _, opt := range opts {
+		opt(&config)
+	}
+
+	cgroupFDs, err := createCgroups(config)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create cgroups: %w", err)
+	}
+
+	return &Cgroup2Manager{cgroupFDs: cgroupFDs}, nil
+}
+
+func createCgroups(configs cgroup2Config) (map[ProcessType]int, error) {
+	var (
+		results = make(map[ProcessType]int)
+		errs    []error
+	)
+
+	for procType, config := range configs.processTypes {
+		fullPath := filepath.Join(configs.rootPath, config.Path)
+		fd, err := createCgroup(fullPath, config.Properties)
+		if err != nil {
+			errs = append(errs, fmt.Errorf("failed to create %s cgroup: %w", procType, err))
+
+			continue
+		}
+		results[procType] = fd
+	}
+
+	if len(errs) > 0 {
+		for procType, fd := range results {
+			err := unix.Close(fd)
+			if err != nil {
+				errs = append(errs, fmt.Errorf("failed to close cgroup fd for %s: %w", procType, err))
+			}
+		}
+
+		return nil, errors.Join(errs...)
+	}
+
+	return results, nil
+}
+
+func createCgroup(fullPath string, properties map[string]string) (int, error) {
+	if err := os.MkdirAll(fullPath, 0o755); err != nil {
+		return -1, fmt.Errorf("failed to create cgroup root: %w", err)
+	}
+
+	var errs []error
+	for name, value := range properties {
+		if err := os.WriteFile(filepath.Join(fullPath, name), []byte(value), 0o644); err != nil {
+			errs = append(errs, fmt.Errorf("failed to write cgroup property: %w", err))
+		}
+	}
+	if len(errs) > 0 {
+		return -1, errors.Join(errs...)
+	}
+
+	return unix.Open(fullPath, unix.O_RDONLY, 0)
+}
+
+func (c Cgroup2Manager) GetFileDescriptor(procType ProcessType) (int, bool) {
+	fd, ok := c.cgroupFDs[procType]
+
+	return fd, ok
+}
+
+func (c Cgroup2Manager) Close() error {
+	var errs []error
+	for procType, fd := range c.cgroupFDs {
+		if err := unix.Close(fd); err != nil {
+			errs = append(errs, fmt.Errorf("failed to close cgroup fd for %s: %w", procType, err))
+		}
+		delete(c.cgroupFDs, procType)
+	}
+
+	return errors.Join(errs...)
+}

envd/internal/services/cgroups/cgroup2_test.go

@@ -0,0 +1,185 @@
+package cgroups
+
+import (
+	"context"
+	"fmt"
+	"math/rand"
+	"os"
+	"os/exec"
+	"strconv"
+	"syscall"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+const (
+	oneByte  = 1
+	kilobyte = 1024 * oneByte
+	megabyte = 1024 * kilobyte
+)
+
+func TestCgroupRoundTrip(t *testing.T) {
+	t.Parallel()
+
+	if os.Geteuid() != 0 {
+		t.Skip("must run as root")
+
+		return
+	}
+
+	maxTimeout := time.Second * 5
+
+	t.Run("process does not die without cgroups", func(t *testing.T) {
+		t.Parallel()
+
+		// create manager
+		m, err := NewCgroup2Manager()
+		require.NoError(t, err)
+
+		// create new child process
+		cmd := startProcess(t, m, "not-a-real-one")
+
+		// wait for child process to die
+		err = waitForProcess(t, cmd, maxTimeout)
+
+		require.ErrorIs(t, err, context.DeadlineExceeded)
+	})
+
+	t.Run("process dies with cgroups", func(t *testing.T) {
+		t.Parallel()
+
+		cgroupPath := createCgroupPath(t, "real-one")
+
+		// create manager
+		m, err := NewCgroup2Manager(
+			WithCgroup2ProcessType(ProcessTypePTY, cgroupPath, map[string]string{
+				"memory.max": strconv.Itoa(1 * megabyte),
+			}),
+		)
+		require.NoError(t, err)
+
+		t.Cleanup(func() {
+			err := m.Close()
+			assert.NoError(t, err)
+		})
+
+		// create new child process
+		cmd := startProcess(t, m, ProcessTypePTY)
+
+		// wait for child process to die
+		err = waitForProcess(t, cmd, maxTimeout)
+
+		// verify process exited correctly
+		var exitErr *exec.ExitError
+		require.ErrorAs(t, err, &exitErr)
+		assert.Equal(t, "signal: killed", exitErr.Error())
+		assert.False(t, exitErr.Exited())
+		assert.False(t, exitErr.Success())
+		assert.Equal(t, -1, exitErr.ExitCode())
+
+		// dig a little deeper
+		ws, ok := exitErr.Sys().(syscall.WaitStatus)
+		require.True(t, ok)
+		assert.Equal(t, syscall.SIGKILL, ws.Signal())
+		assert.True(t, ws.Signaled())
+		assert.False(t, ws.Stopped())
+		assert.False(t, ws.Continued())
+		assert.False(t, ws.CoreDump())
+		assert.False(t, ws.Exited())
+		assert.Equal(t, -1, ws.ExitStatus())
+	})
+
+	t.Run("process cannot be spawned because memory limit is too low", func(t *testing.T) {
+		t.Parallel()
+
+		cgroupPath := createCgroupPath(t, "real-one")
+
+		// create manager
+		m, err := NewCgroup2Manager(
+			WithCgroup2ProcessType(ProcessTypeSocat, cgroupPath, map[string]string{
+				"memory.max": strconv.Itoa(1 * kilobyte),
+			}),
+		)
+		require.NoError(t, err)
+
+		t.Cleanup(func() {
+			err := m.Close()
+			assert.NoError(t, err)
+		})
+
+		// create new child process
+		cmd := startProcess(t, m, ProcessTypeSocat)
+
+		// wait for child process to die
+		err = waitForProcess(t, cmd, maxTimeout)
+
+		// verify process exited correctly
+		var exitErr *exec.ExitError
+		require.ErrorAs(t, err, &exitErr)
+		assert.Equal(t, "exit status 253", exitErr.Error())
+		assert.True(t, exitErr.Exited())
+		assert.False(t, exitErr.Success())
+		assert.Equal(t, 253, exitErr.ExitCode())
+
+		// dig a little deeper
+		ws, ok := exitErr.Sys().(syscall.WaitStatus)
+		require.True(t, ok)
+		assert.Equal(t, syscall.Signal(-1), ws.Signal())
+		assert.False(t, ws.Signaled())
+		assert.False(t, ws.Stopped())
+		assert.False(t, ws.Continued())
+		assert.False(t, ws.CoreDump())
+		assert.True(t, ws.Exited())
+		assert.Equal(t, 253, ws.ExitStatus())
+	})
+}
+
+func createCgroupPath(t *testing.T, s string) string {
+	t.Helper()
+
+	randPart := rand.Int()
+
+	return fmt.Sprintf("envd-test-%s-%d", s, randPart)
+}
+
+func startProcess(t *testing.T, m *Cgroup2Manager, pt ProcessType) *exec.Cmd {
+	t.Helper()
+
+	cmdName, args := "bash", []string{"-c", `sleep 1 && tail /dev/zero`}
+	cmd := exec.CommandContext(t.Context(), cmdName, args...)
+
+	fd, ok := m.GetFileDescriptor(pt)
+	cmd.SysProcAttr = &syscall.SysProcAttr{
+		UseCgroupFD: ok,
+		CgroupFD:    fd,
+	}
+
+	err := cmd.Start()
+	require.NoError(t, err)
+
+	return cmd
+}
+
+func waitForProcess(t *testing.T, cmd *exec.Cmd, timeout time.Duration) error {
+	t.Helper()
+
+	done := make(chan error, 1)
+
+	go func() {
+		defer close(done)
+		done <- cmd.Wait()
+	}()
+
+	ctx, cancel := context.WithTimeout(t.Context(), timeout)
+	t.Cleanup(cancel)
+
+	select {
+	case <-ctx.Done():
+		return ctx.Err()
+	case err := <-done:
+		return err
+	}
+}

envd/internal/services/cgroups/iface.go

@@ -0,0 +1,14 @@
+package cgroups
+
+type ProcessType string
+
+const (
+	ProcessTypePTY   ProcessType = "pty"
+	ProcessTypeUser  ProcessType = "user"
+	ProcessTypeSocat ProcessType = "socat"
+)
+
+type Manager interface {
+	GetFileDescriptor(procType ProcessType) (int, bool)
+	Close() error
+}

envd/internal/services/cgroups/noop.go

@@ -0,0 +1,17 @@
+package cgroups
+
+type NoopManager struct{}
+
+var _ Manager = (*NoopManager)(nil)
+
+func NewNoopManager() *NoopManager {
+	return &NoopManager{}
+}
+
+func (n NoopManager) GetFileDescriptor(ProcessType) (int, bool) {
+	return 0, false
+}
+
+func (n NoopManager) Close() error {
+	return nil
+}

envd/internal/services/filesystem/dir.go

@@ -0,0 +1,184 @@
+package filesystem
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"connectrpc.com/connect"
+
+	"git.omukk.dev/wrenn/sandbox/envd/internal/permissions"
+	rpc "git.omukk.dev/wrenn/sandbox/envd/internal/services/spec/filesystem"
+)
+
+func (s Service) ListDir(ctx context.Context, req *connect.Request[rpc.ListDirRequest]) (*connect.Response[rpc.ListDirResponse], error) {
+	depth := req.Msg.GetDepth()
+	if depth == 0 {
+		depth = 1 // default depth to current directory
+	}
+
+	u, err := permissions.GetAuthUser(ctx, s.defaults.User)
+	if err != nil {
+		return nil, err
+	}
+
+	requestedPath := req.Msg.GetPath()
+
+	// Expand the path so we can return absolute paths in the response.
+	requestedPath, err = permissions.ExpandAndResolve(requestedPath, u, s.defaults.Workdir)
+	if err != nil {
+		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+	}
+
+	resolvedPath, err := followSymlink(requestedPath)
+	if err != nil {
+		return nil, err
+	}
+
+	err = checkIfDirectory(resolvedPath)
+	if err != nil {
+		return nil, err
+	}
+
+	entries, err := walkDir(requestedPath, resolvedPath, int(depth))
+	if err != nil {
+		return nil, err
+	}
+
+	return connect.NewResponse(&rpc.ListDirResponse{
+		Entries: entries,
+	}), nil
+}
+
+func (s Service) MakeDir(ctx context.Context, req *connect.Request[rpc.MakeDirRequest]) (*connect.Response[rpc.MakeDirResponse], error) {
+	u, err := permissions.GetAuthUser(ctx, s.defaults.User)
+	if err != nil {
+		return nil, err
+	}
+
+	dirPath, err := permissions.ExpandAndResolve(req.Msg.GetPath(), u, s.defaults.Workdir)
+	if err != nil {
+		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+	}
+
+	stat, err := os.Stat(dirPath)
+	if err != nil && !os.IsNotExist(err) {
+		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("error getting file info: %w", err))
+	}
+
+	if err == nil {
+		if stat.IsDir() {
+			return nil, connect.NewError(connect.CodeAlreadyExists, fmt.Errorf("directory already exists: %s", dirPath))
+		}
+
+		return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("path already exists but it is not a directory: %s", dirPath))
+	}
+
+	uid, gid, userErr := permissions.GetUserIdInts(u)
+	if userErr != nil {
+		return nil, connect.NewError(connect.CodeInternal, userErr)
+	}
+
+	userErr = permissions.EnsureDirs(dirPath, uid, gid)
+	if userErr != nil {
+		return nil, connect.NewError(connect.CodeInternal, userErr)
+	}
+
+	entry, err := entryInfo(dirPath)
+	if err != nil {
+		return nil, err
+	}
+
+	return connect.NewResponse(&rpc.MakeDirResponse{
+		Entry: entry,
+	}), nil
+}
+
+// followSymlink resolves a symbolic link to its target path.
+func followSymlink(path string) (string, error) {
+	// Resolve symlinks
+	resolvedPath, err := filepath.EvalSymlinks(path)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return "", connect.NewError(connect.CodeNotFound, fmt.Errorf("path not found: %w", err))
+		}
+
+		if strings.Contains(err.Error(), "too many links") {
+			return "", connect.NewError(connect.CodeFailedPrecondition, fmt.Errorf("cyclic symlink or chain >255 links at %q", path))
+		}
+
+		return "", connect.NewError(connect.CodeInternal, fmt.Errorf("error resolving symlink: %w", err))
+	}
+
+	return resolvedPath, nil
+}
+
+// checkIfDirectory checks if the given path is a directory.
+func checkIfDirectory(path string) error {
+	stat, err := os.Stat(path)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return connect.NewError(connect.CodeNotFound, fmt.Errorf("directory not found: %w", err))
+		}
+
+		return connect.NewError(connect.CodeInternal, fmt.Errorf("error getting file info: %w", err))
+	}
+
+	if !stat.IsDir() {
+		return connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("path is not a directory: %s", path))
+	}
+
+	return nil
+}
+
+// walkDir walks the directory tree starting from dirPath up to the specified depth (doesn't follow symlinks).
+func walkDir(requestedPath string, dirPath string, depth int) (entries []*rpc.EntryInfo, err error) {
+	err = filepath.WalkDir(dirPath, func(path string, _ os.DirEntry, err error) error {
+		if err != nil {
+			return err
+		}
+
+		// Skip the root directory itself
+		if path == dirPath {
+			return nil
+		}
+
+		// Calculate current depth
+		relPath, err := filepath.Rel(dirPath, path)
+		if err != nil {
+			return err
+		}
+		currentDepth := len(strings.Split(relPath, string(os.PathSeparator)))
+
+		if currentDepth > depth {
+			return filepath.SkipDir
+		}
+
+		entryInfo, err := entryInfo(path)
+		if err != nil {
+			var connectErr *connect.Error
+			if errors.As(err, &connectErr) && connectErr.Code() == connect.CodeNotFound {
+				// Skip entries that don't exist anymore
+				return nil
+			}
+
+			return err
+		}
+
+		// Return the requested path as the base path instead of the symlink-resolved path
+		path = filepath.Join(requestedPath, relPath)
+		entryInfo.Path = path
+
+		entries = append(entries, entryInfo)
+
+		return nil
+	})
+	if err != nil {
+		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("error reading directory %s: %w", dirPath, err))
+	}
+
+	return entries, nil
+}

envd/internal/services/filesystem/dir_test.go

@@ -0,0 +1,405 @@
+package filesystem
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"os/user"
+	"path/filepath"
+	"testing"
+
+	"connectrpc.com/authn"
+	"connectrpc.com/connect"
+	"github.com/google/uuid"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"git.omukk.dev/wrenn/sandbox/envd/internal/services/spec/filesystem"
+)
+
+func TestListDir(t *testing.T) {
+	t.Parallel()
+
+	// Setup temp root and user
+	root := t.TempDir()
+	u, err := user.Current()
+	require.NoError(t, err)
+
+	// Setup directory structure
+	testFolder := filepath.Join(root, "test")
+	require.NoError(t, os.MkdirAll(filepath.Join(testFolder, "test-dir", "sub-dir-1"), 0o755))
+	require.NoError(t, os.MkdirAll(filepath.Join(testFolder, "test-dir", "sub-dir-2"), 0o755))
+	filePath := filepath.Join(testFolder, "test-dir", "sub-dir-1", "file.txt")
+	require.NoError(t, os.WriteFile(filePath, []byte("Hello, World!"), 0o644))
+
+	// Service instance
+	svc := mockService()
+
+	// Helper to inject user into context
+	injectUser := func(ctx context.Context, u *user.User) context.Context {
+		return authn.SetInfo(ctx, u)
+	}
+
+	tests := []struct {
+		name          string
+		depth         uint32
+		expectedPaths []string
+	}{
+		{
+			name:  "depth 0 lists only root directory",
+			depth: 0,
+			expectedPaths: []string{
+				filepath.Join(testFolder, "test-dir"),
+			},
+		},
+		{
+			name:  "depth 1 lists root directory",
+			depth: 1,
+			expectedPaths: []string{
+				filepath.Join(testFolder, "test-dir"),
+			},
+		},
+		{
+			name:  "depth 2 lists first level of subdirectories (in this case the root directory)",
+			depth: 2,
+			expectedPaths: []string{
+				filepath.Join(testFolder, "test-dir"),
+				filepath.Join(testFolder, "test-dir", "sub-dir-1"),
+				filepath.Join(testFolder, "test-dir", "sub-dir-2"),
+			},
+		},
+		{
+			name:  "depth 3 lists all directories and files",
+			depth: 3,
+			expectedPaths: []string{
+				filepath.Join(testFolder, "test-dir"),
+				filepath.Join(testFolder, "test-dir", "sub-dir-1"),
+				filepath.Join(testFolder, "test-dir", "sub-dir-2"),
+				filepath.Join(testFolder, "test-dir", "sub-dir-1", "file.txt"),
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			ctx := injectUser(t.Context(), u)
+			req := connect.NewRequest(&filesystem.ListDirRequest{
+				Path:  testFolder,
+				Depth: tt.depth,
+			})
+			resp, err := svc.ListDir(ctx, req)
+			require.NoError(t, err)
+			assert.NotEmpty(t, resp.Msg)
+			assert.Len(t, resp.Msg.GetEntries(), len(tt.expectedPaths))
+			actualPaths := make([]string, len(resp.Msg.GetEntries()))
+			for i, entry := range resp.Msg.GetEntries() {
+				actualPaths[i] = entry.GetPath()
+			}
+			assert.ElementsMatch(t, tt.expectedPaths, actualPaths)
+		})
+	}
+}
+
+func TestListDirNonExistingPath(t *testing.T) {
+	t.Parallel()
+
+	svc := mockService()
+	u, err := user.Current()
+	require.NoError(t, err)
+	ctx := authn.SetInfo(t.Context(), u)
+
+	req := connect.NewRequest(&filesystem.ListDirRequest{
+		Path:  "/non-existing-path",
+		Depth: 1,
+	})
+	_, err = svc.ListDir(ctx, req)
+	require.Error(t, err)
+	var connectErr *connect.Error
+	ok := errors.As(err, &connectErr)
+	assert.True(t, ok, "expected error to be of type *connect.Error")
+	assert.Equal(t, connect.CodeNotFound, connectErr.Code())
+}
+
+func TestListDirRelativePath(t *testing.T) {
+	t.Parallel()
+
+	// Setup temp root and user
+	u, err := user.Current()
+	require.NoError(t, err)
+
+	// Setup directory structure
+	testRelativePath := fmt.Sprintf("test-%s", uuid.New())
+	testFolderPath := filepath.Join(u.HomeDir, testRelativePath)
+	filePath := filepath.Join(testFolderPath, "file.txt")
+	require.NoError(t, os.MkdirAll(testFolderPath, 0o755))
+	require.NoError(t, os.WriteFile(filePath, []byte("Hello, World!"), 0o644))
+
+	// Service instance
+	svc := mockService()
+	ctx := authn.SetInfo(t.Context(), u)
+
+	req := connect.NewRequest(&filesystem.ListDirRequest{
+		Path:  testRelativePath,
+		Depth: 1,
+	})
+	resp, err := svc.ListDir(ctx, req)
+	require.NoError(t, err)
+	assert.NotEmpty(t, resp.Msg)
+
+	expectedPaths := []string{
+		filepath.Join(testFolderPath, "file.txt"),
+	}
+	assert.Len(t, resp.Msg.GetEntries(), len(expectedPaths))
+
+	actualPaths := make([]string, len(resp.Msg.GetEntries()))
+	for i, entry := range resp.Msg.GetEntries() {
+		actualPaths[i] = entry.GetPath()
+	}
+	assert.ElementsMatch(t, expectedPaths, actualPaths)
+}
+
+func TestListDir_Symlinks(t *testing.T) {
+	t.Parallel()
+
+	root := t.TempDir()
+	u, err := user.Current()
+	require.NoError(t, err)
+	ctx := authn.SetInfo(t.Context(), u)
+
+	symlinkRoot := filepath.Join(root, "test-symlinks")
+	require.NoError(t, os.MkdirAll(symlinkRoot, 0o755))
+
+	// 1. Prepare a real directory + file that a symlink will point to
+	realDir := filepath.Join(symlinkRoot, "real-dir")
+	require.NoError(t, os.MkdirAll(realDir, 0o755))
+	filePath := filepath.Join(realDir, "file.txt")
+	require.NoError(t, os.WriteFile(filePath, []byte("hello via symlink"), 0o644))
+
+	// 2. Prepare a standalone real file (points-to-file scenario)
+	realFile := filepath.Join(symlinkRoot, "real-file.txt")
+	require.NoError(t, os.WriteFile(realFile, []byte("i am a plain file"), 0o644))
+
+	// 3. Create the three symlinks
+	linkToDir := filepath.Join(symlinkRoot, "link-dir")   // → directory
+	linkToFile := filepath.Join(symlinkRoot, "link-file") // → file
+	cyclicLink := filepath.Join(symlinkRoot, "cyclic")    // → itself
+	require.NoError(t, os.Symlink(realDir, linkToDir))
+	require.NoError(t, os.Symlink(realFile, linkToFile))
+	require.NoError(t, os.Symlink(cyclicLink, cyclicLink))
+
+	svc := mockService()
+
+	t.Run("symlink to directory behaves like directory and the content looks like inside the directory", func(t *testing.T) {
+		t.Parallel()
+
+		req := connect.NewRequest(&filesystem.ListDirRequest{
+			Path:  linkToDir,
+			Depth: 1,
+		})
+		resp, err := svc.ListDir(ctx, req)
+		require.NoError(t, err)
+		expected := []string{
+			filepath.Join(linkToDir, "file.txt"),
+		}
+		actual := make([]string, len(resp.Msg.GetEntries()))
+		for i, e := range resp.Msg.GetEntries() {
+			actual[i] = e.GetPath()
+		}
+		assert.ElementsMatch(t, expected, actual)
+	})
+
+	t.Run("link to file", func(t *testing.T) {
+		t.Parallel()
+
+		req := connect.NewRequest(&filesystem.ListDirRequest{
+			Path:  linkToFile,
+			Depth: 1,
+		})
+		_, err := svc.ListDir(ctx, req)
+		require.Error(t, err)
+		assert.Contains(t, err.Error(), "not a directory")
+	})
+
+	t.Run("cyclic symlink surfaces 'too many links' → invalid-argument", func(t *testing.T) {
+		t.Parallel()
+
+		req := connect.NewRequest(&filesystem.ListDirRequest{
+			Path: cyclicLink,
+		})
+		_, err := svc.ListDir(ctx, req)
+		require.Error(t, err)
+		var connectErr *connect.Error
+		ok := errors.As(err, &connectErr)
+		assert.True(t, ok, "expected error to be of type *connect.Error")
+		assert.Equal(t, connect.CodeFailedPrecondition, connectErr.Code())
+		assert.Contains(t, connectErr.Error(), "cyclic symlink")
+	})
+
+	t.Run("symlink not resolved if not root", func(t *testing.T) {
+		t.Parallel()
+
+		req := connect.NewRequest(&filesystem.ListDirRequest{
+			Path:  symlinkRoot,
+			Depth: 3,
+		})
+		res, err := svc.ListDir(ctx, req)
+		require.NoError(t, err)
+		expected := []string{
+			filepath.Join(symlinkRoot, "cyclic"),
+			filepath.Join(symlinkRoot, "link-dir"),
+			filepath.Join(symlinkRoot, "link-file"),
+			filepath.Join(symlinkRoot, "real-dir"),
+			filepath.Join(symlinkRoot, "real-dir", "file.txt"),
+			filepath.Join(symlinkRoot, "real-file.txt"),
+		}
+		actual := make([]string, len(res.Msg.GetEntries()))
+		for i, e := range res.Msg.GetEntries() {
+			actual[i] = e.GetPath()
+		}
+		assert.ElementsMatch(t, expected, actual, "symlinks should not be resolved when listing the symlink root directory")
+	})
+}
+
+// TestFollowSymlink_Success makes sure that followSymlink resolves symlinks,
+// while also being robust to the /var → /private/var indirection that exists on macOS.
+func TestFollowSymlink_Success(t *testing.T) {
+	t.Parallel()
+
+	// Base temporary directory. On macOS this lives under /var/folders/…
+	// which itself is a symlink to /private/var/folders/….
+	base := t.TempDir()
+
+	// Create a real directory that we ultimately want to resolve to.
+	target := filepath.Join(base, "target")
+	require.NoError(t, os.MkdirAll(target, 0o755))
+
+	// Create a symlink pointing at the real directory so we can verify that
+	// followSymlink follows it.
+	link := filepath.Join(base, "link")
+	require.NoError(t, os.Symlink(target, link))
+
+	got, err := followSymlink(link)
+	require.NoError(t, err)
+
+	// Canonicalise the expected path too, so that /var → /private/var (macOS)
+	// or any other benign symlink indirections don’t cause flaky tests.
+	want, err := filepath.EvalSymlinks(link)
+	require.NoError(t, err)
+
+	require.Equal(t, want, got, "followSymlink should resolve and canonicalise symlinks")
+}
+
+// TestFollowSymlink_MultiSymlinkChain verifies that followSymlink follows a chain
+// of several symlinks (non‑cyclic) correctly.
+func TestFollowSymlink_MultiSymlinkChain(t *testing.T) {
+	t.Parallel()
+
+	base := t.TempDir()
+
+	// Final destination directory.
+	target := filepath.Join(base, "target")
+	require.NoError(t, os.MkdirAll(target, 0o755))
+
+	// Build a 3‑link chain: link1 → link2 → link3 → target.
+	link3 := filepath.Join(base, "link3")
+	require.NoError(t, os.Symlink(target, link3))
+
+	link2 := filepath.Join(base, "link2")
+	require.NoError(t, os.Symlink(link3, link2))
+
+	link1 := filepath.Join(base, "link1")
+	require.NoError(t, os.Symlink(link2, link1))
+
+	got, err := followSymlink(link1)
+	require.NoError(t, err)
+
+	want, err := filepath.EvalSymlinks(link1)
+	require.NoError(t, err)
+
+	require.Equal(t, want, got, "followSymlink should resolve an arbitrary symlink chain")
+}
+
+func TestFollowSymlink_NotFound(t *testing.T) {
+	t.Parallel()
+
+	_, err := followSymlink("/definitely/does/not/exist")
+	require.Error(t, err)
+
+	var cerr *connect.Error
+	require.ErrorAs(t, err, &cerr)
+	require.Equal(t, connect.CodeNotFound, cerr.Code())
+}
+
+func TestFollowSymlink_CyclicSymlink(t *testing.T) {
+	t.Parallel()
+
+	dir := t.TempDir()
+	a := filepath.Join(dir, "a")
+	b := filepath.Join(dir, "b")
+	require.NoError(t, os.MkdirAll(a, 0o755))
+	require.NoError(t, os.MkdirAll(b, 0o755))
+
+	// Create a two‑node loop: a/loop → b/loop, b/loop → a/loop.
+	require.NoError(t, os.Symlink(filepath.Join(b, "loop"), filepath.Join(a, "loop")))
+	require.NoError(t, os.Symlink(filepath.Join(a, "loop"), filepath.Join(b, "loop")))
+
+	_, err := followSymlink(filepath.Join(a, "loop"))
+	require.Error(t, err)
+
+	var cerr *connect.Error
+	require.ErrorAs(t, err, &cerr)
+	require.Equal(t, connect.CodeFailedPrecondition, cerr.Code())
+	require.Contains(t, cerr.Message(), "cyclic")
+}
+
+func TestCheckIfDirectory(t *testing.T) {
+	t.Parallel()
+
+	dir := t.TempDir()
+	require.NoError(t, checkIfDirectory(dir))
+
+	file := filepath.Join(dir, "file.txt")
+	require.NoError(t, os.WriteFile(file, []byte("hello"), 0o644))
+
+	err := checkIfDirectory(file)
+	require.Error(t, err)
+
+	var cerr *connect.Error
+	require.ErrorAs(t, err, &cerr)
+	require.Equal(t, connect.CodeInvalidArgument, cerr.Code())
+}
+
+func TestWalkDir_Depth(t *testing.T) {
+	t.Parallel()
+
+	root := t.TempDir()
+	sub := filepath.Join(root, "sub")
+	subsub := filepath.Join(sub, "subsub")
+	require.NoError(t, os.MkdirAll(subsub, 0o755))
+
+	entries, err := walkDir(root, root, 1)
+	require.NoError(t, err)
+
+	// Collect the names for easier assertions.
+	names := make([]string, 0, len(entries))
+	for _, e := range entries {
+		names = append(names, e.GetName())
+	}
+
+	require.Contains(t, names, "sub")
+	require.NotContains(t, names, "subsub", "entries beyond depth should be excluded")
+}
+
+func TestWalkDir_Error(t *testing.T) {
+	t.Parallel()
+
+	_, err := walkDir("/does/not/exist", "/does/not/exist", 1)
+	require.Error(t, err)
+
+	var cerr *connect.Error
+	require.ErrorAs(t, err, &cerr)
+	require.Equal(t, connect.CodeInternal, cerr.Code())
+}

envd/internal/services/filesystem/move.go

@@ -0,0 +1,58 @@
+package filesystem
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"connectrpc.com/connect"
+
+	"git.omukk.dev/wrenn/sandbox/envd/internal/permissions"
+	rpc "git.omukk.dev/wrenn/sandbox/envd/internal/services/spec/filesystem"
+)
+
+func (s Service) Move(ctx context.Context, req *connect.Request[rpc.MoveRequest]) (*connect.Response[rpc.MoveResponse], error) {
+	u, err := permissions.GetAuthUser(ctx, s.defaults.User)
+	if err != nil {
+		return nil, err
+	}
+
+	source, err := permissions.ExpandAndResolve(req.Msg.GetSource(), u, s.defaults.Workdir)
+	if err != nil {
+		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+	}
+
+	destination, err := permissions.ExpandAndResolve(req.Msg.GetDestination(), u, s.defaults.Workdir)
+	if err != nil {
+		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+	}
+
+	uid, gid, userErr := permissions.GetUserIdInts(u)
+	if userErr != nil {
+		return nil, connect.NewError(connect.CodeInternal, userErr)
+	}
+
+	userErr = permissions.EnsureDirs(filepath.Dir(destination), uid, gid)
+	if userErr != nil {
+		return nil, connect.NewError(connect.CodeInternal, userErr)
+	}
+
+	err = os.Rename(source, destination)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return nil, connect.NewError(connect.CodeNotFound, fmt.Errorf("source file not found: %w", err))
+		}
+
+		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("error renaming: %w", err))
+	}
+
+	entry, err := entryInfo(destination)
+	if err != nil {
+		return nil, err
+	}
+
+	return connect.NewResponse(&rpc.MoveResponse{
+		Entry: entry,
+	}), nil
+}

envd/internal/services/filesystem/move_test.go

@@ -0,0 +1,364 @@
+package filesystem
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"os/user"
+	"path/filepath"
+	"testing"
+
+	"connectrpc.com/authn"
+	"connectrpc.com/connect"
+	"github.com/google/uuid"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"git.omukk.dev/wrenn/sandbox/envd/internal/services/spec/filesystem"
+)
+
+func TestMove(t *testing.T) {
+	t.Parallel()
+
+	// Setup temp root and user
+	root := t.TempDir()
+	u, err := user.Current()
+	require.NoError(t, err)
+
+	// Setup source and destination directories
+	sourceDir := filepath.Join(root, "source")
+	destDir := filepath.Join(root, "destination")
+	require.NoError(t, os.MkdirAll(sourceDir, 0o755))
+	require.NoError(t, os.MkdirAll(destDir, 0o755))
+
+	// Create a test file to move
+	sourceFile := filepath.Join(sourceDir, "test-file.txt")
+	testContent := []byte("Hello, World!")
+	require.NoError(t, os.WriteFile(sourceFile, testContent, 0o644))
+
+	// Destination file path
+	destFile := filepath.Join(destDir, "test-file.txt")
+
+	// Service instance
+	svc := mockService()
+
+	// Call the Move function
+	ctx := authn.SetInfo(t.Context(), u)
+	req := connect.NewRequest(&filesystem.MoveRequest{
+		Source:      sourceFile,
+		Destination: destFile,
+	})
+	resp, err := svc.Move(ctx, req)
+
+	// Verify the move was successful
+	require.NoError(t, err)
+	assert.NotNil(t, resp)
+	assert.Equal(t, destFile, resp.Msg.GetEntry().GetPath())
+
+	// Verify the file exists at the destination
+	_, err = os.Stat(destFile)
+	require.NoError(t, err)
+
+	// Verify the file no longer exists at the source
+	_, err = os.Stat(sourceFile)
+	assert.True(t, os.IsNotExist(err))
+
+	// Verify the content of the moved file
+	content, err := os.ReadFile(destFile)
+	require.NoError(t, err)
+	assert.Equal(t, testContent, content)
+}
+
+func TestMoveDirectory(t *testing.T) {
+	t.Parallel()
+
+	// Setup temp root and user
+	root := t.TempDir()
+	u, err := user.Current()
+	require.NoError(t, err)
+
+	// Setup source and destination directories
+	sourceParent := filepath.Join(root, "source-parent")
+	destParent := filepath.Join(root, "dest-parent")
+	require.NoError(t, os.MkdirAll(sourceParent, 0o755))
+	require.NoError(t, os.MkdirAll(destParent, 0o755))
+
+	// Create a test directory with files to move
+	sourceDir := filepath.Join(sourceParent, "test-dir")
+	require.NoError(t, os.MkdirAll(filepath.Join(sourceDir, "subdir"), 0o755))
+
+	// Create some files in the directory
+	file1 := filepath.Join(sourceDir, "file1.txt")
+	file2 := filepath.Join(sourceDir, "subdir", "file2.txt")
+	require.NoError(t, os.WriteFile(file1, []byte("File 1 content"), 0o644))
+	require.NoError(t, os.WriteFile(file2, []byte("File 2 content"), 0o644))
+
+	// Destination directory path
+	destDir := filepath.Join(destParent, "test-dir")
+
+	// Service instance
+	svc := mockService()
+
+	// Call the Move function
+	ctx := authn.SetInfo(t.Context(), u)
+	req := connect.NewRequest(&filesystem.MoveRequest{
+		Source:      sourceDir,
+		Destination: destDir,
+	})
+	resp, err := svc.Move(ctx, req)
+
+	// Verify the move was successful
+	require.NoError(t, err)
+	assert.NotNil(t, resp)
+	assert.Equal(t, destDir, resp.Msg.GetEntry().GetPath())
+
+	// Verify the directory exists at the destination
+	_, err = os.Stat(destDir)
+	require.NoError(t, err)
+
+	// Verify the files exist at the destination
+	destFile1 := filepath.Join(destDir, "file1.txt")
+	destFile2 := filepath.Join(destDir, "subdir", "file2.txt")
+	_, err = os.Stat(destFile1)
+	require.NoError(t, err)
+	_, err = os.Stat(destFile2)
+	require.NoError(t, err)
+
+	// Verify the directory no longer exists at the source
+	_, err = os.Stat(sourceDir)
+	assert.True(t, os.IsNotExist(err))
+
+	// Verify the content of the moved files
+	content1, err := os.ReadFile(destFile1)
+	require.NoError(t, err)
+	assert.Equal(t, []byte("File 1 content"), content1)
+
+	content2, err := os.ReadFile(destFile2)
+	require.NoError(t, err)
+	assert.Equal(t, []byte("File 2 content"), content2)
+}
+
+func TestMoveNonExistingFile(t *testing.T) {
+	t.Parallel()
+
+	// Setup temp root and user
+	root := t.TempDir()
+	u, err := user.Current()
+	require.NoError(t, err)
+
+	// Setup destination directory
+	destDir := filepath.Join(root, "destination")
+	require.NoError(t, os.MkdirAll(destDir, 0o755))
+
+	// Non-existing source file
+	sourceFile := filepath.Join(root, "non-existing-file.txt")
+
+	// Destination file path
+	destFile := filepath.Join(destDir, "moved-file.txt")
+
+	// Service instance
+	svc := mockService()
+
+	// Call the Move function
+	ctx := authn.SetInfo(t.Context(), u)
+	req := connect.NewRequest(&filesystem.MoveRequest{
+		Source:      sourceFile,
+		Destination: destFile,
+	})
+	_, err = svc.Move(ctx, req)
+
+	// Verify the correct error is returned
+	require.Error(t, err)
+
+	var connectErr *connect.Error
+	ok := errors.As(err, &connectErr)
+	assert.True(t, ok, "expected error to be of type *connect.Error")
+	assert.Equal(t, connect.CodeNotFound, connectErr.Code())
+	assert.Contains(t, connectErr.Message(), "source file not found")
+}
+
+func TestMoveRelativePath(t *testing.T) {
+	t.Parallel()
+
+	// Setup user
+	u, err := user.Current()
+	require.NoError(t, err)
+
+	// Setup directory structure with unique name to avoid conflicts
+	testRelativePath := fmt.Sprintf("test-move-%s", uuid.New())
+	testFolderPath := filepath.Join(u.HomeDir, testRelativePath)
+	require.NoError(t, os.MkdirAll(testFolderPath, 0o755))
+
+	// Create a test file to move
+	sourceFile := filepath.Join(testFolderPath, "source-file.txt")
+	testContent := []byte("Hello from relative path!")
+	require.NoError(t, os.WriteFile(sourceFile, testContent, 0o644))
+
+	// Destination file path (also relative)
+	destRelativePath := fmt.Sprintf("test-move-dest-%s", uuid.New())
+	destFolderPath := filepath.Join(u.HomeDir, destRelativePath)
+	require.NoError(t, os.MkdirAll(destFolderPath, 0o755))
+	destFile := filepath.Join(destFolderPath, "moved-file.txt")
+
+	// Service instance
+	svc := mockService()
+
+	// Call the Move function with relative paths
+	ctx := authn.SetInfo(t.Context(), u)
+	req := connect.NewRequest(&filesystem.MoveRequest{
+		Source:      filepath.Join(testRelativePath, "source-file.txt"), // Relative path
+		Destination: filepath.Join(destRelativePath, "moved-file.txt"),  // Relative path
+	})
+	resp, err := svc.Move(ctx, req)
+
+	// Verify the move was successful
+	require.NoError(t, err)
+	assert.NotNil(t, resp)
+	assert.Equal(t, destFile, resp.Msg.GetEntry().GetPath())
+
+	// Verify the file exists at the destination
+	_, err = os.Stat(destFile)
+	require.NoError(t, err)
+
+	// Verify the file no longer exists at the source
+	_, err = os.Stat(sourceFile)
+	assert.True(t, os.IsNotExist(err))
+
+	// Verify the content of the moved file
+	content, err := os.ReadFile(destFile)
+	require.NoError(t, err)
+	assert.Equal(t, testContent, content)
+
+	// Clean up
+	os.RemoveAll(testFolderPath)
+	os.RemoveAll(destFolderPath)
+}
+
+func TestMove_Symlinks(t *testing.T) { //nolint:tparallel // this test cannot be executed in parallel
+	root := t.TempDir()
+	u, err := user.Current()
+	require.NoError(t, err)
+	ctx := authn.SetInfo(t.Context(), u)
+
+	// Setup source and destination directories
+	sourceRoot := filepath.Join(root, "source")
+	destRoot := filepath.Join(root, "destination")
+	require.NoError(t, os.MkdirAll(sourceRoot, 0o755))
+	require.NoError(t, os.MkdirAll(destRoot, 0o755))
+
+	// 1. Prepare a real directory + file that a symlink will point to
+	realDir := filepath.Join(sourceRoot, "real-dir")
+	require.NoError(t, os.MkdirAll(realDir, 0o755))
+	filePath := filepath.Join(realDir, "file.txt")
+	require.NoError(t, os.WriteFile(filePath, []byte("hello via symlink"), 0o644))
+
+	// 2. Prepare a standalone real file (points-to-file scenario)
+	realFile := filepath.Join(sourceRoot, "real-file.txt")
+	require.NoError(t, os.WriteFile(realFile, []byte("i am a plain file"), 0o644))
+
+	// 3. Create symlinks
+	linkToDir := filepath.Join(sourceRoot, "link-dir")   // → directory
+	linkToFile := filepath.Join(sourceRoot, "link-file") // → file
+	require.NoError(t, os.Symlink(realDir, linkToDir))
+	require.NoError(t, os.Symlink(realFile, linkToFile))
+
+	svc := mockService()
+
+	t.Run("move symlink to directory", func(t *testing.T) {
+		t.Parallel()
+		destPath := filepath.Join(destRoot, "moved-link-dir")
+
+		req := connect.NewRequest(&filesystem.MoveRequest{
+			Source:      linkToDir,
+			Destination: destPath,
+		})
+		resp, err := svc.Move(ctx, req)
+		require.NoError(t, err)
+		assert.Equal(t, destPath, resp.Msg.GetEntry().GetPath())
+
+		// Verify the symlink was moved
+		_, err = os.Stat(destPath)
+		require.NoError(t, err)
+
+		// Verify it's still a symlink
+		info, err := os.Lstat(destPath)
+		require.NoError(t, err)
+		assert.NotEqual(t, 0, info.Mode()&os.ModeSymlink, "expected a symlink")
+
+		// Verify the symlink target is still correct
+		target, err := os.Readlink(destPath)
+		require.NoError(t, err)
+		assert.Equal(t, realDir, target)
+
+		// Verify the original symlink is gone
+		_, err = os.Stat(linkToDir)
+		assert.True(t, os.IsNotExist(err))
+
+		// Verify the real directory still exists
+		_, err = os.Stat(realDir)
+		assert.NoError(t, err)
+	})
+
+	t.Run("move symlink to file", func(t *testing.T) { //nolint:paralleltest
+		destPath := filepath.Join(destRoot, "moved-link-file")
+
+		req := connect.NewRequest(&filesystem.MoveRequest{
+			Source:      linkToFile,
+			Destination: destPath,
+		})
+		resp, err := svc.Move(ctx, req)
+		require.NoError(t, err)
+		assert.Equal(t, destPath, resp.Msg.GetEntry().GetPath())
+
+		// Verify the symlink was moved
+		_, err = os.Stat(destPath)
+		require.NoError(t, err)
+
+		// Verify it's still a symlink
+		info, err := os.Lstat(destPath)
+		require.NoError(t, err)
+		assert.NotEqual(t, 0, info.Mode()&os.ModeSymlink, "expected a symlink")
+
+		// Verify the symlink target is still correct
+		target, err := os.Readlink(destPath)
+		require.NoError(t, err)
+		assert.Equal(t, realFile, target)
+
+		// Verify the original symlink is gone
+		_, err = os.Stat(linkToFile)
+		assert.True(t, os.IsNotExist(err))
+
+		// Verify the real file still exists
+		_, err = os.Stat(realFile)
+		assert.NoError(t, err)
+	})
+
+	t.Run("move real file that is target of symlink", func(t *testing.T) {
+		t.Parallel()
+		// Create a new symlink to the real file
+		newLinkToFile := filepath.Join(sourceRoot, "new-link-file")
+		require.NoError(t, os.Symlink(realFile, newLinkToFile))
+
+		destPath := filepath.Join(destRoot, "moved-real-file.txt")
+
+		req := connect.NewRequest(&filesystem.MoveRequest{
+			Source:      realFile,
+			Destination: destPath,
+		})
+		resp, err := svc.Move(ctx, req)
+		require.NoError(t, err)
+		assert.Equal(t, destPath, resp.Msg.GetEntry().GetPath())
+
+		// Verify the real file was moved
+		_, err = os.Stat(destPath)
+		require.NoError(t, err)
+
+		// Verify the original file is gone
+		_, err = os.Stat(realFile)
+		assert.True(t, os.IsNotExist(err))
+
+		// Verify the symlink still exists but now points to a non-existent file
+		_, err = os.Stat(newLinkToFile)
+		require.Error(t, err, "symlink should point to non-existent file")
+	})
+}

envd/internal/services/filesystem/remove.go

@@ -0,0 +1,31 @@
+package filesystem
+
+import (
+	"context"
+	"fmt"
+	"os"
+
+	"connectrpc.com/connect"
+
+	"git.omukk.dev/wrenn/sandbox/envd/internal/permissions"
+	rpc "git.omukk.dev/wrenn/sandbox/envd/internal/services/spec/filesystem"
+)
+
+func (s Service) Remove(ctx context.Context, req *connect.Request[rpc.RemoveRequest]) (*connect.Response[rpc.RemoveResponse], error) {
+	u, err := permissions.GetAuthUser(ctx, s.defaults.User)
+	if err != nil {
+		return nil, err
+	}
+
+	path, err := permissions.ExpandAndResolve(req.Msg.GetPath(), u, s.defaults.Workdir)
+	if err != nil {
+		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+	}
+
+	err = os.RemoveAll(path)
+	if err != nil {
+		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("error removing file or directory: %w", err))
+	}
+
+	return connect.NewResponse(&rpc.RemoveResponse{}), nil
+}

envd/internal/services/filesystem/service.go

@@ -0,0 +1,34 @@
+package filesystem
+
+import (
+	"connectrpc.com/connect"
+	"github.com/go-chi/chi/v5"
+	"github.com/rs/zerolog"
+
+	"git.omukk.dev/wrenn/sandbox/envd/internal/execcontext"
+	"git.omukk.dev/wrenn/sandbox/envd/internal/logs"
+	spec "git.omukk.dev/wrenn/sandbox/envd/internal/services/spec/filesystem/filesystemconnect"
+	"git.omukk.dev/wrenn/sandbox/envd/internal/utils"
+)
+
+type Service struct {
+	logger   *zerolog.Logger
+	watchers *utils.Map[string, *FileWatcher]
+	defaults *execcontext.Defaults
+}
+
+func Handle(server *chi.Mux, l *zerolog.Logger, defaults *execcontext.Defaults) {
+	service := Service{
+		logger:   l,
+		watchers: utils.NewMap[string, *FileWatcher](),
+		defaults: defaults,
+	}
+
+	interceptors := connect.WithInterceptors(
+		logs.NewUnaryLogInterceptor(l),
+	)
+
+	path, handler := spec.NewFilesystemHandler(service, interceptors)
+
+	server.Mount(path, handler)
+}

envd/internal/services/filesystem/service_test.go

@@ -0,0 +1,14 @@
+package filesystem
+
+import (
+	"git.omukk.dev/wrenn/sandbox/envd/internal/execcontext"
+	"git.omukk.dev/wrenn/sandbox/envd/internal/utils"
+)
+
+func mockService() Service {
+	return Service{
+		defaults: &execcontext.Defaults{
+			EnvVars: utils.NewMap[string, string](),
+		},
+	}
+}

envd/internal/services/filesystem/stat.go

@@ -0,0 +1,29 @@
+package filesystem
+
+import (
+	"context"
+
+	"connectrpc.com/connect"
+
+	"git.omukk.dev/wrenn/sandbox/envd/internal/permissions"
+	rpc "git.omukk.dev/wrenn/sandbox/envd/internal/services/spec/filesystem"
+)
+
+func (s Service) Stat(ctx context.Context, req *connect.Request[rpc.StatRequest]) (*connect.Response[rpc.StatResponse], error) {
+	u, err := permissions.GetAuthUser(ctx, s.defaults.User)
+	if err != nil {
+		return nil, err
+	}
+
+	path, err := permissions.ExpandAndResolve(req.Msg.GetPath(), u, s.defaults.Workdir)
+	if err != nil {
+		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+	}
+
+	entry, err := entryInfo(path)
+	if err != nil {
+		return nil, err
+	}
+
+	return connect.NewResponse(&rpc.StatResponse{Entry: entry}), nil
+}

envd/internal/services/filesystem/stat_test.go

@@ -0,0 +1,114 @@
+package filesystem
+
+import (
+	"context"
+	"os"
+	"os/user"
+	"path/filepath"
+	"testing"
+
+	"connectrpc.com/authn"
+	"connectrpc.com/connect"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"git.omukk.dev/wrenn/sandbox/envd/internal/services/spec/filesystem"
+)
+
+func TestStat(t *testing.T) {
+	t.Parallel()
+
+	// Setup temp root and user
+	root := t.TempDir()
+	// Get the actual path to the temp directory (symlinks can cause issues)
+	root, err := filepath.EvalSymlinks(root)
+	require.NoError(t, err)
+
+	u, err := user.Current()
+	require.NoError(t, err)
+
+	group, err := user.LookupGroupId(u.Gid)
+	require.NoError(t, err)
+
+	// Setup directory structure
+	testFolder := filepath.Join(root, "test")
+	err = os.MkdirAll(testFolder, 0o755)
+	require.NoError(t, err)
+
+	testFile := filepath.Join(testFolder, "file.txt")
+	err = os.WriteFile(testFile, []byte("Hello, World!"), 0o644)
+	require.NoError(t, err)
+
+	linkedFile := filepath.Join(testFolder, "linked-file.txt")
+	err = os.Symlink(testFile, linkedFile)
+	require.NoError(t, err)
+
+	// Service instance
+	svc := mockService()
+
+	// Helper to inject user into context
+	injectUser := func(ctx context.Context, u *user.User) context.Context {
+		return authn.SetInfo(ctx, u)
+	}
+
+	tests := []struct {
+		name string
+		path string
+	}{
+		{
+			name: "Stat file directory",
+			path: testFile,
+		},
+		{
+			name: "Stat symlink to file",
+			path: linkedFile,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			ctx := injectUser(t.Context(), u)
+			req := connect.NewRequest(&filesystem.StatRequest{
+				Path: tt.path,
+			})
+			resp, err := svc.Stat(ctx, req)
+			require.NoError(t, err)
+			require.NotEmpty(t, resp.Msg)
+			require.NotNil(t, resp.Msg.GetEntry())
+			assert.Equal(t, tt.path, resp.Msg.GetEntry().GetPath())
+			assert.Equal(t, filesystem.FileType_FILE_TYPE_FILE, resp.Msg.GetEntry().GetType())
+			assert.Equal(t, u.Username, resp.Msg.GetEntry().GetOwner())
+			assert.Equal(t, group.Name, resp.Msg.GetEntry().GetGroup())
+			assert.Equal(t, uint32(0o644), resp.Msg.GetEntry().GetMode())
+			if tt.path == linkedFile {
+				require.NotNil(t, resp.Msg.GetEntry().GetSymlinkTarget())
+				assert.Equal(t, testFile, resp.Msg.GetEntry().GetSymlinkTarget())
+			} else {
+				assert.Empty(t, resp.Msg.GetEntry().GetSymlinkTarget())
+			}
+		})
+	}
+}
+
+func TestStatMissingPathReturnsNotFound(t *testing.T) {
+	t.Parallel()
+
+	u, err := user.Current()
+	require.NoError(t, err)
+
+	svc := mockService()
+	ctx := authn.SetInfo(t.Context(), u)
+
+	req := connect.NewRequest(&filesystem.StatRequest{
+		Path: filepath.Join(t.TempDir(), "missing.txt"),
+	})
+
+	_, err = svc.Stat(ctx, req)
+	require.Error(t, err)
+
+	var connectErr *connect.Error
+	require.ErrorAs(t, err, &connectErr)
+	assert.Equal(t, connect.CodeNotFound, connectErr.Code())
+}

envd/internal/services/filesystem/utils.go

@@ -0,0 +1,107 @@
+package filesystem
+
+import (
+	"fmt"
+	"os"
+	"os/user"
+	"syscall"
+	"time"
+
+	"connectrpc.com/connect"
+	"google.golang.org/protobuf/types/known/timestamppb"
+
+	rpc "git.omukk.dev/wrenn/sandbox/envd/internal/services/spec/filesystem"
+	"git.omukk.dev/wrenn/sandbox/envd/internal/shared/filesystem"
+)
+
+// Filesystem magic numbers from Linux kernel (include/uapi/linux/magic.h)
+const (
+	nfsSuperMagic   = 0x6969
+	cifsMagic       = 0xFF534D42
+	smbSuperMagic   = 0x517B
+	smb2MagicNumber = 0xFE534D42
+	fuseSuperMagic  = 0x65735546
+)
+
+// IsPathOnNetworkMount checks if the given path is on a network filesystem mount.
+// Returns true if the path is on NFS, CIFS, SMB, or FUSE filesystem.
+func IsPathOnNetworkMount(path string) (bool, error) {
+	var statfs syscall.Statfs_t
+	if err := syscall.Statfs(path, &statfs); err != nil {
+		return false, fmt.Errorf("failed to statfs %s: %w", path, err)
+	}
+
+	switch statfs.Type {
+	case nfsSuperMagic, cifsMagic, smbSuperMagic, smb2MagicNumber, fuseSuperMagic:
+		return true, nil
+	default:
+		return false, nil
+	}
+}
+
+func entryInfo(path string) (*rpc.EntryInfo, error) {
+	info, err := filesystem.GetEntryFromPath(path)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return nil, connect.NewError(connect.CodeNotFound, fmt.Errorf("file not found: %w", err))
+		}
+
+		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("error getting file info: %w", err))
+	}
+
+	owner, group := getFileOwnership(info)
+
+	return &rpc.EntryInfo{
+		Name:          info.Name,
+		Type:          getEntryType(info.Type),
+		Path:          info.Path,
+		Size:          info.Size,
+		Mode:          uint32(info.Mode),
+		Permissions:   info.Permissions,
+		Owner:         owner,
+		Group:         group,
+		ModifiedTime:  toTimestamp(info.ModifiedTime),
+		SymlinkTarget: info.SymlinkTarget,
+	}, nil
+}
+
+func toTimestamp(time time.Time) *timestamppb.Timestamp {
+	if time.IsZero() {
+		return nil
+	}
+
+	return timestamppb.New(time)
+}
+
+// getFileOwnership returns the owner and group names for a file.
+// If the lookup fails, it returns the numeric UID and GID as strings.
+func getFileOwnership(fileInfo filesystem.EntryInfo) (owner, group string) {
+	// Look up username
+	owner = fmt.Sprintf("%d", fileInfo.UID)
+	if u, err := user.LookupId(owner); err == nil {
+		owner = u.Username
+	}
+
+	// Look up group name
+	group = fmt.Sprintf("%d", fileInfo.GID)
+	if g, err := user.LookupGroupId(group); err == nil {
+		group = g.Name
+	}
+
+	return owner, group
+}
+
+// getEntryType determines the type of file entry based on its mode and path.
+// If the file is a symlink, it follows the symlink to determine the actual type.
+func getEntryType(fileType filesystem.FileType) rpc.FileType {
+	switch fileType {
+	case filesystem.FileFileType:
+		return rpc.FileType_FILE_TYPE_FILE
+	case filesystem.DirectoryFileType:
+		return rpc.FileType_FILE_TYPE_DIRECTORY
+	case filesystem.SymlinkFileType:
+		return rpc.FileType_FILE_TYPE_SYMLINK
+	default:
+		return rpc.FileType_FILE_TYPE_UNSPECIFIED
+	}
+}

envd/internal/services/filesystem/utils_test.go

@@ -0,0 +1,149 @@
+package filesystem
+
+import (
+	"context"
+	"os/exec"
+	osuser "os/user"
+	"strconv"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	fsmodel "git.omukk.dev/wrenn/sandbox/envd/internal/shared/filesystem"
+)
+
+func TestIsPathOnNetworkMount(t *testing.T) {
+	t.Parallel()
+
+	// Test with a regular directory (should not be on network mount)
+	tempDir := t.TempDir()
+	isNetwork, err := IsPathOnNetworkMount(tempDir)
+	require.NoError(t, err)
+	assert.False(t, isNetwork, "temp directory should not be on a network mount")
+}
+
+func TestIsPathOnNetworkMount_FuseMount(t *testing.T) {
+	t.Parallel()
+
+	// Require bindfs to be available
+	_, err := exec.LookPath("bindfs")
+	require.NoError(t, err, "bindfs must be installed for this test")
+
+	// Require fusermount to be available (needed for unmounting)
+	_, err = exec.LookPath("fusermount")
+	require.NoError(t, err, "fusermount must be installed for this test")
+
+	// Create source and mount directories
+	sourceDir := t.TempDir()
+	mountDir := t.TempDir()
+
+	// Mount sourceDir onto mountDir using bindfs (FUSE)
+	ctx := context.Background()
+	cmd := exec.CommandContext(ctx, "bindfs", sourceDir, mountDir)
+	require.NoError(t, cmd.Run(), "failed to mount bindfs")
+
+	// Ensure we unmount on cleanup
+	t.Cleanup(func() {
+		_ = exec.CommandContext(context.Background(), "fusermount", "-u", mountDir).Run()
+	})
+
+	// Test that the FUSE mount is detected
+	isNetwork, err := IsPathOnNetworkMount(mountDir)
+	require.NoError(t, err)
+	assert.True(t, isNetwork, "FUSE mount should be detected as network filesystem")
+
+	// Test that the source directory is NOT detected as network mount
+	isNetworkSource, err := IsPathOnNetworkMount(sourceDir)
+	require.NoError(t, err)
+	assert.False(t, isNetworkSource, "source directory should not be detected as network filesystem")
+}
+
+func TestGetFileOwnership_CurrentUser(t *testing.T) {
+	t.Parallel()
+
+	t.Run("current user", func(t *testing.T) {
+		t.Parallel()
+
+		// Get current user running the tests
+		cur, err := osuser.Current()
+		if err != nil {
+			t.Skipf("unable to determine current user: %v", err)
+		}
+
+		// Determine expected owner/group using the same lookup logic
+		expectedOwner := cur.Uid
+		if u, err := osuser.LookupId(cur.Uid); err == nil {
+			expectedOwner = u.Username
+		}
+
+		expectedGroup := cur.Gid
+		if g, err := osuser.LookupGroupId(cur.Gid); err == nil {
+			expectedGroup = g.Name
+		}
+
+		// Parse UID/GID strings to uint32 for EntryInfo
+		uid64, err := strconv.ParseUint(cur.Uid, 10, 32)
+		require.NoError(t, err)
+		gid64, err := strconv.ParseUint(cur.Gid, 10, 32)
+		require.NoError(t, err)
+
+		// Build a minimal EntryInfo with current UID/GID
+		info := fsmodel.EntryInfo{ // from shared pkg
+			UID: uint32(uid64),
+			GID: uint32(gid64),
+		}
+
+		owner, group := getFileOwnership(info)
+		assert.Equal(t, expectedOwner, owner)
+		assert.Equal(t, expectedGroup, group)
+	})
+
+	t.Run("no user", func(t *testing.T) {
+		t.Parallel()
+
+		// Find a UID that does not exist on this system
+		var unknownUIDStr string
+		for i := 60001; i < 70000; i++ { // search a high range typically unused
+			idStr := strconv.Itoa(i)
+			if _, err := osuser.LookupId(idStr); err != nil {
+				unknownUIDStr = idStr
+
+				break
+			}
+		}
+		if unknownUIDStr == "" {
+			t.Skip("could not find a non-existent UID in the probed range")
+		}
+
+		// Find a GID that does not exist on this system
+		var unknownGIDStr string
+		for i := 60001; i < 70000; i++ { // search a high range typically unused
+			idStr := strconv.Itoa(i)
+			if _, err := osuser.LookupGroupId(idStr); err != nil {
+				unknownGIDStr = idStr
+
+				break
+			}
+		}
+		if unknownGIDStr == "" {
+			t.Skip("could not find a non-existent GID in the probed range")
+		}
+
+		// Parse to uint32 for EntryInfo construction
+		uid64, err := strconv.ParseUint(unknownUIDStr, 10, 32)
+		require.NoError(t, err)
+		gid64, err := strconv.ParseUint(unknownGIDStr, 10, 32)
+		require.NoError(t, err)
+
+		info := fsmodel.EntryInfo{
+			UID: uint32(uid64),
+			GID: uint32(gid64),
+		}
+
+		owner, group := getFileOwnership(info)
+		// Expect numeric fallbacks because lookups should fail for unknown IDs
+		assert.Equal(t, unknownUIDStr, owner)
+		assert.Equal(t, unknownGIDStr, group)
+	})
+}

envd/internal/services/filesystem/watch.go

@@ -0,0 +1,159 @@
+package filesystem
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"connectrpc.com/connect"
+	"github.com/e2b-dev/fsnotify"
+
+	"git.omukk.dev/wrenn/sandbox/envd/internal/logs"
+	"git.omukk.dev/wrenn/sandbox/envd/internal/permissions"
+	rpc "git.omukk.dev/wrenn/sandbox/envd/internal/services/spec/filesystem"
+	"git.omukk.dev/wrenn/sandbox/envd/internal/utils"
+)
+
+func (s Service) WatchDir(ctx context.Context, req *connect.Request[rpc.WatchDirRequest], stream *connect.ServerStream[rpc.WatchDirResponse]) error {
+	return logs.LogServerStreamWithoutEvents(ctx, s.logger, req, stream, s.watchHandler)
+}
+
+func (s Service) watchHandler(ctx context.Context, req *connect.Request[rpc.WatchDirRequest], stream *connect.ServerStream[rpc.WatchDirResponse]) error {
+	u, err := permissions.GetAuthUser(ctx, s.defaults.User)
+	if err != nil {
+		return err
+	}
+
+	watchPath, err := permissions.ExpandAndResolve(req.Msg.GetPath(), u, s.defaults.Workdir)
+	if err != nil {
+		return connect.NewError(connect.CodeInvalidArgument, err)
+	}
+
+	info, err := os.Stat(watchPath)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return connect.NewError(connect.CodeNotFound, fmt.Errorf("path %s not found: %w", watchPath, err))
+		}
+
+		return connect.NewError(connect.CodeInternal, fmt.Errorf("error statting path %s: %w", watchPath, err))
+	}
+
+	if !info.IsDir() {
+		return connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("path %s not a directory: %w", watchPath, err))
+	}
+
+	// Check if path is on a network filesystem mount
+	isNetworkMount, err := IsPathOnNetworkMount(watchPath)
+	if err != nil {
+		return connect.NewError(connect.CodeInternal, fmt.Errorf("error checking mount status: %w", err))
+	}
+	if isNetworkMount {
+		return connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("cannot watch path on network filesystem: %s", watchPath))
+	}
+
+	w, err := fsnotify.NewWatcher()
+	if err != nil {
+		return connect.NewError(connect.CodeInternal, fmt.Errorf("error creating watcher: %w", err))
+	}
+	defer w.Close()
+
+	err = w.Add(utils.FsnotifyPath(watchPath, req.Msg.GetRecursive()))
+	if err != nil {
+		return connect.NewError(connect.CodeInternal, fmt.Errorf("error adding path %s to watcher: %w", watchPath, err))
+	}
+
+	err = stream.Send(&rpc.WatchDirResponse{
+		Event: &rpc.WatchDirResponse_Start{
+			Start: &rpc.WatchDirResponse_StartEvent{},
+		},
+	})
+	if err != nil {
+		return connect.NewError(connect.CodeUnknown, fmt.Errorf("error sending start event: %w", err))
+	}
+
+	keepaliveTicker, resetKeepalive := permissions.GetKeepAliveTicker(req)
+	defer keepaliveTicker.Stop()
+
+	for {
+		select {
+		case <-keepaliveTicker.C:
+			streamErr := stream.Send(&rpc.WatchDirResponse{
+				Event: &rpc.WatchDirResponse_Keepalive{
+					Keepalive: &rpc.WatchDirResponse_KeepAlive{},
+				},
+			})
+			if streamErr != nil {
+				return connect.NewError(connect.CodeUnknown, fmt.Errorf("error sending keepalive: %w", streamErr))
+			}
+		case <-ctx.Done():
+			return ctx.Err()
+		case chErr, ok := <-w.Errors:
+			if !ok {
+				return connect.NewError(connect.CodeInternal, fmt.Errorf("watcher error channel closed"))
+			}
+
+			return connect.NewError(connect.CodeInternal, fmt.Errorf("watcher error: %w", chErr))
+		case e, ok := <-w.Events:
+			if !ok {
+				return connect.NewError(connect.CodeInternal, fmt.Errorf("watcher event channel closed"))
+			}
+
+			// One event can have multiple operations.
+			ops := []rpc.EventType{}
+
+			if fsnotify.Create.Has(e.Op) {
+				ops = append(ops, rpc.EventType_EVENT_TYPE_CREATE)
+			}
+
+			if fsnotify.Rename.Has(e.Op) {
+				ops = append(ops, rpc.EventType_EVENT_TYPE_RENAME)
+			}
+
+			if fsnotify.Chmod.Has(e.Op) {
+				ops = append(ops, rpc.EventType_EVENT_TYPE_CHMOD)
+			}
+
+			if fsnotify.Write.Has(e.Op) {
+				ops = append(ops, rpc.EventType_EVENT_TYPE_WRITE)
+			}
+
+			if fsnotify.Remove.Has(e.Op) {
+				ops = append(ops, rpc.EventType_EVENT_TYPE_REMOVE)
+			}
+
+			for _, op := range ops {
+				name, nameErr := filepath.Rel(watchPath, e.Name)
+				if nameErr != nil {
+					return connect.NewError(connect.CodeInternal, fmt.Errorf("error getting relative path: %w", nameErr))
+				}
+
+				filesystemEvent := &rpc.WatchDirResponse_Filesystem{
+					Filesystem: &rpc.FilesystemEvent{
+						Name: name,
+						Type: op,
+					},
+				}
+
+				event := &rpc.WatchDirResponse{
+					Event: filesystemEvent,
+				}
+
+				streamErr := stream.Send(event)
+
+				s.logger.
+					Debug().
+					Str("event_type", "filesystem_event").
+					Str(string(logs.OperationIDKey), ctx.Value(logs.OperationIDKey).(string)).
+					Interface("filesystem_event", event).
+					Msg("Streaming filesystem event")
+
+				if streamErr != nil {
+					return connect.NewError(connect.CodeUnknown, fmt.Errorf("error sending filesystem event: %w", streamErr))
+				}
+
+				resetKeepalive()
+			}
+		}
+	}
+}

envd/internal/services/filesystem/watch_sync.go

@@ -0,0 +1,224 @@
+package filesystem
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"path/filepath"
+	"sync"
+
+	"connectrpc.com/connect"
+	"github.com/e2b-dev/fsnotify"
+	"github.com/rs/zerolog"
+
+	"git.omukk.dev/wrenn/sandbox/envd/internal/logs"
+	"git.omukk.dev/wrenn/sandbox/envd/internal/permissions"
+	rpc "git.omukk.dev/wrenn/sandbox/envd/internal/services/spec/filesystem"
+	"git.omukk.dev/wrenn/sandbox/envd/internal/utils"
+	"git.omukk.dev/wrenn/sandbox/envd/internal/shared/id"
+)
+
+type FileWatcher struct {
+	watcher *fsnotify.Watcher
+	Events  []*rpc.FilesystemEvent
+	cancel  func()
+	Error   error
+
+	Lock sync.Mutex
+}
+
+func CreateFileWatcher(ctx context.Context, watchPath string, recursive bool, operationID string, logger *zerolog.Logger) (*FileWatcher, error) {
+	w, err := fsnotify.NewWatcher()
+	if err != nil {
+		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("error creating watcher: %w", err))
+	}
+
+	// We don't want to cancel the context when the request is finished
+	ctx, cancel := context.WithCancel(context.WithoutCancel(ctx))
+
+	err = w.Add(utils.FsnotifyPath(watchPath, recursive))
+	if err != nil {
+		_ = w.Close()
+		cancel()
+
+		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("error adding path %s to watcher: %w", watchPath, err))
+	}
+	fw := &FileWatcher{
+		watcher: w,
+		cancel:  cancel,
+		Events:  []*rpc.FilesystemEvent{},
+		Error:   nil,
+	}
+
+	go func() {
+		for {
+			select {
+			case <-ctx.Done():
+				return
+			case chErr, ok := <-w.Errors:
+				if !ok {
+					fw.Error = connect.NewError(connect.CodeInternal, fmt.Errorf("watcher error channel closed"))
+
+					return
+				}
+
+				fw.Error = connect.NewError(connect.CodeInternal, fmt.Errorf("watcher error: %w", chErr))
+
+				return
+			case e, ok := <-w.Events:
+				if !ok {
+					fw.Error = connect.NewError(connect.CodeInternal, fmt.Errorf("watcher event channel closed"))
+
+					return
+				}
+
+				// One event can have multiple operations.
+				ops := []rpc.EventType{}
+
+				if fsnotify.Create.Has(e.Op) {
+					ops = append(ops, rpc.EventType_EVENT_TYPE_CREATE)
+				}
+
+				if fsnotify.Rename.Has(e.Op) {
+					ops = append(ops, rpc.EventType_EVENT_TYPE_RENAME)
+				}
+
+				if fsnotify.Chmod.Has(e.Op) {
+					ops = append(ops, rpc.EventType_EVENT_TYPE_CHMOD)
+				}
+
+				if fsnotify.Write.Has(e.Op) {
+					ops = append(ops, rpc.EventType_EVENT_TYPE_WRITE)
+				}
+
+				if fsnotify.Remove.Has(e.Op) {
+					ops = append(ops, rpc.EventType_EVENT_TYPE_REMOVE)
+				}
+
+				for _, op := range ops {
+					name, nameErr := filepath.Rel(watchPath, e.Name)
+					if nameErr != nil {
+						fw.Error = connect.NewError(connect.CodeInternal, fmt.Errorf("error getting relative path: %w", nameErr))
+
+						return
+					}
+
+					fw.Lock.Lock()
+					fw.Events = append(fw.Events, &rpc.FilesystemEvent{
+						Name: name,
+						Type: op,
+					})
+					fw.Lock.Unlock()
+
+					// these are only used for logging
+					filesystemEvent := &rpc.WatchDirResponse_Filesystem{
+						Filesystem: &rpc.FilesystemEvent{
+							Name: name,
+							Type: op,
+						},
+					}
+					event := &rpc.WatchDirResponse{
+						Event: filesystemEvent,
+					}
+
+					logger.
+						Debug().
+						Str("event_type", "filesystem_event").
+						Str(string(logs.OperationIDKey), operationID).
+						Interface("filesystem_event", event).
+						Msg("Streaming filesystem event")
+				}
+			}
+		}
+	}()
+
+	return fw, nil
+}
+
+func (fw *FileWatcher) Close() {
+	_ = fw.watcher.Close()
+	fw.cancel()
+}
+
+func (s Service) CreateWatcher(ctx context.Context, req *connect.Request[rpc.CreateWatcherRequest]) (*connect.Response[rpc.CreateWatcherResponse], error) {
+	u, err := permissions.GetAuthUser(ctx, s.defaults.User)
+	if err != nil {
+		return nil, err
+	}
+
+	watchPath, err := permissions.ExpandAndResolve(req.Msg.GetPath(), u, s.defaults.Workdir)
+	if err != nil {
+		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+	}
+
+	info, err := os.Stat(watchPath)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return nil, connect.NewError(connect.CodeNotFound, fmt.Errorf("path %s not found: %w", watchPath, err))
+		}
+
+		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("error statting path %s: %w", watchPath, err))
+	}
+
+	if !info.IsDir() {
+		return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("path %s not a directory: %w", watchPath, err))
+	}
+
+	// Check if path is on a network filesystem mount
+	isNetworkMount, err := IsPathOnNetworkMount(watchPath)
+	if err != nil {
+		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("error checking mount status: %w", err))
+	}
+	if isNetworkMount {
+		return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("cannot watch path on network filesystem: %s", watchPath))
+	}
+
+	watcherId := "w" + id.Generate()
+
+	w, err := CreateFileWatcher(ctx, watchPath, req.Msg.GetRecursive(), watcherId, s.logger)
+	if err != nil {
+		return nil, err
+	}
+
+	s.watchers.Store(watcherId, w)
+
+	return connect.NewResponse(&rpc.CreateWatcherResponse{
+		WatcherId: watcherId,
+	}), nil
+}
+
+func (s Service) GetWatcherEvents(_ context.Context, req *connect.Request[rpc.GetWatcherEventsRequest]) (*connect.Response[rpc.GetWatcherEventsResponse], error) {
+	watcherId := req.Msg.GetWatcherId()
+
+	w, ok := s.watchers.Load(watcherId)
+	if !ok {
+		return nil, connect.NewError(connect.CodeNotFound, fmt.Errorf("watcher with id %s not found", watcherId))
+	}
+
+	if w.Error != nil {
+		return nil, w.Error
+	}
+
+	w.Lock.Lock()
+	defer w.Lock.Unlock()
+	events := w.Events
+	w.Events = []*rpc.FilesystemEvent{}
+
+	return connect.NewResponse(&rpc.GetWatcherEventsResponse{
+		Events: events,
+	}), nil
+}
+
+func (s Service) RemoveWatcher(_ context.Context, req *connect.Request[rpc.RemoveWatcherRequest]) (*connect.Response[rpc.RemoveWatcherResponse], error) {
+	watcherId := req.Msg.GetWatcherId()
+
+	w, ok := s.watchers.Load(watcherId)
+	if !ok {
+		return nil, connect.NewError(connect.CodeNotFound, fmt.Errorf("watcher with id %s not found", watcherId))
+	}
+
+	w.Close()
+	s.watchers.Delete(watcherId)
+
+	return connect.NewResponse(&rpc.RemoveWatcherResponse{}), nil
+}

envd/internal/services/process/connect.go

@@ -0,0 +1,126 @@
+package process
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"connectrpc.com/connect"
+
+	"git.omukk.dev/wrenn/sandbox/envd/internal/logs"
+	"git.omukk.dev/wrenn/sandbox/envd/internal/permissions"
+	rpc "git.omukk.dev/wrenn/sandbox/envd/internal/services/spec/process"
+)
+
+func (s *Service) Connect(ctx context.Context, req *connect.Request[rpc.ConnectRequest], stream *connect.ServerStream[rpc.ConnectResponse]) error {
+	return logs.LogServerStreamWithoutEvents(ctx, s.logger, req, stream, s.handleConnect)
+}
+
+func (s *Service) handleConnect(ctx context.Context, req *connect.Request[rpc.ConnectRequest], stream *connect.ServerStream[rpc.ConnectResponse]) error {
+	ctx, cancel := context.WithCancelCause(ctx)
+	defer cancel(nil)
+
+	proc, err := s.getProcess(req.Msg.GetProcess())
+	if err != nil {
+		return err
+	}
+
+	exitChan := make(chan struct{})
+
+	data, dataCancel := proc.DataEvent.Fork()
+	defer dataCancel()
+
+	end, endCancel := proc.EndEvent.Fork()
+	defer endCancel()
+
+	streamErr := stream.Send(&rpc.ConnectResponse{
+		Event: &rpc.ProcessEvent{
+			Event: &rpc.ProcessEvent_Start{
+				Start: &rpc.ProcessEvent_StartEvent{
+					Pid: proc.Pid(),
+				},
+			},
+		},
+	})
+	if streamErr != nil {
+		return connect.NewError(connect.CodeUnknown, fmt.Errorf("error sending start event: %w", streamErr))
+	}
+
+	go func() {
+		defer close(exitChan)
+
+		keepaliveTicker, resetKeepalive := permissions.GetKeepAliveTicker(req)
+		defer keepaliveTicker.Stop()
+
+	dataLoop:
+		for {
+			select {
+			case <-keepaliveTicker.C:
+				streamErr := stream.Send(&rpc.ConnectResponse{
+					Event: &rpc.ProcessEvent{
+						Event: &rpc.ProcessEvent_Keepalive{
+							Keepalive: &rpc.ProcessEvent_KeepAlive{},
+						},
+					},
+				})
+				if streamErr != nil {
+					cancel(connect.NewError(connect.CodeUnknown, fmt.Errorf("error sending keepalive: %w", streamErr)))
+
+					return
+				}
+			case <-ctx.Done():
+				cancel(ctx.Err())
+
+				return
+			case event, ok := <-data:
+				if !ok {
+					break dataLoop
+				}
+
+				streamErr := stream.Send(&rpc.ConnectResponse{
+					Event: &rpc.ProcessEvent{
+						Event: &event,
+					},
+				})
+				if streamErr != nil {
+					cancel(connect.NewError(connect.CodeUnknown, fmt.Errorf("error sending data event: %w", streamErr)))
+
+					return
+				}
+
+				resetKeepalive()
+			}
+		}
+
+		select {
+		case <-ctx.Done():
+			cancel(ctx.Err())
+
+			return
+		case event, ok := <-end:
+			if !ok {
+				cancel(connect.NewError(connect.CodeUnknown, errors.New("end event channel closed before sending end event")))
+
+				return
+			}
+
+			streamErr := stream.Send(&rpc.ConnectResponse{
+				Event: &rpc.ProcessEvent{
+					Event: &event,
+				},
+			})
+			if streamErr != nil {
+				cancel(connect.NewError(connect.CodeUnknown, fmt.Errorf("error sending end event: %w", streamErr)))
+
+				return
+			}
+		}
+	}()
+
+	select {
+	case <-ctx.Done():
+		return ctx.Err()
+	case <-exitChan:
+		return nil
+	}
+}

envd/internal/services/process/handler/handler.go

@@ -0,0 +1,478 @@
+package handler
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"os/user"
+	"strconv"
+	"strings"
+	"sync"
+	"syscall"
+
+	"connectrpc.com/connect"
+	"github.com/creack/pty"
+	"github.com/rs/zerolog"
+
+	"git.omukk.dev/wrenn/sandbox/envd/internal/execcontext"
+	"git.omukk.dev/wrenn/sandbox/envd/internal/logs"
+	"git.omukk.dev/wrenn/sandbox/envd/internal/permissions"
+	"git.omukk.dev/wrenn/sandbox/envd/internal/services/cgroups"
+	rpc "git.omukk.dev/wrenn/sandbox/envd/internal/services/spec/process"
+)
+
+const (
+	defaultNice      = 0
+	defaultOomScore  = 100
+	outputBufferSize = 64
+	stdChunkSize     = 2 << 14
+	ptyChunkSize     = 2 << 13
+)
+
+type ProcessExit struct {
+	Error  *string
+	Status string
+	Exited bool
+	Code   int32
+}
+
+type Handler struct {
+	Config *rpc.ProcessConfig
+
+	logger *zerolog.Logger
+
+	Tag *string
+	cmd *exec.Cmd
+	tty *os.File
+
+	cancel context.CancelFunc
+
+	outCtx    context.Context //nolint:containedctx // todo: refactor so this can be removed
+	outCancel context.CancelFunc
+
+	stdinMu sync.Mutex
+	stdin   io.WriteCloser
+
+	DataEvent *MultiplexedChannel[rpc.ProcessEvent_Data]
+	EndEvent  *MultiplexedChannel[rpc.ProcessEvent_End]
+}
+
+// This method must be called only after the process has been started
+func (p *Handler) Pid() uint32 {
+	return uint32(p.cmd.Process.Pid)
+}
+
+// userCommand returns a human-readable representation of the user's original command,
+// without the internal OOM/nice wrapper that is prepended to the actual exec.
+func (p *Handler) userCommand() string {
+	return strings.Join(append([]string{p.Config.GetCmd()}, p.Config.GetArgs()...), " ")
+}
+
+// currentNice returns the nice value of the current process.
+func currentNice() int {
+	prio, err := syscall.Getpriority(syscall.PRIO_PROCESS, 0)
+	if err != nil {
+		return 0
+	}
+
+	// Getpriority returns 20 - nice on Linux.
+	return 20 - prio
+}
+
+func New(
+	ctx context.Context,
+	user *user.User,
+	req *rpc.StartRequest,
+	logger *zerolog.Logger,
+	defaults *execcontext.Defaults,
+	cgroupManager cgroups.Manager,
+	cancel context.CancelFunc,
+) (*Handler, error) {
+	// User command string for logging (without the internal wrapper details).
+	userCmd := strings.Join(append([]string{req.GetProcess().GetCmd()}, req.GetProcess().GetArgs()...), " ")
+
+	// Wrap the command in a shell that sets the OOM score and nice value before exec-ing the actual command.
+	// This eliminates the race window where grandchildren could inherit the parent's protected OOM score (-1000)
+	// or high CPU priority (nice -20) before the post-start calls had a chance to correct them.
+	// nice(1) applies a relative adjustment, so we compute the delta from the current (inherited) nice to the target.
+	niceDelta := defaultNice - currentNice()
+	oomWrapperScript := fmt.Sprintf(`echo %d > /proc/$$/oom_score_adj && exec /usr/bin/nice -n %d "${@}"`, defaultOomScore, niceDelta)
+	wrapperArgs := append([]string{"-c", oomWrapperScript, "--", req.GetProcess().GetCmd()}, req.GetProcess().GetArgs()...)
+	cmd := exec.CommandContext(ctx, "/bin/sh", wrapperArgs...)
+
+	uid, gid, err := permissions.GetUserIdUints(user)
+	if err != nil {
+		return nil, connect.NewError(connect.CodeInternal, err)
+	}
+
+	groups := []uint32{gid}
+	if gids, err := user.GroupIds(); err != nil {
+		logger.Warn().Err(err).Str("user", user.Username).Msg("failed to get supplementary groups")
+	} else {
+		for _, g := range gids {
+			if parsed, err := strconv.ParseUint(g, 10, 32); err == nil {
+				groups = append(groups, uint32(parsed))
+			}
+		}
+	}
+
+	cgroupFD, ok := cgroupManager.GetFileDescriptor(getProcType(req))
+
+	cmd.SysProcAttr = &syscall.SysProcAttr{
+		UseCgroupFD: ok,
+		CgroupFD:    cgroupFD,
+		Credential: &syscall.Credential{
+			Uid:    uid,
+			Gid:    gid,
+			Groups: groups,
+		},
+	}
+
+	resolvedPath, err := permissions.ExpandAndResolve(req.GetProcess().GetCwd(), user, defaults.Workdir)
+	if err != nil {
+		return nil, connect.NewError(connect.CodeInvalidArgument, err)
+	}
+
+	// Check if the cwd resolved path exists
+	if _, err := os.Stat(resolvedPath); errors.Is(err, os.ErrNotExist) {
+		return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("cwd '%s' does not exist", resolvedPath))
+	}
+
+	cmd.Dir = resolvedPath
+
+	var formattedVars []string
+
+	// Take only 'PATH' variable from the current environment
+	// The 'PATH' should ideally be set in the environment
+	formattedVars = append(formattedVars, "PATH="+os.Getenv("PATH"))
+	formattedVars = append(formattedVars, "HOME="+user.HomeDir)
+	formattedVars = append(formattedVars, "USER="+user.Username)
+	formattedVars = append(formattedVars, "LOGNAME="+user.Username)
+
+	// Add the environment variables from the global environment
+	if defaults.EnvVars != nil {
+		defaults.EnvVars.Range(func(key string, value string) bool {
+			formattedVars = append(formattedVars, key+"="+value)
+
+			return true
+		})
+	}
+
+	// Only the last values of the env vars are used - this allows for overwriting defaults
+	for key, value := range req.GetProcess().GetEnvs() {
+		formattedVars = append(formattedVars, key+"="+value)
+	}
+
+	cmd.Env = formattedVars
+
+	outMultiplex := NewMultiplexedChannel[rpc.ProcessEvent_Data](outputBufferSize)
+
+	var outWg sync.WaitGroup
+
+	// Create a context for waiting for and cancelling output pipes.
+	// Cancellation of the process via timeout will propagate and cancel this context too.
+	outCtx, outCancel := context.WithCancel(ctx)
+
+	h := &Handler{
+		Config:    req.GetProcess(),
+		cmd:       cmd,
+		Tag:       req.Tag,
+		DataEvent: outMultiplex,
+		cancel:    cancel,
+		outCtx:    outCtx,
+		outCancel: outCancel,
+		EndEvent:  NewMultiplexedChannel[rpc.ProcessEvent_End](0),
+		logger:    logger,
+	}
+
+	if req.GetPty() != nil {
+		// The pty should ideally start only in the Start method, but the package does not support that and we would have to code it manually.
+		// The output of the pty should correctly be passed though.
+		tty, err := pty.StartWithSize(cmd, &pty.Winsize{
+			Cols: uint16(req.GetPty().GetSize().GetCols()),
+			Rows: uint16(req.GetPty().GetSize().GetRows()),
+		})
+		if err != nil {
+			return nil, connect.NewError(connect.CodeInvalidArgument, fmt.Errorf("error starting pty with command '%s' in dir '%s' with '%d' cols and '%d' rows: %w", userCmd, cmd.Dir, req.GetPty().GetSize().GetCols(), req.GetPty().GetSize().GetRows(), err))
+		}
+
+		outWg.Go(func() {
+			for {
+				buf := make([]byte, ptyChunkSize)
+
+				n, readErr := tty.Read(buf)
+
+				if n > 0 {
+					outMultiplex.Source <- rpc.ProcessEvent_Data{
+						Data: &rpc.ProcessEvent_DataEvent{
+							Output: &rpc.ProcessEvent_DataEvent_Pty{
+								Pty: buf[:n],
+							},
+						},
+					}
+				}
+
+				if errors.Is(readErr, io.EOF) {
+					break
+				}
+
+				if readErr != nil {
+					fmt.Fprintf(os.Stderr, "error reading from pty: %s\n", readErr)
+
+					break
+				}
+			}
+		})
+
+		h.tty = tty
+	} else {
+		stdout, err := cmd.StdoutPipe()
+		if err != nil {
+			return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("error creating stdout pipe for command '%s': %w", userCmd, err))
+		}
+
+		outWg.Go(func() {
+			stdoutLogs := make(chan []byte, outputBufferSize)
+			defer close(stdoutLogs)
+
+			stdoutLogger := logger.With().Str("event_type", "stdout").Logger()
+
+			go logs.LogBufferedDataEvents(stdoutLogs, &stdoutLogger, "data")
+
+			for {
+				buf := make([]byte, stdChunkSize)
+
+				n, readErr := stdout.Read(buf)
+
+				if n > 0 {
+					outMultiplex.Source <- rpc.ProcessEvent_Data{
+						Data: &rpc.ProcessEvent_DataEvent{
+							Output: &rpc.ProcessEvent_DataEvent_Stdout{
+								Stdout: buf[:n],
+							},
+						},
+					}
+
+					stdoutLogs <- buf[:n]
+				}
+
+				if errors.Is(readErr, io.EOF) {
+					break
+				}
+
+				if readErr != nil {
+					fmt.Fprintf(os.Stderr, "error reading from stdout: %s\n", readErr)
+
+					break
+				}
+			}
+		})
+
+		stderr, err := cmd.StderrPipe()
+		if err != nil {
+			return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("error creating stderr pipe for command '%s': %w", userCmd, err))
+		}
+
+		outWg.Go(func() {
+			stderrLogs := make(chan []byte, outputBufferSize)
+			defer close(stderrLogs)
+
+			stderrLogger := logger.With().Str("event_type", "stderr").Logger()
+
+			go logs.LogBufferedDataEvents(stderrLogs, &stderrLogger, "data")
+
+			for {
+				buf := make([]byte, stdChunkSize)
+
+				n, readErr := stderr.Read(buf)
+
+				if n > 0 {
+					outMultiplex.Source <- rpc.ProcessEvent_Data{
+						Data: &rpc.ProcessEvent_DataEvent{
+							Output: &rpc.ProcessEvent_DataEvent_Stderr{
+								Stderr: buf[:n],
+							},
+						},
+					}
+
+					stderrLogs <- buf[:n]
+				}
+
+				if errors.Is(readErr, io.EOF) {
+					break
+				}
+
+				if readErr != nil {
+					fmt.Fprintf(os.Stderr, "error reading from stderr: %s\n", readErr)
+
+					break
+				}
+			}
+		})
+
+		// For backwards compatibility we still set the stdin if not explicitly disabled
+		// If stdin is disabled, the process will use /dev/null as stdin
+		if req.Stdin == nil || req.GetStdin() == true {
+			stdin, err := cmd.StdinPipe()
+			if err != nil {
+				return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("error creating stdin pipe for command '%s': %w", userCmd, err))
+			}
+
+			h.stdin = stdin
+		}
+	}
+
+	go func() {
+		outWg.Wait()
+
+		close(outMultiplex.Source)
+
+		outCancel()
+	}()
+
+	return h, nil
+}
+
+func getProcType(req *rpc.StartRequest) cgroups.ProcessType {
+	if req != nil && req.GetPty() != nil {
+		return cgroups.ProcessTypePTY
+	}
+
+	return cgroups.ProcessTypeUser
+}
+
+func (p *Handler) SendSignal(signal syscall.Signal) error {
+	if p.cmd.Process == nil {
+		return fmt.Errorf("process not started")
+	}
+
+	if signal == syscall.SIGKILL || signal == syscall.SIGTERM {
+		p.outCancel()
+	}
+
+	return p.cmd.Process.Signal(signal)
+}
+
+func (p *Handler) ResizeTty(size *pty.Winsize) error {
+	if p.tty == nil {
+		return fmt.Errorf("tty not assigned to process")
+	}
+
+	return pty.Setsize(p.tty, size)
+}
+
+func (p *Handler) WriteStdin(data []byte) error {
+	if p.tty != nil {
+		return fmt.Errorf("tty assigned to process — input should be written to the pty, not the stdin")
+	}
+
+	p.stdinMu.Lock()
+	defer p.stdinMu.Unlock()
+
+	if p.stdin == nil {
+		return fmt.Errorf("stdin not enabled or closed")
+	}
+
+	_, err := p.stdin.Write(data)
+	if err != nil {
+		return fmt.Errorf("error writing to stdin of process '%d': %w", p.cmd.Process.Pid, err)
+	}
+
+	return nil
+}
+
+// CloseStdin closes the stdin pipe to signal EOF to the process.
+// Only works for non-PTY processes.
+func (p *Handler) CloseStdin() error {
+	if p.tty != nil {
+		return fmt.Errorf("cannot close stdin for PTY process — send Ctrl+D (0x04) instead")
+	}
+
+	p.stdinMu.Lock()
+	defer p.stdinMu.Unlock()
+
+	if p.stdin == nil {
+		return nil
+	}
+
+	err := p.stdin.Close()
+	// We still set the stdin to nil even on error as there are no errors,
+	// for which it is really safe to retry close across all distributions.
+	p.stdin = nil
+
+	return err
+}
+
+func (p *Handler) WriteTty(data []byte) error {
+	if p.tty == nil {
+		return fmt.Errorf("tty not assigned to process — input should be written to the stdin, not the tty")
+	}
+
+	_, err := p.tty.Write(data)
+	if err != nil {
+		return fmt.Errorf("error writing to tty of process '%d': %w", p.cmd.Process.Pid, err)
+	}
+
+	return nil
+}
+
+func (p *Handler) Start() (uint32, error) {
+	// Pty is already started in the New method
+	if p.tty == nil {
+		err := p.cmd.Start()
+		if err != nil {
+			return 0, fmt.Errorf("error starting process '%s': %w", p.userCommand(), err)
+		}
+	}
+
+	p.logger.
+		Info().
+		Str("event_type", "process_start").
+		Int("pid", p.cmd.Process.Pid).
+		Str("command", p.userCommand()).
+		Msg(fmt.Sprintf("Process with pid %d started", p.cmd.Process.Pid))
+
+	return uint32(p.cmd.Process.Pid), nil
+}
+
+func (p *Handler) Wait() {
+	// Wait for the output pipes to be closed or cancelled.
+	<-p.outCtx.Done()
+
+	err := p.cmd.Wait()
+
+	p.tty.Close()
+
+	var errMsg *string
+
+	if err != nil {
+		msg := err.Error()
+		errMsg = &msg
+	}
+
+	endEvent := &rpc.ProcessEvent_EndEvent{
+		Error:    errMsg,
+		ExitCode: int32(p.cmd.ProcessState.ExitCode()),
+		Exited:   p.cmd.ProcessState.Exited(),
+		Status:   p.cmd.ProcessState.String(),
+	}
+
+	event := rpc.ProcessEvent_End{
+		End: endEvent,
+	}
+
+	p.EndEvent.Source <- event
+
+	p.logger.
+		Info().
+		Str("event_type", "process_end").
+		Interface("process_result", endEvent).
+		Msg(fmt.Sprintf("Process with pid %d ended", p.cmd.Process.Pid))
+
+	// Ensure the process cancel is called to cleanup resources.
+	// As it is called after end event and Wait, it should not affect command execution or returned events.
+	p.cancel()
+}

envd/internal/services/process/handler/multiplex.go

@@ -0,0 +1,73 @@
+package handler
+
+import (
+	"sync"
+	"sync/atomic"
+)
+
+type MultiplexedChannel[T any] struct {
+	Source   chan T
+	channels []chan T
+	mu       sync.RWMutex
+	exited   atomic.Bool
+}
+
+func NewMultiplexedChannel[T any](buffer int) *MultiplexedChannel[T] {
+	c := &MultiplexedChannel[T]{
+		channels: nil,
+		Source:   make(chan T, buffer),
+	}
+
+	go func() {
+		for v := range c.Source {
+			c.mu.RLock()
+
+			for _, cons := range c.channels {
+				cons <- v
+			}
+
+			c.mu.RUnlock()
+		}
+
+		c.exited.Store(true)
+
+		for _, cons := range c.channels {
+			close(cons)
+		}
+	}()
+
+	return c
+}
+
+func (m *MultiplexedChannel[T]) Fork() (chan T, func()) {
+	if m.exited.Load() {
+		ch := make(chan T)
+		close(ch)
+
+		return ch, func() {}
+	}
+
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	consumer := make(chan T)
+
+	m.channels = append(m.channels, consumer)
+
+	return consumer, func() {
+		m.remove(consumer)
+	}
+}
+
+func (m *MultiplexedChannel[T]) remove(consumer chan T) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	for i, ch := range m.channels {
+		if ch == consumer {
+			m.channels = append(m.channels[:i], m.channels[i+1:]...)
+
+			return
+		}
+	}
+}

envd/internal/services/process/input.go

@@ -0,0 +1,107 @@
+package process
+
+import (
+	"context"
+	"fmt"
+
+	"connectrpc.com/connect"
+	"github.com/rs/zerolog"
+
+	"git.omukk.dev/wrenn/sandbox/envd/internal/logs"
+	"git.omukk.dev/wrenn/sandbox/envd/internal/services/process/handler"
+	rpc "git.omukk.dev/wrenn/sandbox/envd/internal/services/spec/process"
+)
+
+func handleInput(ctx context.Context, process *handler.Handler, in *rpc.ProcessInput, logger *zerolog.Logger) error {
+	switch in.GetInput().(type) {
+	case *rpc.ProcessInput_Pty:
+		err := process.WriteTty(in.GetPty())
+		if err != nil {
+			return connect.NewError(connect.CodeInternal, fmt.Errorf("error writing to tty: %w", err))
+		}
+
+	case *rpc.ProcessInput_Stdin:
+		err := process.WriteStdin(in.GetStdin())
+		if err != nil {
+			return connect.NewError(connect.CodeInternal, fmt.Errorf("error writing to stdin: %w", err))
+		}
+
+		logger.Debug().
+			Str("event_type", "stdin").
+			Interface("stdin", in.GetStdin()).
+			Str(string(logs.OperationIDKey), ctx.Value(logs.OperationIDKey).(string)).
+			Msg("Streaming input to process")
+
+	default:
+		return connect.NewError(connect.CodeUnimplemented, fmt.Errorf("invalid input type %T", in.GetInput()))
+	}
+
+	return nil
+}
+
+func (s *Service) SendInput(ctx context.Context, req *connect.Request[rpc.SendInputRequest]) (*connect.Response[rpc.SendInputResponse], error) {
+	proc, err := s.getProcess(req.Msg.GetProcess())
+	if err != nil {
+		return nil, err
+	}
+
+	err = handleInput(ctx, proc, req.Msg.GetInput(), s.logger)
+	if err != nil {
+		return nil, err
+	}
+
+	return connect.NewResponse(&rpc.SendInputResponse{}), nil
+}
+
+func (s *Service) StreamInput(ctx context.Context, stream *connect.ClientStream[rpc.StreamInputRequest]) (*connect.Response[rpc.StreamInputResponse], error) {
+	return logs.LogClientStreamWithoutEvents(ctx, s.logger, stream, s.streamInputHandler)
+}
+
+func (s *Service) streamInputHandler(ctx context.Context, stream *connect.ClientStream[rpc.StreamInputRequest]) (*connect.Response[rpc.StreamInputResponse], error) {
+	var proc *handler.Handler
+
+	for stream.Receive() {
+		req := stream.Msg()
+
+		switch req.GetEvent().(type) {
+		case *rpc.StreamInputRequest_Start:
+			p, err := s.getProcess(req.GetStart().GetProcess())
+			if err != nil {
+				return nil, err
+			}
+
+			proc = p
+		case *rpc.StreamInputRequest_Data:
+			err := handleInput(ctx, proc, req.GetData().GetInput(), s.logger)
+			if err != nil {
+				return nil, err
+			}
+		case *rpc.StreamInputRequest_Keepalive:
+		default:
+			return nil, connect.NewError(connect.CodeUnimplemented, fmt.Errorf("invalid event type %T", req.GetEvent()))
+		}
+	}
+
+	err := stream.Err()
+	if err != nil {
+		return nil, connect.NewError(connect.CodeUnknown, fmt.Errorf("error streaming input: %w", err))
+	}
+
+	return connect.NewResponse(&rpc.StreamInputResponse{}), nil
+}
+
+func (s *Service) CloseStdin(
+	_ context.Context,
+	req *connect.Request[rpc.CloseStdinRequest],
+) (*connect.Response[rpc.CloseStdinResponse], error) {
+	handler, err := s.getProcess(req.Msg.GetProcess())
+	if err != nil {
+		return nil, err
+	}
+
+	if err := handler.CloseStdin(); err != nil {
+		return nil, connect.NewError(connect.CodeUnknown, fmt.Errorf("error closing stdin: %w", err))
+	}
+
+	return connect.NewResponse(&rpc.CloseStdinResponse{}), nil
+}

envd/internal/services/process/list.go

@@ -0,0 +1,28 @@
+package process
+
+import (
+	"context"
+
+	"connectrpc.com/connect"
+
+	"git.omukk.dev/wrenn/sandbox/envd/internal/services/process/handler"
+	rpc "git.omukk.dev/wrenn/sandbox/envd/internal/services/spec/process"
+)
+
+func (s *Service) List(context.Context, *connect.Request[rpc.ListRequest]) (*connect.Response[rpc.ListResponse], error) {
+	processes := make([]*rpc.ProcessInfo, 0)
+
+	s.processes.Range(func(pid uint32, value *handler.Handler) bool {
+		processes = append(processes, &rpc.ProcessInfo{
+			Pid:    pid,
+			Tag:    value.Tag,
+			Config: value.Config,
+		})
+
+		return true
+	})
+
+	return connect.NewResponse(&rpc.ListResponse{
+		Processes: processes,
+	}), nil
+}

envd/internal/services/process/service.go

@@ -0,0 +1,84 @@
+package process
+
+import (
+	"fmt"
+
+	"connectrpc.com/connect"
+	"github.com/go-chi/chi/v5"
+	"github.com/rs/zerolog"
+
+	"git.omukk.dev/wrenn/sandbox/envd/internal/execcontext"
+	"git.omukk.dev/wrenn/sandbox/envd/internal/logs"
+	"git.omukk.dev/wrenn/sandbox/envd/internal/services/cgroups"
+	"git.omukk.dev/wrenn/sandbox/envd/internal/services/process/handler"
+	rpc "git.omukk.dev/wrenn/sandbox/envd/internal/services/spec/process"
+	spec "git.omukk.dev/wrenn/sandbox/envd/internal/services/spec/process/processconnect"
+	"git.omukk.dev/wrenn/sandbox/envd/internal/utils"
+)
+
+type Service struct {
+	processes     *utils.Map[uint32, *handler.Handler]
+	logger        *zerolog.Logger
+	defaults      *execcontext.Defaults
+	cgroupManager cgroups.Manager
+}
+
+func newService(l *zerolog.Logger, defaults *execcontext.Defaults, cgroupManager cgroups.Manager) *Service {
+	return &Service{
+		logger:        l,
+		processes:     utils.NewMap[uint32, *handler.Handler](),
+		defaults:      defaults,
+		cgroupManager: cgroupManager,
+	}
+}
+
+func Handle(server *chi.Mux, l *zerolog.Logger, defaults *execcontext.Defaults, cgroupManager cgroups.Manager) *Service {
+	service := newService(l, defaults, cgroupManager)
+
+	interceptors := connect.WithInterceptors(logs.NewUnaryLogInterceptor(l))
+
+	path, h := spec.NewProcessHandler(service, interceptors)
+
+	server.Mount(path, h)
+
+	return service
+}
+
+func (s *Service) getProcess(selector *rpc.ProcessSelector) (*handler.Handler, error) {
+	var proc *handler.Handler
+
+	switch selector.GetSelector().(type) {
+	case *rpc.ProcessSelector_Pid:
+		p, ok := s.processes.Load(selector.GetPid())
+		if !ok {
+			return nil, connect.NewError(connect.CodeNotFound, fmt.Errorf("process with pid %d not found", selector.GetPid()))
+		}
+
+		proc = p
+	case *rpc.ProcessSelector_Tag:
+		tag := selector.GetTag()
+
+		s.processes.Range(func(_ uint32, value *handler.Handler) bool {
+			if value.Tag == nil {
+				return true
+			}
+
+			if *value.Tag == tag {
+				proc = value
+
+				return true
+			}
+
+			return false
+		})
+
+		if proc == nil {
+			return nil, connect.NewError(connect.CodeNotFound, fmt.Errorf("process with tag %s not found", tag))
+		}
+
+	default:
+		return nil, connect.NewError(connect.CodeUnimplemented, fmt.Errorf("invalid input type %T", selector))
+	}
+
+	return proc, nil
+}

envd/internal/services/process/signal.go

@@ -0,0 +1,38 @@
+package process
+
+import (
+	"context"
+	"fmt"
+	"syscall"
+
+	"connectrpc.com/connect"
+
+	rpc "git.omukk.dev/wrenn/sandbox/envd/internal/services/spec/process"
+)
+
+func (s *Service) SendSignal(
+	_ context.Context,
+	req *connect.Request[rpc.SendSignalRequest],
+) (*connect.Response[rpc.SendSignalResponse], error) {
+	handler, err := s.getProcess(req.Msg.GetProcess())
+	if err != nil {
+		return nil, err
+	}
+
+	var signal syscall.Signal
+	switch req.Msg.GetSignal() {
+	case rpc.Signal_SIGNAL_SIGKILL:
+		signal = syscall.SIGKILL
+	case rpc.Signal_SIGNAL_SIGTERM:
+		signal = syscall.SIGTERM
+	default:
+		return nil, connect.NewError(connect.CodeUnimplemented, fmt.Errorf("invalid signal: %s", req.Msg.GetSignal()))
+	}
+
+	err = handler.SendSignal(signal)
+	if err != nil {
+		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("error sending signal: %w", err))
+	}
+
+	return connect.NewResponse(&rpc.SendSignalResponse{}), nil
+}

envd/internal/services/process/start.go

@@ -0,0 +1,247 @@
+package process
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net/http"
+	"os/user"
+	"strconv"
+	"time"
+
+	"connectrpc.com/connect"
+
+	"git.omukk.dev/wrenn/sandbox/envd/internal/logs"
+	"git.omukk.dev/wrenn/sandbox/envd/internal/permissions"
+	"git.omukk.dev/wrenn/sandbox/envd/internal/services/process/handler"
+	rpc "git.omukk.dev/wrenn/sandbox/envd/internal/services/spec/process"
+)
+
+func (s *Service) InitializeStartProcess(ctx context.Context, user *user.User, req *rpc.StartRequest) error {
+	var err error
+
+	ctx = logs.AddRequestIDToContext(ctx)
+
+	defer s.logger.
+		Err(err).
+		Interface("request", req).
+		Str(string(logs.OperationIDKey), ctx.Value(logs.OperationIDKey).(string)).
+		Msg("Initialized startCmd")
+
+	handlerL := s.logger.With().Str(string(logs.OperationIDKey), ctx.Value(logs.OperationIDKey).(string)).Logger()
+
+	startProcCtx, startProcCancel := context.WithCancel(ctx)
+	proc, err := handler.New(startProcCtx, user, req, &handlerL, s.defaults, s.cgroupManager, startProcCancel)
+	if err != nil {
+		return err
+	}
+
+	pid, err := proc.Start()
+	if err != nil {
+		return err
+	}
+
+	s.processes.Store(pid, proc)
+
+	go func() {
+		defer s.processes.Delete(pid)
+
+		proc.Wait()
+	}()
+
+	return nil
+}
+
+func (s *Service) Start(ctx context.Context, req *connect.Request[rpc.StartRequest], stream *connect.ServerStream[rpc.StartResponse]) error {
+	return logs.LogServerStreamWithoutEvents(ctx, s.logger, req, stream, s.handleStart)
+}
+
+func (s *Service) handleStart(ctx context.Context, req *connect.Request[rpc.StartRequest], stream *connect.ServerStream[rpc.StartResponse]) error {
+	ctx, cancel := context.WithCancelCause(ctx)
+	defer cancel(nil)
+
+	handlerL := s.logger.With().Str(string(logs.OperationIDKey), ctx.Value(logs.OperationIDKey).(string)).Logger()
+
+	u, err := permissions.GetAuthUser(ctx, s.defaults.User)
+	if err != nil {
+		return err
+	}
+
+	timeout, err := determineTimeoutFromHeader(stream.Conn().RequestHeader())
+	if err != nil {
+		return connect.NewError(connect.CodeInvalidArgument, err)
+	}
+
+	// Create a new context with a timeout if provided.
+	// We do not want the command to be killed if the request context is cancelled
+	procCtx, cancelProc := context.Background(), func() {}
+	if timeout > 0 { // zero timeout means no timeout
+		procCtx, cancelProc = context.WithTimeout(procCtx, timeout)
+	}
+
+	proc, err := handler.New( //nolint:contextcheck // TODO: fix this later
+		procCtx,
+		u,
+		req.Msg,
+		&handlerL,
+		s.defaults,
+		s.cgroupManager,
+		cancelProc,
+	)
+	if err != nil {
+		// Ensure the process cancel is called to cleanup resources.
+		cancelProc()
+
+		return err
+	}
+
+	exitChan := make(chan struct{})
+
+	startMultiplexer := handler.NewMultiplexedChannel[rpc.ProcessEvent_Start](0)
+	defer close(startMultiplexer.Source)
+
+	start, startCancel := startMultiplexer.Fork()
+	defer startCancel()
+
+	data, dataCancel := proc.DataEvent.Fork()
+	defer dataCancel()
+
+	end, endCancel := proc.EndEvent.Fork()
+	defer endCancel()
+
+	go func() {
+		defer close(exitChan)
+
+		select {
+		case <-ctx.Done():
+			cancel(ctx.Err())
+
+			return
+		case event, ok := <-start:
+			if !ok {
+				cancel(connect.NewError(connect.CodeUnknown, errors.New("start event channel closed before sending start event")))
+
+				return
+			}
+
+			streamErr := stream.Send(&rpc.StartResponse{
+				Event: &rpc.ProcessEvent{
+					Event: &event,
+				},
+			})
+			if streamErr != nil {
+				cancel(connect.NewError(connect.CodeUnknown, fmt.Errorf("error sending start event: %w", streamErr)))
+
+				return
+			}
+		}
+
+		keepaliveTicker, resetKeepalive := permissions.GetKeepAliveTicker(req)
+		defer keepaliveTicker.Stop()
+
+	dataLoop:
+		for {
+			select {
+			case <-keepaliveTicker.C:
+				streamErr := stream.Send(&rpc.StartResponse{
+					Event: &rpc.ProcessEvent{
+						Event: &rpc.ProcessEvent_Keepalive{
+							Keepalive: &rpc.ProcessEvent_KeepAlive{},
+						},
+					},
+				})
+				if streamErr != nil {
+					cancel(connect.NewError(connect.CodeUnknown, fmt.Errorf("error sending keepalive: %w", streamErr)))
+
+					return
+				}
+			case <-ctx.Done():
+				cancel(ctx.Err())
+
+				return
+			case event, ok := <-data:
+				if !ok {
+					break dataLoop
+				}
+
+				streamErr := stream.Send(&rpc.StartResponse{
+					Event: &rpc.ProcessEvent{
+						Event: &event,
+					},
+				})
+				if streamErr != nil {
+					cancel(connect.NewError(connect.CodeUnknown, fmt.Errorf("error sending data event: %w", streamErr)))
+
+					return
+				}
+
+				resetKeepalive()
+			}
+		}
+
+		select {
+		case <-ctx.Done():
+			cancel(ctx.Err())
+
+			return
+		case event, ok := <-end:
+			if !ok {
+				cancel(connect.NewError(connect.CodeUnknown, errors.New("end event channel closed before sending end event")))
+
+				return
+			}
+
+			streamErr := stream.Send(&rpc.StartResponse{
+				Event: &rpc.ProcessEvent{
+					Event: &event,
+				},
+			})
+			if streamErr != nil {
+				cancel(connect.NewError(connect.CodeUnknown, fmt.Errorf("error sending end event: %w", streamErr)))
+
+				return
+			}
+		}
+	}()
+
+	pid, err := proc.Start()
+	if err != nil {
+		return connect.NewError(connect.CodeInvalidArgument, err)
+	}
+
+	s.processes.Store(pid, proc)
+
+	start <- rpc.ProcessEvent_Start{
+		Start: &rpc.ProcessEvent_StartEvent{
+			Pid: pid,
+		},
+	}
+
+	go func() {
+		defer s.processes.Delete(pid)
+
+		proc.Wait()
+	}()
+
+	select {
+	case <-ctx.Done():
+		return ctx.Err()
+	case <-exitChan:
+		return nil
+	}
+}
+
+func determineTimeoutFromHeader(header http.Header) (time.Duration, error) {
+	timeoutHeader := header.Get("Connect-Timeout-Ms")
+
+	if timeoutHeader == "" {
+		return 0, nil
+	}
+
+	timeout, err := strconv.Atoi(timeoutHeader)
+	if err != nil {
+		return 0, err
+	}
+
+	return time.Duration(timeout) * time.Millisecond, nil
+}

envd/internal/services/process/update.go

@@ -0,0 +1,30 @@
+package process
+
+import (
+	"context"
+	"fmt"
+
+	"connectrpc.com/connect"
+	"github.com/creack/pty"
+
+	rpc "git.omukk.dev/wrenn/sandbox/envd/internal/services/spec/process"
+)
+
+func (s *Service) Update(_ context.Context, req *connect.Request[rpc.UpdateRequest]) (*connect.Response[rpc.UpdateResponse], error) {
+	proc, err := s.getProcess(req.Msg.GetProcess())
+	if err != nil {
+		return nil, err
+	}
+
+	if req.Msg.GetPty() != nil {
+		err := proc.ResizeTty(&pty.Winsize{
+			Rows: uint16(req.Msg.GetPty().GetSize().GetRows()),
+			Cols: uint16(req.Msg.GetPty().GetSize().GetCols()),
+		})
+		if err != nil {
+			return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("error resizing tty: %w", err))
+		}
+	}
+
+	return connect.NewResponse(&rpc.UpdateResponse{}), nil
+}

envd/internal/services/spec/filesystem/filesystemconnect/filesystem.connect.go

@@ -0,0 +1,337 @@
+// Code generated by protoc-gen-connect-go. DO NOT EDIT.
+//
+// Source: filesystem/filesystem.proto
+
+package filesystemconnect
+
+import (
+	connect "connectrpc.com/connect"
+	context "context"
+	errors "errors"
+	filesystem "git.omukk.dev/wrenn/sandbox/envd/internal/services/spec/filesystem"
+	http "net/http"
+	strings "strings"
+)
+
+// This is a compile-time assertion to ensure that this generated file and the connect package are
+// compatible. If you get a compiler error that this constant is not defined, this code was
+// generated with a version of connect newer than the one compiled into your binary. You can fix the
+// problem by either regenerating this code with an older version of connect or updating the connect
+// version compiled into your binary.
+const _ = connect.IsAtLeastVersion1_13_0
+
+const (
+	// FilesystemName is the fully-qualified name of the Filesystem service.
+	FilesystemName = "filesystem.Filesystem"
+)
+
+// These constants are the fully-qualified names of the RPCs defined in this package. They're
+// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route.
+//
+// Note that these are different from the fully-qualified method names used by
+// google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to
+// reflection-formatted method names, remove the leading slash and convert the remaining slash to a
+// period.
+const (
+	// FilesystemStatProcedure is the fully-qualified name of the Filesystem's Stat RPC.
+	FilesystemStatProcedure = "/filesystem.Filesystem/Stat"
+	// FilesystemMakeDirProcedure is the fully-qualified name of the Filesystem's MakeDir RPC.
+	FilesystemMakeDirProcedure = "/filesystem.Filesystem/MakeDir"
+	// FilesystemMoveProcedure is the fully-qualified name of the Filesystem's Move RPC.
+	FilesystemMoveProcedure = "/filesystem.Filesystem/Move"
+	// FilesystemListDirProcedure is the fully-qualified name of the Filesystem's ListDir RPC.
+	FilesystemListDirProcedure = "/filesystem.Filesystem/ListDir"
+	// FilesystemRemoveProcedure is the fully-qualified name of the Filesystem's Remove RPC.
+	FilesystemRemoveProcedure = "/filesystem.Filesystem/Remove"
+	// FilesystemWatchDirProcedure is the fully-qualified name of the Filesystem's WatchDir RPC.
+	FilesystemWatchDirProcedure = "/filesystem.Filesystem/WatchDir"
+	// FilesystemCreateWatcherProcedure is the fully-qualified name of the Filesystem's CreateWatcher
+	// RPC.
+	FilesystemCreateWatcherProcedure = "/filesystem.Filesystem/CreateWatcher"
+	// FilesystemGetWatcherEventsProcedure is the fully-qualified name of the Filesystem's
+	// GetWatcherEvents RPC.
+	FilesystemGetWatcherEventsProcedure = "/filesystem.Filesystem/GetWatcherEvents"
+	// FilesystemRemoveWatcherProcedure is the fully-qualified name of the Filesystem's RemoveWatcher
+	// RPC.
+	FilesystemRemoveWatcherProcedure = "/filesystem.Filesystem/RemoveWatcher"
+)
+
+// FilesystemClient is a client for the filesystem.Filesystem service.
+type FilesystemClient interface {
+	Stat(context.Context, *connect.Request[filesystem.StatRequest]) (*connect.Response[filesystem.StatResponse], error)
+	MakeDir(context.Context, *connect.Request[filesystem.MakeDirRequest]) (*connect.Response[filesystem.MakeDirResponse], error)
+	Move(context.Context, *connect.Request[filesystem.MoveRequest]) (*connect.Response[filesystem.MoveResponse], error)
+	ListDir(context.Context, *connect.Request[filesystem.ListDirRequest]) (*connect.Response[filesystem.ListDirResponse], error)
+	Remove(context.Context, *connect.Request[filesystem.RemoveRequest]) (*connect.Response[filesystem.RemoveResponse], error)
+	WatchDir(context.Context, *connect.Request[filesystem.WatchDirRequest]) (*connect.ServerStreamForClient[filesystem.WatchDirResponse], error)
+	// Non-streaming versions of WatchDir
+	CreateWatcher(context.Context, *connect.Request[filesystem.CreateWatcherRequest]) (*connect.Response[filesystem.CreateWatcherResponse], error)
+	GetWatcherEvents(context.Context, *connect.Request[filesystem.GetWatcherEventsRequest]) (*connect.Response[filesystem.GetWatcherEventsResponse], error)
+	RemoveWatcher(context.Context, *connect.Request[filesystem.RemoveWatcherRequest]) (*connect.Response[filesystem.RemoveWatcherResponse], error)
+}
+
+// NewFilesystemClient constructs a client for the filesystem.Filesystem service. By default, it
+// uses the Connect protocol with the binary Protobuf Codec, asks for gzipped responses, and sends
+// uncompressed requests. To use the gRPC or gRPC-Web protocols, supply the connect.WithGRPC() or
+// connect.WithGRPCWeb() options.
+//
+// The URL supplied here should be the base URL for the Connect or gRPC server (for example,
+// http://api.acme.com or https://acme.com/grpc).
+func NewFilesystemClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) FilesystemClient {
+	baseURL = strings.TrimRight(baseURL, "/")
+	filesystemMethods := filesystem.File_filesystem_filesystem_proto.Services().ByName("Filesystem").Methods()
+	return &filesystemClient{
+		stat: connect.NewClient[filesystem.StatRequest, filesystem.StatResponse](
+			httpClient,
+			baseURL+FilesystemStatProcedure,
+			connect.WithSchema(filesystemMethods.ByName("Stat")),
+			connect.WithClientOptions(opts...),
+		),
+		makeDir: connect.NewClient[filesystem.MakeDirRequest, filesystem.MakeDirResponse](
+			httpClient,
+			baseURL+FilesystemMakeDirProcedure,
+			connect.WithSchema(filesystemMethods.ByName("MakeDir")),
+			connect.WithClientOptions(opts...),
+		),
+		move: connect.NewClient[filesystem.MoveRequest, filesystem.MoveResponse](
+			httpClient,
+			baseURL+FilesystemMoveProcedure,
+			connect.WithSchema(filesystemMethods.ByName("Move")),
+			connect.WithClientOptions(opts...),
+		),
+		listDir: connect.NewClient[filesystem.ListDirRequest, filesystem.ListDirResponse](
+			httpClient,
+			baseURL+FilesystemListDirProcedure,
+			connect.WithSchema(filesystemMethods.ByName("ListDir")),
+			connect.WithClientOptions(opts...),
+		),
+		remove: connect.NewClient[filesystem.RemoveRequest, filesystem.RemoveResponse](
+			httpClient,
+			baseURL+FilesystemRemoveProcedure,
+			connect.WithSchema(filesystemMethods.ByName("Remove")),
+			connect.WithClientOptions(opts...),
+		),
+		watchDir: connect.NewClient[filesystem.WatchDirRequest, filesystem.WatchDirResponse](
+			httpClient,
+			baseURL+FilesystemWatchDirProcedure,
+			connect.WithSchema(filesystemMethods.ByName("WatchDir")),
+			connect.WithClientOptions(opts...),
+		),
+		createWatcher: connect.NewClient[filesystem.CreateWatcherRequest, filesystem.CreateWatcherResponse](
+			httpClient,
+			baseURL+FilesystemCreateWatcherProcedure,
+			connect.WithSchema(filesystemMethods.ByName("CreateWatcher")),
+			connect.WithClientOptions(opts...),
+		),
+		getWatcherEvents: connect.NewClient[filesystem.GetWatcherEventsRequest, filesystem.GetWatcherEventsResponse](
+			httpClient,
+			baseURL+FilesystemGetWatcherEventsProcedure,
+			connect.WithSchema(filesystemMethods.ByName("GetWatcherEvents")),
+			connect.WithClientOptions(opts...),
+		),
+		removeWatcher: connect.NewClient[filesystem.RemoveWatcherRequest, filesystem.RemoveWatcherResponse](
+			httpClient,
+			baseURL+FilesystemRemoveWatcherProcedure,
+			connect.WithSchema(filesystemMethods.ByName("RemoveWatcher")),
+			connect.WithClientOptions(opts...),
+		),
+	}
+}
+
+// filesystemClient implements FilesystemClient.
+type filesystemClient struct {
+	stat             *connect.Client[filesystem.StatRequest, filesystem.StatResponse]
+	makeDir          *connect.Client[filesystem.MakeDirRequest, filesystem.MakeDirResponse]
+	move             *connect.Client[filesystem.MoveRequest, filesystem.MoveResponse]
+	listDir          *connect.Client[filesystem.ListDirRequest, filesystem.ListDirResponse]
+	remove           *connect.Client[filesystem.RemoveRequest, filesystem.RemoveResponse]
+	watchDir         *connect.Client[filesystem.WatchDirRequest, filesystem.WatchDirResponse]
+	createWatcher    *connect.Client[filesystem.CreateWatcherRequest, filesystem.CreateWatcherResponse]
+	getWatcherEvents *connect.Client[filesystem.GetWatcherEventsRequest, filesystem.GetWatcherEventsResponse]
+	removeWatcher    *connect.Client[filesystem.RemoveWatcherRequest, filesystem.RemoveWatcherResponse]
+}
+
+// Stat calls filesystem.Filesystem.Stat.
+func (c *filesystemClient) Stat(ctx context.Context, req *connect.Request[filesystem.StatRequest]) (*connect.Response[filesystem.StatResponse], error) {
+	return c.stat.CallUnary(ctx, req)
+}
+
+// MakeDir calls filesystem.Filesystem.MakeDir.
+func (c *filesystemClient) MakeDir(ctx context.Context, req *connect.Request[filesystem.MakeDirRequest]) (*connect.Response[filesystem.MakeDirResponse], error) {
+	return c.makeDir.CallUnary(ctx, req)
+}
+
+// Move calls filesystem.Filesystem.Move.
+func (c *filesystemClient) Move(ctx context.Context, req *connect.Request[filesystem.MoveRequest]) (*connect.Response[filesystem.MoveResponse], error) {
+	return c.move.CallUnary(ctx, req)
+}
+
+// ListDir calls filesystem.Filesystem.ListDir.
+func (c *filesystemClient) ListDir(ctx context.Context, req *connect.Request[filesystem.ListDirRequest]) (*connect.Response[filesystem.ListDirResponse], error) {
+	return c.listDir.CallUnary(ctx, req)
+}
+
+// Remove calls filesystem.Filesystem.Remove.
+func (c *filesystemClient) Remove(ctx context.Context, req *connect.Request[filesystem.RemoveRequest]) (*connect.Response[filesystem.RemoveResponse], error) {
+	return c.remove.CallUnary(ctx, req)
+}
+
+// WatchDir calls filesystem.Filesystem.WatchDir.
+func (c *filesystemClient) WatchDir(ctx context.Context, req *connect.Request[filesystem.WatchDirRequest]) (*connect.ServerStreamForClient[filesystem.WatchDirResponse], error) {
+	return c.watchDir.CallServerStream(ctx, req)
+}
+
+// CreateWatcher calls filesystem.Filesystem.CreateWatcher.
+func (c *filesystemClient) CreateWatcher(ctx context.Context, req *connect.Request[filesystem.CreateWatcherRequest]) (*connect.Response[filesystem.CreateWatcherResponse], error) {
+	return c.createWatcher.CallUnary(ctx, req)
+}
+
+// GetWatcherEvents calls filesystem.Filesystem.GetWatcherEvents.
+func (c *filesystemClient) GetWatcherEvents(ctx context.Context, req *connect.Request[filesystem.GetWatcherEventsRequest]) (*connect.Response[filesystem.GetWatcherEventsResponse], error) {
+	return c.getWatcherEvents.CallUnary(ctx, req)
+}
+
+// RemoveWatcher calls filesystem.Filesystem.RemoveWatcher.
+func (c *filesystemClient) RemoveWatcher(ctx context.Context, req *connect.Request[filesystem.RemoveWatcherRequest]) (*connect.Response[filesystem.RemoveWatcherResponse], error) {
+	return c.removeWatcher.CallUnary(ctx, req)
+}
+
+// FilesystemHandler is an implementation of the filesystem.Filesystem service.
+type FilesystemHandler interface {
+	Stat(context.Context, *connect.Request[filesystem.StatRequest]) (*connect.Response[filesystem.StatResponse], error)
+	MakeDir(context.Context, *connect.Request[filesystem.MakeDirRequest]) (*connect.Response[filesystem.MakeDirResponse], error)
+	Move(context.Context, *connect.Request[filesystem.MoveRequest]) (*connect.Response[filesystem.MoveResponse], error)
+	ListDir(context.Context, *connect.Request[filesystem.ListDirRequest]) (*connect.Response[filesystem.ListDirResponse], error)
+	Remove(context.Context, *connect.Request[filesystem.RemoveRequest]) (*connect.Response[filesystem.RemoveResponse], error)
+	WatchDir(context.Context, *connect.Request[filesystem.WatchDirRequest], *connect.ServerStream[filesystem.WatchDirResponse]) error
+	// Non-streaming versions of WatchDir
+	CreateWatcher(context.Context, *connect.Request[filesystem.CreateWatcherRequest]) (*connect.Response[filesystem.CreateWatcherResponse], error)
+	GetWatcherEvents(context.Context, *connect.Request[filesystem.GetWatcherEventsRequest]) (*connect.Response[filesystem.GetWatcherEventsResponse], error)
+	RemoveWatcher(context.Context, *connect.Request[filesystem.RemoveWatcherRequest]) (*connect.Response[filesystem.RemoveWatcherResponse], error)
+}
+
+// NewFilesystemHandler builds an HTTP handler from the service implementation. It returns the path
+// on which to mount the handler and the handler itself.
+//
+// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf
+// and JSON codecs. They also support gzip compression.
+func NewFilesystemHandler(svc FilesystemHandler, opts ...connect.HandlerOption) (string, http.Handler) {
+	filesystemMethods := filesystem.File_filesystem_filesystem_proto.Services().ByName("Filesystem").Methods()
+	filesystemStatHandler := connect.NewUnaryHandler(
+		FilesystemStatProcedure,
+		svc.Stat,
+		connect.WithSchema(filesystemMethods.ByName("Stat")),
+		connect.WithHandlerOptions(opts...),
+	)
+	filesystemMakeDirHandler := connect.NewUnaryHandler(
+		FilesystemMakeDirProcedure,
+		svc.MakeDir,
+		connect.WithSchema(filesystemMethods.ByName("MakeDir")),
+		connect.WithHandlerOptions(opts...),
+	)
+	filesystemMoveHandler := connect.NewUnaryHandler(
+		FilesystemMoveProcedure,
+		svc.Move,
+		connect.WithSchema(filesystemMethods.ByName("Move")),
+		connect.WithHandlerOptions(opts...),
+	)
+	filesystemListDirHandler := connect.NewUnaryHandler(
+		FilesystemListDirProcedure,
+		svc.ListDir,
+		connect.WithSchema(filesystemMethods.ByName("ListDir")),
+		connect.WithHandlerOptions(opts...),
+	)
+	filesystemRemoveHandler := connect.NewUnaryHandler(
+		FilesystemRemoveProcedure,
+		svc.Remove,
+		connect.WithSchema(filesystemMethods.ByName("Remove")),
+		connect.WithHandlerOptions(opts...),
+	)
+	filesystemWatchDirHandler := connect.NewServerStreamHandler(
+		FilesystemWatchDirProcedure,
+		svc.WatchDir,
+		connect.WithSchema(filesystemMethods.ByName("WatchDir")),
+		connect.WithHandlerOptions(opts...),
+	)
+	filesystemCreateWatcherHandler := connect.NewUnaryHandler(
+		FilesystemCreateWatcherProcedure,
+		svc.CreateWatcher,
+		connect.WithSchema(filesystemMethods.ByName("CreateWatcher")),
+		connect.WithHandlerOptions(opts...),
+	)
+	filesystemGetWatcherEventsHandler := connect.NewUnaryHandler(
+		FilesystemGetWatcherEventsProcedure,
+		svc.GetWatcherEvents,
+		connect.WithSchema(filesystemMethods.ByName("GetWatcherEvents")),
+		connect.WithHandlerOptions(opts...),
+	)
+	filesystemRemoveWatcherHandler := connect.NewUnaryHandler(
+		FilesystemRemoveWatcherProcedure,
+		svc.RemoveWatcher,
+		connect.WithSchema(filesystemMethods.ByName("RemoveWatcher")),
+		connect.WithHandlerOptions(opts...),
+	)
+	return "/filesystem.Filesystem/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case FilesystemStatProcedure:
+			filesystemStatHandler.ServeHTTP(w, r)
+		case FilesystemMakeDirProcedure:
+			filesystemMakeDirHandler.ServeHTTP(w, r)
+		case FilesystemMoveProcedure:
+			filesystemMoveHandler.ServeHTTP(w, r)
+		case FilesystemListDirProcedure:
+			filesystemListDirHandler.ServeHTTP(w, r)
+		case FilesystemRemoveProcedure:
+			filesystemRemoveHandler.ServeHTTP(w, r)
+		case FilesystemWatchDirProcedure:
+			filesystemWatchDirHandler.ServeHTTP(w, r)
+		case FilesystemCreateWatcherProcedure:
+			filesystemCreateWatcherHandler.ServeHTTP(w, r)
+		case FilesystemGetWatcherEventsProcedure:
+			filesystemGetWatcherEventsHandler.ServeHTTP(w, r)
+		case FilesystemRemoveWatcherProcedure:
+			filesystemRemoveWatcherHandler.ServeHTTP(w, r)
+		default:
+			http.NotFound(w, r)
+		}
+	})
+}
+
+// UnimplementedFilesystemHandler returns CodeUnimplemented from all methods.
+type UnimplementedFilesystemHandler struct{}
+
+func (UnimplementedFilesystemHandler) Stat(context.Context, *connect.Request[filesystem.StatRequest]) (*connect.Response[filesystem.StatResponse], error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("filesystem.Filesystem.Stat is not implemented"))
+}
+
+func (UnimplementedFilesystemHandler) MakeDir(context.Context, *connect.Request[filesystem.MakeDirRequest]) (*connect.Response[filesystem.MakeDirResponse], error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("filesystem.Filesystem.MakeDir is not implemented"))
+}
+
+func (UnimplementedFilesystemHandler) Move(context.Context, *connect.Request[filesystem.MoveRequest]) (*connect.Response[filesystem.MoveResponse], error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("filesystem.Filesystem.Move is not implemented"))
+}
+
+func (UnimplementedFilesystemHandler) ListDir(context.Context, *connect.Request[filesystem.ListDirRequest]) (*connect.Response[filesystem.ListDirResponse], error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("filesystem.Filesystem.ListDir is not implemented"))
+}
+
+func (UnimplementedFilesystemHandler) Remove(context.Context, *connect.Request[filesystem.RemoveRequest]) (*connect.Response[filesystem.RemoveResponse], error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("filesystem.Filesystem.Remove is not implemented"))
+}
+
+func (UnimplementedFilesystemHandler) WatchDir(context.Context, *connect.Request[filesystem.WatchDirRequest], *connect.ServerStream[filesystem.WatchDirResponse]) error {
+	return connect.NewError(connect.CodeUnimplemented, errors.New("filesystem.Filesystem.WatchDir is not implemented"))
+}
+
+func (UnimplementedFilesystemHandler) CreateWatcher(context.Context, *connect.Request[filesystem.CreateWatcherRequest]) (*connect.Response[filesystem.CreateWatcherResponse], error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("filesystem.Filesystem.CreateWatcher is not implemented"))
+}
+
+func (UnimplementedFilesystemHandler) GetWatcherEvents(context.Context, *connect.Request[filesystem.GetWatcherEventsRequest]) (*connect.Response[filesystem.GetWatcherEventsResponse], error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("filesystem.Filesystem.GetWatcherEvents is not implemented"))
+}
+
+func (UnimplementedFilesystemHandler) RemoveWatcher(context.Context, *connect.Request[filesystem.RemoveWatcherRequest]) (*connect.Response[filesystem.RemoveWatcherResponse], error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("filesystem.Filesystem.RemoveWatcher is not implemented"))
+}

envd/internal/services/spec/process/processconnect/process.connect.go

@@ -0,0 +1,310 @@
+// Code generated by protoc-gen-connect-go. DO NOT EDIT.
+//
+// Source: process/process.proto
+
+package processconnect
+
+import (
+	connect "connectrpc.com/connect"
+	context "context"
+	errors "errors"
+	process "git.omukk.dev/wrenn/sandbox/envd/internal/services/spec/process"
+	http "net/http"
+	strings "strings"
+)
+
+// This is a compile-time assertion to ensure that this generated file and the connect package are
+// compatible. If you get a compiler error that this constant is not defined, this code was
+// generated with a version of connect newer than the one compiled into your binary. You can fix the
+// problem by either regenerating this code with an older version of connect or updating the connect
+// version compiled into your binary.
+const _ = connect.IsAtLeastVersion1_13_0
+
+const (
+	// ProcessName is the fully-qualified name of the Process service.
+	ProcessName = "process.Process"
+)
+
+// These constants are the fully-qualified names of the RPCs defined in this package. They're
+// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route.
+//
+// Note that these are different from the fully-qualified method names used by
+// google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to
+// reflection-formatted method names, remove the leading slash and convert the remaining slash to a
+// period.
+const (
+	// ProcessListProcedure is the fully-qualified name of the Process's List RPC.
+	ProcessListProcedure = "/process.Process/List"
+	// ProcessConnectProcedure is the fully-qualified name of the Process's Connect RPC.
+	ProcessConnectProcedure = "/process.Process/Connect"
+	// ProcessStartProcedure is the fully-qualified name of the Process's Start RPC.
+	ProcessStartProcedure = "/process.Process/Start"
+	// ProcessUpdateProcedure is the fully-qualified name of the Process's Update RPC.
+	ProcessUpdateProcedure = "/process.Process/Update"
+	// ProcessStreamInputProcedure is the fully-qualified name of the Process's StreamInput RPC.
+	ProcessStreamInputProcedure = "/process.Process/StreamInput"
+	// ProcessSendInputProcedure is the fully-qualified name of the Process's SendInput RPC.
+	ProcessSendInputProcedure = "/process.Process/SendInput"
+	// ProcessSendSignalProcedure is the fully-qualified name of the Process's SendSignal RPC.
+	ProcessSendSignalProcedure = "/process.Process/SendSignal"
+	// ProcessCloseStdinProcedure is the fully-qualified name of the Process's CloseStdin RPC.
+	ProcessCloseStdinProcedure = "/process.Process/CloseStdin"
+)
+
+// ProcessClient is a client for the process.Process service.
+type ProcessClient interface {
+	List(context.Context, *connect.Request[process.ListRequest]) (*connect.Response[process.ListResponse], error)
+	Connect(context.Context, *connect.Request[process.ConnectRequest]) (*connect.ServerStreamForClient[process.ConnectResponse], error)
+	Start(context.Context, *connect.Request[process.StartRequest]) (*connect.ServerStreamForClient[process.StartResponse], error)
+	Update(context.Context, *connect.Request[process.UpdateRequest]) (*connect.Response[process.UpdateResponse], error)
+	// Client input stream ensures ordering of messages
+	StreamInput(context.Context) *connect.ClientStreamForClient[process.StreamInputRequest, process.StreamInputResponse]
+	SendInput(context.Context, *connect.Request[process.SendInputRequest]) (*connect.Response[process.SendInputResponse], error)
+	SendSignal(context.Context, *connect.Request[process.SendSignalRequest]) (*connect.Response[process.SendSignalResponse], error)
+	// Close stdin to signal EOF to the process.
+	// Only works for non-PTY processes. For PTY, send Ctrl+D (0x04) instead.
+	CloseStdin(context.Context, *connect.Request[process.CloseStdinRequest]) (*connect.Response[process.CloseStdinResponse], error)
+}
+
+// NewProcessClient constructs a client for the process.Process service. By default, it uses the
+// Connect protocol with the binary Protobuf Codec, asks for gzipped responses, and sends
+// uncompressed requests. To use the gRPC or gRPC-Web protocols, supply the connect.WithGRPC() or
+// connect.WithGRPCWeb() options.
+//
+// The URL supplied here should be the base URL for the Connect or gRPC server (for example,
+// http://api.acme.com or https://acme.com/grpc).
+func NewProcessClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) ProcessClient {
+	baseURL = strings.TrimRight(baseURL, "/")
+	processMethods := process.File_process_process_proto.Services().ByName("Process").Methods()
+	return &processClient{
+		list: connect.NewClient[process.ListRequest, process.ListResponse](
+			httpClient,
+			baseURL+ProcessListProcedure,
+			connect.WithSchema(processMethods.ByName("List")),
+			connect.WithClientOptions(opts...),
+		),
+		connect: connect.NewClient[process.ConnectRequest, process.ConnectResponse](
+			httpClient,
+			baseURL+ProcessConnectProcedure,
+			connect.WithSchema(processMethods.ByName("Connect")),
+			connect.WithClientOptions(opts...),
+		),
+		start: connect.NewClient[process.StartRequest, process.StartResponse](
+			httpClient,
+			baseURL+ProcessStartProcedure,
+			connect.WithSchema(processMethods.ByName("Start")),
+			connect.WithClientOptions(opts...),
+		),
+		update: connect.NewClient[process.UpdateRequest, process.UpdateResponse](
+			httpClient,
+			baseURL+ProcessUpdateProcedure,
+			connect.WithSchema(processMethods.ByName("Update")),
+			connect.WithClientOptions(opts...),
+		),
+		streamInput: connect.NewClient[process.StreamInputRequest, process.StreamInputResponse](
+			httpClient,
+			baseURL+ProcessStreamInputProcedure,
+			connect.WithSchema(processMethods.ByName("StreamInput")),
+			connect.WithClientOptions(opts...),
+		),
+		sendInput: connect.NewClient[process.SendInputRequest, process.SendInputResponse](
+			httpClient,
+			baseURL+ProcessSendInputProcedure,
+			connect.WithSchema(processMethods.ByName("SendInput")),
+			connect.WithClientOptions(opts...),
+		),
+		sendSignal: connect.NewClient[process.SendSignalRequest, process.SendSignalResponse](
+			httpClient,
+			baseURL+ProcessSendSignalProcedure,
+			connect.WithSchema(processMethods.ByName("SendSignal")),
+			connect.WithClientOptions(opts...),
+		),
+		closeStdin: connect.NewClient[process.CloseStdinRequest, process.CloseStdinResponse](
+			httpClient,
+			baseURL+ProcessCloseStdinProcedure,
+			connect.WithSchema(processMethods.ByName("CloseStdin")),
+			connect.WithClientOptions(opts...),
+		),
+	}
+}
+
+// processClient implements ProcessClient.
+type processClient struct {
+	list        *connect.Client[process.ListRequest, process.ListResponse]
+	connect     *connect.Client[process.ConnectRequest, process.ConnectResponse]
+	start       *connect.Client[process.StartRequest, process.StartResponse]
+	update      *connect.Client[process.UpdateRequest, process.UpdateResponse]
+	streamInput *connect.Client[process.StreamInputRequest, process.StreamInputResponse]
+	sendInput   *connect.Client[process.SendInputRequest, process.SendInputResponse]
+	sendSignal  *connect.Client[process.SendSignalRequest, process.SendSignalResponse]
+	closeStdin  *connect.Client[process.CloseStdinRequest, process.CloseStdinResponse]
+}
+
+// List calls process.Process.List.
+func (c *processClient) List(ctx context.Context, req *connect.Request[process.ListRequest]) (*connect.Response[process.ListResponse], error) {
+	return c.list.CallUnary(ctx, req)
+}
+
+// Connect calls process.Process.Connect.
+func (c *processClient) Connect(ctx context.Context, req *connect.Request[process.ConnectRequest]) (*connect.ServerStreamForClient[process.ConnectResponse], error) {
+	return c.connect.CallServerStream(ctx, req)
+}
+
+// Start calls process.Process.Start.
+func (c *processClient) Start(ctx context.Context, req *connect.Request[process.StartRequest]) (*connect.ServerStreamForClient[process.StartResponse], error) {
+	return c.start.CallServerStream(ctx, req)
+}
+
+// Update calls process.Process.Update.
+func (c *processClient) Update(ctx context.Context, req *connect.Request[process.UpdateRequest]) (*connect.Response[process.UpdateResponse], error) {
+	return c.update.CallUnary(ctx, req)
+}
+
+// StreamInput calls process.Process.StreamInput.
+func (c *processClient) StreamInput(ctx context.Context) *connect.ClientStreamForClient[process.StreamInputRequest, process.StreamInputResponse] {
+	return c.streamInput.CallClientStream(ctx)
+}
+
+// SendInput calls process.Process.SendInput.
+func (c *processClient) SendInput(ctx context.Context, req *connect.Request[process.SendInputRequest]) (*connect.Response[process.SendInputResponse], error) {
+	return c.sendInput.CallUnary(ctx, req)
+}
+
+// SendSignal calls process.Process.SendSignal.
+func (c *processClient) SendSignal(ctx context.Context, req *connect.Request[process.SendSignalRequest]) (*connect.Response[process.SendSignalResponse], error) {
+	return c.sendSignal.CallUnary(ctx, req)
+}
+
+// CloseStdin calls process.Process.CloseStdin.
+func (c *processClient) CloseStdin(ctx context.Context, req *connect.Request[process.CloseStdinRequest]) (*connect.Response[process.CloseStdinResponse], error) {
+	return c.closeStdin.CallUnary(ctx, req)
+}
+
+// ProcessHandler is an implementation of the process.Process service.
+type ProcessHandler interface {
+	List(context.Context, *connect.Request[process.ListRequest]) (*connect.Response[process.ListResponse], error)
+	Connect(context.Context, *connect.Request[process.ConnectRequest], *connect.ServerStream[process.ConnectResponse]) error
+	Start(context.Context, *connect.Request[process.StartRequest], *connect.ServerStream[process.StartResponse]) error
+	Update(context.Context, *connect.Request[process.UpdateRequest]) (*connect.Response[process.UpdateResponse], error)
+	// Client input stream ensures ordering of messages
+	StreamInput(context.Context, *connect.ClientStream[process.StreamInputRequest]) (*connect.Response[process.StreamInputResponse], error)
+	SendInput(context.Context, *connect.Request[process.SendInputRequest]) (*connect.Response[process.SendInputResponse], error)
+	SendSignal(context.Context, *connect.Request[process.SendSignalRequest]) (*connect.Response[process.SendSignalResponse], error)
+	// Close stdin to signal EOF to the process.
+	// Only works for non-PTY processes. For PTY, send Ctrl+D (0x04) instead.
+	CloseStdin(context.Context, *connect.Request[process.CloseStdinRequest]) (*connect.Response[process.CloseStdinResponse], error)
+}
+
+// NewProcessHandler builds an HTTP handler from the service implementation. It returns the path on
+// which to mount the handler and the handler itself.
+//
+// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf
+// and JSON codecs. They also support gzip compression.
+func NewProcessHandler(svc ProcessHandler, opts ...connect.HandlerOption) (string, http.Handler) {
+	processMethods := process.File_process_process_proto.Services().ByName("Process").Methods()
+	processListHandler := connect.NewUnaryHandler(
+		ProcessListProcedure,
+		svc.List,
+		connect.WithSchema(processMethods.ByName("List")),
+		connect.WithHandlerOptions(opts...),
+	)
+	processConnectHandler := connect.NewServerStreamHandler(
+		ProcessConnectProcedure,
+		svc.Connect,
+		connect.WithSchema(processMethods.ByName("Connect")),
+		connect.WithHandlerOptions(opts...),
+	)
+	processStartHandler := connect.NewServerStreamHandler(
+		ProcessStartProcedure,
+		svc.Start,
+		connect.WithSchema(processMethods.ByName("Start")),
+		connect.WithHandlerOptions(opts...),
+	)
+	processUpdateHandler := connect.NewUnaryHandler(
+		ProcessUpdateProcedure,
+		svc.Update,
+		connect.WithSchema(processMethods.ByName("Update")),
+		connect.WithHandlerOptions(opts...),
+	)
+	processStreamInputHandler := connect.NewClientStreamHandler(
+		ProcessStreamInputProcedure,
+		svc.StreamInput,
+		connect.WithSchema(processMethods.ByName("StreamInput")),
+		connect.WithHandlerOptions(opts...),
+	)
+	processSendInputHandler := connect.NewUnaryHandler(
+		ProcessSendInputProcedure,
+		svc.SendInput,
+		connect.WithSchema(processMethods.ByName("SendInput")),
+		connect.WithHandlerOptions(opts...),
+	)
+	processSendSignalHandler := connect.NewUnaryHandler(
+		ProcessSendSignalProcedure,
+		svc.SendSignal,
+		connect.WithSchema(processMethods.ByName("SendSignal")),
+		connect.WithHandlerOptions(opts...),
+	)
+	processCloseStdinHandler := connect.NewUnaryHandler(
+		ProcessCloseStdinProcedure,
+		svc.CloseStdin,
+		connect.WithSchema(processMethods.ByName("CloseStdin")),
+		connect.WithHandlerOptions(opts...),
+	)
+	return "/process.Process/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case ProcessListProcedure:
+			processListHandler.ServeHTTP(w, r)
+		case ProcessConnectProcedure:
+			processConnectHandler.ServeHTTP(w, r)
+		case ProcessStartProcedure:
+			processStartHandler.ServeHTTP(w, r)
+		case ProcessUpdateProcedure:
+			processUpdateHandler.ServeHTTP(w, r)
+		case ProcessStreamInputProcedure:
+			processStreamInputHandler.ServeHTTP(w, r)
+		case ProcessSendInputProcedure:
+			processSendInputHandler.ServeHTTP(w, r)
+		case ProcessSendSignalProcedure:
+			processSendSignalHandler.ServeHTTP(w, r)
+		case ProcessCloseStdinProcedure:
+			processCloseStdinHandler.ServeHTTP(w, r)
+		default:
+			http.NotFound(w, r)
+		}
+	})
+}
+
+// UnimplementedProcessHandler returns CodeUnimplemented from all methods.
+type UnimplementedProcessHandler struct{}
+
+func (UnimplementedProcessHandler) List(context.Context, *connect.Request[process.ListRequest]) (*connect.Response[process.ListResponse], error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("process.Process.List is not implemented"))
+}
+
+func (UnimplementedProcessHandler) Connect(context.Context, *connect.Request[process.ConnectRequest], *connect.ServerStream[process.ConnectResponse]) error {
+	return connect.NewError(connect.CodeUnimplemented, errors.New("process.Process.Connect is not implemented"))
+}
+
+func (UnimplementedProcessHandler) Start(context.Context, *connect.Request[process.StartRequest], *connect.ServerStream[process.StartResponse]) error {
+	return connect.NewError(connect.CodeUnimplemented, errors.New("process.Process.Start is not implemented"))
+}
+
+func (UnimplementedProcessHandler) Update(context.Context, *connect.Request[process.UpdateRequest]) (*connect.Response[process.UpdateResponse], error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("process.Process.Update is not implemented"))
+}
+
+func (UnimplementedProcessHandler) StreamInput(context.Context, *connect.ClientStream[process.StreamInputRequest]) (*connect.Response[process.StreamInputResponse], error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("process.Process.StreamInput is not implemented"))
+}
+
+func (UnimplementedProcessHandler) SendInput(context.Context, *connect.Request[process.SendInputRequest]) (*connect.Response[process.SendInputResponse], error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("process.Process.SendInput is not implemented"))
+}
+
+func (UnimplementedProcessHandler) SendSignal(context.Context, *connect.Request[process.SendSignalRequest]) (*connect.Response[process.SendSignalResponse], error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("process.Process.SendSignal is not implemented"))
+}
+
+func (UnimplementedProcessHandler) CloseStdin(context.Context, *connect.Request[process.CloseStdinRequest]) (*connect.Response[process.CloseStdinResponse], error) {
+	return nil, connect.NewError(connect.CodeUnimplemented, errors.New("process.Process.CloseStdin is not implemented"))
+}