@salve-software/salvetron-react-native 1.0.1

package/src/library/device/__tests__/device-handler.test.ts

@@ -0,0 +1,86 @@
+jest.mock('react-native', () => ({
+  Platform: {
+    OS: 'ios',
+  },
+}));
+
+import { Platform } from 'react-native';
+
+import { DeviceHandler } from '../device-handler';
+
+import { NitroRnTuiSdk } from '../../../index';
+
+import { generateUUID } from '../utils/generate-uuid';
+
+jest.mock('../../../index', () => ({
+  NitroRnTuiSdk: {
+    getDeviceInfo: jest.fn(),
+    getStoredDeviceId: jest.fn(),
+    storeDeviceId: jest.fn(),
+  },
+}));
+
+jest.mock('../utils/generate-uuid', () => ({
+  generateUUID: jest.fn(),
+}));
+
+describe('DeviceHandler', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    (
+      generateUUID as jest.Mock
+    ).mockReturnValue('generated-uuid');
+  });
+
+  it('should fallback to iOS device name', () => {
+    Platform.OS = 'ios';
+
+    (
+      NitroRnTuiSdk.getDeviceInfo as jest.Mock
+    ).mockReturnValue({});
+
+    const handler = new DeviceHandler();
+
+    expect(
+      handler.getDeviceName(),
+    ).toBe('iOS Device');
+  });
+
+  it('should fallback to Android device name', () => {
+    Platform.OS = 'android';
+
+    (
+      NitroRnTuiSdk.getDeviceInfo as jest.Mock
+    ).mockReturnValue({});
+
+    const handler = new DeviceHandler();
+
+    expect(
+      handler.getDeviceName(),
+    ).toBe('Android Device');
+  });
+
+  it('should return platform in device info', () => {
+    Platform.OS = 'android';
+
+    (
+      NitroRnTuiSdk.getDeviceInfo as jest.Mock
+    ).mockReturnValue({
+      deviceId: 'id',
+      deviceName: 'Pixel',
+      appName: 'App',
+      bundleId: 'com.test',
+    });
+
+    const handler = new DeviceHandler();
+
+    expect(handler.getDeviceInfo()).toEqual({
+      deviceId: 'id',
+      deviceName: 'Pixel',
+      platform: 'android',
+      appName: 'App',
+      bundleId: 'com.test',
+    });
+  });
+});

package/src/library/device/device-handler.ts

@@ -0,0 +1,85 @@
+import { Platform } from 'react-native'
+import { NitroRnTuiSdk } from '../../index'
+import { generateUUID } from './utils/generate-uuid'
+import type { DeviceInfoData } from './types'
+
+export class DeviceHandler {
+  private cachedDeviceId: string | null = null
+  private cachedDeviceName: string | null = null
+
+  private getOrCreateDeviceId(): string {
+    if (this.cachedDeviceId) {
+      return this.cachedDeviceId
+    }
+
+    try {
+      const nativeInfo = NitroRnTuiSdk.getDeviceInfo()
+      if (nativeInfo.deviceId) {
+        this.cachedDeviceId = nativeInfo.deviceId
+        return nativeInfo.deviceId
+      }
+
+      const storedId = NitroRnTuiSdk.getStoredDeviceId()
+      if (storedId) {
+        this.cachedDeviceId = storedId
+        return storedId
+      }
+
+      const newId = generateUUID()
+      NitroRnTuiSdk.storeDeviceId(newId)
+      this.cachedDeviceId = newId
+      return newId
+    } catch (err) {
+      this.cachedDeviceId = generateUUID()
+      return this.cachedDeviceId
+    }
+  }
+
+  getDeviceName(): string {
+    if (this.cachedDeviceName) {
+      return this.cachedDeviceName
+    }
+
+    const nativeInfo = NitroRnTuiSdk.getDeviceInfo()
+    if (nativeInfo.deviceName) {
+      this.cachedDeviceName = nativeInfo.deviceName
+      return nativeInfo.deviceName
+    }
+
+    const model = Platform.OS === 'ios' ? 'iOS Device' : 'Android Device'
+    this.cachedDeviceName = model
+    return model
+  }
+
+  getAppName(): string {
+    try {
+      const nativeInfo = NitroRnTuiSdk.getDeviceInfo()
+      return nativeInfo.appName || 'React Native App'
+    } catch {
+      return 'React Native App'
+    }
+  }
+
+  getBundleId(): string {
+    try {
+      const nativeInfo = NitroRnTuiSdk.getDeviceInfo()
+      return nativeInfo.bundleId || ''
+    } catch {
+      return ''
+    }
+  }
+
+  getDeviceInfo(): DeviceInfoData {
+    const deviceId = this.getOrCreateDeviceId()
+    const deviceName = this.getDeviceName()
+    const appName = this.getAppName()
+
+    return {
+      deviceId,
+      deviceName,
+      platform: Platform.OS as 'ios' | 'android',
+      appName,
+      bundleId: this.getBundleId(),
+    }
+  }
+}

package/src/library/device/index.ts

@@ -0,0 +1,3 @@
+import { DeviceHandler } from './device-handler'
+
+export const deviceHandler = new DeviceHandler()

package/src/library/device/types.ts

@@ -0,0 +1,7 @@
+export interface DeviceInfoData {
+  deviceId: string;
+  deviceName: string;
+  platform: 'ios' | 'android';
+  appName: string;
+  bundleId: string;
+}

package/src/library/device/utils/generate-uuid.ts

@@ -0,0 +1,7 @@
+export function generateUUID(): string {
+  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+    const r = (Math.random() * 16) | 0;
+    const v = c === 'x' ? r : (r & 0x3) | 0x8;
+    return v.toString(16);
+  });
+}

package/src/library/index.ts

@@ -0,0 +1,158 @@
+/**
+ * Salvetron SDK for React Native
+ *
+ * Captures network requests and sends them to the Salvetron CLI
+ * for debugging and inspection.
+ *
+ * @example
+ * ```typescript
+ * import Salvetron from '@salve-software/salvetron-react-native';
+ *
+ * if (__DEV__) {
+ *   Salvetron.connect({
+ *     host: 'localhost',
+ *     port: 8765,
+ *   });
+ * }
+ * ```
+ */
+
+import { client } from './client'
+import type { SalvetronConfig } from './types'
+
+/**
+ * Salvetron SDK main interface
+ */
+export default {
+  /**
+   * Connect to Salvetron CLI
+   *
+   * @param config - Configuration options
+   * @example
+   * ```typescript
+   * Salvetron.connect({
+   *   host: '192.168.1.100', // Mac IP address
+   *   port: 8765,
+   *   enableNetworkCapture: true,
+   *   ignoredUrls: [/my-internal-api/],
+   *   onConnect: () => console.log('Connected to Salvetron'),
+   *   onDisconnect: () => console.log('Disconnected from Salvetron'),
+   * });
+   * ```
+   */
+  connect(config?: SalvetronConfig): void {
+    client.connect(config)
+  },
+
+  /**
+   * Disconnect from Salvetron CLI
+   */
+  disconnect(): void {
+    client.disconnect()
+  },
+
+  /**
+   * Check if currently connected to Salvetron
+   */
+  isConnected(): boolean {
+    return client.isConnected()
+  },
+
+  /**
+   * Send a log message (info level)
+   * @param message - The log message
+   * @param metadata - Optional metadata object
+   */
+  log(message: string, metadata?: Record<string, unknown>): void {
+    client.sendLog('info', message, metadata)
+  },
+
+  /**
+   * Send a debug log message
+   * @param message - The log message
+   * @param metadata - Optional metadata object
+   */
+  debug(message: string, metadata?: Record<string, unknown>): void {
+    client.sendLog('debug', message, metadata)
+  },
+
+  /**
+   * Send an info log message
+   * @param message - The log message
+   * @param metadata - Optional metadata object
+   */
+  info(message: string, metadata?: Record<string, unknown>): void {
+    client.sendLog('info', message, metadata)
+  },
+
+  /**
+   * Send a warning log message
+   * @param message - The log message
+   * @param metadata - Optional metadata object
+   */
+  warn(message: string, metadata?: Record<string, unknown>): void {
+    client.sendLog('warn', message, metadata)
+  },
+
+  /**
+   * Send an error log message
+   * @param message - The log message
+   * @param metadata - Optional metadata object
+   */
+  error(message: string, metadata?: Record<string, unknown>): void {
+    client.sendLog('error', message, metadata)
+  },
+
+  /**
+   * Stop capturing native platform logs (NSLog/print on iOS, Logcat on Android)
+   * Native log capture starts automatically on connect()
+   */
+  stopNativeLogCapture(): void {
+    client.stopNativeLogCapture()
+  },
+
+  /**
+   * Check if native log capture is currently active
+   * @returns true if native log capture is enabled
+   */
+  isNativeLogCaptureEnabled(): boolean {
+    return client.isNativeLogCaptureEnabled()
+  },
+
+  /**
+   * Start performance monitoring to track FPS, memory, and CPU
+   * @returns true if successfully enabled
+   */
+  startPerformanceMonitoring(): boolean {
+    return client.startPerformanceMonitoring()
+  },
+
+  /**
+   * Stop performance monitoring
+   */
+  stopPerformanceMonitoring(): void {
+    client.stopPerformanceMonitoring()
+  },
+
+  /**
+   * Check if performance monitoring is currently active
+   * @returns true if performance monitoring is enabled
+   */
+  isPerformanceMonitoringEnabled(): boolean {
+    return client.isPerformanceMonitoringEnabled()
+  },
+}
+
+// Export types for consumers
+export type {
+  SalvetronConfig,
+  NetworkRequestEvent,
+  NetworkResponseEvent,
+  NetworkEvent,
+  LogEvent,
+  NativeLogEvent,
+  LogLevel,
+  LogSource,
+  NativeLogSource,
+  PerformanceMetricsEvent,
+} from './types'

package/src/library/interceptors/__tests__/js-console.test.ts

@@ -0,0 +1,186 @@
+import { JSConsoleInterceptor } from '../js-console'
+import type { JSConsoleCallbacks } from '../js-console'
+
+describe('JSConsoleInterceptor', () => {
+  let interceptor: JSConsoleInterceptor
+
+  // Capture real originals before any patching
+  const realLog = console.log
+  const realWarn = console.warn
+  const realError = console.error
+
+  const createCallbacks = (): { callbacks: JSConsoleCallbacks; onLog: jest.Mock } => {
+    const onLog = jest.fn()
+    return { callbacks: { onLog }, onLog }
+  }
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+
+    // Reset singleton so each test gets a fresh instance
+    ;(JSConsoleInterceptor as any).instance = null
+    interceptor = JSConsoleInterceptor.getInstance()
+
+    // Ensure stopped before each test
+    interceptor.stop()
+  })
+
+  afterEach(() => {
+    // Always restore console methods after each test
+    interceptor.stop()
+    jest.restoreAllMocks()
+  })
+
+  afterAll(() => {
+    // Guarantee originals are back after the suite
+    console.log = realLog
+    console.warn = realWarn
+    console.error = realError
+  })
+
+  // ── start / stop basics ──────────────────────────────────────────────────
+
+  it('should return true on first start', () => {
+    const { callbacks } = createCallbacks()
+    expect(interceptor.start(callbacks)).toBe(true)
+    expect(interceptor.isEnabled()).toBe(true)
+  })
+
+  it('should no-op (return false) on double start', () => {
+    const { callbacks } = createCallbacks()
+    interceptor.start(callbacks)
+    expect(interceptor.start(callbacks)).toBe(false)
+  })
+
+  it('should no-op stop when not enabled', () => {
+    expect(() => interceptor.stop()).not.toThrow()
+    expect(interceptor.isEnabled()).toBe(false)
+  })
+
+  // ── console.log forwarding ───────────────────────────────────────────────
+
+  it('console.log("hello") → onLog("log", "hello", undefined)', () => {
+    const { callbacks, onLog } = createCallbacks()
+    interceptor.start(callbacks)
+
+    console.log('hello')
+
+    expect(onLog).toHaveBeenCalledTimes(1)
+    expect(onLog).toHaveBeenCalledWith('log', 'hello', undefined)
+  })
+
+  it('console.warn("bad", { x: 1 }) → onLog("warn", "bad", { args: [{ x: 1 }] })', () => {
+    const { callbacks, onLog } = createCallbacks()
+    interceptor.start(callbacks)
+
+    console.warn('bad', { x: 1 })
+
+    expect(onLog).toHaveBeenCalledTimes(1)
+    expect(onLog).toHaveBeenCalledWith('warn', 'bad', { args: [{ x: 1 }] })
+  })
+
+  it('console.error("boom") → onLog("error", "boom", undefined)', () => {
+    const { callbacks, onLog } = createCallbacks()
+    interceptor.start(callbacks)
+
+    console.error('boom')
+
+    expect(onLog).toHaveBeenCalledTimes(1)
+    expect(onLog).toHaveBeenCalledWith('error', 'boom', undefined)
+  })
+
+  // ── multi-arg metadata ────────────────────────────────────────────────────
+
+  it('multi-arg: console.log("a", "b", "c") → metadata: { args: ["b", "c"] }', () => {
+    const { callbacks, onLog } = createCallbacks()
+    interceptor.start(callbacks)
+
+    console.log('a', 'b', 'c')
+
+    expect(onLog).toHaveBeenCalledWith('log', 'a', { args: ['b', 'c'] })
+  })
+
+  // ── [Salvetron] guard ─────────────────────────────────────────────────────
+
+  it('console.log("[Salvetron] internal") is not forwarded; original still called', () => {
+    const { callbacks, onLog } = createCallbacks()
+
+    // Replace the stored original BEFORE start() so the patched closure captures our spy
+    const originalSpy = jest.fn()
+    ;(interceptor as any).originalLog = originalSpy
+
+    interceptor.start(callbacks)
+
+    console.log('[Salvetron] internal')
+
+    // Restore properly: stop() will restore console.log to originalSpy,
+    // then we put realLog back so subsequent tests are unaffected.
+    interceptor.stop()
+    console.log = realLog
+
+    expect(onLog).not.toHaveBeenCalled()
+    expect(originalSpy).toHaveBeenCalledWith('[Salvetron] internal')
+  })
+
+  it('non-string first arg with [Salvetron] prefix check does not throw', () => {
+    const { callbacks, onLog } = createCallbacks()
+    interceptor.start(callbacks)
+
+    // Non-string first arg: should not match [Salvetron] guard, should forward
+    expect(() => console.log({ y: 2 })).not.toThrow()
+    expect(onLog).toHaveBeenCalledWith('log', '[object Object]', undefined)
+  })
+
+  // ── console.debug / console.info not intercepted ─────────────────────────
+
+  it('console.debug and console.info are not patched after start', () => {
+    const originalDebug = console.debug
+    const originalInfo = console.info
+    const { callbacks } = createCallbacks()
+
+    interceptor.start(callbacks)
+
+    expect(console.debug).toBe(originalDebug)
+    expect(console.info).toBe(originalInfo)
+  })
+
+  // ── restore after stop ────────────────────────────────────────────────────
+
+  it('console.log/warn/error are restored after stop()', () => {
+    const { callbacks } = createCallbacks()
+    interceptor.start(callbacks)
+
+    // Methods should be patched
+    expect(console.log).not.toBe(realLog)
+    expect(console.warn).not.toBe(realWarn)
+    expect(console.error).not.toBe(realError)
+
+    interceptor.stop()
+
+    expect(console.log).toBe(realLog)
+    expect(console.warn).toBe(realWarn)
+    expect(console.error).toBe(realError)
+    expect(interceptor.isEnabled()).toBe(false)
+  })
+
+  // ── error swallow ─────────────────────────────────────────────────────────
+
+  it('if onLog throws, original is still called and error is swallowed', () => {
+    const throwingCallbacks: JSConsoleCallbacks = {
+      onLog: () => { throw new Error('forwarding failed') },
+    }
+    const originalSpy = jest.fn()
+    interceptor.start(throwingCallbacks)
+
+    // Replace stored original to spy on it
+    ;(interceptor as any).originalLog = originalSpy
+
+    expect(() => console.log('test')).not.toThrow()
+    expect(originalSpy).toHaveBeenCalledWith('test')
+
+    // stop() restores console.log to originalSpy (not realLog), so explicitly
+    // put realLog back to avoid corrupting subsequent tests.
+    interceptor.stop()
+    console.log = realLog
+  })
+})