react-native-security-suite 0.6.7 → 0.7.0

package/android/build.gradle

@@ -28,7 +28,6 @@ def isNewArchitectureEnabled() {
 plugins {
   id "com.android.library"
   id "kotlin-android"
-  id "com.google.devtools.ksp" version "1.9.21-1.0.15"
 }
 
 if (isNewArchitectureEnabled()) {
@@ -112,19 +111,5 @@ dependencies {
   implementation "com.squareup.okhttp3:okhttp:4.12.0"
   implementation "com.scottyab:rootbeer-lib:0.1.0"
   implementation "com.github.chuckerteam.chucker:library:4.1.0"
-
-  implementation "com.google.android.material:material:1.12.0"
-  implementation "com.google.code.gson:gson:2.11.0"
-  implementation "org.brotli:dec:0.1.2"
-  implementation "androidx.databinding:viewbinding:8.7.3"
-  implementation "androidx.constraintlayout:constraintlayout:2.2.0"
-  implementation "androidx.palette:palette-ktx:1.0.0"
-  implementation "androidx.activity:activity-ktx:1.9.3"
-  implementation "androidx.fragment:fragment-ktx:1.8.5"
-  implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:2.8.7"
-  implementation "androidx.lifecycle:lifecycle-livedata-ktx:2.8.7"
-  implementation "androidx.room:room-ktx:2.6.1"
-  implementation "androidx.room:room-runtime:2.6.1"
-  ksp "androidx.room:room-compiler:2.6.1"
 }
 

package/android/src/main/AndroidManifest.xml

@@ -1,49 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns:android="http://schemas.android.com/apk/res/android">
-
-  <queries>
-    <intent>
-      <action android:name="android.intent.action.CREATE_DOCUMENT" />
-      <data android:mimeType="*/*" />
-    </intent>
-  </queries>
-
-  <uses-permission
-    android:name="android.permission.WAKE_LOCK"
-    android:maxSdkVersion="25" />
-
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="com.securitysuite">
   <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
-
-  <application>
-    <activity
-      android:name="com.securitysuite.internal.ui.MainActivity"
-      android:label="@string/chucker_name"
-      android:launchMode="singleTask"
-      android:taskAffinity="com.securitysuite.task"
-      android:theme="@style/Chucker.Theme" />
-
-    <activity
-      android:name="com.securitysuite.internal.ui.transaction.TransactionActivity"
-      android:parentActivityName="com.securitysuite.internal.ui.MainActivity"
-      android:theme="@style/Chucker.Theme" />
-
-    <service
-      android:name="com.securitysuite.internal.support.ClearDatabaseService"
-      android:exported="false"
-      android:permission="android.permission.BIND_JOB_SERVICE" />
-
-    <receiver
-      android:name="com.securitysuite.internal.support.ClearDatabaseJobIntentServiceReceiver"
-      android:exported="false" />
-
-    <provider
-      android:name="com.securitysuite.internal.support.ChuckerFileProvider"
-      android:authorities="${applicationId}.com.securitysuite.provider"
-      android:exported="false"
-      android:grantUriPermissions="true">
-      <meta-data
-        android:name="android.support.FILE_PROVIDER_PATHS"
-        android:resource="@xml/chucker_provider_paths" />
-    </provider>
-  </application>
-</manifest>
+</manifest>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-security-suite",
-  "version": "0.6.7",
+  "version": "0.7.0",
   "description": "Security solution for React Native",
   "source": "./src/index.tsx",
   "main": "./lib/commonjs/index.js",

package/android/src/main/java/com/securitysuite/NetworkLogger.java

@@ -1,25 +0,0 @@
-package com.securitysuite;
-
-import android.content.Context;
-
-import com.facebook.react.modules.network.OkHttpClientFactory;
-import com.facebook.react.modules.network.ReactCookieJarContainer;
-import com.securitysuite.api.ChuckerInterceptor;
-
-import okhttp3.OkHttpClient;
-public class NetworkLogger implements OkHttpClientFactory {
-  private Context context;
-
-  public NetworkLogger(Context context) {
-    this.context = context;
-  }
-
-  public OkHttpClient createNewNetworkModuleClient() {
-    OkHttpClient client = new OkHttpClient.Builder()
-      .addInterceptor(new ChuckerInterceptor.Builder(context).build())
-      .cookieJar(new ReactCookieJarContainer())
-      .build();
-
-    return client;
-  }
-}

package/android/src/main/java/com/securitysuite/api/BodyDecoder.kt

@@ -1,35 +0,0 @@
-package com.securitysuite.api
-
-import okhttp3.Request
-import okhttp3.Response
-import okio.ByteString
-import okio.IOException
-
-/**
- * Decodes HTTP request and response bodies to human–readable texts.
- */
-public interface BodyDecoder {
-    /**
-     * Returns a text representation of [body] that will be displayed in Chucker UI transaction,
-     * or `null` if [request] cannot be handled by this decoder. [Body][body] is no longer than
-     * [max content length][ChuckerInterceptor.Builder.maxContentLength] and is guaranteed to be
-     * uncompressed even if [request] has gzip or br header.
-     */
-    @Throws(IOException::class)
-    public fun decodeRequest(
-        request: Request,
-        body: ByteString,
-    ): String?
-
-    /**
-     * Returns a text representation of [body] that will be displayed in Chucker UI transaction,
-     * or `null` if [response] cannot be handled by this decoder. [Body][body] is no longer than
-     * [max content length][ChuckerInterceptor.Builder.maxContentLength] and is guaranteed to be
-     * uncompressed even if [response] has gzip or br header.
-     */
-    @Throws(IOException::class)
-    public fun decodeResponse(
-        response: Response,
-        body: ByteString,
-    ): String?
-}

package/android/src/main/java/com/securitysuite/api/Chucker.kt

@@ -1,108 +0,0 @@
-package com.securitysuite.api
-
-import android.content.Context
-import android.content.Intent
-import android.content.pm.ShortcutInfo
-import android.content.pm.ShortcutManager
-import android.graphics.drawable.Icon
-import android.os.Build
-import android.util.Log
-import androidx.core.content.getSystemService
-import com.securitysuite.R
-import com.securitysuite.internal.support.Logger
-import com.securitysuite.internal.support.NotificationHelper
-import com.securitysuite.internal.ui.MainActivity
-
-/**
- * Chucker methods and utilities to interact with the library.
- */
-public object Chucker {
-    private const val SHORTCUT_ID = "chuckerShortcutId"
-
-    /**
-     * Keep track of latest show notifications value from ChuckerCollector.
-     */
-    internal var showNotifications: Boolean = true
-
-    /**
-     * Check if this instance is the operation one or no-op.
-     * @return `true` if this is the operation instance.
-     */
-    @Suppress("MayBeConst ") // https://github.com/ChuckerTeam/chucker/pull/169#discussion_r362341353
-    public val isOp: Boolean = true
-
-    /**
-     * Get an Intent to launch the Chucker UI directly.
-     * @param context An Android [Context].
-     * @return An Intent for the main Chucker Activity that can be started with [Context.startActivity].
-     */
-    @JvmStatic
-    public fun getLaunchIntent(context: Context): Intent {
-        return Intent(context, MainActivity::class.java)
-            .setFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
-    }
-
-    /**
-     * Create a shortcut to launch Chucker UI.
-     * @param context An Android [Context].
-     */
-    internal fun createShortcut(context: Context) {
-        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.N_MR1) {
-            return
-        }
-
-        val shortcutManager = context.getSystemService<ShortcutManager>() ?: return
-        if (shortcutManager.dynamicShortcuts.any { it.id == SHORTCUT_ID }) {
-            return
-        }
-
-        val shortcut =
-            ShortcutInfo.Builder(context, SHORTCUT_ID)
-                .setShortLabel(context.getString(R.string.chucker_shortcut_label))
-                .setLongLabel(context.getString(R.string.chucker_shortcut_label))
-                .setIcon(Icon.createWithResource(context, R.mipmap.chucker_ic_launcher))
-                .setIntent(getLaunchIntent(context).setAction(Intent.ACTION_VIEW))
-                .build()
-        try {
-            shortcutManager.addDynamicShortcuts(listOf(shortcut))
-        } catch (e: IllegalArgumentException) {
-            Logger.warn("ShortcutManager addDynamicShortcuts failed ", e)
-        } catch (e: IllegalStateException) {
-            Logger.warn("ShortcutManager addDynamicShortcuts failed ", e)
-        }
-    }
-
-    /**
-     * Dismisses all previous Chucker notifications.
-     */
-    @JvmStatic
-    public fun dismissNotifications(context: Context) {
-        NotificationHelper(context).dismissNotifications()
-    }
-
-    internal var logger: Logger =
-        object : Logger {
-            val TAG = "Chucker"
-
-            override fun info(
-                message: String,
-                throwable: Throwable?,
-            ) {
-                Log.i(TAG, message, throwable)
-            }
-
-            override fun warn(
-                message: String,
-                throwable: Throwable?,
-            ) {
-                Log.w(TAG, message, throwable)
-            }
-
-            override fun error(
-                message: String,
-                throwable: Throwable?,
-            ) {
-                Log.e(TAG, message, throwable)
-            }
-        }
-}

package/android/src/main/java/com/securitysuite/api/ChuckerCollector.kt

@@ -1,129 +0,0 @@
-package com.securitysuite.api
-
-import android.content.Context
-import android.net.Uri
-import com.securitysuite.R
-import com.securitysuite.internal.data.entity.HttpTransaction
-import com.securitysuite.internal.data.har.log.Creator
-import com.securitysuite.internal.data.repository.RepositoryProvider
-import com.securitysuite.internal.support.HarUtils
-import com.securitysuite.internal.support.JsonConverter
-import com.securitysuite.internal.support.NotificationHelper
-import com.securitysuite.internal.support.TransactionDetailsHarSharable
-import com.securitysuite.internal.support.TransactionListDetailsSharable
-import com.securitysuite.internal.support.writeToFile
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.MainScope
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.withContext
-
-/**
- * The collector responsible of collecting data from a [ChuckerInterceptor] and
- * storing it/displaying push notification. You need to instantiate one of those and
- * provide it to
- *
- * @param context An Android Context
- * @param showNotification Control whether a notification is shown while HTTP activity
- * is recorded.
- * @param retentionPeriod Set the retention period for HTTP transaction data captured
- * by this collector. The default is one week.
- */
-public class ChuckerCollector
-    @JvmOverloads
-    constructor(
-        context: Context,
-        public var showNotification: Boolean = true,
-        retentionPeriod: RetentionManager.Period = RetentionManager.Period.ONE_WEEK,
-    ) {
-        private val retentionManager: RetentionManager = RetentionManager(context, retentionPeriod)
-        private val notificationHelper: NotificationHelper = NotificationHelper(context)
-        private val scope = MainScope()
-
-        init {
-            RepositoryProvider.initialize(context)
-            Chucker.showNotifications = showNotification
-        }
-
-        /**
-         * Call this method when you send an HTTP request.
-         * @param transaction The HTTP transaction sent
-         */
-        internal fun onRequestSent(transaction: HttpTransaction) {
-            scope.launch {
-                withContext(Dispatchers.IO) {
-                    RepositoryProvider.transaction().insertTransaction(transaction)
-                }
-
-                if (showNotification) {
-                    notificationHelper.show(transaction)
-                }
-                withContext(Dispatchers.IO) {
-                    retentionManager.doMaintenance()
-                }
-            }
-        }
-
-        /**
-         * Call this method when you received the response of an HTTP request.
-         * It must be called after [ChuckerCollector.onRequestSent].
-         * @param transaction The sent HTTP transaction completed with the response
-         */
-        internal fun onResponseReceived(transaction: HttpTransaction) {
-            scope.launch {
-                val updated =
-                    withContext(Dispatchers.IO) {
-                        RepositoryProvider.transaction().updateTransaction(transaction)
-                    }
-                if (showNotification && updated > 0) {
-                    notificationHelper.show(transaction)
-                }
-            }
-        }
-
-        /**
-         * Export the Chucker transactions to a file. Please note that this function is blocking
-         * and performs Disk I/O. Make sure you run it on a separate thread or coroutine.
-         *
-         * @param context Application context
-         * @param startTimestamp The timestamp to read transactions from. Passing null means
-         * transactions will not be limited by timestamp
-         * @param exportFormat The export format: LOG or HAR
-         * @return The content uri of a file with the transactions in or null if the export failed.
-         */
-        public fun writeTransactions(
-            context: Context,
-            startTimestamp: Long?,
-            exportFormat: ExportFormat = ExportFormat.LOG,
-        ): Uri? {
-            val transactions =
-                RepositoryProvider.transaction().getTransactionsInTimeRange(startTimestamp)
-            if (transactions.isEmpty()) {
-                return null
-            }
-
-            val sharableTransactions =
-                when (exportFormat) {
-                    ExportFormat.LOG -> {
-                        TransactionListDetailsSharable(transactions, encodeUrls = false)
-                    }
-                    ExportFormat.HAR -> {
-                        TransactionDetailsHarSharable(
-                            JsonConverter.nonNullSerializerInstance
-                                .toJson(
-                                    HarUtils.fromHttpTransactions(
-                                        transactions,
-                                        Creator(
-                                            context.getString(R.string.chucker_name),
-                                            context.getString(R.string.chucker_version),
-                                        ),
-                                    ),
-                                ),
-                        )
-                    }
-                }
-            return sharableTransactions.writeToFile(
-                context = context,
-                fileName = "api_transactions.${exportFormat.extension}",
-            )
-        }
-    }

package/android/src/main/java/com/securitysuite/api/ChuckerInterceptor.kt

@@ -1,280 +0,0 @@
-package com.securitysuite.api
-
-import android.content.Context
-import androidx.annotation.VisibleForTesting
-import com.securitysuite.internal.data.entity.HttpTransaction
-import com.securitysuite.internal.support.CacheDirectoryProvider
-import com.securitysuite.internal.support.PlainTextDecoder
-import com.securitysuite.internal.support.RequestProcessor
-import com.securitysuite.internal.support.ResponseProcessor
-import com.securitysuite.internal.support.addNonBlankPathSegments
-import okhttp3.HttpUrl
-import okhttp3.Interceptor
-import okhttp3.Response
-import java.io.IOException
-
-/**
- * An OkHttp Interceptor which persists and displays HTTP activity
- * in your application for later inspection.
- */
-public class ChuckerInterceptor private constructor(
-    builder: Builder,
-) : Interceptor {
-    /**
-     * An OkHttp Interceptor which persists and displays HTTP activity
-     * in your application for later inspection.
-     *
-     * This constructor  is a shorthand for `ChuckerInterceptor.Builder(context).build()`.
-     *
-     * @param context An Android [Context]
-     * @see ChuckerInterceptor.Builder
-     */
-    public constructor(context: Context) : this(Builder(context))
-
-    private val headersToRedact = builder.headersToRedact.toMutableSet()
-
-    private val decoders = builder.decoders + BUILT_IN_DECODERS
-
-    private val collector = builder.collector ?: ChuckerCollector(builder.context)
-
-    private val requestProcessor =
-        RequestProcessor(
-            builder.context,
-            collector,
-            builder.maxContentLength,
-            headersToRedact,
-            decoders,
-        )
-
-    private val responseProcessor =
-        ResponseProcessor(
-            collector,
-            builder.cacheDirectoryProvider ?: CacheDirectoryProvider { builder.context.filesDir },
-            builder.maxContentLength,
-            headersToRedact,
-            builder.alwaysReadResponseBody,
-            decoders,
-        )
-
-    private val skipPaths = builder.skipPaths.toSet()
-    private val skipPathsRegex = builder.skipPathsRegex.toSet()
-    private val skipDomains = builder.skipDomains.toSet()
-    private val skipDomainRegex = builder.skipDomainRegex.toSet()
-
-    init {
-        if (builder.createShortcut) {
-            Chucker.createShortcut(builder.context)
-        }
-    }
-
-    /** Adds [headerName] into [headersToRedact] */
-    public fun redactHeader(vararg headerName: String) {
-        headersToRedact.addAll(headerName)
-    }
-
-    @Throws(IOException::class)
-    override fun intercept(chain: Interceptor.Chain): Response {
-        val transaction = HttpTransaction()
-        val request = chain.request()
-        val path = request.url.encodedPath
-        val host = request.url.host
-        val shouldSkipPath = skipPaths.contains(path) || skipPathsRegex.any { it.matches(path) }
-        // Skip evaluation of domain if the path is already skipped
-        val shouldSkipDomain =
-            shouldSkipPath || skipDomains.contains(host) || skipDomainRegex.any { it.matches(host) }
-        val shouldProcessTheRequest = !(shouldSkipPath || shouldSkipDomain)
-
-        if (shouldProcessTheRequest) {
-            requestProcessor.process(request, transaction)
-        }
-        val response =
-            try {
-                chain.proceed(request)
-            } catch (e: IOException) {
-                transaction.error = e.toString()
-                collector.onResponseReceived(transaction)
-                throw e
-            }
-        return if (shouldProcessTheRequest) {
-            responseProcessor.process(response, transaction)
-        } else {
-            response
-        }
-    }
-
-    /**
-     * Assembles a new [ChuckerInterceptor].
-     *
-     * @param context An Android [Context].
-     */
-    @Suppress("TooManyFunctions")
-    public class Builder(internal var context: Context) {
-        internal var collector: ChuckerCollector? = null
-        internal var maxContentLength = MAX_CONTENT_LENGTH
-        internal var cacheDirectoryProvider: CacheDirectoryProvider? = null
-        internal var alwaysReadResponseBody = false
-        internal var headersToRedact = emptySet<String>()
-        internal var decoders = emptyList<BodyDecoder>()
-        internal var createShortcut = true
-        internal val skipPaths = mutableSetOf<String>()
-        internal val skipPathsRegex = mutableSetOf<Regex>()
-        internal val skipDomains = mutableSetOf<String>()
-        internal val skipDomainRegex = mutableSetOf<Regex>()
-
-        /**
-         * Sets the [ChuckerCollector] to customize data retention.
-         */
-        public fun collector(collector: ChuckerCollector): Builder =
-            apply {
-                this.collector = collector
-            }
-
-        /**
-         * Sets the maximum length for requests and responses content before their truncation.
-         *
-         * Warning: setting this value too high may cause unexpected results.
-         */
-        public fun maxContentLength(length: Long): Builder =
-            apply {
-                this.maxContentLength = length
-            }
-
-        /**
-         * Sets headers that will be redacted if their names match.
-         * They will be replaced with the `**` symbols in the Chucker UI.
-         */
-        public fun redactHeaders(headerNames: Iterable<String>): Builder =
-            apply {
-                this.headersToRedact = headerNames.toSet()
-            }
-
-        /**
-         * Sets headers that will be redacted if their names match.
-         * They will be replaced with the `**` symbols in the Chucker UI.
-         */
-        public fun redactHeaders(vararg headerNames: String): Builder =
-            apply {
-                this.headersToRedact = headerNames.toSet()
-            }
-
-        /**
-         * If set to `true` [ChuckerInterceptor] will read full content of response
-         * bodies even in case of parsing errors or closing the response body without reading it.
-         *
-         * Warning: enabling this feature may potentially cause different behaviour from the
-         * production application.
-         */
-        public fun alwaysReadResponseBody(enable: Boolean): Builder =
-            apply {
-                this.alwaysReadResponseBody = enable
-            }
-
-        /**
-         * Adds a [decoder] into Chucker's processing pipeline. Decoders are applied in an order they were added in.
-         * Request and response bodies are set to the first non–null value returned by any of the decoders.
-         */
-        public fun addBodyDecoder(decoder: BodyDecoder): Builder =
-            apply {
-                this.decoders += decoder
-            }
-
-        /**
-         * If set to `true`, [ChuckerInterceptor] will create a shortcut for your app
-         * to access list of transaction in Chucker.
-         */
-        public fun createShortcut(enable: Boolean): Builder =
-            apply {
-                this.createShortcut = enable
-            }
-
-        /**
-         * Sets provider of a directory where Chucker will save temporary responses
-         * before processing them.
-         */
-        @VisibleForTesting
-        internal fun cacheDirectorProvider(provider: CacheDirectoryProvider): Builder =
-            apply {
-                this.cacheDirectoryProvider = provider
-            }
-
-        /**
-         * Sets a list of [String] to skip paths. When any of the [String] matches
-         * a request path, the request will be skipped.
-         *
-         * **Note:** An empty path will be treated as the '/'.
-         * '//' will also be treated as the '/' path.
-         */
-        public fun skipPaths(vararg paths: String): Builder =
-            apply {
-                paths.forEach { candidatePath ->
-                    val httpUrl =
-                        HttpUrl.Builder()
-                            .scheme("https")
-                            .host("example.com")
-                            .addNonBlankPathSegments(candidatePath)
-                            .build()
-                    this@Builder.skipPaths.add(httpUrl.encodedPath)
-                }
-            }
-
-        /**
-         * Sets a list of [Regex] to skip paths. When any of the [Regex] matches a
-         * request path, the request will be skipped. Include [RegexOption] where
-         * necessary.
-         *
-         * ```
-         * ".*(jpg|jpeg|png|gif|webp|svg|bmp|ico)$".toRegex(), // Ignore all image requests
-         *  ".*iGnOrE.*"toRegex(RegexOption.IGNORE_CASE), // Case insensitive
-         *  ".*path/to/skip.*".toRegex(),
-         *  ".*path/ends/with/dev$".toRegex(),
-         * ```
-         */
-        public fun skipPaths(paths: Regex): Builder =
-            apply {
-                this.skipPathsRegex.add(paths)
-            }
-
-        /**
-         * Sets a list of [String] to skip domains. Domain names are evaluated in
-         * lowercase format. When any of the [String] matches a request domain, the
-         * request will be skipped.
-         *
-         * ```
-         * example.com, subdomain.example.com, exam-ple.com, eXaMpLe.CoM, example.co.uk
-         * ```
-         */
-        public fun skipDomains(vararg domains: String): Builder =
-            apply {
-                this@Builder.skipDomains.addAll(domains.map { it.lowercase() })
-            }
-
-        /**
-         * Sets a list of [Regex] to skip domains. Domain names are evaluated in
-         * lowercase format. When any of the [Regex] matches a request domain,
-         * the request will be skipped. Include [RegexOption] where necessary.
-         *
-         * ```
-         *  ".*iGnOrE.*"toRegex(RegexOption.IGNORE_CASE),
-         *  "ignoresubdomain.*".toRegex(),
-         *  "domainname.*".toRegex(),
-         *  ".*.dev$".toRegex(),
-         * ```
-         */
-        public fun skipDomains(domains: Regex): Builder =
-            apply {
-                this.skipDomainRegex.add(domains)
-            }
-
-        /**
-         * Creates a new [ChuckerInterceptor] instance with values defined in this
-         * builder.
-         */
-        public fun build(): ChuckerInterceptor = ChuckerInterceptor(this)
-    }
-
-    private companion object {
-        private const val MAX_CONTENT_LENGTH = 250_000L
-
-        private val BUILT_IN_DECODERS = listOf(PlainTextDecoder)
-    }
-}

package/android/src/main/java/com/securitysuite/api/ExportFormat.kt

@@ -1,12 +0,0 @@
-package com.securitysuite.api
-
-/**
- * The supported export format for transactions file exports.
- */
-public enum class ExportFormat(public val extension: String) {
-    /** LOG Format with txt extension */
-    LOG("txt"),
-
-    /** HAR format with har extension */
-    HAR("har"),
-}