linkedin-secret-sauce 0.3.12 → 0.3.14

package/dist/config.d.ts

@@ -1,3 +1,4 @@
+import type { SentryClient } from './utils/sentry';
 export interface LinkedInClientConfig {
     cosiallApiUrl: string;
     cosiallApiKey: string;
@@ -14,6 +15,10 @@ export interface LinkedInClientConfig {
     accountCooldownMs?: number;
     maxFailuresBeforeCooldown?: number;
     maxRequestHistory?: number;
+    eagerInitialization?: boolean;
+    onInitializationError?: (error: Error) => void;
+    sentryClient?: SentryClient;
+    fallbackWithoutProxyOnError?: boolean;
 }
-export declare function initializeLinkedInClient(config: LinkedInClientConfig): void;
+export declare function initializeLinkedInClient(config: LinkedInClientConfig): Promise<void>;
 export declare function getConfig(): LinkedInClientConfig;

package/dist/config.js

@@ -1,10 +1,43 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.initializeLinkedInClient = initializeLinkedInClient;
 exports.getConfig = getConfig;
 const errors_1 = require("./utils/errors");
 let globalConfig = null;
-function initializeLinkedInClient(config) {
+async function initializeLinkedInClient(config) {
     // Basic presence validation
     if (!config || !config.cosiallApiUrl || !config.cosiallApiKey) {
         throw new errors_1.LinkedInClientError('Missing required credentials', 'INVALID_CONFIG', 400);
@@ -19,9 +52,9 @@ function initializeLinkedInClient(config) {
     // Apply defaults (package-wide reasonable defaults)
     const withDefaults = {
         profileCacheTtl: 15 * 60 * 1000,
-        searchCacheTtl: 3 * 60 * 1000,
-        companyCacheTtl: 10 * 60 * 1000, // 600_000 ms
-        typeaheadCacheTtl: 60 * 60 * 1000, // 3_600_000 ms
+        searchCacheTtl: 15 * 60 * 1000, // Increased from 3m to 15m for better caching
+        companyCacheTtl: 10 * 60 * 1000,
+        typeaheadCacheTtl: 60 * 60 * 1000,
         cookieRefreshInterval: 15 * 60 * 1000,
         cookieFreshnessWindow: 24 * 60 * 60 * 1000,
         maxRetries: 2,
@@ -30,8 +63,15 @@ function initializeLinkedInClient(config) {
         maxFailuresBeforeCooldown: 3,
         logLevel: 'info',
         maxRequestHistory: 500,
+        eagerInitialization: true, // NEW: Default to eager initialization
+        fallbackWithoutProxyOnError: false, // NEW: Opt-in for proxy fallback
         ...config,
     };
+    // Configure Sentry if provided
+    if (withDefaults.sentryClient) {
+        const { setSentryClient } = await Promise.resolve().then(() => __importStar(require('./utils/sentry')));
+        setSentryClient(withDefaults.sentryClient);
+    }
     // Optionally mask API key from accidental JSON serialization
     try {
         Object.defineProperty(withDefaults, 'cosiallApiKey', {
@@ -48,6 +88,28 @@ function initializeLinkedInClient(config) {
     if (!globalConfig) {
         globalConfig = withDefaults;
     }
+    // NEW: Eager initialization if enabled
+    if (withDefaults.eagerInitialization && process.env.NODE_ENV !== 'test') {
+        try {
+            const { initializeCookiePool } = await Promise.resolve().then(() => __importStar(require('./cookie-pool')));
+            await initializeCookiePool();
+            const { log } = await Promise.resolve().then(() => __importStar(require('./utils/logger')));
+            log('info', 'client.initialized', { cookiePoolReady: true });
+        }
+        catch (err) {
+            const error = err;
+            const { log } = await Promise.resolve().then(() => __importStar(require('./utils/logger')));
+            log('error', 'client.initFailed', { message: error.message, stack: error.stack });
+            // Call optional error handler
+            if (withDefaults.onInitializationError) {
+                withDefaults.onInitializationError(error);
+            }
+            else {
+                // Default: throw to alert consumer immediately
+                throw new errors_1.LinkedInClientError('Failed to initialize LinkedIn client: ' + error.message, 'INITIALIZATION_FAILED', 0);
+            }
+        }
+    }
 }
 function getConfig() {
     if (!globalConfig) {

package/dist/cookie-pool.d.ts

@@ -1,5 +1,17 @@
 import type { LinkedInCookie } from './types';
-export declare function selectAccountForRequest(): Promise<{
+export declare function initializeCookiePool(): Promise<void>;
+export declare function getCookiePoolHealth(): {
+    initialized: boolean;
+    totalAccounts: number;
+    healthyAccounts: number;
+    expiredAccounts: number;
+    coolingDownAccounts: number;
+};
+export declare function forceRefreshCookies(): Promise<void>;
+export declare function getAccountForSession(sessionId: string): string | undefined;
+export declare function setAccountForSession(sessionId: string, accountId: string): void;
+export declare function clearSessionAccount(sessionId: string): void;
+export declare function selectAccountForRequest(sessionId?: string): Promise<{
     accountId: string;
     cookies: LinkedInCookie[];
 }>;

package/dist/cookie-pool.js

@@ -1,5 +1,44 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.initializeCookiePool = initializeCookiePool;
+exports.getCookiePoolHealth = getCookiePoolHealth;
+exports.forceRefreshCookies = forceRefreshCookies;
+exports.getAccountForSession = getAccountForSession;
+exports.setAccountForSession = setAccountForSession;
+exports.clearSessionAccount = clearSessionAccount;
 exports.selectAccountForRequest = selectAccountForRequest;
 exports.getAccountsSummary = getAccountsSummary;
 exports.reportAccountFailure = reportAccountFailure;
@@ -13,12 +52,16 @@ const config_1 = require("./config");
 const errors_1 = require("./utils/errors");
 const logger_1 = require("./utils/logger");
 const metrics_1 = require("./utils/metrics");
+// Session tracking for account stickiness (Phase 2.1)
+const sessionAccountMap = new Map();
 const poolState = {
     initialized: false,
     order: [],
     accounts: new Map(),
     rrIndex: 0,
     refreshTimer: null,
+    lastMassFailureCheck: 0,
+    consecutiveMassFailures: 0,
 };
 function nowMs() {
     return Date.now();
@@ -91,13 +134,125 @@ async function ensureInitialized() {
             catch (e) {
                 const err = e;
                 (0, logger_1.log)('warn', 'cookiePool.refreshFailed', { error: err?.message });
+                // Report to Sentry if configured
+                try {
+                    const { reportWarningToSentry } = await Promise.resolve().then(() => __importStar(require('./utils/sentry')));
+                    reportWarningToSentry('Cookie refresh failed', {
+                        error: err?.message,
+                        tags: { component: 'cookie-pool', severity: 'medium' },
+                    });
+                }
+                catch { }
             }
         }, interval);
     }
 }
-async function selectAccountForRequest() {
+// Export for eager initialization
+async function initializeCookiePool() {
+    await ensureInitialized();
+}
+// Export health check function
+function getCookiePoolHealth() {
+    if (!poolState.initialized) {
+        return {
+            initialized: false,
+            totalAccounts: 0,
+            healthyAccounts: 0,
+            expiredAccounts: 0,
+            coolingDownAccounts: 0,
+        };
+    }
+    const now = nowMs();
+    const accounts = Array.from(poolState.accounts.values());
+    return {
+        initialized: true,
+        totalAccounts: accounts.length,
+        healthyAccounts: accounts.filter(a => !isExpired(a) && a.failures === 0 && a.cooldownUntil <= now).length,
+        expiredAccounts: accounts.filter(a => isExpired(a)).length,
+        coolingDownAccounts: accounts.filter(a => a.cooldownUntil > now).length,
+    };
+}
+// Force refresh cookies (for mass failures)
+async function forceRefreshCookies() {
+    try {
+        (0, logger_1.log)('info', 'cookiePool.forceRefresh', {});
+        const refreshed = await (0, cosiall_client_1.fetchCookiesFromCosiall)();
+        // Rebuild state (same logic as periodic refresh)
+        const newMap = new Map();
+        const newOrder = [];
+        for (const acc of refreshed) {
+            newMap.set(acc.accountId, {
+                accountId: acc.accountId,
+                cookies: acc.cookies || [],
+                expiresAt: acc.expiresAt,
+                failures: 0, // Reset failures after forced refresh
+                cooldownUntil: 0, // Clear cooldown
+                lastUsedAt: poolState.accounts.get(acc.accountId)?.lastUsedAt,
+            });
+            newOrder.push(acc.accountId);
+        }
+        poolState.accounts = newMap;
+        poolState.order = newOrder;
+        poolState.consecutiveMassFailures = 0; // Reset counter
+        (0, logger_1.log)('info', 'cookiePool.forceRefreshed', { count: refreshed.length });
+    }
+    catch (e) {
+        const err = e;
+        (0, logger_1.log)('error', 'cookiePool.forceRefreshFailed', { error: err?.message });
+        throw e;
+    }
+}
+// Phase 2.1: Session management functions
+function getAccountForSession(sessionId) {
+    const session = sessionAccountMap.get(sessionId);
+    if (!session)
+        return undefined;
+    // Check if session expired (30 minutes)
+    if (Date.now() > session.expiresAt) {
+        sessionAccountMap.delete(sessionId);
+        return undefined;
+    }
+    // Check if account is still healthy
+    const entry = poolState.accounts.get(session.accountId);
+    if (!entry || isExpired(entry) || entry.failures >= getSettings().maxFailures) {
+        sessionAccountMap.delete(sessionId);
+        return undefined;
+    }
+    return session.accountId;
+}
+function setAccountForSession(sessionId, accountId) {
+    sessionAccountMap.set(sessionId, {
+        accountId,
+        lastUsedAt: Date.now(),
+        expiresAt: Date.now() + (30 * 60 * 1000), // 30 minutes
+    });
+    (0, logger_1.log)('debug', 'cookiePool.sessionSticky', { sessionId, accountId });
+}
+function clearSessionAccount(sessionId) {
+    sessionAccountMap.delete(sessionId);
+    (0, logger_1.log)('debug', 'cookiePool.sessionCleared', { sessionId });
+}
+// Modified selectAccountForRequest to support sessions (Phase 2.1)
+async function selectAccountForRequest(sessionId) {
     await ensureInitialized();
     const settings = getSettings();
+    // If sessionId provided, try to reuse same account
+    if (sessionId) {
+        const stickyAccountId = getAccountForSession(sessionId);
+        if (stickyAccountId) {
+            const entry = poolState.accounts.get(stickyAccountId);
+            if (entry && !isExpired(entry) && entry.failures < settings.maxFailures && entry.cooldownUntil <= nowMs()) {
+                (0, logger_1.log)('debug', 'cookiePool.sessionReuse', { sessionId, accountId: stickyAccountId });
+                entry.lastUsedAt = nowMs();
+                return { accountId: stickyAccountId, cookies: entry.cookies };
+            }
+            else {
+                // Account no longer healthy, clear session
+                clearSessionAccount(sessionId);
+            }
+        }
+    }
+    // Round-robin selection for new sessions or when sticky account unavailable
     const n = poolState.order.length;
     for (let i = 0; i < n; i++) {
         const idx = (poolState.rrIndex + i) % n;
@@ -113,9 +268,13 @@ async function selectAccountForRequest() {
             continue;
         // Select this account
         poolState.rrIndex = (idx + 1) % n;
-        (0, logger_1.log)('debug', 'cookiePool.select', { accountId: entry.accountId, rrIndex: poolState.rrIndex });
+        (0, logger_1.log)('debug', 'cookiePool.select', { accountId: entry.accountId, rrIndex: poolState.rrIndex, sessionId: sessionId || 'none' });
         (0, metrics_1.incrementMetric)('accountSelections');
         entry.lastUsedAt = nowMs();
+        // Set sticky session if sessionId provided
+        if (sessionId) {
+            setAccountForSession(sessionId, entry.accountId);
+        }
         return { accountId: entry.accountId, cookies: entry.cookies };
     }
     throw new errors_1.LinkedInClientError('No valid LinkedIn accounts', 'NO_VALID_ACCOUNTS', 503);

package/dist/cosiall-client.js

@@ -1,4 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fetchCookiesFromCosiall = fetchCookiesFromCosiall;
 const config_1 = require("./config");
@@ -21,10 +54,31 @@ async function fetchCookiesFromCosiall() {
     if (!response.ok) {
         (0, logger_1.log)('warn', 'cosiall.fetch.error', { status: response.status });
         (0, metrics_1.incrementMetric)('cosiallFailures');
+        // Report Cosiall downtime to Sentry (critical for operations)
+        try {
+            const { reportCriticalError } = await Promise.resolve().then(() => __importStar(require('./utils/sentry')));
+            reportCriticalError('Cosiall API failure - cookie service unavailable', {
+                status: response.status,
+                url,
+                tags: { component: 'cosiall-client', severity: 'critical' },
+            });
+        }
+        catch { }
         throw new errors_1.LinkedInClientError('Cosiall fetch failed', 'REQUEST_FAILED', response.status);
     }
     const data = await response.json();
     if (!Array.isArray(data)) {
+        (0, logger_1.log)('error', 'cosiall.fetch.invalidFormat', { dataType: typeof data });
+        // Report data format issues to Sentry
+        try {
+            const { reportCriticalError } = await Promise.resolve().then(() => __importStar(require('./utils/sentry')));
+            reportCriticalError('Cosiall API returned invalid format', {
+                expectedType: 'array',
+                actualType: typeof data,
+                tags: { component: 'cosiall-client', severity: 'critical' },
+            });
+        }
+        catch { }
         throw new errors_1.LinkedInClientError('Invalid Cosiall response format', 'REQUEST_FAILED', 500);
     }
     (0, logger_1.log)('info', 'cosiall.fetch.success', { count: data.length });

package/dist/http-client.d.ts

@@ -3,5 +3,6 @@ export interface LinkedInRequestOptions {
     method?: 'GET' | 'POST';
     body?: unknown;
     headers?: Record<string, string>;
+    sessionId?: string;
 }
 export declare function executeLinkedInRequest<T>(options: LinkedInRequestOptions, _operationName: string): Promise<T>;

package/dist/http-client.js

@@ -1,4 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.executeLinkedInRequest = executeLinkedInRequest;
 const config_1 = require("./config");
@@ -31,15 +64,42 @@ async function executeLinkedInRequest(options, _operationName) {
             proxySet = true;
             (0, logger_1.log)('info', 'proxy.set', { host: masked });
         }
-        // Try up to 3 different accounts on auth/rate failures
+        // Phase 1.4: Try ALL available accounts (not just 3)
+        const health = (0, cookie_pool_1.getCookiePoolHealth)();
+        const maxRotations = health.totalAccounts > 0 ? health.totalAccounts : 3;
         let lastError;
-        for (let rotation = 0; rotation < 3; rotation++) {
+        let accountsTriedCount = 0;
+        for (let rotation = 0; rotation < maxRotations; rotation++) {
             let selection;
             try {
-                selection = await (0, cookie_pool_1.selectAccountForRequest)();
+                selection = await (0, cookie_pool_1.selectAccountForRequest)(options.sessionId);
             }
             catch (err) {
-                if (process.env.NODE_ENV !== 'test')
+                const e = err;
+                // Phase 1.3: If NO_VALID_ACCOUNTS, try force refresh once
+                if (e?.code === 'NO_VALID_ACCOUNTS' && accountsTriedCount > 0) {
+                    (0, logger_1.log)('warn', 'http.noValidAccounts.forceRefresh', { accountsTriedCount });
+                    try {
+                        await (0, cookie_pool_1.forceRefreshCookies)();
+                        // Retry selection after refresh
+                        selection = await (0, cookie_pool_1.selectAccountForRequest)(options.sessionId);
+                    }
+                    catch (refreshErr) {
+                        const re = refreshErr;
+                        (0, logger_1.log)('error', 'http.forceRefreshFailed', { error: re?.message });
+                        // Report to Sentry
+                        try {
+                            const { reportCriticalError } = await Promise.resolve().then(() => __importStar(require('./utils/sentry')));
+                            reportCriticalError('All accounts exhausted, force refresh failed', {
+                                error: re?.message,
+                                accountsTriedCount,
+                                tags: { component: 'http-client', severity: 'critical' },
+                            });
+                        }
+                        catch { }
+                    }
+                }
+                if (!selection && process.env.NODE_ENV !== 'test')
                     throw err;
             }
             if (!selection || !selection.accountId) {
@@ -54,6 +114,7 @@ async function executeLinkedInRequest(options, _operationName) {
                 }
             }
             const { accountId, cookies } = selection;
+            accountsTriedCount++;
             const csrf = (0, cookie_pool_1.extractCsrfToken)(cookies);
             const cookieHeader = (0, cookie_pool_1.buildCookieHeader)(cookies);
             // Choose header profile based on Sales vs Voyager context
@@ -89,6 +150,18 @@ async function executeLinkedInRequest(options, _operationName) {
                         (0, request_history_1.recordRequest)({ operation: op, selector: options.url, status: 0, durationMs: Date.now() - started, accountId, errorMessage: String(e?.message || err) });
                     }
                     catch { }
+                    // Report network errors to Sentry
+                    try {
+                        const { reportWarningToSentry } = await Promise.resolve().then(() => __importStar(require('./utils/sentry')));
+                        reportWarningToSentry('Network error during LinkedIn request', {
+                            code,
+                            url: options.url,
+                            accountId,
+                            error: String(e?.message || err),
+                            tags: { component: 'http-client', severity: 'high' },
+                        });
+                    }
+                    catch { }
                     lastError = new errors_1.LinkedInClientError('LinkedIn fetch failed', 'REQUEST_FAILED', 0, accountId);
                     break; // rotate to next account
                 }
@@ -136,6 +209,30 @@ async function executeLinkedInRequest(options, _operationName) {
                     catch { }
                     break; // break inner loop to rotate account
                 }
+                // Phase 1.5: Proxy fallback on 502/503/504 if enabled
+                const isProxyError = status === 502 || status === 503 || status === 504;
+                const fallbackEnabled = config.fallbackWithoutProxyOnError ?? false;
+                if (isProxyError && fallbackEnabled && proxySet && attempt < perAccountAttempts - 1) {
+                    (0, logger_1.log)('warn', 'http.proxyFallback', { accountId, status, attempt: attempt + 1 });
+                    // Temporarily disable proxy for this retry
+                    delete process.env.HTTP_PROXY;
+                    delete process.env.HTTPS_PROXY;
+                    proxySet = false;
+                    // Report to Sentry
+                    try {
+                        const { reportWarningToSentry } = await Promise.resolve().then(() => __importStar(require('./utils/sentry')));
+                        reportWarningToSentry('Proxy error, retrying without proxy', {
+                            status,
+                            url: options.url,
+                            accountId,
+                            tags: { component: 'http-client', severity: 'medium' },
+                        });
+                    }
+                    catch { }
+                    (0, metrics_1.incrementMetric)('httpRetries');
+                    await sleep(delay);
+                    continue;
+                }
                 // Retryable 5xx on same account
                 if ((status >= 500 && status < 600) && attempt < perAccountAttempts - 1) {
                     (0, logger_1.log)('debug', 'http.retry', { accountId, status, attempt: attempt + 1, nextDelayMs: delay });
@@ -161,10 +258,23 @@ async function executeLinkedInRequest(options, _operationName) {
                 throw err;
             }
         }
-        // Exhausted rotations
+        // Exhausted all accounts
+        const errMsg = `All ${accountsTriedCount} LinkedIn accounts exhausted`;
+        (0, logger_1.log)('error', 'http.allAccountsExhausted', { accountsTriedCount, maxRotations });
+        // Report critical failure to Sentry
+        try {
+            const { reportCriticalError } = await Promise.resolve().then(() => __importStar(require('./utils/sentry')));
+            reportCriticalError(errMsg, {
+                accountsTriedCount,
+                maxRotations,
+                lastError: lastError?.message,
+                tags: { component: 'http-client', severity: 'critical' },
+            });
+        }
+        catch { }
         if (lastError)
             throw lastError;
-        throw new errors_1.LinkedInClientError('All LinkedIn accounts exhausted', 'ALL_ACCOUNTS_FAILED', 503);
+        throw new errors_1.LinkedInClientError(errMsg, 'ALL_ACCOUNTS_FAILED', 503);
     }
     finally {
         // Restore proxy env

package/dist/linkedin-api.d.ts

@@ -8,6 +8,7 @@ export declare function searchSalesLeads(keywords: string, options?: {
     decorationId?: string;
     filters?: SalesSearchFilters;
     rawQuery?: string;
+    sessionId?: string;
 }): Promise<SearchSalesResult | SalesLeadSearchResult[]>;
 export declare function getProfilesBatch(vanities: string[], concurrency?: number): Promise<(LinkedInProfile | null)[]>;
 export declare function resolveCompanyUniversalName(universalName: string): Promise<{

package/dist/linkedin-api.js

@@ -168,7 +168,8 @@ async function searchSalesLeads(keywords, options) {
     const count = Number.isFinite(options?.count) ? Number(options.count) : 25;
     const deco = options?.decorationId || 'com.linkedin.sales.deco.desktop.searchv2.LeadSearchResult-14';
     const sig = (0, search_encoder_1.buildFilterSignature)(options?.filters, options?.rawQuery);
-    const cacheKey = JSON.stringify({ k: String(keywords || '').toLowerCase(), start, count, deco, sig });
+    // Phase 2.1: Include sessionId in cache key for session-specific caching
+    const cacheKey = JSON.stringify({ k: String(keywords || '').toLowerCase(), start, count, deco, sig, sessionId: options?.sessionId || null });
     const cached = getCached(searchCache, cacheKey, cfg.searchCacheTtl);
     if (cached) {
         (0, metrics_1.incrementMetric)('searchCacheHits');
@@ -184,15 +185,16 @@ async function searchSalesLeads(keywords, options) {
     async function doRequest(decorationId) {
         const url = `${SALES_NAV_BASE}/salesApiLeadSearch?q=searchQuery&start=${start}&count=${count}&decorationId=${encodeURIComponent(decorationId)}&query=${queryStruct}`;
         try {
-            (0, logger_1.log)('info', 'api.start', { operation: 'searchSalesLeads', selector: { keywords, start, count, deco: decorationId } });
+            (0, logger_1.log)('info', 'api.start', { operation: 'searchSalesLeads', selector: { keywords, start, count, deco: decorationId, sessionId: options?.sessionId } });
         }
         catch { }
         const out = await (0, http_client_1.executeLinkedInRequest)({
             url,
             headers: { Referer: 'https://www.linkedin.com/sales/search/people' },
+            sessionId: options?.sessionId, // Phase 2.1: Pass sessionId for account stickiness
         }, 'searchSalesLeads');
         try {
-            (0, logger_1.log)('info', 'api.ok', { operation: 'searchSalesLeads', selector: { keywords, start, count, deco: decorationId } });
+            (0, logger_1.log)('info', 'api.ok', { operation: 'searchSalesLeads', selector: { keywords, start, count, deco: decorationId, sessionId: options?.sessionId } });
         }
         catch { }
         return out;

package/dist/parsers/profile-parser.js

@@ -8,14 +8,29 @@ function parseFullProfile(rawResponse, vanity) {
     const identity = included.find((it) => String(it?.$type || '').includes('identity.profile.Profile')) || {};
     const profile = {
         vanity,
+        publicIdentifier: identity.publicIdentifier,
         firstName: identity.firstName,
         lastName: identity.lastName,
         headline: identity.headline,
         summary: identity.summary,
         locationText: identity.locationName || identity.geoLocationName,
+        objectUrn: identity.objectUrn,
+        premium: identity.premium,
+        influencer: identity.influencer,
+        industryUrn: identity.industryUrn,
+        versionTag: identity.versionTag,
         positions: [],
         educations: [],
     };
+    // Extract geoLocation and countryCode
+    const geoLocation = identity.geoLocation;
+    if (geoLocation?.geoUrn) {
+        profile.geoLocationUrn = geoLocation.geoUrn;
+    }
+    const location = identity.location;
+    if (location?.countryCode) {
+        profile.countryCode = location.countryCode;
+    }
     // Positions
     function extractCompanyIdFromUrn(urn) {
         if (!urn)
@@ -95,6 +110,21 @@ function parseFullProfile(rawResponse, vanity) {
         };
         profile.educations.push(edu);
     }
+    // Skills
+    const skills = [];
+    for (const item of included) {
+        const rec = item;
+        const urn = rec?.entityUrn || '';
+        if (!urn.includes('fsd_skill'))
+            continue;
+        const skill = {
+            name: rec?.name,
+            entityUrn: urn,
+        };
+        skills.push(skill);
+    }
+    if (skills.length > 0)
+        profile.skills = skills;
     // Avatar (via helper)
     const avatarItem = included.find((it) => it?.vectorImage && JSON.stringify(it).includes('vectorImage'));
     const vector = avatarItem?.vectorImage;

package/dist/types.d.ts

@@ -35,8 +35,13 @@ export interface ProfileEducation {
     endYear?: number;
     endMonth?: number;
 }
+export interface ProfileSkill {
+    name?: string;
+    entityUrn?: string;
+}
 export interface LinkedInProfile {
     vanity: string;
+    publicIdentifier?: string;
     firstName?: string;
     lastName?: string;
     headline?: string;
@@ -45,8 +50,16 @@ export interface LinkedInProfile {
     avatarUrl?: string;
     coverUrl?: string;
     fsdProfileUrn?: string;
+    objectUrn?: string;
+    premium?: boolean;
+    influencer?: boolean;
+    industryUrn?: string;
+    geoLocationUrn?: string;
+    countryCode?: string;
+    versionTag?: string;
     positions: ProfilePosition[];
     educations: ProfileEducation[];
+    skills?: ProfileSkill[];
 }
 export interface LinkedInTenure {
     numYears?: number;

package/dist/utils/sentry.d.ts

@@ -0,0 +1,8 @@
+export interface SentryClient {
+    captureException(error: Error, context?: Record<string, unknown>): void;
+    captureMessage(message: string, level: 'error' | 'warning' | 'info', context?: Record<string, unknown>): void;
+}
+export declare function setSentryClient(client: SentryClient): void;
+export declare function reportToSentry(error: Error | string, context?: Record<string, unknown>): void;
+export declare function reportWarningToSentry(message: string, context?: Record<string, unknown>): void;
+export declare function reportCriticalError(message: string, context?: Record<string, unknown>): void;

package/dist/utils/sentry.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setSentryClient = setSentryClient;
+exports.reportToSentry = reportToSentry;
+exports.reportWarningToSentry = reportWarningToSentry;
+exports.reportCriticalError = reportCriticalError;
+const logger_1 = require("./logger");
+let sentryClient = null;
+function setSentryClient(client) {
+    sentryClient = client;
+    (0, logger_1.log)('info', 'sentry.configured', {});
+}
+function reportToSentry(error, context) {
+    if (!sentryClient)
+        return;
+    try {
+        if (typeof error === 'string') {
+            sentryClient.captureMessage(error, 'error', context);
+        }
+        else {
+            sentryClient.captureException(error, context);
+        }
+    }
+    catch (err) {
+        (0, logger_1.log)('error', 'sentry.reportFailed', { error: err.message });
+    }
+}
+function reportWarningToSentry(message, context) {
+    if (!sentryClient)
+        return;
+    try {
+        sentryClient.captureMessage(message, 'warning', context);
+    }
+    catch (err) {
+        (0, logger_1.log)('error', 'sentry.warningFailed', { error: err.message });
+    }
+}
+function reportCriticalError(message, context) {
+    if (!sentryClient)
+        return;
+    try {
+        sentryClient.captureMessage(message, 'error', context);
+    }
+    catch (err) {
+        (0, logger_1.log)('error', 'sentry.criticalFailed', { error: err.message });
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linkedin-secret-sauce",
-  "version": "0.3.12",
+  "version": "0.3.14",
   "description": "Private LinkedIn Sales Navigator client with automatic cookie management",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",