pakstr 0.1.0 → 0.2.1

package/android-template/app/src/main/assets/nip07.js

@@ -5,71 +5,112 @@
     const pending = new Map();
 
     function callNative(method, payload) {
-
         return new Promise((resolve, reject) => {
 
             const id = crypto.randomUUID();
 
-            pending.set(
-                id,
-                {
-                    resolve,
-                    reject
-                }
-            );
+            pending.set(id, {
+                resolve,
+                reject
+            });
 
             window.AndroidBridge.call(
                 method,
                 id,
-                payload
-                    ? JSON.stringify(payload)
-                    : ""
+                payload ? JSON.stringify(payload) : ""
             );
         });
     }
 
     window.__nostrResolve = (id, result) => {
 
-        const p =
-            pending.get(id);
-
+        const p = pending.get(id);
         if (!p) return;
 
         pending.delete(id);
 
         try {
-
-            const parsed =
-                JSON.parse(result);
+            const parsed = JSON.parse(result);
 
             if (parsed.error) {
                 p.reject(parsed);
                 return;
             }
+
         } catch (_) {
             // Normal string response
         }
+
         p.resolve(result);
     };
 
     window.nostr = {
 
         getPublicKey: async () => {
+            return await callNative("getPublicKey");
+        },
 
-            return await callNative(
-                "getPublicKey"
+        signEvent: async (event) => {
+
+            const result = await callNative(
+                "signEvent",
+                event
             );
+
+            return JSON.parse(result);
         },
 
-        signEvent: async (event) => {
+        nip04: {
+
+            encrypt: async (pubkey, plaintext) => {
 
-            const result =
-                await callNative(
-                    "signEvent",
-                    event
+                return await callNative(
+                    "nip04_encrypt",
+                    {
+                        pubkey,
+                        plaintext
+                    }
                 );
+            },
+
+            decrypt: async (pubkey, ciphertext) => {
+
+                return await callNative(
+                    "nip04_decrypt",
+                    {
+                        pubkey,
+                        ciphertext
+                    }
+                );
+            }
+
+        },
+
+        nip44: {
+
+            encrypt: async (pubkey, plaintext) => {
+
+                return await callNative(
+                    "nip44_encrypt",
+                    {
+                        pubkey,
+                        plaintext
+                    }
+                );
+            },
+
+            decrypt: async (pubkey, ciphertext) => {
+
+                return await callNative(
+                    "nip44_decrypt",
+                    {
+                        pubkey,
+                        ciphertext
+                    }
+                );
+            }
 
-            return JSON.parse(result);
         }
     };
+
 })();

package/android-template/app/src/main/assets/www/index.html

@@ -39,7 +39,6 @@
     Sign Event
 </button>
 
-
 <pre id="output">
 Waiting...
 </pre>
@@ -47,6 +46,7 @@ Waiting...
 
 <script>
 
+
     function log(data) {
 
         document.getElementById("output").innerText =
@@ -59,10 +59,16 @@ Waiting...
     }
 
 
-    console.log(
-        "Nostr provider:",
-        window.nostr
-    );
+    // Check provider after Pakstr injection
+    setTimeout(() => {
+
+        console.log(
+            "Nostr provider:",
+            window.nostr
+        );
+
+    }, 2000);
+
 
 
     async function getPublicKey() {
@@ -91,7 +97,8 @@ Waiting...
 
                 pubkey,
 
-                length: pubkey.length,
+                length:
+                    pubkey.length,
 
                 format:
                     pubkey.startsWith("npub")
@@ -105,7 +112,8 @@ Waiting...
 
             log({
 
-                error: e.message
+                error:
+                    e.message
 
             });
 
@@ -115,102 +123,89 @@ Waiting...
 
 
 
-    async function signEvent() {
-
-    try {
-
-        log("Signing event...");
-
-        if (!window.nostr) {
-
-            throw new Error(
 
-                "Nostr provider not available"
-
-            );
-
-        }
-
-        const pubkey =
-
-            await window.nostr.getPublicKey();
-
-        const event = {
+    async function signEvent() {
 
-            pubkey: pubkey,
+        try {
 
-            kind: 1,
+            log("Signing event...");
 
-            content:
 
-                "Hello from Pakstr NIP-07",
+            if (!window.nostr) {
 
-            tags: [],
+                throw new Error(
+                    "Nostr provider not available"
+                );
 
-            created_at:
+            }
 
-                Math.floor(
 
-                    Date.now() / 1000
+            const pubkey =
+                await window.nostr.getPublicKey();
 
-                )
 
-        };
+            const event = {
 
-        console.log(
+                pubkey,
 
-            "Unsigned event",
+                kind: 1,
 
-            event
+                content:
+                    "Hello from Pakstr NIP-07",
 
-        );
+                tags: [],
 
-        log({
+                created_at:
+                    Math.floor(
+                        Date.now() / 1000
+                    )
 
-            step: "sending event",
+            };
 
-            event
 
-        });
+            console.log(
+                "Unsigned event",
+                event
+            );
 
-        const signedEvent =
 
-            await window.nostr.signEvent(
+            const signedEvent =
+                await window.nostr.signEvent(
+                    event
+                );
 
-                event
 
+            console.log(
+                "Signed event",
+                signedEvent
             );
 
-        console.log(
 
-            "Signed event",
-
-            signedEvent
-
-        );
+            log({
 
-        log({
+                success: true,
 
-            success: true,
+                signedEvent
 
-            signedEvent
+            });
 
-        });
 
-    } catch (e) {
+        } catch (e) {
 
-        console.error(e);
+            console.error(e);
 
-        log({
 
-            error: e.message,
+            log({
 
-            stack: e.stack
+                error:
+                    e.message,
 
-        });
+                stack:
+                    e.stack
 
-    }
+            });
 
+        }
 }
 
 

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

@@ -3,6 +3,7 @@ package com.pakstr.app
 import android.Manifest
 import android.content.Intent
 import android.os.Bundle
+import android.util.Log
 
 import android.view.View
 import android.webkit.PermissionRequest
@@ -17,12 +18,17 @@ 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 {
 
@@ -44,6 +50,12 @@ class MainActivity : AppCompatActivity(), PermissionHandler {
 
         super.onCreate(savedInstanceState)
 
+        if (BuildConfig.DEBUG) {
+
+            WebView.setWebContentsDebuggingEnabled(true)
+
+        }
+
         setContentView(
             R.layout.activity_layout
         )
@@ -58,10 +70,12 @@ class MainActivity : AppCompatActivity(), PermissionHandler {
             }
 
         initSigner()
-
-        if (AppPreferences.getBoolean("isFirstRun", true)) {
-            showSignerPicker()
-        }
+        signerManager.setActiveType(
+            SignerType.AMBER
+        )
+        //if (AppPreferences.getBoolean("isFirstRun", true)) {
+            //showSignerPicker()
+        //}
 
         ViewCompat.setOnApplyWindowInsetsListener(
             container
@@ -144,8 +158,15 @@ class MainActivity : AppCompatActivity(), PermissionHandler {
     }
 
     override fun onDestroy() {
-        runtime.stop()
+
+        if (::runtime.isInitialized) {
+
+            runtime.stop()
+
+        }
+
         super.onDestroy()
+
     }
 
     override fun onRequestPermissionsResult(

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

@@ -110,6 +110,8 @@ class WebViewController(
                     val url = request?.url ?: return true
                     return url.host != "127.0.0.1"
                 }
+
+
             }
             webChromeClient = object : WebChromeClient() {
 
@@ -129,7 +131,7 @@ class WebViewController(
 
                 signerManager = signerManager,
 
-                webView = webView
+                webView = webView,
 
             ),
 
@@ -192,4 +194,4 @@ class WebViewController(
             false
         }
     }
-}
+}

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

@@ -0,0 +1,33 @@
+package com.pakstr.app.crypto
+
+class Nip04Crypto : NostrEncryption {
+
+    override fun encrypt(
+
+        plaintext: String,
+
+        privateKey: ByteArray,
+
+        publicKey: ByteArray
+
+    ): String {
+
+        TODO()
+
+    }
+
+    override fun decrypt(
+
+        payload: String,
+
+        privateKey: ByteArray,
+
+        publicKey: ByteArray
+
+    ): String {
+
+        TODO()
+
+    }
+
+}

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

@@ -0,0 +1,16 @@
+package com.pakstr.app.crypto
+
+interface NostrEncryption {
+
+    fun encrypt(
+        plaintext: String,
+        privateKey: ByteArray,
+        publicKey: ByteArray
+    ): String
+
+    fun decrypt(
+        payload: String,
+        privateKey: ByteArray,
+        publicKey: ByteArray
+    ): String
+}

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

@@ -42,47 +42,77 @@ class AmberSigner(
     // Android intents return results asynchronously, so the callback is used
     // to resume the suspended coroutine when Amber responds.
     private var pendingCallback: ((String) -> Unit)? = null
+    private var cachedPubkey: String? = null
+    override suspend fun getPublicKey(): String {
 
-    override suspend fun getPublicKey(): String = withTimeout(30_000) {
+        cachedPubkey?.let {
 
-        suspendCancellableCoroutine { continuation ->
+            return it
 
-            pendingCallback = { pubkey ->
+        }
+
+        return withTimeout(30_000) {
+
+            suspendCancellableCoroutine { continuation ->
+
+                pendingCallback = { pubkey ->
+
+                    cachedPubkey = pubkey
+
+                    if (continuation.isActive) {
+
+                        continuation.resume(pubkey)
+
+                    }
 
-                if (continuation.isActive) {
-                    continuation.resume(pubkey)
                 }
-            }
 
-            val intent = Intent(
-                Intent.ACTION_VIEW
-            ).apply {
+                val intent = Intent(
 
-                data = Uri.parse(
-                    "nostrsigner:?type=get_public_key"
-                )
+                    Intent.ACTION_VIEW
 
-                putExtra(
-                    "type", "get_public_key"
-                )
+                ).apply {
 
-            }
+                    data = Uri.parse(
 
-            try {
+                        "nostrsigner:?type=get_public_key"
 
-                launcher.launch(intent)
+                    )
 
-            } catch (_: ActivityNotFoundException) {
+                    putExtra(
+
+                        "type",
+
+                        "get_public_key"
+
+                    )
+
+                }
+
+                try {
+
+                    launcher.launch(intent)
+
+                } catch (_: ActivityNotFoundException) {
+
+                    if (continuation.isActive) {
+
+                        continuation.resume("")
+
+                    }
+
+                }
+
+                continuation.invokeOnCancellation {
+
+                    pendingCallback = null
 
-                if (continuation.isActive) {
-                    continuation.resume("")
                 }
-            }
 
-            continuation.invokeOnCancellation {
-                pendingCallback = null
             }
+
         }
+
     }
 
     override suspend fun signEvent(
@@ -165,23 +195,270 @@ class AmberSigner(
         }
 
     override suspend fun nip04Encrypt(
-        pubkey: String, plaintext: String
-    ): String {
+        pubkey: String,
+        plaintext: String
+    ): String =
+        withTimeout(30_000) {
 
-        throw NotImplementedError(
-            "NIP04 not implemented"
-        )
-    }
+            suspendCancellableCoroutine { continuation ->
+
+                pendingCallback = { encrypted ->
+
+                    if (continuation.isActive) {
+                        continuation.resume(encrypted)
+                    }
+                }
+
+                val intent = Intent(
+                    Intent.ACTION_VIEW
+                ).apply {
+
+                    data = Uri.parse(
+                        "nostrsigner:?type=nip04_encrypt" +
+                                "&pubkey=$pubkey" +
+                                "&plaintext=${Uri.encode(plaintext)}"
+                    )
+
+                    putExtra(
+                        "type",
+                        "nip04_encrypt"
+                    )
+
+                    putExtra(
+                        "pubkey",
+                        pubkey
+                    )
+
+                    putExtra(
+                        "plaintext",
+                        plaintext
+                    )
+                }
+
+                try {
+
+                    launcher.launch(intent)
+
+                } catch (_: ActivityNotFoundException) {
+
+                    if (continuation.isActive) {
+                        continuation.resume("")
+                    }
+                }
+
+                continuation.invokeOnCancellation {
+                    pendingCallback = null
+                }
+            }
+        }
 
     override suspend fun nip04Decrypt(
-        pubkey: String, ciphertext: String
-    ): String {
+        pubkey: String,
+        ciphertext: String
+    ): String = withTimeout(30_000) {
 
-        throw NotImplementedError(
-            "NIP04 not implemented"
-        )
+        suspendCancellableCoroutine { continuation ->
+
+            pendingCallback = { result ->
+
+                if (continuation.isActive) {
+                    continuation.resume(result)
+                }
+            }
+
+            val intent = Intent(
+                Intent.ACTION_VIEW
+            ).apply {
+
+                data = Uri.parse(
+                    "nostrsigner:?type=nip04_decrypt" +
+                            "&pubkey=$pubkey" +
+                            "&message=${Uri.encode(ciphertext)}"
+                )
+
+                putExtra(
+                    "type",
+                    "nip04_decrypt"
+                )
+
+                putExtra(
+                    "pubkey",
+                    pubkey
+                )
+
+                putExtra(
+                    "message",
+                    ciphertext
+                )
+            }
+
+            try {
+
+                launcher.launch(intent)
+
+            } catch (_: ActivityNotFoundException) {
+
+                if (continuation.isActive) {
+                    continuation.resume("")
+                }
+            }
+
+            continuation.invokeOnCancellation {
+                pendingCallback = null
+            }
+        }
     }
 
+    override suspend fun nip44Encrypt(
+
+        pubkey: String,
+
+        plaintext: String
+
+    ): String =
+
+        withTimeout(30_000) {
+
+            val currentUser = getCachedPublicKey()
+
+            suspendCancellableCoroutine { continuation ->
+
+                pendingCallback = { encrypted ->
+
+                    if (continuation.isActive) {
+
+                        continuation.resume(encrypted)
+
+                    }
+
+                }
+
+                val intent = Intent(
+
+                    Intent.ACTION_VIEW
+
+                ).apply {
+
+                    data = Uri.parse(
+
+                        "nostrsigner:${Uri.encode(plaintext)}"
+
+                    )
+
+                    putExtra(
+
+                        "type",
+
+                        "nip44_encrypt"
+
+                    )
+
+                    putExtra(
+
+                        "pubkey",
+
+                        pubkey
+
+                    )
+
+                    putExtra(
+
+                        "current_user",
+
+                        currentUser
+
+                    )
+
+                }
+
+                try {
+
+                    launcher.launch(intent)
+
+                } catch (_: ActivityNotFoundException) {
+
+                    if (continuation.isActive) {
+
+                        continuation.resume("")
+
+                    }
+
+                }
+
+                continuation.invokeOnCancellation {
+
+                    pendingCallback = null
+
+                }
+
+            }
+
+        }
+
+    override suspend fun nip44Decrypt(
+        pubkey: String,
+        ciphertext: String
+    ): String =
+        withTimeout(30_000) {
+            val currentUser = getCachedPublicKey()
+            suspendCancellableCoroutine { continuation ->
+
+                pendingCallback = { result ->
+
+                    if (continuation.isActive) {
+                        continuation.resume(result)
+                    }
+                }
+
+                val intent = Intent(
+                    Intent.ACTION_VIEW
+                ).apply {
+
+                    data = Uri.parse(
+                        "nostrsigner:${Uri.encode(ciphertext)}"
+                    )
+
+                    putExtra(
+                        "type",
+                        "nip44_decrypt"
+                    )
+
+                    putExtra(
+                        "pubkey",
+                        pubkey
+                    )
+
+                    putExtra(
+                        "current_user",
+                        currentUser
+                    )
+                }
+
+
+                AppDebugLogger.log(
+                    "NIP44",
+                    "decrypt sender=$pubkey current=$pubkey length=${ciphertext.length}"
+                )
+
+
+                try {
+
+                    launcher.launch(intent)
+
+                } catch (_: ActivityNotFoundException) {
+
+                    if (continuation.isActive) {
+                        continuation.resume("")
+                    }
+                }
+
+
+                continuation.invokeOnCancellation {
+                    pendingCallback = null
+                }
+            }
+        }
+
     fun onResult(
         result: ActivityResult
     ) {
@@ -200,10 +477,44 @@ class AmberSigner(
 
         val value =
 
-            result.data?.getStringExtra("result") ?: result.data?.getStringExtra("signature") ?: ""
+            result.data?.getStringExtra("result")
+
+                ?: result.data?.getStringExtra("event")
+
+                ?: result.data?.getStringExtra("signature")
+
+                ?: result.data?.getStringExtra("plaintext")
+
+                ?: result.data?.getStringExtra("message")
+                ?: result.data?.getStringExtra("content")
+
+                ?: ""
+
+        AppDebugLogger.log(
+
+            "AMBER_RESULT",
+
+            value
+
+        )
+        AppDebugLogger.log(
+
+            "AMBER_RESULT_KEYS",
+
+            result.data?.extras?.keySet()?.joinToString()
+
+                ?: "NO_KEYS"
+
+        )
 
         callback?.invoke(
             value
         )
     }
+
+    private suspend fun getCachedPublicKey(): String {
+
+        return cachedPubkey ?: getPublicKey()
+
+    }
 }

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

@@ -25,4 +25,18 @@ class BunkerSigner(context: Context) : NostrSigner {
     ): String {
         TODO("Not yet implemented")
     }
+
+    override suspend fun nip44Encrypt(
+        pubkey: String,
+        plaintext: String
+    ): String {
+        TODO("Not yet implemented")
+    }
+
+    override suspend fun nip44Decrypt(
+        pubkey: String,
+        ciphertext: String
+    ): String {
+        TODO("Not yet implemented")
+    }
 }

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

@@ -28,4 +28,18 @@ class FakeSigner : NostrSigner {
 
     }
 
+    override suspend fun nip44Encrypt(
+        pubkey: String,
+        plaintext: String
+    ): String {
+        TODO("Not yet implemented")
+    }
+
+    override suspend fun nip44Decrypt(
+        pubkey: String,
+        ciphertext: String
+    ): String {
+        TODO("Not yet implemented")
+    }
+
 }

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

@@ -114,6 +114,195 @@ class NostrBridge(
                 }
             }
 
+            "nip04_encrypt" -> {
+
+                scope.launch {
+
+                    try {
+
+                        require(!payload.isNullOrBlank()) {
+                            "NIP04 encrypt payload is empty"
+                        }
+
+                        val json =
+                            JSONObject(payload)
+
+                        val pubkey =
+                            json.getString("pubkey")
+
+                        val plaintext =
+                            json.getString("plaintext")
+
+
+                        val result =
+                            signerManager
+                                .getSigner()
+                                .nip04Encrypt(
+                                    pubkey,
+                                    plaintext
+                                )
+
+
+                        resolve(
+                            callbackId,
+                            result
+                        )
+
+                    } catch (e: SignerUnavailableException) {
+
+                        resolve(
+                            callbackId,
+                            errorResponse(
+                                "SIGNER_UNAVAILABLE",
+                                e.message ?: "Signer unavailable"
+                            )
+                        )
+
+                    } catch (e: Exception) {
+
+                        resolve(
+                            callbackId,
+                            errorResponse(
+                                "SIGNER_ERROR",
+                                e.message ?: "Unknown signer error"
+                            )
+                        )
+                    }
+                }
+            }
+
+
+            "nip04_decrypt" -> {
+
+                scope.launch {
+
+                    try {
+
+                        require(!payload.isNullOrBlank()) {
+                            "NIP04 decrypt payload is empty"
+                        }
+
+
+                        val json =
+                            JSONObject(payload)
+
+                        val pubkey =
+                            json.getString("pubkey")
+
+                        val ciphertext =
+                            json.getString("ciphertext")
+
+
+                        val result =
+                            signerManager
+                                .getSigner()
+                                .nip04Decrypt(
+                                    pubkey,
+                                    ciphertext
+                                )
+
+
+                        resolve(
+                            callbackId,
+                            result
+                        )
+
+
+                    } catch (e: SignerUnavailableException) {
+
+                        resolve(
+                            callbackId,
+                            errorResponse(
+                                "SIGNER_UNAVAILABLE",
+                                e.message ?: "Signer unavailable"
+                            )
+                        )
+
+                    } catch (e: Exception) {
+
+                        resolve(
+                            callbackId,
+                            errorResponse(
+                                "SIGNER_ERROR",
+                                e.message ?: "Unknown signer error"
+                            )
+                        )
+                    }
+                }
+            }
+
+            "nip44_encrypt" -> {
+
+                scope.launch {
+
+                    try {
+
+                        val json =
+                            JSONObject(payload ?: "")
+
+                        val result =
+                            signerManager
+                                .getSigner()
+                                .nip44Encrypt(
+                                    json.getString("pubkey"),
+                                    json.getString("plaintext")
+                                )
+
+                        resolve(
+                            callbackId,
+                            result
+                        )
+
+
+                    } catch (e: Exception) {
+
+                        resolve(
+                            callbackId,
+                            errorResponse(
+                                "SIGNER_ERROR",
+                                e.message ?: ""
+                            )
+                        )
+                    }
+                }
+            }
+
+            "nip44_decrypt" -> {
+
+                scope.launch {
+
+                    try {
+
+                        val json =
+                            JSONObject(payload ?: "")
+
+                        val result =
+                            signerManager
+                                .getSigner()
+                                .nip44Decrypt(
+                                    json.getString("pubkey"),
+                                    json.getString("ciphertext")
+                                )
+
+                        resolve(
+                            callbackId,
+                            result
+                        )
+
+
+                    } catch (e: Exception) {
+
+                        resolve(
+                            callbackId,
+                            errorResponse(
+                                "SIGNER_ERROR",
+                                e.message ?: ""
+                            )
+                        )
+                    }
+                }
+            }
+
             else -> {
 
                 resolve(

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

@@ -44,6 +44,8 @@ class SignerManager(
 
     private var activeSigner: NostrSigner? = null
 
+    private var currentUserPubkey: String? = null
+
     fun getActiveType(): SignerType? {
 
         val value =
@@ -60,6 +62,26 @@ class SignerManager(
         }
     }
 
+    suspend fun getCurrentUserPubkey(): String {
+
+        currentUserPubkey?.let {
+
+            return it
+
+        }
+
+        val pk =
+
+            getSigner()
+
+                .getPublicKey()
+
+        currentUserPubkey = pk
+
+        return pk
+
+    }
+
     fun setActiveType(
         type: SignerType
     ) {

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

@@ -22,4 +22,14 @@ interface NostrSigner {
 
     ): String
 
+    suspend fun nip44Encrypt(
+        pubkey: String,
+        plaintext: String
+    ): String
+
+    suspend fun nip44Decrypt(
+        pubkey: String,
+        ciphertext: String
+    ): String
+
 }

package/dist/android/permissions.js

@@ -23,10 +23,25 @@ function patchPermissions(androidRoot, manifest) {
             console.warn(`⚠️ Unknown permission: ${perm}`);
             continue;
         }
-        const line = `<uses-permission android:name="${androidPermission}"/>`;
-        if (!xml.includes(line)) {
-            xml = xml.replace("<manifest", `<manifest\n    ${line}`);
+        /**
+         * Check if permission already exists.
+         *
+         * Handles:
+         *
+         * <uses-permission android:name="android.permission.X"/>
+         *
+         * and
+         *
+         * <uses-permission android:name="android.permission.X" />
+         */
+        const exists = new RegExp(`<uses-permission[^>]+android:name="${androidPermission}"[^>]*/>`).test(xml);
+        if (exists) {
+            console.log(`✔ Permission already exists: ${androidPermission}`);
+            continue;
         }
+        const permissionLine = `    <uses-permission android:name="${androidPermission}" />`;
+        xml = xml.replace(/<manifest[^>]*>/, (match) => `${match}\n${permissionLine}`);
+        console.log(`➕ Added permission: ${androidPermission}`);
     }
     fs_1.default.writeFileSync(file, xml);
     console.log("🔐 Permissions patched");

package/package.json

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