@flisk-sh/flisk 0.0.0-stage → 1.3.190

package/discovery/manifest/normalize.star

@@ -0,0 +1,289 @@
+# Copyright (c) 2026 Flisk contributors
+# SPDX-License-Identifier: MIT
+# =============================================================================
+# 📋 TILT SDK - MANIFEST NORMALIZATION & DISCOVERY
+# =============================================================================
+# Path: .tilt/topologies/tilt/discovery/manifest/normalize.star
+# Purpose: Normalize manifests and provide helper accessors
+# =============================================================================
+
+load('../../engine/topologies/tilt/manifest/parser.star', 'generated_string_error')
+load('./constants.star', 'MANIFEST_DEFAULTS', 'MANIFEST_FILENAME')
+load('./loading.star', 'apply_manifest_defaults', 'check_prisma_folder', 'get_default_syncs_for_type')
+load('./validation.star', 'validate_manifest')
+load('../../engine/topologies/tilt/common/utils.star', 'Utils')
+load('../../engine/topologies/platform/docker/constants.star', 'PlatformDockerConstants')
+load('../../specs/specs/TILT_TECH_STACK.star', 'RUNTIME', 'MESSAGING')
+
+
+def _load_and_normalize(manifest_path, warn_only=True):
+    """
+    🎯 MAIN ENTRY POINT: Load manifest and normalize to full resource config.
+    
+    This function is the bridge between the discovery system (resource_registry.star)
+    and the manifest loading system. It:
+    
+    1. Reads the JSON file
+    2. Validates the structure
+    3. Normalizes with smart defaults
+    4. Computes labels, syncs, has_migrator
+    5. Returns a resource-ready configuration
+    
+    Args:
+        manifest_path: Full path to manifest file
+        warn_only: If True, return None on error instead of failing
+        
+    Returns:
+        Normalized manifest dict or None on error (if warn_only=True)
+    """
+    # Prepend project root to relative paths for correct resolution
+    project_root = os.environ.get('TDK_PROJECT_ROOT', '')
+    if project_root and not manifest_path.startswith('/'):
+        full_path = project_root + '/' + manifest_path
+    else:
+        full_path = manifest_path
+    
+    # Read manifest file
+    content = read_file(full_path, default='')
+    
+    if not content or not str(content).strip():
+        if warn_only:
+            print("   ⚠️  Empty or missing manifest: " + manifest_path)
+            return None
+        fail("Empty or missing manifest: " + manifest_path)
+    
+    # Parse JSON
+    manifest = decode_json(content)
+    if manifest == None:
+        if warn_only:
+            print("   ⚠️  Invalid JSON in manifest: " + manifest_path)
+            return None
+        fail("Invalid JSON in manifest: " + manifest_path)
+
+    # Refuse service.json values that would add keys to generated config (GHSA-phgf-pww4-7jxc)
+    unsafe_field_error = generated_string_error(manifest, manifest_path) if type(manifest) == "dict" else None
+    if unsafe_field_error:
+        fail(unsafe_field_error)
+    
+    # Validate
+    issues = validate_manifest(manifest)
+    if issues:
+        if warn_only:
+            for issue in issues:
+                print("   ⚠️  " + manifest_path + ": " + issue)
+            return None
+        fail("Manifest validation failed:\n" + "\n".join(issues))
+    
+    # Extract service path from manifest path
+    resource_path = manifest_path.rsplit('/', 1)[0]
+    
+    # BUG FIX: Normalize various path patterns to project-relative paths
+    # Pattern 1: Worktrees - .worktrees/task1-dry/services/platform/...
+    # Pattern 2: Flisk output - .tdk/.tdk-out/../.. or .tdk/.tdk-out/../../path
+    
+    if resource_path.startswith('.worktrees/'):
+        # Extract the part after the worktree name
+        parts = resource_path.split('/')
+        if len(parts) >= 3:
+            resource_path = '/'.join(parts[2:])
+    elif '.worktrees/' in resource_path:
+        worktree_idx = resource_path.find('.worktrees/')
+        after_worktree = resource_path[worktree_idx:]
+        parts = after_worktree.split('/')
+        if len(parts) >= 3:
+            resource_path = '/'.join(parts[2:])
+    elif '.tdk/.tdk-out/../..' in resource_path:
+        # Handle Flisk output paths like: /path/to/.tdk/.tdk-out/../.. or .tdk/.tdk-out/../../services/...
+        tdk_idx = resource_path.find('.tdk/.tdk-out/../..')
+        if tdk_idx != -1:
+            after_tdk = resource_path[tdk_idx + len('.tdk/.tdk-out/../..'):]
+            if after_tdk.startswith('/'):
+                after_tdk = after_tdk[1:]
+            resource_path = after_tdk
+    elif resource_path.endswith('.tdk/.tdk-out/../..'):
+        # Handle bare Flisk output path that ends with just the resolution pattern
+        resource_path = ''
+    
+    # Apply smart defaults
+    normalized = apply_manifest_defaults(manifest, resource_path)
+    
+    # Compute additional fields for registry compatibility
+    app_name = normalized.get('appName', '')
+    app_type = normalized.get('appType', 'backend')
+    stack = normalized.get('stack', '')
+    features = normalized.get('featuresEnabled', [])
+    
+    # 🎯 AUTO-COMPUTE labels from stack
+    normalized['labels'] = ['app.' + stack]
+    
+    # 🎯 AUTO-DETECT has_migrator
+    has_migrator = 'prisma' in features
+    if not has_migrator:
+        has_migrator = check_prisma_folder(resource_path)
+    normalized['has_migrator'] = has_migrator
+    
+    # 🎯 AUTO-COMPUTE syncs if not specified
+    if normalized.get('syncs') == None:
+        normalized['syncs'] = get_default_syncs_for_type(app_type, features)
+    
+    # 🎯 COMPUTE dockerfile path
+    dockerfile = normalized.get('dockerfile', 'Dockerfile')
+    normalized['dockerfile_path'] = app_name + '/' + dockerfile
+    
+    # 🎯 MARK as frontend if applicable
+    if app_type == 'frontend':
+        normalized['frontend'] = True
+    
+    # 🎯 EXTRACT dependencies for registry
+    normalized['serviceDependencies'] = normalized.get('dependsOn', [])
+
+    return normalized
+
+
+def _discover_manifests_in_path(root_path):
+    """
+    Discover all manifest files under a root path.
+    
+    Args:
+        root_path: Directory to search (e.g., 'services/product')
+        
+    Returns:
+        List of manifest file paths
+    """
+    find_cmd = "find {root} -name '{filename}' -type f 2>/dev/null | sort".format(
+        root=root_path,
+        filename=MANIFEST_FILENAME
+    )
+    result = str(local(find_cmd, quiet=True, echo_off=True))
+    
+    manifests = []
+    if result:
+        for line in result.strip().split('\n'):
+            if line and line.strip():
+                manifests.append(line.strip())
+    
+    return manifests
+
+
+def _load_all_manifests(root_path, warn_only=True):
+    """
+    Load and normalize all manifests under a root path.
+    
+    Args:
+        root_path: Directory to search (e.g., 'services/product')
+        warn_only: If True, skip invalid manifests with warnings
+        
+    Returns:
+        List of normalized manifest dicts
+    """
+    manifest_paths = _discover_manifests_in_path(root_path)
+    manifests = []
+    
+    for path in manifest_paths:
+        normalized = _load_and_normalize(path, warn_only=warn_only)
+        if normalized:
+            manifests.append(normalized)
+    
+    return manifests
+
+
+def _get_port(manifest):
+    """Get the resource port from manifest."""
+    return manifest.get('port', MANIFEST_DEFAULTS['port'])
+
+
+def _get_database_url(manifest, host='localhost', port=5432):
+    """
+    Generate DATABASE_URL from manifest.
+    
+    Args:
+        manifest: Manifest dictionary
+        host: Database host (default: localhost)
+        port: Database port (default: 5432)
+        
+    Returns:
+        PostgreSQL connection string
+    """
+    db_name = manifest.get('databaseName', PlatformDockerConstants.get_db_name(manifest.get('stack', 'app')))
+    return PlatformDockerConstants.get_tilt_database_url_template().format(
+        host=host,
+        port=port,
+        db=db_name,
+    )
+
+
+def _print_summary(manifests):
+    """
+    Print formatted summary of loaded manifests.
+    
+    Args:
+        manifests: List of manifest dictionaries
+    """
+    print("")
+    print("📋 ═══════════════════════════════════════════════════════════════")
+    print("📋  LOADED MANIFESTS")
+    print("📋 ═══════════════════════════════════════════════════════════════")
+    
+    for m in manifests:
+        status = "✅" if not m.get('_synthesized') else "⚡"
+        app_name = m.get('appName', 'unknown')
+        app_type = m.get('appType', 'unknown')
+        port = m.get('port', 0)
+        stack = m.get('stack', 'unknown')
+        
+        print("   {status} {name} | {type} | Port: {port} | Stack: {stack}".format(
+            status=status,
+            name=app_name,
+            type=app_type,
+            port=port,
+            stack=stack,
+        ))
+    
+    print("📋 ═══════════════════════════════════════════════════════════════")
+    print("")
+
+
+def _generate_manifest_template(app_name, stack, app_type='backend', port=4000):
+    """
+    🎯 TEMPLATE GENERATOR: Returns a string with a standard manifest.
+    """
+    template = {
+        "$schema": PlatformDockerConstants.RESOURCE_SCHEMA_URL,
+        "appName": app_name,
+        "appType": app_type,
+        "stack": stack,
+        "port": port,
+        "replicas": 1,
+        "featuresEnabled": [MESSAGING, "infisical"],
+        "dependsOn": [],
+        "runtime": RUNTIME
+    }
+    return Utils.encode_json(template)
+
+
+def load_and_normalize(manifest_path, warn_only=True):
+    return _load_and_normalize(manifest_path, warn_only=warn_only)
+
+
+def discover_manifests_in_path(root_path):
+    return _discover_manifests_in_path(root_path)
+
+
+def load_all_manifests(root_path, warn_only=True):
+    return _load_all_manifests(root_path, warn_only=warn_only)
+
+
+def get_port(manifest):
+    return _get_port(manifest)
+
+
+def get_database_url(manifest, host='localhost', port=5432):
+    return _get_database_url(manifest, host=host, port=port)
+
+
+def print_summary(manifests):
+    return _print_summary(manifests)
+
+
+def generate_manifest_template(app_name, stack, app_type='backend', port=4000):
+    return _generate_manifest_template(app_name, stack, app_type=app_type, port=port)

package/discovery/manifest/validation.star

@@ -0,0 +1,110 @@
+# Copyright (c) 2026 Flisk Landscape contributors
+# SPDX-License-Identifier: MIT
+# =============================================================================
+# ✅ TILT SDK - MANIFEST VALIDATION
+# =============================================================================
+# Path: .tilt/topologies/tilt/discovery/manifest/validation.star
+# Purpose: Validate manifest structure and values
+# =============================================================================
+
+load('./constants.star', 'VALID_APP_TYPES')
+load('../TILT_DISCOVERY.star', 'VALID_STACKS', 'VALID_RESOURCE_FEATURES', 'PORT_RANGES')
+
+
+def validate_manifest(manifest):
+    """
+    🎯 ENTERPRISE VALIDATOR: Strict structure and value validation.
+    
+    Validates:
+    - Required fields: appName, appType, stack, port
+    - appName pattern: kebab-case, 3-64 chars
+    - appType: from VALID_APP_TYPES
+    - stack: from VALID_STACKS
+    - appType: from VALID_APP_TYPES
+    - port: within range for appType (backends: 4000-5999, frontends: 3000-3999)
+    - features: from VALID_RESOURCE_FEATURES
+    - dependsOn: from VALID_STACKS (resource aliases)
+    - replicas: 1-10
+    """
+    issues = []
+    
+    # 1. Required fields & appName pattern
+    app_name = manifest.get('appName')
+    if not app_name:
+        issues.append("Missing required field: appName")
+    elif type(app_name) != 'string':
+        issues.append("appName must be a string")
+    elif len(app_name) < 3:
+        issues.append("appName too short: '" + app_name + "'. Minimum 3 characters")
+    elif len(app_name) > 64:
+        issues.append("appName too long: '" + app_name + "'. Maximum 64 characters")
+    
+    # Check kebab-case pattern
+    for i in range(len(app_name)):
+        char = app_name[i]
+        if not (char.islower() or char.isdigit() or char == '-'):
+            issues.append("Invalid character in appName: '" + char + "'. Must be kebab-case (lowercase, numbers, hyphens)")
+            break
+    if app_name.startswith('-') or app_name.endswith('-'):
+        issues.append("appName cannot start or end with a hyphen")
+    
+    # 2. appType validation
+    app_type = manifest.get('appType')
+    if not app_type:
+        issues.append("Missing required field: appType")
+    elif app_type not in VALID_APP_TYPES:
+        issues.append("Invalid appType: " + str(app_type) + ". Must be one of: " + ', '.join(VALID_APP_TYPES))
+    
+    # 3. stack validation
+    stack = manifest.get('stack')
+    if not stack:
+        issues.append("Missing required field: stack")
+    elif len(VALID_STACKS) > 0 and stack not in VALID_STACKS:
+        # Only validate against list if VALID_STACKS is not empty
+        issues.append("Invalid stack: " + str(stack) + ". Must be one of: " + ', '.join(VALID_STACKS))
+    
+    # 4. port validation with appType-specific ranges (skip for infra services)
+    port = manifest.get('port')
+    if port == None:
+        if app_type != 'infra':
+            issues.append("Missing required field: port")
+    elif type(port) != 'int':
+        issues.append("Invalid port: " + str(port) + ". Must be an integer")
+    elif app_type != 'infra':
+        if port < 3000 or port > 9999:
+            issues.append("Invalid port: " + str(port) + ". Must be integer 3000-9999")
+        elif app_type and app_type in PORT_RANGES:
+            port_range = PORT_RANGES[app_type]
+            if port < port_range['min'] or port > port_range['max']:
+                issues.append("Port " + str(port) + " out of range for " + app_type + ". Expected " + str(port_range['min']) + "-" + str(port_range['max']))
+    
+    # 5. Validate features array
+    features = manifest.get('featuresEnabled', [])
+    if type(features) != 'list':
+        issues.append("Invalid features: must be an array")
+    else:
+        for f in features:
+            if f not in VALID_RESOURCE_FEATURES:
+                issues.append("Invalid feature: " + str(f) + ". Must be one of: " + ', '.join(VALID_RESOURCE_FEATURES))
+    
+    # 6. Validate dependsOn array (must be valid resource aliases)
+    deps = manifest.get('dependsOn', [])
+    if type(deps) != 'list':
+        issues.append("Invalid dependsOn: must be an array")
+    else:
+        # Valid dependency targets are discovered dynamically from manifests
+        # No hardcoded list - all dependencies validated against discovered resources
+        # The actual validation happens at orchestration time, not here
+        pass
+    
+    # 7. Validate replicas (if specified)
+    replicas = manifest.get('replicas')
+    if replicas != None:
+        if type(replicas) != 'int':
+            issues.append("Invalid replicas: must be an integer")
+        elif replicas < 1:
+            issues.append("Invalid replicas: " + str(replicas) + ". Minimum is 1")
+        elif replicas > 10:
+            issues.append("Invalid replicas: " + str(replicas) + ". Maximum is 10")
+    
+    return issues

package/discovery/normalization.star

@@ -0,0 +1,13 @@
+# Copyright (c) 2026 Flisk Landscape contributors
+# SPDX-License-Identifier: MIT
+load(
+    "./manifest/normalize.star",
+    _load_and_normalize = "load_and_normalize",
+    _load_all_manifests = "load_all_manifests",
+)
+
+def normalize(manifest_path, warn_only = True):
+    return _load_and_normalize(manifest_path, warn_only = warn_only)
+
+def normalize_all(root_path, warn_only = True):
+    return _load_all_manifests(root_path, warn_only = warn_only)