pakstr 0.22.0 → 0.24.0

package/README.md

@@ -49,7 +49,7 @@ build:
 #   apiBase: https://api.example.com  # Optional packaged /api/* proxy target.
 ```
 
-`runtime.apiBase` must be an absolute HTTPS URL. It is public APK metadata, not a secret. When omitted, Pakstr generates an empty runtime config and keeps `/api/*` disabled; when set, `/api/x` forwards to `<apiBase>/api/x`.
+`runtime.apiBase` must be an absolute HTTPS URL. It is the immutable packaged/default proxy target and public APK metadata, not a secret. The effective target precedence is persistent runtime override, then packaged default, then disabled. A web app may call `window.PakstrBridge.setApiBaseUrl(url)` to validate and synchronously persist an HTTPS override, and `window.PakstrBridge.getApiBaseUrl()` to read the effective URL. Developer Tools uses the same setting. Reset removes the override and restores the packaged default; without a packaged default it disables `/api/*`. Changes affect the next proxy request without an app restart, LocalServer restart, or WebView reload.
 
 ### 3. Build, sign, and publish
 ```bash

package/android-template/app/src/main/java/com/pakstr/app/LocalServer.kt

@@ -80,6 +80,11 @@ internal fun localRequestUrl(
             if (query.isNullOrEmpty()) "" else "?$query"
 )
 
+internal fun proxyApiUrl(
+    apiBase: String,
+    uri: String
+): URL = URL(apiBase + uri)
+
 internal data class ProxyHttpResponse(
     val code: Int,
     val contentType: String?,
@@ -258,7 +263,8 @@ class LocalServer(
         )
         if (uri.startsWith("/api/")) {
 
-            if (!RuntimeConfig.apiEnabled(context)) {
+            val apiBase = RuntimeConfig.apiBase(context)
+            if (apiBase == null) {
 
                 AppDebugLogger.network(
 
@@ -283,7 +289,7 @@ class LocalServer(
                 )
             }
 
-            return proxyApi(session, uri)
+            return proxyApi(session, uri, apiBase)
 
         }
 
@@ -370,7 +376,7 @@ class LocalServer(
     }
 
     private fun proxyApi(
-        session: IHTTPSession?, uri: String
+        session: IHTTPSession?, uri: String, apiBase: String
     ): Response {
 
         if (AppDebugLogger.isNetworkLoggingEnabled(context)) {
@@ -386,29 +392,7 @@ class LocalServer(
 
         return try {
 
-            val config = RuntimeConfig.load(context)
-
-            val apiBase = config.optString("apiBase")
-
-            if (apiBase.isBlank()) {
-                AppDebugLogger.error(
-
-                    context,
-
-                    "API",
-
-                    "apiBase missing"
-
-                )
-                return newFixedLengthResponse(
-                    Response.Status.INTERNAL_ERROR,
-                    "application/json",
-                    """{"error":"apiBase missing"}"""
-                )
-            }
-
-            val finalUrl = apiBase.removeSuffix("/") + uri
-            val url = URL(finalUrl)
+            val url = proxyApiUrl(apiBase, uri)
             val method = session?.method?.name ?: "GET"
             val requestHeaders = session?.headers ?: emptyMap()
             val localRequestUrl = localRequestUrl(
@@ -438,7 +422,7 @@ class LocalServer(
                 if (AppDebugLogger.isNetworkLoggingEnabled(context)) {
                     AppDebugLogger.network(
                         context,
-                        "Response: ${response.code} $finalUrl"
+                        "Proxy response: ${response.code}"
                     )
                 }
                 return newFixedLengthResponse(
@@ -498,7 +482,7 @@ class LocalServer(
                 AppDebugLogger.network(
 
                     context,
-                    "Response: $code $finalUrl"
+                    "Proxy response: $code"
 
                 )
 

package/android-template/app/src/main/java/com/pakstr/app/PakstrBridge.kt

@@ -2,10 +2,22 @@ package com.pakstr.app
 
 import android.webkit.JavascriptInterface
 
-class PakstrBridge {
+class PakstrBridge(
+    private val runtimeApiBaseSettings: RuntimeApiBaseSettings
+) {
 
     @JavascriptInterface
     fun getNip55CallbackUrl(): String {
         return Nip55Callback.callbackPrefix
     }
+
+    @JavascriptInterface
+    fun setApiBaseUrl(url: String): Boolean {
+        return runtimeApiBaseSettings.setOverride(url)
+    }
+
+    @JavascriptInterface
+    fun getApiBaseUrl(): String? {
+        return runtimeApiBaseSettings.current().url
+    }
 }

package/android-template/app/src/main/java/com/pakstr/app/RuntimeApiBaseSettings.kt

@@ -0,0 +1,98 @@
+package com.pakstr.app
+
+import android.content.Context
+import android.content.SharedPreferences
+
+class RuntimeApiBaseSettings private constructor(
+    private val preferences: Preferences,
+    private val packagedValueProvider: () -> String?
+) {
+    enum class Source {
+        RUNTIME_OVERRIDE,
+        PACKAGED_DEFAULT,
+        DISABLED
+    }
+
+    data class Value(
+        val url: String?,
+        val source: Source
+    )
+
+    fun current(): Value = resolveEffectiveValue(
+        persistedOverride = preferences.getString(API_BASE_OVERRIDE_KEY),
+        packagedDefault = packagedValueProvider()
+    )
+
+    fun setOverride(value: String): Boolean {
+        val canonical = RuntimeApiBaseValidator.validateAndCanonicalize(value)
+            ?: return false
+        return preferences.putString(API_BASE_OVERRIDE_KEY, canonical)
+    }
+
+    fun reset(): Boolean = preferences.remove(API_BASE_OVERRIDE_KEY)
+
+    internal interface Preferences {
+        fun getString(key: String): String?
+        fun putString(key: String, value: String): Boolean
+        fun remove(key: String): Boolean
+    }
+
+    private class SharedPreferencesAdapter(
+        private val preferences: SharedPreferences
+    ) : Preferences {
+        override fun getString(key: String): String? = preferences.getString(key, null)
+
+        override fun putString(key: String, value: String): Boolean =
+            preferences.edit().putString(key, value).commit()
+
+        override fun remove(key: String): Boolean =
+            preferences.edit().remove(key).commit()
+    }
+
+    companion object {
+        internal const val PREFERENCES_FILE = "pakstr_runtime_api_base"
+        internal const val API_BASE_OVERRIDE_KEY = "api_base_override"
+
+        fun from(context: Context): RuntimeApiBaseSettings {
+            val applicationContext = context.applicationContext
+            val preferences = applicationContext.getSharedPreferences(
+                PREFERENCES_FILE,
+                Context.MODE_PRIVATE
+            )
+            return RuntimeApiBaseSettings(
+                SharedPreferencesAdapter(preferences)
+            ) {
+                RuntimeConfig.packagedApiBase(applicationContext)
+            }
+        }
+
+        internal fun resolveEffectiveValue(
+            persistedOverride: String?,
+            packagedDefault: String?
+        ): Value {
+            val override = RuntimeApiBaseValidator.validateAndCanonicalize(
+                persistedOverride
+            )
+            if (override != null) {
+                return Value(override, Source.RUNTIME_OVERRIDE)
+            }
+
+            val packaged = RuntimeApiBaseValidator.validateAndCanonicalize(
+                packagedDefault
+            )
+            return if (packaged != null) {
+                Value(packaged, Source.PACKAGED_DEFAULT)
+            } else {
+                Value(null, Source.DISABLED)
+            }
+        }
+
+        internal fun createForTesting(
+            preferences: Preferences,
+            packagedValueProvider: () -> String?
+        ): RuntimeApiBaseSettings = RuntimeApiBaseSettings(
+            preferences,
+            packagedValueProvider
+        )
+    }
+}

package/android-template/app/src/main/java/com/pakstr/app/RuntimeApiBaseValidator.kt

@@ -0,0 +1,30 @@
+package com.pakstr.app
+
+import java.net.URI
+
+object RuntimeApiBaseValidator {
+    const val MAX_LENGTH = 2048
+
+    fun validateAndCanonicalize(value: String?): String? {
+        if (
+            value == null ||
+            value.isEmpty() ||
+            value.length > MAX_LENGTH ||
+            value != value.trim()
+        ) {
+            return null
+        }
+
+        val uri = runCatching { URI(value) }.getOrNull() ?: return null
+        if (!uri.isAbsolute || !uri.scheme.equals("https", ignoreCase = true)) return null
+        if (uri.host.isNullOrBlank()) return null
+        if (uri.rawUserInfo != null || uri.rawQuery != null || uri.rawFragment != null) return null
+
+        val host = uri.host.lowercase().let {
+            if (it.contains(':') && !it.startsWith("[")) "[$it]" else it
+        }
+        val port = if (uri.port == -1) "" else ":${uri.port}"
+        val path = uri.rawPath.orEmpty().trimEnd('/')
+        return "https://$host$port$path"
+    }
+}

package/android-template/app/src/main/java/com/pakstr/app/RuntimeConfig.kt

@@ -58,19 +58,14 @@ object RuntimeConfig {
      */
     fun apiBase(
         context: Context
-    ): String? {
+    ): String? = RuntimeApiBaseSettings.from(context).current().url
 
-        val value = load(context).optString(
-                "apiBase", ""
-            )
-
-
-        debug("apiBase=$value")
-
-
-        return value.takeIf {
-            it.isNotBlank()
-        }
+    internal fun packagedApiBase(
+        context: Context
+    ): String? = load(context).optString(
+        "apiBase", ""
+    ).takeIf {
+        it.isNotBlank()
     }
 
     /**

package/android-template/app/src/main/java/com/pakstr/app/WebViewController.kt

@@ -339,7 +339,7 @@ class WebViewController(
 
         )
         webView.addJavascriptInterface(
-            PakstrBridge(),
+            PakstrBridge(RuntimeApiBaseSettings.from(context)),
             "PakstrBridge"
         )
 

package/android-template/app/src/main/java/com/pakstr/app/debug/DeveloperToolsActivity.kt

@@ -15,13 +15,18 @@ import android.widget.TextView
 import android.widget.Toast
 import androidx.activity.enableEdgeToEdge
 import androidx.appcompat.app.AppCompatActivity
+import androidx.core.view.ViewCompat
+import androidx.core.view.WindowInsetsCompat
+import androidx.core.view.updatePadding
 import com.google.android.material.appbar.MaterialToolbar
 import com.google.android.material.button.MaterialButton
 import com.google.android.material.dialog.MaterialAlertDialogBuilder
 import com.google.android.material.switchmaterial.SwitchMaterial
+import com.google.android.material.textfield.TextInputEditText
+import com.google.android.material.textfield.TextInputLayout
 import com.pakstr.app.BuildConfig
 import com.pakstr.app.R
-import com.pakstr.app.RuntimeConfig
+import com.pakstr.app.RuntimeApiBaseSettings
 
 class DeveloperToolsActivity : AppCompatActivity() {
 
@@ -30,8 +35,12 @@ class DeveloperToolsActivity : AppCompatActivity() {
     private lateinit var uptimeValue: TextView
     private lateinit var debugModeSwitch: SwitchMaterial
     private lateinit var apiSwitch: SwitchMaterial
+    private lateinit var apiBaseInputLayout: TextInputLayout
+    private lateinit var apiBaseInput: TextInputEditText
+    private lateinit var apiBaseSource: TextView
     private lateinit var debugWebViewStatus: TextView
     private lateinit var webViewStatus: TextView
+    private lateinit var runtimeApiBaseSettings: RuntimeApiBaseSettings
 
     private val uptimeUpdater = object : Runnable {
         override fun run() {
@@ -50,11 +59,14 @@ class DeveloperToolsActivity : AppCompatActivity() {
         }
 
         setContentView(R.layout.activity_developer_tools)
+        runtimeApiBaseSettings = RuntimeApiBaseSettings.from(this)
 
+        setupWindowInsets()
         setupToolbar()
         bindViews()
         populateRuntimeDetails()
         setupDebugControls()
+        setupApiBaseControls()
         setupLogActions()
         setupCrashTesting()
         setupWebViewActions()
@@ -71,6 +83,18 @@ class DeveloperToolsActivity : AppCompatActivity() {
         super.onStop()
     }
 
+    private fun setupWindowInsets() {
+        ViewCompat.setOnApplyWindowInsetsListener(
+            findViewById(R.id.developerToolsRoot)
+        ) { view, insets ->
+            val bars = insets.getInsets(
+                WindowInsetsCompat.Type.systemBars()
+            )
+            view.updatePadding(top = bars.top)
+            insets
+        }
+    }
+
     private fun setupToolbar() {
         findViewById<MaterialToolbar>(R.id.developerToolsToolbar).setNavigationOnClickListener {
             finish()
@@ -81,6 +105,9 @@ class DeveloperToolsActivity : AppCompatActivity() {
         uptimeValue = findViewById(R.id.runtimeUptimeValue)
         debugModeSwitch = findViewById(R.id.debugModeSwitch)
         apiSwitch = findViewById(R.id.apiEnabledSwitch)
+        apiBaseInputLayout = findViewById(R.id.apiBaseInputLayout)
+        apiBaseInput = findViewById(R.id.apiBaseInput)
+        apiBaseSource = findViewById(R.id.apiBaseSource)
         debugWebViewStatus = findViewById(R.id.debugWebViewStatus)
         webViewStatus = findViewById(R.id.webViewStatus)
     }
@@ -101,8 +128,6 @@ class DeveloperToolsActivity : AppCompatActivity() {
     }
 
     private fun setupDebugControls() {
-        apiSwitch.isChecked = RuntimeConfig.apiEnabled(this)
-
         debugModeSwitch.setOnCheckedChangeListener { _, isChecked ->
             if (isChecked) {
                 DeveloperToolsManager.enableDebug(this)
@@ -115,9 +140,50 @@ class DeveloperToolsActivity : AppCompatActivity() {
         }
     }
 
+    private fun setupApiBaseControls() {
+        findViewById<MaterialButton>(R.id.saveApiBaseButton).setOnClickListener {
+            val value = apiBaseInput.text?.toString().orEmpty()
+            if (runtimeApiBaseSettings.setOverride(value)) {
+                apiBaseInputLayout.error = null
+                refreshApiBase()
+                showMessage(R.string.developer_tools_api_base_saved)
+            } else {
+                apiBaseInputLayout.error = getString(
+                    R.string.developer_tools_api_base_invalid
+                )
+            }
+        }
+        findViewById<MaterialButton>(R.id.resetApiBaseButton).setOnClickListener {
+            if (runtimeApiBaseSettings.reset()) {
+                apiBaseInputLayout.error = null
+                refreshApiBase()
+                showMessage(R.string.developer_tools_api_base_reset)
+            } else {
+                showMessage(R.string.developer_tools_api_base_save_failed)
+            }
+        }
+        refreshApiBase()
+    }
+
+    private fun refreshApiBase() {
+        val current = runtimeApiBaseSettings.current()
+        apiSwitch.isChecked = current.url != null
+        apiBaseInput.setText(current.url.orEmpty())
+        apiBaseSource.setText(
+            when (current.source) {
+                RuntimeApiBaseSettings.Source.RUNTIME_OVERRIDE ->
+                    R.string.developer_tools_api_base_runtime_override
+                RuntimeApiBaseSettings.Source.PACKAGED_DEFAULT ->
+                    R.string.developer_tools_api_base_packaged_default
+                RuntimeApiBaseSettings.Source.DISABLED ->
+                    R.string.developer_tools_api_base_not_configured
+            }
+        )
+    }
+
     private fun refreshStatuses() {
         debugModeSwitch.isChecked = DeveloperToolsManager.isEnabled(this)
-        apiSwitch.isChecked = RuntimeConfig.apiEnabled(this)
+        refreshApiBase()
 
         val status = if (isWebViewDebugEnabled()) {
             R.string.developer_tools_enabled