@elizaos/capacitor-websiteblocker 1.0.0

package/ios/Sources/WebsiteBlockerPlugin/WebsiteBlockerShared.swift

@@ -0,0 +1,294 @@
+import Foundation
+import SafariServices
+
+struct WebsiteBlockerStoredState: Codable {
+    let websites: [String]
+    let endsAtEpochMs: Double?
+    let requestedWebsites: [String]?
+    let blockedWebsites: [String]?
+    let allowedWebsites: [String]?
+    let matchMode: String?
+}
+
+enum WebsiteBlockerShared {
+    static var appGroupIdentifier: String {
+        "group.\(Bundle.main.bundleIdentifier ?? "ai.elizaos.app")"
+    }
+
+    static var contentBlockerIdentifier: String {
+        "\(Bundle.main.bundleIdentifier ?? "ai.elizaos.app").WebsiteBlockerContentExtension"
+    }
+
+    static let stateKey = "website_blocker_state_v1"
+    static let iso8601Formatter = ISO8601DateFormatter()
+    static let exactMatchMode = "exact"
+    static let subdomainMatchMode = "subdomain"
+    static let xTwitterBlockedWebsites = [
+        "x.com",
+        "www.x.com",
+        "mobile.x.com",
+        "twitter.com",
+        "www.twitter.com",
+        "mobile.twitter.com",
+        "t.co",
+        "abs.twimg.com",
+        "pbs.twimg.com",
+        "video.twimg.com",
+        "ton.twimg.com",
+        "platform.twitter.com",
+        "tweetdeck.twitter.com",
+    ]
+    static let xTwitterAllowedWebsites = [
+        "api.x.com",
+        "api.twitter.com",
+    ]
+    static let googleNewsBlockedWebsites = ["news.google.com"]
+    static let googleNewsAllowedWebsites = [
+        "accounts.google.com",
+        "oauth2.googleapis.com",
+        "openidconnect.googleapis.com",
+        "www.googleapis.com",
+    ]
+
+    static func normalizeHostname(_ value: String) -> String? {
+        let trimmed = value
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+            .trimmingCharacters(in: CharacterSet(charactersIn: "."))
+            .lowercased()
+        guard !trimmed.isEmpty else {
+            return nil
+        }
+        guard trimmed.contains(".") else {
+            return nil
+        }
+        guard trimmed.range(of: "^[a-z0-9.-]+$", options: .regularExpression) != nil else {
+            return nil
+        }
+        guard !trimmed.hasPrefix("."), !trimmed.hasSuffix(".") else {
+            return nil
+        }
+        return trimmed
+    }
+
+    static func parseWebsites(explicit: [Any], text: String?) -> [String] {
+        var websites: [String] = []
+        for value in explicit {
+            if let hostname = value as? String,
+               let normalized = normalizeHostname(hostname) {
+                websites.append(normalized)
+            }
+        }
+
+        if let text, !text.isEmpty {
+            let parts = text.components(separatedBy: CharacterSet.whitespacesAndNewlines.union(CharacterSet(charactersIn: ",")))
+            for part in parts {
+                if let normalized = normalizeHostname(part) {
+                    websites.append(normalized)
+                }
+            }
+        }
+
+        return Array(Set(websites)).sorted()
+    }
+
+    static func parseDurationMinutes(_ rawDuration: Any?) -> Int? {
+        switch rawDuration {
+        case let value as NSNumber:
+            let minutes = value.intValue
+            return minutes > 0 ? minutes : nil
+        case let value as String:
+            guard let minutes = Int(value), minutes > 0 else {
+                return nil
+            }
+            return minutes
+        default:
+            return nil
+        }
+    }
+
+    static func buildPolicy(for requestedWebsites: [String]) -> WebsiteBlockerStoredState {
+        let normalizedRequested = Array(Set(requestedWebsites.compactMap(normalizeHostname))).sorted()
+        var blockedWebsites = Set<String>()
+        var allowedWebsites = Set<String>()
+
+        for website in normalizedRequested {
+            blockedWebsites.insert(website)
+            if shouldAddWwwVariant(website) {
+                blockedWebsites.insert("www.\(website)")
+            }
+
+            if ["x.com", "twitter.com"].contains(website) {
+                blockedWebsites.formUnion(xTwitterBlockedWebsites)
+                allowedWebsites.formUnion(xTwitterAllowedWebsites)
+            } else if website == "news.google.com" {
+                blockedWebsites.formUnion(googleNewsBlockedWebsites)
+                allowedWebsites.formUnion(googleNewsAllowedWebsites)
+            }
+        }
+
+        return WebsiteBlockerStoredState(
+            websites: normalizedRequested,
+            endsAtEpochMs: nil,
+            requestedWebsites: normalizedRequested,
+            blockedWebsites: Array(blockedWebsites).sorted(),
+            allowedWebsites: Array(allowedWebsites).sorted(),
+            matchMode: exactMatchMode
+        )
+    }
+
+    static func sharedDefaults() -> UserDefaults? {
+        UserDefaults(suiteName: appGroupIdentifier)
+    }
+
+    static func loadState() -> WebsiteBlockerStoredState? {
+        guard let defaults = sharedDefaults(),
+              let data = defaults.data(forKey: stateKey) else {
+            return nil
+        }
+
+        guard var decoded = try? JSONDecoder().decode(WebsiteBlockerStoredState.self, from: data) else {
+            defaults.removeObject(forKey: stateKey)
+            return nil
+        }
+
+        if decoded.requestedWebsites == nil || decoded.blockedWebsites == nil || decoded.allowedWebsites == nil || decoded.matchMode == nil {
+            decoded = WebsiteBlockerStoredState(
+                websites: decoded.websites,
+                endsAtEpochMs: decoded.endsAtEpochMs,
+                requestedWebsites: decoded.websites,
+                blockedWebsites: decoded.websites,
+                allowedWebsites: [],
+                matchMode: exactMatchMode
+            )
+        }
+
+        if let endsAtEpochMs = decoded.endsAtEpochMs,
+           endsAtEpochMs <= Date().timeIntervalSince1970 * 1000 {
+            defaults.removeObject(forKey: stateKey)
+            return nil
+        }
+
+        if decoded.websites.isEmpty {
+            defaults.removeObject(forKey: stateKey)
+            return nil
+        }
+
+        return decoded
+    }
+
+    static func saveState(websites: [String], durationMinutes: Int?) throws -> WebsiteBlockerStoredState {
+        let policy = buildPolicy(for: websites)
+        let endsAtEpochMs = durationMinutes.map { Date().timeIntervalSince1970 * 1000 + Double($0 * 60_000) }
+        let state = WebsiteBlockerStoredState(
+            websites: policy.websites,
+            endsAtEpochMs: endsAtEpochMs,
+            requestedWebsites: policy.requestedWebsites,
+            blockedWebsites: policy.blockedWebsites,
+            allowedWebsites: policy.allowedWebsites,
+            matchMode: policy.matchMode
+        )
+
+        guard let defaults = sharedDefaults() else {
+            throw NSError(
+                domain: "ElizaWebsiteBlocker",
+                code: 1,
+                userInfo: [NSLocalizedDescriptionKey: "The iPhone website blocker app group is not available in this build."]
+            )
+        }
+
+        let encoded = try JSONEncoder().encode(state)
+        defaults.set(encoded, forKey: stateKey)
+        return state
+    }
+
+    static func clearState() {
+        sharedDefaults()?.removeObject(forKey: stateKey)
+    }
+
+    static func shouldAddWwwVariant(_ hostname: String) -> Bool {
+        let labels = hostname.split(separator: ".")
+        return labels.count == 2 && labels.first != "www"
+    }
+
+    static func endsAtString(for state: WebsiteBlockerStoredState?) -> String? {
+        guard let endsAtEpochMs = state?.endsAtEpochMs else {
+            return nil
+        }
+        return iso8601Formatter.string(from: Date(timeIntervalSince1970: endsAtEpochMs / 1000))
+    }
+
+    static func buildContentBlockerRules(for websites: [String]) -> [[String: Any]] {
+        let policy = buildPolicy(for: websites)
+        let blockedRules = policy.blockedWebsites?.map { website -> [String: Any] in
+            [
+                "trigger": [
+                    "url-filter": "^https?://([A-Za-z0-9-]+\\\\.)*\(NSRegularExpression.escapedPattern(for: website))([/:?#]|$)",
+                ],
+                "action": [
+                    "type": "block",
+                ],
+            ]
+        } ?? []
+        let allowRules = policy.allowedWebsites?.map { website -> [String: Any] in
+            [
+                "trigger": [
+                    "url-filter": "^https?://([A-Za-z0-9-]+\\\\.)*\(NSRegularExpression.escapedPattern(for: website))([/:?#]|$)",
+                ],
+                "action": [
+                    "type": "ignore-previous-rules",
+                ],
+            ]
+        } ?? []
+        return blockedRules + allowRules
+    }
+
+    static func writeRulesFile() throws -> URL {
+        let websites = loadState()?.websites ?? []
+        let rules = buildContentBlockerRules(for: websites)
+        let data = try JSONSerialization.data(withJSONObject: rules, options: [])
+        let url = FileManager.default.temporaryDirectory
+            .appendingPathComponent("eliza-website-blocker-rules", isDirectory: true)
+            .appendingPathComponent("blockerList.json")
+        try FileManager.default.createDirectory(
+            at: url.deletingLastPathComponent(),
+            withIntermediateDirectories: true,
+            attributes: nil
+        )
+        try data.write(to: url, options: .atomic)
+        return url
+    }
+
+    static func contentBlockerState() async throws -> SFContentBlockerState {
+        try await withCheckedThrowingContinuation { continuation in
+            SFContentBlockerManager.getStateOfContentBlocker(withIdentifier: contentBlockerIdentifier) { state, error in
+                if let error {
+                    continuation.resume(throwing: error)
+                    return
+                }
+                guard let state else {
+                    continuation.resume(
+                        throwing: NSError(
+                            domain: "ElizaWebsiteBlocker",
+                            code: 2,
+                            userInfo: [NSLocalizedDescriptionKey: "Safari did not return the Website Blocker extension state."]
+                        )
+                    )
+                    return
+                }
+                continuation.resume(returning: state)
+            }
+        }
+    }
+
+    static func reloadContentBlocker() async throws {
+        try await withCheckedThrowingContinuation { (continuation: CheckedContinuation<Void, Error>) in
+            SFContentBlockerManager.reloadContentBlocker(withIdentifier: contentBlockerIdentifier) { error in
+                if let error {
+                    continuation.resume(throwing: error)
+                } else {
+                    continuation.resume(returning: ())
+                }
+            }
+        }
+    }
+}

package/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "@elizaos/capacitor-websiteblocker",
+  "version": "1.0.0",
+  "description": "Blocks websites through the Eliza runtime on desktop/web, uses native Android VPN DNS enforcement, and manages a native Safari content blocker on iPhone and iPad.",
+  "keywords": [
+    "website-blocker",
+    "vpn",
+    "dns",
+    "focus"
+  ],
+  "main": "./dist/plugin.cjs.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/esm/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/esm/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "require": "./dist/plugin.cjs.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "unpkg": "dist/plugin.js",
+  "files": [
+    "android/src/main/",
+    "android/build.gradle",
+    "dist/",
+    "ios/Sources/",
+    "*.podspec"
+  ],
+  "scripts": {
+    "build": "npm run clean && tsc && rollup -c rollup.config.mjs",
+    "clean": "rimraf ./dist",
+    "prepublishOnly": "npm run build"
+  },
+  "author": "elizaOS",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/elizaOS/eliza.git",
+    "directory": "apps/app/plugins/websiteblocker"
+  },
+  "capacitor": {
+    "ios": {
+      "src": "ios",
+      "podName": "ElizaosCapacitorWebsiteblocker"
+    },
+    "android": {
+      "src": "android"
+    }
+  },
+  "devDependencies": {
+    "@capacitor/cli": "^8.0.0",
+    "@capacitor/core": "^8.3.1",
+    "rimraf": "^6.0.0",
+    "rollup": "^4.60.2",
+    "typescript": "^6.0.0"
+  },
+  "peerDependencies": {
+    "@capacitor/core": "^8.3.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "elizaos": {
+    "platforms": [
+      "browser",
+      "android",
+      "ios"
+    ],
+    "runtime": "both",
+    "platformDetails": {
+      "browser": "Delegates website blocking to the connected Eliza runtime HTTP API when available",
+      "ios": "Native Safari content blocker managed by the Eliza app with shared block state and Settings-based enablement",
+      "android": "Native split-tunnel VPN DNS blocker with system-wide hostname blocking"
+    }
+  }
+}