pakstr 0.4.0 → 0.5.0

package/android-template/app/build.gradle.kts

@@ -1,12 +1,59 @@
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+import java.util.Properties
+import java.io.File
+
 plugins {
     alias(libs.plugins.android.application)
     alias(libs.plugins.kotlin.compose)
 }
 
+val keystoreProperties =
+
+    Properties()
+
+val keystorePath =
+    providers.gradleProperty(
+        "releaseKeystoreConfig"
+    ).orNull
+
+val keystorePropertiesFile =
+    keystorePath?.let { rootProject.file(it) }
+if (keystorePropertiesFile?.exists() == true) {
+
+    keystorePropertiesFile.inputStream()
+        .use {
+            keystoreProperties.load(it)
+        }
+}
+
 android {
     namespace = "com.pakstr.app"
     compileSdk = 36
 
+    signingConfigs {
+
+        create("release") {
+
+            if (keystorePropertiesFile?.exists() == true) {
+
+                storeFile =
+                    File(
+                        keystorePropertiesFile.parentFile,
+                        keystoreProperties["storeFile"] as String
+                    )
+
+                storePassword =
+                    keystoreProperties["storePassword"] as String
+
+                keyAlias =
+                    keystoreProperties["keyAlias"] as String
+
+                keyPassword =
+                    keystoreProperties["keyPassword"] as String
+            }
+        }
+    }
+
     defaultConfig {
         applicationId = "com.pakstr.app"
         minSdk = 28
@@ -18,23 +65,43 @@ android {
     }
 
     buildTypes {
+
+        debug {
+            applicationIdSuffix = ".debug"
+            versionNameSuffix = "-debug"
+        }
+
         release {
-            isMinifyEnabled = false
+            signingConfig =
+                signingConfigs.getByName("release")
+            isMinifyEnabled = true
+            isShrinkResources = true
             proguardFiles(
-                getDefaultProguardFile("proguard-android-optimize.txt"),
+                getDefaultProguardFile(
+                    "proguard-android-optimize.txt"
+                ),
                 "proguard-rules.pro"
             )
         }
     }
     compileOptions {
-        sourceCompatibility = JavaVersion.VERSION_11
-        targetCompatibility = JavaVersion.VERSION_11
+        sourceCompatibility = JavaVersion.VERSION_17
+        targetCompatibility = JavaVersion.VERSION_17
     }
+
     buildFeatures {
         compose = true
         buildConfig = true
     }
 }
+tasks.withType<KotlinCompile>()
+    .configureEach {
+        compilerOptions {
+            jvmTarget.set(
+                org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_17
+            )
+        }
+    }
 
 dependencies {
     implementation(libs.androidx.core.ktx)

package/android-template/app/proguard-rules.pro

@@ -1,21 +1,24 @@
-# Add project specific ProGuard rules here.
-# You can control the set of applied configuration files using the
-# proguardFiles setting in build.gradle.
-#
-# For more details, see
-#   http://developer.android.com/guide/developing/tools/proguard.html
+# JavaScript bridge
+-keepclassmembers class * {
+    @android.webkit.JavascriptInterface <methods>;
+}
 
-# If your project uses WebView with JS, uncomment the following
-# and specify the fully qualified class name to the JavaScript interface
-# class:
-#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
-#   public *;
-#}
+# Nostr signer
+-keep class com.pakstr.app.signer.** { *; }
 
-# Uncomment this to preserve the line number information for
-# debugging stack traces.
-#-keepattributes SourceFile,LineNumberTable
+# Crypto
+-keep class com.pakstr.app.crypto.** { *; }
 
-# If you keep the line number information, uncomment this to
-# hide the original source file name.
-#-renamesourcefileattribute SourceFile
+# BouncyCastle
+-keep class org.bouncycastle.crypto.** { *; }
+-keep class org.bouncycastle.math.** { *; }
+-keep class org.bouncycastle.asn1.** { *; }
+
+# Ignore unavailable Java SE classes
+-dontwarn javax.naming.**
+
+# Keep Application class
+-keep class com.pakstr.app.ApplicationClass { *; }
+
+# Keep model classes used through JSON
+-keep class com.pakstr.app.signer.** { *; }

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

@@ -2,6 +2,9 @@ package com.pakstr.app
 
 import android.app.Application
 import com.pakstr.app.crypto.CryptoInitializer
+import com.pakstr.app.debug.AppDebugLogger
+import com.pakstr.app.debug.CrashHandler
+import com.pakstr.app.debug.DebugSession
 import com.pakstr.app.utils.AppPreferences
 
 class ApplicationClass : Application() {
@@ -9,5 +12,16 @@ class ApplicationClass : Application() {
         super.onCreate()
         AppPreferences.init(this)
         CryptoInitializer.init()
+        CrashHandler.install(this)
+
+        AppDebugLogger.log(
+
+            this,
+
+            "SESSION",
+
+            "Session started: ${DebugSession.sessionId}"
+
+        )
     }
 }

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

@@ -18,9 +18,11 @@ import androidx.core.view.ViewCompat
 import androidx.core.view.WindowInsetsCompat
 import androidx.core.view.updatePadding
 import com.pakstr.app.debug.AppDebugLogger
+import com.pakstr.app.debug.CrashHandler
 
 import com.pakstr.app.debug.DebugReportShare
 import com.pakstr.app.debug.DeveloperToolsManager
+import com.pakstr.app.debug.WebViewDebugManager
 
 import com.pakstr.app.permissions.PermissionManager
 import com.pakstr.app.permissions.interfaces.PermissionHandler
@@ -52,21 +54,32 @@ class MainActivity : AppCompatActivity(), PermissionHandler {
         enableEdgeToEdge()
 
         super.onCreate(savedInstanceState)
+        if (BuildConfig.DEBUG) {
+
+            DeveloperToolsManager.enableDebug(this)
+
+        }
+
+        WebViewDebugManager.enable(this)
+
         AppDebugLogger.log(
 
             this,
 
-            "SESSION",
+            "TEST",
 
-            "========== APP START =========="
+            "Developer debug enabled"
 
         )
+        AppDebugLogger.log(
 
-        if (BuildConfig.DEBUG) {
+            this,
+
+            "SESSION",
 
-            WebView.setWebContentsDebuggingEnabled(true)
+            "========== APP START =========="
 
-        }
+        )
 
         setContentView(
 

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

@@ -97,7 +97,7 @@ class ShellRuntime(
             }
 
         }
-
+        AppDebugLogger.load(context)
     }
 
     private fun startServer(): Boolean {

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

@@ -95,6 +95,7 @@ class WebViewController(
                         nip07Injected = injectNip07()
 
                     }
+                    injectDebugLogger()
                 }
 
                 override fun onReceivedHttpError(
@@ -343,4 +344,138 @@ class WebViewController(
             false
         }
     }
+
+    private fun injectDebugLogger() {
+
+        val js = """
+        (function(){
+
+            if (!window.AndroidBridge) {
+                return;
+            }
+
+
+            const oldLog = console.log;
+            const oldWarn = console.warn;
+            const oldError = console.error;
+
+
+            function send(level, args){
+
+                try {
+
+                    const message =
+                        Array.from(args)
+                        .map(item => {
+
+                            if(typeof item === 'object'){
+                                return JSON.stringify(item);
+                            }
+
+                            return String(item);
+
+                        })
+                        .join(" ");
+
+                    window.AndroidBridge.debugLog(
+                        level,
+                        message
+                    );
+
+                } catch(e){
+
+                }
+            }
+
+
+            console.log = function(){
+
+                send(
+                    "LOG",
+                    arguments
+                );
+
+                oldLog.apply(
+                    console,
+                    arguments
+                );
+            };
+
+
+            console.warn = function(){
+
+                send(
+                    "WARN",
+                    arguments
+                );
+
+                oldWarn.apply(
+                    console,
+                    arguments
+                );
+            };
+
+
+            console.error = function(){
+
+                send(
+                    "ERROR",
+                    arguments
+                );
+
+                oldError.apply(
+                    console,
+                    arguments
+                );
+            };
+
+
+            window.onerror =
+                function(
+                    message,
+                    source,
+                    line,
+                    column,
+                    error
+                ){
+
+                    send(
+                        "ERROR",
+                        [
+                            "JS ERROR:",
+                            message,
+                            source,
+                            line,
+                            column,
+                            error?.stack
+                        ]
+                    );
+
+                    return false;
+                };
+
+
+            window.onunhandledrejection =
+                function(event){
+
+                    send(
+                        "ERROR",
+                        [
+                            "PROMISE ERROR:",
+                            event.reason
+                        ]
+                    );
+
+                };
+
+
+        })();
+    """.trimIndent()
+
+
+        webView.evaluateJavascript(
+            js,
+            null
+        )
+    }
 }

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

@@ -5,6 +5,7 @@ import android.util.Log
 import com.pakstr.app.BuildConfig
 import com.pakstr.app.RuntimeConfig
 import java.text.SimpleDateFormat
+import java.util.Collections
 import java.util.Date
 import java.util.Locale
 
@@ -15,7 +16,12 @@ object AppDebugLogger {
     private const val MAX_LOGS = 500
 
     private val logs =
-        mutableListOf<String>()
+
+        Collections.synchronizedList(
+
+            mutableListOf<String>()
+
+        )
 
     fun log(
         context: Context,
@@ -108,10 +114,14 @@ object AppDebugLogger {
 
     }
 
-    fun clear() {
+    fun clear(
+        context: Context
+    ) {
 
         logs.clear()
 
+        DebugLogStorage.clear(context)
+
     }
 
     private fun isDebugEnabled(
@@ -280,14 +290,77 @@ object AppDebugLogger {
     }
 
     private fun config(
+        context: Context
+    ): DebugConfig {
+
+
+        val runtime =
+            DebugRuntimeOverride.get(context)
+
+
+        if (runtime != null) {
+            return runtime
+        }
+
+
+        val stored =
+            DebugPreferences.load(
+                context
+            )
+
+
+        if (stored.enabled) {
+            return stored
+        }
+
+
+        return RuntimeConfig.debugConfig(
+            context
+        )
+
+    }
 
+    fun exportLogs(
         context: Context
+    ): String {
 
-    ): DebugConfig {
+        return buildString {
+
+            appendLine(
+                "===== PAKSTR DEBUG LOG ====="
+            )
+
+            appendLine(
+                "Version: ${BuildConfig.VERSION_NAME}"
+            )
+
+            appendLine(
+                "Debug: ${isDebugEnabled(context)}"
+            )
+
+            appendLine()
+
+
+            getLogs().forEach {
+                appendLine(it)
+            }
 
-        return DebugRuntimeOverride.get()
+        }
+    }
+
+    fun load(
+
+        context: Context
+
+    ) {
+
+        logs.clear()
 
-            ?: RuntimeConfig.debugConfig(context)
+        logs.addAll(
+
+            DebugLogStorage.read(context)
+
+        )
 
     }
 }

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

@@ -0,0 +1,32 @@
+package com.pakstr.app.debug
+
+import android.content.Context
+
+object CrashHandler {
+
+    fun install(
+        context: Context
+    ) {
+
+        val defaultHandler =
+            Thread.getDefaultUncaughtExceptionHandler()
+
+
+        Thread.setDefaultUncaughtExceptionHandler { thread, throwable ->
+
+
+            AppDebugLogger.error(
+                context,
+                "CRASH",
+                "Unhandled exception in ${thread.name}",
+                throwable
+            )
+
+
+            defaultHandler?.uncaughtException(
+                thread,
+                throwable
+            )
+        }
+    }
+}

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

@@ -1,10 +1,13 @@
 package com.pakstr.app.debug
 
+import android.content.Context
+
 object DebugConfigProvider {
 
     private var manifestConfig =
         DebugConfig()
 
+
     fun initialize(
         config: DebugConfig
     ) {
@@ -13,10 +16,12 @@ object DebugConfigProvider {
 
     }
 
-    fun current():
-            DebugConfig {
 
-        return DebugRuntimeOverride.get()
+    fun current(
+        context: Context
+    ): DebugConfig {
+
+        return DebugRuntimeOverride.get(context)
             ?: manifestConfig
 
     }

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

@@ -11,6 +11,8 @@ object DebugLogStorage {
     private const val MAX_FILE_SIZE =
         1024 * 1024 // 1 MB
 
+    private const val MAX_LINES = 5000
+
     fun append(
         context: Context,
         entry: String
@@ -26,9 +28,13 @@ object DebugLogStorage {
 
 
             file.appendText(
+
                 entry + "\n"
+
             )
 
+            trimFile(file)
+
         } catch (_: Exception) {
 
             // Logging must never crash the app
@@ -38,27 +44,21 @@ object DebugLogStorage {
 
     fun read(
         context: Context
-    ): String {
+    ): List<String> {
 
         return try {
 
-            val file =
-                getFile(context)
-
+            val file = getFile(context)
 
             if (file.exists()) {
-
-                file.readText()
-
+                file.readLines()
             } else {
-
-                ""
-
+                emptyList()
             }
 
         } catch (_: Exception) {
 
-            ""
+            emptyList()
 
         }
     }
@@ -104,4 +104,36 @@ object DebugLogStorage {
         )
 
     }
+
+    private fun trimFile(
+
+        file: File
+
+    ) {
+
+        try {
+
+            val lines =
+
+                file.readLines()
+
+            if (lines.size > MAX_LINES) {
+
+                file.writeText(
+
+                    lines
+
+                        .takeLast(MAX_LINES)
+
+                        .joinToString("\n") + "\n"
+
+                )
+
+            }
+
+        } catch (_: Exception) {
+
+        }
+
+    }
 }

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

@@ -0,0 +1,85 @@
+package com.pakstr.app.debug
+
+import android.content.Context
+
+object DebugPreferences {
+
+    private const val PREFS_NAME = "pakstr_debug"
+
+    private const val KEY_ENABLED = "enabled"
+    private const val KEY_NETWORK = "networkLogs"
+    private const val KEY_WEBVIEW = "webViewLogs"
+
+
+    private fun prefs(context: Context) =
+        context.getSharedPreferences(
+            PREFS_NAME,
+            Context.MODE_PRIVATE
+        )
+
+
+    fun save(
+        context: Context,
+        config: DebugConfig
+    ) {
+
+        prefs(context)
+            .edit()
+            .putBoolean(
+                KEY_ENABLED,
+                config.enabled
+            )
+            .putBoolean(
+                KEY_NETWORK,
+                config.networkLogs
+            )
+            .putBoolean(
+                KEY_WEBVIEW,
+                config.webViewLogs
+            )
+            .apply()
+
+    }
+
+
+    fun load(
+        context: Context
+    ): DebugConfig {
+
+        val prefs = prefs(context)
+
+        return DebugConfig(
+
+            enabled =
+                prefs.getBoolean(
+                    KEY_ENABLED,
+                    false
+                ),
+
+            networkLogs =
+                prefs.getBoolean(
+                    KEY_NETWORK,
+                    false
+                ),
+
+            webViewLogs =
+                prefs.getBoolean(
+                    KEY_WEBVIEW,
+                    false
+                )
+
+        )
+    }
+
+
+    fun clear(
+        context: Context
+    ) {
+
+        prefs(context)
+            .edit()
+            .clear()
+            .apply()
+
+    }
+}

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

@@ -38,7 +38,7 @@ object DebugReportExporter {
         val file =
             File(
                 context.cacheDir,
-                "pakstr-debug-report.txt"
+                "pakstr-debug-report-${DebugSession.sessionId}.txt"
             )
 
 
@@ -57,19 +57,8 @@ object DebugReportExporter {
 
 
         val rawLogs =
-            if (debugEnabled) {
-
-                DebugLogStorage.read(context)
-
-            } else {
-
-                DebugLogStorage.read(context)
-                    .lines()
-                    .filter {
-                        it.contains("[ERROR]")
-                    }
-                    .joinToString("\n")
-            }
+            DebugLogStorage.read(context)
+                .joinToString("\n")
 
 
         val logs =
@@ -77,32 +66,53 @@ object DebugReportExporter {
 
 
         return """
-            Pakstr Debug Report
-            ===================
+        Pakstr Debug Report
+        ===================
+
+        Session:
+        -------------------
+        ID:
+        ${DebugSession.sessionId}
+
+        Started:
+        ${java.util.Date(DebugSession.startedAt)}
+
+        Uptime:
+        ${DebugSession.uptime()} ms
+
+
+        Application:
+        -------------------
+        ${BuildConfig.APPLICATION_ID}
+
+
+        Version:
+        ${BuildConfig.VERSION_NAME} (${BuildConfig.VERSION_CODE})
+
+
+        Device:
+        ${Build.MANUFACTURER} ${Build.MODEL}
+
 
-            Application:
-            ${BuildConfig.APPLICATION_ID}
+        Android:
+        ${Build.VERSION.RELEASE}
 
-            Version:
-            ${BuildConfig.VERSION_NAME} (${BuildConfig.VERSION_CODE})
 
-            Device:
-            ${Build.MANUFACTURER} ${Build.MODEL}
+        Debug:
+        $debugEnabled
 
-            Android:
-            ${Build.VERSION.RELEASE}
 
-            Debug:
-            $debugEnabled
+        API Enabled:
+        ${RuntimeConfig.apiEnabled(context)}
 
-            API Enabled:
-            ${RuntimeConfig.apiEnabled(context)}
+        WebView Debug:
+        ${BuildConfig.DEBUG || RuntimeConfig.debugEnabled(context)}
 
-            Logs:
-            -------------------
-            $logs
+        Logs:
+        -------------------
+        $logs
 
-        """.trimIndent()
+    """.trimIndent()
     }
 
 

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

@@ -1,29 +1,55 @@
 package com.pakstr.app.debug
 
+import android.content.Context
+
+
 object DebugRuntimeOverride {
 
-    private var overrideConfig: DebugConfig? = null
+
+    private var overrideConfig:
+            DebugConfig? = null
 
 
     fun set(
+        context: Context,
         config: DebugConfig
     ) {
 
         overrideConfig = config
 
+        DebugPreferences.save(
+            context,
+            config
+        )
     }
 
 
-    fun clear() {
+    fun clear(
+        context: Context
+    ) {
 
         overrideConfig = null
 
+        DebugPreferences.clear(
+            context
+        )
     }
 
 
-    fun get(): DebugConfig? {
+    fun get(
+        context: Context
+    ): DebugConfig? {
 
-        return overrideConfig
+        if (overrideConfig == null) {
+
+            val saved =
+                DebugPreferences.load(context)
 
+            if (saved.enabled) {
+                overrideConfig = saved
+            }
+        }
+
+        return overrideConfig
     }
 }

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

@@ -0,0 +1,16 @@
+package com.pakstr.app.debug
+
+import java.util.UUID
+
+object DebugSession {
+
+    val sessionId: String =
+        UUID.randomUUID().toString()
+
+    val startedAt: Long =
+        System.currentTimeMillis()
+
+    fun uptime(): Long {
+        return System.currentTimeMillis() - startedAt
+    }
+}

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

@@ -1,34 +1,63 @@
 package com.pakstr.app.debug
+
+import android.content.Context
+
+
 object DeveloperToolsManager {
 
-    fun enableDebug() {
 
-        DebugRuntimeOverride.set(
+    fun enableDebug(
+        context: Context
+    ) {
 
-            DebugConfig(
+        val config = DebugConfig(
 
-                enabled = true,
+            enabled = true,
 
-                networkLogs = true,
+            networkLogs = true,
 
-                webViewLogs = true,
+            webViewLogs = true
+
+        )
+
+
+
+        DebugRuntimeOverride.set(context,
+            config
+        )
 
-                )
+        DebugPreferences.save(
+            context,
+            config
         )
 
     }
 
-    fun disableDebug() {
 
-        DebugRuntimeOverride.clear()
+    fun disableDebug(
+        context: Context
+    ) {
+
+
+        DebugRuntimeOverride.clear(context)
+
+
+        DebugPreferences.clear(
+            context
+        )
 
     }
 
-    fun isEnabled(): Boolean {
 
-        return DebugRuntimeOverride.get()
-            ?.enabled
-            ?: false
+    fun isEnabled(
+        context: Context
+    ): Boolean {
+
+
+        return DebugPreferences
+            .load(context)
+            .enabled
 
     }
+
 }

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

@@ -0,0 +1,30 @@
+package com.pakstr.app.debug
+
+import android.R.attr.enabled
+import android.content.Context
+import android.webkit.WebView
+import com.pakstr.app.BuildConfig
+import com.pakstr.app.RuntimeConfig
+
+object WebViewDebugManager {
+
+
+    fun enable(
+        context: Context
+    ) {
+
+        WebView.setWebContentsDebuggingEnabled(
+            BuildConfig.DEBUG ||
+                    RuntimeConfig.debugEnabled(context)
+        )
+        AppDebugLogger.log(
+
+            context,
+
+            "WEBVIEW",
+
+            "WebView debugging enabled: $enabled"
+
+        )
+    }
+}

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

@@ -0,0 +1,16 @@
+package com.pakstr.app.debug.logging
+
+data class PakstrLog(
+    val timestamp: Long,
+    val level: Level,
+    val tag: String,
+    val message: String
+) {
+
+    enum class Level {
+        DEBUG,
+        INFO,
+        WARN,
+        ERROR
+    }
+}

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

@@ -0,0 +1,154 @@
+package com.pakstr.app.debug.logging
+
+import android.util.Log
+import com.pakstr.app.debug.logging.PakstrLog
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
+
+object PakstrLogger {
+
+    private const val MAX_LOGS = 1000
+
+    private val logs =
+        mutableListOf<PakstrLog>()
+
+
+    fun d(
+        tag: String,
+        message: String
+    ) {
+        add(
+            PakstrLog.Level.DEBUG,
+            tag,
+            message
+        )
+
+        Log.d(
+            "PakstrDebug",
+            "[$tag] $message"
+        )
+    }
+
+
+    fun i(
+        tag: String,
+        message: String
+    ) {
+        add(
+            PakstrLog.Level.INFO,
+            tag,
+            message
+        )
+
+        Log.i(
+            "PakstrDebug",
+            "[$tag] $message"
+        )
+    }
+
+
+    fun w(
+        tag: String,
+        message: String
+    ) {
+        add(
+            PakstrLog.Level.WARN,
+            tag,
+            message
+        )
+
+        Log.w(
+            "PakstrDebug",
+            "[$tag] $message"
+        )
+    }
+
+
+    fun e(
+        tag: String,
+        message: String,
+        throwable: Throwable? = null
+    ) {
+
+        add(
+            PakstrLog.Level.ERROR,
+            tag,
+            message
+        )
+
+        Log.e(
+            "PakstrDebug",
+            "[$tag] $message",
+            throwable
+        )
+    }
+
+
+    fun getLogs(): List<PakstrLog> {
+        return logs.toList()
+    }
+
+
+    fun clear() {
+        logs.clear()
+    }
+
+
+    private fun add(
+        level: PakstrLog.Level,
+        tag: String,
+        message: String
+    ) {
+
+        logs.add(
+            PakstrLog(
+                timestamp =
+                    System.currentTimeMillis(),
+                level = level,
+                tag = tag,
+                message = message
+            )
+        )
+
+
+        if (logs.size > MAX_LOGS) {
+            logs.removeFirst()
+        }
+    }
+
+
+    fun exportText(): String {
+
+        val formatter =
+            SimpleDateFormat(
+                "yyyy-MM-dd HH:mm:ss",
+                Locale.US
+            )
+
+        return buildString {
+
+            appendLine(
+                "Pakstr Debug Report"
+            )
+
+            appendLine(
+                "=================="
+            )
+
+            appendLine()
+
+            logs.forEach {
+
+                appendLine(
+                    "${formatter.format(
+                        Date(it.timestamp)
+                    )} " +
+                            "[${it.level}] " +
+                            "[${it.tag}] " +
+                            it.message
+                )
+            }
+        }
+    }
+}

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

@@ -435,7 +435,7 @@ class NostrBridge(
 
                 AppDebugLogger.error(
                     webView.context,
-                    "WEB",
+                    "WEB-JS",
                     message
                 )
 

package/android-template/gradle/libs.versions.toml

@@ -39,3 +39,4 @@ material = { module = "com.google.android.material:material", version.ref = "mat
 android-application = { id = "com.android.application", version.ref = "agp" }
 kotlin-compose = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kotlin" }
 
+

package/android-template/gradle.properties

@@ -12,4 +12,5 @@ org.gradle.jvmargs=-Xmx2048m -Dfile.encoding=UTF-8
 # https://developer.android.com/r/tools/gradle-multi-project-decoupled-projects
 # org.gradle.parallel=true
 # Kotlin code style for this project: "official" or "obsolete":
-kotlin.code.style=official
+kotlin.code.style=official
+releaseKeystoreConfig=../../../keystore.properties

package/package.json

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