@flisk-sh/flisk 0.0.0-stage → 1.3.190

package/ext/ide-components/shared/test_config_service.py

@@ -0,0 +1,328 @@
+#!/usr/bin/env python3
+# Copyright (c) 2026 Flisk Landscape contributors
+# SPDX-License-Identifier: MIT
+"""
+Automated tests for ConfigService
+Tests path validation, file operations, backups, and security features.
+"""
+
+import os
+import sys
+import tempfile
+import shutil
+from pathlib import Path
+
+# Add parent to path
+sys.path.insert(0, str(Path(__file__).parent))
+from config_service import ConfigService, SaveResult
+
+
+class TestConfigService:
+    """Test suite for ConfigService"""
+    
+    def __init__(self):
+        self.passed = 0
+        self.failed = 0
+        self.temp_dir = None
+    
+    def setup(self):
+        """Create temporary test directory"""
+        self.temp_dir = tempfile.mkdtemp()
+        # Create structure mimicking project
+        (Path(self.temp_dir) / '.tilt-engine' / 'topologies').mkdir(parents=True)
+        (Path(self.temp_dir) / '.tilt-engine' / 'topologies' / 'test.star').write_text('# test')
+        
+        # Create root master configs
+        (Path(self.temp_dir) / 'TILT_RESOURCE_DEFAULTS.star').write_text('# defaults')
+        (Path(self.temp_dir) / 'spec.master').write_text('# spec')
+        
+        # Override PROJECT_ROOT for testing by patching the module directly
+        import config_service
+        self.original_root = config_service.PROJECT_ROOT
+        config_service.PROJECT_ROOT = Path(self.temp_dir)
+        # Also patch in file_utils
+        import file_utils
+        self.original_file_utils_root = file_utils.PROJECT_ROOT
+        file_utils.PROJECT_ROOT = Path(self.temp_dir)
+    
+    def teardown(self):
+        """Cleanup temporary directory"""
+        # Restore original
+        import config_service
+        config_service.PROJECT_ROOT = self.original_root
+        import file_utils
+        file_utils.PROJECT_ROOT = self.original_file_utils_root
+        
+        if self.temp_dir and os.path.exists(self.temp_dir):
+            shutil.rmtree(self.temp_dir)
+    
+    def assert_true(self, condition, msg):
+        """Assert condition is true"""
+        if condition:
+            self.passed += 1
+            print(f"  ✓ {msg}")
+        else:
+            self.failed += 1
+            print(f"  ✗ {msg}")
+    
+    def assert_false(self, condition, msg):
+        """Assert condition is false"""
+        self.assert_true(not condition, msg)
+    
+    def assert_equals(self, a, b, msg):
+        """Assert two values are equal"""
+        if a == b:
+            self.passed += 1
+            print(f"  ✓ {msg}")
+        else:
+            self.failed += 1
+            print(f"  ✗ {msg}: expected {b}, got {a}")
+    
+    def run_all_tests(self):
+        """Run all test methods"""
+        print("\n" + "="*60)
+        print("ConfigService Test Suite")
+        print("="*60)
+        
+        self.setup()
+        try:
+            self.test_path_validation()
+            self.test_file_type_validation()
+            self.test_hash_computation()
+            self.test_backup_rotation()
+            self.test_conflict_detection()
+            self.test_atomic_write()
+            self.test_csrf_validation()
+            self.test_content_length_validation()
+        finally:
+            self.teardown()
+        
+        print("\n" + "="*60)
+        print(f"Results: {self.passed} passed, {self.failed} failed")
+        print("="*60)
+        return self.failed == 0
+    
+    def test_path_validation(self):
+        """Test 7.4, 7.10, 7.11: Path validation and traversal prevention"""
+        print("\n📁 Testing Path Validation (Tasks 7.4, 7.10, 7.11)")
+        
+        # Valid paths - topologies
+        valid_paths = [
+            '.tilt-engine/topologies/test.star',
+            '.tilt-engine/topologies/tilt/discovery/registry.star',
+        ]
+        
+        for path in valid_paths:
+            result = ConfigService.validate_write_path(path)
+            self.assert_true(result is not None, f"Valid path accepted: {path}")
+        
+        # Valid paths - project root master configs (Task 7.11)
+        root_configs = [
+            'TILT_RESOURCE_DEFAULTS.star',
+            'spec.master',
+            '.tilt-engine/spec.master',
+        ]
+        
+        for path in root_configs:
+            result = ConfigService.validate_write_path(path)
+            self.assert_true(result is not None, f"Root config accepted: {path}")
+        
+        # Invalid paths - traversal attempts
+        invalid_paths = [
+            '../outside.star',
+            '.tilt-engine/../../etc/passwd',
+            '%2e%2e%2fsecret.star',
+            '/etc/passwd',
+            'random/file.star',
+            'README.md',
+        ]
+        
+        for path in invalid_paths:
+            result = ConfigService.validate_write_path(path)
+            self.assert_true(result is None, f"Invalid path rejected: {path}")
+    
+    def test_file_type_validation(self):
+        """Test 7.12: File extension validation"""
+        print("\n📄 Testing File Type Validation (Task 7.12)")
+        
+        # Valid file types
+        valid_files = [
+            'test.star',
+            'spec.master',
+            '.tilt-engine/spec.master',
+            'TILT_RESOURCE_DEFAULTS.star',
+        ]
+        
+        for path in valid_files:
+            is_valid, _ = ConfigService.validate_file_type(path)
+            self.assert_true(is_valid, f"Valid file type: {path}")
+        
+        # Invalid file types
+        invalid_files = [
+            'README.md',
+            'file.txt',
+            'script.py',
+            'config.json',
+        ]
+        
+        for path in invalid_files:
+            is_valid, _ = ConfigService.validate_file_type(path)
+            self.assert_false(is_valid, f"Invalid file type rejected: {path}")
+    
+    def test_hash_computation(self):
+        """Test 7.9: Hash computation for conflict detection"""
+        print("\n🔐 Testing Hash Computation (Task 7.9)")
+        
+        # Same content produces same hash
+        content1 = "Hello, World!"
+        hash1 = ConfigService.compute_content_hash(content1)
+        hash2 = ConfigService.compute_content_hash(content1)
+        self.assert_equals(hash1, hash2, "Same content produces same hash")
+        
+        # Different content produces different hash
+        content2 = "Hello, World"
+        hash3 = ConfigService.compute_content_hash(content2)
+        self.assert_true(hash1 != hash3, "Different content produces different hash")
+        
+        # Hash is SHA-256 (64 hex characters)
+        self.assert_equals(len(hash1), 64, "Hash is 64 hex chars (SHA-256)")
+    
+    def test_backup_rotation(self):
+        """Test 7.8: Backup creation and rotation"""
+        print("\n💾 Testing Backup Rotation (Task 7.8)")
+        
+        import time
+        
+        # Create test file
+        test_file = Path(self.temp_dir) / '.tilt-engine' / 'topologies' / 'backup_test.star'
+        test_file.write_text('version 1')
+        
+        # Create multiple backups with small delays to ensure different timestamps
+        for i in range(5):
+            time.sleep(0.01)  # Small delay to ensure different timestamps
+            test_file.write_text(f'version {i+2}')
+            backup_path, msg = ConfigService.create_backup_with_rotation(test_file, max_backups=3)
+            self.assert_true(backup_path is not None, f"Backup {i+1} created: {msg}")
+        
+        # Check only 3 backups exist
+        backup_dir = test_file.parent / '.backups'
+        if backup_dir.exists():
+            backups = list(backup_dir.glob('backup_test.star.*.backup'))
+            self.assert_true(len(backups) <= 3, f"Rotation keeps max 3 backups (found {len(backups)})")
+        else:
+            self.assert_true(False, "Backup directory should exist")
+    
+    def test_conflict_detection(self):
+        """Test 7.9: File content hash conflict detection"""
+        print("\n⚠️  Testing Conflict Detection (Task 7.9)")
+        
+        # Create test file
+        test_file = Path(self.temp_dir) / '.tilt-engine' / 'topologies' / 'conflict_test.star'
+        original_content = "Original content"
+        test_file.write_text(original_content)
+        
+        # Get original hash
+        original_hash = ConfigService.compute_content_hash(original_content)
+        
+        # No conflict when file unchanged
+        has_conflict, msg = ConfigService.check_conflict(test_file, original_hash)
+        self.assert_false(has_conflict, "No conflict when file unchanged")
+        
+        # Modify file
+        test_file.write_text("Modified content")
+        
+        # Conflict detected after modification
+        has_conflict, msg = ConfigService.check_conflict(test_file, original_hash)
+        self.assert_true(has_conflict, "Conflict detected after file modification")
+    
+    def test_atomic_write(self):
+        """Test 7.7, 7.20: Atomic write and failure recovery"""
+        print("\n📝 Testing Atomic Write (Tasks 7.7, 7.20)")
+        
+        # Use relative path that will pass validation
+        rel_path = '.tilt-engine/topologies/atomic_test.star'
+        abs_path = Path(self.temp_dir) / rel_path
+        
+        # Verify path validation works
+        validated = ConfigService.validate_write_path(rel_path)
+        self.assert_true(validated is not None, "Path validation for atomic write")
+        
+        # Test successful write (using relative path)
+        result = ConfigService.atomic_write(validated, "Test content", create_backup=False)
+        self.assert_true(result.success, f"Atomic write succeeds: {result.message}")
+        self.assert_true(abs_path.exists(), "File created")
+        self.assert_equals(abs_path.read_text(), "Test content", "Content written correctly")
+        
+        # Test write with backup
+        result = ConfigService.atomic_write(validated, "Updated content", create_backup=True)
+        self.assert_true(result.success, f"Atomic write with backup succeeds: {result.message}")
+        self.assert_true(result.backup_path is not None, "Backup created")
+        
+        # Test conflict detection during write
+        original_hash = ConfigService.compute_content_hash("Wrong hash")
+        result = ConfigService.atomic_write(
+            validated, 
+            "New content", 
+            original_hash=original_hash,
+            create_backup=False
+        )
+        self.assert_false(result.success, "Write fails with hash conflict")
+    
+    def test_csrf_validation(self):
+        """Test 7.13: CSRF protection"""
+        print("\n🛡️  Testing CSRF Protection (Task 7.13)")
+        
+        # Valid token with localhost origin
+        is_valid, _ = ConfigService.validate_csrf_token(
+            "valid_token_12345",
+            referer="http://localhost:9767/",
+            origin="http://localhost:9767"
+        )
+        self.assert_true(is_valid, "Valid CSRF token with localhost origin")
+        
+        # Invalid token (too short)
+        is_valid, _ = ConfigService.validate_csrf_token(
+            "short",
+            referer="http://localhost:9767/",
+            origin="http://localhost:9767"
+        )
+        self.assert_false(is_valid, "Short token rejected")
+        
+        # Valid token but wrong origin
+        is_valid, _ = ConfigService.validate_csrf_token(
+            "valid_token_12345",
+            referer="https://evil.com/",
+            origin="https://evil.com"
+        )
+        self.assert_false(is_valid, "Wrong origin rejected")
+    
+    def test_content_length_validation(self):
+        """Test content length limits"""
+        print("\n📏 Testing Content Length Validation")
+        
+        # Valid content length
+        is_valid, _ = ConfigService.validate_request_content_length("1024")
+        self.assert_true(is_valid, "Valid content length accepted")
+        
+        # Too large
+        is_valid, _ = ConfigService.validate_request_content_length(str(2 * 1024 * 1024))
+        self.assert_false(is_valid, "Oversized content rejected")
+        
+        # Missing
+        is_valid, _ = ConfigService.validate_request_content_length(None)
+        self.assert_false(is_valid, "Missing content length rejected")
+        
+        # Invalid format
+        is_valid, _ = ConfigService.validate_request_content_length("invalid")
+        self.assert_false(is_valid, "Invalid content length rejected")
+
+
+def run_tests():
+    """Run all tests and return exit code"""
+    tester = TestConfigService()
+    success = tester.run_all_tests()
+    return 0 if success else 1
+
+
+if __name__ == '__main__':
+    sys.exit(run_tests())

package/ext/ide-components/shared/tilt_integration.py

@@ -0,0 +1,160 @@
+#!/usr/bin/env python3
+# Copyright (c) 2026 Flisk Landscape contributors
+# SPDX-License-Identifier: MIT
+"""
+Tilt integration utilities for IDE components
+"""
+
+import subprocess
+import json
+
+from file_utils import PROJECT_ROOT
+
+
+class TiltIntegration:
+    """Utilities for calling Tilt commands from Python"""
+    
+    @staticmethod
+    def trigger_resource(resource_name: str) -> dict:
+        """
+        Trigger a Tilt resource (e.g., config-gen for a service)
+        
+        Returns: {'success': bool, 'output': str, 'error': str}
+        """
+        try:
+            result = subprocess.run(
+                ['tilt', 'trigger', resource_name],
+                cwd=PROJECT_ROOT,
+                capture_output=True,
+                text=True,
+                timeout=30
+            )
+            
+            return {
+                'success': result.returncode == 0,
+                'output': result.stdout,
+                'error': result.stderr if result.returncode != 0 else None
+            }
+        except subprocess.TimeoutExpired:
+            return {'success': False, 'output': '', 'error': 'Command timed out'}
+        except FileNotFoundError:
+            return {'success': False, 'output': '', 'error': 'tilt command not found. Is Tilt installed?'}
+        except Exception as e:
+            return {'success': False, 'output': '', 'error': str(e)}
+    
+    @staticmethod
+    def get_resources() -> list:
+        """
+        Get list of all Tilt resources
+        
+        Returns: List of resource names
+        """
+        try:
+            result = subprocess.run(
+                ['tilt', 'get', 'uiresources', '-o', 'json'],
+                cwd=PROJECT_ROOT,
+                capture_output=True,
+                text=True,
+                timeout=10
+            )
+            
+            if result.returncode != 0:
+                return []
+            
+            data = json.loads(result.stdout)
+            resources = []
+            
+            for item in data.get('items', []):
+                name = item.get('metadata', {}).get('name', '')
+                if name:
+                    resources.append(name)
+            
+            return resources
+        except Exception:
+            return []
+    
+    @staticmethod
+    def get_resource_status(resource_name: str) -> dict:
+        """
+        Get status of a specific Tilt resource
+        
+        Returns: {'exists': bool, 'status': str, 'error': str}
+        """
+        try:
+            result = subprocess.run(
+                ['tilt', 'get', 'uiresources', resource_name, '-o', 'json'],
+                cwd=PROJECT_ROOT,
+                capture_output=True,
+                text=True,
+                timeout=10
+            )
+            
+            if result.returncode != 0:
+                return {'exists': False, 'status': 'unknown', 'error': result.stderr}
+            
+            data = json.loads(result.stdout)
+            status = data.get('status', {}).get('runtimeStatus', 'unknown')
+            
+            return {'exists': True, 'status': status, 'error': None}
+        except Exception as e:
+            return {'exists': False, 'status': 'unknown', 'error': str(e)}
+    
+    @staticmethod
+    def regenerate_resource_configs(resource_name: str) -> dict:
+        """
+        Trigger config regeneration for a service
+        
+        Tries common config-gen resource naming patterns:
+        - <service>-config-gen
+        - <service>-yaml
+        
+        Returns: {'success': bool, 'message': str}
+        """
+        # Try different resource name patterns
+        patterns = [
+            f'{resource_name}-config-gen',
+            f'{resource_name}-yaml',
+            f'{resource_name}-config',
+        ]
+        
+        for pattern in patterns:
+            result = TiltIntegration.trigger_resource(pattern)
+            if result['success']:
+                return {
+                    'success': True,
+                    'message': f'Regenerated configs for {resource_name} via {pattern}'
+                }
+        
+        return {
+            'success': False,
+            'message': f'Could not find config-gen resource for {resource_name}. Tried: {", ".join(patterns)}'
+        }
+    
+    @staticmethod
+    def is_tilt_running() -> bool:
+        """Check if Tilt is currently running"""
+        try:
+            result = subprocess.run(
+                ['tilt', 'status'],
+                cwd=PROJECT_ROOT,
+                capture_output=True,
+                text=True,
+                timeout=5
+            )
+            return result.returncode == 0
+        except Exception:
+            return False
+
+
+if __name__ == '__main__':
+    # Test
+    print(f"Project root: {PROJECT_ROOT}")
+    print(f"Tilt running: {TiltIntegration.is_tilt_running()}")
+    
+    resources = TiltIntegration.get_resources()
+    print(f"Found {len(resources)} resources")
+    
+    # Show first 5
+    for name in resources[:5]:
+        status = TiltIntegration.get_resource_status(name)
+        print(f"  - {name}: {status['status']}")

package/ext/ui-enhancements/cron-status-server.sh

@@ -0,0 +1,51 @@
+#!/bin/bash
+# Copyright (c) 2026 Flisk Landscape contributors
+# SPDX-License-Identifier: MIT
+# ============================================================================
+# Cron Jobs Status HTTP Server
+# Serves cron job status as JSON for the UI extension
+# ============================================================================
+
+STATUS_FILE="/tmp/cron-jobs-status.json"
+PORT=10352
+
+echo "🌐 Cron Jobs Status Server starting on port ${PORT}..."
+
+# Simple HTTP server using Python
+python3 << 'PYEOF'
+import http.server
+import socketserver
+import json
+import os
+
+STATUS_FILE = "/tmp/cron-jobs-status.json"
+PORT = 10352
+
+class Handler(http.server.SimpleHTTPRequestHandler):
+    def do_GET(self):
+        if self.path == '/api/cron-jobs-status':
+            self.send_response(200)
+            self.send_header('Content-Type', 'application/json')
+            self.send_header('Access-Control-Allow-Origin', '*')
+            self.end_headers()
+
+            # Read status file or return default
+            if os.path.exists(STATUS_FILE):
+                with open(STATUS_FILE, 'r') as f:
+                    data = f.read()
+                self.wfile.write(data.encode())
+            else:
+                default = {"jobs": [], "updatedAt": None}
+                self.wfile.write(json.dumps(default).encode())
+        else:
+            self.send_response(404)
+            self.end_headers()
+
+    def log_message(self, format, *args):
+        # Suppress log messages
+        pass
+
+with socketserver.TCPServer(("", PORT), Handler) as httpd:
+    print(f"Cron Jobs Status Server running on port {PORT}")
+    httpd.serve_forever()
+PYEOF

package/ext/ui-enhancements/cron-status-tracker.sh

@@ -0,0 +1,148 @@
+#!/bin/bash
+# Copyright (c) 2026 Flisk Landscape contributors
+# SPDX-License-Identifier: MIT
+# ============================================================================
+# Cron Jobs Status Tracker
+# Tracks execution status of all cron jobs
+# ============================================================================
+
+STATUS_FILE="/tmp/cron-jobs-status.json"
+CONTROL_DIR="/tmp/cron-jobs-control"
+LOG_DIR="/tmp/cron-jobs-logs"
+
+# Ensure directories exist
+mkdir -p "$CONTROL_DIR" "$LOG_DIR"
+
+# Initialize status file
+init_status() {
+    cat > "$STATUS_FILE" << 'EOF'
+{
+  "jobs": [
+    {
+      "name": "cron-lint",
+      "status": "idle",
+      "lastRun": null,
+      "nextRun": null,
+      "history": []
+    },
+    {
+      "name": "cron-format",
+      "status": "idle",
+      "lastRun": null,
+      "nextRun": null,
+      "history": []
+    },
+    {
+      "name": "auto-prune-dangling",
+      "status": "running",
+      "lastRun": null,
+      "nextRun": null,
+      "history": []
+    },
+    {
+      "name": "auto-prune-migrator-images",
+      "status": "running",
+      "lastRun": null,
+      "nextRun": null,
+      "history": []
+    }
+  ],
+  "updatedAt": null
+}
+EOF
+}
+
+# Update job status
+update_job() {
+    local name=$1
+    local status=$2
+    local duration=$3
+    local timestamp=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+
+    # Read current status
+    local current=$(cat "$STATUS_FILE" 2>/dev/null || echo '{"jobs":[]}')
+
+    # Calculate next run (60 seconds from now for cron jobs)
+    local nextRun=$(date -u -v+60S +"%Y-%m-%dT%H:%M:%SZ" 2>/dev/null || date -u -d '+60 seconds' +"%Y-%m-%dT%H:%M:%SZ")
+
+    # Update using Python for reliable JSON manipulation
+    python3 << PYEOF
+import json
+import sys
+from datetime import datetime, timedelta
+
+data = json.loads('''$current''')
+job_name = '''$name'''
+status = '''$status'''
+timestamp = '''$timestamp'''
+duration = '''$duration'''
+next_run = '''$nextRun'''
+
+# Find and update job
+for job in data.get('jobs', []):
+    if job['name'] == job_name:
+        job['status'] = status
+        job['lastRun'] = timestamp
+        job['nextRun'] = next_run
+
+        # Add to history
+        if 'history' not in job:
+            job['history'] = []
+
+        job['history'].insert(0, {
+            'time': timestamp,
+            'status': status,
+            'duration': duration if duration else 'N/A'
+        })
+
+        # Keep only last 10 entries
+        job['history'] = job['history'][:10]
+        break
+
+data['updatedAt'] = timestamp
+print(json.dumps(data, indent=2))
+PYEOF
+}
+
+# Check if job should pause
+check_pause() {
+    local name=$1
+    if [[ -f "$CONTROL_DIR/$name.pause" ]]; then
+        return 0
+    fi
+    return 1
+}
+
+# Check if manual trigger requested
+check_trigger() {
+    local name=$1
+    if [[ -f "$CONTROL_DIR/$name.trigger" ]]; then
+        rm "$CONTROL_DIR/$name.trigger"
+        return 0
+    fi
+    return 1
+}
+
+# Main execution
+command=$1
+shift
+
+case $command in
+    init)
+        init_status
+        echo "Status file initialized at $STATUS_FILE"
+        ;;
+    update)
+        update_job "$1" "$2" "$3" > "${STATUS_FILE}.tmp" && mv "${STATUS_FILE}.tmp" "$STATUS_FILE"
+        ;;
+    pause-check)
+        check_pause "$1"
+        ;;
+    trigger-check)
+        check_trigger "$1"
+        ;;
+    *)
+        echo "Usage: $0 {init|update <name> <status> [duration]|pause-check <name>|trigger-check <name>}"
+        exit 1
+        ;;
+esac