runcode.go

package xshellz

import (
	"context"
	"fmt"
	"sort"
	"strings"
)

// codeInterpreters maps a RunCode language to its interpreter binary and
// temp-file extension on the box.
var codeInterpreters = map[string]struct {
	command   string
	extension string
}{
	"python": {"python3", ".py"},
	"node":   {"node", ".js"},
	"bash":   {"bash", ".sh"},
	"ruby":   {"ruby", ".rb"},
	"php":    {"php", ".php"},
}

// SupportedLanguages returns the languages RunCode accepts, sorted.
func SupportedLanguages() []string {
	langs := make([]string, 0, len(codeInterpreters))
	for lang := range codeInterpreters {
		langs = append(langs, lang)
	}
	sort.Strings(langs)
	return langs
}

// RunCode executes a snippet of source code on the box and returns the same
// RunResult as Run — this is the "code interpreter" path for AI-generated
// code: the code is written to a unique temp file, run with the language's
// interpreter, and the temp file is always deleted afterwards.
//
// Supported languages: "python" (python3), "node", "bash", "ruby", "php".
// An unknown language fails with ErrUnsupportedLanguage. As with Run, a
// non-zero exit code (e.g. a Python traceback) is data on the result, not an
// error. opts applies to the interpreter invocation (Cwd, Env, streaming).
func (s *Sandbox) RunCode(ctx context.Context, language, code string, opts *RunOptions) (*RunResult, error) {
	spec, ok := codeInterpreters[language]
	if !ok {
		return nil, fmt.Errorf("%w: %q (supported: %s)", ErrUnsupportedLanguage, language, strings.Join(SupportedLanguages(), ", "))
	}

	suffix, err := randomHex(4)
	if err != nil {
		return nil, err
	}
	remotePath := "/tmp/xshellz-code-" + suffix + spec.extension

	if err := s.WriteFile(ctx, remotePath, []byte(code)); err != nil {
		return nil, err
	}

	res, runErr := s.Run(ctx, spec.command+" "+shellQuote(remotePath), opts)
	_, _ = s.Run(ctx, "rm -f "+shellQuote(remotePath), nil)
	if runErr != nil {
		return nil, runErr
	}
	return res, nil
}