pakstr 0.3.1 → 0.3.3

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

@@ -1,13 +1,15 @@
 package com.pakstr.app
 
 import android.content.Context
+import android.util.Log
+
 import android.webkit.MimeTypeMap
+
 import fi.iki.elonen.NanoHTTPD
 import java.io.IOException
-import java.util.Locale
-
 import java.net.HttpURLConnection
 import java.net.URL
+import java.util.Locale
 
 class LocalServer(
 
@@ -17,158 +19,228 @@ class LocalServer(
 
 ) : NanoHTTPD(port) {
 
+    private val TAG = "LocalServer"
+
     override fun serve(session: IHTTPSession?): Response {
-        // Fallback to root if URI is null
-        val uri =
 
-            (session?.uri ?: "/")
+        val uri = (session?.uri ?: "/").replace("..", "")
 
-                .replace("..", "")
 
         if (uri.startsWith("/api/")) {
 
-            return proxyApi(
+            if (!RuntimeConfig.apiEnabled(context)) {
 
-                session,
+                return newFixedLengthResponse(
 
-                uri
+                    Response.Status.NOT_FOUND,
 
-            )
+                    "application/json",
+
+                    """
+
+            {
+              "error":"api_disabled"
+            }
+            """.trimIndent()
+                )
+            }
+
+            return proxyApi(session, uri)
 
         }
 
-        // Map the root URL to index.html, otherwise target the requested file in the assets folder
         val filePath = when {
 
             uri == "/" -> "www/index.html"
 
-            uri.contains(".") -> "www$uri" // css, js, images
+            uri.contains(".") -> "www$uri"
 
-            else -> "www/index.html" // SPA ROUTES FALLBACK
+            else -> "www/index.html"
 
         }
 
+
         return try {
-            // Open the file directly from the app's assets
+
+            Log.d(
+                TAG, "Serving asset: $filePath"
+            )
+
             val inputStream = context.assets.open(filePath)
 
-            // Stream the file chunk-by-chunk to optimize memory usage
-            newChunkedResponse(Response.Status.OK, getMimeType(filePath), inputStream)
+            newChunkedResponse(
+                Response.Status.OK, getMimeType(filePath), inputStream
+            )
+
         } catch (e: IOException) {
-            // Return clean 404 response if the file does not exist or cannot be read
-            newFixedLengthResponse(Response.Status.NOT_FOUND, "text/plain", "404 Not Found")
+
+            Log.e(
+                TAG, "Failed loading asset: $filePath", e
+            )
+
+            newFixedLengthResponse(
+                Response.Status.NOT_FOUND, "text/plain", "404 Not Found"
+            )
         }
     }
 
-    /**
-     * Automatically detects the correct MIME type based on the file extension.
-     */
     private fun getMimeType(
         file: String
     ): String {
 
-        val extension =
-            MimeTypeMap
-                .getFileExtensionFromUrl(file)
-                ?.lowercase(Locale.ROOT)
-                ?: ""
+        val extension = MimeTypeMap.getFileExtensionFromUrl(file)
+            ?.lowercase(Locale.ROOT) ?: ""
+
 
         return when (extension) {
-            "js" ->
-                "application/javascript"
 
-            "json" ->
-                "application/json"
+            "js" -> "application/javascript"
 
-            "css" ->
-                "text/css"
+            "json" -> "application/json"
 
-            "html" ->
-                "text/html"
+            "css" -> "text/css"
 
-            "svg" ->
-                "image/svg+xml"
+            "html" -> "text/html"
 
-            else ->
-                MimeTypeMap
-                    .getSingleton()
-                    .getMimeTypeFromExtension(extension)
-                    ?: "application/octet-stream"
+            "svg" -> "image/svg+xml"
+
+            else -> MimeTypeMap.getSingleton()
+                .getMimeTypeFromExtension(extension) ?: "application/octet-stream"
         }
     }
 
+    override fun start() {
+
+        super.start()
+
+        Log.d(
+            TAG, "🚀 LocalServer started on port $listeningPort"
+        )
+    }
+
     private fun proxyApi(
-        session: IHTTPSession?,
-        uri: String
+        session: IHTTPSession?, uri: String
     ): Response {
 
-        val apiBase =
-
-            RuntimeConfig.load(context)
+        return try {
 
-                .optString("apiBase", null)
+            val config = RuntimeConfig.load(context)
 
-                ?: return newFixedLengthResponse(
+            val apiBase = config.optString("apiBase")
 
+            if (apiBase.isBlank()) {
+                return newFixedLengthResponse(
                     Response.Status.INTERNAL_ERROR,
-
                     "application/json",
-
                     """{"error":"apiBase missing"}"""
-
                 )
+            }
 
+            val finalUrl = apiBase.removeSuffix("/") + uri
 
-        return try {
+            val connection = URL(finalUrl).openConnection() as HttpURLConnection
+            connection.doInput = true
+            connection.instanceFollowRedirects = false
+
+            val method = session?.method?.name ?: "GET"
+
+            connection.requestMethod = method
+
+            connection.connectTimeout = 15000
+            connection.readTimeout = 30000
 
-            val url =
-                URL(
-                    apiBase.removeSuffix("/") + uri
+            /*
+             * Forward headers
+             */
+
+            session?.headers?.forEach { (key, value) ->
+
+                val skip = setOf(
+                    "host", "content-length", "connection", "accept-encoding"
                 )
 
 
-            val connection =
-                url.openConnection() as HttpURLConnection
+                if (!skip.contains(key.lowercase())) {
 
+                    connection.setRequestProperty(
+                        key, value
+                    )
+                }
+            }
+            session?.headers?.get("authorization")
+                ?.let { auth ->
+                    connection.setRequestProperty(
+                        "Authorization",
+                        auth
+                    )
+                }
 
-            connection.requestMethod =
-                session?.method?.name ?: "GET"
 
+            if (method == "POST" || method == "PUT" || method == "PATCH") {
 
-            connection.connectTimeout = 10000
-            connection.readTimeout = 10000
+                val files = HashMap<String, String>()
 
+                session?.parseBody(files)
 
-            val code =
-                connection.responseCode
+                val body = files["postData"] ?: ""
 
+                val bytes = body.toByteArray(Charsets.UTF_8)
 
-            val stream =
-                if (code >= 400)
-                    connection.errorStream
-                else
-                    connection.inputStream
+                connection.doOutput = true
+                session?.headers?.get("content-type")?.let {
+                    connection.setRequestProperty(
+                        "Content-Type",
+                        it
+                    )
+                }
 
+                connection.outputStream.use { output ->
 
-            newChunkedResponse(
-                Response.Status.lookup(code)
-                    ?: Response.Status.OK,
-                connection.contentType ?: "application/json",
-                stream
-            )
+                    output.write(bytes)
+                    output.flush()
+                }
+            }
+
+            val code = connection.responseCode
+
+            val stream = if (code >= 400) connection.errorStream
+            else connection.inputStream
+
+            val body = stream?.bufferedReader()
+                ?.use {
+                    it.readText()
+                } ?: ""
 
+            val responseContentType =
+                connection.contentType ?: "application/json"
+
+
+            connection.disconnect()
+
+
+            return newFixedLengthResponse(
+
+                Response.Status.lookup(code) ?: Response.Status.OK,
+
+                responseContentType,
+
+                body
+
+            )
 
         } catch (e: Exception) {
+            Log.e(
+                TAG,
+                "Proxy failed: ${e.javaClass.simpleName}"
+            )
+            return newFixedLengthResponse(
 
-            newFixedLengthResponse(
                 Response.Status.INTERNAL_ERROR,
+
                 "application/json",
-                """
-            {
-              "error":"proxy_failed",
-              "message":"${e.message}"
-            }
-            """.trimIndent()
+
+                """{"error":"proxy_failed"}""".trimIndent()
+
             )
         }
     }

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

@@ -18,17 +18,14 @@ import androidx.core.splashscreen.SplashScreen.Companion.installSplashScreen
 import androidx.core.view.ViewCompat
 import androidx.core.view.WindowInsetsCompat
 import androidx.core.view.updatePadding
-import androidx.lifecycle.lifecycleScope
+
 import com.pakstr.app.permissions.PermissionManager
 import com.pakstr.app.permissions.interfaces.PermissionHandler
-import com.pakstr.app.crypto.CryptoInitializer
-import com.pakstr.app.debug.AppDebugLogger
 
 import com.pakstr.app.signer.SignerManager
 import com.pakstr.app.signer.SignerType
 import com.pakstr.app.utils.AppPreferences
 import com.pakstr.app.utils.SignerPickerBottomSheet
-import kotlinx.coroutines.launch
 
 class MainActivity : AppCompatActivity(), PermissionHandler {
 
@@ -41,6 +38,9 @@ class MainActivity : AppCompatActivity(), PermissionHandler {
     private lateinit var amberLauncher:
             ActivityResultLauncher<Intent>
 
+
+    private val TAG = "ShellRuntime"
+
     override fun onCreate(
         savedInstanceState: Bundle?
     ) {
@@ -93,9 +93,11 @@ class MainActivity : AppCompatActivity(), PermissionHandler {
             insets
         }
 
+
         setupRuntime()
         setupBackNavigation()
         showLoader(true)
+
         runtime.start()
 
     }
@@ -143,11 +145,14 @@ class MainActivity : AppCompatActivity(), PermissionHandler {
             findViewById(R.id.mainContainer)
         webView =
             findViewById(R.id.webView)
+
         loader =
             findViewById(R.id.loader)
 
         permissionManager =
             PermissionManager(this)
+
+        WebView.setWebContentsDebuggingEnabled(true)
     }
 
     private fun handleSignerSetup() {

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

@@ -1,25 +1,30 @@
 package com.pakstr.app
 
 import android.content.Context
+import android.util.Log
 import org.json.JSONObject
 
 object RuntimeConfig {
 
+    private const val TAG = "RuntimeConfig"
+
     private var config: JSONObject? = null
 
 
     fun load(context: Context): JSONObject {
 
-        if (config != null) {
-            return config!!
+        config?.let {
+            Log.d(TAG, "Returning cached config: $it")
+            return it
         }
 
 
         config = try {
 
             val input =
-                context.assets.open("pakstr-runtime.json")
-
+                context.assets.open(
+                    "www/pakstr-runtime.json"
+                )
 
             val json =
                 input.bufferedReader()
@@ -28,24 +33,117 @@ object RuntimeConfig {
 
             JSONObject(json)
 
-
         } catch (e: Exception) {
 
+            Log.e(
+                TAG,
+                "Failed loading runtime config",
+                e
+            )
+
             JSONObject()
 
         }
 
 
+        Log.d(
+            TAG,
+            "FINAL CONFIG: $config"
+        )
+
+
         return config!!
     }
 
 
-    fun apiBase(context: Context): String? {
+    /**
+     * Returns backend API URL.
+     *
+     * Empty means:
+     * - Nostr-only mode
+     * - no REST API proxy
+     */
+    fun apiBase(
+        context: Context
+    ): String? {
+
+        val value =
+            load(context)
+                .optString(
+                    "apiBase",
+                    ""
+                )
+
+
+        Log.d(
+            TAG,
+            "apiBase=$value"
+        )
+
+
+        return value.takeIf {
+            it.isNotBlank()
+        }
+    }
+
+
+    /**
+     * Determines if REST API proxy should be enabled.
+     */
+    fun apiEnabled(
+        context: Context
+    ): Boolean {
+
+        val enabled =
+            !apiBase(context).isNullOrBlank()
+
+
+        Log.d(
+            TAG,
+            "apiEnabled=$enabled"
+        )
+
+
+        return enabled
+    }
+
+
+    /**
+     * Nostr relay URL.
+     */
+    fun relayUrl(
+        context: Context
+    ): String {
+
+        val relay =
+            load(context)
+                .optString(
+                    "relayUrl",
+                    ""
+                )
+
+
+        Log.d(
+            TAG,
+            "relayUrl=$relay"
+        )
+
+
+        return relay
+    }
+
+
+    /**
+     * Clears cached config.
+     * Useful for testing after changing pakstr-runtime.json.
+     */
+    fun clearCache() {
+
+        config = null
 
-        return load(context)
-            .optString("apiBase")
-            .takeIf {
-                it.isNotBlank()
-            }
+        Log.d(
+            TAG,
+            "Config cache cleared"
+        )
     }
 }

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

@@ -49,6 +49,7 @@ class WebViewController(
 
     fun setup() {
         showLoader()
+        setupCookies()
         setupWebView()
         loadApp()
     }
@@ -141,6 +142,24 @@ class WebViewController(
 
     }
 
+    private fun setupCookies() {
+
+        val cookieManager = CookieManager.getInstance()
+
+        cookieManager.setAcceptCookie(true)
+
+        cookieManager.setAcceptThirdPartyCookies(
+
+            webView,
+
+            true
+
+        )
+
+        cookieManager.flush()
+
+    }
+
     /**
      * Loads the local server URL with a minor delay to ensure NanoHTTPD is fully bound.
      */

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

@@ -34,15 +34,20 @@ object NostrEventHasher {
         event: JSONObject
     ): String {
 
+        val pubkey =
+            event.optString("pubkey")
+
+        require(pubkey.isNotBlank()) {
+            "Missing pubkey in nostr event: $event"
+        }
+
         val serialized =
             JSONArray()
                 .apply {
 
                     put(0)
 
-                    put(
-                        event.getString("pubkey")
-                    )
+                    put(pubkey)
 
                     put(
                         event.getLong("created_at")
@@ -67,7 +72,6 @@ object NostrEventHasher {
         return sha256Hex(
             serialized.toByteArray()
         )
-
     }
 
     /**

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

@@ -118,79 +118,88 @@ class AmberSigner(
     override suspend fun signEvent(
         eventJson: String
     ): String =
-
         withTimeout(30_000) {
 
+            val event = JSONObject(eventJson)
+
+            val currentPubkey = event.optString("pubkey")
+
+            if (currentPubkey.isBlank()) {
+
+                val amberPubkey = getPublicKey()
+
+                require(amberPubkey.isNotBlank()) {
+
+                    "Amber returned empty pubkey"
+
+                }
+
+                event.put(
+
+                    "pubkey",
+
+                    amberPubkey
+
+                )
+
+            }
+
             suspendCancellableCoroutine { continuation ->
 
-                val event = JSONObject(eventJson)
+                AppDebugLogger.log(
+                    "AMBER",
+                    "Signing event request"
+                )
 
                 pendingCallback = { signature ->
 
                     if (signature.isEmpty()) {
 
-                        if (continuation.isActive) {
-
-                            continuation.resume("")
-
-                        }
+                        continuation.resume("")
 
                     } else {
 
                         val signedEvent =
-
                             NostrEventBuilder.addId(event)
                                 .apply {
-
                                     put(
-                                        "sig", signature
+                                        "sig",
+                                        signature
                                     )
-
                                 }
-                        // Verify the signed event locally before returning it.
-                        // This ensures that the received signature matches the event data
-                        // and protects against invalid signer responses.
-                        val verified = NostrEventVerifier.verify(signedEvent)
-
-                        AppDebugLogger.log(
-                            "NOSTR_VERIFY", "Event verified=$verified"
-                        )
-
-                        if (continuation.isActive) {
-                            if (verified) {
-                                continuation.resume(
-                                    signedEvent.toString()
-                                )
-
-                            } else {
-                                continuation.resume("")
-                            }
+
+
+                        val verified =
+                            NostrEventVerifier.verify(
+                                signedEvent
+                            )
+
+
+                        if (verified) {
+                            continuation.resume(
+                                signedEvent.toString()
+                            )
+                        } else {
+                            continuation.resume("")
                         }
                     }
                 }
 
+
                 val intent = Intent(
-                    Intent.ACTION_VIEW, Uri.parse(
+                    Intent.ACTION_VIEW,
+                    Uri.parse(
                         "nostrsigner:${Uri.encode(event.toString())}"
                     )
                 ).apply {
                     putExtra(
-                        "type", "sign_event"
+                        "type",
+                        "sign_event"
                     )
                 }
-                try {
-                    launcher.launch(intent)
-
-                } catch (_: ActivityNotFoundException) {
 
-                    if (continuation.isActive) {
-                        continuation.resume("")
-                    }
-                }
 
-                continuation.invokeOnCancellation {
-                    pendingCallback = null
-                }
+                launcher.launch(intent)
             }
         }
 
@@ -434,13 +443,6 @@ class AmberSigner(
                     )
                 }
 
-
-                AppDebugLogger.log(
-                    "NIP44",
-                    "decrypt sender=$pubkey current=$pubkey length=${ciphertext.length}"
-                )
-
-
                 try {
 
                     launcher.launch(intent)
@@ -489,27 +491,12 @@ class AmberSigner(
                 ?: result.data?.getStringExtra("content")
 
                 ?: ""
-
         AppDebugLogger.log(
-
-            "AMBER_RESULT",
-
-            value
-
+            "AMBER",
+            "Operation completed"
         )
-        AppDebugLogger.log(
-
-            "AMBER_RESULT_KEYS",
-
-            result.data?.extras?.keySet()?.joinToString()
-
-                ?: "NO_KEYS"
 
-        )
-
-        callback?.invoke(
-            value
-        )
+        callback?.invoke(value)
     }
 
     private suspend fun getCachedPublicKey(): String {

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

@@ -133,7 +133,6 @@ class NostrBridge(
                         val plaintext =
                             json.getString("plaintext")
 
-
                         val result =
                             signerManager
                                 .getSigner()
@@ -171,7 +170,6 @@ class NostrBridge(
                 }
             }
 
-
             "nip04_decrypt" -> {
 
                 scope.launch {
@@ -182,7 +180,6 @@ class NostrBridge(
                             "NIP04 decrypt payload is empty"
                         }
 
-
                         val json =
                             JSONObject(payload)
 
@@ -192,7 +189,6 @@ class NostrBridge(
                         val ciphertext =
                             json.getString("ciphertext")
 
-
                         val result =
                             signerManager
                                 .getSigner()
@@ -207,7 +203,6 @@ class NostrBridge(
                             result
                         )
 
-
                     } catch (e: SignerUnavailableException) {
 
                         resolve(
@@ -253,7 +248,6 @@ class NostrBridge(
                             result
                         )
 
-
                     } catch (e: Exception) {
 
                         resolve(
@@ -289,7 +283,6 @@ class NostrBridge(
                             result
                         )
 
-
                     } catch (e: Exception) {
 
                         resolve(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pakstr",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "CLI for packaging Nostr web apps into Android APKs",
   "type": "commonjs",
   "main": "dist/index.js",