@onekeyfe/react-native-native-logger 1.1.20 → 1.1.21

package/android/build.gradle

@@ -92,6 +92,7 @@ android {
   buildTypes {
     release {
       minifyEnabled false
+      consumerProguardFiles 'consumer-rules.pro'
     }
   }
 

package/android/consumer-rules.pro

@@ -0,0 +1,5 @@
+# Logback-android: keep classes required by logback XML configuration
+-keep class ch.qos.logback.** { *; }
+-keep class org.slf4j.** { *; }
+-dontwarn ch.qos.logback.**
+-dontwarn org.slf4j.**

package/android/src/main/AndroidManifest.xml

@@ -1 +1,8 @@
-<manifest xmlns:android="http://schemas.android.com/apk/res/android" />
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    <application>
+        <provider
+            android:name=".OneKeyLogInitProvider"
+            android:authorities="${applicationId}.onekeylog-init"
+            android:exported="false" />
+    </application>
+</manifest>

package/android/src/main/java/com/margelo/nitro/nativelogger/NativeLogger.kt

@@ -7,27 +7,82 @@ import java.io.File
 @DoNotStrip
 class NativeLogger : HybridNativeLoggerSpec() {
 
+    companion object {
+        /** Patterns that should never be written to log files */
+        private val sensitivePatterns = listOf(
+            // Hex-encoded private keys (64 hex chars), with optional 0x prefix
+            Regex("(?:0x)?[0-9a-fA-F]{64}"),
+            // WIF private keys (base58, starting with 5, K, or L)
+            Regex("\\b[5KL][1-9A-HJ-NP-Za-km-z]{50,51}\\b"),
+            // Extended keys (xprv/xpub/zprv/zpub/yprv/ypub)
+            Regex("\\b[xyzXYZ](?:prv|pub)[1-9A-HJ-NP-Za-km-z]{107,108}\\b"),
+            // BIP39 mnemonic-like sequences (12+ words of 3-8 lowercase letters)
+            Regex("(?:\\b[a-z]{3,8}\\b[\\s,]+){11,}\\b[a-z]{3,8}\\b"),
+            // Bearer/API tokens
+            Regex("(?:Bearer|token[=:]?)\\s*[A-Za-z0-9_.\\-+/=]{20,}"),
+            // Base64 encoded data that looks like keys (44+ chars)
+            Regex("(?:eyJ|AAAA)[A-Za-z0-9+/=]{40,}"),
+        )
+
+        /** Rate limiting: max messages per second */
+        private const val MAX_MESSAGES_PER_SECOND = 100
+        @Volatile private var messageCount = 0
+        @Volatile private var windowStartMs = System.currentTimeMillis()
+        private val rateLimitLock = Any()
+
+        private fun isRateLimited(): Boolean {
+            synchronized(rateLimitLock) {
+                val now = System.currentTimeMillis()
+                if (now - windowStartMs >= 1000L) {
+                    windowStartMs = now
+                    messageCount = 0
+                }
+                messageCount++
+                return messageCount > MAX_MESSAGES_PER_SECOND
+            }
+        }
+
+        fun sanitize(message: String): String {
+            var result = message
+            for (pattern in sensitivePatterns) {
+                result = pattern.replace(result, "[REDACTED]")
+            }
+            // Strip newlines to prevent log injection
+            result = result.replace("\n", " ").replace("\r", " ")
+            return result
+        }
+    }
+
     override fun write(level: Double, msg: String) {
+        if (isRateLimited()) return
+        val sanitized = sanitize(msg)
         when (level.toInt()) {
-            0 -> OneKeyLog.debug("JS", msg)
-            1 -> OneKeyLog.info("JS", msg)
-            2 -> OneKeyLog.warn("JS", msg)
-            3 -> OneKeyLog.error("JS", msg)
-            else -> OneKeyLog.info("JS", msg)
+            0 -> OneKeyLog.debug("JS", sanitized)
+            1 -> OneKeyLog.info("JS", sanitized)
+            2 -> OneKeyLog.warn("JS", sanitized)
+            3 -> OneKeyLog.error("JS", sanitized)
+            else -> OneKeyLog.info("JS", sanitized)
         }
     }
 
+    override fun getLogDirectory(): String {
+        return OneKeyLog.logsDirectory
+    }
+
     override fun getLogFilePaths(): Promise<Array<String>> {
         return Promise.async {
+            // Flush buffered log data so the active file reflects all written logs
+            OneKeyLog.flush()
             val dir = OneKeyLog.logsDirectory
             if (dir.isEmpty()) return@async arrayOf<String>()
             val files = File(dir).listFiles { _, name -> name.endsWith(".log") }
             if (files == null) {
-                OneKeyLog.warn("NativeLogger", "Failed to list log directory: $dir")
+                OneKeyLog.warn("NativeLogger", "Failed to list log directory")
                 return@async arrayOf<String>()
             }
+            // Return filenames only, not absolute paths
             files.sortedBy { it.name }
-                .map { it.absolutePath }.toTypedArray()
+                .map { it.name }.toTypedArray()
         }
     }
 
@@ -37,13 +92,13 @@ class NativeLogger : HybridNativeLoggerSpec() {
             if (dir.isEmpty()) return@async
             val files = File(dir).listFiles { _, name -> name.endsWith(".log") }
             if (files == null) {
-                OneKeyLog.warn("NativeLogger", "Failed to list log directory for deletion: $dir")
+                OneKeyLog.warn("NativeLogger", "Failed to list log directory for deletion")
                 return@async
             }
             // Skip the active log file to avoid breaking logback's open file handle
             files.filter { it.name != "app-latest.log" }.forEach { file ->
                 if (!file.delete()) {
-                    OneKeyLog.warn("NativeLogger", "Failed to delete log file: ${file.name}")
+                    OneKeyLog.warn("NativeLogger", "Failed to delete log file")
                 }
             }
         }

package/android/src/main/java/com/margelo/nitro/nativelogger/OneKeyLog.kt

@@ -12,8 +12,8 @@ import ch.qos.logback.core.util.FileSize
 import com.margelo.nitro.NitroModules
 import java.io.File
 import java.nio.charset.Charset
-import java.text.SimpleDateFormat
-import java.util.Date
+import java.time.LocalTime
+import java.time.format.DateTimeFormatter
 import java.util.Locale
 
 object OneKeyLog {
@@ -28,6 +28,18 @@ object OneKeyLog {
     @Volatile
     private var cachedLogsDir: String? = null
 
+    /**
+     * Initialise OneKeyLog with an Android Context before NitroModules is ready.
+     * Call this early in Application.onCreate() so that logs emitted before
+     * React Native loads are not silently dropped.
+     */
+    @JvmStatic
+    fun init(context: android.content.Context) {
+        if (cachedLogsDir == null) {
+            cachedLogsDir = "${context.cacheDir.absolutePath}/logs"
+        }
+    }
+
     val logsDirectory: String
         get() {
             cachedLogsDir?.let { return it }
@@ -99,7 +111,8 @@ object OneKeyLog {
             }
         }
 
-    private val timeFormatter = SimpleDateFormat("HH:mm:ss", Locale.US)
+    // DateTimeFormatter is immutable and thread-safe (unlike SimpleDateFormat)
+    private val timeFormatter = DateTimeFormatter.ofPattern("HH:mm:ss", Locale.US)
 
     private fun truncate(message: String): String {
         return if (message.length > MAX_MESSAGE_LENGTH) {
@@ -109,23 +122,84 @@ object OneKeyLog {
         }
     }
 
+    private fun sanitizeForLog(str: String): String {
+        return str.replace("\n", " ").replace("\r", " ")
+    }
+
+    /** Sanitize sensitive data from all log messages (native and JS) */
+    private val nativeSensitivePatterns = listOf(
+        Regex("(?:0x)?[0-9a-fA-F]{64}"),
+        Regex("\\b[5KL][1-9A-HJ-NP-Za-km-z]{50,51}\\b"),
+        Regex("\\b[xyzXYZ](?:prv|pub)[1-9A-HJ-NP-Za-km-z]{107,108}\\b"),
+        Regex("(?:\\b[a-z]{3,8}\\b[\\s,]+){11,}\\b[a-z]{3,8}\\b"),
+        Regex("(?:Bearer|token[=:]?)\\s*[A-Za-z0-9_.\\-+/=]{20,}"),
+        Regex("(?:eyJ|AAAA)[A-Za-z0-9+/=]{40,}"),
+    )
+
+    private fun sanitizeSensitive(message: String): String {
+        var result = message
+        for (pattern in nativeSensitivePatterns) {
+            result = pattern.replace(result, "[REDACTED]")
+        }
+        return result
+    }
+
     private fun formatMessage(tag: String, level: String, message: String): String {
-        if (tag == "JS") {
-            return truncate(message)
+        val safeTag = sanitizeForLog(tag.take(64))
+        val safeMessage = sanitizeSensitive(sanitizeForLog(message))
+        if (safeTag == "JS") {
+            return truncate(safeMessage)
+        }
+        val time = LocalTime.now().format(timeFormatter)
+        return truncate("$time | $level : [$safeTag] $safeMessage")
+    }
+
+    private fun log(tag: String, level: String, message: String, androidLogLevel: Int) {
+        val formatted = formatMessage(tag, level, message)
+        val l = logger
+        if (l != null) {
+            when (androidLogLevel) {
+                android.util.Log.DEBUG -> l.debug(formatted)
+                android.util.Log.INFO -> l.info(formatted)
+                android.util.Log.WARN -> l.warn(formatted)
+                android.util.Log.ERROR -> l.error(formatted)
+            }
+        } else {
+            // Fallback to android.util.Log when file logger is unavailable
+            // Use formatted (sanitized) message, not raw message
+            android.util.Log.println(androidLogLevel, "OneKey/${tag.take(64)}", formatted)
+        }
+    }
+
+    /**
+     * Flush all buffered log data to disk.
+     * Call before reading log files to ensure the active file is up-to-date.
+     */
+    @JvmStatic
+    fun flush() {
+        val loggerContext = LoggerFactory.getILoggerFactory()
+        if (loggerContext is LoggerContext) {
+            val appender = loggerContext.getLogger("OneKey")
+                ?.getAppender(APPENDER_NAME)
+            if (appender is RollingFileAppender<*>) {
+                try {
+                    appender.outputStream?.flush()
+                } catch (_: Exception) {
+                    // Ignore flush errors
+                }
+            }
         }
-        val time = timeFormatter.format(Date())
-        return truncate("$time | $level : [$tag] $message")
     }
 
     @JvmStatic
-    fun debug(tag: String, message: String) { logger?.debug(formatMessage(tag, "DEBUG", message)) }
+    fun debug(tag: String, message: String) { log(tag, "DEBUG", message, android.util.Log.DEBUG) }
 
     @JvmStatic
-    fun info(tag: String, message: String) { logger?.info(formatMessage(tag, "INFO", message)) }
+    fun info(tag: String, message: String) { log(tag, "INFO", message, android.util.Log.INFO) }
 
     @JvmStatic
-    fun warn(tag: String, message: String) { logger?.warn(formatMessage(tag, "WARN", message)) }
+    fun warn(tag: String, message: String) { log(tag, "WARN", message, android.util.Log.WARN) }
 
     @JvmStatic
-    fun error(tag: String, message: String) { logger?.error(formatMessage(tag, "ERROR", message)) }
+    fun error(tag: String, message: String) { log(tag, "ERROR", message, android.util.Log.ERROR) }
 }

package/android/src/main/java/com/margelo/nitro/nativelogger/OneKeyLogInitProvider.kt

@@ -0,0 +1,27 @@
+package com.margelo.nitro.nativelogger
+
+import android.content.ContentProvider
+import android.content.ContentValues
+import android.database.Cursor
+import android.net.Uri
+
+/**
+ * Auto-initialises [OneKeyLog] before Application.onCreate().
+ *
+ * ContentProvider.onCreate() is invoked by the system between
+ * Application.attachBaseContext() and Application.onCreate(),
+ * so the logger is ready for the earliest app-level code.
+ */
+class OneKeyLogInitProvider : ContentProvider() {
+
+    override fun onCreate(): Boolean {
+        context?.let { OneKeyLog.init(it) }
+        return true
+    }
+
+    override fun query(uri: Uri, proj: Array<String>?, sel: String?, selArgs: Array<String>?, sort: String?): Cursor? = null
+    override fun getType(uri: Uri): String? = null
+    override fun insert(uri: Uri, values: ContentValues?): Uri? = null
+    override fun delete(uri: Uri, sel: String?, selArgs: Array<String>?): Int = 0
+    override fun update(uri: Uri, values: ContentValues?, sel: String?, selArgs: Array<String>?): Int = 0
+}

package/ios/NativeLogger.swift

@@ -1,31 +1,92 @@
 import NitroModules
+import CocoaLumberjack
 
 class NativeLogger: HybridNativeLoggerSpec {
 
+    /// Patterns that should never be written to log files
+    private static let sensitivePatterns: [NSRegularExpression] = {
+        let patterns = [
+            // Hex-encoded private keys (64 hex chars), with optional 0x prefix
+            "(?:0x)?[0-9a-fA-F]{64}",
+            // WIF private keys (base58, starting with 5, K, or L)
+            "\\b[5KL][1-9A-HJ-NP-Za-km-z]{50,51}\\b",
+            // Extended keys (xprv/xpub/zprv/zpub/yprv/ypub)
+            "\\b[xyzXYZ](?:prv|pub)[1-9A-HJ-NP-Za-km-z]{107,108}\\b",
+            // BIP39 mnemonic-like sequences (12+ words of 3-8 lowercase letters)
+            "(?:\\b[a-z]{3,8}\\b[\\s,]+){11,}\\b[a-z]{3,8}\\b",
+            // Bearer/API tokens
+            "(?:Bearer|token[=:]?)\\s*[A-Za-z0-9_.\\-+/=]{20,}",
+            // Base64 encoded data that looks like keys (44+ chars)
+            "(?:eyJ|AAAA)[A-Za-z0-9+/=]{40,}",
+        ]
+        return patterns.compactMap { try? NSRegularExpression(pattern: $0) }
+    }()
+
+    /// Rate limiting: max messages per second
+    private static let maxMessagesPerSecond = 100
+    private static var messageCount = 0
+    private static var windowStart = Date()
+    private static let rateLimitLock = NSLock()
+
+    private static func isRateLimited() -> Bool {
+        rateLimitLock.lock()
+        defer { rateLimitLock.unlock() }
+        let now = Date()
+        if now.timeIntervalSince(windowStart) >= 1.0 {
+            windowStart = now
+            messageCount = 0
+        }
+        messageCount += 1
+        return messageCount > maxMessagesPerSecond
+    }
+
+    private static func sanitize(_ message: String) -> String {
+        var result = message
+        for regex in sensitivePatterns {
+            result = regex.stringByReplacingMatches(
+                in: result,
+                range: NSRange(result.startIndex..., in: result),
+                withTemplate: "[REDACTED]"
+            )
+        }
+        // Strip newlines to prevent log injection
+        result = result.replacingOccurrences(of: "\n", with: " ")
+        result = result.replacingOccurrences(of: "\r", with: " ")
+        return result
+    }
+
     func write(level: Double, msg: String) {
+        if NativeLogger.isRateLimited() { return }
+        let sanitized = NativeLogger.sanitize(msg)
         switch Int(level) {
-        case 0: OneKeyLog.debug("JS", msg)
-        case 1: OneKeyLog.info("JS", msg)
-        case 2: OneKeyLog.warn("JS", msg)
-        case 3: OneKeyLog.error("JS", msg)
-        default: OneKeyLog.info("JS", msg)
+        case 0: OneKeyLog.debug("JS", sanitized)
+        case 1: OneKeyLog.info("JS", sanitized)
+        case 2: OneKeyLog.warn("JS", sanitized)
+        case 3: OneKeyLog.error("JS", sanitized)
+        default: OneKeyLog.info("JS", sanitized)
         }
     }
 
+    func getLogDirectory() throws -> String {
+        return OneKeyLog.logsDirectory
+    }
+
     func getLogFilePaths() throws -> Promise<[String]> {
         return Promise.async {
+            // Flush buffered log data so the active file reflects all written logs
+            DDLog.flushLog()
             let dir = OneKeyLog.logsDirectory
             let fm = FileManager.default
             let files: [String]
             do {
                 files = try fm.contentsOfDirectory(atPath: dir)
             } catch {
-                OneKeyLog.warn("NativeLogger", "Failed to list log directory: \(error.localizedDescription)")
+                OneKeyLog.warn("NativeLogger", "Failed to list log directory")
                 return []
             }
+            // Return filenames only, not absolute paths
             return files
                 .filter { $0.hasSuffix(".log") }
-                .map { "\(dir)/\($0)" }
                 .sorted()
         }
     }
@@ -38,7 +99,7 @@ class NativeLogger: HybridNativeLoggerSpec {
             do {
                 files = try fm.contentsOfDirectory(atPath: dir)
             } catch {
-                OneKeyLog.warn("NativeLogger", "Failed to list log directory for deletion: \(error.localizedDescription)")
+                OneKeyLog.warn("NativeLogger", "Failed to list log directory for deletion")
                 return
             }
             // Skip the active log file to avoid breaking CocoaLumberjack's open file handle
@@ -46,7 +107,7 @@ class NativeLogger: HybridNativeLoggerSpec {
                 do {
                     try fm.removeItem(atPath: "\(dir)/\(file)")
                 } catch {
-                    OneKeyLog.warn("NativeLogger", "Failed to delete log file \(file): \(error.localizedDescription)")
+                    OneKeyLog.warn("NativeLogger", "Failed to delete log file")
                 }
             }
         }

package/ios/OneKeyLog.swift

@@ -5,13 +5,20 @@ private let ddLogLevel: DDLogLevel = .debug
 private class OneKeyLogFileManager: DDLogFileManagerDefault {
     private static let logPrefix = "app"
     private static let latestFileName = "\(logPrefix)-latest.log"
-    private static let dateFormatter: DateFormatter = {
+    private static let dateFormatterLock = NSLock()
+    private static let _dateFormatter: DateFormatter = {
         let fmt = DateFormatter()
         fmt.dateFormat = "yyyy-MM-dd"
         fmt.locale = Locale(identifier: "en_US_POSIX")
         return fmt
     }()
 
+    private static func formattedDate(_ date: Date) -> String {
+        dateFormatterLock.lock()
+        defer { dateFormatterLock.unlock() }
+        return _dateFormatter.string(from: date)
+    }
+
     /// Always write to app-latest.log (matches Android behavior)
     override var newLogFileName: String {
         return Self.latestFileName
@@ -23,33 +30,40 @@ private class OneKeyLogFileManager: DDLogFileManagerDefault {
 
     /// When rolled, rename app-latest.log → app-{yyyy-MM-dd}.{i}.log (matches Android pattern)
     override func didArchiveLogFile(atPath logFilePath: String, wasRolled: Bool) {
-        if wasRolled {
-            let dir = (logFilePath as NSString).deletingLastPathComponent
-            let dateStr = Self.dateFormatter.string(from: Date())
-            let fm = FileManager.default
-
-            // Find next available index, retry on move failure to handle TOCTOU race
-            var index = 0
-            var moved = false
-            while !moved && index < 1000 {
-                let archivedPath = "\(dir)/\(Self.logPrefix)-\(dateStr).\(index).log"
-                if fm.fileExists(atPath: archivedPath) {
-                    index += 1
-                    continue
-                }
-                do {
-                    try fm.moveItem(atPath: logFilePath, toPath: archivedPath)
-                    moved = true
-                } catch {
-                    // Another thread may have created this file; try next index
-                    index += 1
-                }
+        guard wasRolled else {
+            super.didArchiveLogFile(atPath: logFilePath, wasRolled: wasRolled)
+            return
+        }
+
+        let dir = (logFilePath as NSString).deletingLastPathComponent
+        let dateStr = Self.formattedDate(Date())
+        let fm = FileManager.default
+
+        // Find next available index, retry on move failure to handle TOCTOU race
+        var index = 0
+        var archivedPath = logFilePath
+        var moved = false
+        while !moved && index < 1000 {
+            archivedPath = "\(dir)/\(Self.logPrefix)-\(dateStr).\(index).log"
+            if fm.fileExists(atPath: archivedPath) {
+                index += 1
+                continue
             }
-            if !moved {
-                NSLog("[OneKeyLog] Failed to archive log file after 1000 attempts: %@", logFilePath)
+            do {
+                try fm.moveItem(atPath: logFilePath, toPath: archivedPath)
+                moved = true
+            } catch {
+                // Another thread may have created this file; try next index
+                index += 1
             }
         }
-        super.didArchiveLogFile(atPath: logFilePath, wasRolled: wasRolled)
+        if !moved {
+            NSLog("[OneKeyLog] Failed to archive log file after 1000 attempts: %@", logFilePath)
+            super.didArchiveLogFile(atPath: logFilePath, wasRolled: wasRolled)
+        } else {
+            // Pass the new path so the super class can find the file for cleanup
+            super.didArchiveLogFile(atPath: archivedPath, wasRolled: wasRolled)
+        }
     }
 }
 
@@ -86,13 +100,21 @@ private class OneKeyLogFileManager: DDLogFileManagerDefault {
         return true
     }()
 
-    private static let timeFormatter: DateFormatter = {
+    // Use a lock to protect DateFormatter (not thread-safe per Apple docs)
+    private static let timeFormatterLock = NSLock()
+    private static let _timeFormatter: DateFormatter = {
         let fmt = DateFormatter()
         fmt.dateFormat = "HH:mm:ss"
         fmt.locale = Locale(identifier: "en_US_POSIX")
         return fmt
     }()
 
+    private static func formattedTime(_ date: Date) -> String {
+        timeFormatterLock.lock()
+        defer { timeFormatterLock.unlock() }
+        return _timeFormatter.string(from: date)
+    }
+
     private static func truncate(_ message: String) -> String {
         if message.count > maxMessageLength {
             return String(message.prefix(maxMessageLength)) + "...(truncated)"
@@ -100,12 +122,44 @@ private class OneKeyLogFileManager: DDLogFileManagerDefault {
         return message
     }
 
+    private static func sanitizeForLog(_ str: String) -> String {
+        return str.replacingOccurrences(of: "\n", with: " ")
+                  .replacingOccurrences(of: "\r", with: " ")
+    }
+
+    /// Sanitize sensitive data from native-side log messages
+    private static let nativeSensitivePatterns: [NSRegularExpression] = {
+        let patterns = [
+            "(?:0x)?[0-9a-fA-F]{64}",
+            "\\b[5KL][1-9A-HJ-NP-Za-km-z]{50,51}\\b",
+            "\\b[xyzXYZ](?:prv|pub)[1-9A-HJ-NP-Za-km-z]{107,108}\\b",
+            "(?:\\b[a-z]{3,8}\\b[\\s,]+){11,}\\b[a-z]{3,8}\\b",
+            "(?:Bearer|token[=:]?)\\s*[A-Za-z0-9_.\\-+/=]{20,}",
+            "(?:eyJ|AAAA)[A-Za-z0-9+/=]{40,}",
+        ]
+        return patterns.compactMap { try? NSRegularExpression(pattern: $0) }
+    }()
+
+    private static func sanitizeSensitive(_ message: String) -> String {
+        var result = message
+        for regex in nativeSensitivePatterns {
+            result = regex.stringByReplacingMatches(
+                in: result,
+                range: NSRange(result.startIndex..., in: result),
+                withTemplate: "[REDACTED]"
+            )
+        }
+        return result
+    }
+
     private static func formatMessage(_ tag: String, _ level: String, _ message: String) -> String {
-        if tag == "JS" {
-            return truncate(message)
+        let safeTag = sanitizeForLog(String(tag.prefix(64)))
+        let safeMessage = sanitizeSensitive(sanitizeForLog(message))
+        if safeTag == "JS" {
+            return truncate(safeMessage)
         }
-        let time = timeFormatter.string(from: Date())
-        return truncate("\(time) | \(level) : [\(tag)] \(message)")
+        let time = formattedTime(Date())
+        return truncate("\(time) | \(level) : [\(safeTag)] \(safeMessage)")
     }
 
     @objc public static func debug(_ tag: String, _ message: String) {

package/lib/typescript/src/NativeLogger.nitro.d.ts

@@ -4,6 +4,7 @@ export interface NativeLogger extends HybridObject<{
     android: 'kotlin';
 }> {
     write(level: number, msg: string): void;
+    getLogDirectory(): string;
     getLogFilePaths(): Promise<string[]>;
     deleteLogFiles(): Promise<void>;
 }

package/lib/typescript/src/NativeLogger.nitro.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NativeLogger.nitro.d.ts","sourceRoot":"","sources":["../../../src/NativeLogger.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAE/D,MAAM,WAAW,YACf,SAAQ,YAAY,CAAC;IAAE,GAAG,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,QAAQ,CAAA;CAAE,CAAC;IACzD,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IACxC,eAAe,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IACrC,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACjC"}
+{"version":3,"file":"NativeLogger.nitro.d.ts","sourceRoot":"","sources":["../../../src/NativeLogger.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAE/D,MAAM,WAAW,YACf,SAAQ,YAAY,CAAC;IAAE,GAAG,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,QAAQ,CAAA;CAAE,CAAC;IACzD,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IACxC,eAAe,IAAI,MAAM,CAAC;IAC1B,eAAe,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IACrC,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACjC"}

package/nitrogen/generated/android/c++/JHybridNativeLoggerSpec.cpp

@@ -50,6 +50,11 @@ namespace margelo::nitro::nativelogger {
     static const auto method = javaClassStatic()->getMethod<void(double /* level */, jni::alias_ref<jni::JString> /* msg */)>("write");
     method(_javaPart, level, jni::make_jstring(msg));
   }
+  std::string JHybridNativeLoggerSpec::getLogDirectory() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getLogDirectory");
+    auto __result = method(_javaPart);
+    return __result->toStdString();
+  }
   std::shared_ptr<Promise<std::vector<std::string>>> JHybridNativeLoggerSpec::getLogFilePaths() {
     static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("getLogFilePaths");
     auto __result = method(_javaPart);

package/nitrogen/generated/android/c++/JHybridNativeLoggerSpec.hpp

@@ -55,6 +55,7 @@ namespace margelo::nitro::nativelogger {
   public:
     // Methods
     void write(double level, const std::string& msg) override;
+    std::string getLogDirectory() override;
     std::shared_ptr<Promise<std::vector<std::string>>> getLogFilePaths() override;
     std::shared_ptr<Promise<void>> deleteLogFiles() override;
 

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nativelogger/HybridNativeLoggerSpec.kt

@@ -50,6 +50,10 @@ abstract class HybridNativeLoggerSpec: HybridObject() {
   @Keep
   abstract fun write(level: Double, msg: String): Unit
   
+  @DoNotStrip
+  @Keep
+  abstract fun getLogDirectory(): String
+  
   @DoNotStrip
   @Keep
   abstract fun getLogFilePaths(): Promise<Array<String>>

package/nitrogen/generated/ios/ReactNativeNativeLogger-Swift-Cxx-Bridge.hpp

@@ -154,6 +154,15 @@ namespace margelo::nitro::nativelogger::bridge::swift {
     return Result<void>::withError(error);
   }
   
+  // pragma MARK: Result<std::string>
+  using Result_std__string_ = Result<std::string>;
+  inline Result_std__string_ create_Result_std__string_(const std::string& value) noexcept {
+    return Result<std::string>::withValue(value);
+  }
+  inline Result_std__string_ create_Result_std__string_(const std::exception_ptr& error) noexcept {
+    return Result<std::string>::withError(error);
+  }
+  
   // pragma MARK: Result<std::shared_ptr<Promise<std::vector<std::string>>>>
   using Result_std__shared_ptr_Promise_std__vector_std__string____ = Result<std::shared_ptr<Promise<std::vector<std::string>>>>;
   inline Result_std__shared_ptr_Promise_std__vector_std__string____ create_Result_std__shared_ptr_Promise_std__vector_std__string____(const std::shared_ptr<Promise<std::vector<std::string>>>& value) noexcept {

package/nitrogen/generated/ios/c++/HybridNativeLoggerSpecSwift.hpp

@@ -68,6 +68,14 @@ namespace margelo::nitro::nativelogger {
         std::rethrow_exception(__result.error());
       }
     }
+    inline std::string getLogDirectory() override {
+      auto __result = _swiftPart.getLogDirectory();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
     inline std::shared_ptr<Promise<std::vector<std::string>>> getLogFilePaths() override {
       auto __result = _swiftPart.getLogFilePaths();
       if (__result.hasError()) [[unlikely]] {

package/nitrogen/generated/ios/swift/HybridNativeLoggerSpec.swift

@@ -15,6 +15,7 @@ public protocol HybridNativeLoggerSpec_protocol: HybridObject {
 
   // Methods
   func write(level: Double, msg: String) throws -> Void
+  func getLogDirectory() throws -> String
   func getLogFilePaths() throws -> Promise<[String]>
   func deleteLogFiles() throws -> Promise<Void>
 }

package/nitrogen/generated/ios/swift/HybridNativeLoggerSpec_cxx.swift

@@ -128,6 +128,18 @@ open class HybridNativeLoggerSpec_cxx {
     }
   }
   
+  @inline(__always)
+  public final func getLogDirectory() -> bridge.Result_std__string_ {
+    do {
+      let __result = try self.__implementation.getLogDirectory()
+      let __resultCpp = std.string(__result)
+      return bridge.create_Result_std__string_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__string_(__exceptionPtr)
+    }
+  }
+  
   @inline(__always)
   public final func getLogFilePaths() -> bridge.Result_std__shared_ptr_Promise_std__vector_std__string____ {
     do {

package/nitrogen/generated/shared/c++/HybridNativeLoggerSpec.cpp

@@ -15,6 +15,7 @@ namespace margelo::nitro::nativelogger {
     // load custom methods/properties
     registerHybrids(this, [](Prototype& prototype) {
       prototype.registerHybridMethod("write", &HybridNativeLoggerSpec::write);
+      prototype.registerHybridMethod("getLogDirectory", &HybridNativeLoggerSpec::getLogDirectory);
       prototype.registerHybridMethod("getLogFilePaths", &HybridNativeLoggerSpec::getLogFilePaths);
       prototype.registerHybridMethod("deleteLogFiles", &HybridNativeLoggerSpec::deleteLogFiles);
     });

package/nitrogen/generated/shared/c++/HybridNativeLoggerSpec.hpp

@@ -51,6 +51,7 @@ namespace margelo::nitro::nativelogger {
     public:
       // Methods
       virtual void write(double level, const std::string& msg) = 0;
+      virtual std::string getLogDirectory() = 0;
       virtual std::shared_ptr<Promise<std::vector<std::string>>> getLogFilePaths() = 0;
       virtual std::shared_ptr<Promise<void>> deleteLogFiles() = 0;
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/react-native-native-logger",
-  "version": "1.1.20",
+  "version": "1.1.21",
   "description": "react-native-native-logger",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",

package/src/NativeLogger.nitro.ts

@@ -3,6 +3,7 @@ import type { HybridObject } from 'react-native-nitro-modules';
 export interface NativeLogger
   extends HybridObject<{ ios: 'swift'; android: 'kotlin' }> {
   write(level: number, msg: string): void;
+  getLogDirectory(): string;
   getLogFilePaths(): Promise<string[]>;
   deleteLogFiles(): Promise<void>;
 }