@elizaos/capacitor-websiteblocker 1.0.0

package/ElizaosCapacitorWebsiteBlocker.podspec

@@ -0,0 +1,17 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name = 'ElizaosCapacitorWebsiteblocker'
+  s.version = package['version']
+  s.summary = package['description']
+  s.license = package['license'] || { :type => 'MIT' }
+  s.homepage = 'https://elizaos.ai'
+  s.authors = { 'elizaOS' => 'dev@elizaos.ai' }
+  s.source = { :git => 'https://github.com/elizaOS/eliza.git', :tag => s.version.to_s }
+  s.source_files = 'ios/Sources/**/*.{swift,h,m,c,cc,mm,cpp}'
+  s.ios.deployment_target = '15.0'
+  s.dependency 'Capacitor'
+  s.swift_version = '5.1'
+end

package/android/build.gradle

@@ -0,0 +1,51 @@
+ext {
+    junitVersion = project.hasProperty('junitVersion') ? rootProject.ext.junitVersion : '4.13.2'
+    androidxAppCompatVersion = project.hasProperty('androidxAppCompatVersion') ? rootProject.ext.androidxAppCompatVersion : '1.6.1'
+    androidxCoreVersion = project.hasProperty('androidxCoreVersion') ? rootProject.ext.androidxCoreVersion : '1.12.0'
+    androidxJunitVersion = project.hasProperty('androidxJunitVersion') ? rootProject.ext.androidxJunitVersion : '1.1.5'
+    androidxEspressoCoreVersion = project.hasProperty('androidxEspressoCoreVersion') ? rootProject.ext.androidxEspressoCoreVersion : '3.5.1'
+}
+
+apply plugin: 'com.android.library'
+android {
+    namespace = "ai.eliza.plugins.websiteblocker"
+    compileSdk project.hasProperty('compileSdkVersion') ? rootProject.ext.compileSdkVersion : 34
+
+    defaultConfig {
+        minSdkVersion project.hasProperty('minSdkVersion') ? rootProject.ext.minSdkVersion : 24
+        targetSdkVersion project.hasProperty('targetSdkVersion') ? rootProject.ext.targetSdkVersion : 34
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+    }
+
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
+        }
+    }
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
+    }
+
+}
+
+repositories {
+    google()
+    maven {
+        url = uri(rootProject.ext.mavenCentralMirrorUrl)
+    }
+    mavenCentral()
+}
+
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation project(':capacitor-android')
+    implementation "androidx.appcompat:appcompat:$androidxAppCompatVersion"
+    implementation "androidx.core:core-ktx:$androidxCoreVersion"
+
+    testImplementation "junit:junit:$junitVersion"
+    androidTestImplementation "androidx.test.ext:junit:$androidxJunitVersion"
+    androidTestImplementation "androidx.test.espresso:espresso-core:$androidxEspressoCoreVersion"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,35 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_SPECIAL_USE" />
+    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
+    <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
+
+    <application>
+        <service
+            android:name=".WebsiteBlockerVpnService"
+            android:enabled="true"
+            android:exported="false"
+            android:foregroundServiceType="specialUse"
+            android:permission="android.permission.BIND_VPN_SERVICE">
+            <intent-filter>
+                <action android:name="android.net.VpnService" />
+            </intent-filter>
+
+            <property
+                android:name="android.app.PROPERTY_SPECIAL_USE_FGS_SUBTYPE"
+                android:value="website_blocking_vpn" />
+        </service>
+
+        <receiver
+            android:name=".WebsiteBlockerBootReceiver"
+            android:enabled="true"
+            android:exported="false">
+            <intent-filter>
+                <action android:name="android.intent.action.BOOT_COMPLETED" />
+                <action android:name="android.intent.action.LOCKED_BOOT_COMPLETED" />
+                <action android:name="android.intent.action.MY_PACKAGE_REPLACED" />
+            </intent-filter>
+        </receiver>
+    </application>
+</manifest>

package/android/src/main/java/ai/eliza/plugins/websiteblocker/DnsPacketCodec.kt

@@ -0,0 +1,170 @@
+package ai.eliza.plugins.websiteblocker
+
+import java.net.Inet4Address
+
+data class DnsQueryPacket(
+    val sourceAddress: ByteArray,
+    val destinationAddress: ByteArray,
+    val sourcePort: Int,
+    val destinationPort: Int,
+    val dnsPayload: ByteArray,
+    val queryName: String,
+)
+
+object DnsPacketCodec {
+    private const val IPV4_HEADER_SIZE = 20
+    private const val UDP_HEADER_SIZE = 8
+
+    fun parseUdpDnsQuery(
+        packet: ByteArray,
+        length: Int,
+        expectedDnsAddress: Inet4Address,
+    ): DnsQueryPacket? {
+        if (length < IPV4_HEADER_SIZE + UDP_HEADER_SIZE + 12) {
+            return null
+        }
+
+        val version = (packet[0].toInt() ushr 4) and 0x0F
+        val headerLength = (packet[0].toInt() and 0x0F) * 4
+        if (version != 4 || headerLength < IPV4_HEADER_SIZE || length < headerLength + UDP_HEADER_SIZE) {
+            return null
+        }
+
+        val protocol = packet[9].toInt() and 0xFF
+        if (protocol != 17) {
+            return null
+        }
+
+        val destinationAddress = packet.copyOfRange(16, 20)
+        if (!destinationAddress.contentEquals(expectedDnsAddress.address)) {
+            return null
+        }
+
+        val udpOffset = headerLength
+        val sourcePort = readUInt16(packet, udpOffset)
+        val destinationPort = readUInt16(packet, udpOffset + 2)
+        if (destinationPort != 53) {
+            return null
+        }
+
+        val udpLength = readUInt16(packet, udpOffset + 4)
+        if (udpLength < UDP_HEADER_SIZE || udpOffset + udpLength > length) {
+            return null
+        }
+
+        val dnsOffset = udpOffset + UDP_HEADER_SIZE
+        val dnsPayload = packet.copyOfRange(dnsOffset, dnsOffset + udpLength - UDP_HEADER_SIZE)
+        val queryName = parseQueryName(dnsPayload) ?: return null
+
+        return DnsQueryPacket(
+            sourceAddress = packet.copyOfRange(12, 16),
+            destinationAddress = destinationAddress,
+            sourcePort = sourcePort,
+            destinationPort = destinationPort,
+            dnsPayload = dnsPayload,
+            queryName = queryName,
+        )
+    }
+
+    fun buildBlockedDnsResponse(queryPayload: ByteArray): ByteArray {
+        val response = queryPayload.copyOf()
+        response[2] = (response[2].toInt() or 0x80).toByte()
+        response[3] = ((response[3].toInt() and 0xF0) or 0x03).toByte()
+        response[6] = 0
+        response[7] = 0
+        response[8] = 0
+        response[9] = 0
+        response[10] = 0
+        response[11] = 0
+        return response
+    }
+
+    fun buildServerFailureDnsResponse(queryPayload: ByteArray): ByteArray {
+        val response = queryPayload.copyOf()
+        response[2] = (response[2].toInt() or 0x80).toByte()
+        response[3] = ((response[3].toInt() and 0xF0) or 0x02).toByte()
+        response[6] = 0
+        response[7] = 0
+        response[8] = 0
+        response[9] = 0
+        response[10] = 0
+        response[11] = 0
+        return response
+    }
+
+    fun buildUdpDnsResponse(query: DnsQueryPacket, dnsPayload: ByteArray): ByteArray {
+        val udpLength = UDP_HEADER_SIZE + dnsPayload.size
+        val totalLength = IPV4_HEADER_SIZE + udpLength
+        val response = ByteArray(totalLength)
+
+        response[0] = 0x45
+        response[1] = 0
+        writeUInt16(response, 2, totalLength)
+        writeUInt16(response, 4, 0)
+        writeUInt16(response, 6, 0)
+        response[8] = 64
+        response[9] = 17
+        writeUInt16(response, 10, 0)
+
+        System.arraycopy(query.destinationAddress, 0, response, 12, 4)
+        System.arraycopy(query.sourceAddress, 0, response, 16, 4)
+        writeUInt16(response, IPV4_HEADER_SIZE, query.destinationPort)
+        writeUInt16(response, IPV4_HEADER_SIZE + 2, query.sourcePort)
+        writeUInt16(response, IPV4_HEADER_SIZE + 4, udpLength)
+        writeUInt16(response, IPV4_HEADER_SIZE + 6, 0)
+        System.arraycopy(dnsPayload, 0, response, IPV4_HEADER_SIZE + UDP_HEADER_SIZE, dnsPayload.size)
+
+        val checksum = computeIpv4HeaderChecksum(response, IPV4_HEADER_SIZE)
+        writeUInt16(response, 10, checksum)
+        return response
+    }
+
+    private fun parseQueryName(payload: ByteArray): String? {
+        if (payload.size < 12) {
+            return null
+        }
+        var offset = 12
+        val labels = mutableListOf<String>()
+        while (offset < payload.size) {
+            val length = payload[offset].toInt() and 0xFF
+            if (length == 0) {
+                return labels.joinToString(".")
+            }
+            if (length and 0xC0 != 0 || offset + 1 + length > payload.size) {
+                return null
+            }
+            val label = payload.copyOfRange(offset + 1, offset + 1 + length)
+                .toString(Charsets.UTF_8)
+            labels += label
+            offset += length + 1
+        }
+        return null
+    }
+
+    private fun readUInt16(buffer: ByteArray, offset: Int): Int {
+        return ((buffer[offset].toInt() and 0xFF) shl 8) or
+            (buffer[offset + 1].toInt() and 0xFF)
+    }
+
+    private fun writeUInt16(buffer: ByteArray, offset: Int, value: Int) {
+        buffer[offset] = ((value ushr 8) and 0xFF).toByte()
+        buffer[offset + 1] = (value and 0xFF).toByte()
+    }
+
+    private fun computeIpv4HeaderChecksum(packet: ByteArray, headerLength: Int): Int {
+        var sum = 0
+        var offset = 0
+        while (offset < headerLength) {
+            if (offset == 10) {
+                offset += 2
+                continue
+            }
+            sum += readUInt16(packet, offset)
+            while (sum > 0xFFFF) {
+                sum = (sum and 0xFFFF) + (sum ushr 16)
+            }
+            offset += 2
+        }
+        return sum.inv() and 0xFFFF
+    }
+}

package/android/src/main/java/ai/eliza/plugins/websiteblocker/WebsiteBlockerBootReceiver.kt

@@ -0,0 +1,39 @@
+package ai.eliza.plugins.websiteblocker
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import androidx.core.content.ContextCompat
+
+class WebsiteBlockerBootReceiver : BroadcastReceiver() {
+    override fun onReceive(context: Context, intent: Intent) {
+        val action = intent.action ?: return
+        if (
+            action != Intent.ACTION_BOOT_COMPLETED &&
+            action != Intent.ACTION_LOCKED_BOOT_COMPLETED &&
+            action != Intent.ACTION_MY_PACKAGE_REPLACED
+        ) {
+            return
+        }
+
+        val savedBlock = WebsiteBlockerStateStore.load(context) ?: return
+        if (android.net.VpnService.prepare(context) != null) {
+            return
+        }
+
+        ContextCompat.startForegroundService(
+            context,
+            Intent(context, WebsiteBlockerVpnService::class.java).apply {
+                this.action = WebsiteBlockerVpnService.ACTION_START
+                putStringArrayListExtra(
+                    WebsiteBlockerVpnService.EXTRA_WEBSITES,
+                    ArrayList(savedBlock.requestedWebsites),
+                )
+                putExtra(
+                    WebsiteBlockerVpnService.EXTRA_ENDS_AT,
+                    savedBlock.endsAtEpochMs ?: -1L,
+                )
+            },
+        )
+    }
+}

package/android/src/main/java/ai/eliza/plugins/websiteblocker/WebsiteBlockerPlugin.kt

@@ -0,0 +1,277 @@
+package ai.eliza.plugins.websiteblocker
+
+import android.content.Intent
+import android.net.VpnService
+import android.os.Build
+import android.provider.Settings
+import androidx.activity.result.ActivityResult
+import androidx.core.content.ContextCompat
+import com.getcapacitor.JSArray
+import com.getcapacitor.JSObject
+import com.getcapacitor.Plugin
+import com.getcapacitor.PluginCall
+import com.getcapacitor.PluginMethod
+import com.getcapacitor.annotation.ActivityCallback
+import com.getcapacitor.annotation.CapacitorPlugin
+import java.time.Instant
+
+@CapacitorPlugin(name = "ElizaWebsiteBlocker")
+class WebsiteBlockerPlugin : Plugin() {
+    private data class PendingStartRequest(
+        val websites: List<String>,
+        val endsAtEpochMs: Long?,
+    )
+
+    private var pendingStartRequest: PendingStartRequest? = null
+
+    @PluginMethod
+    fun getStatus(call: PluginCall) {
+        call.resolve(buildStatus())
+    }
+
+    @PluginMethod
+    fun startBlock(call: PluginCall) {
+        val websites = extractWebsites(call)
+        if (websites.isEmpty()) {
+            call.resolve(JSObject().apply {
+                put("success", false)
+                put("error", "Provide at least one public website hostname, such as x.com or twitter.com.")
+            })
+            return
+        }
+
+        val durationMinutes = parseDurationMinutes(call)
+        val endsAtEpochMs = durationMinutes?.let { System.currentTimeMillis() + it * 60_000 }
+        val permissionIntent = VpnService.prepare(context)
+        if (permissionIntent != null) {
+            pendingStartRequest = PendingStartRequest(websites, endsAtEpochMs)
+            startActivityForResult(call, permissionIntent, "handleVpnPermissionResult")
+            return
+        }
+
+        startBlockInternal(websites, endsAtEpochMs)
+        call.resolve(buildStartResult(websites, durationMinutes, endsAtEpochMs))
+    }
+
+    @PluginMethod
+    fun stopBlock(call: PluginCall) {
+        WebsiteBlockerStateStore.clear(context)
+        context.stopService(Intent(context, WebsiteBlockerVpnService::class.java).apply {
+            action = WebsiteBlockerVpnService.ACTION_STOP
+        })
+
+        call.resolve(JSObject().apply {
+            put("success", true)
+            put("removed", true)
+            put("status", JSObject().apply {
+                put("active", false)
+                put("endsAt", null)
+                put("websites", JSArray())
+                put("requestedWebsites", JSArray())
+                put("blockedWebsites", JSArray())
+                put("allowedWebsites", JSArray())
+                put("matchMode", "exact")
+                put("canUnblockEarly", true)
+                put("requiresElevation", permissionRequiresConsent())
+            })
+        })
+    }
+
+    @PluginMethod
+    override fun checkPermissions(call: PluginCall) {
+        call.resolve(buildPermissionResult())
+    }
+
+    @PluginMethod
+    override fun requestPermissions(call: PluginCall) {
+        val permissionIntent = VpnService.prepare(context)
+        if (permissionIntent == null) {
+            call.resolve(buildPermissionResult())
+            return
+        }
+        startActivityForResult(call, permissionIntent, "handleVpnPermissionResult")
+    }
+
+    @PluginMethod
+    fun openSettings(call: PluginCall) {
+        val activity = activity
+        if (activity == null) {
+            call.resolve(JSObject().apply {
+                put("opened", false)
+            })
+            return
+        }
+
+        activity.startActivity(Intent(Settings.ACTION_VPN_SETTINGS))
+        call.resolve(JSObject().apply {
+            put("opened", true)
+        })
+    }
+
+    @ActivityCallback
+    private fun handleVpnPermissionResult(call: PluginCall, result: ActivityResult) {
+        if (result.resultCode != android.app.Activity.RESULT_OK) {
+            if (pendingStartRequest != null) {
+                pendingStartRequest = null
+                call.resolve(JSObject().apply {
+                    put("success", false)
+                    put("error", "Android VPN consent was not granted.")
+                })
+                return
+            }
+
+            call.resolve(buildPermissionResult())
+            return
+        }
+
+        val pendingStart = pendingStartRequest
+        if (pendingStart != null) {
+            pendingStartRequest = null
+            startBlockInternal(
+                pendingStart.websites,
+                pendingStart.endsAtEpochMs,
+            )
+            call.resolve(
+                buildStartResult(
+                    pendingStart.websites,
+                    durationMinutesFromEndsAt(pendingStart.endsAtEpochMs),
+                    pendingStart.endsAtEpochMs,
+                ),
+            )
+            return
+        }
+
+        call.resolve(buildPermissionResult())
+    }
+
+    private fun startBlockInternal(
+        websites: List<String>,
+        endsAtEpochMs: Long?,
+    ) {
+        WebsiteBlockerStateStore.save(context, websites, endsAtEpochMs)
+        val serviceIntent = Intent(context, WebsiteBlockerVpnService::class.java).apply {
+            action = WebsiteBlockerVpnService.ACTION_START
+            putStringArrayListExtra(
+                WebsiteBlockerVpnService.EXTRA_WEBSITES,
+                ArrayList(websites),
+            )
+            putExtra(
+                WebsiteBlockerVpnService.EXTRA_ENDS_AT,
+                endsAtEpochMs ?: -1L,
+            )
+        }
+        ContextCompat.startForegroundService(context, serviceIntent)
+    }
+
+    private fun durationMinutesFromEndsAt(endsAtEpochMs: Long?): Long? {
+        if (endsAtEpochMs == null) return null
+        val remainingMs = endsAtEpochMs - System.currentTimeMillis()
+        return if (remainingMs <= 0) 0 else kotlin.math.ceil(remainingMs / 60_000.0).toLong()
+    }
+
+    private fun buildStartResult(
+        websites: List<String>,
+        durationMinutes: Long?,
+        endsAtEpochMs: Long?,
+    ): JSObject {
+        return JSObject().apply {
+            put("success", true)
+            put(
+                "endsAt",
+                endsAtEpochMs?.let { Instant.ofEpochMilli(it).toString() },
+            )
+            put("request", JSObject().apply {
+                put("websites", JSArray(websites))
+                put("durationMinutes", durationMinutes)
+            })
+        }
+    }
+
+    private fun buildPermissionResult(): JSObject {
+        val granted = !permissionRequiresConsent()
+        return JSObject().apply {
+            put("status", if (granted) "granted" else "not-determined")
+            put("canRequest", !granted)
+            if (!granted) {
+                put(
+                    "reason",
+                    "Android needs VPN consent before Eliza can block websites system-wide on this phone.",
+                )
+            }
+        }
+    }
+
+    private fun buildStatus(): JSObject {
+        val saved = WebsiteBlockerStateStore.load(context)
+        val permission = buildPermissionResult()
+        return JSObject().apply {
+            put("available", true)
+            put("active", saved != null)
+            put("hostsFilePath", null)
+            put(
+                "endsAt",
+                saved?.endsAtEpochMs?.let { Instant.ofEpochMilli(it).toString() },
+            )
+            put("websites", JSArray(saved?.requestedWebsites ?: emptyList<String>()))
+            put("requestedWebsites", JSArray(saved?.requestedWebsites ?: emptyList<String>()))
+            put("blockedWebsites", JSArray(saved?.blockedWebsites ?: emptyList<String>()))
+            put("allowedWebsites", JSArray(saved?.allowedWebsites ?: emptyList<String>()))
+            put("matchMode", saved?.matchMode ?: "exact")
+            put("canUnblockEarly", true)
+            put("requiresElevation", permissionRequiresConsent())
+            put("engine", "vpn-dns")
+            put("platform", "android")
+            put("supportsElevationPrompt", permissionRequiresConsent())
+            put(
+                "elevationPromptMethod",
+                if (permissionRequiresConsent()) "vpn-consent" else null,
+            )
+            put("permissionStatus", permission.getString("status"))
+            put("canRequestPermission", permission.getBool("canRequest"))
+            put("canOpenSystemSettings", true)
+            val reason = when {
+                saved != null && !WebsiteBlockerVpnService.isRunning() ->
+                    "Website blocking is configured and the VPN service is reconnecting."
+                permissionRequiresConsent() ->
+                    permission.getString("reason")
+                else -> null
+            }
+            if (reason != null) {
+                put("reason", reason)
+            }
+        }
+    }
+
+    private fun extractWebsites(call: PluginCall): List<String> {
+        val websites = mutableListOf<String>()
+        val explicitWebsites = call.data.optJSONArray("websites")
+        if (explicitWebsites != null) {
+            for (index in 0 until explicitWebsites.length()) {
+                val value = explicitWebsites.optString(index)
+                WebsiteBlockerStateStore.normalizeHostname(value)?.let(websites::add)
+            }
+        }
+
+        val text = call.getString("text")
+        if (!text.isNullOrBlank()) {
+            text.split(Regex("[\\s,]+"))
+                .mapNotNull(WebsiteBlockerStateStore::normalizeHostname)
+                .forEach(websites::add)
+        }
+
+        return websites.distinct()
+    }
+
+    private fun parseDurationMinutes(call: PluginCall): Long? {
+        val rawValue = call.data.opt("durationMinutes") ?: return null
+        return when (rawValue) {
+            is Number -> rawValue.toLong()
+            is String -> rawValue.toLongOrNull()
+            else -> null
+        }?.takeIf { it > 0 }
+    }
+
+    private fun permissionRequiresConsent(): Boolean {
+        return VpnService.prepare(context) != null
+    }
+}