feat(config): add hostRequirements pre-flight validation

e2e/tests/readconfiguration/readconfiguration.go

@@ -218,4 +218,32 @@ var _ = ginkgo.Describe("read-configuration command", ginkgo.Label("read-configu
 			gomega.Expect(opa["onAutoForward"]).To(gomega.Equal("ignore"))
 			gomega.Expect(opa["label"]).To(gomega.Equal("default"))
 		}, ginkgo.SpecTimeout(framework.TimeoutShort()))
+
+	ginkgo.It("preserves hostRequirements in configuration output", func(ctx context.Context) {
+		f := framework.NewDefaultFramework(initialDir + "/bin")
+		tempDir, err := framework.CopyToTempDirWithoutChdir(
+			"tests/readconfiguration/testdata-host-requirements",
+		)
+		framework.ExpectNoError(err)
+		ginkgo.DeferCleanup(func() { _ = os.RemoveAll(tempDir) })
+
+		stdout, _, err := f.ExecCommandCapture(ctx, []string{
+			"read-configuration",
+			"--workspace-folder", tempDir,
+		})
+		framework.ExpectNoError(err)
+
+		var result map[string]any
+		err = json.Unmarshal([]byte(stdout), &result)
+		framework.ExpectNoError(err, "output should be valid JSON")
+
+		config, ok := result["configuration"].(map[string]any)
+		gomega.Expect(ok).To(gomega.BeTrue(), "configuration should be an object")
+
+		hr, ok := config["hostRequirements"].(map[string]any)
+		gomega.Expect(ok).To(gomega.BeTrue(), "hostRequirements should be an object")
+		gomega.Expect(hr["cpus"]).To(gomega.BeEquivalentTo(4))
+		gomega.Expect(hr["memory"]).To(gomega.Equal("8gb"))
+		gomega.Expect(hr["storage"]).To(gomega.Equal("32gb"))
+	}, ginkgo.SpecTimeout(framework.TimeoutShort()))
 })

e2e/tests/readconfiguration/testdata-host-requirements/.devcontainer/devcontainer.json

@@ -0,0 +1,9 @@
+{
+  "name": "Host Requirements Test",
+  "image": "mcr.microsoft.com/devcontainers/base:ubuntu",
+  "hostRequirements": {
+    "cpus": 4,
+    "memory": "8gb",
+    "storage": "32gb"
+  }
+}

pkg/devcontainer/config/host_requirements.go

@@ -0,0 +1,124 @@
+package config
+
+import (
+	"fmt"
+	"regexp"
+	"strconv"
+	"strings"
+
+	"github.com/devsy-org/devsy/pkg/log"
+)
+
+// HostInfo provides system resource information for validation.
+// Abstracted as an interface to allow testing with mock values.
+type HostInfo interface {
+	NumCPU() int
+	TotalMemoryBytes() (uint64, error)
+	AvailableStorageBytes(path string) (uint64, error)
+}
+
+// ValidateHostRequirements checks whether the host satisfies the resource
+// requirements declared in devcontainer.json. Returns warning strings for
+// each unmet requirement; an empty slice means all requirements are met.
+func ValidateHostRequirements(
+	reqs *HostRequirements, host HostInfo, workspacePath string,
+) []string {
+	if reqs == nil {
+		return nil
+	}
+
+	var warnings []string
+	warnings = appendCPUWarning(warnings, reqs.CPUs, host)
+	warnings = appendMemoryWarning(warnings, reqs.Memory, host)
+	warnings = appendStorageWarning(warnings, reqs.Storage, host, workspacePath)
+
+	for _, w := range warnings {
+		log.Warnw("hostRequirements not met", "warning", w)
+	}
+	return warnings
+}
+
+func appendCPUWarning(warnings []string, required int, host HostInfo) []string {
+	if required <= 0 {
+		return warnings
+	}
+	available := host.NumCPU()
+	if available < required {
+		return append(warnings, fmt.Sprintf(
+			"cpus: required %d, available %d", required, available,
+		))
+	}
+	return warnings
+}
+
+func appendMemoryWarning(warnings []string, required string, host HostInfo) []string {
+	if required == "" {
+		return warnings
+	}
+	reqBytes, err := ParseSizeToBytes(required)
+	if err != nil {
+		return append(warnings, fmt.Sprintf("memory: invalid value %q: %v", required, err))
+	}
+	available, err := host.TotalMemoryBytes()
+	if err != nil {
+		return append(warnings, fmt.Sprintf("memory: unable to detect: %v", err))
+	}
+	if available < reqBytes {
+		return append(warnings, fmt.Sprintf(
+			"memory: required %s (%d bytes), available %d bytes",
+			required, reqBytes, available,
+		))
+	}
+	return warnings
+}
+
+func appendStorageWarning(
+	warnings []string, required string, host HostInfo, path string,
+) []string {
+	if required == "" {
+		return warnings
+	}
+	reqBytes, err := ParseSizeToBytes(required)
+	if err != nil {
+		return append(warnings, fmt.Sprintf("storage: invalid value %q: %v", required, err))
+	}
+	available, err := host.AvailableStorageBytes(path)
+	if err != nil {
+		return append(warnings, fmt.Sprintf("storage: unable to detect at %q: %v", path, err))
+	}
+	if available < reqBytes {
+		return append(warnings, fmt.Sprintf(
+			"storage: required %s (%d bytes), available %d bytes at %q",
+			required, reqBytes, available, path,
+		))
+	}
+	return warnings
+}
+
+var sizePattern = regexp.MustCompile(`(?i)^\s*(\d+)\s*(tb|gb|mb|kb)?\s*$`)
+
+// ParseSizeToBytes converts a human-readable size string (e.g. "8gb", "512mb")
+// to bytes. If no unit suffix is present, the value is treated as bytes.
+func ParseSizeToBytes(s string) (uint64, error) {
+	matches := sizePattern.FindStringSubmatch(s)
+	if matches == nil {
+		return 0, fmt.Errorf("unrecognized size format: %q", s)
+	}
+	val, err := strconv.ParseUint(matches[1], 10, 64)
+	if err != nil {
+		return 0, err
+	}
+	unit := strings.ToLower(matches[2])
+	switch unit {
+	case "tb":
+		return val * 1024 * 1024 * 1024 * 1024, nil
+	case "gb":
+		return val * 1024 * 1024 * 1024, nil
+	case "mb":
+		return val * 1024 * 1024, nil
+	case "kb":
+		return val * 1024, nil
+	default:
+		return val, nil
+	}
+}

pkg/devcontainer/config/host_requirements_storage_unix.go

@@ -0,0 +1,13 @@
+//go:build !windows
+
+package config
+
+import "syscall"
+
+func availableStorageBytes(path string) (uint64, error) {
+	var stat syscall.Statfs_t
+	if err := syscall.Statfs(path, &stat); err != nil {
+		return 0, err
+	}
+	return stat.Bavail * uint64(stat.Bsize), nil //nolint:gosec // Bsize type varies by platform
+}

pkg/devcontainer/config/host_requirements_storage_windows.go

@@ -0,0 +1,9 @@
+//go:build windows
+
+package config
+
+import "fmt"
+
+func availableStorageBytes(path string) (uint64, error) {
+	return 0, fmt.Errorf("storage detection not supported on windows")
+}

pkg/devcontainer/config/host_requirements_system.go

@@ -0,0 +1,60 @@
+package config
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"runtime"
+	"strconv"
+	"strings"
+)
+
+// SystemHostInfo provides real system resource information.
+type SystemHostInfo struct {
+	WorkspacePath string
+}
+
+func (s SystemHostInfo) NumCPU() int {
+	return runtime.NumCPU()
+}
+
+func (s SystemHostInfo) TotalMemoryBytes() (uint64, error) {
+	return readMemTotalFromProc()
+}
+
+func (s SystemHostInfo) AvailableStorageBytes(path string) (uint64, error) {
+	if path == "" {
+		path = "/"
+	}
+	bytes, err := availableStorageBytes(path)
+	if err != nil {
+		return 0, fmt.Errorf("statfs %q: %w", path, err)
+	}
+	return bytes, nil
+}
+
+func readMemTotalFromProc() (uint64, error) {
+	f, err := os.Open("/proc/meminfo")
+	if err != nil {
+		return 0, fmt.Errorf("open /proc/meminfo: %w", err)
+	}
+	defer f.Close() //nolint:errcheck // best-effort close on read-only file
+
+	scanner := bufio.NewScanner(f)
+	for scanner.Scan() {
+		line := scanner.Text()
+		if !strings.HasPrefix(line, "MemTotal:") {
+			continue
+		}
+		fields := strings.Fields(line)
+		if len(fields) < 2 {
+			return 0, fmt.Errorf("unexpected MemTotal format: %q", line)
+		}
+		kb, err := strconv.ParseUint(fields[1], 10, 64)
+		if err != nil {
+			return 0, fmt.Errorf("parse MemTotal: %w", err)
+		}
+		return kb * 1024, nil
+	}
+	return 0, fmt.Errorf("MemTotal not found in /proc/meminfo")
+}