@gatekeeperx/cordova-plugin-devicex 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,33 @@
+# Changelog
+
+> **Nota:** La versión del plugin Cordova es independiente de la versión del SDK nativo (AAR).
+> Cada release del plugin indica qué versión del SDK nativo incluye.
+
+## [0.1.0] - 2026-02-10
+
+### Added
+- `getPluginVersion()` — retorna la versión del plugin Cordova (string estático).
+- Versionamiento independiente del plugin Cordova vs SDK nativo.
+
+### Changed
+- Plugin Cordova ahora usa versión `0.1.0` (antes usaba la misma del SDK nativo).
+- `getVersion()` sigue retornando la versión del **SDK nativo** (AAR).
+
+### SDK nativo incluido
+- Device Intelligence SDK: **1.3.x** (AAR)
+- Bridge: `devicex-bridge.aar`
+
+---
+
+## [1.0.0] - 2026-01-19 (versión legacy, alineada con SDK)
+
+### Added
+- Initial release
+- Android support with cordova-android >= 11
+- Pre-compiled AAR bridge (Kotlin)
+- Device Intelligence SDK integration
+- Auto-configuration via plugin variables
+- TypeScript definitions
+
+### SDK nativo incluido
+- Device Intelligence SDK: **1.0.0** (AAR)

package/LICENSE

@@ -0,0 +1,11 @@
+Apache License 2.0
+Copyright 2026 GatekeeperX
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/README.md

@@ -0,0 +1,171 @@
+# @gatekeeperx/cordova-plugin-devicex
+
+[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
+
+Plugin oficial de Cordova para la integración del SDK **GatekeeperX Device Intelligence** en aplicaciones Android. Proporciona capacidades avanzadas de fingerprinting, detección de fraude (root, emuladores, hooks) y telemetría de seguridad.
+
+---
+
+## 📋 Requisitos
+
+Para integrar este plugin, asegúrate de cumplir con los siguientes requisitos:
+
+- **Cordova Android**: Versión `11.0.0` o superior.
+- **Java**: JDK 11 o 17.
+- **Android SDK**: API Level 21+ soportado (API 31+ recomendado).
+- **GatekeeperX Credentials**: Tenant ID y API Key válidos.
+
+---
+
+## 🔧 Instalación
+
+
+### Prerequisitos
+
+Asegúrate de tener instalado Node.js y npm en tu máquina. ejecuta este comando para instalar el plugin:
+
+
+```bash
+npm i @gatekeeperx/cordova-plugin-devicex
+```
+
+### Instalación
+
+Instala el plugin utilizando el CLI de Cordova o Ionic. Esto configurará automáticamente las dependencias nativas en tu proyecto.
+
+```bash
+# Usando Ionic CLI (Recomendado)
+ionic cordova plugin add @gatekeeperx/cordova-plugin-devicex
+
+# Usando Cordova CLI
+cordova plugin add @gatekeeperx/cordova-plugin-devicex
+```
+
+### Configuración de Plataforma
+
+Asegúrate de tener la plataforma Android configurada correctamente:
+
+```bash
+cordova platform add android@11
+```
+
+---
+
+## 📚 API Reference
+
+El plugin expone el objeto global `Devicex` una vez que el evento `deviceready` se ha disparado.
+
+### 1. `Devicex.configure(options)`
+Inicializa el SDK con las credenciales de tu proyecto. **Debe llamarse antes que cualquier otro método.**
+
+**Parámetros:**
+- `options` (`ConfigureOptions`):
+    - `tenant` (string, requerido): ID de tu tenant.
+    - `apiKey` (string, requerido): Tu clave de API.
+    - `environment` (string, opcional): `'SANDBOX'`, o `'PRODUCTION'`.
+    - `organizationId` (string, opcional): Identificador de organización.
+
+**Ejemplo:**
+```typescript
+await Devicex.configure({
+  tenant: 'mi-tenant',
+  apiKey: 'tu-api-key',
+  environment: 'PRODUCTION'
+});
+```
+
+### 2. `Devicex.sendEvent(name, properties?, headers?)`
+Envía un evento de telemetría con señales de seguridad adjuntas automáticamente.
+
+**Parámetros:**
+- `name` (string, requerido): Nombre del evento (ej: `'login'`, `'checkout'`).
+- `properties` (object, opcional): Metadatos adicionales del evento.
+- `headers` (object, opcional): Cabeceras HTTP personalizadas.
+
+**Ejemplo:**
+```typescript
+const result = await Devicex.sendEvent('login', { user: 'id_123' });
+if (result.ok) {
+  console.log('DeviceX ID:', result.deviceXId);
+}
+```
+
+### 3. `Devicex.isInitialized()`
+Verifica si el SDK ha sido configurado correctamente.
+
+**Retorna:** `Promise<boolean>`
+
+### 4. `Devicex.getVersion()`
+Obtiene la versión del SDK nativo subyacente.
+
+**Retorna:** `Promise<string>`
+
+---
+
+## 🚀 Uso Rápido (Ionic/Angular)
+
+```typescript
+// En app.component.ts
+async initializeApp() {
+  await this.platform.ready();
+  
+  if (this.platform.is('cordova')) {
+    declare const Devicex: any;
+    
+    try {
+      await Devicex.configure({
+        tenant: 'gatekeeperx', // tu tenant
+        apiKey: 'YOUR_API_KEY', // tu api key
+        environment: 'PRODUCTION' // PRODUCTION o SANDBOX
+      });
+      console.log('DeviceX Ready');
+    } catch (err) {
+      console.error('DeviceX Init Error', err);
+    }
+  }
+}
+
+
+async login() {
+    //,,, logica previo a enviar el login
+
+    loading.present();
+    try {
+        // Enviar evento de login para obtener deviceXId
+        const result = await this.deviceX.sendEvent('login', {
+            username: this.username,
+            method: 'password',
+            timestamp: new Date().toISOString(),
+            screen: 'login'
+        });
+        console.log('Evento enviado, deviceXId:', result.deviceXId);
+
+
+        /** EVALUACION DE RIESGO
+         *  Evaluar riesgo con GatekeeperX - debe hacerse back to back, no en el cliente.
+         *  debe ser dentro del proceso del login en el backend
+         *  si la decision es allow, se puede continuar con el login
+         *  si la decision es deny, se debe denegar el acceso
+         *  si la decision es unknown, se debe denegar el acceso
+         */
+       
+        //invocar proceso de login en el backend
+        const response = await this.http.post(BACKEND_URL, {
+            username: this.username,
+            password: this.password,
+            deviceXId: result.deviceXId
+        });
+        console.log('Login response:', JSON.stringify(response, null, 2));
+
+        loading.dismiss();
+
+
+        console.log('Login event result:', JSON.stringify(result, null, 2));
+
+    } catch (error) {
+        loading.dismiss();
+        console.error('Login event error:', error);
+        this.showAlert('Error', 'No se pudo enviar el evento de login', 'error');
+    }
+}
+```

package/package.json

@@ -0,0 +1,46 @@
+{
+    "name": "@gatekeeperx/cordova-plugin-devicex",
+    "version": "0.1.0",
+    "description": "GatekeeperX Device Intelligence Cordova plugin (Android)",
+    "license": "Apache-2.0",
+    "keywords": [
+        "cordova",
+        "cordova-android",
+        "gatekeeperx",
+        "device",
+        "security",
+        "intelligence"
+    ],
+    "engines": [
+        {
+            "name": "cordova-android",
+            "version": ">=11.0.0"
+        }
+    ],
+    "cordova": {
+        "id": "cordova-plugin-devicex",
+        "platforms": [
+            "android"
+        ]
+    },
+    "main": "www/devicex.js",
+    "types": "types/index.d.ts",
+    "files": [
+        "plugin.xml",
+        "www/",
+        "types/",
+        "src/android/",
+        "README.md",
+        "CHANGELOG.md",
+        "LICENSE"
+    ],
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/gatekeeperx/deviceX-plugins.git"
+    },
+    "author": "GatekeeperX",
+    "bugs": {
+        "url": "https://github.com/gatekeeperx/deviceX-plugins/issues"
+    },
+    "homepage": "https://github.com/gatekeeperx/deviceX-plugins/tree/master/cordova/cordova-plugin-devicex"
+}

package/plugin.xml

@@ -0,0 +1,51 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<plugin id="@gatekeeperx/cordova-plugin-devicex"
+  xmlns="http://apache.org/cordova/ns/plugins/1.0"
+  xmlns:android="http://schemas.android.com/apk/res/android" version="0.1.0">
+  <name>Devicex</name>
+  <description>GatekeeperX Device Intelligence Cordova plugin (Android)</description>
+  <license>Apache-2.0</license>
+  <keywords>cordova, gatekeeperx, device, intelligence, security</keywords>
+
+  <js-module name="Devicex" src="www/devicex.js">
+    <clobbers target="DeviceX" />
+  </js-module>
+
+  <engines>
+    <engine name="cordova-android" version=">=11.0.0" />
+  </engines>
+
+  <platform name="android">
+    <!-- Runtime dependencies -->
+    <!-- Kotlin stdlib alineado con el bridge -->
+    <framework src="org.jetbrains.kotlin:kotlin-stdlib:1.9.25" />
+    <framework src="org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3" />
+
+    <!-- Kotlinx Serialization (requerido por Ktor) -->
+    <framework src="org.jetbrains.kotlinx:kotlinx-serialization-json:1.6.2" />
+
+    <!-- Ktor Client (HTTP engine del SDK) -->
+    <framework src="io.ktor:ktor-client-cio:2.3.7" />
+    <framework src="io.ktor:ktor-client-logging:2.3.7" />
+    <framework src="io.ktor:ktor-client-content-negotiation:2.3.7" />
+    <framework src="io.ktor:ktor-serialization-kotlinx-json:2.3.7" />
+    <!-- AARs locales -->
+    <lib-file src="src/android/libs/devicex-bridge.aar" arch="device" />
+    <lib-file src="src/android/libs/devicex-1.3.1.aar" arch="device" />
+
+    <!-- Hook para configurar Gradle -->
+    <hook type="after_plugin_install" src="src/android/hooks/configure-gradle.js" />
+
+    <!-- Registrar el plugin nativo en config.xml -->
+    <config-file target="res/xml/config.xml" parent="/*">
+      <feature name="Devicex">
+        <param name="android-package" value="com.gatekeeperx.cordova.DevicexPlugin" />
+        <param name="onload" value="true" />
+      </feature>
+    </config-file>
+
+    <!-- Incluir las clases Java del plugin -->
+    <source-file src="src/android/com/gatekeeperx/cordova/DevicexPlugin.java" target-dir="src/com/gatekeeperx/cordova" />
+    <source-file src="src/android/com/gatekeeperx/cordova/GatekeeperXClient.java" target-dir="src/com/gatekeeperx/cordova" />
+  </platform>
+</plugin>

package/src/android/com/gatekeeperx/cordova/DevicexPlugin.java

@@ -0,0 +1,240 @@
+package com.gatekeeperx.cordova;
+
+import android.content.Context;
+
+import org.apache.cordova.CallbackContext;
+import org.apache.cordova.CordovaInterface;
+import org.apache.cordova.CordovaPlugin;
+import org.apache.cordova.CordovaWebView;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+public class DevicexPlugin extends CordovaPlugin {
+
+    @Override
+    public void initialize(CordovaInterface cordova, CordovaWebView webView) {
+        super.initialize(cordova, webView);
+        try {
+            Context ctx = cordova.getActivity().getApplicationContext();
+            android.util.Log.d("DevicexPlugin", "Reading meta-data from manifest...");
+
+            android.content.pm.ApplicationInfo ai = ctx.getPackageManager()
+                    .getApplicationInfo(ctx.getPackageName(), android.content.pm.PackageManager.GET_META_DATA);
+            android.os.Bundle meta = ai.metaData;
+
+            if (meta == null) {
+                android.util.Log.e("DevicexPlugin", "No meta-data found in manifest");
+                return;
+            }
+
+            String tenant = meta.getString("com.gatekeeperx.deviceintelligence.TENANT");
+            String apiKey = meta.getString("com.gatekeeperx.deviceintelligence.API_KEY");
+            String env = meta.getString("com.gatekeeperx.deviceintelligence.ENVIRONMENT");
+            String orgId = meta.getString("com.gatekeeperx.deviceintelligence.ORGANIZATION_ID");
+
+            android.util.Log.d("DevicexPlugin", "Tenant: " + tenant + ", Env: " + env);
+
+            if (tenant == null || tenant.trim().isEmpty() || apiKey == null || apiKey.trim().isEmpty()) {
+                android.util.Log.d("DevicexPlugin", "Auto-config skipped: no credentials provided");
+                return;
+            }
+
+            boolean ok = DevicexBridge.INSTANCE.configure(
+                    ctx,
+                    tenant.trim(),
+                    apiKey.trim(),
+                    env != null ? env.trim() : "PRODUCTION",
+                    orgId != null ? orgId.trim() : null,
+                    null);
+
+            android.util.Log.d("DevicexPlugin", "Manual configure result: " + ok);
+        } catch (Throwable e) {
+            android.util.Log.e("DevicexPlugin", "Error initializing: " + e.getMessage(), e);
+        }
+    }
+
+    @Override
+    public boolean execute(String action, JSONArray args, CallbackContext callbackContext) {
+        switch (action) {
+            case "configure":
+                configure(args, callbackContext);
+                return true;
+            case "sendEvent":
+                sendEvent(args, callbackContext);
+                return true;
+            case "isInitialized":
+                try {
+                    boolean value = DevicexBridge.INSTANCE.isInitialized();
+                    callbackContext.success(new JSONObject().put("value", value));
+                } catch (JSONException e) {
+                    callbackContext.error(e.getMessage());
+                }
+                return true;
+            case "getVersion":
+                try {
+                    String value = DevicexBridge.INSTANCE.getVersion();
+                    callbackContext.success(new JSONObject().put("value", value));
+                } catch (JSONException e) {
+                    callbackContext.error(e.getMessage());
+                }
+                return true;
+            // case "evaluateRisk":
+            // evaluateRisk(args, callbackContext);
+            // return true;
+            default:
+                return false;
+        }
+    }
+
+    private void configure(JSONArray args, CallbackContext cb) {
+        try {
+            JSONObject obj = args.optJSONObject(0);
+            if (obj == null)
+                obj = new JSONObject();
+            Context ctx = cordova.getActivity().getApplicationContext();
+            String tenant = obj.optString("tenant", "").trim();
+            String apiKey = obj.optString("apiKey", "").trim();
+            String orgId = obj.optString("organizationId", "").trim();
+            String env = obj.optString("environment", "PRODUCTION").trim();
+            JSONObject headersObj = obj.optJSONObject("headers");
+            Map<String, String> headers = headersObj != null ? toStringMap(headersObj) : new HashMap<>();
+
+            if (tenant.isEmpty() || apiKey.isEmpty()) {
+                cb.error("tenant and apiKey are required");
+                return;
+            }
+
+            boolean ok = DevicexBridge.INSTANCE.configure(
+                    ctx,
+                    tenant,
+                    apiKey,
+                    env,
+                    orgId.isEmpty() ? null : orgId,
+                    headers);
+            if (ok)
+                cb.success();
+            else
+                cb.error("configure failed");
+        } catch (Throwable e) {
+            cb.error(e.getMessage());
+        }
+    }
+
+    private void sendEvent(JSONArray args, final CallbackContext cb) {
+        try {
+            JSONObject obj = args.optJSONObject(0);
+            if (obj == null)
+                obj = new JSONObject();
+            String name = obj.optString("name", "").trim();
+            if (name.isEmpty()) {
+                cb.error("name is required");
+                return;
+            }
+            JSONObject propsObj = obj.optJSONObject("properties");
+            JSONObject headersObj = obj.optJSONObject("headers");
+            Map<String, Object> properties = propsObj != null ? toAnyMap(propsObj) : new HashMap<String, Object>();
+            Map<String, String> headers = headersObj != null ? toStringMap(headersObj) : new HashMap<String, String>();
+
+            @SuppressWarnings("unchecked")
+            DevicexBridge.EventCallback callback = new DevicexBridge.EventCallback() {
+                @Override
+                public void onResult(Map result) {
+                    try {
+                        cb.success(new JSONObject(result));
+                    } catch (Throwable t) {
+                        cb.error(t.getMessage());
+                    }
+                }
+            };
+            DevicexBridge.INSTANCE.sendEvent(name, properties, headers, callback);
+        } catch (Throwable e) {
+            cb.error(e.getMessage());
+        }
+    }
+
+    // Helpers
+    private static Map<String, String> toStringMap(JSONObject obj) {
+        Map<String, String> map = new HashMap<>();
+        Iterator<String> it = obj.keys();
+        while (it.hasNext()) {
+            String k = it.next();
+            String v = obj.optString(k, null);
+            if (v != null)
+                map.put(k, v);
+        }
+        return map;
+    }
+
+    private static Map<String, Object> toAnyMap(JSONObject obj) {
+        Map<String, Object> map = new HashMap<>();
+        Iterator<String> it = obj.keys();
+        while (it.hasNext()) {
+            String k = it.next();
+            Object v = obj.opt(k);
+            map.put(k, fromJson(v));
+        }
+        return map;
+    }
+
+    private static Object fromJson(Object v) {
+        if (v == null || v == JSONObject.NULL)
+            return null;
+        if (v instanceof JSONObject)
+            return toAnyMap((JSONObject) v);
+        if (v instanceof JSONArray)
+            return toList((JSONArray) v);
+        if (v instanceof String || v instanceof Boolean || v instanceof Integer || v instanceof Long
+                || v instanceof Double)
+            return v;
+        return String.valueOf(v);
+    }
+
+    private static List<Object> toList(JSONArray arr) {
+        List<Object> list = new ArrayList<>();
+        for (int i = 0; i < arr.length(); i++) {
+            Object v = arr.opt(i);
+            list.add(fromJson(v));
+        }
+        return list;
+    }
+
+    // private void evaluateRisk(JSONArray args, final CallbackContext cb) {
+    // try {
+    // JSONObject obj = args.optJSONObject(0);
+    // if (obj == null)
+    // obj = new JSONObject();
+
+    // String apiUrl = obj.optString("apiUrl", "");
+    // String orgId = obj.optString("organizationId", "");
+    // String apiKey = obj.optString("apiKey", "");
+    // JSONObject payload = obj.optJSONObject("payload");
+
+    // if (apiUrl.isEmpty() || orgId.isEmpty() || payload == null) {
+    // cb.error("apiUrl, organizationId and payload are required");
+    // return;
+    // }
+
+    // GatekeeperXClient.evaluateRisk(apiUrl, orgId, apiKey, payload, new
+    // GatekeeperXClient.Callback() {
+    // @Override
+    // public void onSuccess(JSONObject response) {
+    // cb.success(response);
+    // }
+
+    // @Override
+    // public void onError(String error) {
+    // cb.error(error);
+    // }
+    // });
+    // } catch (Exception e) {
+    // cb.error(e.getMessage());
+    // }
+    // }
+}

package/src/android/com/gatekeeperx/cordova/GatekeeperXClient.java

@@ -0,0 +1,110 @@
+package com.gatekeeperx.cordova;
+
+import android.os.AsyncTask;
+import android.util.Log;
+
+import org.json.JSONObject;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.net.HttpURLConnection;
+import java.net.URL;
+
+/**
+ * Cliente HTTP para llamadas al API de GatekeeperX.
+ * Ejecuta requests en background para evitar bloquear el UI thread.
+ */
+public class GatekeeperXClient {
+
+    private static final String TAG = "GatekeeperXClient";
+    private static final int CONNECT_TIMEOUT = 30000;
+    private static final int READ_TIMEOUT = 30000;
+
+    public interface Callback {
+        void onSuccess(JSONObject response);
+
+        void onError(String error);
+    }
+
+    /**
+     * Evalúa el riesgo de un evento enviando datos al API de GatekeeperX.
+     *
+     * @param apiUrl         URL del endpoint (ej:
+     *                       https://api.gatekeeperx.com/gatekeeperx/events/v1)
+     * @param organizationId ID de la organización
+     * @param apiKey         API Key para autenticación (opcional)
+     * @param payload        JSON con los datos del evento
+     * @param callback       Callback para manejar respuesta/error
+     */
+    private static void evaluateRisk(
+            final String apiUrl,
+            final String organizationId,
+            final String apiKey,
+            final JSONObject payload,
+            final Callback callback) {
+
+        new AsyncTask<Void, Void, Object>() {
+            @Override
+            protected Object doInBackground(Void... voids) {
+                HttpURLConnection conn = null;
+                try {
+                    URL url = new URL(apiUrl);
+                    conn = (HttpURLConnection) url.openConnection();
+                    conn.setRequestMethod("POST");
+                    conn.setRequestProperty("Content-Type", "application/json");
+                    conn.setRequestProperty("X-Organization-Id", organizationId);
+                    if (apiKey != null && !apiKey.isEmpty()) {
+                        conn.setRequestProperty("X-Api-Key", apiKey);
+                    }
+                    conn.setDoOutput(true);
+                    conn.setConnectTimeout(CONNECT_TIMEOUT);
+                    conn.setReadTimeout(READ_TIMEOUT);
+
+                    OutputStream os = conn.getOutputStream();
+                    os.write(payload.toString().getBytes("UTF-8"));
+                    os.close();
+
+                    int responseCode = conn.getResponseCode();
+                    BufferedReader br;
+                    if (responseCode >= 200 && responseCode < 300) {
+                        br = new BufferedReader(new InputStreamReader(conn.getInputStream(), "UTF-8"));
+                    } else {
+                        br = new BufferedReader(new InputStreamReader(conn.getErrorStream(), "UTF-8"));
+                    }
+
+                    StringBuilder response = new StringBuilder();
+                    String line;
+                    while ((line = br.readLine()) != null) {
+                        response.append(line);
+                    }
+                    br.close();
+
+                    Log.d(TAG, "Response code: " + responseCode);
+                    Log.d(TAG, "Response body: " + response.toString());
+
+                    if (responseCode >= 200 && responseCode < 300) {
+                        return new JSONObject(response.toString());
+                    } else {
+                        return "HTTP " + responseCode + ": " + response.toString();
+                    }
+                } catch (Exception e) {
+                    Log.e(TAG, "evaluateRisk error: " + e.getMessage(), e);
+                    return e.getMessage();
+                } finally {
+                    if (conn != null)
+                        conn.disconnect();
+                }
+            }
+
+            @Override
+            protected void onPostExecute(Object result) {
+                if (result instanceof JSONObject) {
+                    callback.onSuccess((JSONObject) result);
+                } else {
+                    callback.onError((String) result);
+                }
+            }
+        }.execute();
+    }
+}

package/src/android/hooks/configure-gradle.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+module.exports = function (context) {
+    const platforms = context.opts.cordova.platforms;
+    if (platforms.indexOf('android') === -1) return;
+
+    const buildGradlePath = path.join(
+        context.opts.projectRoot,
+        'platforms',
+        'android',
+        'app',
+        'build.gradle'
+    );
+
+    if (!fs.existsSync(buildGradlePath)) {
+        console.log('[devicex] build.gradle no encontrado');
+        return;
+    }
+
+    let buildGradle = fs.readFileSync(buildGradlePath, 'utf8');
+
+    // Agregar repositorio flatDir si no existe en el bloque principal
+    if (buildGradle.indexOf('flatDir') === -1) {
+        const repoBlock = `
+repositories {
+    flatDir {
+        dirs 'libs'
+    }
+}
+`;
+        // Insertar antes del último bloque dependencies (el principal)
+        const lastDepsIndex = buildGradle.lastIndexOf('dependencies {');
+        if (lastDepsIndex !== -1) {
+            buildGradle = buildGradle.slice(0, lastDepsIndex) +
+                repoBlock + '\n' +
+                buildGradle.slice(lastDepsIndex);
+        }
+    }
+
+    // Agregar dependencias de AARs después de fileTree si no existen
+    if (buildGradle.indexOf('devicex-bridge') === -1) {
+        const depsBlock = `    implementation files('libs/devicex-bridge.aar')
+    implementation files('libs/devicex-1.3.1.aar')
+    
+    // Dependencias del SDK Devicex
+    implementation 'io.ktor:ktor-client-core:2.3.7'
+    implementation 'io.ktor:ktor-client-okhttp:2.3.7'
+    implementation 'org.jetbrains.kotlinx:kotlinx-serialization-json:1.6.2'
+`;
+        // Buscar después de fileTree en el bloque principal
+        buildGradle = buildGradle.replace(
+            /(implementation fileTree\(dir: 'libs', include: '\*\.jar'\))/,
+            '$1\n' + depsBlock
+        );
+    }
+
+    fs.writeFileSync(buildGradlePath, buildGradle, 'utf8');
+    console.log('[devicex] build.gradle configurado con AARs locales');
+};

package/types/index.d.ts

@@ -0,0 +1,57 @@
+// Type definitions for @gatekeeperx/cordova-plugin-devicex
+// Project: https://npmjs.com/package/@gatekeeperx/cordova-plugin-devicex
+// Definitions by: GatekeeperX
+
+export type Environment = 'DEV' | 'DEVELOPMENT' | 'SANDBOX' | 'STAGE' | 'STAGING' | 'PROD' | 'PRODUCTION';
+
+export interface ConfigureOptions {
+    tenant: string;
+    apiKey: string;
+    organizationId?: string;
+    environment?: Environment;
+    headers?: Record<string, string>;
+}
+
+export interface EventSuccess {
+    ok: true;
+    code: number;
+    deviceXId: string;
+    message?: string;
+}
+
+export interface EventFailure {
+    ok: false;
+    errorCode: string;
+    errorMessage: string;
+    httpCode?: number | null;
+}
+
+export type EventResult = EventSuccess | EventFailure;
+
+export interface RiskAssessment {
+    isRooted: boolean;
+    isFridaDetected: boolean;
+    isXposedDetected: boolean;
+    isMagiskDetected: boolean;
+    isEmulator: boolean;
+    isDebuggerAttached: boolean;
+    isHookingDetected: boolean;
+    riskScore: number;
+    riskLevel: string;
+}
+
+declare const Devicex: {
+    configure(options: ConfigureOptions): Promise<void>;
+    sendEvent(name: string, properties?: Record<string, any>, headers?: Record<string, string>): Promise<EventResult>;
+    getRiskAssessment(): Promise<RiskAssessment>;
+    isInitialized(): Promise<boolean>;
+
+    /** Retorna la versión del SDK nativo (AAR). Ej: "1.3.1" */
+    getVersion(): Promise<string>;
+
+    /** Retorna la versión del plugin Cordova (wrapper). Ej: "0.1.0" */
+    getPluginVersion(): string;
+};
+
+export default Devicex;
+export as namespace Devicex;

package/www/devicex.js

@@ -0,0 +1,51 @@
+var exec = require('cordova/exec');
+var PLUGIN = 'Devicex';
+
+/**
+ * Versión del plugin Cordova (wrapper).
+ * Independiente de la versión del SDK nativo (AAR).
+ *
+ * - Plugin Cordova: 0.1.0 (este valor)
+ * - SDK nativo:     se obtiene con getVersion() (desde el AAR)
+ */
+var PLUGIN_VERSION = '0.1.0';
+
+function call(action, args) {
+  return new Promise(function (resolve, reject) {
+    exec(function (res) { resolve(res); }, function (err) { reject(err); }, PLUGIN, action, args || []);
+  });
+}
+
+exports.configure = function (options) {
+  options = options || {};
+  return call('configure', [options]);
+};
+
+exports.sendEvent = function (name, properties, headers) {
+  if (!name || typeof name !== 'string') {
+    return Promise.reject('name is required');
+  }
+  return call('sendEvent', [{ name: name, properties: properties || {}, headers: headers || {} }]);
+};
+
+exports.isInitialized = function () {
+  return call('isInitialized', []).then(function (res) { return res && res.value === true; });
+};
+
+/**
+ * Retorna la versión del SDK nativo (AAR de Device Intelligence).
+ * Ejemplo: "1.3.1"
+ */
+exports.getVersion = function () {
+  return call('getVersion', []).then(function (res) { return (res && res.value) || ''; });
+};
+
+/**
+ * Retorna la versión del plugin Cordova (wrapper JS + bridge).
+ * Ejemplo: "0.1.0"
+ *
+ * Esta versión es independiente del SDK nativo y sigue su propio ciclo de releases.
+ */
+exports.getPluginVersion = function () {
+  return PLUGIN_VERSION;
+};