tutti/services/tuttid/service/workspace/apps_runtime.go

package workspace

import (
	"context"
	"errors"
	"fmt"
	"log/slog"
	"path/filepath"
	"strings"
	"time"

	workspacebiz "github.com/tutti-os/tutti/services/tuttid/biz/workspace"
	builtinapps "github.com/tutti-os/tutti/services/tuttid/builtin-apps"
	workspacedata "github.com/tutti-os/tutti/services/tuttid/data/workspace"
)

var ErrInvalidWorkspaceAppRuntimeState = errors.New("invalid workspace app runtime state")

func (s *AppCenterService) Launch(ctx context.Context, workspaceID string, appID string) (workspacebiz.WorkspaceApp, error) {
	if _, err := s.workspaceSummary(ctx, workspaceID); err != nil {
		return workspacebiz.WorkspaceApp{}, err
	}

	appPackage, installation, err := s.installedPackage(ctx, workspaceID, appID)
	if err != nil {
		return workspacebiz.WorkspaceApp{}, err
	}

	runtimeState := s.runner().State(workspaceID, appPackage.AppID)
	switch runtimeState.Status {
	case workspacebiz.AppRuntimeStatusIdle:
		runtimeState, err = s.startPackage(ctx, workspaceID, appPackage, false)
		if err != nil {
			return workspacebiz.WorkspaceApp{}, err
		}
	case workspacebiz.AppRuntimeStatusPreparing, workspacebiz.AppRuntimeStatusStarting, workspacebiz.AppRuntimeStatusRunning:
	case workspacebiz.AppRuntimeStatusFailed:
		return workspacebiz.WorkspaceApp{}, fmt.Errorf("%w: failed workspace apps must be retried before launch", ErrInvalidWorkspaceAppRuntimeState)
	case workspacebiz.AppRuntimeStatusStopping:
		return workspacebiz.WorkspaceApp{}, fmt.Errorf("%w: workspace app is stopping", ErrInvalidWorkspaceAppRuntimeState)
	default:
		return workspacebiz.WorkspaceApp{}, fmt.Errorf("%w: unsupported status %q", ErrInvalidWorkspaceAppRuntimeState, runtimeState.Status)
	}

	return s.publishInstalledAppRuntime(ctx, workspaceID, appPackage, installation, runtimeState), nil
}

func (s *AppCenterService) Retry(ctx context.Context, workspaceID string, appID string) (workspacebiz.WorkspaceApp, error) {
	if _, err := s.workspaceSummary(ctx, workspaceID); err != nil {
		return workspacebiz.WorkspaceApp{}, err
	}

	appPackage, installation, err := s.installedPackage(ctx, workspaceID, appID)
	if err != nil {
		return workspacebiz.WorkspaceApp{}, err
	}
	if runtimeState := s.runner().State(workspaceID, appPackage.AppID); runtimeState.Status != workspacebiz.AppRuntimeStatusFailed {
		return workspacebiz.WorkspaceApp{}, fmt.Errorf("%w: workspace app retry requires failed runtime status", ErrInvalidWorkspaceAppRuntimeState)
	}
	runtimeState, err := s.startPackage(ctx, workspaceID, appPackage, true)
	if err != nil {
		return workspacebiz.WorkspaceApp{}, err
	}

	return s.publishInstalledAppRuntime(ctx, workspaceID, appPackage, installation, runtimeState), nil
}

func (s *AppCenterService) StartEnabled(ctx context.Context, workspaceID string) ([]workspacebiz.WorkspaceApp, error) {
	startedAt := time.Now()
	if _, err := s.workspaceSummary(ctx, workspaceID); err != nil {
		return nil, err
	}
	installations, err := s.Store.ListWorkspaceAppInstallations(ctx, workspaceID)
	if err != nil {
		return nil, err
	}
	enabledAppIDs := make(map[string]struct{}, len(installations))
	for _, installation := range installations {
		if installation.Enabled {
			enabledAppIDs[installation.AppID] = struct{}{}
		}
	}
	var builtins []builtinapps.App
	slog.Info("workspace app start enabled started", "workspaceId", workspaceID, "enabledAppCount", len(enabledAppIDs))
	if len(enabledAppIDs) > 0 {
		refreshStartedAt := time.Now()
		var err error
		builtins, err = s.refreshBuiltinCatalogForStartEnabled(ctx, workspaceID)
		if err != nil {
			slog.Warn(
				"workspace app start enabled remote catalog refresh failed; continuing with cached builtin catalog",
				"workspaceId", workspaceID,
				"error", err,
			)
			builtins, err = s.builtinCatalog(ctx)
			if err != nil {
				return nil, err
			}
		}
		slog.Info("workspace app start enabled remote catalog refresh completed", "workspaceId", workspaceID, "enabledAppCount", len(enabledAppIDs), "durationMs", time.Since(refreshStartedAt).Milliseconds())
	} else {
		slog.Info("workspace app start enabled remote catalog refresh skipped", "workspaceId", workspaceID, "enabledAppCount", len(enabledAppIDs), "reason", "no-enabled-apps")
	}
	remoteBuiltins := remoteBuiltinByAppID(builtins)

	for _, installation := range installations {
		if !installation.Enabled {
			continue
		}
		appPackage, err := s.Store.GetAppPackage(ctx, installation.AppID)
		if err != nil {
			if !errors.Is(err, workspacedata.ErrWorkspaceAppNotFound) {
				return nil, err
			}
			remoteBuiltin, ok := remoteBuiltins[installation.AppID]
			if !ok {
				return nil, err
			}
			s.startRemoteBuiltinInstallJob(workspaceID, remoteBuiltin)
			slog.Warn("workspace app start enabled deferred app; package unavailable locally", "workspaceId", workspaceID, "appId", installation.AppID)
			continue
		}
		if remoteBuiltin, ok := remoteBuiltins[installation.AppID]; ok && s.shouldMaterializeRemoteBuiltin(appPackage, remoteBuiltin) {
			s.startRemoteBuiltinInstallJob(workspaceID, remoteBuiltin)
			slog.Info(
				"workspace app start enabled deferred app; remote builtin update available",
				"workspaceId", workspaceID,
				"appId", installation.AppID,
				"currentVersion", appPackage.Version,
				"availableVersion", remoteBuiltin.Manifest.Version,
			)
			continue
		}
		runtimeState := s.runner().State(workspaceID, appPackage.AppID)
		switch runtimeState.Status {
		case workspacebiz.AppRuntimeStatusIdle:
		case workspacebiz.AppRuntimeStatusPreparing, workspacebiz.AppRuntimeStatusStarting, workspacebiz.AppRuntimeStatusRunning:
			continue
		case workspacebiz.AppRuntimeStatusFailed, workspacebiz.AppRuntimeStatusStopping:
			slog.Info(
				"workspace app start enabled skipped app in non-launchable runtime state",
				"workspaceId", workspaceID,
				"appId", appPackage.AppID,
				"runtimeStatus", runtimeState.Status,
			)
			continue
		default:
			slog.Warn(
				"workspace app start enabled skipped app in unknown runtime state",
				"workspaceId", workspaceID,
				"appId", appPackage.AppID,
				"runtimeStatus", runtimeState.Status,
			)
			continue
		}
		if _, err := s.startPackage(ctx, workspaceID, appPackage, false); err != nil {
			return nil, err
		}
	}
	slog.Info("workspace app start enabled completed", "workspaceId", workspaceID, "enabledAppCount", len(enabledAppIDs), "duration", time.Since(startedAt), "durationMs", time.Since(startedAt).Milliseconds())

	if len(enabledAppIDs) > 0 {
		return s.listWithBuiltins(ctx, workspaceID, builtins)
	}
	return s.List(ctx, workspaceID)
}

func (s *AppCenterService) refreshBuiltinCatalogForStartEnabled(ctx context.Context, workspaceID string) ([]builtinapps.App, error) {
	if s.BuiltinCatalog != nil {
		return s.BuiltinCatalog()
	}
	snapshot, err := s.refreshBuiltinCatalogAndWait(ctx)
	if err != nil {
		return nil, err
	}
	if snapshot.RemoteCatalog.Status == builtinapps.RemoteCatalogLoadStatusFailed {
		slog.Warn(
			"workspace app start enabled remote catalog refresh failed",
			"workspaceId", workspaceID,
			"error", snapshot.RemoteCatalog.LastError,
		)
	}
	return snapshot.Apps, nil
}

func (s *AppCenterService) StopAll(ctx context.Context, workspaceID string) ([]workspacebiz.WorkspaceApp, error) {
	if _, err := s.workspaceSummary(ctx, workspaceID); err != nil {
		return nil, err
	}

	s.deactivateWorkspaceAppCLI(ctx, workspaceID)
	s.runner().StopWorkspace(ctx, workspaceID)
	return s.List(ctx, workspaceID)
}

func (s *AppCenterService) publishInstalledAppRuntime(ctx context.Context, workspaceID string, appPackage workspacebiz.AppPackage, installation workspacebiz.AppInstallation, runtimeState workspacebiz.AppRuntimeState) workspacebiz.WorkspaceApp {
	app := workspacebiz.WorkspaceApp{
		Package:      appPackage,
		Installation: &installation,
		Runtime:      runtimeStateForActivePackage(runtimeState, appPackage),
	}
	app.CLI = s.appCLIState(workspaceID, app)
	return s.publishAppIfChanged(ctx, workspaceID, appPackage.AppID, app)
}

func (s *AppCenterService) startRemoteBuiltinInstallJob(workspaceID string, builtin builtinapps.App) bool {
	appID := strings.TrimSpace(builtin.Manifest.AppID)
	return s.startInstallJob(workspaceID, appID, InstallOptions{}, appRuntimeProfileForManifest(builtin.Manifest), func(ctx context.Context) (workspacebiz.AppPackage, error) {
		return s.packageForRemoteBuiltinInstall(ctx, builtin)
	})
}

func (s *AppCenterService) packageForRemoteBuiltinInstall(ctx context.Context, builtin builtinapps.App) (workspacebiz.AppPackage, error) {
	appID := strings.TrimSpace(builtin.Manifest.AppID)
	version := strings.TrimSpace(builtin.Manifest.Version)
	if appID == "" || version == "" {
		return workspacebiz.AppPackage{}, errors.New("remote builtin app id and version are required")
	}
	existing, err := s.Store.GetAppPackageVersion(ctx, appID, version)
	if err == nil && existing.Source == workspacebiz.AppPackageSourceBuiltin {
		if s.shouldMaterializeRemoteBuiltin(existing, builtin) {
			return s.downloadRemoteBuiltinPackage(ctx, builtin)
		}
		return existing, nil
	}
	if err != nil && !errors.Is(err, workspacedata.ErrWorkspaceAppNotFound) {
		return workspacebiz.AppPackage{}, err
	}
	return s.downloadRemoteBuiltinPackage(ctx, builtin)
}

func remoteBuiltinByAppID(builtins []builtinapps.App) map[string]builtinapps.App {
	apps := make(map[string]builtinapps.App, len(builtins))
	for _, builtin := range builtins {
		if builtin.Distribution.Kind != builtinapps.DistributionRemote {
			continue
		}
		appID := strings.TrimSpace(builtin.Manifest.AppID)
		if appID == "" {
			continue
		}
		apps[appID] = builtin
	}
	return apps
}

func (s *AppCenterService) installedPackage(ctx context.Context, workspaceID string, appID string) (workspacebiz.AppPackage, workspacebiz.AppInstallation, error) {
	appPackage, err := s.Store.GetAppPackage(ctx, appID)
	if err != nil {
		return workspacebiz.AppPackage{}, workspacebiz.AppInstallation{}, err
	}

	installations, err := s.Store.ListWorkspaceAppInstallations(ctx, workspaceID)
	if err != nil {
		return workspacebiz.AppPackage{}, workspacebiz.AppInstallation{}, err
	}
	for _, installation := range installations {
		if installation.AppID == appPackage.AppID {
			return appPackage, installation, nil
		}
	}
	return workspacebiz.AppPackage{}, workspacebiz.AppInstallation{}, workspacedata.ErrWorkspaceAppNotFound
}

func (s *AppCenterService) startPackage(ctx context.Context, workspaceID string, appPackage workspacebiz.AppPackage, restart bool) (workspacebiz.AppRuntimeState, error) {
	workspace, err := s.workspaceSummary(ctx, workspaceID)
	if err != nil {
		return workspacebiz.AppRuntimeState{}, err
	}
	root := s.workspaceAppStateRoot(workspaceID, appPackage.AppID)
	return s.runner().Start(ctx, AppStartInput{
		WorkspaceID:     workspaceID,
		WorkspaceName:   workspace.Name,
		AppID:           appPackage.AppID,
		PackageDir:      appPackage.PackageDir,
		Bootstrap:       appPackage.Manifest.Runtime.Bootstrap,
		HealthcheckPath: appPackage.Manifest.Runtime.HealthcheckPath,
		RuntimeProfile:  appRuntimeProfileForPackage(appPackage),
		RuntimeDir:      filepath.Join(root, "runtime"),
		DataDir:         filepath.Join(root, "data"),
		DatabaseDir:     filepath.Join(root, "database"),
		LogDir:          filepath.Join(root, "logs"),
		Restart:         restart,
	})
}