exec.go

package codex

import (
	"bufio"
	"bytes"
	"context"
	"encoding/json"
	"fmt"
	"os"
	"os/exec"
	"regexp"
	"strconv"
	"strings"
)

const internalOriginatorEnv = "CODEX_INTERNAL_ORIGINATOR_OVERRIDE"
const goSDKOriginator = "codex_sdk_go"

// CodexExecArgs contains the CLI arguments for a single Codex execution.
type CodexExecArgs struct {
	// Input is written to subprocess stdin.
	Input string

	// BaseURL overrides the API base URL.
	BaseURL string
	// APIKey overrides the API key.
	APIKey string
	// ThreadID resumes an existing thread when non-empty.
	ThreadID string
	// Images adds repeated `--image` flags.
	Images []string

	// Model sets the model passed to the CLI.
	Model string
	// SandboxMode sets the CLI sandbox.
	SandboxMode SandboxMode
	// WorkingDirectory sets the CLI working directory.
	WorkingDirectory string
	// AdditionalDirectories adds repeated `--add-dir` flags.
	AdditionalDirectories []string
	// SkipGitRepoCheck passes `--skip-git-repo-check`.
	SkipGitRepoCheck bool
	// OutputSchemaFile points at a temporary JSON schema file.
	OutputSchemaFile string
	// ModelReasoningEffort adds a reasoning override.
	ModelReasoningEffort ModelReasoningEffort
	// NetworkAccessEnabled overrides workspace-write network access.
	NetworkAccessEnabled *bool
	// WebSearchMode explicitly configures web search.
	WebSearchMode WebSearchMode
	// WebSearchEnabled provides the legacy boolean search toggle.
	WebSearchEnabled *bool
	// ApprovalPolicy configures CLI approval behavior.
	ApprovalPolicy ApprovalMode
}

// CodexExec spawns the Codex CLI and emits stdout one JSONL line at a time.
type CodexExec struct {
	executablePath  string
	envOverride     map[string]string
	configOverrides map[string]any
}

// NewCodexExec constructs a CodexExec helper.
func NewCodexExec(executablePath string, env map[string]string, configOverrides map[string]any) *CodexExec {
	return &CodexExec{
		executablePath:  executablePath,
		envOverride:     cloneEnv(env),
		configOverrides: cloneConfig(configOverrides),
	}
}

// Run starts the Codex CLI, forwards stdin, and calls onLine for each stdout
// line emitted by the subprocess.
func (e *CodexExec) Run(ctx context.Context, args CodexExecArgs, onLine func(string) error) error {
	if ctx == nil {
		ctx = context.Background()
	}

	executablePath, err := e.resolveExecutablePath()
	if err != nil {
		return err
	}

	commandArgs, err := e.buildCommandArgs(args)
	if err != nil {
		return err
	}

	runCtx, cancel := context.WithCancel(ctx)
	defer cancel()

	cmd := exec.CommandContext(runCtx, executablePath, commandArgs...)
	cmd.Env = buildEnv(e.envOverride, args.BaseURL, args.APIKey)

	stdout, err := cmd.StdoutPipe()
	if err != nil {
		return err
	}
	stdin, err := cmd.StdinPipe()
	if err != nil {
		return err
	}

	var stderr bytes.Buffer
	cmd.Stderr = &stderr

	if err := cmd.Start(); err != nil {
		return err
	}

	writeErr := make(chan error, 1)
	go func() {
		_, err := stdin.Write([]byte(args.Input))
		closeErr := stdin.Close()
		if err == nil {
			err = closeErr
		}
		writeErr <- err
		close(writeErr)
	}()

	scanner := bufio.NewScanner(stdout)
	scanner.Buffer(make([]byte, 0, 64*1024), 8*1024*1024)

	var callbackErr error
	for scanner.Scan() {
		if err := onLine(scanner.Text()); err != nil {
			callbackErr = err
			cancel()
			break
		}
	}

	scanErr := scanner.Err()
	if err := <-writeErr; err != nil && callbackErr == nil {
		callbackErr = err
		cancel()
	}

	waitErr := cmd.Wait()

	if callbackErr != nil {
		return callbackErr
	}
	if scanErr != nil {
		return scanErr
	}
	if waitErr != nil {
		return fmt.Errorf("Codex Exec exited: %s: %s", waitErr.Error(), strings.TrimSpace(stderr.String()))
	}

	return nil
}

func (e *CodexExec) buildCommandArgs(args CodexExecArgs) ([]string, error) {
	commandArgs := []string{"exec", "--experimental-json"}

	if len(e.configOverrides) > 0 {
		overrides, err := serializeConfigOverrides(e.configOverrides)
		if err != nil {
			return nil, err
		}
		for _, override := range overrides {
			commandArgs = append(commandArgs, "--config", override)
		}
	}

	if args.Model != "" {
		commandArgs = append(commandArgs, "--model", args.Model)
	}
	if args.SandboxMode != "" {
		commandArgs = append(commandArgs, "--sandbox", string(args.SandboxMode))
	}
	if args.WorkingDirectory != "" {
		commandArgs = append(commandArgs, "--cd", args.WorkingDirectory)
	}
	for _, dir := range args.AdditionalDirectories {
		commandArgs = append(commandArgs, "--add-dir", dir)
	}
	if args.SkipGitRepoCheck {
		commandArgs = append(commandArgs, "--skip-git-repo-check")
	}
	if args.OutputSchemaFile != "" {
		commandArgs = append(commandArgs, "--output-schema", args.OutputSchemaFile)
	}
	if args.ModelReasoningEffort != "" {
		commandArgs = append(commandArgs, "--config", `model_reasoning_effort="`+string(args.ModelReasoningEffort)+`"`)
	}
	if args.NetworkAccessEnabled != nil {
		commandArgs = append(
			commandArgs,
			"--config",
			"sandbox_workspace_write.network_access="+strconv.FormatBool(*args.NetworkAccessEnabled),
		)
	}
	if args.WebSearchMode != "" {
		commandArgs = append(commandArgs, "--config", `web_search="`+string(args.WebSearchMode)+`"`)
	} else if args.WebSearchEnabled != nil {
		if *args.WebSearchEnabled {
			commandArgs = append(commandArgs, "--config", `web_search="live"`)
		} else {
			commandArgs = append(commandArgs, "--config", `web_search="disabled"`)
		}
	}
	if args.ApprovalPolicy != "" {
		commandArgs = append(commandArgs, "--config", `approval_policy="`+string(args.ApprovalPolicy)+`"`)
	}
	if args.ThreadID != "" {
		commandArgs = append(commandArgs, "resume", args.ThreadID)
	}
	for _, image := range args.Images {
		commandArgs = append(commandArgs, "--image", image)
	}

	return commandArgs, nil
}

func (e *CodexExec) resolveExecutablePath() (string, error) {
	if e.executablePath != "" {
		return e.executablePath, nil
	}
	path, err := exec.LookPath("codex")
	if err != nil {
		return "", fmt.Errorf("unable to locate codex CLI in PATH")
	}
	return path, nil
}

func buildEnv(envOverride map[string]string, baseURL string, apiKey string) []string {
	env := map[string]string{}
	if envOverride != nil {
		for key, value := range envOverride {
			env[key] = value
		}
	} else {
		for _, entry := range os.Environ() {
			parts := strings.SplitN(entry, "=", 2)
			if len(parts) != 2 {
				continue
			}
			env[parts[0]] = parts[1]
		}
	}

	if env[internalOriginatorEnv] == "" {
		env[internalOriginatorEnv] = goSDKOriginator
	}
	if baseURL != "" {
		env["OPENAI_BASE_URL"] = baseURL
	}
	if apiKey != "" {
		env["CODEX_API_KEY"] = apiKey
	}

	result := make([]string, 0, len(env))
	for key, value := range env {
		result = append(result, key+"="+value)
	}
	return result
}

func serializeConfigOverrides(configOverrides map[string]any) ([]string, error) {
	overrides := make([]string, 0)
	if err := flattenConfigOverrides(configOverrides, "", &overrides); err != nil {
		return nil, err
	}
	return overrides, nil
}

func flattenConfigOverrides(value any, prefix string, overrides *[]string) error {
	object, ok := value.(map[string]any)
	if !ok {
		if prefix == "" {
			return fmt.Errorf("codex config overrides must be a plain object")
		}
		rendered, err := toTomlValue(value, prefix)
		if err != nil {
			return err
		}
		*overrides = append(*overrides, prefix+"="+rendered)
		return nil
	}

	if prefix == "" && len(object) == 0 {
		return nil
	}
	if prefix != "" && len(object) == 0 {
		*overrides = append(*overrides, prefix+"={}")
		return nil
	}

	for key, child := range object {
		if key == "" {
			return fmt.Errorf("codex config override keys must be non-empty strings")
		}
		if child == nil {
			continue
		}

		path := key
		if prefix != "" {
			path = prefix + "." + key
		}

		if childObject, ok := child.(map[string]any); ok {
			if err := flattenConfigOverrides(childObject, path, overrides); err != nil {
				return err
			}
			continue
		}

		rendered, err := toTomlValue(child, path)
		if err != nil {
			return err
		}
		*overrides = append(*overrides, path+"="+rendered)
	}

	return nil
}

var tomlBareKey = regexp.MustCompile(`^[A-Za-z0-9_-]+$`)

func toTomlValue(value any, path string) (string, error) {
	switch typed := value.(type) {
	case string:
		encoded, _ := json.Marshal(typed)
		return string(encoded), nil
	case bool:
		if typed {
			return "true", nil
		}
		return "false", nil
	case int:
		return strconv.Itoa(typed), nil
	case int8, int16, int32, int64:
		return fmt.Sprintf("%d", typed), nil
	case uint, uint8, uint16, uint32, uint64:
		return fmt.Sprintf("%d", typed), nil
	case float32:
		if !isFinite(float64(typed)) {
			return "", fmt.Errorf("codex config override at %s must be a finite number", path)
		}
		return strconv.FormatFloat(float64(typed), 'f', -1, 32), nil
	case float64:
		if !isFinite(typed) {
			return "", fmt.Errorf("codex config override at %s must be a finite number", path)
		}
		return strconv.FormatFloat(typed, 'f', -1, 64), nil
	case []any:
		parts := make([]string, 0, len(typed))
		for index, item := range typed {
			rendered, err := toTomlValue(item, fmt.Sprintf("%s[%d]", path, index))
			if err != nil {
				return "", err
			}
			parts = append(parts, rendered)
		}
		return "[" + strings.Join(parts, ", ") + "]", nil
	case map[string]any:
		parts := make([]string, 0, len(typed))
		for key, child := range typed {
			if key == "" {
				return "", fmt.Errorf("codex config override keys must be non-empty strings")
			}
			if child == nil {
				continue
			}
			rendered, err := toTomlValue(child, path+"."+key)
			if err != nil {
				return "", err
			}
			parts = append(parts, formatTomlKey(key)+" = "+rendered)
		}
		return "{" + strings.Join(parts, ", ") + "}", nil
	case nil:
		return "", fmt.Errorf("codex config override at %s cannot be null", path)
	default:
		return "", fmt.Errorf("unsupported codex config override value at %s: %T", path, value)
	}
}

func formatTomlKey(key string) string {
	if tomlBareKey.MatchString(key) {
		return key
	}
	encoded, _ := json.Marshal(key)
	return string(encoded)
}

func isFinite(value float64) bool {
	return !strings.EqualFold(strconv.FormatFloat(value, 'f', -1, 64), "NaN") &&
		!strings.EqualFold(strconv.FormatFloat(value, 'f', -1, 64), "+Inf") &&
		!strings.EqualFold(strconv.FormatFloat(value, 'f', -1, 64), "-Inf")
}

func cloneEnv(env map[string]string) map[string]string {
	if env == nil {
		return nil
	}
	cloned := make(map[string]string, len(env))
	for key, value := range env {
		cloned[key] = value
	}
	return cloned
}

func cloneConfig(config map[string]any) map[string]any {
	if config == nil {
		return nil
	}
	cloned := make(map[string]any, len(config))
	for key, value := range config {
		cloned[key] = value
	}
	return cloned
}