engagelab-captcha-sdk 1.0.0

package/src/logger.ts

@@ -0,0 +1,170 @@
+/**
+ * EngageLab CAPTCHA SDK Logger
+ *
+ * Provides structured logging with levels and optional console output.
+ * Can be enabled via config or localStorage for debugging.
+ */
+
+export enum LogLevel {
+  NONE = 0,
+  ERROR = 1,
+  WARN = 2,
+  INFO = 3,
+  DEBUG = 4,
+}
+
+interface LogEntry {
+  timestamp: number;
+  level: string;
+  module: string;
+  message: string;
+  data?: any;
+}
+
+class SDKLogger {
+  private level: LogLevel = LogLevel.NONE;
+  private logs: LogEntry[] = [];
+  private maxLogs = 500;
+  private prefix = '[EngageLab-CAPTCHA]';
+  private apiBase = '';
+  private siteKey = '';
+  private sessionId = '';
+  private flushTimer: ReturnType<typeof setInterval> | null = null;
+  private isFlushing = false;
+
+  setLevel(level: LogLevel): void {
+    this.level = level;
+  }
+
+  enableDebug(): void {
+    this.level = LogLevel.DEBUG;
+  }
+
+  disable(): void {
+    this.level = LogLevel.NONE;
+  }
+
+  error(module: string, message: string, data?: any): void {
+    this.log(LogLevel.ERROR, module, message, data);
+  }
+
+  warn(module: string, message: string, data?: any): void {
+    this.log(LogLevel.WARN, module, message, data);
+  }
+
+  info(module: string, message: string, data?: any): void {
+    this.log(LogLevel.INFO, module, message, data);
+  }
+
+  debug(module: string, message: string, data?: any): void {
+    this.log(LogLevel.DEBUG, module, message, data);
+  }
+
+  getLogs(): LogEntry[] {
+    return [...this.logs];
+  }
+
+  clearLogs(): void {
+    this.logs = [];
+  }
+
+  private log(level: LogLevel, module: string, message: string, data?: any): void {
+    if (level > this.level) return;
+
+    const entry: LogEntry = {
+      timestamp: Date.now(),
+      level: LogLevel[level],
+      module,
+      message,
+      data,
+    };
+
+    this.logs.push(entry);
+    if (this.logs.length > this.maxLogs) {
+      this.logs.splice(0, this.logs.length - this.maxLogs);
+    }
+
+    const levelNames = ['', 'ERROR', 'WARN', 'INFO', 'DEBUG'];
+    const tag = `${this.prefix}[${levelNames[level]}][${module}]`;
+
+    if (level === LogLevel.ERROR) {
+      console.error(tag, message, data !== undefined ? data : '');
+    } else if (level === LogLevel.WARN) {
+      console.warn(tag, message, data !== undefined ? data : '');
+    } else if (level === LogLevel.INFO) {
+      console.info(tag, message, data !== undefined ? data : '');
+    } else {
+      console.log(tag, message, data !== undefined ? data : '');
+    }
+  }
+
+  configure(apiBase: string, siteKey: string): void {
+    this.apiBase = apiBase.replace(/\/$/, '');
+    this.siteKey = siteKey;
+  }
+
+  setSessionId(id: string): void {
+    this.sessionId = id;
+  }
+
+  startAutoFlush(intervalMs: number = 30000): void {
+    this.stopAutoFlush();
+    this.flushTimer = setInterval(() => this.flush(), intervalMs);
+  }
+
+  stopAutoFlush(): void {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+  }
+
+  async flush(): Promise<void> {
+    if (this.isFlushing || this.logs.length === 0 || !this.apiBase) return;
+    this.isFlushing = true;
+
+    const logsToSend = this.logs.splice(0, 50);
+    try {
+      await fetch(`${this.apiBase}/v1/logs/report`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'X-Site-Key': this.siteKey,
+        },
+        body: JSON.stringify({
+          siteKey: this.siteKey,
+          sessionId: this.sessionId,
+          sdkVersion: '2.0.0',
+          platform: 'web',
+          logs: logsToSend,
+        }),
+      });
+    } catch {
+      // Put logs back on failure
+      this.logs.unshift(...logsToSend);
+    } finally {
+      this.isFlushing = false;
+    }
+  }
+
+  destroy(): void {
+    this.stopAutoFlush();
+    void this.flush();
+  }
+}
+
+// Check localStorage for debug flag
+function shouldEnableDebug(): boolean {
+  try {
+    return localStorage.getItem('engagelab_captcha_debug') === 'true';
+  } catch {
+    return false;
+  }
+}
+
+export const sdkLogger = new SDKLogger();
+
+// Auto-enable if debug flag is set
+if (typeof window !== 'undefined' && shouldEnableDebug()) {
+  sdkLogger.enableDebug();
+}

package/src/native_monitor.ts

@@ -0,0 +1,100 @@
+/**
+ * NativeMonitor — wrap sensitive global functions to detect automation tool injection.
+ *
+ * Records stack traces from calls to eval, Function constructor, and setTimeout(string).
+ * Provides disable() and a config flag (disableEvalPatching) for environments
+ * where wrapping interferes with HMR or dev tooling.
+ */
+import type { NativeTrace } from './types';
+
+const MAX_TRACES = 100;
+
+export class NativeMonitor {
+  private traces: NativeTrace[] = [];
+  private originals: Record<string, any> = {};
+  private active = false;
+
+  start(): void {
+    if (this.active) return;
+    this.active = true;
+
+    this.wrapEval();
+    this.wrapFunctionConstructor();
+    this.wrapSetTimeoutString();
+  }
+
+  disable(): void {
+    this.active = false;
+    this.restore();
+  }
+
+  getTraces(): NativeTrace[] {
+    return this.traces.slice();
+  }
+
+  private record(fn: string): void {
+    if (!this.active) return;
+    const err = new Error();
+    const stack = (err.stack || '').split('\n').slice(2, 8).join('\n');
+    this.traces.push({ fn, stack, timestamp: Date.now() });
+    if (this.traces.length > MAX_TRACES) {
+      this.traces.splice(0, this.traces.length - MAX_TRACES);
+    }
+  }
+
+  private wrapEval(): void {
+    if (typeof window === 'undefined') return;
+    const origEval = window.eval;
+    this.originals['eval'] = origEval;
+    const self = this;
+
+    (window as any).eval = function (code: string) {
+      self.record('eval');
+      return origEval.call(this, code);
+    };
+  }
+
+  private wrapFunctionConstructor(): void {
+    const origCtor = Function.prototype.constructor;
+    this.originals['FunctionConstructor'] = origCtor;
+    const self = this;
+
+    try {
+      Function.prototype.constructor = function (this: any, ...args: any[]) {
+        self.record('Function.constructor');
+        return origCtor.apply(this, args);
+      } as any;
+    } catch {
+      // Some environments don't allow overriding Function.prototype.constructor
+    }
+  }
+
+  private wrapSetTimeoutString(): void {
+    if (typeof window === 'undefined') return;
+    const origSetTimeout = window.setTimeout;
+    this.originals['setTimeout'] = origSetTimeout;
+    const self = this;
+
+    (window as any).setTimeout = function (handler: any, timeout?: number, ...args: any[]) {
+      if (typeof handler === 'string') {
+        self.record('setTimeout(string)');
+      }
+      return origSetTimeout.call(this, handler, timeout, ...args);
+    };
+  }
+
+  private restore(): void {
+    if (this.originals['eval'] && typeof window !== 'undefined') {
+      (window as any).eval = this.originals['eval'];
+    }
+    if (this.originals['FunctionConstructor']) {
+      try {
+        Function.prototype.constructor = this.originals['FunctionConstructor'];
+      } catch { /* ignore */ }
+    }
+    if (this.originals['setTimeout'] && typeof window !== 'undefined') {
+      (window as any).setTimeout = this.originals['setTimeout'];
+    }
+    this.originals = {};
+  }
+}