react-native-ovpn 0.1.0

package/plugin/build/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const android_1 = __importDefault(require("./android"));
+const ios_1 = __importDefault(require("./ios"));
+const withOpenVPN = (config, props) => {
+    if (!props || typeof props.iosAppGroup !== 'string' || !props.iosAppGroup) {
+        throw new Error('react-native-ovpn: iosAppGroup is required in the plugin options. ' +
+            'Add it to your app.config.js plugins entry: ' +
+            '["react-native-ovpn", { iosAppGroup: "group.com.example.openvpn" }]');
+    }
+    config = (0, android_1.default)(config, props);
+    config = (0, ios_1.default)(config, props);
+    return config;
+};
+exports.default = withOpenVPN;

package/plugin/build/ios/index.d.ts

@@ -0,0 +1,4 @@
+import type { ConfigPlugin } from '@expo/config-plugins';
+import type { OpenVPNPluginProps } from '../types';
+declare const withOpenVPNIos: ConfigPlugin<OpenVPNPluginProps>;
+export default withOpenVPNIos;

package/plugin/build/ios/index.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const withIosEntitlements_1 = __importDefault(require("./withIosEntitlements"));
+const withIosInfoPlist_1 = __importDefault(require("./withIosInfoPlist"));
+const withIosDeploymentTarget_1 = __importDefault(require("./withIosDeploymentTarget"));
+const withOpenVPNIos = (config, props) => {
+    config = (0, withIosEntitlements_1.default)(config, props);
+    config = (0, withIosInfoPlist_1.default)(config, props);
+    config = (0, withIosDeploymentTarget_1.default)(config, props);
+    return config;
+};
+exports.default = withOpenVPNIos;

package/plugin/build/ios/withIosDeploymentTarget.d.ts

@@ -0,0 +1,4 @@
+import { type ConfigPlugin } from '@expo/config-plugins';
+import type { OpenVPNPluginProps } from '../types';
+declare const withIosDeploymentTarget: ConfigPlugin<OpenVPNPluginProps>;
+export default withIosDeploymentTarget;

package/plugin/build/ios/withIosDeploymentTarget.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_plugins_1 = require("@expo/config-plugins");
+const TARGET = '13.0';
+const withIosDeploymentTarget = (config) => {
+    return (0, config_plugins_1.withXcodeProject)(config, async (config) => {
+        const project = config.modResults;
+        const section = project.pbxXCBuildConfigurationSection();
+        for (const key of Object.keys(section)) {
+            const buildConfig = section[key];
+            if (!buildConfig || typeof buildConfig !== 'object')
+                continue;
+            const settings = buildConfig.buildSettings;
+            if (!settings)
+                continue;
+            const current = settings.IPHONEOS_DEPLOYMENT_TARGET;
+            if (typeof current === 'undefined') {
+                settings.IPHONEOS_DEPLOYMENT_TARGET = TARGET;
+            }
+            else if (typeof current === 'string' &&
+                parseFloat(current) < parseFloat(TARGET)) {
+                settings.IPHONEOS_DEPLOYMENT_TARGET = TARGET;
+            }
+        }
+        return config;
+    });
+};
+exports.default = withIosDeploymentTarget;

package/plugin/build/ios/withIosEntitlements.d.ts

@@ -0,0 +1,4 @@
+import { type ConfigPlugin } from '@expo/config-plugins';
+import type { OpenVPNPluginProps } from '../types';
+declare const withIosEntitlements: ConfigPlugin<OpenVPNPluginProps>;
+export default withIosEntitlements;

package/plugin/build/ios/withIosEntitlements.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_plugins_1 = require("@expo/config-plugins");
+const KEY = 'com.apple.security.application-groups';
+const withIosEntitlements = (config, props) => {
+    return (0, config_plugins_1.withEntitlementsPlist)(config, async (config) => {
+        const groups = config.modResults[KEY] ?? [];
+        if (!groups.includes(props.iosAppGroup)) {
+            groups.push(props.iosAppGroup);
+        }
+        config.modResults[KEY] = groups;
+        return config;
+    });
+};
+exports.default = withIosEntitlements;

package/plugin/build/ios/withIosInfoPlist.d.ts

@@ -0,0 +1,4 @@
+import { type ConfigPlugin } from '@expo/config-plugins';
+import type { OpenVPNPluginProps } from '../types';
+declare const withIosInfoPlist: ConfigPlugin<OpenVPNPluginProps>;
+export default withIosInfoPlist;

package/plugin/build/ios/withIosInfoPlist.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_plugins_1 = require("@expo/config-plugins");
+const withIosInfoPlist = (config, props) => {
+    return (0, config_plugins_1.withInfoPlist)(config, async (config) => {
+        config.modResults.OpenVPNAppGroupIdentifier =
+            props.iosAppGroup;
+        if (props.iosExtensionBundleIdentifier) {
+            config.modResults.OpenVPNExtensionBundleIdentifier = props.iosExtensionBundleIdentifier;
+        }
+        return config;
+    });
+};
+exports.default = withIosInfoPlist;

package/plugin/build/types.d.ts

@@ -0,0 +1,13 @@
+export type OpenVPNPluginProps = {
+    /** Required. App Group identifier shared by host and extension on iOS. */
+    iosAppGroup: string;
+    /** Optional. If the extension target's bundle id doesn't follow the default
+     *  `<host>.OpenVPNTunnel` convention, set it here so the host knows what to
+     *  start. */
+    iosExtensionBundleIdentifier?: string;
+    /** Optional. Path (relative to the consumer's project root) to a small
+     *  notification icon to use on Android. PNG or vector drawable. */
+    androidNotificationIcon?: string;
+    /** Optional. Override the default notification channel name on Android. */
+    androidNotificationChannelName?: string;
+};

package/plugin/build/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/NativeOpenvpn.ts

@@ -0,0 +1,46 @@
+import type { TurboModule } from 'react-native';
+import { TurboModuleRegistry } from 'react-native';
+
+export type NativeNotificationConfig = {
+  title?: string;
+  text?: string;
+  smallIcon?: string;
+  channelId?: string;
+};
+
+export type NativeConnectParams = {
+  config: string;
+  username: string;
+  password: string;
+  killSwitch: boolean;
+  dns: string[];
+  allowedApps: string[];
+  disallowedApps: string[];
+  notification: NativeNotificationConfig;
+};
+
+export type NativeStatus = {
+  state: string;
+  connectedSince?: number;
+  server?: string;
+  localIp?: string;
+  remoteIp?: string;
+};
+
+export type NativeStats = {
+  bytesIn: number;
+  bytesOut: number;
+  durationMs: number;
+};
+
+export interface Spec extends TurboModule {
+  requestPermission(): Promise<boolean>;
+  connect(params: NativeConnectParams): Promise<void>;
+  disconnect(): Promise<void>;
+  getStatus(): Promise<NativeStatus>;
+  getStats(): Promise<NativeStats>;
+  addListener(eventName: string): void;
+  removeListeners(count: number): void;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('Openvpn');

package/src/OpenVPNClient.ts

@@ -0,0 +1,239 @@
+import type { EmitterSubscription } from 'react-native';
+import { NativeEventEmitter, NativeModules } from 'react-native';
+import NativeOpenvpn from './NativeOpenvpn';
+import type { Stats, Status, VPNState } from './types';
+import { ERROR_CODES, HARD_ERROR_CODES, OpenVPNError } from './errors';
+import type { ErrorCode } from './errors';
+import type { ConnectOptions, ReconnectingEvent } from './types';
+import { Scheduler } from './reconnect';
+import type { NativeConnectParams } from './NativeOpenvpn';
+
+type Listener<T> = (payload: T) => void;
+
+type EventMap = {
+  state: VPNState;
+  stats: Stats;
+  log: string;
+  error: OpenVPNError;
+  reconnecting: ReconnectingEvent;
+};
+
+// NativeEventEmitter requires a NativeModule with addListener/removeListeners.
+// In tests the TurboModule mock satisfies this shape.
+type NativeModuleLike = {
+  addListener: (eventName: string) => void;
+  removeListeners: (count: number) => void;
+};
+
+export class OpenVPNClient {
+  private readonly emitter: NativeEventEmitter;
+  private readonly listeners: {
+    [K in keyof EventMap]: Set<Listener<EventMap[K]>>;
+  } = {
+    state: new Set(),
+    stats: new Set(),
+    log: new Set(),
+    error: new Set(),
+    reconnecting: new Set(),
+  };
+  private subscriptions: EmitterSubscription[] = [];
+
+  private currentConnect: {
+    resolve: () => void;
+    reject: (err: OpenVPNError) => void;
+  } | null = null;
+
+  private userRequestedDisconnect = false;
+  private hardErrorPending = false;
+  private scheduler: Scheduler | null = null;
+  private lastParams: NativeConnectParams | null = null;
+  private lastReconnectOpts: Required<import('./types').ReconnectOptions> = {
+    maxRetries: 5,
+    baseDelayMs: 1000,
+    maxDelayMs: 60000,
+  };
+
+  constructor() {
+    // On iOS (including the jest defaultPlatform) NativeEventEmitter requires
+    // a non-null module. Use the imported TurboModule instance (or native
+    // registry) as that module — it always exposes addListener/removeListeners.
+    const nativeModule: NativeModuleLike =
+      (NativeModules.Openvpn as NativeModuleLike | undefined) ??
+      (NativeOpenvpn as unknown as NativeModuleLike);
+    // NativeModule type is not exported from react-native, cast via any.
+
+    this.emitter = new NativeEventEmitter(nativeModule as any);
+
+    this.subscriptions.push(
+      this.emitter.addListener('OpenVpn:state', (s: unknown) => {
+        const state = s as VPNState;
+        this.emit('state', state);
+        if (state === 'connected') {
+          this.settleConnect(null, true);
+          if (this.scheduler) {
+            this.scheduler.stop();
+            this.scheduler = null;
+          }
+        }
+        if (state === 'disconnected') this.handleDisconnect();
+      }),
+      this.emitter.addListener('OpenVpn:stats', (s: unknown) => {
+        this.emit('stats', s as Stats);
+      }),
+      this.emitter.addListener('OpenVpn:log', (line: unknown) => {
+        this.emit('log', line as string);
+      }),
+      this.emitter.addListener('OpenVpn:error', (raw: unknown) => {
+        const r = raw as { code: string; nativeMessage?: string };
+        const code = (ERROR_CODES as readonly string[]).includes(r.code)
+          ? (r.code as ErrorCode)
+          : 'NATIVE_ERROR';
+        const err = new OpenVPNError(code, r.nativeMessage);
+        this.emit('error', err);
+        if (HARD_ERROR_CODES.has(code)) {
+          this.hardErrorPending = true;
+          if (this.currentConnect) this.settleConnect(err, false);
+        }
+      })
+    );
+  }
+
+  on<K extends keyof EventMap>(event: K, fn: Listener<EventMap[K]>): void {
+    this.listeners[event].add(fn);
+  }
+
+  off<K extends keyof EventMap>(event: K, fn: Listener<EventMap[K]>): void {
+    this.listeners[event].delete(fn);
+  }
+
+  removeAllListeners(): void {
+    for (const key of Object.keys(this.listeners) as (keyof EventMap)[]) {
+      this.listeners[key].clear();
+    }
+  }
+
+  protected emit<K extends keyof EventMap>(
+    event: K,
+    payload: EventMap[K]
+  ): void {
+    for (const fn of this.listeners[event]) fn(payload);
+  }
+
+  dispose(): void {
+    for (const sub of this.subscriptions) sub.remove();
+    this.subscriptions = [];
+    this.removeAllListeners();
+  }
+
+  async requestPermission(): Promise<boolean> {
+    return NativeOpenvpn.requestPermission();
+  }
+
+  async getStatus(): Promise<Status> {
+    const raw = await NativeOpenvpn.getStatus();
+    return raw as Status;
+  }
+
+  async getStats(): Promise<Stats> {
+    return NativeOpenvpn.getStats();
+  }
+
+  async connect(options: ConnectOptions): Promise<void> {
+    if (this.currentConnect) {
+      throw new OpenVPNError(
+        'NATIVE_ERROR',
+        'connect() called while already connecting'
+      );
+    }
+    if (this.scheduler) {
+      this.scheduler.stop();
+      this.scheduler = null;
+    }
+    this.userRequestedDisconnect = false;
+    this.hardErrorPending = false;
+
+    const params: NativeConnectParams = {
+      config: options.config,
+      username: options.username,
+      password: options.password,
+      killSwitch: options.killSwitch ?? false,
+      dns: options.dns ?? [],
+      allowedApps: options.allowedApps ?? [],
+      disallowedApps: options.disallowedApps ?? [],
+      notification: options.notification ?? {},
+    };
+
+    this.lastParams = params;
+    this.lastReconnectOpts = {
+      maxRetries: options.reconnect?.maxRetries ?? 5,
+      baseDelayMs: options.reconnect?.baseDelayMs ?? 1000,
+      maxDelayMs: options.reconnect?.maxDelayMs ?? 60000,
+    };
+
+    return new Promise<void>((resolve, reject) => {
+      this.currentConnect = { resolve, reject };
+      NativeOpenvpn.connect(params).catch((nativeErr: Error) => {
+        this.settleConnect(
+          new OpenVPNError('NATIVE_ERROR', nativeErr.message),
+          false
+        );
+      });
+    });
+  }
+
+  async disconnect(): Promise<void> {
+    this.userRequestedDisconnect = true;
+    if (this.scheduler) {
+      this.scheduler.stop();
+      this.scheduler = null;
+    }
+    await NativeOpenvpn.disconnect();
+  }
+
+  private settleConnect(err: OpenVPNError | null, resolved: boolean): void {
+    const pending = this.currentConnect;
+    if (!pending) return;
+    this.currentConnect = null;
+    if (resolved) pending.resolve();
+    else if (err) pending.reject(err);
+  }
+
+  private handleDisconnect(): void {
+    if (this.userRequestedDisconnect || this.hardErrorPending) return;
+    if (!this.lastParams) return;
+    // Immediately overwrite the just-emitted 'disconnected' so the UI never
+    // paints an enabled Connect button between auto-retry attempts. React's
+    // automatic batching collapses both setState calls in this tick.
+    this.emit('state', 'reconnecting');
+    if (this.scheduler) {
+      // We're already in a retry loop and just heard another drop —
+      // tell the scheduler the most-recent attempt failed.
+      this.scheduler.notifyFailure();
+      return;
+    }
+    this.scheduler = new Scheduler({
+      maxRetries: this.lastReconnectOpts.maxRetries,
+      baseDelayMs: this.lastReconnectOpts.baseDelayMs,
+      maxDelayMs: this.lastReconnectOpts.maxDelayMs,
+      onAttempt: ({ attempt, delayMs }) => {
+        this.emit('state', 'reconnecting');
+        this.emit('reconnecting', { attempt, delayMs });
+        // Drive retries off state events, not the connect() Promise — the
+        // catch here only logs; the eventual 'disconnected' event drives
+        // notifyFailure via handleDisconnect.
+        NativeOpenvpn.connect(this.lastParams!).catch((nativeErr: Error) => {
+          this.emit(
+            'error',
+            new OpenVPNError('NATIVE_ERROR', nativeErr.message)
+          );
+        });
+      },
+      onExhausted: () => {
+        this.emit('error', new OpenVPNError('RECONNECT_EXHAUSTED'));
+        this.emit('state', 'disconnected');
+        this.scheduler = null;
+      },
+    });
+    this.scheduler.start();
+  }
+}

package/src/errors.ts

@@ -0,0 +1,29 @@
+export const ERROR_CODES = [
+  'PERMISSION_DENIED',
+  'INVALID_CONFIG',
+  'AUTH_FAILED',
+  'TLS_FAILED',
+  'NETWORK_UNREACHABLE',
+  'RECONNECT_EXHAUSTED',
+  'NATIVE_ERROR',
+] as const;
+
+export type ErrorCode = (typeof ERROR_CODES)[number];
+
+export class OpenVPNError extends Error {
+  readonly code: ErrorCode;
+  readonly nativeMessage?: string;
+
+  constructor(code: ErrorCode, nativeMessage?: string) {
+    super(nativeMessage ? `${code}: ${nativeMessage}` : code);
+    this.name = 'OpenVPNError';
+    this.code = code;
+    this.nativeMessage = nativeMessage;
+  }
+}
+
+export const HARD_ERROR_CODES: ReadonlySet<ErrorCode> = new Set([
+  'AUTH_FAILED',
+  'INVALID_CONFIG',
+  'PERMISSION_DENIED',
+]);

package/src/index.ts

@@ -0,0 +1,12 @@
+export { OpenVPNClient } from './OpenVPNClient';
+export { OpenVPNError, ERROR_CODES } from './errors';
+export type { ErrorCode } from './errors';
+export type {
+  VPNState,
+  ConnectOptions,
+  ReconnectOptions,
+  NotificationOptions,
+  Status,
+  Stats,
+  ReconnectingEvent,
+} from './types';

package/src/reconnect.ts

@@ -0,0 +1,68 @@
+export function calculateDelay(
+  attempt: number,
+  baseDelayMs: number,
+  maxDelayMs: number
+): number {
+  const raw = baseDelayMs * Math.pow(2, attempt);
+  return Math.min(raw, maxDelayMs);
+}
+
+export type SchedulerOptions = {
+  maxRetries: number;
+  baseDelayMs: number;
+  maxDelayMs: number;
+  onAttempt: (info: { attempt: number; delayMs: number }) => void;
+  onExhausted: () => void;
+};
+
+export class Scheduler {
+  private readonly opts: SchedulerOptions;
+  private attempt = 0;
+  private timer: ReturnType<typeof setTimeout> | null = null;
+  private started = false;
+
+  constructor(opts: SchedulerOptions) {
+    this.opts = opts;
+  }
+
+  start(): void {
+    if (this.started) return;
+    this.started = true;
+    this.attempt = 0;
+    this.scheduleNext();
+  }
+
+  stop(): void {
+    this.started = false;
+    if (this.timer !== null) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+  }
+
+  notifyFailure(): void {
+    if (!this.started) return;
+    if (this.attempt >= this.opts.maxRetries) {
+      this.stop();
+      this.opts.onExhausted();
+      return;
+    }
+    this.scheduleNext();
+  }
+
+  private scheduleNext(): void {
+    if (this.timer !== null) {
+      clearTimeout(this.timer);
+    }
+    const delayMs = calculateDelay(
+      this.attempt,
+      this.opts.baseDelayMs,
+      this.opts.maxDelayMs
+    );
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      this.attempt += 1;
+      this.opts.onAttempt({ attempt: this.attempt, delayMs });
+    }, delayMs);
+  }
+}

package/src/types.ts

@@ -0,0 +1,53 @@
+export type VPNState =
+  | 'idle'
+  | 'connecting'
+  | 'reconnecting'
+  | 'connected'
+  | 'disconnecting'
+  | 'disconnected'
+  | 'error';
+
+export type NotificationOptions = {
+  title?: string;
+  text?: string;
+  smallIcon?: string;
+  channelId?: string;
+};
+
+export type ReconnectOptions = {
+  maxRetries?: number;
+  baseDelayMs?: number;
+  maxDelayMs?: number;
+};
+
+export type ConnectOptions = {
+  config: string;
+  username: string;
+  password: string;
+  reconnect?: ReconnectOptions;
+  killSwitch?: boolean;
+  dns?: string[];
+  allowedApps?: string[];
+  disallowedApps?: string[];
+  notification?: NotificationOptions;
+};
+
+export type Status = {
+  state: VPNState;
+  connectedSince?: number;
+  server?: string;
+  localIp?: string;
+  remoteIp?: string;
+};
+
+export type Stats = {
+  bytesIn: number;
+  bytesOut: number;
+  durationMs: number;
+};
+
+export type ReconnectingEvent = {
+  attempt: number;
+  /** Delay in ms that elapsed BEFORE this attempt was made (not the next wait). */
+  delayMs: number;
+};