devfortress-sdk 4.2.0 → 4.2.1

package/dist/devfortress.js

@@ -0,0 +1,758 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DevFortress = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const axios_1 = __importDefault(require("axios"));
+const internal_closed_loop_engine_1 = require("./internal-closed-loop-engine");
+const circuit_breaker_1 = require("./circuit-breaker");
+const unified_audit_1 = require("./unified-audit");
+const tier_gate_1 = require("./tier-gate");
+const DEFAULT_ENDPOINT = 'https://www.devfortress.net/api/events/ingest';
+const DEFAULT_TIMEOUT = 5000;
+const DEFAULT_RETRIES = 3;
+const WEBHOOK_MAX_AGE_MS = 5 * 60 * 1000;
+function deriveBaseUrl(endpoint) {
+    const url = new URL(endpoint);
+    const parts = url.pathname.split('/').filter(Boolean);
+    if (parts.length > 0 && parts[parts.length - 1] === 'ingest') {
+        parts.pop();
+    }
+    url.pathname = '/' + parts.join('/');
+    return url.toString().replace(/\/$/, '');
+}
+const memoryCache = new Map();
+function memGet(key) {
+    const entry = memoryCache.get(key);
+    if (!entry)
+        return null;
+    if (Date.now() > entry.expiresAt) {
+        memoryCache.delete(key);
+        return null;
+    }
+    return entry.value;
+}
+function memSet(key, value, ttlSeconds) {
+    memoryCache.set(key, {
+        value,
+        expiresAt: Date.now() + ttlSeconds * 1000,
+    });
+}
+class DevFortress {
+    constructor(config) {
+        this.handlers = new Map();
+        this.internalEngine = null;
+        this.circuitBreaker = null;
+        if (!config.apiKey) {
+            throw new Error('DevFortress: apiKey is required');
+        }
+        if (!config.appId) {
+            throw new Error('DevFortress: appId is required');
+        }
+        this.apiKey = config.apiKey;
+        this.appId = config.appId;
+        this.environment = config.environment || 'production';
+        this.debug = config.debug || false;
+        this.endpoint = config.endpoint || DEFAULT_ENDPOINT;
+        this.timeout = config.timeout || DEFAULT_TIMEOUT;
+        this.retries = config.retries || DEFAULT_RETRIES;
+        this.enrichment = config.enrichment;
+        this.responseWebhook = config.responseWebhook;
+        this.cacheConfig = config.cache;
+        const tier = (config.tier || 'starter');
+        this.tierGate = new tier_gate_1.TierGate(tier, {
+            hybridAddonEnabled: config.hybridAddonEnabled,
+        });
+        this.mode = this.tierGate.getEffectiveMode(config.mode);
+        this.auditTrail = new unified_audit_1.UnifiedAuditTrail({ debug: this.debug });
+        if (this.mode === 'internal' || this.mode === 'hybrid') {
+            const iclConfig = {
+                failMode: config.internalCL?.failMode ?? 'closed',
+                enableExternalRelay: this.mode === 'hybrid',
+                tier2Scorer: config.internalCL
+                    ?.tier2Scorer,
+                blockThreshold: config.internalCL?.blockThreshold ?? 85,
+                rateLimitMax: config.internalCL?.rateLimitMax ?? 100,
+                rateLimitWindowMs: config.internalCL?.rateLimitWindowMs ?? 60000,
+                debug: this.debug,
+            };
+            this.internalEngine = new internal_closed_loop_engine_1.InternalClosedLoopEngine(iclConfig);
+        }
+        if (this.mode === 'hybrid') {
+            this.circuitBreaker = new circuit_breaker_1.PlatformCircuitBreaker({
+                failureThreshold: config.circuitBreaker?.failureThreshold ?? 3,
+                recoveryTimeMs: config.circuitBreaker?.recoveryTimeMs ?? 60000,
+                onStateChange: (from, to, reason) => {
+                    this.log('warn', `Circuit breaker: ${from} → ${to} (${reason})`);
+                },
+            });
+        }
+        if (this.endpoint.startsWith('http://') &&
+            !this.endpoint.includes('localhost') &&
+            !this.endpoint.includes('127.0.0.1')) {
+            this.log('warn', 'Using non-HTTPS endpoint. API key will be transmitted in cleartext.');
+        }
+        this.axios = axios_1.default.create({
+            baseURL: this.endpoint,
+            timeout: this.timeout,
+            headers: {
+                'Content-Type': 'application/json',
+                'X-DevFortress-Key': this.apiKey,
+                'X-DevFortress-App': this.appId,
+            },
+        });
+        const baseApiUrl = deriveBaseUrl(this.endpoint);
+        this.apiAxios = axios_1.default.create({
+            baseURL: baseApiUrl,
+            timeout: this.timeout,
+            headers: {
+                'Content-Type': 'application/json',
+                'X-DevFortress-Key': this.apiKey,
+                'X-DevFortress-App': this.appId,
+            },
+        });
+        this.log('info', `DevFortress SDK v4.0.0 initialized (app=${this.appId}, mode=${this.mode}, tier=${tier})`);
+    }
+    getMode() {
+        return this.mode;
+    }
+    getAudit() {
+        return this.auditTrail;
+    }
+    getTierGate() {
+        return this.tierGate;
+    }
+    getInternalEngine() {
+        return this.internalEngine;
+    }
+    getCircuitBreakerDiagnostics() {
+        return this.circuitBreaker?.getDiagnostics() ?? null;
+    }
+    async observe(req, options) {
+        const limitCheck = this.tierGate.checkEventLimit();
+        if (!limitCheck.allowed) {
+            this.log('warn', 'Daily event limit reached, skipping observe()');
+            return null;
+        }
+        this.tierGate.recordEvent();
+        try {
+            const r = req;
+            const method = r.method || 'GET';
+            const path = r.url || r.path || '/';
+            const headers = r.headers || {};
+            let ip = '0.0.0.0';
+            if (!options?.skipEnrichment && this.enrichment?.getIP) {
+                ip = this.enrichment.getIP(req) || ip;
+            }
+            else {
+                const forwarded = headers['x-forwarded-for'];
+                ip =
+                    (typeof forwarded === 'string'
+                        ? forwarded.split(',')[0]?.trim()
+                        : undefined) ||
+                        headers['x-real-ip'] ||
+                        ip;
+            }
+            let userId = null;
+            let sessionId = null;
+            if (!options?.skipEnrichment && this.enrichment) {
+                if (this.enrichment.getUserId) {
+                    userId = await Promise.resolve(this.enrichment.getUserId(req));
+                }
+                if (this.enrichment.getSessionId) {
+                    sessionId = await Promise.resolve(this.enrichment.getSessionId(req));
+                }
+            }
+            const userAgent = typeof headers['user-agent'] === 'string'
+                ? headers['user-agent']
+                : null;
+            if (this.mode === 'internal') {
+                return this.observeInternal({
+                    ip,
+                    method,
+                    path,
+                    userAgent: userAgent || undefined,
+                    userId,
+                    sessionId,
+                }, options);
+            }
+            else if (this.mode === 'hybrid') {
+                return this.observeHybrid({
+                    ip,
+                    method,
+                    path,
+                    userAgent: userAgent || undefined,
+                    userId,
+                    sessionId,
+                }, options);
+            }
+            else {
+                return this.observeExternal({ ip, method, path, userAgent, userId, sessionId }, options);
+            }
+        }
+        catch (error) {
+            this.log('error', `observe() failed: ${error instanceof Error ? error.message : 'Unknown'}`);
+            return null;
+        }
+    }
+    async observeExternal(parsed, options) {
+        const startTime = performance.now();
+        try {
+            const payload = {
+                eventType: 'custom',
+                ip: parsed.ip,
+                method: parsed.method,
+                path: parsed.path,
+                userAgent: parsed.userAgent,
+                userId: parsed.userId,
+                sessionId: parsed.sessionId,
+                appId: this.appId,
+                environment: this.environment,
+                timestamp: new Date().toISOString(),
+                metadata: {
+                    ...options?.meta,
+                    clMode: options?.meta?.clMode || this.mode,
+                },
+            };
+            const response = await this.sendWithRetry(payload);
+            const data = response.data;
+            const latencyMs = performance.now() - startTime;
+            this.auditTrail.record({
+                eventId: data.eventId || data.event_id || `ext_${Date.now().toString(36)}`,
+                timestamp: Date.now(),
+                source: 'external',
+                tier: 0,
+                decision: data.flagged ? 'block' : 'allow',
+                score: data.confidence ? data.confidence * 100 : 0,
+                severity: data.flagged ? 'high' : 'low',
+                latencyMs: Math.round(latencyMs),
+                ip: parsed.ip,
+                path: parsed.path,
+                method: parsed.method,
+                matchedRules: [],
+                userId: parsed.userId,
+                sessionId: parsed.sessionId,
+            });
+            if (data.flagged) {
+                return {
+                    flagged: true,
+                    event_id: data.eventId || data.event_id || '',
+                    confidence: data.confidence || 0,
+                };
+            }
+            return null;
+        }
+        catch (error) {
+            this.log('error', `observeExternal() failed: ${error instanceof Error ? error.message : 'Unknown'}`);
+            return null;
+        }
+    }
+    async observeInternal(parsed, options) {
+        if (!this.internalEngine) {
+            this.log('error', 'Internal engine not initialized');
+            return null;
+        }
+        const iclRequest = {
+            ip: parsed.ip,
+            method: parsed.method,
+            path: parsed.path,
+            userAgent: parsed.userAgent,
+            userId: parsed.userId,
+            sessionId: parsed.sessionId,
+            agentId: options?.meta?.agent_id,
+            toolName: options?.meta?.tool_name,
+        };
+        const result = await this.internalEngine.evaluate(iclRequest);
+        this.auditTrail.record({
+            eventId: result.eventId,
+            timestamp: Date.now(),
+            source: 'internal',
+            tier: result.tier,
+            decision: result.decision,
+            score: result.score,
+            severity: result.score >= 85
+                ? 'critical'
+                : result.score >= 60
+                    ? 'high'
+                    : result.score >= 35
+                        ? 'medium'
+                        : 'low',
+            latencyMs: result.evaluationTimeUs / 1000,
+            ip: parsed.ip,
+            path: parsed.path,
+            method: parsed.method,
+            matchedRules: result.matchedRules,
+            userId: parsed.userId,
+            agentId: options?.meta?.agent_id,
+            sessionId: parsed.sessionId,
+        });
+        if (result.decision !== 'allow' && this.tierGate.canBlock()) {
+            memSet(`blocked:ip:${parsed.ip}`, '1', 3600);
+            await this.fireThreatHandlers(result, parsed, options);
+        }
+        if (result.decision !== 'allow') {
+            return {
+                flagged: true,
+                event_id: result.eventId,
+                confidence: result.score / 100,
+            };
+        }
+        return null;
+    }
+    async observeHybrid(parsed, options) {
+        const internalResult = await this.observeInternal(parsed, options);
+        if (internalResult?.flagged) {
+            this.relayToExternalAsync(parsed, options).catch(() => { });
+            return internalResult;
+        }
+        if (this.circuitBreaker && this.circuitBreaker.shouldCallExternal()) {
+            try {
+                const externalResult = await this.observeExternal({ ...parsed, userAgent: parsed.userAgent || null }, options);
+                this.circuitBreaker.recordSuccess();
+                if (externalResult?.flagged) {
+                    this.auditTrail.record({
+                        eventId: externalResult.event_id,
+                        timestamp: Date.now(),
+                        source: 'hybrid',
+                        tier: 0,
+                        decision: 'block',
+                        score: externalResult.confidence * 100,
+                        severity: 'high',
+                        latencyMs: 0,
+                        ip: parsed.ip,
+                        path: parsed.path,
+                        method: parsed.method,
+                        matchedRules: ['external_enrichment'],
+                        userId: parsed.userId,
+                        sessionId: parsed.sessionId,
+                        fallbackMode: false,
+                    });
+                    return externalResult;
+                }
+                return null;
+            }
+            catch {
+                this.circuitBreaker.recordFailure();
+                this.log('warn', 'External CL unavailable, relying on internal-only');
+                this.auditTrail.record({
+                    eventId: `fb_${Date.now().toString(36)}`,
+                    timestamp: Date.now(),
+                    source: 'hybrid',
+                    tier: 0,
+                    decision: 'allow',
+                    score: 0,
+                    severity: 'low',
+                    latencyMs: 0,
+                    ip: parsed.ip,
+                    path: parsed.path,
+                    method: parsed.method,
+                    matchedRules: ['fallback_to_internal'],
+                    userId: parsed.userId,
+                    sessionId: parsed.sessionId,
+                    fallbackMode: true,
+                });
+                return null;
+            }
+        }
+        else {
+            this.log('debug', 'Circuit open, using internal-only mode');
+            return null;
+        }
+    }
+    async relayToExternalAsync(parsed, options) {
+        if (!this.circuitBreaker?.shouldCallExternal())
+            return;
+        try {
+            await this.observeExternal({ ...parsed, userAgent: parsed.userAgent || null }, options);
+            this.circuitBreaker?.recordSuccess();
+        }
+        catch {
+            this.circuitBreaker?.recordFailure();
+        }
+    }
+    async fireThreatHandlers(result, parsed, options) {
+        const severity = result.score >= 85
+            ? 'critical'
+            : result.score >= 60
+                ? 'high'
+                : result.score >= 35
+                    ? 'medium'
+                    : 'low';
+        const threatEvent = {
+            event_id: result.eventId,
+            threat_type: result.matchedRules.join(', ') || 'internal_detection',
+            severity,
+            confidence: result.score / 100,
+            composite_score: result.score,
+            ip: parsed.ip,
+            identity: {
+                user_id: parsed.userId,
+                session_id: parsed.sessionId,
+            },
+            endpoint: parsed.path,
+            method: parsed.method,
+            timestamp: new Date().toISOString(),
+            meta: {
+                ...(options?.meta || {}),
+                source: 'internal',
+                tier: result.tier,
+                evaluation_time_us: result.evaluationTimeUs,
+            },
+        };
+        const specificHandlers = this.handlers.get(severity) || [];
+        const wildcardHandlers = this.handlers.get('*') || [];
+        for (const handler of [...specificHandlers, ...wildcardHandlers]) {
+            try {
+                await handler(threatEvent);
+            }
+            catch (error) {
+                this.log('error', `Threat handler error: ${error instanceof Error ? error.message : 'Unknown'}`);
+            }
+        }
+    }
+    async enrichEvent(eventId, additionalData) {
+        if (this.mode === 'internal') {
+            this.log('debug', `enrichEvent() is a no-op in internal mode`);
+            return;
+        }
+        try {
+            await this.apiAxios.patch(`/enrich/${eventId}`, additionalData);
+            this.log('debug', `Enriched event ${eventId}`);
+        }
+        catch (error) {
+            this.log('error', `enrichEvent() failed: ${error instanceof Error ? error.message : 'Unknown'}`);
+        }
+    }
+    async isBlocked(ip, options) {
+        if (this.internalEngine) {
+            if (this.internalEngine.isIPBlocked(ip))
+                return true;
+        }
+        if (memGet(`blocked:ip:${ip}`))
+            return true;
+        if (options?.userId && memGet(`blocked:user:${options.userId}`))
+            return true;
+        if (options?.sessionId && memGet(`blocked:session:${options.sessionId}`))
+            return true;
+        if (this.mode === 'internal')
+            return false;
+        try {
+            const response = await this.apiAxios.get('/blocked', {
+                params: { ip, userId: options?.userId, sessionId: options?.sessionId },
+            });
+            const blocked = response.data.blocked;
+            if (blocked) {
+                memSet(`blocked:ip:${ip}`, '1', this.cacheConfig?.ttl || 3600);
+            }
+            return blocked;
+        }
+        catch {
+            this.log('warn', `isBlocked() check failed for ${ip}, failing open`);
+            return false;
+        }
+    }
+    onThreatDetected(severity, handler) {
+        if (!this.handlers.has(severity)) {
+            this.handlers.set(severity, []);
+        }
+        this.handlers.get(severity).push(handler);
+        this.log('debug', `Registered threat handler for severity: ${severity}`);
+    }
+    async reportActionTaken(eventId, report) {
+        if (this.mode === 'internal') {
+            this.log('debug', `reportActionTaken() recorded locally in internal mode`);
+            return;
+        }
+        try {
+            await this.apiAxios.post('/actions/confirm', {
+                event_id: eventId,
+                ...report,
+                timestamp: new Date().toISOString(),
+            });
+            this.log('info', `Action confirmed for event ${eventId}: ${report.actions.join(', ')}`);
+        }
+        catch (error) {
+            this.log('error', `reportActionTaken() failed: ${error instanceof Error ? error.message : 'Unknown'}`);
+        }
+    }
+    async handleWebhook(rawBody, signature, timestamp) {
+        if (!this.responseWebhook?.secret) {
+            this.log('error', 'handleWebhook() called but no webhook secret configured');
+            return false;
+        }
+        const webhookTime = new Date(timestamp).getTime();
+        if (isNaN(webhookTime) || Date.now() - webhookTime > WEBHOOK_MAX_AGE_MS) {
+            this.log('warn', 'Webhook rejected: timestamp too old or invalid');
+            return false;
+        }
+        const expectedSignature = crypto_1.default
+            .createHmac('sha256', this.responseWebhook.secret)
+            .update(`${timestamp}.${rawBody}`)
+            .digest('hex');
+        const sigBuffer = Buffer.from(signature, 'hex');
+        const expectedBuffer = Buffer.from(expectedSignature, 'hex');
+        if (sigBuffer.length !== expectedBuffer.length ||
+            !crypto_1.default.timingSafeEqual(sigBuffer, expectedBuffer)) {
+            this.log('warn', 'Webhook rejected: invalid signature');
+            return false;
+        }
+        let payload;
+        try {
+            payload = JSON.parse(rawBody);
+        }
+        catch {
+            this.log('error', 'Webhook rejected: invalid JSON body');
+            return false;
+        }
+        const threatEvent = {
+            event_id: payload.event_id,
+            threat_type: payload.threat_type,
+            severity: payload.severity,
+            confidence: payload.confidence,
+            composite_score: payload.composite_score,
+            ip: payload.ip,
+            identity: payload.identity,
+            geo: payload.geo,
+            abuseipdb: payload.abuseipdb,
+            endpoint: payload.endpoint,
+            method: payload.method,
+            timestamp: payload.timestamp,
+            meta: payload.meta || {},
+        };
+        if (this.tierGate.canBlock()) {
+            if (payload.severity === 'critical' || payload.severity === 'high') {
+                memSet(`blocked:ip:${payload.ip}`, '1', this.cacheConfig?.ttl || 3600);
+                if (payload.identity.user_id) {
+                    memSet(`blocked:user:${payload.identity.user_id}`, '1', this.cacheConfig?.ttl || 3600);
+                }
+                if (this.internalEngine) {
+                    this.internalEngine.blockIP(payload.ip, `webhook:${payload.threat_type}`, this.cacheConfig?.ttl || 3600);
+                }
+            }
+        }
+        this.auditTrail.record({
+            eventId: payload.event_id,
+            timestamp: Date.now(),
+            source: 'external',
+            tier: 0,
+            decision: 'webhook_response',
+            score: payload.composite_score,
+            severity: payload.severity,
+            latencyMs: 0,
+            ip: payload.ip,
+            path: payload.endpoint,
+            method: payload.method,
+            matchedRules: [payload.threat_type],
+            userId: payload.identity.user_id,
+            sessionId: payload.identity.session_id,
+        });
+        const specificHandlers = this.handlers.get(payload.severity) || [];
+        const wildcardHandlers = this.handlers.get('*') || [];
+        for (const handler of [...specificHandlers, ...wildcardHandlers]) {
+            try {
+                await handler(threatEvent);
+            }
+            catch (error) {
+                this.log('error', `Threat handler error: ${error instanceof Error ? error.message : 'Unknown'}`);
+            }
+        }
+        this.log('info', `Webhook processed: ${payload.event_id} [${payload.severity}] ${payload.threat_type}`);
+        return true;
+    }
+    blockIP(ip, ttlSeconds) {
+        const error = this.tierGate.validateBlockAction('block_ip');
+        if (error) {
+            this.log('warn', error);
+            return;
+        }
+        memSet(`blocked:ip:${ip}`, '1', ttlSeconds || this.cacheConfig?.ttl || 3600);
+        if (this.internalEngine) {
+            this.internalEngine.blockIP(ip, 'manual', ttlSeconds);
+        }
+        this.log('info', `IP blocked: ${ip}`);
+    }
+    unblockIP(ip) {
+        memoryCache.delete(`blocked:ip:${ip}`);
+        if (this.internalEngine) {
+            this.internalEngine.unblockIP(ip);
+        }
+        this.log('info', `IP unblocked: ${ip}`);
+    }
+    async trackEvent(event) {
+        const limitCheck = this.tierGate.checkEventLimit();
+        if (!limitCheck.allowed) {
+            return { success: false };
+        }
+        this.tierGate.recordEvent();
+        if (this.mode === 'internal' && this.internalEngine) {
+            const result = await this.internalEngine.evaluate({
+                ip: event.ip,
+                method: event.method || 'GET',
+                path: event.path || '/',
+                userAgent: event.userAgent,
+            });
+            if (result.decision !== 'allow' && this.tierGate.canBlock()) {
+                if (event.severity === 'HIGH' || event.severity === 'CRITICAL') {
+                    const severity = event.severity.toLowerCase();
+                    const handlers = [
+                        ...(this.handlers.get(severity) || []),
+                        ...(this.handlers.get('*') || []),
+                    ];
+                    const threatEvent = {
+                        event_id: result.eventId,
+                        threat_type: event.eventType,
+                        severity,
+                        confidence: result.score / 100,
+                        composite_score: result.score,
+                        ip: event.ip,
+                        identity: { user_id: null, session_id: null },
+                        endpoint: event.path || '/',
+                        method: event.method || 'GET',
+                        timestamp: new Date().toISOString(),
+                        meta: event.metadata || {},
+                    };
+                    for (const handler of handlers) {
+                        try {
+                            await Promise.resolve(handler(threatEvent));
+                        }
+                        catch (e) {
+                            this.log('error', `Threat handler error: ${e instanceof Error ? e.message : 'Unknown'}`);
+                        }
+                    }
+                }
+            }
+            return { success: true, eventId: result.eventId };
+        }
+        try {
+            const payload = {
+                eventType: event.eventType,
+                ip: event.ip,
+                severity: event.severity || 'MEDIUM',
+                method: event.method || 'GET',
+                requestPath: event.path,
+                userAgent: event.userAgent,
+                statusCode: event.statusCode,
+                metadata: {
+                    ...event.metadata,
+                    appId: this.appId,
+                    environment: this.environment,
+                    sdk_version: '4.0.0',
+                    mode: this.mode,
+                },
+                timestamp: new Date().toISOString(),
+            };
+            const response = await this.sendWithRetry(payload);
+            const data = response.data;
+            if (data.success) {
+                this.log('debug', `trackEvent(${event.eventType}) sent for ${event.ip}`);
+                if (event.severity === 'HIGH' || event.severity === 'CRITICAL') {
+                    const severity = event.severity.toLowerCase();
+                    const handlers = [
+                        ...(this.handlers.get(severity) || []),
+                        ...(this.handlers.get('*') || []),
+                    ];
+                    const threatEvent = {
+                        event_id: data.eventId || '',
+                        threat_type: event.eventType,
+                        severity,
+                        confidence: 0.9,
+                        composite_score: event.severity === 'CRITICAL' ? 95 : 75,
+                        ip: event.ip,
+                        identity: { user_id: null, session_id: null },
+                        endpoint: event.path || '/',
+                        method: event.method || 'GET',
+                        timestamp: new Date().toISOString(),
+                        meta: event.metadata || {},
+                    };
+                    for (const handler of handlers) {
+                        try {
+                            await Promise.resolve(handler(threatEvent));
+                        }
+                        catch (e) {
+                            this.log('error', `Threat handler error: ${e instanceof Error ? e.message : 'Unknown'}`);
+                        }
+                    }
+                }
+            }
+            return { success: !!data.success, eventId: data.eventId };
+        }
+        catch (error) {
+            this.log('error', `trackEvent() failed: ${error instanceof Error ? error.message : 'Unknown'}`);
+            return { success: false };
+        }
+    }
+    async registerTestIPs(ips) {
+        if (this.mode === 'internal') {
+            this.log('debug', 'registerTestIPs() is a no-op in internal mode');
+            return true;
+        }
+        try {
+            const response = await this.apiAxios.post('/test-ips', { ips });
+            const data = response.data;
+            this.log('info', `Registered ${ips.length} test IPs: ${ips.join(', ')}`);
+            return data.success;
+        }
+        catch (error) {
+            this.log('error', `registerTestIPs() failed: ${error instanceof Error ? error.message : 'Unknown'}`);
+            return false;
+        }
+    }
+    async testConnection() {
+        if (this.mode === 'internal') {
+            return this.internalEngine !== null;
+        }
+        try {
+            const response = await this.axios.post('', {
+                eventType: 'custom',
+                ip: '127.0.0.1',
+                appId: this.appId,
+                metadata: { test: true, sdk_version: '4.0.0', mode: this.mode },
+                timestamp: new Date().toISOString(),
+            });
+            return response.data.success === true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async sendWithRetry(payload, attempt = 1) {
+        try {
+            const response = await this.axios.post('', payload);
+            return response;
+        }
+        catch (error) {
+            const axiosError = error;
+            if (axiosError.response?.status && axiosError.response.status < 500) {
+                throw error;
+            }
+            if (attempt < this.retries) {
+                const backoff = Math.pow(2, attempt) * 1000;
+                await new Promise(resolve => setTimeout(resolve, backoff));
+                return this.sendWithRetry(payload, attempt + 1);
+            }
+            throw error;
+        }
+    }
+    log(level, message) {
+        if (!this.debug && level === 'debug')
+            return;
+        const prefix = '[DevFortress]';
+        switch (level) {
+            case 'error':
+                console.error(`${prefix} ${message}`);
+                break;
+            case 'warn':
+                console.warn(`${prefix} ${message}`);
+                break;
+            case 'debug':
+            case 'info':
+                if (this.debug) {
+                    console.log(`${prefix} ${message}`);
+                }
+                break;
+        }
+    }
+}
+exports.DevFortress = DevFortress;