Work/Backend/internal/bootstrap/project_disk_bootstrap.go

// Path: Backend/internal/bootstrap/project_disk_bootstrap.go

package bootstrap

import (
	"fmt"
	"os"
	"path/filepath"
	"strings"
)

func (service *Service) ensureBootstrapPOSIXSkeleton(
	installation InstallationRecord,
	admin AdminSummary,
	organization namedRecord,
	department namedRecord,
	team namedRecord,
	project namedRecord,
) error {
	rootPath := strings.TrimSpace(service.posixRoot)
	if rootPath == "" {
		return nil
	}

	if err := os.MkdirAll(rootPath, 0o755); err != nil {
		return fmt.Errorf("create POSIX root: %w", err)
	}

	if err := writeCBORFile(filepath.Join(rootPath, posixSettingsFileName), map[string]any{
		"installation": map[string]any{
			"id":             installation.ID,
			"name":           installation.Name,
			"mode":           installation.Mode,
			"access":         installation.Access,
			"protocol":       installation.Protocol,
			"host":           installation.Host,
			"isBootstrapped": installation.IsBootstrapped,
		},
		"organization": map[string]any{
			"id":   organization.ID,
			"name": organization.Name,
			"slug": organization.Slug,
		},
	}); err != nil {
		return fmt.Errorf("write tenant %s: %w", posixSettingsFileName, err)
	}

	if err := writeCBORFile(filepath.Join(rootPath, posixLayoutFileName), map[string]any{
		"version": 1,
		"type":    "tenant-layout",
		"home": map[string]any{
			"defaultProjectSlug": project.Slug,
		},
	}); err != nil {
		return fmt.Errorf("write tenant %s: %w", posixLayoutFileName, err)
	}

	if err := os.MkdirAll(filepath.Join(rootPath, "catalog", "packs"), 0o755); err != nil {
		return fmt.Errorf("create catalog packs root: %w", err)
	}

	if err := os.MkdirAll(filepath.Join(rootPath, "catalog", "standalone"), 0o755); err != nil {
		return fmt.Errorf("create catalog standalone root: %w", err)
	}

	corePackPath := filepath.Join(rootPath, "catalog", "packs", "pack-core")
	corePackEntriesPath := filepath.Join(corePackPath, "entries")
	coreAppEntryPath := filepath.Join(corePackEntriesPath, "app-shell")
	standaloneAppPath := filepath.Join(rootPath, "catalog", "standalone", "app-shell")

	for _, dirPath := range []string{corePackPath, corePackEntriesPath, coreAppEntryPath, standaloneAppPath} {
		if err := os.MkdirAll(dirPath, 0o755); err != nil {
			return fmt.Errorf("create catalog directory %s: %w", dirPath, err)
		}
	}

	if err := writeJSONCFile(filepath.Join(corePackPath, posixManifestFileName), map[string]any{
		"id":          "pack-core",
		"slug":        "core",
		"type":        "pack",
		"name":        "Core Pack",
		"version":     "0.1.0",
		"description": "First-party shared package of starter Moku surfaces.",
		"entries": []map[string]any{{
			"slug": "app-shell",
			"path": "entries/app-shell",
		}},
		"capabilities": []string{"first-party", "bootstrap", "catalog-pack"},
	}); err != nil {
		return fmt.Errorf("write catalog pack %s: %w", posixManifestFileName, err)
	}

	if err := writeJSONCFile(filepath.Join(coreAppEntryPath, posixManifestFileName), map[string]any{
		"id":          "app-shell",
		"slug":        "app-shell",
		"type":        "app",
		"name":        "App Shell",
		"version":     "0.1.0",
		"description": "Primary shell surface for navigating the installation.",
		"source":      "pack-core",
		"runtime": map[string]any{
			"kind": "route",
			"path": "/v1/app-shell",
		},
		"capabilities": []string{"shell", "navigation", "workspace"},
	}); err != nil {
		return fmt.Errorf("write catalog entry %s: %w", posixManifestFileName, err)
	}

	if err := writeJSONCFile(filepath.Join(standaloneAppPath, posixManifestFileName), map[string]any{
		"id":          "app-shell",
		"slug":        "app-shell",
		"type":        "app",
		"name":        "App Shell",
		"version":     "0.1.0",
		"description": "Standalone registration for the primary shell surface.",
		"source":      "standalone",
		"runtime": map[string]any{
			"kind": "route",
			"path": "/v1/app-shell",
		},
		"capabilities": []string{"shell", "navigation", "standalone"},
	}); err != nil {
		return fmt.Errorf("write standalone entry %s: %w", posixManifestFileName, err)
	}

	departmentPath := filepath.Join(rootPath, "departments", slugDir("department", department.Slug))
	teamPath := filepath.Join(departmentPath, "teams", slugDir("team", team.Slug))
	projectPath := filepath.Join(rootPath, "projects", slugDir("project", project.Slug))
	usersPath := filepath.Join(rootPath, "users")
	personalName := strings.TrimSpace(admin.DisplayName)
	if personalName == "" {
		personalName = defaultPersonalDisplayName
	}
	personalSlug := normalizePOSIXSlug(personalName)
	personalHomePath := filepath.Join(usersPath, "personals", slugDir("personal", personalSlug))

	for _, dirPath := range []string{
		departmentPath,
		teamPath,
		projectPath,
		filepath.Join(projectPath, "children"),
		filepath.Join(projectPath, "tree"),
		filepath.Join(usersPath, "personals"),
		personalHomePath,
		filepath.Join(personalHomePath, "tree"),
	} {
		if err := os.MkdirAll(dirPath, 0o755); err != nil {
			return fmt.Errorf("create POSIX directory %s: %w", dirPath, err)
		}
	}

	if err := writeCBORFile(filepath.Join(departmentPath, posixSettingsFileName), map[string]any{
		"id":   department.ID,
		"name": department.Name,
		"slug": department.Slug,
		"type": "department",
	}); err != nil {
		return fmt.Errorf("write department %s: %w", posixSettingsFileName, err)
	}

	if err := writeCBORFile(filepath.Join(departmentPath, posixUsersFileName), map[string]any{
		"owners": []map[string]string{{
			"id":          admin.ID,
			"email":       admin.Email,
			"displayName": admin.DisplayName,
		}},
	}); err != nil {
		return fmt.Errorf("write department %s: %w", posixUsersFileName, err)
	}

	if err := writeCBORFile(filepath.Join(teamPath, posixSettingsFileName), map[string]any{
		"id":   team.ID,
		"name": team.Name,
		"slug": team.Slug,
		"type": "team",
	}); err != nil {
		return fmt.Errorf("write team %s: %w", posixSettingsFileName, err)
	}

	if err := writeCBORFile(filepath.Join(teamPath, posixUsersFileName), map[string]any{
		"owners": []map[string]string{{
			"id":          admin.ID,
			"email":       admin.Email,
			"displayName": admin.DisplayName,
		}},
	}); err != nil {
		return fmt.Errorf("write team %s: %w", posixUsersFileName, err)
	}

	if err := writeCBORFile(filepath.Join(projectPath, posixSettingsFileName), map[string]any{
		"id":   project.ID,
		"name": project.Name,
		"slug": project.Slug,
		"type": "project",
	}); err != nil {
		return fmt.Errorf("write project %s: %w", posixSettingsFileName, err)
	}

	if err := writeCBORFile(filepath.Join(projectPath, posixHomeFileName), map[string]any{
		"type":  "project-home",
		"title": project.Name,
	}); err != nil {
		return fmt.Errorf("write project %s: %w", posixHomeFileName, err)
	}

	if err := writeCBORFile(filepath.Join(projectPath, posixACLFileName), map[string]any{
		"version":  1,
		"inherits": true,
		"rules":    []any{},
	}); err != nil {
		return fmt.Errorf("write project %s: %w", posixACLFileName, err)
	}

	if err := writeCBORFile(filepath.Join(usersPath, posixSettingsFileName), map[string]any{
		"primaryAdminId": admin.ID,
	}); err != nil {
		return fmt.Errorf("write users %s: %w", posixSettingsFileName, err)
	}

	if err := writeCBORFile(filepath.Join(usersPath, posixDataFileName), map[string]any{
		"admins": []map[string]string{{
			"id":          admin.ID,
			"email":       admin.Email,
			"displayName": admin.DisplayName,
		}},
	}); err != nil {
		return fmt.Errorf("write users %s: %w", posixDataFileName, err)
	}

	if err := writeCBORFile(filepath.Join(personalHomePath, posixSettingsFileName), map[string]any{
		"type": "personal",
		"name": personalName,
		"slug": personalSlug,
		"theme": map[string]any{
			"presetId": "moku-midnight",
		},
	}); err != nil {
		return fmt.Errorf("write personal %s: %w", posixSettingsFileName, err)
	}

	if err := writeCBORFile(filepath.Join(personalHomePath, posixLayoutFileName), map[string]any{
		"version": 1,
		"type":    "personal-layout",
		"home": map[string]any{
			"defaultProjectSlug": project.Slug,
		},
	}); err != nil {
		return fmt.Errorf("write personal %s: %w", posixLayoutFileName, err)
	}

	if err := writeCBORFile(filepath.Join(personalHomePath, posixHomeFileName), map[string]any{
		"type":  "personal-home",
		"title": personalHomeTitle(personalName),
	}); err != nil {
		return fmt.Errorf("write personal %s: %w", posixHomeFileName, err)
	}

	return nil
}