@capgo/inappbrowser 8.2.0 → 8.3.0-alpha.0

package/ios/Sources/InAppBrowserPlugin/ProxySchemeHandler.swift

@@ -0,0 +1,257 @@
+import Foundation
+import WebKit
+import Capacitor
+
+public class ProxySchemeHandler: NSObject, WKURLSchemeHandler {
+    weak var plugin: InAppBrowserPlugin?
+    private var pendingTasks: [String: WKURLSchemeTask] = [:]
+    private var pendingBodies: [String: Data] = [:]
+    private var pendingNetworkTasks: [String: URLSessionDataTask] = [:]
+    private var stoppedRequests: Set<String> = []
+    private let taskLock = NSLock()
+    private let webviewId: String
+    private let proxyTimeoutSeconds: TimeInterval = 10
+
+    init(plugin: InAppBrowserPlugin, webviewId: String) {
+        self.plugin = plugin
+        self.webviewId = webviewId
+        super.init()
+    }
+
+    public func webView(_ webView: WKWebView, start urlSchemeTask: WKURLSchemeTask) {
+        let request = urlSchemeTask.request
+        guard let url = request.url else {
+            urlSchemeTask.didFailWithError(NSError(
+                domain: "ProxySchemeHandler",
+                code: -1,
+                userInfo: [NSLocalizedDescriptionKey: "No URL in request"]
+            ))
+            return
+        }
+
+        let requestId = UUID().uuidString
+
+        taskLock.lock()
+        pendingTasks[requestId] = urlSchemeTask
+        taskLock.unlock()
+
+        // Encode body to base64, buffering stream data for later pass-through
+        var base64Body: String? = nil
+        if let bodyData = request.httpBody {
+            base64Body = bodyData.base64EncodedString()
+        } else if let bodyStream = request.httpBodyStream {
+            let data = Data(reading: bodyStream)
+            if !data.isEmpty {
+                base64Body = data.base64EncodedString()
+                taskLock.lock()
+                pendingBodies[requestId] = data
+                taskLock.unlock()
+            }
+        }
+
+        // Build headers dict
+        var headers: [String: String] = [:]
+        if let allHeaders = request.allHTTPHeaderFields {
+            headers = allHeaders
+        }
+
+        let eventData: [String: Any] = [
+            "requestId": requestId,
+            "url": url.absoluteString,
+            "method": request.httpMethod ?? "GET",
+            "headers": headers,
+            "body": base64Body as Any,
+            "webviewId": webviewId,
+        ]
+
+        plugin?.notifyListeners("proxyRequest", data: eventData)
+
+        // Timeout: if JS never responds, fail the request after proxyTimeoutSeconds
+        DispatchQueue.global().asyncAfter(deadline: .now() + proxyTimeoutSeconds) { [weak self] in
+            guard let self = self else { return }
+            self.taskLock.lock()
+            guard let task = self.pendingTasks.removeValue(forKey: requestId) else {
+                self.taskLock.unlock()
+                return
+            }
+            self.pendingBodies.removeValue(forKey: requestId)
+            self.taskLock.unlock()
+
+            print("[InAppBrowser] Proxy request timed out after \(Int(self.proxyTimeoutSeconds))s: \(requestId)")
+            task.didFailWithError(NSError(
+                domain: "ProxySchemeHandler",
+                code: NSURLErrorTimedOut,
+                userInfo: [NSLocalizedDescriptionKey: "Proxy handler did not respond within \(Int(self.proxyTimeoutSeconds)) seconds"]
+            ))
+        }
+    }
+
+    public func webView(_ webView: WKWebView, stop urlSchemeTask: WKURLSchemeTask) {
+        taskLock.lock()
+        let requestIdToRemove = pendingTasks.first(where: { $0.value === urlSchemeTask })?.key
+        var networkTask: URLSessionDataTask?
+        if let key = requestIdToRemove {
+            pendingTasks.removeValue(forKey: key)
+            pendingBodies.removeValue(forKey: key)
+            networkTask = pendingNetworkTasks.removeValue(forKey: key)
+            stoppedRequests.insert(key)
+        }
+        taskLock.unlock()
+        networkTask?.cancel()
+    }
+
+    /// Called from handleProxyRequest plugin method with the JS response
+    func handleResponse(requestId: String, responseData: [String: Any]?) {
+        taskLock.lock()
+        let isStopped = stoppedRequests.remove(requestId) != nil
+        guard let urlSchemeTask = pendingTasks[requestId] else {
+            pendingTasks.removeValue(forKey: requestId)
+            pendingBodies.removeValue(forKey: requestId)
+            taskLock.unlock()
+            return
+        }
+        let bufferedBody = pendingBodies.removeValue(forKey: requestId)
+
+        if isStopped {
+            pendingTasks.removeValue(forKey: requestId)
+            taskLock.unlock()
+            return
+        }
+
+        if responseData != nil {
+            // JS provided a response — remove from pending now
+            pendingTasks.removeValue(forKey: requestId)
+        }
+        // For pass-through (nil), keep pendingTasks entry so stop can find it
+        taskLock.unlock()
+
+        if let responseData = responseData {
+            let statusCode = responseData["status"] as? Int ?? 200
+            let headersDict = responseData["headers"] as? [String: String] ?? [:]
+            let base64Body = responseData["body"] as? String ?? ""
+
+            let bodyData = Data(base64Encoded: base64Body) ?? Data()
+
+            guard let url = urlSchemeTask.request.url else {
+                urlSchemeTask.didFailWithError(NSError(
+                    domain: "ProxySchemeHandler",
+                    code: -1,
+                    userInfo: [NSLocalizedDescriptionKey: "No URL"]
+                ))
+                return
+            }
+
+            guard let httpResponse = HTTPURLResponse(
+                url: url,
+                statusCode: statusCode,
+                httpVersion: "HTTP/1.1",
+                headerFields: headersDict
+            ) else {
+                urlSchemeTask.didFailWithError(NSError(
+                    domain: "ProxySchemeHandler",
+                    code: -2,
+                    userInfo: [NSLocalizedDescriptionKey: "Failed to create response"]
+                ))
+                return
+            }
+
+            urlSchemeTask.didReceive(httpResponse)
+            urlSchemeTask.didReceive(bodyData)
+            urlSchemeTask.didFinish()
+        } else {
+            // Null response = pass-through via URLSession
+            executePassThrough(requestId: requestId, urlSchemeTask: urlSchemeTask, bufferedBody: bufferedBody)
+        }
+    }
+
+    private func executePassThrough(requestId: String, urlSchemeTask: WKURLSchemeTask, bufferedBody: Data?) {
+        var request = urlSchemeTask.request
+        // Restore body if it was consumed from httpBodyStream during interception
+        if request.httpBody == nil, let body = bufferedBody {
+            request.httpBody = body
+        }
+        let session = URLSession.shared
+        let task = session.dataTask(with: request) { [weak self] data, response, error in
+            guard let self = self else { return }
+
+            // Clean up and check if this request was stopped while in-flight
+            self.taskLock.lock()
+            self.pendingTasks.removeValue(forKey: requestId)
+            self.pendingNetworkTasks.removeValue(forKey: requestId)
+            let wasStopped = self.stoppedRequests.remove(requestId) != nil
+            self.taskLock.unlock()
+
+            if wasStopped {
+                return
+            }
+
+            if let error = error {
+                if (error as NSError).code == NSURLErrorCancelled {
+                    return
+                }
+                urlSchemeTask.didFailWithError(error)
+                return
+            }
+
+            guard let httpResponse = response as? HTTPURLResponse else {
+                urlSchemeTask.didFailWithError(NSError(
+                    domain: "ProxySchemeHandler",
+                    code: -3,
+                    userInfo: [NSLocalizedDescriptionKey: "Non-HTTP response"]
+                ))
+                return
+            }
+
+            urlSchemeTask.didReceive(httpResponse)
+            if let data = data {
+                urlSchemeTask.didReceive(data)
+            }
+            urlSchemeTask.didFinish()
+        }
+
+        taskLock.lock()
+        pendingNetworkTasks[requestId] = task
+        taskLock.unlock()
+        task.resume()
+    }
+
+    func cancelAllPendingTasks() {
+        taskLock.lock()
+        let tasks = pendingTasks
+        let networkTasks = pendingNetworkTasks
+        pendingTasks.removeAll()
+        pendingBodies.removeAll()
+        pendingNetworkTasks.removeAll()
+        stoppedRequests.removeAll()
+        taskLock.unlock()
+
+        for (_, networkTask) in networkTasks {
+            networkTask.cancel()
+        }
+        for (_, task) in tasks {
+            task.didFailWithError(NSError(
+                domain: "ProxySchemeHandler",
+                code: NSURLErrorCancelled,
+                userInfo: [NSLocalizedDescriptionKey: "WebView closed"]
+            ))
+        }
+    }
+}
+
+extension Data {
+    init(reading input: InputStream) {
+        self.init()
+        input.open()
+        let bufferSize = 1024
+        let buffer = UnsafeMutablePointer<UInt8>.allocate(capacity: bufferSize)
+        while input.hasBytesAvailable {
+            let read = input.read(buffer, maxLength: bufferSize)
+            if read < 0 {
+                break
+            }
+            self.append(buffer, count: read)
+        }
+        buffer.deallocate()
+        input.close()
+    }
+}

package/ios/Sources/InAppBrowserPlugin/WKWebView+SchemeHandling.swift

@@ -0,0 +1,53 @@
+import Foundation
+import ObjectiveC
+import WebKit
+
+/// Enables registering a `WKURLSchemeHandler` for built-in schemes like `http` and `https`.
+///
+/// Apple's public `setURLSchemeHandler(_:forURLScheme:)` API throws for http/https because
+/// `WKWebView.handlesURLScheme(_:)` returns `true` for them. This extension swizzles that
+/// class method to return `false` for specified schemes, allowing the public API to work.
+///
+/// This is the industry-standard approach used by DuckDuckGo Browser, TON Proxy, and others.
+extension WKWebView {
+
+    /// Tracks which schemes have been overridden to allow custom handling
+    private static var _overriddenSchemes = Set<String>()
+
+    /// One-time swizzle — matches the pattern used by DuckDuckGo and ton-proxy-swift
+    private static let _swizzleOnce: Void = {
+        let original = class_getClassMethod(WKWebView.self, #selector(WKWebView.handlesURLScheme(_:)))
+        let swizzled = class_getClassMethod(
+            WKWebView.self,
+            #selector(WKWebView._capgo_handlesURLScheme(_:))
+        )
+
+        guard let original, let swizzled else {
+            print("[InAppBrowser][Proxy] WARNING: Could not get methods for swizzle")
+            return
+        }
+
+        method_exchangeImplementations(original, swizzled)
+    }()
+
+    /// Swizzled replacement — returns false for overridden schemes, calls original for all others
+    @objc(capgo_handlesURLScheme:)
+    private static func _capgo_handlesURLScheme(_ urlScheme: String) -> Bool {
+        if _overriddenSchemes.contains(urlScheme.lowercased()) {
+            return false
+        }
+        // After swizzle, this actually calls the ORIGINAL handlesURLScheme
+        return _capgo_handlesURLScheme(urlScheme)
+    }
+
+    /// Call this before `setURLSchemeHandler(_:forURLScheme:)` to allow registering for http/https.
+    static func enableCustomSchemeHandling(for schemes: [String]) {
+        // Add schemes BEFORE triggering the swizzle
+        for scheme in schemes {
+            _overriddenSchemes.insert(scheme.lowercased())
+        }
+
+        // Trigger the one-time swizzle
+        _ = _swizzleOnce
+    }
+}

package/ios/Sources/InAppBrowserPlugin/WKWebViewController.swift

@@ -101,11 +101,13 @@ open class WKWebViewController: UIViewController, WKScriptMessageHandler {
         self.initWebview(isInspectable: isInspectable)
     }
 
-    public init(url: URL, headers: [String: String], isInspectable: Bool, credentials: WKWebViewCredentials? = nil, preventDeeplink: Bool, blankNavigationTab: Bool, enabledSafeBottomMargin: Bool, enabledSafeTopMargin: Bool = true, blockedHosts: [String], authorizedAppLinks: [String]) {
+    public init(url: URL, headers: [String: String], isInspectable: Bool, credentials: WKWebViewCredentials? = nil, preventDeeplink: Bool, blankNavigationTab: Bool, enabledSafeBottomMargin: Bool, enabledSafeTopMargin: Bool = true, blockedHosts: [String], authorizedAppLinks: [String], proxyRequests: Bool = false, proxySchemeHandler: ProxySchemeHandler? = nil) {
         super.init(nibName: nil, bundle: nil)
         self.blankNavigationTab = blankNavigationTab
         self.enabledSafeBottomMargin = enabledSafeBottomMargin
         self.enabledSafeTopMargin = enabledSafeTopMargin
+        self.proxyRequests = proxyRequests
+        self.proxySchemeHandler = proxySchemeHandler
         self.source = .remote(url)
         self.credentials = credentials
         self.setHeaders(headers: headers)
@@ -153,6 +155,8 @@ open class WKWebViewController: UIViewController, WKScriptMessageHandler {
     var authorizedAppLinks: [String] = []
     var activeNativeNavigationForWebview: Bool = true
     var disableOverscroll: Bool = false
+    var proxyRequests: Bool = false
+    var proxySchemeHandler: ProxySchemeHandler?
 
     // Dimension properties
     var customWidth: CGFloat?
@@ -669,6 +673,19 @@ open class WKWebViewController: UIViewController, WKScriptMessageHandler {
         // Enable background task processing
         webConfiguration.processPool = WKProcessPool()
 
+        // Register proxy scheme handler if enabled
+        // Swizzles WKWebView.handlesURLScheme to allow registering for http/https via the public API
+        // This is the industry-standard approach used by DuckDuckGo Browser and others
+        if proxyRequests, let handler = proxySchemeHandler {
+            WKWebView.enableCustomSchemeHandling(for: ["https", "http"])
+            if !WKWebView.handlesURLScheme("https") && !WKWebView.handlesURLScheme("http") {
+                webConfiguration.setURLSchemeHandler(handler, forURLScheme: "https")
+                webConfiguration.setURLSchemeHandler(handler, forURLScheme: "http")
+            } else {
+                print("[InAppBrowser][Proxy] WARNING: handlesURLScheme swizzle failed; proxy scheme handler not registered")
+            }
+        }
+
         // Enable JavaScript to run automatically (needed for preShowScript and Firebase polyfill)
         webConfiguration.preferences.javaScriptCanOpenWindowsAutomatically = true
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capgo/inappbrowser",
-  "version": "8.2.0",
+  "version": "8.3.0-alpha.0",
   "description": "Capacitor plugin in app browser",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",
@@ -41,7 +41,8 @@
     "prettier": "prettier-pretty-check \"**/*.{css,html,ts,js,java}\" --plugin=prettier-plugin-java",
     "swiftlint": "node-swiftlint",
     "docgen": "docgen --api InAppBrowserPlugin --output-readme README.md --output-json dist/docs.json",
-    "build": "npm run clean && npm run docgen && tsc && rollup -c rollup.config.mjs",
+    "build:proxy-bridge": "esbuild src/proxy-bridge.ts --bundle --outfile=android/src/main/assets/proxy-bridge.js --format=iife --target=es2015",
+    "build": "npm run clean && npm run docgen && tsc && rollup -c rollup.config.mjs && npm run build:proxy-bridge",
     "clean": "rimraf ./dist",
     "watch": "tsc --watch",
     "prepublishOnly": "npm run build"
@@ -56,6 +57,7 @@
     "@ionic/prettier-config": "^4.0.0",
     "@ionic/swiftlint-config": "^2.0.0",
     "@types/node": "^24.10.1",
+    "esbuild": "^0.27.3",
     "eslint": "^8.57.1",
     "eslint-plugin-import": "^2.31.0",
     "husky": "^9.1.7",