react-native-dev-guard 0.0.1 → 1.0.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 arsarsars1
+Copyright (c) 2026 DevGuard-uk
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -1,85 +1,231 @@
 # React Native DevGuard
 
-Remote licensing and application protection for React Native. HMAC signing and GZip telemetry run in a compiled native C++ module.
+<p align="center">
+  <a href="https://devguard.uk"><img src="https://img.shields.io/badge/website-devguard.uk-6C47FF?style=flat-square" alt="Website" /></a>
+  <img src="https://img.shields.io/badge/platforms-iOS%20%7C%20Android-2D7DD2?style=flat-square" alt="Platforms" />
+  <img src="https://img.shields.io/badge/license-MIT-3CB371?style=flat-square" alt="License" />
+</p>
 
-## Features
+**Protect your apps. Get paid.** DevGuard is a remote licensing and application-protection layer for React Native. Remotely **lock, warn, wipe, and monitor** your published apps from the DevGuard dashboard — ideal for agencies and developers who need to enforce payment terms or revoke access to client deliverables. Security-critical operations (HMAC signing, the shared secret, GZip telemetry) run inside a compiled **Native C++ module** so your keys never sit in plain JavaScript.
 
-- Glassmorphic lock screen
-- Native HMAC signing (C++ black box)
-- GZip tunnel (`v1-gzip`) for compact telemetry
-- Heartbeat and lifecycle sync policies
-- Hardware fingerprinting and emulator blocking
-- Nonce-based remote wipe
-- Privacy-gated advanced telemetry (RAM, storage, battery)
+> 👉 **Create your free account and grab your keys at [devguard.uk](https://devguard.uk).**
+> You'll need a **Project ID** and a **Master Secret** to initialize the SDK.
 
-## Requirements
+## 📱 How it looks
 
-- React Native 0.85.x (tested on 0.85.3)
-- React 19.2.x
-- iOS 15.1+ · Android minSdk 24
+The Lock Screen, warning toast, and diagnostics overlay are all **built in** — you don't build any UI. DevGuard renders the right screen automatically based on the status returned by your dashboard.
 
-## Installation
+<table>
+  <tr>
+    <td align="center" width="33%"><img src="screenshots/welcome-screen.png" width="240" alt="Active and protected app" /></td>
+    <td align="center" width="33%"><img src="screenshots/payment-reminder.png" width="240" alt="In-app warning toast" /></td>
+    <td align="center" width="33%"><img src="screenshots/access-suspended.png" width="240" alt="Access suspended lock screen" /></td>
+  </tr>
+  <tr>
+    <td align="center"><b>Active &amp; Protected</b><br/>Your app runs normally · <code>ACTIVE</code></td>
+    <td align="center"><b>In-App Warning</b><br/>Non-blocking toast (e.g. payment reminder) · <code>WARNING</code></td>
+    <td align="center"><b>Access Suspended</b><br/>Automatic Lock Screen with your support contacts · <code>LOCKED</code></td>
+  </tr>
+</table>
+
+## ✨ Features
+
+- **Glassmorphic Lock Screen**: Premium, built-in UI that blocks access instantly — with your WhatsApp / Email / Call support buttons and an optional unlock-key entry.
+- **Native Security**: HMAC signing and the shared secret are handled in compiled C++ to prevent secret extraction.
+- **GZip Tunneling**: Compact telemetry payloads for minimum data usage.
+- **Remote Config**: Access server-defined JSON settings via the `response` object.
+- **Heartbeat & Sync**: Automated background pings (with `lifecycleSync` / `syncPolicy` support) to keep license status fresh.
+- **Hardware Fingerprinting**: Robust device identity that survives app re-installs.
+- **Emulator Blocking**: When the project enables `blockEmulators`, the SDK locks on emulators/simulators automatically.
+- **Hardened Remote Wipe**: Nonce-based remote wipe clears the response cache, usage logs, encrypted vault diagnostics, and stored device-user identity.
+- **Privacy-Gated Telemetry**: Advanced metrics (RAM, storage, battery, network) are only collected after the server enables `advancedTelemetry`.
+
+## 🚀 Getting Started
+
+### 1. Create your DevGuard account
+
+1. Sign up at **[devguard.uk](https://devguard.uk)**.
+2. Create a **Project** in the dashboard.
+3. Copy your **Project ID** and **Master Secret** (Settings → Master Secret). You'll pass both to the SDK below.
+
+### 2. Install
 
 ```bash
 npm install react-native-dev-guard react-native-device-info react-native-keychain @react-native-async-storage/async-storage
-npx pod-install
+# or
+yarn add react-native-dev-guard react-native-device-info react-native-keychain @react-native-async-storage/async-storage
 ```
 
-## Quick start
+`@react-native-async-storage/async-storage` is required by the bundled Vault Logger (encrypted local diagnostics). Use **v3.x** with React Native 0.85+; run `npx pod-install` after adding it on iOS.
+
+### 3. Native setup
+
+#### Requirements
+- **React Native** `0.85.x` (tested on `0.85.3`)
+- **React** `19.2.x`
+- **iOS** 15.1+ · **Android** minSdk 24
+
+#### iOS
+1. Open `ios/Podfile` and ensure your target meets React Native's minimum iOS version (`min_ios_version_supported`, currently 15.1).
+2. Run `npx pod-install`.
+
+#### Android
+Ensure your app `minSdkVersion` is at least **24** (matches the RN 0.85 template).
+
+### 4. Protect your app
+
+Wrap your application root with `DevGuardProvider`. That's it — once the status returned by your dashboard is `LOCKED`, the Lock Screen appears automatically.
 
 ```tsx
 import React from 'react';
 import { DevGuardProvider } from 'react-native-dev-guard';
 
-const App = () => (
-  <DevGuardProvider
-    projectId="your_project_id"
-    secret="YOUR_MASTER_SECRET"
-    autoProtect={true}
-    failSafe="open"
-  >
-    <MainApp />
-  </DevGuardProvider>
-);
+const App = () => {
+  return (
+    <DevGuardProvider
+      projectId="your_project_id"   // From the DevGuard dashboard
+      secret="YOUR_MASTER_SECRET"   // Settings → Master Secret
+      autoProtect={true}            // Auto-show the Lock Screen when LOCKED
+      failSafe="open"               // 'open' or 'closed' (offline behavior, no cache)
+    >
+      <MainApp />
+    </DevGuardProvider>
+  );
+};
+
+export default App;
 ```
 
-### Access status in components
+## 🧭 Status lifecycle
+
+DevGuard syncs on app launch, on foreground/background, and on a server-defined heartbeat. The current `status` drives what the user sees:
+
+| Status | Meaning | What the user sees |
+| --- | --- | --- |
+| `ACTIVE` | Valid license / access granted. | Your app, running normally. |
+| `WARNING` | App still works, but a notice is shown. | A non-blocking toast (e.g. *"Payment reminder"*). |
+| `LOCKED` | Access revoked by you. | The built-in **Lock Screen** (when `autoProtect`). |
+| `EXPIRED` | License expired. | Treated as locked. |
+| `PENDING` | Initial state before the first successful sync (`failSafe: open`). | Your app (optimistic). |
+| `ERROR` | Sync failed. | Depends on `failSafe` (see below). |
+
+## 🪝 API
+
+### `<DevGuardProvider>` props
+
+| Prop | Type | Default | Description |
+| --- | --- | --- | --- |
+| `projectId` | `string` | **required** | Your DevGuard project ID. |
+| `secret` | `string` | — | Your account **Master Secret** (Settings → Master Secret), used to authenticate requests. |
+| `autoProtect` | `boolean` | `true` | Automatically render the built-in Lock Screen when status is `LOCKED` / `EXPIRED`. |
+| `failSafe` | `'open' \| 'closed'` | `'open'` | Behavior when the server is unreachable and no cache exists. `open` keeps the app usable; `closed` locks it. |
+| `apiKey` | `string` | — | **Deprecated** alias for `secret`. |
+
+### `useDevGuard()`
 
 ```tsx
 import { useDevGuard } from 'react-native-dev-guard';
 
 const MyComponent = () => {
   const { status, response, isLocked, verify } = useDevGuard();
-  return <Text>Status: {status}</Text>;
+
+  return (
+    <View>
+      <Text>Status: {status}</Text>
+      {response?.betaFeatures?.showBetaFeature && <BetaComponent />}
+    </View>
+  );
 };
 ```
 
-## Configuration
+| Field | Type | Description |
+| --- | --- | --- |
+| `status` | `GuardStatus` | `ACTIVE` · `WARNING` · `LOCKED` · `EXPIRED` · `PENDING` · `ERROR`. |
+| `isLocked` | `boolean` | `true` when status is `LOCKED` or `EXPIRED`. |
+| `response` | `GuardResponse \| null` | Full server response (messages, contacts, `config`, `betaFeatures`, etc.). |
+| `verify` | `(force?: boolean) => Promise<void>` | Manually trigger a license sync. |
+| `unlock` | `(key: string) => Promise<boolean>` | Submit an unlock key; resolves `true` on success. |
+| `setDeviceUser` | `(username?, email?, phone?, customData?) => Promise<void>` | Register the signed-in app user so they appear in the Developer Portal. |
+
+### Track app users in the Developer Portal
 
-| Prop | Description |
-|------|-------------|
-| `projectId` | Your DevGuard project ID |
-| `secret` | Master Secret from portal settings |
-| `autoProtect` | Show lock screen when status is LOCKED (default `true`) |
-| `failSafe` | `'open'` (default) or `'closed'` when offline with no cache |
+When someone signs in or registers in your app, pass their profile to DevGuard. You'll then be able to see **how many users are using your application** in the **Developer Portal** — total user count, recent activity, and basic profile fields (username, email, phone, and any custom metadata you attach).
+
+Call this after login or registration (all parameters are optional):
+
+```tsx
+const { setDeviceUser } = useDevGuard();
+
+await setDeviceUser(
+  'jane_doe',           // username
+  'jane@example.com',   // email
+  '+15551234567',       // phone
+  { plan: 'pro' }       // any custom data
+);
+```
+
+Open **Developer Portal → Users** to view your app's user base and engagement.
 
 ### Manual verification
 
+Force a sync after a meaningful event (e.g. login or payment):
+
 ```tsx
 const { verify } = useDevGuard();
-await verify(true); // force sync
+await verify(true); // true forces a sync regardless of policy
 ```
 
-### Diagnostic overlay
+### Unlock with a key
+
+The built-in Lock Screen already includes an **"Enter Unlock Key"** flow, so most apps never call this directly — but it's available if you want a custom UI:
+
+```tsx
+const { unlock } = useDevGuard();
+const ok = await unlock('USER-ENTERED-KEY');
+```
+
+## 🐞 Diagnostic Overlay & Vault Logger
+
+DevGuard includes an integrated diagnostic UI (the Bug Icon) and an encrypted local Vault Logger for advanced debugging without rebuilding your app.
+
+### Vault Logger
+The SDK bundles `react-native-vault-logger`. By default, it automatically intercepts and encrypts fatal JS errors and usage info, saving them securely to local storage using **per-device AES-256-CBC keys** derived from the hardware `deviceId` at init (no static secret in source).
+You can manually log data to the Info Vault:
+```tsx
+import { DevGuardLogger } from 'react-native-dev-guard/src/services/DevGuardLogger';
+
+DevGuardLogger.info('User completed onboarding', { userId: 123 });
+```
+
+### The Bug Icon (Diagnostic Overlay)
+To view telemetry and logs directly inside the running app without connecting a debugger:
+1. Go to your DevGuard Admin Control Center.
+2. Ensure you have configured a **6-digit Diagnostic Passcode**.
+3. Under the project settings, toggle on **Enable Diagnostic Logs (Beta Feature)** for the desired devices.
+4. A floating **🐛 Bug Icon** will appear in your app.
+5. Tap it and enter your Passcode to view device telemetry and access the encrypted error vaults.
+
+## ⚙️ Configuration
+
+### Fail-Safe Modes
+- **`open` (Default)**: If the server is unreachable and no cache exists, the app remains accessible.
+- **`closed`**: The app will lock until a successful status is fetched.
+
+## 🔐 Security Best Practices
+
+1. **Obfuscation**: Always use `javascript-obfuscator` or similar tools for your JS bundle.
+2. **Hermes**: Ensure Hermes is enabled in your `app/build.gradle` and `Podfile` to benefit from bytecode pre-compilation.
+3. **ProGuard**: Use the included ProGuard rules to protect the native C++ library.
 
-Enable **Diagnostic Logs** in your DevGuard project settings and set a 6-digit passcode. A bug icon appears in-app for authorized debugging.
+## 💬 Support & Contact
 
-## Security
+- 🌐 **Website / register:** [devguard.uk](https://devguard.uk)
+- 📧 **Email:** [contact@devguard.uk](mailto:contact@devguard.uk)
+- 🐛 **Issues:** [GitHub Issues](https://github.com/DevGuard-uk/react-native-dev-guard/issues)
 
-- Obfuscate your JS bundle in production
-- Enable Hermes and ProGuard (see `example/android/app/proguard-rules.pro`)
-- Never commit your Master Secret to source control
+## 📄 License
 
-## License
+MIT © [DevGuard](https://devguard.uk)
 
-MIT — see [LICENSE](LICENSE).
+---
+*Secure by Design. Managed by You.*

package/lib/index.js

@@ -36,7 +36,11 @@ const DevGuardProvider = ({ children, projectId, secret, apiKey, autoProtect = t
     const lastSyncTime = (0, react_1.useRef)(0);
     const [showDiagnostics, setShowDiagnostics] = (0, react_1.useState)(false);
     const lastLifecycleSyncTime = (0, react_1.useRef)(0);
-    // Latest response for long-lived closures (AppState listener, heartbeat).
+    // Mirror of `response` for use inside long-lived closures (AppState listener,
+    // heartbeat). Those callbacks are registered once, so reading the `response`
+    // state directly would capture a stale (initial null) value — breaking
+    // telemetry consent and lifecycle gating. The ref always holds the latest.
+    // (Parity with Flutter, where these reads hit the `_cachedResponse` field.)
     const responseRef = (0, react_1.useRef)(null);
     (0, react_1.useEffect)(() => {
         responseRef.current = response;
@@ -187,7 +191,7 @@ const DevGuardProvider = ({ children, projectId, secret, apiKey, autoProtect = t
             else {
                 console.warn('DevGuard: Missing server response signature.');
             }
-            // Client-side enforcement (e.g. blockEmulators).
+            // Client-side enforcement (e.g. blockEmulators) — parity with Flutter.
             const enforced = GuardEnforcement_1.GuardEnforcement.apply(result, metadata);
             const finalStatus = String(enforced.status || 'ERROR').toUpperCase();
             responseRef.current = enforced; // keep ref fresh for chained/triggered syncs
@@ -196,7 +200,7 @@ const DevGuardProvider = ({ children, projectId, secret, apiKey, autoProtect = t
             setShowWarning(finalStatus === 'WARNING');
             lastSyncTime.current = Date.now();
             CacheService_1.CacheService.saveResponse(projectId, enforced);
-            // Handle beta features from server response
+            // Handle Beta Features (Parity with Flutter)
             if (finalStatus === 'WARNING' && result.betaFeatures?.vibrateOnWarning === true) {
                 react_native_1.Vibration.vibrate();
             }
@@ -206,11 +210,11 @@ const DevGuardProvider = ({ children, projectId, secret, apiKey, autoProtect = t
             }
             // Heartbeat management
             startHeartbeat(result);
-            // Persist server-issued device token
+            // Handle Device Token (Parity with Flutter)
             if (result.deviceToken) {
                 await DeviceTokenService_1.DeviceTokenService.getInstance().saveToken(result.deviceToken, result.betaFeatures?.secureEnclave === true);
             }
-            // Handle remote commands from server
+            // Handle Remote Commands (Parity with Flutter)
             if (result.remoteCommand && result.remoteCommand !== 'none') {
                 await handleRemoteCommand(result.remoteCommand);
             }
@@ -264,7 +268,11 @@ const DevGuardProvider = ({ children, projectId, secret, apiKey, autoProtect = t
             await DeviceTokenService_1.DeviceTokenService.getInstance().clearToken();
         }
     };
-    /** Nonce-based remote wipe — runs once per server command. */
+    /**
+     * Hardened, nonce-based remote wipe (parity with Flutter + .cursorrules §3).
+     * Only triggers when the server nonce is greater than the last executed one,
+     * then persists the new nonce so the wipe runs exactly once per command.
+     */
     const executeRemoteWipe = async (nonce) => {
         const lastHandled = await CacheService_1.CacheService.getLastWipeNonce(projectId);
         if (lastHandled !== null && nonce <= lastHandled)
@@ -307,7 +315,7 @@ const DevGuardProvider = ({ children, projectId, secret, apiKey, autoProtect = t
     const setDeviceUser = async (username, email, phone, customData) => {
         await HardwareService_1.HardwareService.getInstance().setDeviceUser(username, email, phone, customData);
         if (!username && !email && !phone && !customData)
-            return;
+            return; // "if all values will null then no request will need to trigger to server okay"
         await verify(true);
     };
     (0, react_1.useEffect)(() => {
@@ -321,7 +329,8 @@ const DevGuardProvider = ({ children, projectId, secret, apiKey, autoProtect = t
         // Run heavy operations safely in the background JS event loop
         setTimeout(async () => {
             try {
-                await DevGuardLogger_1.DevGuardLogger.init();
+                const deviceId = await HardwareService_1.HardwareService.getInstance().getDeviceId();
+                await DevGuardLogger_1.DevGuardLogger.init(deviceId);
                 const isJailbroken = await react_native_jailbreak_1.default.check();
                 if (isJailbroken) {
                     console.warn('DevGuard Security Alert: Compromised device detected.');

package/lib/services/CacheService.d.ts

@@ -4,7 +4,11 @@ export declare class CacheService {
     static saveResponse(projectId: string, response: any): Promise<void>;
     static getResponse(projectId: string): Promise<any | null>;
     static clear(): Promise<void>;
-    /** Last remote-wipe nonce executed on this device, or null. */
+    /**
+     * Returns the last remote-wipe nonce this client has executed, or null.
+     * Stored separately from the response cache so it survives a cache wipe
+     * (parity with Flutter's nonce persistence).
+     */
     static getLastWipeNonce(projectId: string): Promise<number | null>;
     static setLastWipeNonce(projectId: string, nonce: number): Promise<void>;
 }

package/lib/services/CacheService.js

@@ -81,7 +81,11 @@ class CacheService {
             console.warn('DevGuard Cache: Failed to clear cache', e);
         }
     }
-    /** Last remote-wipe nonce executed on this device, or null. */
+    /**
+     * Returns the last remote-wipe nonce this client has executed, or null.
+     * Stored separately from the response cache so it survives a cache wipe
+     * (parity with Flutter's nonce persistence).
+     */
     static async getLastWipeNonce(projectId) {
         try {
             const credentials = await Keychain.getGenericPassword({ service: this.WIPE_SERVICE });

package/lib/services/DevGuardLogger.d.ts

@@ -3,7 +3,7 @@ export declare class DevGuardLogger {
     static showConsoleLogs: boolean;
     private static initialized;
     private static infoLogs;
-    static init(): Promise<void>;
+    static init(deviceId: string): Promise<void>;
     static enableConsoleLogs(): void;
     static info(message: string, data?: Record<string, any>): void;
     static warning(message: string, data?: Record<string, any>): void;

package/lib/services/DevGuardLogger.js

@@ -1,18 +1,28 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DevGuardLogger = void 0;
+const crypto_js_1 = __importDefault(require("crypto-js"));
 const react_native_vault_logger_1 = require("react-native-vault-logger");
+function deriveVaultKeyMaterial(deviceId, salt) {
+    const hex = crypto_js_1.default.SHA256(`${deviceId}_${salt}`).toString(crypto_js_1.default.enc.Hex);
+    return crypto_js_1.default.enc.Hex.parse(hex).toString(crypto_js_1.default.enc.Latin1);
+}
 class DevGuardLogger {
     static showConsoleLogs = false;
     static initialized = false;
     static infoLogs = [];
-    static async init() {
+    static async init(deviceId) {
         if (this.initialized)
             return;
         try {
+            const encryptionKey = deriveVaultKeyMaterial(deviceId, 'dg_vault_key_v1');
+            const encryptionIV = deriveVaultKeyMaterial(deviceId, 'dg_vault_iv_v1').substring(0, 16);
             await react_native_vault_logger_1.CrashLogService.init({
-                encryptionKey: 'DevGuard_Secure_Vault_Key_32_Ch!',
-                encryptionIV: 'DevGuard_IV_16_C',
+                encryptionKey,
+                encryptionIV,
                 maxLogCount: 1000,
             });
             this.initialized = true;

package/lib/services/DeviceTokenService.d.ts

@@ -10,7 +10,10 @@ export declare class DeviceTokenService {
      * Reads from Keychain/Keystore if available, otherwise from in-memory cache.
      */
     getToken(): Promise<string | null>;
-    /** Persists a registration token using Keychain/Keystore when available. */
+    /**
+     * Persists a registration token received from the server.
+     * Uses hardware-backed Keychain/Keystore when available (parity with Flutter's flutter_secure_storage).
+     */
     saveToken(token: string, useEnclave?: boolean): Promise<void>;
     /**
      * Removes the registration token. Only called on explicit admin revocation.

package/lib/services/DeviceTokenService.js

@@ -52,11 +52,14 @@ class DeviceTokenService {
         // Fallback: in-memory token
         return this.cachedToken;
     }
-    /** Persists a registration token using Keychain/Keystore when available. */
+    /**
+     * Persists a registration token received from the server.
+     * Uses hardware-backed Keychain/Keystore when available (parity with Flutter's flutter_secure_storage).
+     */
     async saveToken(token, useEnclave = false) {
         let finalToken = token;
         if (useEnclave) {
-            // Simulated enclave: reverse and prefix
+            // Simulated Enclave: Reverse and prefix (parity with Flutter)
             finalToken = `se:${token.split('').reverse().join('')}`;
         }
         // Primary: Keychain/Keystore (hardware-backed, persists across restarts)

package/lib/services/HardwareService.d.ts

@@ -5,7 +5,11 @@ export declare class HardwareService {
     static getInstance(): HardwareService;
     getDeviceId(): Promise<string>;
     setDeviceUser(username?: string, email?: string, phone?: string, customData?: Record<string, any>): Promise<void>;
-    /** Clears stored device-user identity (username, email, phone, customData). */
+    /**
+     * Clears all stored device-user identity (username/email/phone/customData).
+     * Used by the hardened remote wipe (parity with Flutter's
+     * SecureStorageService.deleteAllDeviceUserKeys).
+     */
     clearDeviceUser(): Promise<void>;
     getMetadata(betaFeatures?: any): Promise<any>;
     private getNetworkType;
@@ -16,4 +20,13 @@ export declare class HardwareService {
      * Each metric is collected independently so one failure never blocks the rest.
      */
     private collectAdvancedTelemetry;
+    /**
+     * Collects GPS only if permission is already granted — never prompts during sync.
+     *
+     * Uses a cached position (low accuracy, high maximumAge) to avoid waking the GPS
+     * radio. Denied or unavailable permission returns null silently — it must not
+     * pollute the error vault.
+     */
+    private getLocationPassive;
+    private isLocationPermissionGranted;
 }

package/lib/services/HardwareService.js

@@ -86,7 +86,11 @@ class HardwareService {
             console.warn('DevGuard: Failed to save user info', e);
         }
     }
-    /** Clears stored device-user identity (username, email, phone, customData). */
+    /**
+     * Clears all stored device-user identity (username/email/phone/customData).
+     * Used by the hardened remote wipe (parity with Flutter's
+     * SecureStorageService.deleteAllDeviceUserKeys).
+     */
     async clearDeviceUser() {
         try {
             await Keychain.resetGenericPassword({ service: 'devguard.user.service' });
@@ -216,7 +220,65 @@ class HardwareService {
         catch (e) {
             // Ignore individual metric failure.
         }
+        const location = await this.getLocationPassive();
+        if (location) {
+            out.location = location;
+        }
         return out;
     }
+    /**
+     * Collects GPS only if permission is already granted — never prompts during sync.
+     *
+     * Uses a cached position (low accuracy, high maximumAge) to avoid waking the GPS
+     * radio. Denied or unavailable permission returns null silently — it must not
+     * pollute the error vault.
+     */
+    async getLocationPassive() {
+        if (react_native_1.Platform.OS !== 'android' && react_native_1.Platform.OS !== 'ios')
+            return null;
+        if (!(await this.isLocationPermissionGranted()))
+            return null;
+        try {
+            // Optional peer: host app installs react-native-geolocation-service for GPS telemetry.
+            const Geolocation = require('react-native-geolocation-service').default;
+            return await new Promise((resolve) => {
+                Geolocation.getCurrentPosition((position) => {
+                    const { latitude, longitude } = position.coords;
+                    resolve(`${latitude.toFixed(4)},${longitude.toFixed(4)}`);
+                }, () => resolve(null), {
+                    enableHighAccuracy: false,
+                    maximumAge: 86_400_000,
+                    timeout: 5_000,
+                });
+            });
+        }
+        catch {
+            return null;
+        }
+    }
+    async isLocationPermissionGranted() {
+        if (react_native_1.Platform.OS === 'android') {
+            try {
+                const fine = await react_native_1.PermissionsAndroid.check(react_native_1.PermissionsAndroid.PERMISSIONS.ACCESS_FINE_LOCATION);
+                const coarse = await react_native_1.PermissionsAndroid.check(react_native_1.PermissionsAndroid.PERMISSIONS.ACCESS_COARSE_LOCATION);
+                return fine || coarse;
+            }
+            catch {
+                return false;
+            }
+        }
+        if (react_native_1.Platform.OS === 'ios') {
+            try {
+                // Optional peer: react-native-permissions (check only — never request).
+                const { check, PERMISSIONS, RESULTS } = require('react-native-permissions');
+                const status = await check(PERMISSIONS.IOS.LOCATION_WHEN_IN_USE);
+                return status === RESULTS.GRANTED || status === RESULTS.LIMITED;
+            }
+            catch {
+                return false;
+            }
+        }
+        return false;
+    }
 }
 exports.HardwareService = HardwareService;

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "react-native-dev-guard",
-  "version": "0.0.1",
+  "version": "1.0.0",
   "description": "DevGuard protection for React Native apps",
   "license": "MIT",
-  "author": "arsarsars1",
+  "author": "DevGuard-uk",
   "homepage": "https://github.com/DevGuard-uk/react-native-dev-guard",
   "repository": {
     "type": "git",
@@ -21,9 +21,13 @@
   "types": "lib/index.d.ts",
   "files": [
     "lib",
-    "android",
-    "ios",
-    "cpp"
+    "cpp",
+    "ios/DevGuard.h",
+    "ios/DevGuard.mm",
+    "android/build.gradle",
+    "android/src",
+    "react-native-dev-guard.podspec",
+    "screenshots"
   ],
   "scripts": {
     "clean": "rimraf lib",
@@ -58,6 +62,16 @@
     "react": ">=18",
     "react-native": ">=0.76",
     "react-native-device-info": "*",
-    "react-native-keychain": "*"
+    "react-native-geolocation-service": "*",
+    "react-native-keychain": "*",
+    "react-native-permissions": "*"
+  },
+  "peerDependenciesMeta": {
+    "react-native-geolocation-service": {
+      "optional": true
+    },
+    "react-native-permissions": {
+      "optional": true
+    }
   }
 }

package/react-native-dev-guard.podspec

@@ -0,0 +1,19 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "react-native-dev-guard"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"] || "https://github.com/DevGuard-uk/react-native-dev-guard"
+  s.license      = package["license"] || "MIT"
+  s.authors      = package["author"] || "DevGuard"
+
+  s.platforms    = { :ios => "15.1" }
+  s.source       = { :git => (package.dig("repository", "url") || "https://github.com/DevGuard-uk/react-native-dev-guard.git"), :tag => "v#{s.version}" }
+
+  s.source_files = "ios/**/*.{h,m,mm,cpp}", "cpp/**/*.{h,c,cpp}"
+
+  s.dependency "React-Core"
+end