catalyst-core 0.0.3-canary.9 → 0.1.0-beta.2

package/dist/native/androidProject/app/src/main/java/io/yourname/androidproject/SplashActivity.kt

@@ -0,0 +1,111 @@
+package io.yourname.androidproject
+
+import android.app.Activity
+import android.content.Intent
+import android.graphics.Color
+import android.os.Build
+import android.os.Bundle
+import android.os.Handler
+import android.os.Looper
+import android.util.TypedValue
+import androidx.appcompat.app.AppCompatActivity
+import androidx.core.content.ContextCompat
+import androidx.core.graphics.drawable.RoundedBitmapDrawableFactory
+import androidx.core.graphics.drawable.toBitmap
+import io.yourname.androidproject.databinding.ActivitySplashBinding
+import java.util.Properties
+
+class SplashActivity : AppCompatActivity() {
+
+    private lateinit var binding: ActivitySplashBinding
+    private lateinit var properties: Properties
+    private var isFinishing = false
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+
+        properties = Properties()
+        try {
+            assets.open("webview_config.properties").use { properties.load(it) }
+        } catch (e: Exception) {
+            startMainActivity()
+            return
+        }
+
+        if (!properties.getProperty("splashScreen.enabled", "false").toBoolean()) {
+            startMainActivity()
+            return
+        }
+
+        binding = ActivitySplashBinding.inflate(layoutInflater)
+        setContentView(binding.root)
+        
+        configureSplashScreen()
+        startSplashTimer()
+    }
+
+    private fun configureSplashScreen() {
+        val backgroundColor = properties.getProperty("splashScreen.backgroundColor", "#ffffff")
+        val imageWidth = properties.getProperty("splashScreen.imageWidth", "120").toIntOrNull() ?: 120
+        val imageHeight = properties.getProperty("splashScreen.imageHeight", "120").toIntOrNull() ?: 120
+        val cornerRadius = properties.getProperty("splashScreen.cornerRadius", "20").toFloatOrNull() ?: 20f
+
+        try {
+            binding.splashContainer.setBackgroundColor(Color.parseColor(backgroundColor))
+        } catch (e: Exception) {
+            binding.splashContainer.setBackgroundColor(Color.WHITE)
+        }
+
+        val widthPx = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, imageWidth.toFloat(), resources.displayMetrics).toInt()
+        val heightPx = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, imageHeight.toFloat(), resources.displayMetrics).toInt()
+
+        binding.splashImage.layoutParams.apply {
+            width = widthPx
+            height = heightPx
+        }
+
+        val drawable = ContextCompat.getDrawable(this, 
+            resources.getIdentifier("splashscreen", "drawable", packageName).takeIf { it != 0 } 
+                ?: R.mipmap.ic_launcher
+        ) ?: return
+
+        if (cornerRadius > 0) {
+            val radiusPx = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, cornerRadius, resources.displayMetrics)
+            val roundedDrawable = RoundedBitmapDrawableFactory.create(resources, drawable.toBitmap(widthPx, heightPx))
+            roundedDrawable.cornerRadius = radiusPx
+            binding.splashImage.setImageDrawable(roundedDrawable)
+        } else {
+            binding.splashImage.setImageDrawable(drawable)
+        }
+    }
+
+    private fun startSplashTimer() {
+        val duration = properties.getProperty("splashScreen.duration")?.toLongOrNull() ?: 1000
+        Handler(Looper.getMainLooper()).postDelayed({ dismissSplash() }, duration)
+    }
+
+    private fun dismissSplash() {
+        if (isFinishing) return
+        isFinishing = true
+        startActivity(Intent(this, MainActivity::class.java))
+        finish()
+
+        // Use modern API for Android 14+ (API 34+)
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+            overrideActivityTransition(
+                Activity.OVERRIDE_TRANSITION_CLOSE,
+                android.R.anim.fade_in,
+                android.R.anim.fade_out
+            )
+        } else {
+            // Fallback to deprecated API for Android 13 and below
+            @Suppress("DEPRECATION")
+            overridePendingTransition(android.R.anim.fade_in, android.R.anim.fade_out)
+        }
+    }
+
+    private fun startMainActivity() {
+        startActivity(Intent(this, MainActivity::class.java))
+        finish()
+    }
+}

package/dist/native/androidProject/app/src/main/java/io/yourname/androidproject/URLWhitelistManager.kt

@@ -0,0 +1,231 @@
+package io.yourname.androidproject
+
+import android.util.Log
+
+/**
+ * Manager for URL whitelisting and access control
+ * Provides centralized URL validation with pattern matching support
+ *
+ * Pattern matching rules:
+ * - *text* or text (no wildcard) -> checks if URL contains "text"
+ * - text* -> checks if URL starts with "text"
+ * - *text -> checks if URL ends with "text"
+ *
+ * URL processing:
+ * - Query parameters and hash fragments are stripped before matching
+ * - Matching is case-insensitive
+ * - Ports are kept as-is (user must include port in pattern if URL has explicit port)
+ */
+object URLWhitelistManager {
+
+    private const val TAG = "URLWhitelistManager"
+
+    /**
+     * Data class to hold categorized URL patterns for efficient matching
+     */
+    private data class CategorizedPatterns(
+        val contains: List<String>,
+        val prefix: List<String>,
+        val suffix: List<String>
+    )
+
+    @Volatile
+    private var accessControlEnabled: Boolean = false
+
+    @Volatile
+    private var patterns: CategorizedPatterns? = null
+
+    /**
+     * Initialize the whitelist manager with configuration
+     * Should be called once during app initialization
+     */
+    @Synchronized
+    fun initialize(enabled: Boolean, allowedUrls: List<String>) {
+        this.accessControlEnabled = enabled
+        this.patterns = categorizePatterns(allowedUrls)
+
+        try {
+            if (BuildConfig.DEBUG) {
+                Log.d(TAG, "URLWhitelistManager initialized")
+                Log.d(TAG, "Access Control Enabled: $enabled")
+                Log.d(TAG, "Allowed URLs: $allowedUrls")
+                patterns?.let {
+                    Log.d(TAG, "Categorized - Contains: ${it.contains}")
+                    Log.d(TAG, "Categorized - Prefix: ${it.prefix}")
+                    Log.d(TAG, "Categorized - Suffix: ${it.suffix}")
+                }
+            }
+        } catch (e: RuntimeException) {
+            // Log not available in unit tests - silently ignore
+        }
+    }
+
+    /**
+     * Check if access control is enabled
+     */
+    fun isAccessControlEnabled(): Boolean {
+        return accessControlEnabled
+    }
+
+    /**
+     * Check if a URL is allowed according to the whitelist patterns
+     * If access control is disabled, all URLs are allowed
+     */
+    fun isUrlAllowed(url: String): Boolean {
+        // If access control is disabled, allow everything
+        if (!accessControlEnabled) {
+            return true
+        }
+
+        // Always allow framework server URLs (localhost with /framework- pattern)
+        // These are internal infrastructure URLs used for large file handling
+        val frameworkUrlPattern = Regex("^https?://(?:localhost|127\\.0\\.0\\.1)(?::\\d+)?/framework-[a-zA-Z0-9_-]+", RegexOption.IGNORE_CASE)
+        if (frameworkUrlPattern.containsMatchIn(url)) {
+            return true
+        }
+
+        val patterns = this.patterns ?: return false
+
+        // If all pattern lists are empty, block everything
+        if (patterns.contains.isEmpty() && patterns.prefix.isEmpty() && patterns.suffix.isEmpty()) {
+            return false
+        }
+
+        val cleanUrl = cleanUrl(url)
+
+        // Check contains patterns
+        if (patterns.contains.any { cleanUrl.contains(it) }) {
+            try {
+                if (BuildConfig.DEBUG) {
+                    Log.d(TAG, "✅ URL allowed (contains match): $url")
+                }
+            } catch (e: RuntimeException) { /* Ignore in tests */ }
+            return true
+        }
+
+        // Check prefix patterns
+        if (patterns.prefix.any { cleanUrl.startsWith(it) }) {
+            try {
+                if (BuildConfig.DEBUG) {
+                    Log.d(TAG, "✅ URL allowed (prefix match): $url")
+                }
+            } catch (e: RuntimeException) { /* Ignore in tests */ }
+            return true
+        }
+
+        // Check suffix patterns
+        if (patterns.suffix.any { cleanUrl.endsWith(it) }) {
+            try {
+                if (BuildConfig.DEBUG) {
+                    Log.d(TAG, "✅ URL allowed (suffix match): $url")
+                }
+            } catch (e: RuntimeException) { /* Ignore in tests */ }
+            return true
+        }
+
+        try {
+            if (BuildConfig.DEBUG) {
+                Log.w(TAG, "🚫 URL blocked by access control: $url")
+                Log.w(TAG, "🚫 Clean URL: $cleanUrl")
+            }
+        } catch (e: RuntimeException) { /* Ignore in tests */ }
+
+        return false
+    }
+
+    /**
+     * Check if a URL is from an external domain (not in whitelist)
+     * If access control is disabled, nothing is considered external
+     */
+    fun isExternalDomain(url: String): Boolean {
+        // If access control is disabled, nothing is external
+        if (!accessControlEnabled) {
+            return false
+        }
+
+        // Simply the inverse of isUrlAllowed
+        return !isUrlAllowed(url)
+    }
+
+    /**
+     * Clean URL by removing query parameters and hash, then lowercase for case-insensitive matching
+     * Also decodes URL-encoded characters to prevent bypass attempts
+     */
+    private fun cleanUrl(url: String): String {
+        // Decode URL-encoded characters first to prevent bypass (e.g., %3F for ?, %23 for #)
+        val decoded = try {
+            java.net.URLDecoder.decode(url, "UTF-8")
+        } catch (e: Exception) {
+            // If decode fails, use original URL
+            url
+        }
+
+        var cleanUrl = decoded
+
+        // Remove hash fragment (# and everything after)
+        val hashIndex = cleanUrl.indexOf('#')
+        if (hashIndex != -1) {
+            cleanUrl = cleanUrl.substring(0, hashIndex)
+        }
+
+        // Remove query parameters (? and everything after)
+        val queryIndex = cleanUrl.indexOf('?')
+        if (queryIndex != -1) {
+            cleanUrl = cleanUrl.substring(0, queryIndex)
+        }
+
+        return cleanUrl.lowercase()
+    }
+
+    /**
+     * Categorize patterns into contains, prefix, and suffix for efficient matching
+     */
+    private fun categorizePatterns(allowedUrls: List<String>): CategorizedPatterns {
+        val contains = mutableListOf<String>()
+        val prefix = mutableListOf<String>()
+        val suffix = mutableListOf<String>()
+
+        allowedUrls.forEach { pattern ->
+            if (pattern.isEmpty()) return@forEach
+
+            val startsWithWildcard = pattern.startsWith('*')
+            val endsWithWildcard = pattern.endsWith('*')
+
+            when {
+                startsWithWildcard && endsWithWildcard -> {
+                    // *text* -> contains check
+                    if (pattern.length <= 2) return@forEach // Pattern is just * or ** - ignore
+                    val extracted = pattern.substring(1, pattern.length - 1).lowercase()
+                    if (extracted.isNotEmpty()) {
+                        contains.add(extracted)
+                    }
+                }
+                endsWithWildcard -> {
+                    // text* -> prefix check
+                    if (pattern.length <= 1) return@forEach // Pattern is just * - ignore
+                    val extracted = pattern.substring(0, pattern.length - 1).lowercase()
+                    if (extracted.isNotEmpty()) {
+                        prefix.add(extracted)
+                    }
+                }
+                startsWithWildcard -> {
+                    // *text -> suffix check
+                    if (pattern.length <= 1) return@forEach // Pattern is just * - ignore
+                    val extracted = pattern.substring(1).lowercase()
+                    if (extracted.isNotEmpty()) {
+                        suffix.add(extracted)
+                    }
+                }
+                else -> {
+                    // No wildcard -> treat as contains check
+                    val extracted = pattern.lowercase()
+                    if (extracted.isNotEmpty()) {
+                        contains.add(extracted)
+                    }
+                }
+            }
+        }
+
+        return CategorizedPatterns(contains, prefix, suffix)
+    }
+}

package/dist/native/androidProject/app/src/main/java/io/yourname/androidproject/Utils.kt

@@ -2,63 +2,57 @@ package io.yourname.androidproject
 
 import android.net.Uri
 
-fun isUrlAllowed(url: String, allowedUrls: List<String>): Boolean {
-    if (allowedUrls.isEmpty()) return false
-    
-    val parsedUrl = Uri.parse(url) ?: return false
-    val urlHost = "${parsedUrl.scheme}://${parsedUrl.host}${if (parsedUrl.port != -1) ":${parsedUrl.port}" else ""}"
-    
-    return allowedUrls.any { pattern ->
-        when {
-            pattern.contains("*") -> {
-                val regex = pattern
-                    .replace(".", "\\.")
-                    .replace("*", ".*")
-                    .toRegex(RegexOption.IGNORE_CASE)
-                regex.matches(url) || regex.matches(urlHost)
-            }
-            else -> {
-                val patternUri = Uri.parse(pattern)
-                val patternHost = "${patternUri.scheme}://${patternUri.host}${if (patternUri.port != -1) ":${patternUri.port}" else ""}"
-                
-                // Exact match or pattern without port matches URL with any port
-                urlHost.equals(patternHost, ignoreCase = true) || 
-                (patternUri.port == -1 && urlHost.startsWith("${patternUri.scheme}://${patternUri.host}", ignoreCase = true))
-            }
-        }
-    }
-}
+/**
+ * Checks if a URL matches any of the cache patterns
+ * Handles query parameters, hashes, and version strings
+ *
+ * Examples:
+ * - Pattern "*.css" matches:
+ *   - "http://example.com/app.css"
+ *   - "http://example.com/app.d4e5dea6.css"
+ *   - "http://example.com/app.css?v=123"
+ *   - "http://example.com/path/to/style.css#section"
+ *
+ * - Pattern "*.js" matches:
+ *   - "http://example.com/bundle.js"
+ *   - "http://example.com/bundle.abc123.js"
+ *   - "http://example.com/bundle.js?t=456"
+ */
+fun matchesCachePattern(url: String, cachePatterns: List<String>): Boolean {
+    if (cachePatterns.isEmpty()) return false
+
+    try {
+        val parsedUrl = Uri.parse(url) ?: return false
+        // Get the path without query params or hash
+        val path = parsedUrl.path ?: return false
+
+        // Extract filename from path
+        val filename = path.substringAfterLast('/')
+        if (filename.isEmpty()) return false
+
+        return cachePatterns.any { pattern ->
+            when {
+                pattern.contains("*") -> {
+                    // Convert wildcard pattern to regex
+                    // *.css becomes .*\.css$
+                    val regexPattern = pattern
+                        .replace(".", "\\.")  // Escape dots
+                        .replace("*", ".*")   // Convert * to .*
+                        .let { "^$it$" }      // Anchor at start and end
+
+                    val regex = regexPattern.toRegex(RegexOption.IGNORE_CASE)
 
-fun isExternalDomain(url: String, allowedUrls: List<String>): Boolean {
-    if (allowedUrls.isEmpty()) return true
-    
-    val parsedUrl = Uri.parse(url)
-    val urlHost = parsedUrl.host ?: return true
-    val urlScheme = parsedUrl.scheme ?: return true
-    val urlPort = parsedUrl.port
-    
-    return !allowedUrls.any { pattern ->
-        if (pattern.startsWith("*.")) {
-            val domain = pattern.substring(2)
-            urlHost.equals(domain, ignoreCase = true) || urlHost.endsWith(".$domain", ignoreCase = true)
-        } else {
-            val patternUri = Uri.parse(pattern)
-            val patternHost = patternUri?.host ?: return@any false
-            val patternScheme = patternUri?.scheme ?: return@any false
-            val patternPort = patternUri?.port ?: -1
-            
-            val schemeMatches = urlScheme.equals(patternScheme, ignoreCase = true)
-            val hostMatches = if (patternHost.startsWith("*.")) {
-                val domain = patternHost.substring(2)
-                urlHost.equals(domain, ignoreCase = true) || urlHost.endsWith(".$domain", ignoreCase = true)
-            } else {
-                urlHost.equals(patternHost, ignoreCase = true)
+                    // Try matching against filename
+                    regex.matches(filename)
+                }
+                else -> {
+                    // Exact match against filename
+                    filename.equals(pattern, ignoreCase = true)
+                }
             }
-            val portMatches = patternPort == -1 || urlPort == patternPort || 
-                (urlPort == -1 && ((patternPort == 443 && patternScheme.equals("https", ignoreCase = true)) || 
-                                  (patternPort == 80 && patternScheme.equals("http", ignoreCase = true))))
-            
-            schemeMatches && hostMatches && portMatches
         }
+    } catch (e: Exception) {
+        // If parsing fails, return false
+        return false
     }
 }

package/dist/native/androidProject/app/src/main/java/io/yourname/androidproject/WebCacheManager.kt

@@ -12,27 +12,40 @@ import java.net.URL
 import java.security.MessageDigest
 import java.util.concurrent.TimeUnit
 
-class WebCacheManager(private val context: Context) {
+class WebCacheManager(private val context: Context, private val properties: java.util.Properties? = null) {
     private val TAG = "WebCacheManager"
     private val cacheDir = File(context.cacheDir, "webview_cache")
     private val scope = CoroutineScope(Dispatchers.IO + SupervisorJob())
     private val BUFFER_SIZE = 32 * 1024 
 
-    // Cache timing configurations
-    private val maxAge = TimeUnit.HOURS.toMillis(24) // Time until content becomes stale
-    private val staleWhileRevalidate = TimeUnit.HOURS.toMillis(1) // Additional time content can be served while revalidating
+    // Cache timing configurations - now configurable via properties
+    private val maxAge = properties?.getProperty("cache.maxAge", "24")?.toLongOrNull()?.let { TimeUnit.HOURS.toMillis(it) } 
+        ?: TimeUnit.HOURS.toMillis(24) // Default 24 hours
+    private val staleWhileRevalidate = properties?.getProperty("cache.staleWhileRevalidate", "1")?.toLongOrNull()?.let { TimeUnit.HOURS.toMillis(it) } 
+        ?: TimeUnit.HOURS.toMillis(1) // Default 1 hour
+    private val maxCacheSize = properties?.getProperty("cache.maxSize", "100")?.toLongOrNull()?.let { it * 1024 * 1024 } 
+        ?: (100 * 1024 * 1024) // Default 100MB
+    private val memoryFraction = properties?.getProperty("cache.memoryFraction", "8")?.toIntOrNull() ?: 8 // Default 1/8 of memory
 
     // Track ongoing revalidations to prevent duplicate requests
     private val ongoingRevalidations = mutableSetOf<String>()
 
-    // Memory cache
+    // Memory cache - now configurable
     private val memoryCache: LruCache<String, CacheEntry> = LruCache<String, CacheEntry>(
-        (Runtime.getRuntime().maxMemory() / 1024 / 8).toInt()
+        (Runtime.getRuntime().maxMemory() / 1024 / memoryFraction).toInt()
     )
 
     init {
         try {
             cacheDir.mkdirs()
+            if (BuildConfig.DEBUG) {
+                Log.d(TAG, "📦 Cache configuration:")
+                Log.d(TAG, "  - Max age: ${maxAge / (1000 * 60 * 60)} hours")
+                Log.d(TAG, "  - Stale while revalidate: ${staleWhileRevalidate / (1000 * 60 * 60)} hours")
+                Log.d(TAG, "  - Max cache size: ${maxCacheSize / (1024 * 1024)} MB")
+                Log.d(TAG, "  - Memory cache size: ${memoryCache.maxSize() / 1024} KB")
+                Log.d(TAG, "  - Cache directory: ${cacheDir.absolutePath}")
+            }
         } catch (e: Exception) {
             Log.e(TAG, "Failed to create cache directory: ${e.message}")
         }
@@ -45,6 +58,54 @@ class WebCacheManager(private val context: Context) {
         val lastModified: String? = null
     )
 
+    /**
+     * Synchronous cache check - only returns cached content if immediately available
+     * Does not perform network requests or background revalidation
+     * Used by ServiceWorker to avoid blocking
+     */
+    fun getCachedResponseSync(url: String, headers: Map<String, String>): WebResourceResponse? {
+        return try {
+            val cacheKey = generateCacheKey(url)
+            val currentTime = System.currentTimeMillis()
+
+            // Check memory cache first
+            val memoryCacheEntry = memoryCache.get(cacheKey)
+            if (memoryCacheEntry != null) {
+                val age = currentTime - memoryCacheEntry.timestamp
+                // Only return if fresh or within stale-while-revalidate window
+                if (age <= maxAge + staleWhileRevalidate) {
+                    if (BuildConfig.DEBUG) {
+                        Log.d(TAG, "✅ Serving from memory cache (sync): $url")
+                    }
+                    return memoryCacheEntry.response
+                }
+            }
+
+            // Check disk cache synchronously
+            val cacheFile = File(cacheDir, cacheKey)
+            if (cacheFile.exists()) {
+                val fileAge = currentTime - cacheFile.lastModified()
+                if (fileAge <= maxAge + staleWhileRevalidate) {
+                    val metadata = loadMetadata(cacheKey)
+                    val response = createResponseFromCache(cacheFile, metadata)
+                    if (BuildConfig.DEBUG) {
+                        Log.d(TAG, "✅ Serving from disk cache (sync): $url")
+                    }
+                    return response
+                }
+            }
+
+            // No valid cache available
+            if (BuildConfig.DEBUG) {
+                Log.d(TAG, "❌ No valid cache available (sync): $url")
+            }
+            null
+        } catch (e: Exception) {
+            Log.e(TAG, "Error in getCachedResponseSync for URL: $url: ${e.message}")
+            null
+        }
+    }
+
     suspend fun getCachedResponse(url: String, headers: Map<String, String>): WebResourceResponse? =
         withContext(Dispatchers.IO) {
             try {
@@ -117,11 +178,23 @@ class WebCacheManager(private val context: Context) {
             }
         }
 
+    fun clearAll() {
+        try {
+            memoryCache.evictAll()
+            cacheDir.listFiles()?.forEach { it.delete() }
+            if (BuildConfig.DEBUG) {
+                Log.d(TAG, "clearAll: memory cache and disk cache wiped")
+            }
+        } catch (e: Exception) {
+            Log.e(TAG, "clearAll failed: ${e.message}")
+        }
+    }
+
     suspend fun cleanup() {
         withContext(Dispatchers.IO) {
             try {
                 val currentTime = System.currentTimeMillis()
-                val maxCacheSize = 100 * 1024 * 1024 // 100MB max cache size
+                // Use configurable max cache size
                 var totalSize = 0L
 
                 // Get all cache files sorted by last modified time (oldest first)
@@ -274,7 +347,7 @@ class WebCacheManager(private val context: Context) {
                     response = WebResourceResponse(
                         mimeType,
                         encoding,
-                        ByteArrayInputStream(responseBytes.clone())
+                        ByteArrayInputStream(responseBytes.copyOf())
                     ),
                     eTag = eTag,
                     lastModified = lastModified