@capgo/capacitor-inappbrowser 8.14.2 → 8.15.0

package/ios/Sources/InAppBrowserPlugin/BundledAssetSchemeHandler.swift

@@ -0,0 +1,188 @@
+import Foundation
+import ObjectiveC
+import UniformTypeIdentifiers
+import WebKit
+
+final class BundledAssetSchemeHandler: NSObject, WKURLSchemeHandler {
+    private let basePath: String
+    private let expectedHost: String
+    private var activeTasks: [ObjectIdentifier: WKURLSchemeTask] = [:]
+    private let tasksLock = NSLock()
+
+    init(expectedHost: String) {
+        self.basePath = Self.resolveBasePath()
+        self.expectedHost = expectedHost.lowercased()
+        super.init()
+    }
+
+    func webView(_ webView: WKWebView, start urlSchemeTask: WKURLSchemeTask) {
+        guard let requestURL = urlSchemeTask.request.url else {
+            urlSchemeTask.didFailWithError(
+                NSError(domain: "BundledAssetSchemeHandler", code: -1, userInfo: [NSLocalizedDescriptionKey: "Missing request URL"])
+            )
+            return
+        }
+
+        let taskID = ObjectIdentifier(urlSchemeTask)
+        tasksLock.lock()
+        activeTasks[taskID] = urlSchemeTask
+        tasksLock.unlock()
+
+        guard Self.isAllowedBundledAssetRequest(requestURL, expectedHost: expectedHost) else {
+            finish(task: urlSchemeTask, taskID: taskID) {
+                urlSchemeTask.didFailWithError(
+                    NSError(
+                        domain: "BundledAssetSchemeHandler",
+                        code: 403,
+                        userInfo: [NSLocalizedDescriptionKey: "Blocked bundled asset host: \(requestURL.absoluteString)"]
+                    )
+                )
+            }
+            return
+        }
+
+        guard let filePath = BundledAssetSupport.routeAssetPath(for: requestURL.path, basePath: basePath) else {
+            finish(task: urlSchemeTask, taskID: taskID) {
+                urlSchemeTask.didFailWithError(
+                    NSError(
+                        domain: "BundledAssetSchemeHandler",
+                        code: 403,
+                        userInfo: [NSLocalizedDescriptionKey: "Blocked bundled asset path: \(requestURL.path)"]
+                    )
+                )
+            }
+            return
+        }
+
+        let fileURL = URL(fileURLWithPath: filePath)
+
+        DispatchQueue.global(qos: .userInitiated).async { [weak self] in
+            guard let self else {
+                return
+            }
+
+            guard FileManager.default.fileExists(atPath: fileURL.path) else {
+                self.finish(task: urlSchemeTask, taskID: taskID) {
+                    urlSchemeTask.didFailWithError(
+                        NSError(
+                            domain: "BundledAssetSchemeHandler",
+                            code: 404,
+                            userInfo: [NSLocalizedDescriptionKey: "Bundled asset not found: \(requestURL.path)"]
+                        )
+                    )
+                }
+                return
+            }
+
+            do {
+                let data = try Data(contentsOf: fileURL)
+                let mimeType = self.mimeType(for: requestURL.pathExtension)
+                let response = HTTPURLResponse(
+                    url: requestURL,
+                    statusCode: 200,
+                    httpVersion: nil,
+                    headerFields: [
+                        "Content-Type": mimeType,
+                        "Cache-Control": "no-cache"
+                    ]
+                ) ?? URLResponse(url: requestURL, mimeType: mimeType, expectedContentLength: data.count, textEncodingName: nil)
+
+                self.finish(task: urlSchemeTask, taskID: taskID) {
+                    urlSchemeTask.didReceive(response)
+                    urlSchemeTask.didReceive(data)
+                    urlSchemeTask.didFinish()
+                }
+            } catch {
+                self.finish(task: urlSchemeTask, taskID: taskID) {
+                    urlSchemeTask.didFailWithError(error)
+                }
+            }
+        }
+    }
+
+    func webView(_ webView: WKWebView, stop urlSchemeTask: WKURLSchemeTask) {
+        let taskID = ObjectIdentifier(urlSchemeTask)
+        tasksLock.lock()
+        activeTasks.removeValue(forKey: taskID)
+        tasksLock.unlock()
+        urlSchemeTask.stopped = true
+    }
+
+    private func finish(task: WKURLSchemeTask, taskID: ObjectIdentifier, block: @escaping () -> Void) {
+        DispatchQueue.main.async { [weak self] in
+            guard let self else {
+                return
+            }
+
+            guard !task.stopped else {
+                return
+            }
+
+            self.tasksLock.lock()
+            let isActive = self.activeTasks[taskID] != nil
+            if isActive {
+                self.activeTasks.removeValue(forKey: taskID)
+            }
+            self.tasksLock.unlock()
+
+            guard isActive, !task.stopped else {
+                return
+            }
+
+            block()
+        }
+    }
+
+    private static func isAllowedBundledAssetRequest(_ requestURL: URL, expectedHost: String) -> Bool {
+        guard let host = requestURL.host?.lowercased(), host == expectedHost else {
+            return false
+        }
+
+        return requestURL.port == nil
+    }
+
+    private func mimeType(for pathExtension: String) -> String {
+        if !pathExtension.isEmpty,
+           let uti = UTType(filenameExtension: pathExtension),
+           let mimeType = uti.preferredMIMEType {
+            return mimeType
+        }
+
+        return pathExtension.isEmpty ? "text/html" : "application/octet-stream"
+    }
+
+    private static func resolveBasePath() -> String {
+        if let publicDirectory = publicDirectoryURL(),
+           FileManager.default.fileExists(atPath: publicDirectory.path) {
+            return publicDirectory.path
+        }
+
+        if let wwwDirectory = wwwDirectoryURL(),
+           FileManager.default.fileExists(atPath: wwwDirectory.path) {
+            return wwwDirectory.path
+        }
+
+        return publicDirectoryURL()?.path ?? wwwDirectoryURL()?.path ?? ""
+    }
+
+    private static func publicDirectoryURL() -> URL? {
+        Bundle.main.resourceURL?.appendingPathComponent("public", isDirectory: true)
+    }
+
+    private static func wwwDirectoryURL() -> URL? {
+        Bundle.main.resourceURL?.appendingPathComponent("www", isDirectory: true)
+    }
+}
+
+private var bundledAssetStoppedKey: UInt8 = 0
+
+private extension WKURLSchemeTask {
+    var stopped: Bool {
+        get {
+            objc_getAssociatedObject(self, &bundledAssetStoppedKey) as? Bool ?? false
+        }
+        set {
+            objc_setAssociatedObject(self, &bundledAssetStoppedKey, newValue, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+        }
+    }
+}

package/ios/Sources/InAppBrowserPlugin/BundledAssetSupport.swift

@@ -0,0 +1,221 @@
+import Foundation
+
+enum BundledAssetSupport {
+    struct LocalConfig: Equatable {
+        let scheme: String
+        let host: String
+    }
+
+    struct Resolution: Equatable {
+        let url: String
+    }
+
+    static let iosDefaults = LocalConfig(scheme: "capacitor", host: "localhost")
+    static let reservedWebKitSchemes = ["http", "https"]
+
+    static func parseLocalConfig(from localURL: URL?) -> LocalConfig? {
+        guard let localURL else {
+            return nil
+        }
+
+        guard let scheme = localURL.scheme?.lowercased(), !scheme.isEmpty else {
+            return nil
+        }
+
+        let host = localURL.host?.lowercased() ?? ""
+        guard !host.isEmpty else {
+            return nil
+        }
+
+        return LocalConfig(scheme: scheme, host: host)
+    }
+
+    static func handlerScheme(for localConfig: LocalConfig) -> String {
+        if reservedWebKitSchemes.contains(localConfig.scheme) {
+            return iosDefaults.scheme
+        }
+        return localConfig.scheme
+    }
+
+    static func resolve(_ urlString: String, localURL: URL?) -> Resolution? {
+        let trimmed = urlString.trimmingCharacters(in: .whitespacesAndNewlines)
+        let localConfig = parseLocalConfig(from: localURL) ?? iosDefaults
+        let navigationScheme = handlerScheme(for: localConfig)
+
+        if isRelativeBundledPath(trimmed) {
+            guard let path = normalizeBundledPath(trimmed) else {
+                return nil
+            }
+            return Resolution(url: "\(navigationScheme)://\(localConfig.host)\(path)")
+        }
+
+        if isBundledLocalURL(trimmed, localConfig: localConfig) {
+            if let rewritten = rewriteBundledLocalURL(trimmed, localConfig: localConfig, navigationScheme: navigationScheme) {
+                return Resolution(url: rewritten)
+            }
+            return Resolution(url: trimmed)
+        }
+
+        return Resolution(url: trimmed)
+    }
+
+    static func isBundledLocalURL(_ urlString: String, localConfig: LocalConfig) -> Bool {
+        guard let url = URL(string: urlString),
+              let scheme = url.scheme?.lowercased(),
+              let host = url.host?.lowercased() else {
+            return false
+        }
+
+        guard host == localConfig.host else {
+            return false
+        }
+
+        if url.port != nil {
+            return false
+        }
+
+        if scheme == localConfig.scheme || scheme == handlerScheme(for: localConfig) {
+            return true
+        }
+
+        return reservedWebKitSchemes.contains(scheme) && reservedWebKitSchemes.contains(localConfig.scheme)
+    }
+
+    static func isRelativeBundledPath(_ urlString: String) -> Bool {
+        let trimmed = urlString.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !trimmed.isEmpty else {
+            return false
+        }
+
+        return !isAbsoluteURL(trimmed)
+    }
+
+    private static let bundledAssetExtensions: Set<String> = [
+        "html", "htm", "js", "css", "json", "xml", "svg",
+        "png", "jpg", "jpeg", "gif", "webp", "woff", "woff2", "ttf", "map"
+    ]
+
+    static func isLikelyBundledRelativePath(_ urlString: String) -> Bool {
+        guard isRelativeBundledPath(urlString) else {
+            return false
+        }
+
+        let trimmed = stripPathQueryAndFragment(urlString.trimmingCharacters(in: .whitespacesAndNewlines))
+        if finalPathComponentStartsWithDot(trimmed) {
+            return false
+        }
+
+        if trimmed.hasPrefix("/") || trimmed.contains("/") {
+            return true
+        }
+
+        guard let dot = trimmed.lastIndex(of: ".") else {
+            return true
+        }
+
+        if dot == trimmed.startIndex {
+            return false
+        }
+
+        let extensionStart = trimmed.index(after: dot)
+        guard extensionStart < trimmed.endIndex else {
+            return false
+        }
+
+        let fileExtension = String(trimmed[extensionStart...]).lowercased()
+        return bundledAssetExtensions.contains(fileExtension)
+    }
+
+    private static func finalPathComponentStartsWithDot(_ path: String) -> Bool {
+        let finalComponent = path.split(separator: "/").last.map(String.init) ?? path
+        guard let first = finalComponent.first else {
+            return false
+        }
+        return first == "."
+    }
+
+    private static func stripPathQueryAndFragment(_ path: String) -> String {
+        let withoutQuery = path.split(separator: "?", maxSplits: 1, omittingEmptySubsequences: false).first.map(String.init) ?? path
+        return withoutQuery.split(separator: "#", maxSplits: 1, omittingEmptySubsequences: false).first.map(String.init) ?? withoutQuery
+    }
+
+    static func normalizeBundledPath(_ path: String) -> String? {
+        let trimmed = path.trimmingCharacters(in: .whitespacesAndNewlines)
+        if trimmed.isEmpty || trimmed == "/" {
+            return "/"
+        }
+
+        guard !containsPathTraversal(trimmed) else {
+            return nil
+        }
+
+        return trimmed.hasPrefix("/") ? trimmed : "/\(trimmed)"
+    }
+
+    static func routeAssetPath(for requestPath: String, basePath: String) -> String? {
+        guard !containsPathTraversal(requestPath) else {
+            return nil
+        }
+
+        let normalizedPath = requestPath.isEmpty ? "/" : requestPath
+        let relativePath: String
+        if URL(fileURLWithPath: normalizedPath).pathExtension.isEmpty {
+            relativePath = "/index.html"
+        } else {
+            relativePath = normalizedPath.hasPrefix("/") ? normalizedPath : "/\(normalizedPath)"
+        }
+
+        let resolvedURL = URL(fileURLWithPath: basePath).appendingPathComponent(relativePath, isDirectory: false).standardizedFileURL
+        let baseURL = URL(fileURLWithPath: basePath).standardizedFileURL
+        let resolvedPath = resolvedURL.path
+        let basePathValue = baseURL.path
+
+        guard resolvedPath == basePathValue || resolvedPath.hasPrefix(basePathValue + "/") else {
+            return nil
+        }
+
+        return resolvedPath
+    }
+
+    static func containsPathTraversal(_ path: String) -> Bool {
+        path.split(separator: "/").contains(where: { $0 == ".." })
+    }
+
+    private static func rewriteBundledLocalURL(
+        _ urlString: String,
+        localConfig: LocalConfig,
+        navigationScheme: String
+    ) -> String? {
+        guard let url = URL(string: urlString),
+              let host = url.host?.lowercased(),
+              host == localConfig.host else {
+            return nil
+        }
+
+        guard let scheme = url.scheme?.lowercased(), scheme != navigationScheme else {
+            return nil
+        }
+
+        var components = URLComponents(url: url, resolvingAgainstBaseURL: false)
+        components?.scheme = navigationScheme
+        return components?.url?.absoluteString
+    }
+
+    private static func isAbsoluteURL(_ urlString: String) -> Bool {
+        if urlString.hasPrefix("//") {
+            return true
+        }
+
+        guard let colonIndex = urlString.firstIndex(of: ":"),
+              colonIndex > urlString.startIndex else {
+            return false
+        }
+
+        let scheme = urlString[..<colonIndex]
+        guard let first = scheme.first, first.isLetter else {
+            return false
+        }
+
+        return scheme.allSatisfy { $0.isLetter || $0.isNumber || $0 == "+" || $0 == "-" || $0 == "." }
+    }
+}

package/ios/Sources/InAppBrowserPlugin/InAppBrowserPlugin.swift

@@ -415,7 +415,7 @@ public class CapgoInAppBrowserPlugin: CAPPlugin, CAPBridgedPlugin {
         case aware = "AWARE"
         case fakeVisible = "FAKE_VISIBLE"
     }
-    private let pluginVersion: String = "8.14.2"
+    private let pluginVersion: String = "8.15.0"
     public let identifier = "CapgoInAppBrowserPlugin"
     public let jsName = "CapgoInAppBrowser"
     public let pluginMethods: [CAPPluginMethod] = [
@@ -1226,12 +1226,24 @@ public class CapgoInAppBrowserPlugin: CAPPlugin, CAPBridgedPlugin {
         throw optionError("Failed to load \(optionName) icon: \(icon)")
     }
 
+    private func bundledAssetLocalConfig() -> BundledAssetSupport.LocalConfig {
+        BundledAssetSupport.parseLocalConfig(from: self.bridge?.config.localURL) ?? BundledAssetSupport.iosDefaults
+    }
+
+    private func applyBundledAssetSettings(to webViewController: WKWebViewController) {
+        // Scheme handlers are registered once during initWebview; localURL is fixed for the app lifetime.
+        let localConfig = bundledAssetLocalConfig()
+        webViewController.bundledAssetLocalScheme = BundledAssetSupport.handlerScheme(for: localConfig)
+        webViewController.bundledAssetLocalHost = localConfig.host
+    }
+
     private func webSource(for urlString: String) -> WKWebSource? {
         if let html = HtmlDataUrlSupport.parseHtml(from: urlString) {
             return .string(html, base: nil)
         }
 
-        guard let url = URL(string: urlString) else {
+        guard let resolution = BundledAssetSupport.resolve(urlString, localURL: self.bridge?.config.localURL),
+              let url = URL(string: resolution.url) else {
             return nil
         }
 
@@ -1442,7 +1454,8 @@ public class CapgoInAppBrowserPlugin: CAPPlugin, CAPBridgedPlugin {
         }
 
         DispatchQueue.main.async {
-            guard let webSource = self.webSource(for: urlString) else {
+            let webSourceResult = self.webSource(for: urlString)
+            guard let webSource = webSourceResult else {
                 call.reject("Invalid URL format")
                 return
             }
@@ -1495,6 +1508,7 @@ public class CapgoInAppBrowserPlugin: CAPPlugin, CAPBridgedPlugin {
                 authorizedAppLinks: authorizedAppLinks,
                 openBlankTargetInWebView: openBlankTargetInWebView
             )
+            self.applyBundledAssetSettings(to: webViewController)
             webViewController.enableReloadGesture = enableReloadGesture
             webViewController.disableOverscroll = disableOverscroll
             webViewController.initWebview(isInspectable: isInspectable)
@@ -1846,11 +1860,14 @@ public class CapgoInAppBrowserPlugin: CAPPlugin, CAPBridgedPlugin {
             return
         }
 
-        guard let url = URL(string: urlString) else {
+        guard let resolution = BundledAssetSupport.resolve(urlString, localURL: self.bridge?.config.localURL),
+              let url = URL(string: resolution.url) else {
             call.reject("Invalid URL")
             return
         }
 
+        self.applyBundledAssetSettings(to: webViewController)
+
         webViewController.source = .remote(url)
         webViewController.load(remote: url)
         call.resolve()
@@ -2357,6 +2374,11 @@ public class CapgoInAppBrowserPlugin: CAPPlugin, CAPBridgedPlugin {
             return
         }
 
+        if BundledAssetSupport.isLikelyBundledRelativePath(urlString) {
+            call.reject("Bundled assets require openWebView()")
+            return
+        }
+
         guard let url = URL(string: urlString),
               let scheme = url.scheme?.lowercased(),
               ["http", "https"].contains(scheme) else {

package/ios/Sources/InAppBrowserPlugin/WKWebViewController.swift

@@ -482,6 +482,9 @@ open class WKWebViewController: UIViewController, WKScriptMessageHandler {
     var disableOverscroll: Bool = false
     var proxyRequests: Bool = false
     var proxySchemeHandler: ProxySchemeHandler?
+    var bundledAssetSchemeHandler: BundledAssetSchemeHandler?
+    var bundledAssetLocalScheme: String = BundledAssetSupport.iosDefaults.scheme
+    var bundledAssetLocalHost: String = BundledAssetSupport.iosDefaults.host
     var proxyBridge: ProxyBridge?
     var proxyBridgeAccessToken: String?
     var legacyProxyRequestURLRegexPattern: String?
@@ -2065,6 +2068,12 @@ open class WKWebViewController: UIViewController, WKScriptMessageHandler {
             }
         }
 
+        let bundledAssetHandler = BundledAssetSchemeHandler(expectedHost: bundledAssetLocalHost)
+        self.bundledAssetSchemeHandler = bundledAssetHandler
+        if webConfiguration.urlSchemeHandler(forURLScheme: bundledAssetLocalScheme) == nil {
+            webConfiguration.setURLSchemeHandler(bundledAssetHandler, forURLScheme: bundledAssetLocalScheme)
+        }
+
         if ProxyBridgeSupport.shouldInjectBridge(hasProxySchemeHandler: proxySchemeHandler != nil) {
             addProxyBridgeUserScripts(to: userContentController)
         }
@@ -2309,6 +2318,8 @@ open class WKWebViewController: UIViewController, WKScriptMessageHandler {
         self.disableOverscroll = parent.disableOverscroll
         self.proxyRequests = parent.proxyRequests
         self.proxySchemeHandler = proxySchemeHandler
+        self.bundledAssetLocalScheme = parent.bundledAssetLocalScheme
+        self.bundledAssetLocalHost = parent.bundledAssetLocalHost
         self.proxyBridge = parent.proxyBridge
         self.proxyBridgeAccessToken = parent.proxyBridgeAccessToken
         self.legacyProxyRequestURLRegexPattern = parent.legacyProxyRequestURLRegexPattern
@@ -2981,6 +2992,16 @@ fileprivate extension WKWebViewController {
             return
         }
 
+        let bundledLocalConfig = BundledAssetSupport.LocalConfig(
+            scheme: bundledAssetLocalScheme,
+            host: bundledAssetLocalHost
+        )
+        if BundledAssetSupport.isBundledLocalURL(url.absoluteString, localConfig: bundledLocalConfig) {
+            print("[InAppBrowser] bundled local asset URL detected, allowing navigation")
+            completion(false)
+            return
+        }
+
         // Handle all non-http(s) schemes by default
         if scheme != "http" && scheme != "https" && scheme != "file" {
             print("[InAppBrowser] not http(s) scheme, try to open URLs in external apps")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capgo/capacitor-inappbrowser",
-  "version": "8.14.2",
+  "version": "8.15.0",
   "description": "Capacitor plugin in app browser",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",
@@ -35,7 +35,7 @@
     "verify:ios": "bun run build:proxy-bridge && xcodebuild -scheme CapgoCapacitorInappbrowser -destination generic/platform=iOS",
     "verify:android": "cd android && ./gradlew clean build test && cd ..",
     "verify:web": "bun run build && bun run test:web",
-    "test:web": "bun test src/proxy-bridge-support.test.ts",
+    "test:web": "bun test src/proxy-bridge-support.test.ts src/bundled-asset-support.test.ts",
     "test:maestro:android": "./scripts/test-maestro-android.sh",
     "lint": "bun run eslint && bun run prettier -- --check && bun run swiftlint -- lint",
     "fmt": "bun run eslint -- --fix && bun run prettier -- --write && bun run swiftlint -- --fix --format",