vkdeploy-push 1.0.1 → 1.1.0

package/README.md

@@ -52,7 +52,7 @@ if (result.status === 'error') {
 
 ## Configuracao
 
-Crie o arquivo `android/app/src/main/assets/versionamento-vktech-config.json`:
+Crie o arquivo `android/app/src/main/assets/vkdeploy-config.json`:
 
 ```json
 {
@@ -96,3 +96,57 @@ setLogger({
   error: (message, context) => console.error(message, context),
 });
 ```
+
+## Monitoramento de falhas (opcional, desligado por padrão)
+
+A partir da versão 1.1.0 o SDK pode reportar as saídas anormais do app. O recurso
+nasce **desligado** e só é habilitado pelo painel, por projeto — não há chave de
+ativação no `vkdeploy-config.json` nem no código do app.
+
+### O que é coletado
+
+A fonte é o `ApplicationExitInfo` do Android (API 30+), lido na abertura seguinte
+à falha. Isso cobre quatro classes de problema que o JavaScript não enxerga:
+
+| Motivo | Cobertura |
+| --- | --- |
+| `CRASH` | exceção Java/Kotlin não tratada |
+| `CRASH_NATIVE` | SIGSEGV e afins, com o tombstone do sistema |
+| `ANR` | dump de todas as threads |
+| `LOW_MEMORY` | processo morto por falta de memória, sem stack trace |
+
+Saídas normais (usuário fechou o app, atualização do pacote, limpeza de processo
+em segundo plano) são descartadas no lado nativo.
+
+### Como ligar
+
+1. Abra o projeto no painel do Versionamento.
+2. Ative a chave **Monitoramento de falhas**.
+
+A configuração viaja junto da resposta de `POST /versao`, que o app já consulta a
+cada abertura, então não há requisição adicional. A propagação é imediata para
+quem alterna a chave e de no máximo 5 minutos caso a linha seja alterada direto
+no banco.
+
+### Garantias
+
+- **Nada é coletado com a chave desligada.** O módulo nativo só é consultado após
+  o servidor confirmar que o projeto tem o recurso habilitado, e o servidor
+  descarta lotes de projetos desligados.
+- **Ligar a chave não sobe o histórico anterior.** O instante da ativação é usado
+  como marca d'água mínima.
+- **Nenhuma falha é perdida por erro de rede.** A marca d'água local só avança
+  após confirmação do servidor; um envio que falha é repetido na abertura
+  seguinte, e o servidor deduplica pela chave `(projeto, deviceId, ocorridoEm)`.
+- **O monitoramento nunca bloqueia a atualização.** Qualquer erro de coleta ou
+  envio é registrado no logger e ignorado.
+
+### Requisito de build
+
+Esta versão adiciona código nativo. Código nativo **não é entregue por bundle
+OTA**: após atualizar para a 1.1.0 é preciso gerar e publicar um APK novo. Em
+apps que atualizaram apenas o bundle, o SDK detecta a ausência do módulo nativo,
+registra um aviso e segue funcionando sem monitoramento.
+
+Dispositivos abaixo do Android 11 não expõem o histórico de saídas do sistema e
+ficam sem esta camada de cobertura.

package/android/.gradle/buildOutputCleanup/cache.properties

@@ -0,0 +1,2 @@
+#Fri Sep 18 11:46:28 BRT 2026
+gradle.version=9.2.0

package/android/build.gradle

@@ -0,0 +1,53 @@
+buildscript {
+    // O app consumidor define estas versoes em rootProject.ext. Os valores de
+    // fallback existem apenas para quem compila a biblioteca isolada.
+    ext.getExtOrDefault = { name, fallback ->
+        rootProject.ext.has(name) ? rootProject.ext.get(name) : fallback
+    }
+
+    repositories {
+        google()
+        mavenCentral()
+    }
+
+    dependencies {
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion', '2.0.21')}"
+    }
+}
+
+apply plugin: 'com.android.library'
+apply plugin: 'org.jetbrains.kotlin.android'
+
+android {
+    namespace "com.vkdeploy.push"
+    compileSdk getExtOrDefault('compileSdkVersion', 35)
+
+    defaultConfig {
+        minSdk getExtOrDefault('minSdkVersion', 21)
+    }
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
+    }
+
+    kotlinOptions {
+        jvmTarget = "17"
+    }
+
+    lintOptions {
+        abortOnError false
+    }
+}
+
+repositories {
+    google()
+    mavenCentral()
+}
+
+dependencies {
+    // Sem versao: o plugin Gradle do React Native resolve o artefato correto
+    // a partir da versao de react-native usada pelo app consumidor.
+    implementation "com.facebook.react:react-android"
+    implementation "org.jetbrains.kotlin:kotlin-stdlib:${getExtOrDefault('kotlinVersion', '2.0.21')}"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android" />

package/android/src/main/java/com/vkdeploy/push/VkDeployMonitorModule.kt

@@ -0,0 +1,197 @@
+package com.vkdeploy.push
+
+import android.annotation.TargetApi
+import android.app.ActivityManager
+import android.app.ApplicationExitInfo
+import android.content.Context
+import android.os.Build
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.module.annotations.ReactModule
+
+/**
+ * Le as saidas anormais do proprio processo registradas pelo sistema.
+ *
+ * O Android mantem um historico curto de como cada processo do app terminou
+ * (ActivityManager.getHistoricalProcessExitReasons, API 30+). Consultar esse
+ * historico na abertura seguinte cobre, sem instalar nenhum handler, quatro
+ * classes de falha que o JavaScript nao enxerga:
+ *
+ *  - crash de Java/Kotlin em modulo nativo;
+ *  - crash nativo (SIGSEGV e afins), com o tombstone completo;
+ *  - ANR, com o dump de todas as threads;
+ *  - morte por falta de memoria, que nao gera stack trace em lugar nenhum e
+ *    costuma ser relatada pelo usuario como "o app fechou sozinho".
+ *
+ * Nada e coletado enquanto o monitoramento estiver desligado: o lado JavaScript
+ * so chama este modulo depois de o servidor confirmar que o projeto tem o
+ * recurso habilitado.
+ */
+@ReactModule(name = VkDeployMonitorModule.NAME)
+class VkDeployMonitorModule(
+    reactContext: ReactApplicationContext,
+) : ReactContextBaseJavaModule(reactContext) {
+
+    override fun getName(): String = NAME
+
+    /**
+     * Retorna as saidas anormais ocorridas depois de [desdeTimestamp].
+     *
+     * @param desdeTimestamp marca d'agua em epoch ms; saidas anteriores ou iguais
+     *   sao descartadas. O lado JavaScript guarda esse valor e o avanca somente
+     *   apos um envio confirmado, o que evita tanto perda quanto duplicata.
+     * @param maximo teto de itens lidos do historico do sistema.
+     */
+    @ReactMethod
+    fun coletaSaidasAnormais(desdeTimestamp: Double, maximo: Int, promise: Promise) {
+        try {
+            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.R) {
+                // Abaixo da API 30 a API nao existe. Devolver lista vazia mantem o
+                // fluxo do SDK identico e deixa a decisao de cobertura para a
+                // proxima camada (UncaughtExceptionHandler), que roda em qualquer
+                // versao.
+                promise.resolve(Arguments.createArray())
+                return
+            }
+
+            promise.resolve(leHistorico(desdeTimestamp.toLong(), maximo))
+        } catch (erro: Throwable) {
+            promise.reject("EXIT_INFO_ERRO", erro.message, erro)
+        }
+    }
+
+    /**
+     * Informa se este dispositivo consegue fornecer o historico de saidas.
+     */
+    @ReactMethod
+    fun suportaExitInfo(promise: Promise) {
+        promise.resolve(Build.VERSION.SDK_INT >= Build.VERSION_CODES.R)
+    }
+
+    @TargetApi(Build.VERSION_CODES.R)
+    private fun leHistorico(desde: Long, maximo: Int): WritableArray {
+        val resultado = Arguments.createArray()
+        val contexto = reactApplicationContext
+        val activityManager = contexto.getSystemService(Context.ACTIVITY_SERVICE) as? ActivityManager
+            ?: return resultado
+
+        val limite = maximo.coerceIn(1, MAX_ITENS)
+
+        val historico = activityManager.getHistoricalProcessExitReasons(
+            contexto.packageName,
+            PID_TODOS,
+            limite,
+        )
+
+        for (saida in historico) {
+            if (saida.timestamp <= desde) {
+                continue
+            }
+
+            if (saida.reason !in MOTIVOS_RELEVANTES) {
+                continue
+            }
+
+            resultado.pushMap(mapeia(saida))
+        }
+
+        return resultado
+    }
+
+    @TargetApi(Build.VERSION_CODES.R)
+    private fun mapeia(saida: ApplicationExitInfo): WritableMap {
+        val mapa = Arguments.createMap()
+
+        mapa.putInt("reason", saida.reason)
+        mapa.putString("reasonLabel", rotuloMotivo(saida.reason))
+        mapa.putString("descricao", saida.description)
+        mapa.putInt("importancia", saida.importance)
+        mapa.putString("importanciaLabel", rotuloImportancia(saida.importance))
+        // pss e rss vem em kB.
+        mapa.putDouble("pss", saida.pss.toDouble())
+        mapa.putDouble("rss", saida.rss.toDouble())
+        mapa.putDouble("ocorridoEm", saida.timestamp.toDouble())
+        mapa.putString("trace", leTrace(saida))
+        mapa.putString("osVersion", Build.VERSION.RELEASE)
+        mapa.putString("modelo", Build.MODEL)
+        mapa.putString("fabricante", Build.MANUFACTURER)
+
+        return mapa
+    }
+
+    /**
+     * Le o trace anexado a saida, quando existe.
+     *
+     * O sistema so anexa trace para ANR (dump das threads) e para crash nativo
+     * (tombstone). Em REASON_CRASH o resumo da excecao vem apenas em
+     * [ApplicationExitInfo.getDescription], e o retorno aqui e nulo.
+     *
+     * O tombstone pode passar de centenas de kB, entao a leitura e truncada: as
+     * primeiras linhas concentram o sinal (sinal recebido, endereco de falha e
+     * a pilha da thread que morreu).
+     */
+    @TargetApi(Build.VERSION_CODES.R)
+    private fun leTrace(saida: ApplicationExitInfo): String? {
+        return try {
+            saida.traceInputStream?.use { entrada ->
+                val buffer = ByteArray(MAX_TRACE_BYTES)
+                var lidos = 0
+
+                while (lidos < MAX_TRACE_BYTES) {
+                    val n = entrada.read(buffer, lidos, MAX_TRACE_BYTES - lidos)
+                    if (n <= 0) break
+                    lidos += n
+                }
+
+                if (lidos <= 0) null else String(buffer, 0, lidos, Charsets.UTF_8)
+            }
+        } catch (erro: Throwable) {
+            // Um trace ilegivel nao pode impedir o envio do resto do lote: o
+            // motivo, o instante e o uso de memoria ja identificam a falha.
+            null
+        }
+    }
+
+    private fun rotuloMotivo(reason: Int): String = when (reason) {
+        ApplicationExitInfo.REASON_CRASH -> "CRASH"
+        ApplicationExitInfo.REASON_CRASH_NATIVE -> "CRASH_NATIVE"
+        ApplicationExitInfo.REASON_ANR -> "ANR"
+        ApplicationExitInfo.REASON_LOW_MEMORY -> "LOW_MEMORY"
+        else -> "DESCONHECIDO_$reason"
+    }
+
+    private fun rotuloImportancia(importancia: Int): String = when (importancia) {
+        ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND -> "FOREGROUND"
+        ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND_SERVICE -> "FOREGROUND_SERVICE"
+        ActivityManager.RunningAppProcessInfo.IMPORTANCE_VISIBLE -> "VISIBLE"
+        ActivityManager.RunningAppProcessInfo.IMPORTANCE_PERCEPTIBLE -> "PERCEPTIBLE"
+        ActivityManager.RunningAppProcessInfo.IMPORTANCE_SERVICE -> "SERVICE"
+        ActivityManager.RunningAppProcessInfo.IMPORTANCE_CACHED -> "CACHED"
+        else -> "OUTRO_$importancia"
+    }
+
+    companion object {
+        const val NAME = "VkDeployMonitor"
+
+        private const val PID_TODOS = 0
+        private const val MAX_ITENS = 30
+        private const val MAX_TRACE_BYTES = 60_000
+
+        /**
+         * Motivos que representam falha. Saidas normais (usuario fechou o app,
+         * atualizacao do pacote, limpeza de processo em segundo plano) ficam de
+         * fora para nao poluir o painel com ruido que nao pede acao.
+         */
+        private val MOTIVOS_RELEVANTES = setOf(
+            ApplicationExitInfo.REASON_CRASH,
+            ApplicationExitInfo.REASON_CRASH_NATIVE,
+            ApplicationExitInfo.REASON_ANR,
+            ApplicationExitInfo.REASON_LOW_MEMORY,
+        )
+    }
+}

package/android/src/main/java/com/vkdeploy/push/VkDeployMonitorPackage.kt

@@ -0,0 +1,40 @@
+package com.vkdeploy.push
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import com.facebook.react.uimanager.ViewManager
+
+/**
+ * Registro do modulo nativo junto ao autolinking do React Native.
+ *
+ * Herda de BaseReactPackage para que a instancia so seja criada quando o modulo
+ * for de fato usado. Como o monitoramento nasce desligado, na maioria dos apps
+ * este modulo nunca chega a ser instanciado.
+ */
+class VkDeployMonitorPackage : BaseReactPackage() {
+
+    override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? =
+        if (name == VkDeployMonitorModule.NAME) VkDeployMonitorModule(reactContext) else null
+
+    override fun getReactModuleInfoProvider(): ReactModuleInfoProvider = ReactModuleInfoProvider {
+        mapOf(
+            VkDeployMonitorModule.NAME to ReactModuleInfo(
+                VkDeployMonitorModule.NAME,
+                VkDeployMonitorModule.NAME,
+                false, // canOverrideExistingModule
+                false, // needsEagerInit
+                false, // isCxxModule
+                // Modulo escrito a mao, sem spec de codegen: o React Native o expoe
+                // pela camada de interoperabilidade da nova arquitetura.
+                false, // isTurboModule
+            ),
+        )
+    }
+
+    override fun createViewManagers(
+        reactContext: ReactApplicationContext,
+    ): List<ViewManager<*, *>> = emptyList()
+}

package/dist/index.d.ts

@@ -11,5 +11,5 @@ declare const vkdeployPush: {
     resetLogger: typeof resetLogger;
 };
 export default vkdeployPush;
-export type { AtualizarResult, CheckUpdateResult, ErrorCheckResult, ErrorUpdateResult, LoggerContext, RemoteVersionResponse, UpdateLifecycleCallback, UpdatedCheckResult, UpdatedResult, UpToDateCheckResult, VersaoInfo, VkDeployError, VkDeployErrorCode, VkDeployLogger, } from './types';
+export type { AtualizarResult, CheckUpdateResult, ErrorCheckResult, ErrorUpdateResult, LoggerContext, MonitoramentoConfig, MonitoramentoResult, MonitoramentoStatus, RemoteVersionResponse, SaidaAnormal, UpdateLifecycleCallback, UpdatedCheckResult, UpdatedResult, UpToDateCheckResult, VersaoInfo, VkDeployError, VkDeployErrorCode, VkDeployLogger, } from './types';
 export { resetLogger, setLogger };

package/dist/index.js

@@ -9,6 +9,7 @@ const DBSQL_1 = require("./database/DBSQL");
 const logger_1 = require("./logger");
 Object.defineProperty(exports, "setLogger", { enumerable: true, get: function () { return logger_1.setLogger; } });
 Object.defineProperty(exports, "resetLogger", { enumerable: true, get: function () { return logger_1.resetLogger; } });
+const monitoring_1 = require("./monitoring");
 const network_1 = require("./network");
 const runtime_1 = require("./runtime");
 const functions_1 = require("./utils/functions");
@@ -87,6 +88,18 @@ async function getBuildVersion() {
         return (0, logger_1.createError)('INVALID_DEPENDENCY', 'Falha ao executar getVersion() de "react-native-device-info".', cause);
     }
 }
+async function getDeviceId() {
+    const deviceInfo = await (0, runtime_1.loadDeviceInfo)();
+    if (!deviceInfo.ok) {
+        return deviceInfo.error;
+    }
+    try {
+        return await deviceInfo.module.getUniqueId();
+    }
+    catch (cause) {
+        return (0, logger_1.createError)('INVALID_DEPENDENCY', 'Falha ao executar getUniqueId() de "react-native-device-info".', cause);
+    }
+}
 async function downloadBundleArchive(fromUrl, toFile) {
     const rnfs = await (0, runtime_1.loadRNFS)();
     if (!rnfs.ok) {
@@ -102,6 +115,28 @@ async function downloadBundleArchive(fromUrl, toFile) {
         return (0, logger_1.createError)('DOWNLOAD_FAILED', 'Falha ao baixar o bundle remoto.', cause);
     }
 }
+/**
+ * Executa o ciclo de monitoramento sem deixar que ele afete a atualizacao.
+ *
+ * Monitorar e um recurso acessorio: qualquer falha ao coletar ou enviar precisa
+ * ser registrada no log e ignorada, jamais impedir o app de receber um bundle
+ * novo. Por isso o resultado e apenas anotado e nenhuma excecao escapa daqui.
+ */
+async function executaMonitoramento(config, dados) {
+    try {
+        const resultado = await (0, monitoring_1.sincronizaMonitoramento)(API_BASE_URL, config, dados);
+        if (resultado.status === 'erro' && resultado.error) {
+            (0, logger_1.logError)(resultado.error.message, { code: resultado.error.code });
+            return;
+        }
+        if (resultado.status === 'enviado') {
+            (0, logger_1.logInfo)('Monitoramento sincronizado.', { enviados: resultado.enviados });
+        }
+    }
+    catch (cause) {
+        (0, logger_1.logError)('Falha inesperada no ciclo de monitoramento.', { cause });
+    }
+}
 async function getVersao() {
     return (0, DBSQL_1.buscaVersao)();
 }
@@ -119,12 +154,30 @@ async function checkUpdate(antes, depois) {
     if (typeof buildVersion !== 'string') {
         return toCheckErrorResult(buildVersion, versaoLocal);
     }
-    const remoteVersion = await (0, network_1.requestRemoteVersion)(API_BASE_URL, projectIdResult.projectId, buildVersion);
+    const deviceId = await getDeviceId();
+    if (typeof deviceId !== 'string') {
+        return toCheckErrorResult(deviceId, versaoLocal);
+    }
+    const remoteVersion = await (0, network_1.requestRemoteVersion)(API_BASE_URL, projectIdResult.projectId, buildVersion, deviceId);
     if (!remoteVersion.ok) {
         return toCheckErrorResult(remoteVersion.error, versaoLocal);
     }
+    // O monitoramento roda antes da decisao sobre atualizar, e nao depois, porque a
+    // atualizacao termina com o app sendo reiniciado: deixar o envio para o final
+    // faria com que justamente os dispositivos que recebem bundle novo nunca
+    // reportassem as falhas da versao anterior.
+    await executaMonitoramento(remoteVersion.data.monitoramento, {
+        projetoId: projectIdResult.projectId,
+        deviceId,
+        versaoBuild: buildVersion,
+        versaoBundle: versaoLocal.versao,
+    });
     const versaoAtual = versaoLocal.versao;
     const versaoRemota = remoteVersion.data.versao;
+    if (typeof versaoRemota !== 'number') {
+        return toCheckErrorResult((0, logger_1.createError)('INVALID_REMOTE_RESPONSE', 'A resposta da API de versão não contém um campo "versao" válido.'), versaoLocal);
+    }
+    console.log(`Versão atual: ${versaoAtual}, Versão remota: ${versaoRemota}`);
     if (versaoRemota === versaoAtual) {
         return {
             status: 'up-to-date',

package/dist/monitoring.d.ts

@@ -0,0 +1,18 @@
+import type { MonitoramentoConfig, MonitoramentoResult } from './types';
+/**
+ * Coleta e envia as saidas anormais registradas desde o ultimo ciclo.
+ *
+ * Executa apenas quando o painel tem o monitoramento ligado para o projeto. A
+ * marca d'agua efetiva e a maior entre a ultima saida ja enviada e o instante em
+ * que o recurso foi ativado, de modo que ligar a chave comeca a coleta dali para
+ * a frente e nunca sobe o historico anterior a ativacao.
+ *
+ * A marca d'agua so avanca apos confirmacao do servidor: se o envio falhar, o
+ * mesmo lote e tentado de novo na proxima abertura do app.
+ */
+export declare function sincronizaMonitoramento(apiBaseUrl: string, config: MonitoramentoConfig | undefined, dados: {
+    projetoId: string;
+    deviceId: string;
+    versaoBuild: string;
+    versaoBundle: number;
+}): Promise<MonitoramentoResult>;

package/dist/monitoring.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sincronizaMonitoramento = sincronizaMonitoramento;
+const logger_1 = require("./logger");
+const network_1 = require("./network");
+const runtime_1 = require("./runtime");
+const ARQUIVO_MARCA_DAGUA = 'vkdeploy-monitor.json';
+/**
+ * Teto de saidas lidas por execucao.
+ *
+ * O proprio Android guarda cerca de 16 saidas por processo, entao este valor nao
+ * costuma ser alcancado; ele limita o tamanho do lote em dispositivos que
+ * acumularam historico sem conseguir enviar.
+ */
+const MAX_SAIDAS_POR_EXECUCAO = 25;
+function caminhoMarcaDagua(documentDirectoryPath) {
+    return `${documentDirectoryPath}/${ARQUIVO_MARCA_DAGUA}`;
+}
+/**
+ * Le o instante da ultima saida anormal ja enviada com sucesso.
+ *
+ * Retorna 0 quando o arquivo nao existe ou esta corrompido, o que faz o proximo
+ * ciclo reenviar o que ainda estiver no historico do sistema. O indice unico do
+ * servidor absorve a repeticao, entao errar para o lado do reenvio e seguro,
+ * enquanto errar para o lado de pular perderia a falha de forma definitiva.
+ */
+async function leMarcaDagua() {
+    const rnfs = await (0, runtime_1.loadRNFS)();
+    if (!rnfs.ok) {
+        return 0;
+    }
+    try {
+        const caminho = caminhoMarcaDagua(rnfs.module.DocumentDirectoryPath);
+        if (!(await rnfs.module.exists(caminho))) {
+            return 0;
+        }
+        const conteudo = await rnfs.module.readFile(caminho, 'utf8');
+        const dados = JSON.parse(conteudo);
+        return typeof dados.ultimaSaidaEnviada === 'number' && Number.isFinite(dados.ultimaSaidaEnviada)
+            ? dados.ultimaSaidaEnviada
+            : 0;
+    }
+    catch {
+        return 0;
+    }
+}
+async function salvaMarcaDagua(valor) {
+    const rnfs = await (0, runtime_1.loadRNFS)();
+    if (!rnfs.ok) {
+        return;
+    }
+    try {
+        await rnfs.module.writeFile(caminhoMarcaDagua(rnfs.module.DocumentDirectoryPath), JSON.stringify({ ultimaSaidaEnviada: valor }), 'utf8');
+    }
+    catch (cause) {
+        // Falhar ao gravar a marca d'agua apenas provoca reenvio no proximo ciclo,
+        // que o servidor deduplica. Nao ha motivo para interromper o fluxo.
+        (0, logger_1.logWarn)('Nao foi possivel salvar a marca d\'agua do monitoramento.', { cause });
+    }
+}
+/**
+ * Coleta e envia as saidas anormais registradas desde o ultimo ciclo.
+ *
+ * Executa apenas quando o painel tem o monitoramento ligado para o projeto. A
+ * marca d'agua efetiva e a maior entre a ultima saida ja enviada e o instante em
+ * que o recurso foi ativado, de modo que ligar a chave comeca a coleta dali para
+ * a frente e nunca sobe o historico anterior a ativacao.
+ *
+ * A marca d'agua so avanca apos confirmacao do servidor: se o envio falhar, o
+ * mesmo lote e tentado de novo na proxima abertura do app.
+ */
+async function sincronizaMonitoramento(apiBaseUrl, config, dados) {
+    var _a;
+    if (!(config === null || config === void 0 ? void 0 : config.ativo)) {
+        return { status: 'desligado', enviados: 0 };
+    }
+    const nativo = await (0, runtime_1.loadMonitorNative)();
+    if (!nativo.ok) {
+        return { status: 'nao-suportado', enviados: 0, error: nativo.error };
+    }
+    try {
+        if (!(await nativo.module.suportaExitInfo())) {
+            // Dispositivo abaixo do Android 11. A cobertura desta camada depende da
+            // API de historico de saidas, que nao existe nessas versoes.
+            return { status: 'nao-suportado', enviados: 0 };
+        }
+        const marcaLocal = await leMarcaDagua();
+        const marca = Math.max(marcaLocal, (_a = config.ativadoEm) !== null && _a !== void 0 ? _a : 0);
+        const saidas = await nativo.module.coletaSaidasAnormais(marca, MAX_SAIDAS_POR_EXECUCAO);
+        if (!Array.isArray(saidas) || saidas.length === 0) {
+            return { status: 'sem-novidades', enviados: 0 };
+        }
+        const envio = await (0, network_1.enviarSaidasAnormais)(apiBaseUrl, {
+            projetoId: dados.projetoId,
+            deviceId: dados.deviceId,
+            versaoBuild: dados.versaoBuild,
+            versaoBundle: dados.versaoBundle,
+            saidas,
+        });
+        if (!envio.ok) {
+            return { status: 'erro', enviados: 0, error: envio.error };
+        }
+        const maisRecente = saidas.reduce((maior, saida) => (saida.ocorridoEm > maior ? saida.ocorridoEm : maior), marca);
+        await salvaMarcaDagua(maisRecente);
+        (0, logger_1.logInfo)('Saidas anormais enviadas.', {
+            quantidade: saidas.length,
+            gravados: envio.data.gravados,
+        });
+        return { status: 'enviado', enviados: saidas.length };
+    }
+    catch (cause) {
+        return {
+            status: 'erro',
+            enviados: 0,
+            error: (0, logger_1.createError)('MONITOR_COLLECT_FAILED', 'Falha ao coletar as saidas anormais do dispositivo.', cause),
+        };
+    }
+}

package/dist/network.d.ts

@@ -1,4 +1,4 @@
-import type { RemoteVersionResponse, VkDeployError } from './types';
+import type { RemoteVersionResponse, SaidaAnormal, VkDeployError } from './types';
 type Result<T> = {
     ok: true;
     data: T;
@@ -6,6 +6,22 @@ type Result<T> = {
     ok: false;
     error: VkDeployError;
 };
-export declare function requestRemoteVersion(apiBaseUrl: string, projectId: string, buildVersion: string): Promise<Result<RemoteVersionResponse>>;
+export declare function requestRemoteVersion(apiBaseUrl: string, projectId: string, buildVersion: string, deviceId: string): Promise<Result<RemoteVersionResponse>>;
+/**
+ * Envia ao servidor as saidas anormais coletadas neste dispositivo.
+ *
+ * O servidor confere a chave de monitoramento do projeto antes de gravar, entao
+ * um lote enviado por um dispositivo com configuracao desatualizada e descartado
+ * do outro lado.
+ */
+export declare function enviarSaidasAnormais(apiBaseUrl: string, payload: {
+    projetoId: string;
+    deviceId: string;
+    versaoBuild: string;
+    versaoBundle: number;
+    saidas: SaidaAnormal[];
+}): Promise<Result<{
+    gravados: number;
+}>>;
 export declare function resolveBundleFileName(bundleUrl: string): Promise<string>;
 export {};

package/dist/network.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.requestRemoteVersion = requestRemoteVersion;
+exports.enviarSaidasAnormais = enviarSaidasAnormais;
 exports.resolveBundleFileName = resolveBundleFileName;
 const logger_1 = require("./logger");
-async function requestRemoteVersion(apiBaseUrl, projectId, buildVersion) {
+async function requestRemoteVersion(apiBaseUrl, projectId, buildVersion, deviceId) {
     try {
         const response = await fetch(`${apiBaseUrl}/versao`, {
             method: 'POST',
@@ -14,6 +15,7 @@ async function requestRemoteVersion(apiBaseUrl, projectId, buildVersion) {
             body: JSON.stringify({
                 projetoId: projectId,
                 versaoBuild: buildVersion,
+                deviceId,
             }),
         });
         if (!response.ok) {
@@ -23,17 +25,17 @@ async function requestRemoteVersion(apiBaseUrl, projectId, buildVersion) {
             };
         }
         const data = (await response.json());
-        if (typeof data.versao !== 'number' || Number.isNaN(data.versao)) {
-            return {
-                ok: false,
-                error: (0, logger_1.createError)('INVALID_REMOTE_RESPONSE', 'A resposta da API de versão não contém um campo "versao" válido.'),
-            };
-        }
+        // A validacao de "versao" acontece em checkUpdate, e nao aqui. Um projeto sem
+        // versao ativa publicada recebe uma resposta sem esse campo, e mesmo assim
+        // precisa ter a configuracao de monitoramento lida: caso contrario ligar a
+        // chave no painel nao surtiria efeito nesses projetos.
+        const versao = typeof data.versao === 'number' && !Number.isNaN(data.versao) ? data.versao : undefined;
         return {
             ok: true,
             data: {
-                versao: data.versao,
+                versao,
                 mandatori: data.mandatori,
+                monitoramento: normalizaMonitoramento(data.monitoramento),
             },
         };
     }
@@ -44,6 +46,61 @@ async function requestRemoteVersion(apiBaseUrl, projectId, buildVersion) {
         };
     }
 }
+/**
+ * Normaliza a configuracao de monitoramento vinda do servidor.
+ *
+ * Qualquer formato inesperado resulta em "desligado": o recurso e opt-in e nao
+ * pode ser ativado por acidente a partir de uma resposta malformada.
+ */
+function normalizaMonitoramento(valor) {
+    if (!valor || typeof valor !== 'object') {
+        return { ativo: false, ativadoEm: null };
+    }
+    const bruto = valor;
+    const ativadoEm = typeof bruto.ativadoEm === 'number' && Number.isFinite(bruto.ativadoEm)
+        ? bruto.ativadoEm
+        : null;
+    return {
+        ativo: bruto.ativo === true,
+        ativadoEm,
+    };
+}
+/**
+ * Envia ao servidor as saidas anormais coletadas neste dispositivo.
+ *
+ * O servidor confere a chave de monitoramento do projeto antes de gravar, entao
+ * um lote enviado por um dispositivo com configuracao desatualizada e descartado
+ * do outro lado.
+ */
+async function enviarSaidasAnormais(apiBaseUrl, payload) {
+    try {
+        const response = await fetch(`${apiBaseUrl}/erro`, {
+            method: 'POST',
+            headers: {
+                Accept: 'application/json',
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(payload),
+        });
+        if (!response.ok) {
+            return {
+                ok: false,
+                error: (0, logger_1.createError)('MONITOR_SEND_FAILED', `Erro ao enviar saidas anormais: HTTP ${response.status}`),
+            };
+        }
+        const data = (await response.json());
+        return {
+            ok: true,
+            data: { gravados: typeof data.gravados === 'number' ? data.gravados : 0 },
+        };
+    }
+    catch (cause) {
+        return {
+            ok: false,
+            error: (0, logger_1.createError)('MONITOR_SEND_FAILED', 'Falha ao enviar as saidas anormais.', cause),
+        };
+    }
+}
 async function resolveBundleFileName(bundleUrl) {
     var _a;
     try {

package/dist/runtime.d.ts

@@ -1,4 +1,4 @@
-import type { VkDeployError, VersaoInfo } from './types';
+import type { SaidaAnormal, VkDeployError, VersaoInfo } from './types';
 export type RNFSDirEntry = {
     path: string;
     name: string;
@@ -37,6 +37,11 @@ type ZipArchiveModule = {
     unzip(source: string, target: string): Promise<unknown>;
 };
 export type UnzipFunction = ZipArchiveModule['unzip'];
+/** Superficie do modulo nativo de monitoramento (android/src/main/.../VkDeployMonitorModule.kt). */
+export type MonitorNativeModule = {
+    coletaSaidasAnormais(desdeTimestamp: number, maximo: number): Promise<SaidaAnormal[]>;
+    suportaExitInfo(): Promise<boolean>;
+};
 type ModuleLoadResult<T> = {
     ok: true;
     module: T;
@@ -49,5 +54,14 @@ export declare function ensureSupportedPlatform(): Promise<VkDeployError | undef
 export declare function loadRNFS(): Promise<ModuleLoadResult<RNFSModule>>;
 export declare function loadDeviceInfo(): Promise<ModuleLoadResult<DeviceInfoModule>>;
 export declare function loadUnzip(): Promise<ModuleLoadResult<UnzipFunction>>;
+/**
+ * Carrega o modulo nativo de monitoramento.
+ *
+ * A ausencia do modulo e um caso esperado, nao um defeito: codigo nativo nao
+ * viaja em bundle OTA, entao um app que atualizou o vkdeploy-push por bundle sem
+ * gerar um APK novo continua sem ele. Nesse caso o monitoramento fica inativo e
+ * o restante do SDK segue funcionando normalmente.
+ */
+export declare function loadMonitorNative(): Promise<ModuleLoadResult<MonitorNativeModule>>;
 export declare function getSafeBundleVersion(): Promise<string>;
 export {};

package/dist/runtime.js

@@ -5,10 +5,12 @@ exports.ensureSupportedPlatform = ensureSupportedPlatform;
 exports.loadRNFS = loadRNFS;
 exports.loadDeviceInfo = loadDeviceInfo;
 exports.loadUnzip = loadUnzip;
+exports.loadMonitorNative = loadMonitorNative;
 exports.getSafeBundleVersion = getSafeBundleVersion;
 const logger_1 = require("./logger");
 const UNKNOWN_BUNDLE_VERSION = '0.0.0';
 const loggedMessages = new Set();
+const MONITOR_NATIVE_NAME = 'VkDeployMonitor';
 function logOnce(key, level, message, details) {
     if (loggedMessages.has(key)) {
         return;
@@ -135,6 +137,36 @@ async function loadUnzip() {
         module: unzip,
     };
 }
+/**
+ * Carrega o modulo nativo de monitoramento.
+ *
+ * A ausencia do modulo e um caso esperado, nao um defeito: codigo nativo nao
+ * viaja em bundle OTA, entao um app que atualizou o vkdeploy-push por bundle sem
+ * gerar um APK novo continua sem ele. Nesse caso o monitoramento fica inativo e
+ * o restante do SDK segue funcionando normalmente.
+ */
+async function loadMonitorNative() {
+    var _a;
+    const reactNative = await importModule('react-native');
+    if (!reactNative.ok) {
+        return reactNative;
+    }
+    const nativo = (_a = reactNative.module.NativeModules) === null || _a === void 0 ? void 0 : _a[MONITOR_NATIVE_NAME];
+    if (!nativo ||
+        typeof nativo.coletaSaidasAnormais !== 'function' ||
+        typeof nativo.suportaExitInfo !== 'function') {
+        const error = (0, logger_1.createError)('MONITOR_UNAVAILABLE', 'O modulo nativo "VkDeployMonitor" nao esta disponivel. Gere um novo APK apos atualizar o vkdeploy-push: codigo nativo nao e entregue por bundle OTA.');
+        logOnce('monitor:unavailable', 'warn', error.message, { code: error.code });
+        return {
+            ok: false,
+            error,
+        };
+    }
+    return {
+        ok: true,
+        module: nativo,
+    };
+}
 async function getSafeBundleVersion() {
     const deviceInfo = await loadDeviceInfo();
     if (!deviceInfo.ok) {

package/dist/types.d.ts

@@ -8,10 +8,51 @@ export interface VersionamentoConfig {
     app_secret: string;
 }
 export interface RemoteVersionResponse {
-    versao: number;
+    versao?: number;
     mandatori?: boolean;
+    monitoramento?: MonitoramentoConfig;
+}
+/**
+ * Configuracao de monitoramento entregue pelo servidor junto da resposta de versao.
+ *
+ * O recurso nasce desligado e so e ligado pelo painel; o app nunca decide isso
+ * sozinho e nao ha como habilitar por arquivo de configuracao local.
+ */
+export interface MonitoramentoConfig {
+    /** Indica se o projeto tem monitoramento habilitado no painel. */
+    ativo: boolean;
+    /**
+     * Epoch ms em que o monitoramento foi ligado, ou null quando desligado.
+     *
+     * Funciona como marca d'agua minima: saidas anormais anteriores a este instante
+     * sao descartadas, de modo que ligar a chave nunca envia o historico de falhas
+     * acumulado enquanto o recurso estava desligado.
+     */
+    ativadoEm: number | null;
+}
+/** Uma saida anormal do processo, como relatada pelo Android. */
+export interface SaidaAnormal {
+    reason: number;
+    reasonLabel: string;
+    descricao?: string | null;
+    importancia?: number;
+    importanciaLabel?: string;
+    pss?: number;
+    rss?: number;
+    ocorridoEm: number;
+    trace?: string | null;
+    osVersion?: string;
+    modelo?: string;
+    fabricante?: string;
+}
+export type MonitoramentoStatus = 'desligado' | 'nao-suportado' | 'sem-novidades' | 'enviado' | 'erro';
+export interface MonitoramentoResult {
+    status: MonitoramentoStatus;
+    /** Quantidade de saidas anormais enviadas ao servidor. */
+    enviados: number;
+    error?: VkDeployError;
 }
-export type VkDeployErrorCode = 'UNSUPPORTED_PLATFORM' | 'MISSING_DEPENDENCY' | 'INVALID_DEPENDENCY' | 'CONFIG_NOT_FOUND' | 'INVALID_CONFIG' | 'REMOTE_REQUEST_FAILED' | 'INVALID_REMOTE_RESPONSE' | 'DOWNLOAD_FAILED' | 'UNZIP_FAILED' | 'FILESYSTEM_ERROR' | 'UNKNOWN_ERROR';
+export type VkDeployErrorCode = 'UNSUPPORTED_PLATFORM' | 'MISSING_DEPENDENCY' | 'INVALID_DEPENDENCY' | 'CONFIG_NOT_FOUND' | 'INVALID_CONFIG' | 'REMOTE_REQUEST_FAILED' | 'INVALID_REMOTE_RESPONSE' | 'DOWNLOAD_FAILED' | 'UNZIP_FAILED' | 'FILESYSTEM_ERROR' | 'MONITOR_UNAVAILABLE' | 'MONITOR_COLLECT_FAILED' | 'MONITOR_SEND_FAILED' | 'UNKNOWN_ERROR';
 export interface VkDeployError {
     code: VkDeployErrorCode;
     message: string;

package/dist/utils/functions.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.buscProjetoId = buscProjetoId;
 const logger_1 = require("../logger");
 const runtime_1 = require("../runtime");
-const CONFIG_ASSET_PATH = 'versionamento-vktech-config.json';
+const CONFIG_ASSET_PATH = 'vkdeploy-config.json';
 async function buscProjetoId() {
     var _a;
     const rnfs = await (0, runtime_1.loadRNFS)();
@@ -17,7 +17,7 @@ async function buscProjetoId() {
     if (!exists) {
         return {
             ok: false,
-            error: (0, logger_1.createError)('CONFIG_NOT_FOUND', 'Arquivo de configuração não encontrado em android/app/src/main/assets/versionamento-vktech-config.json.'),
+            error: (0, logger_1.createError)('CONFIG_NOT_FOUND', 'Arquivo de configuração não encontrado em android/app/src/main/assets/vkdeploy-config.json.'),
         };
     }
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vkdeploy-push",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "Biblioteca React Native para versionamento e atualizacao remota de bundle Android.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -13,6 +13,7 @@
   },
   "files": [
     "dist",
+    "android",
     "README.md",
     "LICENSE"
   ],
@@ -28,7 +29,10 @@
     "android",
     "bundle",
     "ota",
-    "update"
+    "update",
+    "monitoring",
+    "crash",
+    "anr"
   ],
   "license": "MIT",
   "dependencies": {