pakstr 0.0.1

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

@@ -0,0 +1,125 @@
+package com.nostrappshell.app
+
+import android.content.Context
+import android.util.Log
+import android.webkit.WebView
+import com.nostrappshell.app.signer.SignerManager
+import fi.iki.elonen.NanoHTTPD
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+
+class ShellRuntime(
+    private val context: Context,
+    private val webView: WebView,
+    private val signerManager: SignerManager
+) {
+
+    private val port = Config.PORT
+
+    private var server: LocalServer? = null
+
+    private lateinit var controller: WebViewController
+
+
+    fun start() {
+
+        controller = WebViewController(
+            context,
+            webView,
+            port,
+            signerManager
+        )
+
+
+        CoroutineScope(Dispatchers.IO).launch {
+
+            val ok = startServer()
+
+
+            if (!ok) {
+
+                Log.e(
+                    "RUNTIME",
+                    "Server failed"
+                )
+
+                return@launch
+
+            }
+
+
+            withContext(Dispatchers.Main) {
+
+                controller.setup()
+
+            }
+
+        }
+
+    }
+
+
+    private fun startServer(): Boolean {
+
+        if (server != null)
+            return true
+
+
+        return try {
+
+            server = LocalServer(
+                context,
+                port
+            )
+
+
+            server?.start(
+                NanoHTTPD.SOCKET_READ_TIMEOUT,
+                false
+            )
+
+
+            Log.d(
+                "SERVER",
+                "Started OK"
+            )
+
+
+            true
+
+
+        } catch (e: Exception) {
+
+
+            Log.e(
+                "SERVER",
+                "FAILED TO START",
+                e
+            )
+
+
+            false
+
+        }
+
+    }
+
+
+    fun stop() {
+
+        server?.stop()
+
+        controller.destroy()
+
+    }
+
+
+    fun getWebview(): WebView {
+
+        return webView
+
+    }
+
+}

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

@@ -0,0 +1,139 @@
+package com.nostrappshell.app
+
+import android.app.Activity
+import android.content.Context
+import android.util.Log
+import android.view.View
+import android.webkit.CookieManager
+import android.webkit.WebChromeClient
+import android.webkit.WebResourceRequest
+import android.webkit.WebResourceResponse
+import android.webkit.WebView
+import android.webkit.WebViewClient
+import com.nostrappshell.app.R
+import com.nostrappshell.app.signer.FakeSigner
+import com.nostrappshell.app.signer.NostrBridge
+import com.nostrappshell.app.signer.SignerManager
+import com.nostrappshell.app.signer.interfaces.NostrSigner
+
+class WebViewController(
+
+    private val context: Context,
+
+    private val webView: WebView,
+
+    private val port: Int,
+
+    private val signerManager: SignerManager
+
+) {
+    // Keeps a reference to the runnable to prevent memory leaks if destroyed early
+    private val loadRunnable = Runnable {
+        webView.loadUrl("http://127.0.0.1:$port/")
+        //webView.loadUrl("https://sigit.io")
+    }
+
+    fun setup() {
+        showLoader()
+        setupWebView()
+        loadApp()
+    }
+
+    private fun setupWebView() {
+        webView.apply {
+            // Idiomatically configure WebView settings using scoping functions
+            settings.apply {
+                javaScriptEnabled = true
+                domStorageEnabled = true
+
+                // SECURITY baseline: Prevent access to local files and content providers
+                //allowFileAccess = false
+                //allowContentAccess = false
+
+                allowFileAccess = false
+                allowContentAccess = false
+            }
+
+            // Standard clients are enough since overriding URL loading isn't required
+            webViewClient = object : WebViewClient() {
+
+                override fun onPageFinished(view: WebView?, url: String?) {
+                    super.onPageFinished(view, url)
+                    hideLoader()
+                    val js = context.assets.open("nip07.js")
+
+                        .bufferedReader()
+
+                        .readText()
+
+                    webView.evaluateJavascript(js, null)
+                }
+
+                override fun shouldInterceptRequest(
+
+                    view: WebView?,
+
+                    request: WebResourceRequest?
+
+                ): WebResourceResponse? {
+
+                    val url = request?.url.toString()
+
+                    Log.d("WEB_ASSET", "REQUEST: $url")
+
+                    return super.shouldInterceptRequest(view, request)
+                }
+            }
+            webChromeClient = WebChromeClient()
+        }
+
+        webView.addJavascriptInterface(
+
+            NostrBridge(
+
+                signerManager = signerManager,
+
+                webView = webView
+
+            ),
+
+            "AndroidBridge"
+
+        )
+
+    }
+
+    /**
+     * Loads the local server URL with a minor delay to ensure NanoHTTPD is fully bound.
+     */
+    private fun loadApp() {
+        webView.postDelayed(loadRunnable, 500)
+    }
+
+    private fun showLoader() {
+        (context as? Activity)?.findViewById<View>(R.id.loader)?.visibility = View.VISIBLE
+    }
+
+    private fun hideLoader() {
+        (context as? Activity)?.findViewById<View>(R.id.loader)?.visibility = View.GONE
+    }
+
+    fun destroy() {
+        webView.stopLoading()
+
+        webView.clearCache(true)
+
+        webView.clearHistory()
+
+        CookieManager.getInstance().removeAllCookies(null)
+
+        CookieManager.getInstance().flush()
+
+        webView.loadUrl("about:blank")
+        webView.removeCallbacks(loadRunnable)
+        webView.onPause()
+
+
+        webView.destroy()
+    }
+}

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

@@ -0,0 +1,167 @@
+package com.nostrappshell.app.signer
+
+import android.app.Activity
+import android.content.Context
+import android.content.Intent
+import androidx.activity.result.ActivityResult
+import com.nostrappshell.app.signer.interfaces.NostrSigner
+import kotlinx.coroutines.CancellableContinuation
+import kotlinx.coroutines.suspendCancellableCoroutine
+import kotlin.coroutines.resume
+
+
+class AmberSigner(
+    private val context: Context,
+    private val launchIntent: (Intent) -> Unit
+) : NostrSigner {
+
+
+    private var pendingPublicKey:
+            CancellableContinuation<String>? = null
+
+
+
+    override suspend fun getPublicKey(): String {
+
+        return suspendCancellableCoroutine { cont ->
+
+            pendingPublicKey = cont
+
+            val intent = Intent().apply {
+
+                action =
+
+                    "com.greenart7c3.nostrsigner.GET_PUBLIC_KEY"
+
+            }
+
+            val activities =
+
+                context.packageManager.queryIntentActivities(
+
+                    intent,
+
+                    0
+
+                )
+
+            if (activities.isEmpty()) {
+                activities.forEach {
+
+                    println(
+
+                        "Amber activity: ${it.activityInfo.packageName}/${it.activityInfo.name}"
+
+                    )
+
+                }
+                pendingPublicKey = null
+
+                cont.resumeWith(
+
+                    Result.failure(
+
+                        Exception(
+
+                            "Amber signer is not installed. Please install Amber to continue."
+
+                        )
+
+                    )
+
+                )
+
+                return@suspendCancellableCoroutine
+
+            }
+
+            launchIntent(intent)
+
+        }
+
+    }
+
+
+
+    fun handleResult(
+        result: ActivityResult
+    ) {
+
+        if (result.resultCode != Activity.RESULT_OK) {
+
+            pendingPublicKey?.resumeWith(
+                Result.failure(
+                    Exception(
+                        "Amber cancelled"
+                    )
+                )
+            )
+
+            pendingPublicKey = null
+
+            return
+
+        }
+
+
+        val pubkey =
+            result.data
+                ?.getStringExtra("pubkey")
+
+
+        if (pubkey != null) {
+
+            pendingPublicKey?.resume(
+                pubkey
+            )
+
+        } else {
+
+            pendingPublicKey?.resumeWith(
+                Result.failure(
+                    Exception(
+                        "No public key returned"
+                    )
+                )
+            )
+
+        }
+
+
+        pendingPublicKey = null
+
+    }
+
+
+
+    override suspend fun signEvent(
+        eventJson: String
+    ): String {
+
+        TODO()
+
+    }
+
+
+
+    override suspend fun nip04Encrypt(
+        pubkey: String,
+        plaintext: String
+    ): String {
+
+        TODO()
+
+    }
+
+
+
+    override suspend fun nip04Decrypt(
+        pubkey: String,
+        ciphertext: String
+    ): String {
+
+        TODO()
+
+    }
+
+}

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

@@ -0,0 +1,28 @@
+package com.nostrappshell.app.signer
+
+import android.content.Context
+import com.nostrappshell.app.signer.interfaces.NostrSigner
+
+class BunkerSigner(context: Context) : NostrSigner {
+    override suspend fun getPublicKey(): String {
+        TODO("Not yet implemented")
+    }
+
+    override suspend fun signEvent(eventJson: String): String {
+        TODO("Not yet implemented")
+    }
+
+    override suspend fun nip04Encrypt(
+        pubkey: String,
+        plaintext: String
+    ): String {
+        TODO("Not yet implemented")
+    }
+
+    override suspend fun nip04Decrypt(
+        pubkey: String,
+        ciphertext: String
+    ): String {
+        TODO("Not yet implemented")
+    }
+}

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

@@ -0,0 +1,31 @@
+package com.nostrappshell.app.signer
+
+import com.nostrappshell.app.signer.interfaces.NostrSigner
+
+class FakeSigner : NostrSigner {
+
+    override suspend fun getPublicKey(): String {
+
+        return "npub1fake123"
+
+    }
+
+    override suspend fun signEvent(eventJson: String): String {
+
+        return """{"sig":"fake_signature"}"""
+
+    }
+
+    override suspend fun nip04Encrypt(pubkey: String, plaintext: String): String {
+
+        return "encrypted_fake"
+
+    }
+
+    override suspend fun nip04Decrypt(pubkey: String, ciphertext: String): String {
+
+        return "decrypted_fake"
+
+    }
+
+}

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

@@ -0,0 +1,97 @@
+package com.nostrappshell.app.signer
+
+import android.os.Handler
+import android.os.Looper
+import android.webkit.JavascriptInterface
+import android.webkit.WebView
+import android.widget.Toast
+import com.nostrappshell.app.signer.interfaces.NostrSigner
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+
+class NostrBridge(
+
+    private val webView: WebView,
+
+    private val signerManager: SignerManager
+
+) {
+
+    private val mainHandler = Handler(Looper.getMainLooper())
+
+    @JavascriptInterface
+    fun call(method: String, callbackId: String, payload: String?) {
+
+        when (method) {
+
+            "getPublicKey" -> {
+
+                CoroutineScope(Dispatchers.IO).launch {
+
+                    try {
+
+                        val pk = signerManager
+
+                            .getSigner()
+
+                            .getPublicKey()
+
+                        resolve(callbackId, pk)
+
+                    } catch (e: Exception) {
+
+                        showToast(
+
+                            e.message ?: "Signer error"
+
+                        )
+
+                        resolve(
+
+                            callbackId,
+
+                            ""
+
+                        )
+
+                    }
+
+                }
+
+            }
+
+            "signEvent" -> {
+                CoroutineScope(Dispatchers.IO).launch {
+                    val result = signerManager.getSigner().signEvent(payload ?: "")
+                    resolve(callbackId, result)
+                }
+            }
+        }
+    }
+
+    private fun resolve(callbackId: String, result: String) {
+        mainHandler.post {
+            val js = "window.__nostrResolve('$callbackId', '$result')"
+            webView.evaluateJavascript(js, null)
+        }
+    }
+
+    private fun showToast(message: String) {
+
+        mainHandler.post {
+
+            Toast.makeText(
+
+                webView.context,
+
+                message,
+
+                Toast.LENGTH_LONG
+
+            ).show()
+
+        }
+
+    }
+}