tutti/services/tuttid/service/cli/appcli/registry.go

package appcli

import (
	"context"
	"errors"
	"fmt"
	"net/http"
	"os"
	"path/filepath"
	"strings"
	"sync"

	appclicore "github.com/tutti-os/tutti/packages/appcli/core"
	workspacebiz "github.com/tutti-os/tutti/services/tuttid/biz/workspace"
	cliservice "github.com/tutti-os/tutti/services/tuttid/service/cli"
)

const invokeSchemaVersion = appclicore.InvokeSchemaVersion

var reservedScopes = map[string]struct{}{
	"agent":  {},
	"help":   {},
	"issue":  {},
	"plan":   {},
	"status": {},
}

type WorkspaceCatalog interface {
	Startup(context.Context) (*workspacebiz.Summary, error)
	Get(context.Context, string) (workspacebiz.Summary, error)
}

type RuntimeController interface {
	EnsureAppRunningForCLI(context.Context, string, string) (string, error)
}

type Registry struct {
	Workspaces WorkspaceCatalog
	Runtime    RuntimeController
	HTTPClient *http.Client

	mu        sync.RWMutex
	scopeSets map[string]*appclicore.ScopeSet
}

type Activation struct {
	WorkspaceID string
	AppPackage  workspacebiz.AppPackage
	BaseURL     string
}

func NewRegistry(workspaces WorkspaceCatalog, runtime RuntimeController) *Registry {
	return &Registry{Workspaces: workspaces, Runtime: runtime}
}

func (r *Registry) Activate(_ context.Context, activation Activation) workspacebiz.AppCLIState {
	workspaceID := strings.TrimSpace(activation.WorkspaceID)
	appPackage := activation.AppPackage
	if appPackage.Manifest.CLI == nil {
		r.Deactivate(workspaceID, appPackage.AppID)
		return workspacebiz.AppCLIState{Status: workspacebiz.AppCLIStatusNone}
	}

	cliPath, err := CLIManifestPath(appPackage.PackageDir, appPackage.Manifest.CLI.Manifest)
	if err != nil {
		return r.setError(workspaceID, appPackage.AppID, "", "app_cli_manifest_path_invalid", err.Error())
	}
	manifest, err := ReadManifest(cliPath)
	if err != nil {
		return r.setError(workspaceID, appPackage.AppID, "", "app_cli_manifest_invalid", err.Error())
	}
	documentationFile, documentationPath, err := resolveDocumentation(appPackage.PackageDir, manifest)
	if err != nil {
		return r.setError(workspaceID, appPackage.AppID, manifest.Scope, errCode(err), err.Error())
	}
	iconURL := ""
	if appIconURL := appPackage.IconDataURL(); appIconURL != nil {
		iconURL = strings.TrimSpace(*appIconURL)
	}
	commands := appclicore.BuildCommands(manifest, appclicore.CommandBuildOptions{
		AppID:             appPackage.AppID,
		AppName:           appPackage.DisplayName(),
		IconURL:           iconURL,
		AppDescription:    appPackage.Description(),
		DocumentationFile: documentationFile,
		DocumentationPath: documentationPath,
	})

	r.mu.Lock()
	defer r.mu.Unlock()
	scopeSet := r.scopeSetLocked(workspaceID)
	state := scopeSet.Upsert(appclicore.RegisteredApp{
		AppID:    appPackage.AppID,
		AppName:  appPackage.DisplayName(),
		Scope:    manifest.Scope,
		BaseURL:  strings.TrimRight(strings.TrimSpace(activation.BaseURL), "/"),
		Commands: commands,
	})
	return serviceState(state)
}

func (r *Registry) Deactivate(workspaceID string, appID string) {
	workspaceID = strings.TrimSpace(workspaceID)
	appID = strings.TrimSpace(appID)
	if workspaceID == "" || appID == "" {
		return
	}
	r.mu.Lock()
	defer r.mu.Unlock()
	if r.scopeSets == nil {
		return
	}
	if scopeSet := r.scopeSets[workspaceID]; scopeSet != nil {
		scopeSet.Remove(appID)
		if scopeSet.Empty() {
			delete(r.scopeSets, workspaceID)
		}
	}
}

func (r *Registry) DeactivateApp(appID string) {
	appID = strings.TrimSpace(appID)
	if appID == "" {
		return
	}
	r.mu.Lock()
	defer r.mu.Unlock()
	for workspaceID, scopeSet := range r.scopeSets {
		if scopeSet == nil {
			continue
		}
		scopeSet.Remove(appID)
		if scopeSet.Empty() {
			delete(r.scopeSets, workspaceID)
		}
	}
}

func (r *Registry) Status(workspaceID string, app workspacebiz.WorkspaceApp) workspacebiz.AppCLIState {
	if app.Installation == nil || app.Package.Manifest.CLI == nil {
		return workspacebiz.AppCLIState{Status: workspacebiz.AppCLIStatusNone}
	}
	workspaceID = strings.TrimSpace(workspaceID)
	r.mu.RLock()
	defer r.mu.RUnlock()
	if r.scopeSets != nil {
		if scopeSet := r.scopeSets[workspaceID]; scopeSet != nil {
			if state := serviceState(scopeSet.State(app.Package.AppID)); state.Status != "" {
				return state
			}
		}
	}
	return workspacebiz.AppCLIState{Status: workspacebiz.AppCLIStatusPending}
}

func (r *Registry) Capabilities(ctx context.Context, invokeContext cliservice.InvokeContext) []cliservice.Capability {
	workspaceID, err := r.resolveWorkspaceID(ctx, invokeContext.WorkspaceID)
	if err != nil {
		return []cliservice.Capability{}
	}
	r.mu.RLock()
	scopeSet := r.scopeSet(workspaceID)
	if scopeSet == nil {
		r.mu.RUnlock()
		return []cliservice.Capability{}
	}
	capabilities := scopeSet.Capabilities(appclicore.CapabilityListOptions{
		IncludeIntegration: invokeContext.IncludeIntegrationCapabilities,
	})
	r.mu.RUnlock()
	return serviceCapabilities(capabilities)
}

func (r *Registry) Invoke(ctx context.Context, request cliservice.InvokeRequest) (cliservice.CommandOutput, error) {
	commandID := strings.TrimSpace(request.CommandID)
	if commandID == "" {
		return cliservice.CommandOutput{}, cliservice.ErrCommandNotFound
	}
	if strings.TrimSpace(request.Context.ParentCommandID) == commandID {
		return cliservice.CommandOutput{}, fmt.Errorf("%w: recursive app cli command invocation", cliservice.ErrInvalidInput)
	}
	workspaceID, err := r.resolveWorkspaceID(ctx, request.Context.WorkspaceID)
	if err != nil {
		return cliservice.CommandOutput{}, err
	}
	app, command, ok := r.command(workspaceID, commandID)
	if !ok {
		return cliservice.CommandOutput{}, cliservice.ErrCommandNotFound
	}
	if request.OutputMode == "" {
		request.OutputMode = serviceOutputMode(command.Capability.Output.DefaultMode)
	}
	input, warnings, err := appclicore.NormalizeInputWithWarnings(command.Manifest.InputSchema, request.Input)
	if err != nil {
		return cliservice.CommandOutput{}, serviceInvokeError(err)
	}
	baseURL, err := r.ensureRunning(ctx, workspaceID, app.AppID, app.BaseURL)
	if err != nil {
		return cliservice.CommandOutput{}, cliservice.ServiceUnavailableError("app_cli_runtime_unavailable", err)
	}
	output, err := appclicore.InvokeHTTP(ctx, appclicore.HTTPInvokeRequest{
		BaseURL:     baseURL,
		Command:     command,
		AppID:       app.AppID,
		Scope:       app.Scope,
		WorkspaceID: workspaceID,
		Input:       input,
		OutputMode:  coreOutputMode(request.OutputMode),
		Context: appclicore.InvokeContext{
			Source:          request.Context.Source,
			ParentCommandID: request.Context.ParentCommandID,
		},
		HTTPClient: r.HTTPClient,
	})
	if err != nil {
		return cliservice.CommandOutput{}, serviceInvokeError(err)
	}
	output, err = appclicore.ValidateCommandOutput(command.Capability.Output, output)
	if err != nil {
		return cliservice.CommandOutput{}, serviceInvokeError(err)
	}
	if err := appclicore.ValidateCommandContinuation(command.Capability.Execution, output); err != nil {
		return cliservice.CommandOutput{}, serviceInvokeError(err)
	}
	result := serviceCommandOutput(output)
	result.Warnings = serviceInputWarnings(warnings)
	return result, nil
}

func (r *Registry) command(workspaceID string, commandID string) (appclicore.RegisteredApp, appclicore.Command, bool) {
	r.mu.RLock()
	defer r.mu.RUnlock()
	scopeSet := r.scopeSet(workspaceID)
	if scopeSet == nil {
		return appclicore.RegisteredApp{}, appclicore.Command{}, false
	}
	return scopeSet.Command(commandID)
}

func (r *Registry) ensureRunning(ctx context.Context, workspaceID string, appID string, fallbackBaseURL string) (string, error) {
	if r.Runtime == nil {
		if strings.TrimSpace(fallbackBaseURL) == "" {
			return "", errors.New("app cli runtime controller is unavailable")
		}
		return strings.TrimRight(strings.TrimSpace(fallbackBaseURL), "/"), nil
	}
	baseURL, err := r.Runtime.EnsureAppRunningForCLI(ctx, workspaceID, appID)
	if err != nil {
		return "", err
	}
	baseURL = strings.TrimRight(strings.TrimSpace(baseURL), "/")
	if baseURL == "" {
		return "", errors.New("app runtime base url is unavailable")
	}
	r.mu.Lock()
	if scopeSet := r.scopeSet(workspaceID); scopeSet != nil {
		scopeSet.UpdateBaseURL(appID, baseURL)
	}
	r.mu.Unlock()
	return baseURL, nil
}

func (r *Registry) setError(workspaceID string, appID string, scope string, code string, message string) workspacebiz.AppCLIState {
	r.mu.Lock()
	defer r.mu.Unlock()
	scopeSet := r.scopeSetLocked(workspaceID)
	return serviceState(scopeSet.SetError(appID, scope, appclicore.Issue{Code: code, Message: message}))
}

func (r *Registry) resolveWorkspaceID(ctx context.Context, requested string) (string, error) {
	if r.Workspaces == nil {
		return strings.TrimSpace(requested), nil
	}
	return cliservice.ResolveWorkspaceID(ctx, r.Workspaces, requested)
}

func (r *Registry) scopeSet(workspaceID string) *appclicore.ScopeSet {
	if r.scopeSets == nil {
		return nil
	}
	return r.scopeSets[strings.TrimSpace(workspaceID)]
}

func (r *Registry) scopeSetLocked(workspaceID string) *appclicore.ScopeSet {
	if r.scopeSets == nil {
		r.scopeSets = map[string]*appclicore.ScopeSet{}
	}
	workspaceID = strings.TrimSpace(workspaceID)
	if r.scopeSets[workspaceID] == nil {
		r.scopeSets[workspaceID] = appclicore.NewScopeSet(appclicore.ScopeSetOptions{
			ReservedScopes: reservedScopes,
			IssueMessages: appclicore.ScopeIssueMessages{
				Reserved: func(scope string) appclicore.Issue {
					return appclicore.Issue{
						Code:    "app_cli_scope_reserved",
						Message: fmt.Sprintf("CLI scope %q is reserved by Tutti.", scope),
					}
				},
				Conflict: func(scope string, winnerAppID string) appclicore.Issue {
					return appclicore.Issue{
						Code:    "app_cli_scope_conflict",
						Message: fmt.Sprintf("CLI scope %q is already provided by app %q.", scope, winnerAppID),
					}
				},
			},
		})
	}
	return r.scopeSets[workspaceID]
}

type documentationError struct {
	code string
	err  error
}

func (e documentationError) Error() string {
	if e.err == nil {
		return ""
	}
	return e.err.Error()
}

func (e documentationError) Unwrap() error {
	return e.err
}

func errCode(err error) string {
	var docErr documentationError
	if errors.As(err, &docErr) {
		return docErr.code
	}
	return "app_cli_documentation_path_invalid"
}

func resolveDocumentation(packageDir string, manifest Manifest) (string, string, error) {
	if manifest.Documentation == nil {
		return "", "", nil
	}
	documentationFile := strings.TrimSpace(manifest.Documentation.File)
	resolvedDocumentationPath, err := CLIManifestPath(packageDir, documentationFile)
	if err != nil {
		return "", "", documentationError{code: "app_cli_documentation_path_invalid", err: err}
	}
	if info, err := os.Stat(resolvedDocumentationPath); err != nil || info.IsDir() {
		if err == nil {
			err = fmt.Errorf("documentation file %q is a directory", documentationFile)
		}
		return "", "", documentationError{code: "app_cli_documentation_missing", err: err}
	}
	absoluteDocumentationPath, err := filepath.Abs(resolvedDocumentationPath)
	if err != nil {
		return "", "", documentationError{code: "app_cli_documentation_path_invalid", err: err}
	}
	return documentationFile, absoluteDocumentationPath, nil
}

func serviceInvokeError(err error) error {
	if err == nil {
		return nil
	}
	if errors.Is(err, appclicore.ErrInvalidInput) {
		return fmt.Errorf("%w: %s", cliservice.ErrInvalidInput, err.Error())
	}
	if errors.Is(err, appclicore.ErrServiceUnavailable) {
		reason := appclicore.InvokeErrorReason(err)
		if reason == "" {
			reason = "app_cli_runtime_unavailable"
		}
		return cliservice.ServiceUnavailableError(reason, err)
	}
	if errors.Is(err, appclicore.ErrHandlerBadResponse) || errors.Is(err, appclicore.ErrHandlerFailed) {
		reason := appclicore.InvokeErrorReason(err)
		if reason == "" {
			reason = "app_cli_handler_bad_response"
		}
		return cliservice.WorkspaceOperationError(reason, err)
	}
	return err
}

func serviceCapabilities(capabilities []appclicore.Capability) []cliservice.Capability {
	if len(capabilities) == 0 {
		return []cliservice.Capability{}
	}
	result := make([]cliservice.Capability, 0, len(capabilities))
	for _, capability := range capabilities {
		result = append(result, serviceCapability(capability))
	}
	return result
}

func serviceCapability(capability appclicore.Capability) cliservice.Capability {
	return cliservice.Capability{
		ID:               capability.ID,
		Path:             append([]string(nil), capability.Path...),
		Summary:          capability.Summary,
		Description:      capability.Description,
		Visibility:       serviceCapabilityVisibility(capability.Visibility),
		InputSchema:      appclicore.CloneSchema(capability.InputSchema),
		Output:           serviceCapabilityOutput(capability.Output),
		Execution:        serviceCommandExecution(capability.Execution),
		HandlerTimeoutMs: capability.HandlerTimeoutMs,
		Source:           serviceCapabilitySource(capability.Source),
	}
}

func serviceCommandExecution(execution *appclicore.CommandExecution) *cliservice.CommandExecution {
	if execution == nil {
		return nil
	}
	return &cliservice.CommandExecution{Mode: cliservice.CommandExecutionMode(execution.Mode)}
}

func serviceCapabilityVisibility(visibility appclicore.CommandVisibility) cliservice.CapabilityVisibility {
	switch appclicore.NormalizeVisibility(visibility) {
	case appclicore.CommandVisibilityIntegration:
		return cliservice.CapabilityVisibilityIntegration
	default:
		return cliservice.CapabilityVisibilityPublic
	}
}

func serviceCapabilityOutput(output appclicore.CapabilityOutput) cliservice.CapabilityOutput {
	return cliservice.CapabilityOutput{
		DefaultMode: serviceOutputMode(output.DefaultMode),
		JSON:        output.JSON,
		Table:       serviceTableOutput(output.Table),
	}
}

func serviceCapabilitySource(source appclicore.CapabilitySource) cliservice.CapabilitySource {
	return cliservice.CapabilitySource{
		Kind:              cliservice.CapabilitySourceApp,
		AppID:             source.AppID,
		AppName:           source.AppName,
		IconURL:           source.IconURL,
		CLIDescription:    source.CLIDescription,
		AppDescription:    source.AppDescription,
		DocumentationFile: source.DocumentationFile,
		DocumentationPath: source.DocumentationPath,
	}
}

func serviceTableOutput(output *appclicore.TableOutput) *cliservice.TableOutput {
	if output == nil {
		return nil
	}
	return &cliservice.TableOutput{Columns: serviceTableColumns(output.Columns)}
}

func serviceCommandOutput(output appclicore.CommandOutput) cliservice.CommandOutput {
	result := cliservice.CommandOutput{
		Kind:    serviceOutputMode(output.Kind),
		Columns: serviceTableColumns(output.Columns),
		Rows:    output.Rows,
		Value:   output.Value,
		Text:    output.Text,
	}
	if output.Continuation != nil {
		result.Continuation = &cliservice.CommandContinuation{
			State: cliservice.CommandContinuationState(output.Continuation.State), RetryAfterMs: output.Continuation.RetryAfterMs,
		}
	}
	return result
}

func serviceInputWarnings(warnings []appclicore.InputWarning) []cliservice.CommandWarning {
	if len(warnings) == 0 {
		return nil
	}
	result := make([]cliservice.CommandWarning, 0, len(warnings))
	for _, warning := range warnings {
		result = append(result, cliservice.CommandWarning{
			Code:    warning.Code,
			Message: warning.Message,
		})
	}
	return result
}

func serviceTableColumns(columns []appclicore.TableColumn) []cliservice.TableColumn {
	if len(columns) == 0 {
		return nil
	}
	result := make([]cliservice.TableColumn, 0, len(columns))
	for _, column := range columns {
		result = append(result, cliservice.TableColumn{Key: column.Key, Label: column.Label})
	}
	return result
}

func serviceOutputMode(mode appclicore.OutputMode) cliservice.OutputMode {
	return cliservice.OutputMode(mode)
}

func coreOutputMode(mode cliservice.OutputMode) appclicore.OutputMode {
	return appclicore.OutputMode(mode)
}

func serviceState(state appclicore.State) workspacebiz.AppCLIState {
	if state.Status == "" {
		return workspacebiz.AppCLIState{}
	}
	return workspacebiz.AppCLIState{
		Status: workspacebiz.AppCLIStatus(state.Status),
		Scope:  state.Scope,
		Active: state.Active,
		Issues: serviceIssues(state.Issues),
	}
}

func serviceIssues(issues []appclicore.Issue) []workspacebiz.AppCLIIssue {
	if len(issues) == 0 {
		return nil
	}
	result := make([]workspacebiz.AppCLIIssue, 0, len(issues))
	for _, issue := range issues {
		result = append(result, workspacebiz.AppCLIIssue{Code: issue.Code, Message: issue.Message})
	}
	return result
}