tutti/services/tuttid/service/agent/codex_capability_catalog.go

package agent

import (
	"bufio"
	"context"
	"encoding/json"
	"fmt"
	"io"
	"log/slog"
	"os"
	"strings"
	"time"

	"github.com/tutti-os/tutti/packages/agent/daemon/providerregistry"
	"github.com/tutti-os/tutti/packages/agent/daemon/runtimecmd"
)

// Codex and Tutti Agent capability catalogs use the same app-server startup
// path as model/list, including the provider's first model metadata refresh.
// Keep this bounded independently from the composer request so a cold Windows
// npm shim does not turn a valid capability catalog into a false failure.
const codexAppServerCapabilityListTimeout = 30 * time.Second

type appServerCatalogRequestSet string

const (
	appServerCatalogRequestSetCodex      appServerCatalogRequestSet = "codex"
	appServerCatalogRequestSetSkillsOnly appServerCatalogRequestSet = "skills_only"
)

type CodexCLICapabilityLister struct {
	Command          string
	Args             []string
	Timeout          time.Duration
	RequestSet       appServerCatalogRequestSet
	Environ          func() []string
	HomeDir          func() (string, error)
	IsExecutableFile func(string) bool
	LookPath         func(string) (string, error)
}

type defaultComposerCapabilityLister struct{}

func (defaultComposerCapabilityLister) ListComposerCapabilityOptions(
	ctx context.Context,
	provider string,
	cwd string,
	fallbackSkills []ComposerSkillOption,
) ([]ComposerCapabilityOption, []string) {
	return discoverComposerCapabilityOptions(ctx, provider, cwd, fallbackSkills)
}

func (s *Service) composerCapabilityLister() ComposerCapabilityLister {
	if s.CapabilityLister != nil {
		return s.CapabilityLister
	}
	return defaultComposerCapabilityLister{}
}

func discoverComposerCapabilityOptions(
	ctx context.Context,
	provider string,
	cwd string,
	fallbackSkills []ComposerSkillOption,
) ([]ComposerCapabilityOption, []string) {
	fallback := composerCapabilityCatalogFromSkills(provider, fallbackSkills)
	lister, ok, err := composerCapabilityCatalogLister(composerProfileFor(provider))
	if err != nil {
		return fallback, []string{err.Error()}
	}
	if !ok {
		return fallback, nil
	}
	options, err := lister.List(ctx, cwd)
	if err != nil {
		return fallback, []string{err.Error()}
	}
	return mergeCodexComposerCapabilityOptions(fallback, options), nil
}

func mergeCodexComposerCapabilityOptions(
	fallback []ComposerCapabilityOption,
	native []ComposerCapabilityOption,
) []ComposerCapabilityOption {
	result := append([]ComposerCapabilityOption(nil), fallback...)
	sameSkillFile := newComposerSkillFileIdentityMatcher()

	for _, option := range native {
		replacedFallback := false
		for index := range result {
			if result[index].Kind == "skill" && option.Kind == "skill" && sameSkillFile(result[index].Path, option.Path) {
				result[index] = option
				replacedFallback = true
				break
			}
		}
		if !replacedFallback {
			result = append(result, option)
		}
	}
	return dedupeComposerCapabilityOptions(result)
}

func newComposerSkillFileIdentityMatcher() func(string, string) bool {
	fileInfoByPath := make(map[string]os.FileInfo)
	missingFileInfo := make(map[string]struct{})
	fileInfo := func(path string) (os.FileInfo, bool) {
		path = strings.TrimSpace(path)
		if path == "" {
			return nil, false
		}
		if info, ok := fileInfoByPath[path]; ok {
			return info, true
		}
		if _, ok := missingFileInfo[path]; ok {
			return nil, false
		}
		info, err := os.Stat(path)
		if err != nil || info.IsDir() {
			missingFileInfo[path] = struct{}{}
			return nil, false
		}
		fileInfoByPath[path] = info
		return info, true
	}
	return func(leftPath string, rightPath string) bool {
		leftInfo, leftOK := fileInfo(leftPath)
		rightInfo, rightOK := fileInfo(rightPath)
		return leftOK && rightOK && os.SameFile(leftInfo, rightInfo)
	}
}

func composerCapabilityCatalogLister(profile composerProfile) (CodexCLICapabilityLister, bool, error) {
	switch profile.CapabilityCatalogKind {
	case "":
		return CodexCLICapabilityLister{}, false, nil
	case providerregistry.CapabilityCatalogKindCodexAppServer, providerregistry.CapabilityCatalogKindAppServerSkills:
		command := append([]string(nil), profile.CapabilityCatalogCommand...)
		if len(command) == 0 || strings.TrimSpace(command[0]) == "" {
			return CodexCLICapabilityLister{}, false, fmt.Errorf("capability catalog command is required")
		}
		for index, argument := range command[1:] {
			if strings.TrimSpace(argument) == "" {
				return CodexCLICapabilityLister{}, false, fmt.Errorf("capability catalog command argument %d is empty", index+1)
			}
		}
		requestSet := appServerCatalogRequestSetCodex
		if profile.CapabilityCatalogKind == providerregistry.CapabilityCatalogKindAppServerSkills {
			requestSet = appServerCatalogRequestSetSkillsOnly
		}
		return CodexCLICapabilityLister{
			Command:    command[0],
			Args:       command[1:],
			RequestSet: requestSet,
		}, true, nil
	default:
		return CodexCLICapabilityLister{}, false, fmt.Errorf("unsupported capability catalog kind %q", profile.CapabilityCatalogKind)
	}
}

func (l CodexCLICapabilityLister) List(ctx context.Context, cwd string) ([]ComposerCapabilityOption, error) {
	startedAt := time.Now()
	slog.Info("agent capability catalog fetch started",
		"event", "agent.capability_catalog.fetch_start",
		"provider", "codex",
		"request_set", l.RequestSet,
	)
	timeout := l.Timeout
	if timeout <= 0 {
		timeout = codexAppServerCapabilityListTimeout
	}

	command := strings.TrimSpace(l.Command)
	if command == "" {
		return nil, fmt.Errorf("capability catalog command is required")
	}
	resolver := runtimecmd.Resolver{
		Environ:          l.Environ,
		HomeDir:          l.HomeDir,
		IsExecutableFile: l.IsExecutableFile,
		LookPath:         l.LookPath,
	}
	processEnv := resolver.Env(nil)
	command = resolver.Resolve(command, processEnv)
	args := append([]string{}, l.Args...)
	processCtx, cancel := context.WithTimeout(ctx, timeout)
	defer cancel()
	process, err := startCodexAppServerProcess(processCtx, command, args, processEnv)
	if err != nil {
		slog.Info("agent capability catalog fetch settled",
			"event", "agent.capability_catalog.fetch_settled",
			"provider", "codex",
			"request_set", l.RequestSet,
			"durationMs", time.Since(startedAt).Milliseconds(),
			"error", err,
		)
		return nil, err
	}
	slog.Info("agent capability catalog process launch",
		"event", "agent.capability_catalog.process_start",
		"provider", "codex",
		"command", command,
		"args", args,
	)
	requestStartedAt := time.Now()
	if err := writeAppServerCapabilityListRequests(process.stdin, cwd, l.RequestSet); err != nil {
		slog.Info("agent capability catalog request stage settled",
			"event", "agent.capability_catalog.stage_settled",
			"provider", "codex",
			"request_set", l.RequestSet,
			"stage", "request_dispatch",
			"durationMs", time.Since(requestStartedAt).Milliseconds(),
			"error", err,
		)
		processErr := processCtx.Err()
		_ = process.stop(cancel)
		if processErr != nil {
			return nil, fmt.Errorf("codex app-server capability discovery timed out: %w", processErr)
		}
		return nil, err
	}
	slog.Info("agent capability catalog request stage settled",
		"event", "agent.capability_catalog.stage_settled",
		"provider", "codex",
		"request_set", l.RequestSet,
		"stage", "request_dispatch",
		"durationMs", time.Since(requestStartedAt).Milliseconds(),
	)
	responseStartedAt := time.Now()
	options, err := readAppServerCapabilityListResponses(process.stdout, l.RequestSet)
	slog.Info("agent capability catalog response stage settled",
		"event", "agent.capability_catalog.stage_settled",
		"provider", "codex",
		"request_set", l.RequestSet,
		"stage", "capability_response",
		"durationMs", time.Since(responseStartedAt).Milliseconds(),
		"optionCount", len(options),
		"error", err,
	)
	processErr := processCtx.Err()
	_ = process.stop(cancel)
	settled := func(settledErr error) {
		slog.Info("agent capability catalog fetch settled",
			"event", "agent.capability_catalog.fetch_settled",
			"provider", "codex",
			"request_set", l.RequestSet,
			"durationMs", time.Since(startedAt).Milliseconds(),
			"optionCount", len(options),
			"error", settledErr,
		)
	}
	if err == nil {
		settled(nil)
		return options, nil
	}
	if processErr != nil {
		timeoutErr := fmt.Errorf("codex app-server capability discovery timed out: %w", processErr)
		settled(timeoutErr)
		return nil, timeoutErr
	}
	if stderr := strings.TrimSpace(process.stderr.String()); stderr != "" {
		stderrErr := fmt.Errorf("%w: %s", err, stderr)
		settled(stderrErr)
		return nil, stderrErr
	}
	settled(err)
	return nil, err
}

func writeAppServerCapabilityListRequests(
	stdin io.Writer,
	cwd string,
	requestSet appServerCatalogRequestSet,
) error {
	requests, _, err := appServerCatalogRequests(cwd, requestSet)
	if err != nil {
		return err
	}
	encoder := json.NewEncoder(stdin)
	if err := encoder.Encode(map[string]any{
		"id":     "1",
		"method": "initialize",
		"params": map[string]any{
			"clientInfo": map[string]string{
				"name":    "tuttid",
				"version": "0.1.0",
			},
			"capabilities": map[string]any{
				"experimentalApi": true,
			},
		},
	}); err != nil {
		return fmt.Errorf("write codex app-server initialize: %w", err)
	}
	if err := encoder.Encode(map[string]any{
		"method": "initialized",
		"params": map[string]any{},
	}); err != nil {
		return fmt.Errorf("write codex app-server initialized: %w", err)
	}
	for _, request := range requests {
		if err := encoder.Encode(request); err != nil {
			return fmt.Errorf("write codex app-server %s: %w", request["method"], err)
		}
	}
	return nil
}

func appServerCatalogRequests(
	cwd string,
	requestSet appServerCatalogRequestSet,
) ([]map[string]any, map[string]string, error) {
	if requestSet == "" {
		requestSet = appServerCatalogRequestSetCodex
	}
	cwds := []string{}
	if trimmedCwd := strings.TrimSpace(cwd); trimmedCwd != "" {
		cwds = append(cwds, trimmedCwd)
	}
	requests := []map[string]any{
		{
			"id":     "2",
			"method": "skills/list",
			"params": map[string]any{
				"cwds":        cwds,
				"forceReload": false,
			},
		},
	}
	pending := map[string]string{
		"2": "skills/list",
	}
	switch requestSet {
	case appServerCatalogRequestSetSkillsOnly:
		return requests, pending, nil
	case appServerCatalogRequestSetCodex:
	default:
		return nil, nil, fmt.Errorf("unsupported app-server catalog request set %q", requestSet)
	}
	requests = append(requests,
		map[string]any{
			"id":     "3",
			"method": "app/list",
			"params": map[string]any{
				"limit":        200,
				"forceRefetch": false,
			},
		},
		map[string]any{
			"id":     "4",
			"method": "plugin/list",
			"params": map[string]any{
				"limit": 200,
			},
		},
		map[string]any{
			"id":     "5",
			"method": "mcpServerStatus/list",
			"params": map[string]any{
				"limit":  200,
				"detail": "toolsAndAuthOnly",
			},
		},
	)
	pending["3"] = "app/list"
	pending["4"] = "plugin/list"
	pending["5"] = "mcpServerStatus/list"
	return requests, pending, nil
}

func readAppServerCapabilityListResponses(
	stdout io.Reader,
	requestSet appServerCatalogRequestSet,
) ([]ComposerCapabilityOption, error) {
	_, pendingMethods, err := appServerCatalogRequests("", requestSet)
	if err != nil {
		return nil, err
	}
	pending := make(map[string]struct{}, len(pendingMethods))
	for id := range pendingMethods {
		pending[id] = struct{}{}
	}
	scanner := bufio.NewScanner(stdout)
	scanner.Buffer(make([]byte, 0, 64*1024), codexModelListMaxLineBytes)
	options := make([]ComposerCapabilityOption, 0)
	for scanner.Scan() {
		line := strings.TrimSpace(scanner.Text())
		if line == "" {
			continue
		}
		var payload map[string]json.RawMessage
		if json.Unmarshal([]byte(line), &payload) != nil {
			continue
		}
		id := codexRPCIDString(payload["id"])
		if _, ok := pending[id]; !ok {
			continue
		}
		delete(pending, id)
		if rawError, ok := payload["error"]; ok && string(rawError) != "null" {
			if len(pending) == 0 {
				return dedupeComposerCapabilityOptions(options), nil
			}
			continue
		}
		switch id {
		case "2":
			options = append(options, parseCodexSkillCapabilities(payload["result"])...)
		case "3":
			options = append(options, parseCodexAppCapabilities(payload["result"])...)
		case "4":
			options = append(options, parseCodexPluginCapabilities(payload["result"])...)
		case "5":
			options = append(options, parseCodexMCPCapabilities(payload["result"])...)
		}
		if len(pending) == 0 {
			return dedupeComposerCapabilityOptions(options), nil
		}
	}
	if err := scanner.Err(); err != nil {
		return nil, fmt.Errorf("read codex app-server stdout: %w", err)
	}
	if len(options) > 0 {
		return dedupeComposerCapabilityOptions(options), nil
	}
	return nil, fmt.Errorf("codex app-server exited before capability responses")
}

func codexRPCIDString(raw json.RawMessage) string {
	var stringID string
	if err := json.Unmarshal(raw, &stringID); err == nil {
		return stringID
	}
	var numberID int
	if err := json.Unmarshal(raw, &numberID); err == nil {
		return fmt.Sprintf("%d", numberID)
	}
	return ""
}

func parseCodexSkillCapabilities(raw json.RawMessage) []ComposerCapabilityOption {
	var result struct {
		Data []struct {
			Skills []map[string]any `json:"skills"`
		} `json:"data"`
	}
	if json.Unmarshal(raw, &result) != nil {
		return nil
	}
	options := make([]ComposerCapabilityOption, 0)
	for _, group := range result.Data {
		for _, skill := range group.Skills {
			name := codexTextValue(skill, "name")
			if name == "" {
				continue
			}
			label := firstNonEmptyString(codexTextValue(codexNestedMap(skill, "interface"), "displayName"), name)
			description := firstNonEmptyString(
				codexTextValue(codexNestedMap(skill, "interface"), "shortDescription"),
				codexTextValue(skill, "description"),
			)
			status := "available"
			if enabled, ok := codexBoolValue(skill, "enabled"); ok && !enabled {
				status = "disabled"
			}
			path := codexTextValue(skill, "path")
			options = append(options, ComposerCapabilityOption{
				ID:          "skill:" + name,
				Kind:        "skill",
				Name:        name,
				Label:       label,
				Description: description,
				Status:      status,
				Trigger:     "$" + name,
				Path:        path,
				Invocation:  "promptItem",
			})
		}
	}
	return options
}

func parseCodexAppCapabilities(raw json.RawMessage) []ComposerCapabilityOption {
	var result struct {
		Data []map[string]any `json:"data"`
	}
	if json.Unmarshal(raw, &result) != nil {
		return nil
	}
	options := make([]ComposerCapabilityOption, 0, len(result.Data))
	for _, app := range result.Data {
		id := codexTextValue(app, "id")
		name := firstNonEmptyString(codexTextValue(app, "name"), id)
		if id == "" || name == "" {
			continue
		}
		status := "available"
		if enabled, ok := codexBoolValue(app, "isEnabled"); ok && !enabled {
			status = "disabled"
		}
		if accessible, ok := codexBoolValue(app, "isAccessible"); ok && !accessible {
			status = "authRequired"
		}
		options = append(options, ComposerCapabilityOption{
			ID:          "connector:" + id,
			Kind:        "connector",
			Name:        id,
			Label:       name,
			Description: codexTextValue(app, "description"),
			Status:      status,
			Trigger:     "$" + id,
			Path:        "app://" + id,
			Invocation:  "promptItem",
		})
	}
	return options
}

func parseCodexPluginCapabilities(raw json.RawMessage) []ComposerCapabilityOption {
	var result struct {
		Data []map[string]any `json:"data"`
	}
	if json.Unmarshal(raw, &result) != nil {
		return nil
	}
	options := make([]ComposerCapabilityOption, 0, len(result.Data))
	for _, plugin := range result.Data {
		name := firstNonEmptyString(codexTextValue(plugin, "name"), codexTextValue(plugin, "id"), codexTextValue(plugin, "pluginName"))
		if name == "" {
			continue
		}
		label := firstNonEmptyString(codexTextValue(plugin, "displayName"), codexTextValue(plugin, "title"), name)
		options = append(options, ComposerCapabilityOption{
			ID:          "plugin:" + name,
			Kind:        "plugin",
			Name:        name,
			Label:       label,
			Description: codexTextValue(plugin, "description"),
			Status:      "available",
			Source:      codexPluginSource(plugin),
			PluginName:  name,
			Invocation:  "none",
		})
	}
	return options
}

func parseCodexMCPCapabilities(raw json.RawMessage) []ComposerCapabilityOption {
	var result struct {
		Data []map[string]any `json:"data"`
	}
	if json.Unmarshal(raw, &result) != nil {
		return nil
	}
	options := make([]ComposerCapabilityOption, 0)
	for _, server := range result.Data {
		name := firstNonEmptyString(codexTextValue(server, "name"), codexTextValue(server, "serverName"))
		if name == "" {
			continue
		}
		status := normalizeCodexMCPStatus(codexTextValue(server, "status"))
		options = append(options, ComposerCapabilityOption{
			ID:         "mcpServer:" + name,
			Kind:       "mcpServer",
			Name:       name,
			Label:      name,
			Status:     status,
			ServerName: name,
			Invocation: "none",
		})
		for _, tool := range codexSliceOfMaps(server["tools"]) {
			toolName := firstNonEmptyString(codexTextValue(tool, "name"), codexTextValue(tool, "toolName"))
			if toolName == "" {
				continue
			}
			options = append(options, ComposerCapabilityOption{
				ID:          "mcpTool:" + name + "/" + toolName,
				Kind:        "mcpTool",
				Name:        toolName,
				Label:       toolName,
				Description: codexTextValue(tool, "description"),
				Status:      status,
				ServerName:  name,
				ToolName:    toolName,
				Invocation:  "none",
			})
		}
	}
	return options
}

func normalizeCodexMCPStatus(status string) string {
	normalized := strings.ToLower(strings.TrimSpace(status))
	switch {
	case strings.Contains(normalized, "auth"):
		return "authRequired"
	case strings.Contains(normalized, "fail"), strings.Contains(normalized, "error"), strings.Contains(normalized, "disabled"):
		return "setupRequired"
	default:
		return "available"
	}
}

func codexPluginSource(plugin map[string]any) string {
	source := codexNestedMap(plugin, "source")
	if source == nil {
		return codexTextValue(plugin, "source")
	}
	return firstNonEmptyString(codexTextValue(source, "type"), codexTextValue(source, "url"), codexTextValue(source, "path"))
}

func codexTextValue(values map[string]any, key string) string {
	if values == nil {
		return ""
	}
	value, ok := values[key]
	if !ok {
		return ""
	}
	switch typed := value.(type) {
	case string:
		return strings.TrimSpace(typed)
	case fmt.Stringer:
		return strings.TrimSpace(typed.String())
	default:
		return ""
	}
}

func codexBoolValue(values map[string]any, key string) (bool, bool) {
	if values == nil {
		return false, false
	}
	value, ok := values[key].(bool)
	return value, ok
}

func codexNestedMap(values map[string]any, key string) map[string]any {
	if values == nil {
		return nil
	}
	value, _ := values[key].(map[string]any)
	return value
}

func codexSliceOfMaps(value any) []map[string]any {
	items, ok := value.([]any)
	if !ok {
		return nil
	}
	result := make([]map[string]any, 0, len(items))
	for _, item := range items {
		if record, ok := item.(map[string]any); ok {
			result = append(result, record)
		}
	}
	return result
}

func mergeComposerCapabilityOptions(left []ComposerCapabilityOption, right []ComposerCapabilityOption) []ComposerCapabilityOption {
	if len(left) == 0 {
		return dedupeComposerCapabilityOptions(right)
	}
	if len(right) == 0 {
		return dedupeComposerCapabilityOptions(left)
	}
	return dedupeComposerCapabilityOptions(append(append([]ComposerCapabilityOption{}, left...), right...))
}

func dedupeComposerCapabilityOptions(options []ComposerCapabilityOption) []ComposerCapabilityOption {
	if len(options) == 0 {
		return []ComposerCapabilityOption{}
	}
	seen := map[string]struct{}{}
	result := make([]ComposerCapabilityOption, 0, len(options))
	for _, option := range options {
		id := strings.TrimSpace(option.ID)
		if id == "" {
			continue
		}
		if _, ok := seen[id]; ok {
			continue
		}
		seen[id] = struct{}{}
		result = append(result, option)
	}
	return result
}